everything

server/Game.js

@@ -0,0 +1,426 @@
+import { createPuzzle } from './Puzzle.js'
+import Geometry from './../common/Geometry.js'
+
+const GAMES = {}
+
+function exists(gameId) {
+  return (!!GAMES[gameId]) || false
+}
+
+async function createGame(gameId, targetTiles, image) {
+  GAMES[gameId] = {
+    puzzle: await createPuzzle(targetTiles, image),
+    players: {},
+
+    sockets: [],
+    evtInfos: {},
+  }
+}
+
+function addPlayer(gameId, playerId) {
+  GAMES[gameId].players[playerId] = {
+    id: playerId,
+    x: 0,
+    y: 0,
+    down: false
+  }
+  GAMES[gameId].evtInfos[playerId] = {
+    _last_mouse: null,
+    _last_mouse_down: null,
+  }
+}
+
+function addSocket(gameId, socket) {
+  const sockets = GAMES[gameId].sockets
+
+  if (!sockets.includes(socket)) {
+    sockets.push(socket)
+  }
+}
+
+function get(gameId) {
+  return GAMES[gameId]
+}
+
+function getSockets(gameId) {
+  return GAMES[gameId].sockets
+}
+
+function changePlayer(gameId, playerId, change) {
+  for (let k of Object.keys(change)) {
+    GAMES[gameId].players[playerId][k] = change[k]
+  }
+}
+
+function changeData(gameId, change) {
+  for (let k of Object.keys(change)) {
+    GAMES[gameId].puzzle.data[k] = change[k]
+  }
+}
+
+function changeTile(gameId, tileIdx, change) {
+  for (let k of Object.keys(change)) {
+    GAMES[gameId].puzzle.tiles[tileIdx][k] = change[k]
+  }
+}
+
+const getTile = (gameId, tileIdx) => {
+  return GAMES[gameId].puzzle.tiles[tileIdx]
+}
+
+const getTileGroup = (gameId, tileIdx) => {
+  const tile = getTile(gameId, tileIdx)
+  return tile.group
+}
+
+const getFinalTilePos = (gameId, tileIdx) => {
+  const info = GAMES[gameId].puzzle.info
+  const boardPos = {
+    x: (info.table.width - info.width) / 2,
+    y: (info.table.height - info.height) / 2
+  }
+  const srcPos = srcPosByTileIdx(gameId, tileIdx)
+  return Geometry.pointAdd(boardPos, srcPos)
+}
+
+const getTilePos = (gameId, tileIdx) => {
+  const tile = getTile(gameId, tileIdx)
+  return tile.pos
+}
+
+const getTileZIndex = (gameId, tileIdx) => {
+  const tile = getTile(gameId, tileIdx)
+  return tile.z
+}
+
+const getFirstOwnedTileIdx = (gameId, userId) => {
+  for (let t of GAMES[gameId].puzzle.tiles) {
+    if (t.owner === userId) {
+      return t.idx
+    }
+  }
+  return -1
+}
+
+const getMaxGroup = (gameId) => {
+  return GAMES[gameId].puzzle.data.maxGroup
+}
+
+const getMaxZIndex = (gameId) => {
+  return GAMES[gameId].puzzle.data.maxZ
+}
+
+const getMaxZIndexByTileIdxs = (gameId, tileIdxs) => {
+  let maxZ = 0
+  for (let tileIdx of tileIdxs) {
+    let tileZIndex = getTileZIndex(gameId, tileIdx)
+    if (tileZIndex > maxZ) {
+      maxZ = tileZIndex
+    }
+  }
+  return maxZ
+}
+
+function srcPosByTileIdx(gameId, tileIdx) {
+  const info = GAMES[gameId].puzzle.info
+
+  const c = info.coords[tileIdx]
+  const cx = c.x * info.tileSize
+  const cy = c.y * info.tileSize
+
+  return { x: cx, y: cy }
+}
+
+function getSurroundingTilesByIdx(gameId, tileIdx) {
+  const info = GAMES[gameId].puzzle.info
+
+  const _X = info.coords[tileIdx].x
+  const _Y = info.coords[tileIdx].y
+
+  return [
+    // top
+    (_Y > 0) ?                (tileIdx - info.tiles_x) : -1,
+    // right
+    (_X < info.tiles_x - 1) ? (tileIdx + 1)            : -1,
+    // bottom
+    (_Y < info.tiles_y - 1) ? (tileIdx + info.tiles_x) : -1,
+    // left
+    (_X > 0) ?                (tileIdx - 1)            : -1,
+  ]
+}
+
+const setTilesZIndex = (gameId, tileIdxs, zIndex) => {
+  for (let tilesIdx of tileIdxs) {
+    changeTile(gameId, tilesIdx, { z: zIndex })
+  }
+}
+
+const moveTileDiff = (gameId, tileIdx, diff) => {
+  const oldPos = getTilePos(gameId, tileIdx)
+  const pos = Geometry.pointAdd(oldPos, diff)
+  changeTile(gameId, tileIdx, { pos })
+}
+
+const moveTilesDiff = (gameId, tileIdxs, diff) => {
+  for (let tileIdx of tileIdxs) {
+    moveTileDiff(gameId, tileIdx, diff)
+  }
+}
+
+const finishTiles = (gameId, tileIdxs) => {
+  for (let tileIdx of tileIdxs) {
+    changeTile(gameId, tileIdx, { owner: -1, z: 1 })
+  }
+}
+
+const setTilesOwner = (gameId, tileIdxs, owner) => {
+  for (let tileIdx of tileIdxs) {
+    changeTile(gameId, tileIdx, { owner })
+  }
+}
+
+function pointInBounds(pt, rect) {
+  return pt.x >= rect.x
+    && pt.x <= rect.x + rect.w
+    && pt.y >= rect.y
+    && pt.y <= rect.y + rect.h
+}
+
+// get all grouped tiles for a tile
+function getGroupedTileIdxs(gameId, tileIdx) {
+  const tiles = GAMES[gameId].puzzle.tiles
+  const tile = tiles[tileIdx]
+
+  const grouped = []
+  if (tile.group) {
+    for (let other of tiles) {
+      if (other.group === tile.group) {
+        grouped.push(other.idx)
+      }
+    }
+  } else {
+    grouped.push(tile.idx)
+  }
+  return grouped
+}
+
+// Returns the index of the puzzle tile with the highest z index
+// that is not finished yet and that matches the position
+const freeTileIdxByPos = (gameId, pos) => {
+  let info = GAMES[gameId].puzzle.info
+  let tiles = GAMES[gameId].puzzle.tiles
+
+  let maxZ = -1
+  let tileIdx = -1
+  for (let idx = 0; idx < tiles.length; idx++) {
+    const tile = tiles[idx]
+    if (tile.owner !== 0) {
+      continue
+    }
+
+    const collisionRect = {
+      x: tile.pos.x,
+      y: tile.pos.y,
+      w: info.tileSize,
+      h: info.tileSize,
+    }
+    if (pointInBounds(pos, collisionRect)) {
+      if (maxZ === -1 || tile.z > maxZ) {
+        maxZ = tile.z
+        tileIdx = idx
+      }
+    }
+  }
+  return tileIdx
+}
+
+// determine if two tiles are grouped together
+const areGrouped = (gameId, tileIdx1, tileIdx2) => {
+  const g1 = getTileGroup(gameId, tileIdx1)
+  const g2 = getTileGroup(gameId, tileIdx2)
+  return g1 && g1 === g2
+}
+
+function handleInput(gameId, playerId, input) {
+  let puzzle = GAMES[gameId].puzzle
+  let players = GAMES[gameId].players
+  let evtInfo = GAMES[gameId].evtInfos[playerId]
+
+  let changes = []
+
+  const _dataChange = () => {
+    changes.push(['data', puzzle.data])
+  }
+
+  const _tileChange = (tileIdx) => {
+    changes.push(['tile', getTile(gameId, tileIdx)])
+  }
+
+  const _tileChanges = (tileIdxs) => {
+    for (let tileIdx of tileIdxs) {
+      _tileChange(tileIdx)
+    }
+  }
+
+  const _playerChange = () => {
+    changes.push(['player', players[playerId]])
+  }
+
+  // put both tiles (and their grouped tiles) in the same group
+  const groupTiles = (gameId, tileIdx1, tileIdx2) => {
+    let tiles = GAMES[gameId].puzzle.tiles
+    let group1 = getTileGroup(gameId, tileIdx1)
+    let group2 = getTileGroup(gameId, tileIdx2)
+
+    let group
+    let searchGroups = []
+    if (group1) {
+      searchGroups.push(group1)
+    }
+    if (group2) {
+      searchGroups.push(group2)
+    }
+    if (group1) {
+      group = group1
+    } else if (group2) {
+      group = group2
+    } else {
+      let maxGroup = getMaxGroup(gameId) + 1
+      changeData(gameId, { maxGroup })
+      _dataChange()
+      group = getMaxGroup(gameId)
+    }
+
+    changeTile(gameId, tileIdx1, { group })
+    _tileChange(tileIdx1)
+    changeTile(gameId, tileIdx2, { group })
+    _tileChange(tileIdx2)
+
+    // TODO: strange
+    if (searchGroups.length > 0) {
+      for (let tile of tiles) {
+        if (searchGroups.includes(tile.group)) {
+          changeTile(gameId, tile.idx, { group })
+          _tileChange(tile.idx)
+        }
+      }
+    }
+  }
+
+  let [type, x, y] = input
+  let pos = {x, y}
+  if (type === 'down') {
+    changePlayer(gameId, playerId, { down: true })
+    _playerChange()
+    evtInfo._last_mouse_down = pos
+
+    const tileIdxAtPos = freeTileIdxByPos(gameId, pos)
+    if (tileIdxAtPos >= 0) {
+      console.log('tile: ', tileIdxAtPos)
+      let maxZ = getMaxZIndex(gameId) + 1
+      changeData(gameId, { maxZ })
+      _dataChange()
+      const tileIdxs = getGroupedTileIdxs(gameId, tileIdxAtPos)
+      setTilesZIndex(gameId, tileIdxs, getMaxZIndex(gameId))
+      setTilesOwner(gameId, tileIdxs, playerId)
+      _tileChanges(tileIdxs)
+    }
+
+  } else if (type === 'move') {
+    changePlayer(gameId, playerId, pos)
+    _playerChange()
+
+    if (evtInfo._last_mouse_down !== null) {
+      let tileIdx = getFirstOwnedTileIdx(gameId, playerId)
+      if (tileIdx >= 0) {
+        const diffX = x - evtInfo._last_mouse_down.x
+        const diffY = y - evtInfo._last_mouse_down.y
+        const diff = { x: diffX, y: diffY }
+        const tileIdxs = getGroupedTileIdxs(gameId, tileIdx)
+        moveTilesDiff(gameId, tileIdxs, diff)
+        _tileChanges(tileIdxs)
+      }
+
+      evtInfo._last_mouse_down = pos
+    }
+  } else if (type === 'up') {
+    changePlayer(gameId, playerId, { down: false })
+    _playerChange()
+    evtInfo._last_mouse_down = null
+
+    let tileIdx = getFirstOwnedTileIdx(gameId, playerId)
+    if (tileIdx >= 0) {
+      // drop the tile(s)
+      let tileIdxs = getGroupedTileIdxs(gameId, tileIdx)
+      setTilesOwner(gameId, tileIdxs, 0)
+      _tileChanges(tileIdxs)
+
+      // Check if the tile was dropped near the final location
+      let tilePos = getTilePos(gameId, tileIdx)
+      let finalPos = getFinalTilePos(gameId, tileIdx)
+      if (Geometry.pointDistance(finalPos, tilePos) < puzzle.info.snapDistance) {
+        let diff = Geometry.pointSub(finalPos, tilePos)
+        // Snap the tile to the final destination
+        moveTilesDiff(gameId, tileIdxs, diff)
+        finishTiles(gameId, tileIdxs)
+        _tileChanges(tileIdxs)
+      } else {
+        // Snap to other tiles
+        const check = (gameId, tileIdx, otherTileIdx, off) => {
+          let info = GAMES[gameId].puzzle.info
+          if (otherTileIdx < 0) {
+            return false
+          }
+          if (areGrouped(gameId, tileIdx, otherTileIdx)) {
+            return false
+          }
+          const tilePos = getTilePos(gameId, tileIdx)
+          const dstPos = Geometry.pointAdd(
+            getTilePos(gameId, otherTileIdx),
+            {x: off[0] * info.tileSize, y: off[1] * info.tileSize}
+          )
+          if (Geometry.pointDistance(tilePos, dstPos) < info.snapDistance) {
+            let diff = Geometry.pointSub(dstPos, tilePos)
+            let tileIdxs = getGroupedTileIdxs(gameId, tileIdx)
+            moveTilesDiff(gameId, tileIdxs, diff)
+            groupTiles(gameId, tileIdx, otherTileIdx)
+            tileIdxs = getGroupedTileIdxs(gameId, tileIdx)
+            const zIndex = getMaxZIndexByTileIdxs(gameId, tileIdxs)
+            console.log('z:' , zIndex, tileIdxs)
+            setTilesZIndex(gameId, tileIdxs, zIndex)
+            _tileChanges(tileIdxs)
+            return true
+          }
+          return false
+        }
+
+        for (let tileIdxTmp of getGroupedTileIdxs(gameId, tileIdx)) {
+          let othersIdxs = getSurroundingTilesByIdx(gameId, tileIdxTmp)
+          if (
+            check(gameId, tileIdxTmp, othersIdxs[0], [0, 1]) // top
+            || check(gameId, tileIdxTmp, othersIdxs[1], [-1, 0]) // right
+            || check(gameId, tileIdxTmp, othersIdxs[2], [0, -1]) // bottom
+            || check(gameId, tileIdxTmp, othersIdxs[3], [1, 0]) // left
+          ) {
+            break
+          }
+        }
+      }
+    }
+  }
+  // console.log(mouse)
+  evtInfo._last_mouse = pos
+
+  return changes
+}
+
+
+export default {
+  createGame,
+  exists,
+  addPlayer,
+  addSocket,
+  get,
+  getSockets,
+  handleInput,
+}