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

 

1. Context & Vision

 

Hellsword is a dark fantasy hybrid game that seamlessly blends a collectible card game (CCG) with a voxel-based sandbox, set in a grimdark universe where magic and technology clash in a fractured, decaying realm. Players engage in strategic deck-building, real-time guild warfare, and immersive sandbox exploration, crafting their own commander cards and battling across voxel worlds they can shape and defend. The game emphasizes player agency through personalized commanders, a circular faction system, and dynamic interactions between card battles and sandbox environments. Integrated into a ConcreteCMS v9 website, Hellsword leverages the CMS for user authentication, content management, and community features, creating a unified platform that enhances both gameplay and social engagement.

 

Core Vision Elements:

 

• Strategic Deck-Building: Players construct decks (up to 15 cards, unlimited copies, multiple decks supported) for tactical battles influenced by a rock-paper-scissors faction system.

• Commander Cards: Craftable, customizable cards reflecting the player’s likeness, enhanced with mission-earned commands for unique tactical depth.

• Voxel Sandbox Worlds: Players explore, build, and spawn events in procedurally generated voxel realms, inviting others to collaborate or compete.

• Guild-Driven Conquest: Guilds vie for territorial control, blending card battles with sandbox development for large-scale warfare.

• Notification & Social Ecosystem: A robust, customizable notification system (in-game, email, SMS, social sharing) paired with real-time social features fosters community and engagement.

 

2. ConcreteCMS v9 Integration

 

2.1. Core CMS Benefits

 

• User Management:

  • Leverage ConcreteCMS’s built-in systems for user registration, login, and role-based permissions (e.g., player, guild leader, admin).

  • Extend user profiles with game-specific data (deck lists, commander details, voxel world ownership).

   

• Custom Blocks & Packages:

  • Blocks: Create interactive UI components for deck management, guild dashboards, event notifications, and voxel world previews.

  • Packages: Develop modular packages for game logic (e.g., card crafting, faction multipliers, event spawning) and data handling (e.g., voxel chunk storage, player inventories).

   

• Content & Community:

  • Manage static content (lore pages, FAQs, patch notes) and dynamic community features (forums, leaderboards) within the CMS.

  • Integrate social sharing buttons (e.g., Twitter, Discord) for achievements and event invites.

   

2.2. Data & API Integration

 

• Database Utilization:

  • Store player profiles, card definitions, deck configurations (up to 15 cards), guild hierarchies, voxel world metadata, and notification preferences in ConcreteCMS’s MySQL or PostgreSQL database.

  • Use custom entities for complex data structures (e.g., voxel chunks linked to player-owned tiles).

   

• API Development:

  • RESTful Endpoints: Expose endpoints for real-time interactions (e.g., /api/decks/update, /api/events/spawn, /api/notifications/settings).

  • GraphQL (Optional): Enable flexible querying for nested data (e.g., retrieving a player’s deck and commander stats in one call).

  • Ensure APIs support ConcreteCMS’s authentication tokens for secure access.

   

3. Game Overview

 

3.1. Genre & Core Concept

 

• Dark Fantasy CCG + Voxel Sandbox: A tactical card game where players build decks and engage in battles, paired with a voxel sandbox for exploration, construction, and event hosting, all set in a grimdark aesthetic inspired by Warhammer 40k and Dark Souls.

3.2. New Mechanics

 

• Deck Building: Up to 15 cards per deck, with unlimited copies and support for multiple decks tailored to PvP, guild wars, or event challenges.

• Commander Cards: Unique, craftable cards personalized with voxel-crafted visuals and enhanced by mission-earned commands (e.g., buffs, special abilities).

• Faction Circle Logic: A circular system (e.g., Necrotech > Abyssal > Draconic > Eldritch > Necrotech) where factions have strategic strengths and weaknesses, implemented via damage multipliers.

• Voxel Sandbox Integration: Resources gathered in voxel worlds can be converted into cards, and cards can be deployed as structures or units in the sandbox.

• Player-Spawned Events: Players initiate events (public or invite-only) in their voxel worlds, summoning monsters for cooperative or competitive play.

3.3. Key Features

 

• 2D Management Interface: A sleek, illustrated dashboard for deck-building, resource tracking, commander customization, and guild coordination.

• 3D Voxel Sandbox: Procedurally generated realms where players gather resources, build defenses, and host events.

• Guild Territorial Conquest: Guilds compete for voxel tiles, using card battles and sandbox strategies to claim and fortify territory.

• Notification System: Comprehensive alerts (in-game, email, SMS, social media) with granular control over types, delivery methods, and frequency.

 

4. Game Mechanics

 

4.1. Deck Building & Card System

 

• Deck Structure:

  • Limit: 15 cards per deck, no cap on duplicate cards.

  • Multiple Decks: Players can maintain several decks, switching between them for different contexts (e.g., PvP, guild defense, event farming).

  • Synergy Mechanics: Bonuses for faction-aligned decks or specific card combos (e.g., pairing a Necrotech unit with a structure unlocks a regeneration effect).

   

• Card Types:

  • Unit Cards: Summonable entities (e.g., undead soldiers, draconic wyrms) with attack, health, and abilities (e.g., poison, flight).

  • Spell Cards: One-time effects (e.g., fireball, heal, faction-specific curses).

  • Structure Cards: Deployable assets (e.g., turrets, walls) usable in battles or voxel worlds.

  • Resource Cards: Generate mana or materials to play other cards.

  • Commander Cards: Player-crafted cards with customizable stats, visuals, and mission-earned commands.

   

• Faction Circle Logic:

  • Factions: Necrotech (cyber-undead), Abyssal (demonic chaos), Draconic (fire dragons), Eldritch (cosmic horrors).

  • Multipliers: 1.5x damage against "strong" faction, 0.75x against "weak" faction.

  • Mixed Decks: Gain versatility but may lose faction-specific bonuses.

   

4.2. Commander Cards

 

• Customization:

  • Visuals: Use voxel resources to craft appearances (e.g., armor, faction-themed skins).

  • Stats: Allocate points to health, mana, or ability strength.

  • Abilities: Equip commands from a pool (e.g., "Summon Minions," "Faction Rally") earned via missions.

   

• Progression:

  • Level up through combat or missions, unlocking new slots for commands or stat boosts.

  • Prestige system for veteran commanders with cosmetic rewards.

   

4.3. Voxel Sandbox Integration

 

• World Generation:

  • Procedurally generated biomes (e.g., corrupted forests, volcanic plains) with expandable borders via missions or conquest.

   

• Resource Gathering & Crafting:

  • Resources: Mine metals, crystals, or corrupted wood; harvest from defeated mobs.

  • Crafting: Use stations (e.g., forges, altars) to create items, cards, or commander upgrades.

   

• Building Mechanics:

  • Voxel Tools: Place individual blocks or use blueprints for complex structures (e.g., guild halls, traps).

  • Conversion: Transform voxel items into cards (e.g., a steel wall becomes a structure card) via Converter Stations, with cooldowns to prevent abuse.

   

• Event Spawning:

  • Types: Small skirmishes (e.g., "Ghoul Infestation") to epic battles (e.g., "Abyssal Titan").

  • Mechanics: Consume resources at a Summoning Altar to spawn events, set as public or invite-only.

   

4.4. Guild & Territorial Conquest

 

• Tile Control:

  • Guilds siege voxel tiles, resolving conflicts via card battles or sandbox sabotage (e.g., destroying defenses).

  • Controlled tiles generate resources and can be fortified with structures.

   

• Guild Features:

  • Hierarchy: Leaders, officers, members with role-based permissions.

  • Treasury: Shared resources for guild projects (e.g., crafting stations).

  • Diplomacy: Alliances or trade pacts with other guilds.

   

4.5. Event & Notification System

 

• Player-Spawned Events:

  • Setup: Players configure event difficulty, monster type, and invite settings.

  • Participation: Real-time multiplayer sessions where allies join to defeat spawned threats.

   

• Notification Features:

  • Types: Battle invites, event starts, guild updates, resource thresholds.

  • Delivery: In-game pop-ups, email (via SendGrid), SMS (via Twilio), social media posts.

  • Control: Settings page to toggle notification types, set quiet hours, and select channels.

   

5. Technical Architecture

 

5.1. Frontend Technologies

 

• 2D Interface:

  • Framework: Vue.js 3 with Pinia for reactive state management.

  • Styling: Tailwind CSS with Vuetify for dark-themed components.

  • Build Tool: Vite for fast iteration.

   

• 3D Voxel Sandbox:

  • Rendering: Three.js with chunk-based loading for performance.

  • Physics: Cannon.js for terrain interactions (e.g., collapsing structures).

   

• Real-Time Communication:

  • Socket.IO: Handles chat, battle sync, and event updates, integrated with ConcreteCMS assets.

   

5.2. Backend & Server Frameworks

 

• ConcreteCMS v9 Core:

  • Authentication: Use CMS login for seamless player access.

  • Packages: Custom logic for deck management, voxel persistence, and guild operations.

   

• Database:

  • Schema: Tables for players, cards, decks (15-card limit), voxel chunks, guilds, events.

  • Optimization: Redis caching for live data (e.g., event status, player sessions).

   

• API Services:

  • RESTful: Endpoints for card operations, event triggers, and notification prefs.

  • Microservices (Optional): Node.js for high-concurrency real-time features.

   

5.3. Notification Integrations

 

• External Services: SendGrid for email, Twilio for SMS, OAuth for social media.

• Real-Time: Socket.IO pushes in-game alerts instantly.

 

6. Detailed System Breakdown

 

6.1. Card & Deck Data Models

 

• Card Model: {id, name, faction, type, attack, health, mana_cost, abilities, commander_data}

• Deck Model: {user_id, deck_id, card_ids (array, max 15)}

• Commander Model: {player_id, visual_data, stats, equipped_commands}

6.2. Battle & Game Flow

 

• Initialization: Select a deck, match with opponent (AI, PvP, guild).

• Turn Phases: Draw → Resource Gain → Play Cards → Combat (faction multipliers applied) → End.

• Rewards: XP, resources, or rare cards based on victory margin.

6.3. Voxel Sandbox & Event Mechanics

 

• Storage: Chunks stored as serialized data in ConcreteCMS database.

• Events: {event_id, type, difficulty, invite_list, start_time, status} with real-time synchronization.

6.4. Social & Notification System

 

• Chat: Real-time guild/global channels via Socket.IO.

• Notifications: API-driven settings (/api/notifications/update) for user preferences.

 

7. Performance, Scalability, & Security

 

• Scalability: NGINX load balancing, database sharding for high player counts.

• Performance: Lazy-loaded voxel chunks, Redis caching for frequent queries.

• Security: ConcreteCMS CSRF protection, server-side validation for all actions, HTTPS for data transfer.

 

8. Development Roadmap

 

1. Foundation: Set up ConcreteCMS v9, user auth, and basic site structure.

2. Card Game Core: Build deck system (15-card limit), commander crafting, faction logic.

3. Voxel Sandbox: Integrate Three.js, add resource gathering and event spawning.

4. Guild & Battles: Implement territorial conquest, real-time battle flow.

5. Social & Notifications: Add chat, granular alerts, external integrations.

6. Launch Prep: Optimize performance, test security, release with ongoing updates.

 

9. Conclusion & Next Steps

 

This prompt outlines a robust framework for Hellsword, blending tactical card gameplay with voxel sandbox creativity, all powered by ConcreteCMS v9. To proceed, use this as a foundation for:

 

• A detailed design document expanding on mechanics (e.g., commander crafting workflows).

• A technical blueprint defining API endpoints and database schemas.

• Iterative prototyping, starting with core deck-building and voxel rendering.

Additional Considerations:

 

• Define specific event reward structures and faction lore in follow-up docs.

• Prototype real-time features early to ensure scalability.

• Plan expansions (new factions, seasonal events) for long-term engagement.