@pompidup/kingdomino-engine 1.0.3 → 1.0.4

package/README.md

@@ -2,65 +2,101 @@
 
 ## Overview
 
-Kingdomino Engine is a simple and lightweight TypeScript engine designed to facilitate the gameplay of Kingdomino. It provides the core logic for managing game states, rules, and player interactions, making it easy to integrate into any application that requires a Kingdomino game engine.
+This is under development. The goal is to create a simple and lightweight TypeScript engine designed to facilitate the gameplay of Kingdomino. It provides the core logic for managing game states, rules, and player interactions, making it easy to integrate into any application that requires a Kingdomino game engine.
 
 ## Features
 
 - **Game State Management**: Efficiently manage game states, including player turns, game rules, and game progression.
 - **Rule Enforcement**: Automatically enforce game rules, ensuring a fair and consistent gameplay experience.
 - **Player Interaction**: Simplify player interactions, including drawing tiles, placing dominoes, and scoring.
-- **Customizable Rules**: Support for custom game rules, allowing for a wide range of gameplay variations.
 
 ## Installation
 
-To install the Kingdomino Engine, you can use npm or yarn. Run the following command in your terminal:
-bash npm install @pompidup/kingdomino-engine
+To install the Kingdomino Engine, you can use npm, yarn or pnpm. Run the following command in your terminal:
+
+```bash
+npm install @pompidup/kingdomino-engine
+```
+
+or
+
+```bash
+yarn add @pompidup/kingdomino-engine
+```
 
 or
 
-bash yarn add @pompidup/kingdomino-engine
+```bash
+pnpm add @pompidup/kingdomino-engine
+```
 
 ## Usage
 
+The Kingdomino Engine is designed to be easy to use and integrate into any application. Below are some examples of how you can use the engine to create a new game, add players, and start playing.
+
+Each method returns an updated game state object, which contains the current state of the game, including the board, players, and dominoes. In return you will receive too the nextKing (the next player to play) and the nextAction (the next action to be performed by the next player).
+
+**It's your responsibility to save and pass the updated game state to the next method call.**
+
 ### Basic Setup
 
 To start using the Kingdomino Engine, you need to import it and initialize a new game instance.
 
-typescript import { KingdominoEngine } from '@pompidup/kingdomino-engine';
+```typescript
+import gameEngine from "@pompidup/kingdomino-engine";
 
-const engine = new KingdominoEngine();
+const engine = gameEngine();
+let gameState = engine.init();
+```
 
-### Setting Up Rules
+### Start game and setting up players
 
-You can customize the game rules by passing an array of rule names to the `setRules` method.
+You can add players to the game by passing an array of player.
 
-typescript engine.setRules(['rule1', 'rule2']);
+```typescript
+const players = [{ name: "Player  1" }, { name: "Player  2" }];
+gameState = engine.start(gameState, players);
+```
 
-### Starting a Game
+### Choosing game mode (Classic, Queendomino...)
 
-To start a new game, use the `startGame` method.
+Incoming...
 
-typescript engine.startGame();
+### Setting Up Rules
 
-### Player Actions
+Incoming...
 
-Players can perform actions like drawing tiles, placing dominoes, and passing turns.
+### Player Actions
 
-typescript // Example: Drawing a tile engine.drawTile('player1');
+Players can perform actions like pick domino, placing domino, and passing turns.
 
-// Example: Placing a domino engine.placeDomino('player1', { x: 0, y: 0 }, 'domino1');
+- Pick Domino:
+  You can pick a domino by passing the kingId and the number of the domino you want to pick.
 
-// Example: Passing a turn engine.passTurn('player1');
+```typescript
+gameState = engine.pickDomino(gameState, "kingId", 12);
+```
 
-## Contributing
+- Place Domino:
+  You can place a domino by passing the kingId, the position where you want to place the domino, the orientation (horizontal or vertical), and the rotation (if you want to switch left and right tile you can pass 180 else 0).
 
-Contributions are welcome! Please read the [contributing guide](CONTRIBUTING.md) for details on how to contribute to this project.
+```typescript
+gameState = engine.placeDomino(
+  gameState,
+  "kingId",
+  { x: 0, y: 0 },
+  "horizontal",
+  0
+);
+```
 
-## License
+- Pass Turn:
+  If you can not place a domino you can pass your turn.
 
-This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+```typescript
+gameState = engine.passTurn(gameState, "kingId");
+```
 
-## Acknowledgments
+### Scoring
 
-- Thanks to all the contributors who have helped shape this project.
-- Special thanks to the Kingdomino community for their support and feedback.
+When last turn is played, you will received the final score of each player and their position.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pompidup/kingdomino-engine",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "description": "A simple engine for the game Kingdomino",
   "main": "./dist/index.js",
   "type": "module",
@@ -17,6 +17,9 @@
     "test": "vitest",
     "coverage": "vitest --coverage --config ./vitest.config.ts",
     "build": "tsup",
+    "bump:major": "npm version major",
+    "bump:minor": "npm version minor",
+    "bump:patch": "npm version patch",
     "pub": "pnpm build && npm login && npm publish --access public"
   },
   "keywords": [