Implement hexagonal map and isometric game UI

This commit is contained in:
sokol
2026-02-21 17:23:09 +03:00
parent afd48af0b8
commit 25385de4d4
11 changed files with 2146 additions and 0 deletions

122
QWEN.md Normal file
View File

@@ -0,0 +1,122 @@
# Project Context: hexo
## Project Overview
**hexo** is an educational game project - a clone of [DiceWars](https://www.gamedesign.jp/games/dicewars/). The project is in early development stage.
### Game Concept
A strategy dice game played on a hexagonal grid where players command armies of dice and battle to conquer territories.
### Core Game Mechanics
#### Map System
- Generatable hexagonal grid map (20x20 cells)
- Each cell can be either playable or blocked/impassable
- Each field can hold up to 8 dice
- Each player-owned field provides +1 supply unit to the player
#### Dice System
- Standard 6-sided dice
- Unit strength calculation formula:
```
F = (cnt-1) * full_dice + current_dice
```
Where:
- `cnt` = number of dice on the field
- `full_dice` = maximum die value (6)
- `current_dice` = top die current value (1-6, calculated during gameplay)
#### Game Rules
1. **Setup**: Multiple dice are placed on the map for each player at the start
2. **Movement Conditions**: A user can move a unit if its strength > 1
- When moving: strength-1 transfers to target cell, strength 1 remains on source cell
3. **Combat**: When attacking a cell with enemy dice, both players roll:
- **Attacker**: `F_attack = rnd(F-1)` (random value less than original strength minus 1)
- **Defender**: `F_defence = current_strength` (full field strength)
- **Victory**: If `F_attack > F_defence`, attacker wins; otherwise defender repels the attack
- **On Victory**: Attacker leaves strength 1 on source cell, transfers `F_attack-1` to target
- **On Defeat**: Defender retains `F_defence - F_attack` (minimum 1)
4. **Supply Phase**: After all players have moved, each receives supply:
- `S = sum(Cell)` where Cell = supply value from each player-owned cell
- Maximum per cell: `8 * full_dice` (48 dice points)
- If all cells already have maximum strength, no supply is added
## Directory Structure
```
hexo/
├── README.md # Game specifications and rules (in Russian)
├── QWEN.md # This file - project context for AI assistance
├── .gitignore # Git ignore rules (Python-focused template)
├── jsdom-pkg/ # Local copy of jsdom library
│ └── package/
│ └── lib/
│ ├── api.js # Main jsdom API entry point
│ └── jsdom/ # jsdom core implementation
│ ├── browser/ # Browser emulation (Window, parser, resources)
│ ├── living/ # DOM living standard implementations
│ ├── generated/ # Auto-generated Web IDL bindings
│ └── ... # Various DOM/CSS/SVG/XHR implementations
└── node_modules/
└── jsdom/ # Installed jsdom dependency
```
## Technology Stack
- **Runtime**: Node.js (inferred from jsdom usage)
- **Core Library**: [jsdom](https://github.com/jsdom/jsdom) - JavaScript implementation of DOM and HTML standards
- Provides browser-like environment for server-side JavaScript
- Enables DOM manipulation, event handling, and web API emulation
## Development Status
**Early Stage**: The project currently contains:
- Game design documentation (README.md)
- jsdom library setup (both local copy and node_modules installation)
- No main game source files yet
## Building and Running
> **TODO**: Build and run commands are not yet defined. The project is in initial setup phase.
Expected setup once development begins:
```bash
# Install dependencies
npm install
# Run the game (TBD)
npm start
# Run tests (TBD)
npm test
```
## Development Conventions
> **TODO**: Coding standards and testing practices are not yet established.
### Inferred Practices (based on jsdom usage)
- JavaScript/TypeScript expected for implementation
- DOM-based rendering likely planned (given jsdom inclusion)
- Game logic will need to implement:
- Hexagonal grid generation
- Dice mechanics and randomization
- Turn-based combat system
- Player state management
## Key Implementation Areas
When development begins, focus on these components:
1. **Map Generator**: Hexagonal grid creation with passable/impassable cells
2. **Dice Engine**: Randomization and strength calculation
3. **Combat System**: Attack/defense resolution logic
4. **Game State**: Player turns, unit positions, victory conditions
5. **UI/Rendering**: Visual representation of the game board
## Notes
- The `.gitignore` file appears to be a Python template and may need to be updated for a JavaScript project
- The `jsdom-pkg` directory contains a local copy of jsdom, possibly for offline development or custom modifications
- Game rules are documented in Russian in README.md