@pompidup/kingdomino-engine 1.0.1 → 1.0.2

package/dist/index.js

@@ -1,2 +1,1402 @@
-var A=[{left:{type:"wheat",crowns:0},right:{type:"wheat",crowns:0},number:1},{left:{type:"wheat",crowns:0},right:{type:"wheat",crowns:0},number:2},{left:{type:"forest",crowns:0},right:{type:"forest",crowns:0},number:3},{left:{type:"forest",crowns:0},right:{type:"forest",crowns:0},number:4},{left:{type:"forest",crowns:0},right:{type:"forest",crowns:0},number:5},{left:{type:"forest",crowns:0},right:{type:"forest",crowns:0},number:6},{left:{type:"water",crowns:0},right:{type:"water",crowns:0},number:7},{left:{type:"water",crowns:0},right:{type:"water",crowns:0},number:8},{left:{type:"water",crowns:0},right:{type:"water",crowns:0},number:9},{left:{type:"grass",crowns:0},right:{type:"grass",crowns:0},number:10},{left:{type:"grass",crowns:0},right:{type:"grass",crowns:0},number:11},{left:{type:"swamp",crowns:0},right:{type:"swamp",crowns:0},number:12},{left:{type:"wheat",crowns:0},right:{type:"forest",crowns:0},number:13},{left:{type:"wheat",crowns:0},right:{type:"water",crowns:0},number:14},{left:{type:"wheat",crowns:0},right:{type:"grass",crowns:0},number:15},{left:{type:"wheat",crowns:0},right:{type:"swamp",crowns:0},number:16},{left:{type:"forest",crowns:0},right:{type:"water",crowns:0},number:17},{left:{type:"forest",crowns:0},right:{type:"grass",crowns:0},number:18},{left:{type:"wheat",crowns:1},right:{type:"forest",crowns:0},number:19},{left:{type:"wheat",crowns:1},right:{type:"water",crowns:0},number:20},{left:{type:"wheat",crowns:1},right:{type:"grass",crowns:0},number:21},{left:{type:"wheat",crowns:1},right:{type:"swamp",crowns:0},number:22},{left:{type:"wheat",crowns:1},right:{type:"mine",crowns:0},number:23},{left:{type:"forest",crowns:1},right:{type:"wheat",crowns:0},number:24},{left:{type:"forest",crowns:1},right:{type:"wheat",crowns:0},number:25},{left:{type:"forest",crowns:1},right:{type:"wheat",crowns:0},number:26},{left:{type:"forest",crowns:1},right:{type:"wheat",crowns:0},number:27},{left:{type:"forest",crowns:1},right:{type:"water",crowns:0},number:28},{left:{type:"forest",crowns:1},right:{type:"grass",crowns:0},number:29},{left:{type:"water",crowns:1},right:{type:"wheat",crowns:0},number:30},{left:{type:"water",crowns:1},right:{type:"wheat",crowns:0},number:31},{left:{type:"water",crowns:1},right:{type:"forest",crowns:0},number:32},{left:{type:"water",crowns:1},right:{type:"forest",crowns:0},number:33},{left:{type:"water",crowns:1},right:{type:"forest",crowns:0},number:34},{left:{type:"water",crowns:1},right:{type:"forest",crowns:0},number:35},{left:{type:"wheat",crowns:0},right:{type:"grass",crowns:1},number:36},{left:{type:"water",crowns:0},right:{type:"grass",crowns:1},number:37},{left:{type:"wheat",crowns:0},right:{type:"swamp",crowns:1},number:38},{left:{type:"grass",crowns:0},right:{type:"swamp",crowns:0},number:39},{left:{type:"mine",crowns:1},right:{type:"wheat",crowns:0},number:40},{left:{type:"wheat",crowns:0},right:{type:"grass",crowns:2},number:41},{left:{type:"water",crowns:0},right:{type:"grass",crowns:2},number:42},{left:{type:"wheat",crowns:0},right:{type:"swamp",crowns:2},number:43},{left:{type:"grass",crowns:0},right:{type:"swamp",crowns:2},number:44},{left:{type:"mine",crowns:2},right:{type:"wheat",crowns:0},number:45},{left:{type:"swamp",crowns:0},right:{type:"mine",crowns:2},number:46},{left:{type:"swamp",crowns:0},right:{type:"mine",crowns:2},number:47},{left:{type:"wheat",crowns:0},right:{type:"mine",crowns:3},number:48}];var U=()=>{let e=[];return A.forEach(r=>{e.push({left:{type:r.left.type,crowns:r.left.crowns},right:{type:r.right.type,crowns:r.right.crowns},number:r.number})}),{getAll:()=>e}},v=U;var j=["Classic"];var M=e=>()=>{let r=e.dominoesRepository.getAll();return{id:e.uuidMethod(),dominoes:r,currentDominoes:[],players:[],kings:[],turn:0,maxTurns:0,maxDominoes:0,dominoesPerTurn:0,order:{}}};var z=()=>{let r={type:"empty",crowns:0};return Array.from({length:9},()=>Array.from({length:9},()=>r))},X=()=>{let e=z();return I(e,{x:4,y:4},{type:"castle",crowns:0})},I=(e,r,o)=>{let t=[...e[r.y]];return t[r.x]=o,[...e.slice(0,r.y),t,...e.slice(r.y+1)]},G=(e,r)=>{let o=e[r.y]?.[r.x];if(o===void 0)throw new Error("Invalid placement (not fit into the grid)");return o},ee=(e,r,o,t)=>{let n,s;return r==="horizontal"?o===0?(n={tile:t.left,position:{x:e.x,y:e.y}},s={tile:t.right,position:{x:e.x+1,y:e.y}}):(n={tile:t.right,position:{x:e.x,y:e.y}},s={tile:t.left,position:{x:e.x+1,y:e.y}}):o===0?(n={tile:t.left,position:{x:e.x,y:e.y}},s={tile:t.right,position:{x:e.x,y:e.y+1}}):(n={tile:t.right,position:{x:e.x,y:e.y}},s={tile:t.left,position:{x:e.x,y:e.y+1}}),[n,s]},te=(e,r,o,t,n)=>{let[s,a]=ee(r,o,t,n);if(!ne(e,s.position,a.position))throw new Error("Invalid placement (not free place)");if(!ie(e,[s,a]))throw new Error("Invalid placement (not fit into the grid)");let y=oe(e,s.position,a.position);if(y.length===0)throw new Error("Invalid placement (no adjacent)");if(!se(y,[s.tile,a.tile]))throw new Error("Invalid placement (no valid adjacent)");return re(e,[s,a])},re=(e,r)=>r.reduce((o,{tile:t,position:n})=>I(o,n,t),e),ne=(e,r,o)=>{let t=G(e,r),n=G(e,o);return!(t.type!=="empty"||n.type!=="empty")},oe=(e,r,o)=>{let t=r.x,n=r.y,s=o.x,a=o.y,y=[],i=[{x:t-1,y:n},{x:t,y:n-1},{x:t+1,y:n},{x:t,y:n+1},{x:s-1,y:a},{x:s,y:a-1},{x:s+1,y:a},{x:s,y:a+1}];return i.splice(i.findIndex(c=>c.x===t&&c.y===n),1),i.splice(i.findIndex(c=>c.x===s&&c.y===a),1),i.forEach(c=>{let m=G(e,c);m&&y.push(m)}),y},se=(e,r)=>e.some(o=>r.some(t=>t.type===o.type||o.type==="castle")),ie=(e,r)=>{let t=[...e];t[r[0].position.y][r[0].position.x]=r[0].tile,t[r[1].position.y][r[1].position.x]=r[1].tile;let n=t.map(m=>m.filter(u=>u.type!=="empty")),s=t[0].map((m,u)=>t.map(d=>d[u]).filter(d=>d?.type!=="empty")),a=n.map(m=>m.length),y=s.map(m=>m.length),i=Math.max(...a),c=Math.max(...y);return!(i>5||c>5)},ae={createEmptyKingdom:z,createKingdomWithCastle:X,getTile:G,placeDomino:te},S=ae;var C=e=>r=>{let{state:o,players:t}=r;if(!t)throw new Error("There must be at least 2 players");if(t.length>4)throw new Error("There must be no more than 4 players");if(t.length<2)throw new Error("There must be at least 2 players");let{dominoes:n}=o,{randomMethod:s,uuidMethod:a}=e,{maxDominoes:y,dominoesPerTurn:i,maxTurns:c}=O[t.length],m=s(n);m.splice(y);let u=t.map(w=>({...w,kingdom:S.createKingdomWithCastle(),id:a()})),d;u.length===2?d=[{id:a(),playerId:u[0].id,order:1,turnEnded:!1,hasPick:!1,hasPlace:!1},{id:a(),playerId:u[0].id,order:2,turnEnded:!1,hasPick:!1,hasPlace:!1},{id:a(),playerId:u[1].id,order:3,turnEnded:!1,hasPick:!1,hasPlace:!1},{id:a(),playerId:u[1].id,order:4,turnEnded:!1,hasPick:!1,hasPlace:!1}]:d=u.map((w,h)=>({id:a(),playerId:w.id,order:h+1,turnEnded:!1,hasPick:!1,hasPlace:!1}));let l=s(d);return l.forEach((w,h)=>{w.order=h+1}),l.sort((w,h)=>w.order-h.order),{...o,dominoes:m,players:u,kings:l,maxTurns:c,maxDominoes:y,dominoesPerTurn:i,turn:0}};var F=e=>{let{state:r}=e,o=r.turn+1,t=r.kings;return t.forEach(s=>{s.turnEnded=!1,s.hasPick=!1,s.hasPlace=!1}),{game:{...r,kings:t,turn:o}}};var V=e=>{let{kingId:r,data:o}=e,{state:t,dominoPick:n}=o,{currentDominoes:s,kings:a}=t;if(!L(t,r))throw new Error("It is not your turn");if(a.find(l=>l.id===r)?.hasPick)throw new Error("You have already picked");let i=N(t,n);if((l=>l.error!==void 0)(i))throw new Error(i.error);let m=s.map(l=>(l.domino.number===n&&(l.picked=!0,l.kingId=r),l)),u=a.map(l=>(l.id===r&&(l.hasPick=!0,l.turnEnded=!0,l.dominoPicked=i.domino),l));return{...t,currentDominoes:m,kings:u}};var H=e=>{let{kingId:r,data:o}=e,{state:t,position:n,orientation:s,rotation:a}=o,y=t.kings.find(d=>d.id===r),i=t.players.find(d=>d.id===y?.playerId),c=i?.kingdom;if(!c)throw new Error("Kingdom not found");let m=y?.dominoPicked;if(!m)throw new Error("Domino not found");return S.placeDomino(c,n,s,a,m),i.kingdom=c,y.hasPlace=!0,{...t,kings:t.kings.map(d=>d.id===r?y:d)}};var W=e=>{let{state:r}=e,{kings:o,currentDominoes:t}=r;if(!o.every(i=>i.turnEnded))throw new Error("Not all kings have played");let s=o.map(i=>({...i,order:t.find(c=>c.kingId===i.id)?.position||0})),a=s.reduce((i,c)=>({...i,[c.order]:c.id}),{});return{...r,kings:s,order:a}};var Z=e=>{let{state:r}=e,o=[...r.dominoes],t=o.splice(0,r.dominoesPerTurn);return t.sort((s,a)=>s.number-a.number),{...r,dominoes:o,currentDominoes:t.map((s,a)=>({domino:s,picked:!1,kingId:null,position:a+1}))}};var J=e=>{let r=e.map(i=>i.map(()=>!1)),o=[],t=[[-1,0],[1,0],[0,-1],[0,1]],n=(i,c,m,u)=>{if(i<0||c<0||i>=e[0].length||c>=e.length||r[c][i]||e[c][i].type!==m||e[c][i].type==="empty"||e[c][i].type==="castle")return;r[c][i]=!0;let d=o.find(l=>l.type===m&&l.tiles.some(([T,w])=>{for(let[h,K]of t)if(T+h===i&&w+K===c)return!0;return!1}));d?(d.crowns+=u,d.size++,d.tiles.push([i,c])):o.push({type:m,crowns:u,size:1,tiles:[[i,c]]}),t.forEach(([l,T])=>{let w=i+l,h=c+T;w>=0&&h>=0&&w<e[0].length&&h<e.length&&e[h][w].type===m&&n(w,h,e[h][w].type,e[h][w].crowns)})};if(e.forEach((i,c)=>{i.forEach((m,u)=>{r[c][u]||n(u,c,m.type,m.crowns)})}),o.length===0)return{score:0,maxPropertiesSize:0,totalCrowns:0};let s=o.reduce((i,c)=>i+c.crowns*c.size,0),a=Math.max(...o.map(i=>i.size??0)),y=o.reduce((i,c)=>i+c.crowns,0);return{score:s,maxPropertiesSize:a,totalCrowns:y}};var Y=e=>{let{kingId:r,data:o}=e,{state:t}=o,n=t.kings.find(a=>a.id===r);if(!n)throw new Error("King not found");return n.hasPlace=!0,{...t,kings:t.kings.map(a=>a.id===r?n:a)}};var ce=e=>({init:M(e),setup:C(e),startTurn:F,pick:V,place:H,pass:Y,definePlayerOrder:W,draw:Z,calculateScore:J}),L=(e,r)=>{let{kings:o,currentDominoes:t}=e,n=o.find(a=>a.id===r)?.order,s=t.filter(a=>a.picked);return n===s.length+1},N=(e,r)=>{let{currentDominoes:o}=e,t=o.find(n=>n.domino.number===r);return t?t.picked?{error:"Domino already picked"}:t:{error:"Domino not found"}},O={2:{kings:2,maxDominoes:24,dominoesPerTurn:4,maxTurns:6},3:{kings:1,maxDominoes:36,dominoesPerTurn:3,maxTurns:12},4:{kings:1,maxDominoes:48,dominoesPerTurn:4,maxTurns:12}},_=ce;var $=e=>{e.sort((t,n)=>t.details.score!==n.details.score?n.details.score-t.details.score:t.details.maxPropertiesSize!==n.details.maxPropertiesSize?n.details.maxPropertiesSize-t.details.maxPropertiesSize:n.details.totalCrowns-t.details.totalCrowns);let r=[],o=!1;r.push({...e[0],position:1});for(let t=1;t<e.length;t++){let n=e[t],s=e[t-1];s&&n&&n.details.score===s.details.score&&n.details.maxPropertiesSize===s.details.maxPropertiesSize&&n.details.totalCrowns===s.details.totalCrowns&&(o=!0),o?r.push({...n,position:r[t-1].position}):r.push({...n,position:t+1}),o=!1}return r};var pe=()=>{let e={dominoesRepository:v(),uuidMethod:()=>`uuid-${Math.random()}`,randomMethod:p=>p},{init:r,setup:o,startTurn:t,pick:n,place:s,pass:a,definePlayerOrder:y,draw:i,calculateScore:c}=_(e),m=()=>j,u=(p,f)=>f,d=p=>[],l=(p,f)=>f,T=(p,f)=>{let x=o({state:p,players:f}),g=i({state:x});return{nextKing:g.kings[0].id,nextAction:"pick",game:g}},w=(p,f)=>{let x=a({kingId:f,action:"pass",data:{state:p}});return E(x,"pass",f)},h=(p,f,x,g,b)=>{let k=s({kingId:f,action:"place",data:{state:p,position:x,orientation:g,rotation:b}});return E(k,"place",f)},K=(p,f,x)=>{let g=n({kingId:f,action:"pick",data:{state:p,dominoPick:x}});return E(g,"pick",f)},R=p=>{let f=y({state:p}),x=i({state:f}),g=t({state:x});if(g.game.turn>g.game.maxTurns)throw new Error("Game is over");return g.game},E=(p,f,x)=>{let{kings:g,turn:b}=p;if(b===0){let P=g.find(D=>!D.hasPick);if(!P){let D=R(p);return{nextKing:D.kings[0].id,nextAction:"place",game:D}}return{nextKing:P.id,nextAction:"pick",game:p}}if(f==="place"||f==="pass"){if(p.turn===p.maxTurns){let P=g.find(D=>!D.hasPlace);return P?{nextKing:P.id,nextAction:"place",game:p}:{nextKing:"none",nextAction:"end",game:p}}return{nextKing:x,nextAction:"pick",game:p}}if(g.every(P=>P.hasPick)){let P=R(p);return{nextKing:P.order[1],nextAction:"place",game:P}}return{nextKing:g.find(P=>!P.hasPlace).id,nextAction:"place",game:p}};return{init:r,getMode:m,setMode:u,getRules:d,setRules:l,start:T,pass:w,placeDomino:h,pickDomino:K,endGame:p=>{let f=p.players,x=[];for(let b of f){let k=c(b.kingdom);x.push({playerId:b.id,playerName:b.name,details:k})}return{result:$(x),game:p}}}},q=pe;var Ye=q;export{Ye as default};
-//# sourceMappingURL=index.js.map
+// src/infrastructure/data/dominoes.json
+var dominoes_default = [
+  {
+    left: {
+      type: "wheat",
+      crowns: 0
+    },
+    right: {
+      type: "wheat",
+      crowns: 0
+    },
+    number: 1
+  },
+  {
+    left: {
+      type: "wheat",
+      crowns: 0
+    },
+    right: {
+      type: "wheat",
+      crowns: 0
+    },
+    number: 2
+  },
+  {
+    left: {
+      type: "forest",
+      crowns: 0
+    },
+    right: {
+      type: "forest",
+      crowns: 0
+    },
+    number: 3
+  },
+  {
+    left: {
+      type: "forest",
+      crowns: 0
+    },
+    right: {
+      type: "forest",
+      crowns: 0
+    },
+    number: 4
+  },
+  {
+    left: {
+      type: "forest",
+      crowns: 0
+    },
+    right: {
+      type: "forest",
+      crowns: 0
+    },
+    number: 5
+  },
+  {
+    left: {
+      type: "forest",
+      crowns: 0
+    },
+    right: {
+      type: "forest",
+      crowns: 0
+    },
+    number: 6
+  },
+  {
+    left: {
+      type: "water",
+      crowns: 0
+    },
+    right: {
+      type: "water",
+      crowns: 0
+    },
+    number: 7
+  },
+  {
+    left: {
+      type: "water",
+      crowns: 0
+    },
+    right: {
+      type: "water",
+      crowns: 0
+    },
+    number: 8
+  },
+  {
+    left: {
+      type: "water",
+      crowns: 0
+    },
+    right: {
+      type: "water",
+      crowns: 0
+    },
+    number: 9
+  },
+  {
+    left: {
+      type: "grass",
+      crowns: 0
+    },
+    right: {
+      type: "grass",
+      crowns: 0
+    },
+    number: 10
+  },
+  {
+    left: {
+      type: "grass",
+      crowns: 0
+    },
+    right: {
+      type: "grass",
+      crowns: 0
+    },
+    number: 11
+  },
+  {
+    left: {
+      type: "swamp",
+      crowns: 0
+    },
+    right: {
+      type: "swamp",
+      crowns: 0
+    },
+    number: 12
+  },
+  {
+    left: {
+      type: "wheat",
+      crowns: 0
+    },
+    right: {
+      type: "forest",
+      crowns: 0
+    },
+    number: 13
+  },
+  {
+    left: {
+      type: "wheat",
+      crowns: 0
+    },
+    right: {
+      type: "water",
+      crowns: 0
+    },
+    number: 14
+  },
+  {
+    left: {
+      type: "wheat",
+      crowns: 0
+    },
+    right: {
+      type: "grass",
+      crowns: 0
+    },
+    number: 15
+  },
+  {
+    left: {
+      type: "wheat",
+      crowns: 0
+    },
+    right: {
+      type: "swamp",
+      crowns: 0
+    },
+    number: 16
+  },
+  {
+    left: {
+      type: "forest",
+      crowns: 0
+    },
+    right: {
+      type: "water",
+      crowns: 0
+    },
+    number: 17
+  },
+  {
+    left: {
+      type: "forest",
+      crowns: 0
+    },
+    right: {
+      type: "grass",
+      crowns: 0
+    },
+    number: 18
+  },
+  {
+    left: {
+      type: "wheat",
+      crowns: 1
+    },
+    right: {
+      type: "forest",
+      crowns: 0
+    },
+    number: 19
+  },
+  {
+    left: {
+      type: "wheat",
+      crowns: 1
+    },
+    right: {
+      type: "water",
+      crowns: 0
+    },
+    number: 20
+  },
+  {
+    left: {
+      type: "wheat",
+      crowns: 1
+    },
+    right: {
+      type: "grass",
+      crowns: 0
+    },
+    number: 21
+  },
+  {
+    left: {
+      type: "wheat",
+      crowns: 1
+    },
+    right: {
+      type: "swamp",
+      crowns: 0
+    },
+    number: 22
+  },
+  {
+    left: {
+      type: "wheat",
+      crowns: 1
+    },
+    right: {
+      type: "mine",
+      crowns: 0
+    },
+    number: 23
+  },
+  {
+    left: {
+      type: "forest",
+      crowns: 1
+    },
+    right: {
+      type: "wheat",
+      crowns: 0
+    },
+    number: 24
+  },
+  {
+    left: {
+      type: "forest",
+      crowns: 1
+    },
+    right: {
+      type: "wheat",
+      crowns: 0
+    },
+    number: 25
+  },
+  {
+    left: {
+      type: "forest",
+      crowns: 1
+    },
+    right: {
+      type: "wheat",
+      crowns: 0
+    },
+    number: 26
+  },
+  {
+    left: {
+      type: "forest",
+      crowns: 1
+    },
+    right: {
+      type: "wheat",
+      crowns: 0
+    },
+    number: 27
+  },
+  {
+    left: {
+      type: "forest",
+      crowns: 1
+    },
+    right: {
+      type: "water",
+      crowns: 0
+    },
+    number: 28
+  },
+  {
+    left: {
+      type: "forest",
+      crowns: 1
+    },
+    right: {
+      type: "grass",
+      crowns: 0
+    },
+    number: 29
+  },
+  {
+    left: {
+      type: "water",
+      crowns: 1
+    },
+    right: {
+      type: "wheat",
+      crowns: 0
+    },
+    number: 30
+  },
+  {
+    left: {
+      type: "water",
+      crowns: 1
+    },
+    right: {
+      type: "wheat",
+      crowns: 0
+    },
+    number: 31
+  },
+  {
+    left: {
+      type: "water",
+      crowns: 1
+    },
+    right: {
+      type: "forest",
+      crowns: 0
+    },
+    number: 32
+  },
+  {
+    left: {
+      type: "water",
+      crowns: 1
+    },
+    right: {
+      type: "forest",
+      crowns: 0
+    },
+    number: 33
+  },
+  {
+    left: {
+      type: "water",
+      crowns: 1
+    },
+    right: {
+      type: "forest",
+      crowns: 0
+    },
+    number: 34
+  },
+  {
+    left: {
+      type: "water",
+      crowns: 1
+    },
+    right: {
+      type: "forest",
+      crowns: 0
+    },
+    number: 35
+  },
+  {
+    left: {
+      type: "wheat",
+      crowns: 0
+    },
+    right: {
+      type: "grass",
+      crowns: 1
+    },
+    number: 36
+  },
+  {
+    left: {
+      type: "water",
+      crowns: 0
+    },
+    right: {
+      type: "grass",
+      crowns: 1
+    },
+    number: 37
+  },
+  {
+    left: {
+      type: "wheat",
+      crowns: 0
+    },
+    right: {
+      type: "swamp",
+      crowns: 1
+    },
+    number: 38
+  },
+  {
+    left: {
+      type: "grass",
+      crowns: 0
+    },
+    right: {
+      type: "swamp",
+      crowns: 0
+    },
+    number: 39
+  },
+  {
+    left: {
+      type: "mine",
+      crowns: 1
+    },
+    right: {
+      type: "wheat",
+      crowns: 0
+    },
+    number: 40
+  },
+  {
+    left: {
+      type: "wheat",
+      crowns: 0
+    },
+    right: {
+      type: "grass",
+      crowns: 2
+    },
+    number: 41
+  },
+  {
+    left: {
+      type: "water",
+      crowns: 0
+    },
+    right: {
+      type: "grass",
+      crowns: 2
+    },
+    number: 42
+  },
+  {
+    left: {
+      type: "wheat",
+      crowns: 0
+    },
+    right: {
+      type: "swamp",
+      crowns: 2
+    },
+    number: 43
+  },
+  {
+    left: {
+      type: "grass",
+      crowns: 0
+    },
+    right: {
+      type: "swamp",
+      crowns: 2
+    },
+    number: 44
+  },
+  {
+    left: {
+      type: "mine",
+      crowns: 2
+    },
+    right: {
+      type: "wheat",
+      crowns: 0
+    },
+    number: 45
+  },
+  {
+    left: {
+      type: "swamp",
+      crowns: 0
+    },
+    right: {
+      type: "mine",
+      crowns: 2
+    },
+    number: 46
+  },
+  {
+    left: {
+      type: "swamp",
+      crowns: 0
+    },
+    right: {
+      type: "mine",
+      crowns: 2
+    },
+    number: 47
+  },
+  {
+    left: {
+      type: "wheat",
+      crowns: 0
+    },
+    right: {
+      type: "mine",
+      crowns: 3
+    },
+    number: 48
+  }
+];
+
+// src/infrastructure/repositories/inMemoryDominoes.ts
+var inMemoryDominoes = () => {
+  const dominoes = [];
+  dominoes_default.forEach((domino) => {
+    dominoes.push({
+      left: {
+        type: domino.left.type,
+        crowns: domino.left.crowns
+      },
+      right: {
+        type: domino.right.type,
+        crowns: domino.right.crowns
+      },
+      number: domino.number
+    });
+  });
+  return {
+    getAll: () => {
+      return dominoes;
+    }
+  };
+};
+var inMemoryDominoes_default = inMemoryDominoes;
+
+// src/domain/entities/game.ts
+var availableMode = ["Classic"];
+
+// src/domain/useCases/game/init.ts
+var init = (dependencies) => () => {
+  const dominoes = dependencies.dominoesRepository.getAll();
+  const id = dependencies.uuidMethod();
+  const state = {
+    id,
+    dominoes,
+    currentDominoes: [],
+    players: [],
+    kings: [],
+    turn: 0,
+    maxTurns: 0,
+    maxDominoes: 0,
+    dominoesPerTurn: 0,
+    order: {}
+  };
+  return state;
+};
+
+// src/domain/entities/kingdom.ts
+var createEmptyKingdom = () => {
+  const gridSize = 9;
+  const emptyTile = { type: "empty", crowns: 0 };
+  return Array.from(
+    { length: gridSize },
+    () => Array.from({ length: gridSize }, () => emptyTile)
+  );
+};
+var createKingdomWithCastle = () => {
+  const kingdom2 = createEmptyKingdom();
+  return placeTile(kingdom2, { x: 4, y: 4 }, { type: "castle", crowns: 0 });
+};
+var placeTile = (kingdom2, position, tile) => {
+  const newRow = [...kingdom2[position.y]];
+  newRow[position.x] = tile;
+  return [
+    ...kingdom2.slice(0, position.y),
+    newRow,
+    ...kingdom2.slice(position.y + 1)
+  ];
+};
+var getTile = (grid, position) => {
+  const tile = grid[position.y]?.[position.x];
+  if (tile === void 0) {
+    throw new Error("Invalid placement (not fit into the grid)");
+  }
+  return tile;
+};
+var calculateDominoPosition = (position, orientation, rotation, domino) => {
+  let firstTile;
+  let secondTile;
+  if (orientation === "horizontal") {
+    if (rotation === 0) {
+      firstTile = {
+        tile: domino.left,
+        position: {
+          x: position.x,
+          y: position.y
+        }
+      };
+      secondTile = {
+        tile: domino.right,
+        position: {
+          x: position.x + 1,
+          y: position.y
+        }
+      };
+    } else {
+      firstTile = {
+        tile: domino.right,
+        position: {
+          x: position.x,
+          y: position.y
+        }
+      };
+      secondTile = {
+        tile: domino.left,
+        position: {
+          x: position.x + 1,
+          y: position.y
+        }
+      };
+    }
+  } else {
+    if (rotation === 0) {
+      firstTile = {
+        tile: domino.left,
+        position: {
+          x: position.x,
+          y: position.y
+        }
+      };
+      secondTile = {
+        tile: domino.right,
+        position: {
+          x: position.x,
+          y: position.y + 1
+        }
+      };
+    } else {
+      firstTile = {
+        tile: domino.right,
+        position: {
+          x: position.x,
+          y: position.y
+        }
+      };
+      secondTile = {
+        tile: domino.left,
+        position: {
+          x: position.x,
+          y: position.y + 1
+        }
+      };
+    }
+  }
+  return [firstTile, secondTile];
+};
+var placeDomino = (kingdom2, position, orientation, rotation, domino) => {
+  const [firstTile, secondTile] = calculateDominoPosition(
+    position,
+    orientation,
+    rotation,
+    domino
+  );
+  if (!isFreePlace(kingdom2, firstTile.position, secondTile.position)) {
+    throw new Error("Invalid placement (not free place)");
+  }
+  if (!isFitIntoTheGrid(kingdom2, [firstTile, secondTile])) {
+    throw new Error("Invalid placement (not fit into the grid)");
+  }
+  const adjacentTiles = isAdjacent(
+    kingdom2,
+    firstTile.position,
+    secondTile.position
+  );
+  if (adjacentTiles.length === 0) {
+    throw new Error("Invalid placement (no adjacent)");
+  }
+  const hasValidAdjacentTiles = hasValidAdjacent(adjacentTiles, [
+    firstTile.tile,
+    secondTile.tile
+  ]);
+  if (!hasValidAdjacentTiles) {
+    throw new Error("Invalid placement (no valid adjacent)");
+  }
+  return placeTiles(kingdom2, [firstTile, secondTile]);
+};
+var placeTiles = (kingdom2, tiles) => {
+  return tiles.reduce(
+    (newKingdom, { tile, position }) => placeTile(newKingdom, position, tile),
+    kingdom2
+  );
+};
+var isFreePlace = (kingdom2, firstPosition, secondPosition) => {
+  const firstTile = getTile(kingdom2, firstPosition);
+  const secondTile = getTile(kingdom2, secondPosition);
+  if (firstTile.type !== "empty" || secondTile.type !== "empty") {
+    return false;
+  }
+  return true;
+};
+var isAdjacent = (kingdom2, firstPosition, secondPosition) => {
+  const xFirstPosition = firstPosition.x;
+  const yFirstPosition = firstPosition.y;
+  const xSecondPosition = secondPosition.x;
+  const ySecondPosition = secondPosition.y;
+  const adjacentTiles = [];
+  const adjacentTilesKeys = [
+    { x: xFirstPosition - 1, y: yFirstPosition },
+    { x: xFirstPosition, y: yFirstPosition - 1 },
+    { x: xFirstPosition + 1, y: yFirstPosition },
+    { x: xFirstPosition, y: yFirstPosition + 1 },
+    { x: xSecondPosition - 1, y: ySecondPosition },
+    { x: xSecondPosition, y: ySecondPosition - 1 },
+    { x: xSecondPosition + 1, y: ySecondPosition },
+    { x: xSecondPosition, y: ySecondPosition + 1 }
+  ];
+  adjacentTilesKeys.splice(
+    adjacentTilesKeys.findIndex((pos) => {
+      return pos.x === xFirstPosition && pos.y === yFirstPosition;
+    }),
+    1
+  );
+  adjacentTilesKeys.splice(
+    adjacentTilesKeys.findIndex((pos) => {
+      return pos.x === xSecondPosition && pos.y === ySecondPosition;
+    }),
+    1
+  );
+  adjacentTilesKeys.forEach((key) => {
+    const tile = getTile(kingdom2, key);
+    if (tile) {
+      adjacentTiles.push(tile);
+    }
+  });
+  return adjacentTiles;
+};
+var hasValidAdjacent = (adjacentTiles, tiles) => {
+  return adjacentTiles.some((adjacentTile) => {
+    return tiles.some((tile) => {
+      return tile.type === adjacentTile.type || adjacentTile.type === "castle";
+    });
+  });
+};
+var isFitIntoTheGrid = (grid, positions) => {
+  const maxSize = 5;
+  const simulateNewGrid = [...grid];
+  simulateNewGrid[positions[0].position.y][positions[0].position.x] = positions[0].tile;
+  simulateNewGrid[positions[1].position.y][positions[1].position.x] = positions[1].tile;
+  const lines = simulateNewGrid.map(
+    (line) => line.filter((tile) => tile.type !== "empty")
+  );
+  const columns = simulateNewGrid[0].map(
+    (_, index) => simulateNewGrid.map((line) => line[index]).filter((tile) => tile?.type !== "empty")
+  );
+  const linesLength = lines.map((line) => line.length);
+  const columnsLength = columns.map((line) => line.length);
+  const maxLineLength = Math.max(...linesLength);
+  const maxColumnLength = Math.max(...columnsLength);
+  if (maxLineLength > maxSize || maxColumnLength > maxSize) {
+    return false;
+  }
+  return true;
+};
+var kingdom = {
+  createEmptyKingdom,
+  createKingdomWithCastle,
+  getTile,
+  placeDomino
+};
+var kingdom_default = kingdom;
+
+// src/domain/useCases/game/setup.ts
+var setup = (dependencies) => (payload) => {
+  const { state, players } = payload;
+  if (!players) {
+    throw new Error("There must be at least 2 players");
+  }
+  if (players.length > 4) {
+    throw new Error("There must be no more than 4 players");
+  }
+  if (players.length < 2) {
+    throw new Error("There must be at least 2 players");
+  }
+  const { dominoes } = state;
+  const { randomMethod, uuidMethod } = dependencies;
+  const { maxDominoes, dominoesPerTurn, maxTurns } = rules[players.length];
+  const shuffledDominoes = randomMethod(dominoes);
+  shuffledDominoes.splice(maxDominoes);
+  const newPlayers = players.map((player) => {
+    return {
+      ...player,
+      kingdom: kingdom_default.createKingdomWithCastle(),
+      id: uuidMethod()
+    };
+  });
+  let newKings;
+  if (newPlayers.length === 2) {
+    newKings = [
+      {
+        id: uuidMethod(),
+        playerId: newPlayers[0].id,
+        order: 1,
+        turnEnded: false,
+        hasPick: false,
+        hasPlace: false
+      },
+      {
+        id: uuidMethod(),
+        playerId: newPlayers[0].id,
+        order: 2,
+        turnEnded: false,
+        hasPick: false,
+        hasPlace: false
+      },
+      {
+        id: uuidMethod(),
+        playerId: newPlayers[1].id,
+        order: 3,
+        turnEnded: false,
+        hasPick: false,
+        hasPlace: false
+      },
+      {
+        id: uuidMethod(),
+        playerId: newPlayers[1].id,
+        order: 4,
+        turnEnded: false,
+        hasPick: false,
+        hasPlace: false
+      }
+    ];
+  } else {
+    newKings = newPlayers.map((player, index) => {
+      return {
+        id: uuidMethod(),
+        playerId: player.id,
+        order: index + 1,
+        turnEnded: false,
+        hasPick: false,
+        hasPlace: false
+      };
+    });
+  }
+  const kingsWithOrder = randomMethod(newKings);
+  kingsWithOrder.forEach((king, index) => {
+    king.order = index + 1;
+  });
+  kingsWithOrder.sort((a, b) => a.order - b.order);
+  const newState = {
+    ...state,
+    dominoes: shuffledDominoes,
+    players: newPlayers,
+    kings: kingsWithOrder,
+    maxTurns,
+    maxDominoes,
+    dominoesPerTurn,
+    turn: 0
+  };
+  return newState;
+};
+
+// src/domain/useCases/game/startTurn.ts
+var startTurn = (payload) => {
+  const { state } = payload;
+  const turn = state.turn + 1;
+  const kings = state.kings;
+  kings.forEach((king) => {
+    king.turnEnded = false;
+    king.hasPick = false;
+    king.hasPlace = false;
+  });
+  const updatedState = {
+    ...state,
+    kings,
+    turn
+  };
+  return { game: updatedState };
+};
+
+// src/domain/useCases/game/pick.ts
+var pick = (payload) => {
+  const { kingId, data } = payload;
+  const { state, dominoPick } = data;
+  const { currentDominoes, kings } = state;
+  if (!isKingTurn(state, kingId)) {
+    throw new Error("It is not your turn");
+  }
+  const king = kings.find((king2) => king2.id === kingId);
+  if (king?.hasPick) {
+    throw new Error("You have already picked");
+  }
+  const domino = checkValidityDomino(state, dominoPick);
+  const isError = (domino2) => {
+    return domino2.error !== void 0;
+  };
+  if (isError(domino)) {
+    throw new Error(domino.error);
+  }
+  const updatedCurrentDominoes = currentDominoes.map((domino2) => {
+    if (domino2.domino.number === dominoPick) {
+      domino2.picked = true;
+      domino2.kingId = kingId;
+    }
+    return domino2;
+  });
+  const updatedKings = kings.map((king2) => {
+    if (king2.id === kingId) {
+      king2.hasPick = true;
+      king2.turnEnded = true;
+      king2.dominoPicked = domino.domino;
+    }
+    return king2;
+  });
+  const updatedState = {
+    ...state,
+    currentDominoes: updatedCurrentDominoes,
+    kings: updatedKings
+  };
+  return updatedState;
+};
+
+// src/domain/useCases/game/place.ts
+var place = (payload) => {
+  const { kingId, data } = payload;
+  const { state, position, orientation, rotation } = data;
+  const currentKing = state.kings.find((king) => king.id === kingId);
+  const currentPlayer = state.players.find(
+    (player) => player.id === currentKing?.playerId
+  );
+  const currentKingdom = currentPlayer?.kingdom;
+  if (!currentKingdom) {
+    throw new Error("Kingdom not found");
+  }
+  const domino = currentKing?.dominoPicked;
+  if (!domino) {
+    throw new Error("Domino not found");
+  }
+  kingdom_default.placeDomino(currentKingdom, position, orientation, rotation, domino);
+  currentPlayer.kingdom = currentKingdom;
+  currentKing.hasPlace = true;
+  const newState = {
+    ...state,
+    kings: state.kings.map((king) => {
+      if (king.id === kingId) {
+        return currentKing;
+      }
+      return king;
+    })
+  };
+  return newState;
+};
+
+// src/domain/useCases/game/order.ts
+var definePlayerOrder = (payload) => {
+  const { state } = payload;
+  const { kings, currentDominoes } = state;
+  const allKingsHavePlayed = kings.every((king) => king.turnEnded);
+  if (!allKingsHavePlayed) {
+    throw new Error("Not all kings have played");
+  }
+  const updatedKings = kings.map((king) => {
+    return {
+      ...king,
+      order: currentDominoes.find((domino) => domino.kingId === king.id)?.position || 0
+    };
+  });
+  const order = updatedKings.reduce((acc, king) => {
+    return {
+      ...acc,
+      [king.order]: king.id
+    };
+  }, {});
+  const newState = {
+    ...state,
+    kings: updatedKings,
+    order
+  };
+  return newState;
+};
+
+// src/domain/useCases/game/draw.ts
+var draw = (payload) => {
+  const { state } = payload;
+  const dominoesCopy = [...state.dominoes];
+  const dominoesDrawn = dominoesCopy.splice(0, state.dominoesPerTurn);
+  dominoesDrawn.sort((a, b) => a.number - b.number);
+  const newState = {
+    ...state,
+    dominoes: dominoesCopy,
+    currentDominoes: dominoesDrawn.map((domino, index) => {
+      return {
+        domino,
+        picked: false,
+        kingId: null,
+        position: index + 1
+      };
+    })
+  };
+  return newState;
+};
+
+// src/domain/useCases/game/scoring.ts
+var calculateScore = (kingdom2) => {
+  const visited = kingdom2.map((row) => row.map(() => false));
+  const properties = [];
+  const directions = [
+    [-1, 0],
+    [1, 0],
+    [0, -1],
+    [0, 1]
+  ];
+  const markZone = (x, y, type, crowns) => {
+    if (x < 0 || y < 0 || x >= kingdom2[0].length || y >= kingdom2.length || visited[y][x] || kingdom2[y][x].type !== type || kingdom2[y][x].type === "empty" || kingdom2[y][x].type === "castle") {
+      return;
+    }
+    visited[y][x] = true;
+    const currentZone = properties.find(
+      (property) => property.type === type && property.tiles.some(([tx, ty]) => {
+        for (let [dx, dy] of directions) {
+          if (tx + dx === x && ty + dy === y) {
+            return true;
+          }
+        }
+        return false;
+      })
+    );
+    if (currentZone) {
+      currentZone.crowns += crowns;
+      currentZone.size++;
+      currentZone.tiles.push([x, y]);
+    } else {
+      properties.push({ type, crowns, size: 1, tiles: [[x, y]] });
+    }
+    directions.forEach(([dx, dy]) => {
+      const nx = x + dx;
+      const ny = y + dy;
+      if (nx >= 0 && ny >= 0 && nx < kingdom2[0].length && ny < kingdom2.length && kingdom2[ny][nx].type === type) {
+        markZone(nx, ny, kingdom2[ny][nx].type, kingdom2[ny][nx].crowns);
+      }
+    });
+  };
+  kingdom2.forEach((row, y) => {
+    row.forEach((tile, x) => {
+      if (!visited[y][x]) {
+        markZone(x, y, tile.type, tile.crowns);
+      }
+    });
+  });
+  if (properties.length === 0) {
+    return {
+      score: 0,
+      maxPropertiesSize: 0,
+      totalCrowns: 0
+    };
+  }
+  const score = properties.reduce(
+    (score2, property) => score2 + property.crowns * property.size,
+    0
+  );
+  const maxPropertiesSize = Math.max(
+    ...properties.map((property) => property.size ?? 0)
+  );
+  const totalCrowns = properties.reduce(
+    (total, property) => total + property.crowns,
+    0
+  );
+  return {
+    score,
+    maxPropertiesSize,
+    totalCrowns
+  };
+};
+
+// src/domain/useCases/game/pass.ts
+var pass = (payload) => {
+  const { kingId, data } = payload;
+  const { state } = data;
+  const currentKing = state.kings.find((king) => king.id === kingId);
+  if (!currentKing) {
+    throw new Error("King not found");
+  }
+  currentKing.hasPlace = true;
+  const newState = {
+    ...state,
+    kings: state.kings.map((king) => {
+      if (king.id === kingId) {
+        return currentKing;
+      }
+      return king;
+    })
+  };
+  return newState;
+};
+
+// src/domain/useCases/game/game.ts
+var gameStep = (dependencies) => {
+  return {
+    init: init(dependencies),
+    setup: setup(dependencies),
+    startTurn,
+    pick,
+    place,
+    pass,
+    definePlayerOrder,
+    draw,
+    calculateScore
+  };
+};
+var isKingTurn = (state, kingId) => {
+  const { kings, currentDominoes } = state;
+  const currentKingOrder = kings.find((king) => king.id === kingId)?.order;
+  const pickedDominoes = currentDominoes.filter(
+    (currentDomino) => currentDomino.picked
+  );
+  if (currentKingOrder !== pickedDominoes.length + 1) {
+    return false;
+  }
+  return true;
+};
+var checkValidityDomino = (state, dominoPick) => {
+  const { currentDominoes } = state;
+  const domino = currentDominoes.find(
+    (currentDomino) => currentDomino.domino.number === dominoPick
+  );
+  if (!domino) {
+    const error = {
+      error: "Domino not found"
+    };
+    return error;
+  }
+  if (domino.picked) {
+    const error = {
+      error: "Domino already picked"
+    };
+    return error;
+  }
+  return domino;
+};
+var rules = {
+  2: {
+    kings: 2,
+    maxDominoes: 24,
+    dominoesPerTurn: 4,
+    maxTurns: 6
+  },
+  3: {
+    kings: 1,
+    maxDominoes: 36,
+    dominoesPerTurn: 3,
+    maxTurns: 12
+  },
+  4: {
+    kings: 1,
+    maxDominoes: 48,
+    dominoesPerTurn: 4,
+    maxTurns: 12
+  }
+};
+var game_default = gameStep;
+
+// src/domain/useCases/game/result.ts
+var result = (scores) => {
+  scores.sort((a, b) => {
+    if (a.details.score !== b.details.score) {
+      return b.details.score - a.details.score;
+    }
+    if (a.details.maxPropertiesSize !== b.details.maxPropertiesSize) {
+      return b.details.maxPropertiesSize - a.details.maxPropertiesSize;
+    }
+    return b.details.totalCrowns - a.details.totalCrowns;
+  });
+  const result2 = [];
+  let isTie = false;
+  result2.push({
+    ...scores[0],
+    position: 1
+  });
+  for (let i = 1; i < scores.length; i++) {
+    const currentScore = scores[i];
+    const previousScore = scores[i - 1];
+    if (previousScore && currentScore && currentScore.details.score === previousScore.details.score && currentScore.details.maxPropertiesSize === previousScore.details.maxPropertiesSize && currentScore.details.totalCrowns === previousScore.details.totalCrowns) {
+      isTie = true;
+    }
+    if (isTie) {
+      result2.push({
+        ...currentScore,
+        position: result2[i - 1].position
+      });
+    } else {
+      result2.push({
+        ...currentScore,
+        position: i + 1
+      });
+    }
+    isTie = false;
+  }
+  return result2;
+};
+
+// src/application/engine/index.ts
+var gameEngine = () => {
+  const dependencies = {
+    dominoesRepository: inMemoryDominoes_default(),
+    uuidMethod: () => `uuid-${Math.random()}`,
+    randomMethod: (array) => array
+  };
+  const {
+    init: init2,
+    setup: setup2,
+    startTurn: startTurn2,
+    pick: pick2,
+    place: place2,
+    pass: pass2,
+    definePlayerOrder: definePlayerOrder2,
+    draw: draw2,
+    calculateScore: calculateScore2
+  } = game_default(dependencies);
+  const getMode = () => {
+    return availableMode;
+  };
+  const setMode = (mode, game) => {
+    return game;
+  };
+  const getRules = (mode) => {
+    return [];
+  };
+  const setRules = (rules2, game) => {
+    return game;
+  };
+  const start = (game, players) => {
+    const setupState = setup2({
+      state: game,
+      players
+    });
+    const drawState = draw2({ state: setupState });
+    return {
+      nextKing: drawState.kings[0].id,
+      nextAction: "pick",
+      game: drawState
+    };
+  };
+  const passTurn = (game, kingId) => {
+    const updatedGame = pass2({
+      kingId,
+      action: "pass",
+      data: {
+        state: game
+      }
+    });
+    const resp = defineNextAction(updatedGame, "pass", kingId);
+    return resp;
+  };
+  const placeDomino2 = (game, kingId, position, orientation, rotation) => {
+    const updatedGame = place2({
+      kingId,
+      action: "place",
+      data: {
+        state: game,
+        position,
+        orientation,
+        rotation
+      }
+    });
+    const resp = defineNextAction(updatedGame, "place", kingId);
+    return resp;
+  };
+  const pickDomino = (game, kingId, dominoPick) => {
+    const updatedGame = pick2({
+      kingId,
+      action: "pick",
+      data: {
+        state: game,
+        dominoPick
+      }
+    });
+    const resp = defineNextAction(updatedGame, "pick", kingId);
+    return resp;
+  };
+  const prepareNextTurn = (game) => {
+    const updatedOrder = definePlayerOrder2({ state: game });
+    const updateDraw = draw2({ state: updatedOrder });
+    const updateTurn = startTurn2({ state: updateDraw });
+    if (updateTurn.game.turn > updateTurn.game.maxTurns) {
+      throw new Error("Game is over");
+    }
+    return updateTurn.game;
+  };
+  const defineNextAction = (game, currentAction, currentKingId) => {
+    const { kings, turn } = game;
+    if (turn === 0) {
+      const nextKing2 = kings.find((king) => !king.hasPick);
+      if (!nextKing2) {
+        const newState = prepareNextTurn(game);
+        return {
+          nextKing: newState.kings[0].id,
+          nextAction: "place",
+          game: newState
+        };
+      }
+      return {
+        nextKing: nextKing2.id,
+        nextAction: "pick",
+        game
+      };
+    }
+    if (currentAction === "place" || currentAction === "pass") {
+      if (game.turn === game.maxTurns) {
+        const nextKing2 = kings.find((king) => !king.hasPlace);
+        if (!nextKing2) {
+          return {
+            nextKing: "none",
+            nextAction: "end",
+            game
+          };
+        }
+        return {
+          nextKing: nextKing2.id,
+          nextAction: "place",
+          game
+        };
+      }
+      return {
+        nextKing: currentKingId,
+        nextAction: "pick",
+        game
+      };
+    }
+    const allKingsHavePicked = kings.every((king) => king.hasPick);
+    if (allKingsHavePicked) {
+      const newState = prepareNextTurn(game);
+      return {
+        nextKing: newState.order["1"],
+        nextAction: "place",
+        game: newState
+      };
+    }
+    const nextKing = kings.find((king) => !king.hasPlace);
+    return {
+      nextKing: nextKing.id,
+      nextAction: "place",
+      game
+    };
+  };
+  const endGame = (game) => {
+    const players = game.players;
+    const scores = [];
+    for (let player of players) {
+      const score = calculateScore2(player.kingdom);
+      scores.push({
+        playerId: player.id,
+        playerName: player.name,
+        details: score
+      });
+    }
+    const finalResult = result(scores);
+    return {
+      result: finalResult,
+      game
+    };
+  };
+  return {
+    init: init2,
+    getMode,
+    setMode,
+    getRules,
+    setRules,
+    start,
+    pass: passTurn,
+    placeDomino: placeDomino2,
+    pickDomino,
+    endGame
+  };
+};
+var engine_default = gameEngine;
+
+// src/index.ts
+var src_default = engine_default;
+export {
+  src_default as default
+};
+//# sourceMappingURL=index.js.map