@pompidup/kingdomino-engine 1.0.1 → 1.0.3

package/README.md

@@ -0,0 +1,66 @@
+# Kingdomino Engine
+
+## 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.
+
+## 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
+
+or
+
+bash yarn add @pompidup/kingdomino-engine
+
+## Usage
+
+### 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';
+
+const engine = new KingdominoEngine();
+
+### Setting Up Rules
+
+You can customize the game rules by passing an array of rule names to the `setRules` method.
+
+typescript engine.setRules(['rule1', 'rule2']);
+
+### Starting a Game
+
+To start a new game, use the `startGame` method.
+
+typescript engine.startGame();
+
+### Player Actions
+
+Players can perform actions like drawing tiles, placing dominoes, and passing turns.
+
+typescript // Example: Drawing a tile engine.drawTile('player1');
+
+// Example: Placing a domino engine.placeDomino('player1', { x: 0, y: 0 }, 'domino1');
+
+// Example: Passing a turn engine.passTurn('player1');
+
+## Contributing
+
+Contributions are welcome! Please read the [contributing guide](CONTRIBUTING.md) for details on how to contribute to this project.
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## Acknowledgments
+
+- Thanks to all the contributors who have helped shape this project.
+- Special thanks to the Kingdomino community for their support and feedback.

package/dist/index.d.ts

@@ -0,0 +1,110 @@
+declare const ground: readonly ["castle", "wheat", "forest", "sea", "plain", "swamp", "mine"];
+type Ground = (typeof ground)[number];
+type Tile = {
+    type: Ground;
+    crowns: number;
+};
+type EmptyTile = {
+    type: "empty";
+    crowns: 0;
+};
+type Domino = {
+    left: Tile;
+    right: Tile;
+    number: number;
+};
+type RevealsDomino = {
+    domino: Domino;
+    picked: boolean;
+    kingId: string | null;
+    position: number;
+};
+
+type Position = {
+    x: number;
+    y: number;
+};
+type Orientation = "vertical" | "horizontal";
+type Rotation = 0 | 180;
+type Kingdom = (Tile | EmptyTile)[][];
+
+type King = {
+    id: string;
+    playerId: string;
+    order: number;
+    turnEnded: boolean;
+    hasPick: boolean;
+    hasPlace: boolean;
+    dominoPicked?: Domino;
+};
+type Player = {
+    id?: string;
+    name: string;
+    kingdom: Kingdom;
+};
+declare const availableMode: readonly ["Classic"];
+type AvailableMode = (typeof availableMode)[number];
+type Rule = {
+    name: string;
+    description: string;
+    mode: AvailableMode[];
+    playersLimit?: number;
+};
+type Game = {
+    id: string;
+    dominoes: Domino[];
+    currentDominoes: RevealsDomino[];
+    players: Player[];
+    kings: King[];
+    turn: number;
+    maxTurns: number;
+    maxDominoes: number;
+    dominoesPerTurn: number;
+    order: Record<number, string>;
+    rules?: Rule[];
+};
+
+type Score = {
+    score: number;
+    maxPropertiesSize: number;
+    totalCrowns: number;
+};
+
+type ScoreResult = {
+    playerId: string;
+    playerName: string;
+    details: Score;
+};
+type FinalResult = ScoreResult & {
+    position: number;
+};
+
+type Resp = {
+    nextKing: string;
+    nextAction: "pick" | "place" | "end";
+    game: Game;
+};
+type GameResult = {
+    result: FinalResult[];
+    game: Game;
+};
+/** Todo
+ * Add rules step
+ *
+ **/
+declare const gameEngine: () => {
+    init: () => Game;
+    getMode: () => readonly ["Classic"];
+    setMode: (mode: string, game: Game) => Game;
+    getRules: (mode: string) => never[];
+    setRules: (rules: string[], game: Game) => Game;
+    start: (game: Game, players: {
+        name: string;
+    }[]) => Resp;
+    pass: (game: Game, kingId: string) => Resp;
+    placeDomino: (game: Game, kingId: string, position: Position, orientation: Orientation, rotation: Rotation) => Resp;
+    pickDomino: (game: Game, kingId: string, dominoPick: number) => Resp;
+    endGame: (game: Game) => GameResult;
+};
+
+export { gameEngine as default };