Hellsword: Expanded Design & Technical Prompt (ConcreteCMS v9 Integrated)

Context & Vision:
Hellsword is a dark fantasy collectible card game combined with a voxel sandbox. The game features strategic deck-building, real-time guild warfare, and immersive sandbox exploration. Players build decks (up to 15 cards per deck, with no limit on copies and the option to maintain multiple decks) and engage in battles using a circular faction system. The game also offers unique commander cards—craftable to reflect a player's likeness and supplemented with commands earned from missions—to provide a personal touch and additional tactical depth.

Additionally, players can spawn events in their voxel worlds, issuing public or invite-only invitations for other players to join and help defeat event-specific monsters. The game server supports comprehensive notification systems—including in-game social functions, social sharing, as well as email and SMS alerts—with granular controls so players can choose exactly which notifications they want to receive.

All of this will be integrated into a ConcreteCMS v9 website, which will serve as the central PHP framework for user authentication, content management, and additional site features.

1. ConcreteCMS v9 Integration

1. Core CMS Benefits:

   • User Management: Leverage ConcreteCMS’s built-in registration, login, and role-based permissions for seamless account handling.

   • Custom Blocks & Packages: Create custom blocks for game interfaces (deck management, guild pages, event notifications) and custom packages for data handling (cards, commander details, voxel world data).

   • Content & Community: Manage static pages (lore, FAQs, event announcements), forums, and social media integration within one unified system.

2. Data & API Integration:

   • Use ConcreteCMS’s database to store player profiles, card definitions, deck data, guild info, voxel chunk metadata, and notification preferences.

   • Implement custom RESTful or GraphQL endpoints for real-time interactions, card operations, event management, and notification control.

 

2. Game Overview

1. Genre & Core Concept:

   • Dark Fantasy CCG + Voxel Sandbox: Players create decks, engage in tactical card battles, and explore/build voxel realms.

   • New Mechanics:

     • Deck Building: Decks now have up to 15 cards. Players can maintain multiple decks for varied strategies.

     • Commander Cards: Special craftable cards that players can customize to mirror their likeness, enhanced by command abilities earned through missions.

     • Faction Circle Logic: A circular (rock-paper-scissors) system where each faction (e.g., Necrotech, Abyssal, Draconic, Eldritch) has strategic strengths and weaknesses.

2. Key Features:

   • 2D Management Interface: For deck building (15 cards max per deck), resource tracking, mission and commander management, and guild/social interactions.

   • 3D Voxel Sandbox: Each tile represents a voxel “realm” where players gather resources, craft items, and build defenses. Items can be converted to cards and vice versa.

   • Guild Territorial Conquest: Guilds vie for control of voxel tiles, using both card battles and sandbox building for defense.

   • Player-Spawned Events: Players can initiate events on their worlds, sending out public or invite-only invites. Other players join to help fight off event monsters.

   • Notification System: In-game notifications through built-in social media functions, plus support for social sharing, email, and SMS alerts—with granular control over notification types.

 

3. Game Mechanics

3.1. Deck Building & Card System

• Deck Structure:

  • Deck Limit: Up to 15 cards per deck.

  • Multiple Decks: Players may create and switch between several decks for different strategies (PvP, guild battles, event participation).

  • Unlimited Copies: No restriction on how many copies of a specific card a player can include.

• Card Types:

  • Unit Cards: Summon creatures or soldiers.

  • Spell Cards: One-time effects (damage, healing, buffs, or utility actions).

  • Structure Cards: Represent turrets, barriers, or traps that can be deployed on the battlefield or in the voxel sandbox.

  • Resource Cards: Provide energy, mana, or materials required to play other cards.

  • Commander Cards: Craftable and customizable cards that represent the player’s character. They grant unique command abilities and influence strategic gameplay; these can also incorporate commands earned from missions.

• Circular Faction Logic:

  • Each card includes a “faction tag”.

  • Faction dynamics work in a circular (rock-paper-scissors) system (e.g., Necrotech > Abyssal > Draconic > Necrotech).

  • Implement faction multipliers (server-side or within a microservice) to influence damage and synergy.

3.2. Voxel Sandbox Integration

• Resource Gathering & Crafting:

  • Players mine and gather blocks (metals, crystals, corrupted wood, etc.), which can be crafted into items or converted into cards.

  • Commander Crafting: Specific crafting mechanics allow players to create their own commander cards, with customization options reflecting personal traits or mission achievements.

• Voxel Building:

  • Block Types: Dirt, cobble, corrupted stone, lava pools, etc.

  • Interactive Elements: Electronics, traps, defensive structures, and crafting stations.

  • Block-to-Card Conversion: Special Converter Stations (located in guild halls or specific zones) allow transformation of voxel items into cards. Anti-cheat mechanisms (resource caps, cooldowns) are implemented to prevent exploitation.

3.3. Event & Notification System

• Player-Spawned Events:

  • Players can initiate events in their voxel worlds—ranging from small skirmishes to large-scale battles against event-specific monsters.

  • Event Invites: Events may be public or invite-only, with a system for players to send invites (via in-game notifications, email, or SMS) and track RSVPs.

• Notification Features:

  • In-Game: Use real-time notifications through built-in social media modules for immediate alerts (battle invites, event starts, guild messages).

  • Social Sharing: Integration with external platforms (Facebook, Twitter, Discord) to share achievements and event invitations.

  • Email & SMS: Support through services like SendGrid (email) and Twilio (SMS) for critical notifications.

  • Granular Control: Players can customize which notifications they receive and how (e.g., toggle types of alerts, set quiet hours, select delivery channels).

 

4. Technical Architecture

4.1. Frontend Technologies

1. 2D Interface & UI:

   • Framework: Vue.js 3 or React 18 for the main application (deck management, event creation, notifications).

   • Styling: Tailwind CSS or Bootstrap, potentially with Vuetify (Vue) or MUI (React) for component libraries.

   • Build Tools: Vite for fast development or Webpack for a more robust solution.

   • State Management: Pinia (Vue) or Redux Toolkit (React) to handle decks, notifications, and event data.

2. 3D Voxel Rendering:

   • Rendering Library: Three.js for WebGL-based 3D rendering of voxel worlds.

   • Voxel Engine: Use voxel.js or custom chunk-based rendering within Three.js.

   • Physics: Cannon.js or Ammo.js for realistic physics and collision detection.

3. Real-Time Communication:

   • Options:

     • Socket.IO (Node.js): For robust, real-time chat, in-battle updates, event notifications.

     • Ratchet (PHP): If preferring a PHP-based solution.

   • Integration with ConcreteCMS assets for seamless frontend and backend interactions.

4.2. Backend & Server Frameworks

1. ConcreteCMS v9 as the Core PHP Framework:

   • Custom Packages & Blocks: For game logic (cards, decks, guilds, events) and user management.

   • User Authentication: Leverage ConcreteCMS’s built-in user registration and login services.

2. Database:

   • MySQL/PostgreSQL: Store user profiles, card data, deck configurations (15 cards max per deck), voxel chunk metadata, guild and event details, and notification preferences.

   • Redis (Optional): For caching session data, quick lookups, and live event status.

3. Real-Time & API Services:

   • RESTful/GraphQL Endpoints: Expose endpoints for card crafting, event creation, deck updates, and notification preferences.

   • Node.js Microservice (Optional): For real-time communications using Socket.IO if high concurrency is expected.

4. Notification Services:

   • Email: Integration with SendGrid.

   • SMS: Integration with Twilio.

   • Granular Notification Controls: User-specific settings stored in the database allowing fine-tuned control over what notifications are received and via which channel.

 

5. Detailed System Breakdown

5.1. Card & Deck Data Models

• Card Model:

  • Fields: id, name, faction, type (unit/spell/structure/resource/commander), power, rarity, faction_multiplier_map, and any commander customization data.

• Deck Model:

  • Fields: user_id, deck_id, a list of up to 15 card IDs.

  • Support multiple decks per player.

• Commander Cards:

  • Special attributes for personalization and mission command bonuses.

5.2. Battle & Game Flow

• Battle Initialization:

  • Player selects one of their decks (up to 15 cards).

  • Opponent selection (AI, PvP, guild event) integrates circular faction logic in combat resolution.

• Turn Structure:

  • Draw phase, resource gain, action phase (summon, cast, deploy), and combat resolution (factoring faction multipliers).

• Outcome:

  • Rewards (XP, resources, new cards/commander upgrades) and penalties (resource loss, guild setbacks).

• Real-Time Communication:

  • Updates via Socket.IO (or Ratchet) for synchronized gameplay and notifications.

5.3. Voxel Sandbox & Event Mechanics

• Voxel World Storage:

  • Store each tile as chunks in a dedicated database table (or entity) within ConcreteCMS.

  • Custom Concrete entities for chunk and block data.

• Event Spawning:

  • Players can trigger events on their voxel realms.

  • Event Data: Include event type, monster details, invite type (public/invite-only), and start time.

  • Invitations: Support in-game notifications and integration with external channels (email/SMS/social).

• Event Resolution:

  • Real-time multiplayer events where players team up to defeat a spawned monster.

  • Use real-time services for battle synchronization and progress updates.

5.4. Social & Notification System

• In-Game Social Features:

  • Real-time chat, forums, and guild communication via ConcreteCMS and Socket.IO/Ratchet.

• Notification Management:

  • Users set preferences (via a dedicated settings page) for in-game alerts, email, SMS, and social sharing.

  • API endpoints handle subscription/unsubscription to various notification types.

• External Integration:

  • Social media APIs (Facebook, Twitter, Discord) to share achievements and event details.

 

6. Performance, Scalability, & Security

1. Scalability:

   • Use load balancing (NGINX/HAProxy) and sharding for high concurrency.

   • Optimize voxel rendering with chunk-based loading and lazy texture loading.

2. Security:

   • Rely on ConcreteCMS’s built-in security measures (CSRF, role-based permissions).

   • Implement server-side validation for resource changes, card crafting, and event creation.

3. Caching:

   • Utilize Redis for caching user sessions, live event data, and frequently accessed card/deck info.

 

7. Development Roadmap (ConcreteCMS Focused)

1. Phase 1: Foundation & CMS Setup

   • Install and configure ConcreteCMS v9.

   • Implement basic site pages (Home, FAQ, Lore) and user registration using Concrete’s services.

2. Phase 2: Core Card Game & Deck Building

   • Develop the card system (including commander cards) with a 15-card deck limit and multi-deck support.

   • Create custom packages/blocks for deck management integrated into ConcreteCMS.

3. Phase 3: Voxel Sandbox Prototype & Event System

   • Integrate Three.js-based voxel rendering in a custom block.

   • Implement resource gathering, block-to-card conversion, and the event spawning mechanism.

4. Phase 4: Guild, Battle, & Real-Time Features

   • Develop guild mechanics, territorial conquest, and real-time battle flow with circular faction logic.

   • Integrate Socket.IO (or Ratchet) for real-time updates and notifications.

5. Phase 5: Social, Notification, & External Integrations

   • Build comprehensive notification controls (in-game, email, SMS, social sharing).

   • Extend community features (forums, voice/video via WebRTC, event invites) within the ConcreteCMS framework.

6. Phase 6: Optimization, Testing, & Release

   • Performance optimization (chunk-based rendering, caching, DB tuning).

   • Security audits and load testing.

   • Launch and continuous feature updates (expansions, new factions, event types).

 

8. Conclusion

This revised prompt for Hellsword now integrates the power of ConcreteCMS v9 with a robust front-end stack (Vue.js/React, Three.js, Socket.IO) to deliver a deep and scalable game experience. With enhanced mechanics—craftable commander cards, expanded decks (15 cards max), multi-deck support, player-spawned events, and granular notification management—Hellsword stands to offer a unique blend of tactical card battles, immersive voxel sandbox exploration, and dynamic social interactions.

How to Use This Prompt:

1. Copy & Paste the entire prompt into your AI tool (e.g., ChatGPT or GPT-4).

2. Request a detailed design or technical document covering each section.

3. Iterate by asking follow-up questions (e.g., “Detail how the commander card crafting system should work,” or “Expand on the granular notification settings API design.”).

4. Refine and incorporate feedback to create a full development roadmap and technical blueprint for Hellsword.

 

Additional Considerations:

• Ensure clarity on how commander cards interact with the rest of the card system and how mission commands integrate with them.

• Hash out the details of the event system (trigger conditions, invite management, and reward structures) in subsequent documents.

• Define API endpoints and data models in more detail during the design phase.

• Plan for future scalability by prototyping real-time features early and stress testing them.

This comprehensive prompt will guide your team—and any AI tools you use—to produce an in-depth, actionable design document that covers every critical aspect of Hellsword's gameplay and technical architecture.