@k4la/library 1.0.0

package/lib/tictactoe.js

@@ -0,0 +1,164 @@
+/**
+ * @file lib/utils/tictactoe.js
+ * @description Utility functions for managing Tic Tac Toe game logic
+ * @author K4lameety
+ */
+
+const jimp = require('jimp')
+
+const gameData = {}
+
+const createSession = (id) => {
+  const grid = [0, 0, 0, 0, 0, 0, 0, 0, 0]
+
+  gameData[id] = {
+    id: id,
+    status: 'waiting',
+    players: [],
+    grid: grid,
+    turn: 0,
+    winner: null,
+    winningLine: []
+  }
+  return gameData[id]
+}
+
+const getSession = (id) => gameData[id] || false
+const deleteSession = (id) => delete gameData[id]
+
+const userJoin = (id, sender, name) => {
+  let session = getSession(id)
+  if (!session) session = createSession(id)
+  if (session.status === 'playing') return 'is_playing'
+  if (session.players.some(p => p.id === sender)) return 'already_joined'
+  if (session.players.length >= 2) return 'room_full'
+
+  let marker = session.players.length === 0 ? 'X' : 'O'
+  session.players.push({ id: sender, name: name, marker: marker })
+
+  if (session.players.length === 2) {
+    session.status = 'playing'
+  }
+
+  return 'success'
+}
+
+const fillBoard = (id, sender, index) => {
+  let session = getSession(id)
+  if (!session || session.status !== 'playing') return { status: 'error', msg: 'Invalid session' }
+
+  let playerIdx = session.players.findIndex(p => p.id === sender)
+  if (playerIdx !== session.turn) return { status: 'error', msg: 'Not your turn!' }
+
+  let idx = index - 1
+  if (idx < 0 || idx > 8) return { status: 'error', msg: 'Position 1-9' }
+  if (session.grid[idx] !== 0) return { status: 'error', msg: 'Box already filled' }
+
+  session.grid[idx] = session.players[playerIdx].marker
+
+  let win = checkWin(session.grid)
+  if (win) {
+    session.winner = session.players[playerIdx]
+    session.winningLine = win.line
+    return { status: 'win', winner: session.winner, line: win.line }
+  }
+
+  if (session.grid.every(x => x !== 0)) {
+    return { status: 'draw' }
+  }
+
+  session.turn = session.turn === 0 ? 1 : 0
+
+  return { status: 'success', next: session.players[session.turn] }
+}
+
+const checkWin = (grid) => {
+  const wins = [
+    [0, 1, 2], [3, 4, 5], [6, 7, 8],
+    [0, 3, 6], [1, 4, 7], [2, 5, 8],
+    [0, 4, 8], [2, 4, 6]
+  ]
+
+  for (let line of wins) {
+    if (grid[line[0]] !== 0 &&
+      grid[line[0]] === grid[line[1]] &&
+      grid[line[1]] === grid[line[2]]) {
+      return { winner: grid[line[0]], line: line }
+    }
+  }
+  return null
+}
+
+const canvas = async (id, sock) => {
+  let session = getSession(id)
+  if (!session) return null
+
+  let bg = new jimp(500, 600, 0xFFFFFFFF)
+
+  let font = await jimp.loadFont(jimp.FONT_SANS_32_BLACK)
+  let fontSmall = await jimp.loadFont(jimp.FONT_SANS_16_BLACK)
+
+  bg.scan(166, 50, 5, 400, (x, y, idx) => { bg.bitmap.data[idx] = 0; bg.bitmap.data[idx+1] = 0; bg.bitmap.data[idx+2] = 0; bg.bitmap.data[idx+3] = 255 })
+  bg.scan(332, 50, 5, 400, (x, y, idx) => { bg.bitmap.data[idx] = 0; bg.bitmap.data[idx+1] = 0; bg.bitmap.data[idx+2] = 0; bg.bitmap.data[idx+3] = 255 })
+  
+  bg.scan(50, 183, 400, 5, (x, y, idx) => { bg.bitmap.data[idx] = 0; bg.bitmap.data[idx+1] = 0; bg.bitmap.data[idx+2] = 0; bg.bitmap.data[idx+3] = 255 })
+  bg.scan(50, 316, 400, 5, (x, y, idx) => { bg.bitmap.data[idx] = 0; bg.bitmap.data[idx+1] = 0; bg.bitmap.data[idx+2] = 0; bg.bitmap.data[idx+3] = 255 })
+
+  const coords = [
+    [50, 50], [216, 50], [382, 50],
+    [50, 183], [216, 183], [382, 183],
+    [50, 316], [216, 316], [382, 316]
+  ]
+
+  for (let i = 0; i < 9; i++) {
+    if (session.grid[i] === 0) {
+      bg.print(fontSmall, coords[i][0] + 5, coords[i][1] + 5, `${i+1}`)
+    } else {
+      let marker = session.grid[i]
+      let player = session.players.find(p => p.marker === marker)
+
+      try {
+        let ppUrl = await sock.profilePictureUrl(player.id, 'image').catch(() => 'https://telegra.ph/file/24fa902ead26340f3df2c.png')
+        let pp = await jimp.read(ppUrl)
+
+        pp.resize(100, 100).circle()
+        bg.composite(pp, coords[i][0] + 30, coords[i][1] + 15)
+      } catch (e) {
+        bg.print(font, coords[i][0] + 60, coords[i][1] + 40, marker)
+      }
+    }
+  }
+
+  if (session.winningLine && session.winningLine.length > 0) {
+    let redBox = new jimp(160, 130, 0xFF000055)
+
+    for (let idx of session.winningLine) {
+      let x = coords[idx][0]
+      let y = coords[idx][1]
+      bg.composite(redBox, x, y)
+    }
+  }
+
+  let p1Name = session.players[0] ? session.players[0].name : "-"
+  let p2Name = session.players[1] ? session.players[1].name : "-"
+
+  bg.print(fontSmall, 20, 520, `X: ${p1Name}`)
+  bg.print(fontSmall, 20, 550, `O: ${p2Name}`)
+
+  let turnName = session.status === 'playing'
+    ? (session.winner ? `WINNER: ${session.winner.name}` : `Turn: ${session.players[session.turn].name}`)
+    : "Waiting for Players..."
+
+  bg.print(font, 80, 470, turnName)
+
+  return await bg.getBufferAsync(jimp.MIME_JPEG)
+}
+
+module.exports = {
+  createSession,
+  userJoin,
+  fillBoard,
+  getSession,
+  deleteSession,
+  canvas
+}

package/lib/ulartangga.js

@@ -0,0 +1,181 @@
+/**
+ * @file lib/utils/ulartangga.js
+ * @description Snake and Ladder game utilities
+ * @author K4lameety
+ */
+
+const jimp = require('jimp')
+
+const gameData = {}
+
+const BOARD_URL = "https://raw.githubusercontent.com/K4lameety/game-assets/main/snake-and-ladder/board.png" 
+
+const MAP_CONFIG = {
+    4: 14,
+    9: 31,
+    20: 38,
+    28: 84,
+    40: 59,
+    51: 67,
+    63: 81,
+    71: 91,
+
+    17: 7,
+    54: 34,
+    62: 19,
+    64: 60,
+    87: 24,
+    93: 73,
+    95: 75,
+    99: 78
+}
+
+const createSession = (id) => {
+    gameData[id] = {
+        id: id,
+        status: 'waiting',
+        players: [], 
+        turn: 0
+    }
+    return gameData[id]
+}
+
+const getSession = (id) => gameData[id] || false
+const deleteSession = (id) => delete gameData[id]
+
+const userJoin = (id, sender, name) => {
+    let session = getSession(id)
+    if (!session) session = createSession(id)
+    if (session.status === 'playing') return 'is_playing'
+    if (session.players.some(p => p.id === sender)) return 'already_joined'
+    if (session.players.length >= 4) return 'room_full' 
+
+    const colors = [0xFF0000FF, 0x00FF00FF, 0x0000FFFF, 0xFFFF00FF] 
+    let color = colors[session.players.length]
+
+    session.players.push({ id: sender, name: name, color: color, pos: 1 })
+    return 'success'
+}
+
+const startGame = (id) => {
+    let session = getSession(id)
+    if (!session || session.players.length < 2) return false
+    session.status = 'playing'
+    return true
+}
+
+const rollDice = (id, sender) => {
+    let session = getSession(id)
+    if (!session || session.status !== 'playing') return { status: 'error', msg: 'Session invalid' }
+    
+    let playerIdx = session.players.findIndex(p => p.id === sender)
+    if (playerIdx !== session.turn) return { status: 'error', msg: 'Not your turn!' }
+
+    let player = session.players[playerIdx]
+    
+    let dice = Math.floor(Math.random() * 6) + 1
+    let oldPos = player.pos
+    let newPos = oldPos + dice
+
+    if (newPos > 100) {
+        newPos = 100 - (newPos - 100) 
+    }
+
+    let message = `Dice: ${dice}. Moving to ${newPos}.`
+
+    if (MAP_CONFIG[newPos]) {
+        let dest = MAP_CONFIG[newPos]
+        if (dest > newPos) message += `\nClimbed LADDER! To ${dest}`
+        else message += `\nBitten by SNAKE! Down to ${dest}`
+        newPos = dest
+    }
+
+    player.pos = newPos
+
+    if (newPos === 100) {
+        return { status: 'win', winner: player }
+    }
+
+    session.turn = (session.turn + 1) % session.players.length
+
+    return { status: 'success', player, dice, message, next: session.players[session.turn] }
+}
+
+const canvas = async (id, sock) => {
+    let session = getSession(id)
+    if (!session) return null
+
+    let bg
+    try {
+        bg = await jimp.read(BOARD_URL)
+        bg.resize(600, 600)
+    } catch (e) {
+        console.log('Failed to load board image from URL')
+        bg = new jimp(600, 600, 0xFFFFFFFF)
+    }
+    
+    let layout = new jimp(600, 700, 0xFFFFFFFF)
+    layout.composite(bg, 0, 0)
+
+    let font = await jimp.loadFont(jimp.FONT_SANS_16_BLACK)
+    let fontBig = await jimp.loadFont(jimp.FONT_SANS_32_BLACK)
+
+    for (let p of session.players) {
+        let { x, y } = getCoord(p.pos)
+        
+        try {
+            let ppUrl = await sock.profilePictureUrl(p.id, 'image').catch(() => 'https://telegra.ph/file/24fa902ead26340f3df2c.png')
+            let pp = await jimp.read(ppUrl)
+            pp.resize(40, 40).circle()
+            
+            let border = new jimp(44, 44, p.color)
+            border.circle()
+            border.composite(pp, 2, 2)
+
+            let stackIndex = session.players.filter(pl => pl.pos === p.pos && session.players.indexOf(pl) < session.players.indexOf(p)).length
+            let offsetX = stackIndex * 10 
+            let offsetY = stackIndex * 5  
+            
+            layout.composite(border, x + 8 + offsetX, y + 8 + offsetY)
+
+        } catch (e) { }
+    }
+
+    let turnName = session.status === 'playing' 
+        ? `Turn: ${session.players[session.turn].name}` 
+        : "Waiting for Players..."
+    
+    let statusPos = session.players.map(p => `${p.name.slice(0,5)}: ${p.pos}`).join(' | ')
+    
+    layout.print(fontBig, 20, 610, turnName)
+    layout.print(font, 20, 660, statusPos)
+
+    return await layout.getBufferAsync(jimp.MIME_JPEG)
+}
+
+const getCoord = (pos) => {
+    if (pos < 1) pos = 1
+    if (pos > 100) pos = 100
+
+    let row = Math.floor((pos - 1) / 10) 
+    let col = (pos - 1) % 10 
+
+    if (row % 2 !== 0) {
+        col = 9 - col
+    }
+
+    let x = col * 60
+    let y = (9 - row) * 60
+
+    return { x, y }
+}
+
+module.exports = {
+    createSession,
+    userJoin,
+    startGame,
+    rollDice,
+    getSession,
+    deleteSession,
+    canvas
+}

package/lib/uno.js

@@ -0,0 +1,250 @@
+/**
+ * @file lib/utils/uno.js
+ * @description Utility functions for managing Uno game logic
+ * @author K4lameety
+ */
+
+const fs = require('fs')
+const jimp = require('jimp')
+
+const GITHUB_BASE_URL = "https://raw.githubusercontent.com/K4lameety/game-assets/main/uno/"
+
+const gameData = {}
+
+const shuffle = (array) => {
+  for (let i = array.length - 1; i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    [array[i], array[j]] = [array[j], array[i]]
+  }
+  return array
+}
+
+const mod = (n, m) => ((n % m) + m) % m
+
+const generateDeck = () => {
+  const colors = ['red', 'green', 'blue', 'yellow']
+  const numbers = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']
+  const actions = ['skip', 'reverse', 'draw2']
+  const wilds = ['wild', 'wild4']
+
+  let deck = []
+
+  colors.forEach(color => {
+    numbers.forEach(num => {
+      let count = (num === '0') ? 1 : 2
+      for (let i = 0; i < count; i++) {
+        deck.push({
+          color: color,
+          value: num,
+          id: `${num}_card_${color}`
+        })
+      }
+    })
+
+    actions.forEach(act => {
+      for (let i = 0; i < 2; i++) {
+        let idName = ''
+        if (act === 'skip') idName = `special_block_card_${color}`
+        if (act === 'reverse') idName = `special_revert_card_${color}`
+        if (act === 'draw2') idName = `special_2_card_${color}`
+
+        deck.push({
+          color: color,
+          value: act,
+          id: idName
+        })
+      }
+    })
+  })
+
+  wilds.forEach(wild => {
+    for (let i = 0; i < 4; i++) {
+      let idName = ''
+      if (wild === 'wild') idName = 'special_colorful_card'
+      if (wild === 'wild4') idName = 'special_4_card'
+
+      deck.push({
+        color: 'black',
+        value: wild,
+        id: idName
+      })
+    }
+  })
+
+  return shuffle(deck)
+}
+
+const createSession = (id) => {
+  gameData[id] = {
+    id: id,
+    status: 'waiting',
+    players: [],
+    deck: [],
+    pile: {},
+    turn: 0,
+    direction: 1,
+    currentColor: ''
+  }
+  return gameData[id]
+}
+
+const getSession = (id) => gameData[id] || false
+const deleteSession = (id) => delete gameData[id]
+
+const userJoin = (id, sender, name) => {
+  let session = getSession(id)
+  if (!session) session = createSession(id)
+  if (session.status === 'playing') return 'is_playing'
+  if (session.players.some(p => p.id === sender)) return 'already_joined'
+  session.players.push({ id: sender, name: name, hand: [] })
+  return 'success'
+}
+
+const startGame = (id) => {
+  let session = getSession(id)
+  if (!session || session.players.length < 2) return false
+
+  session.status = 'playing'
+  session.deck = generateDeck()
+  session.players.forEach(p => { p.hand = session.deck.splice(0, 7) })
+
+  let firstCard
+  do {
+    session.deck = shuffle(session.deck)
+    firstCard = session.deck.pop()
+  } while (firstCard.color === 'black')
+
+  session.pile = firstCard
+  session.currentColor = firstCard.color
+
+  return session
+}
+
+const playCard = (id, sender, index, wildColor = null) => {
+  let session = getSession(id)
+  if (!session) return { status: 'error', msg: 'No session' }
+
+  let player = session.players[session.turn]
+  if (player.id !== sender) return { status: 'error', msg: 'Not your turn' }
+  if (!player.hand[index]) return { status: 'error', msg: 'Card not found' }
+
+  let card = player.hand[index]
+  let top = session.pile
+
+  let valid = false
+  if (card.color === session.currentColor) valid = true
+  if (card.value === top.value) valid = true
+  if (card.color === 'black') valid = true
+
+  if (!valid) return { status: 'error', msg: 'Card does not match' }
+
+  player.hand.splice(index, 1)
+  session.pile = card
+
+  if (card.color === 'black') {
+    if (wildColor) wildColor = wildColor.toLowerCase()
+    if (!wildColor || !['red', 'green', 'blue', 'yellow'].includes(wildColor)) {
+      player.hand.push(card)
+      return { status: 'error', msg: 'Please specify the color! Example: .uno play 1 red' }
+    }
+    session.currentColor = wildColor
+  } else {
+    session.currentColor = card.color
+  }
+
+  if (player.hand.length === 0) return { status: 'win', winner: player }
+
+  let skip = 0
+
+  if (card.value === 'reverse') {
+    if (session.players.length === 2) skip = 1
+    else session.direction *= -1
+  }
+
+  if (card.value === 'skip') skip = 1
+
+  if (card.value === 'draw2') {
+    skip = 1
+    let victimIndex = mod(session.turn + session.direction, session.players.length)
+    session.players[victimIndex].hand.push(...session.deck.splice(0, 2))
+  }
+
+  if (card.value === 'wild4') {
+    skip = 1
+    let victimIndex = mod(session.turn + session.direction, session.players.length)
+    session.players[victimIndex].hand.push(...session.deck.splice(0, 4))
+  }
+
+  session.turn = mod(session.turn + (session.direction * (1 + skip)), session.players.length)
+  if (session.deck.length < 5) session.deck = [...session.deck, ...generateDeck()]
+
+  return { status: 'success', next: session.players[session.turn] }
+}
+
+const drawCard = (id, sender) => {
+  let session = getSession(id)
+  let player = session.players[session.turn]
+  if (player.id !== sender) return { status: 'error' }
+
+  let card = session.deck.pop()
+  player.hand.push(card)
+  session.turn = mod(session.turn + session.direction, session.players.length)
+
+  return { status: 'success', card: card, next: session.players[session.turn] }
+}
+
+const canvas = async (id, sender) => {
+  let session = getSession(id)
+  if (!session) return null
+  let player = session.players.find(p => p.id === sender)
+  if (!player) return null
+
+  let bg = new jimp(1200, 800, 0x222222FF)
+  let font = await jimp.loadFont(jimp.FONT_SANS_32_WHITE)
+
+  let pileUrl = `${GITHUB_BASE_URL}${session.pile.id}.png`
+
+  try {
+    let pileImg = await jimp.read(pileUrl)
+    pileImg.resize(180, 260)
+    bg.composite(pileImg, 510, 200)
+  } catch (e) {
+    bg.print(font, 510, 250, session.pile.value)
+  }
+
+  bg.print(font, 50, 50, `Color: ${session.currentColor.toUpperCase()}`)
+  bg.print(font, 50, 100, `Player: ${session.players[session.turn].name}`)
+  bg.print(font, 900, 50, `Direction: ${session.direction === 1 ? '>>' : '<<'}`)
+
+  let x = 50
+  let y = 500
+
+  for (let i = 0; i < player.hand.length; i++) {
+    let card = player.hand[i]
+    let cardUrl = `${GITHUB_BASE_URL}${card.id}.png`
+
+    try {
+      let cardImg = await jimp.read(cardUrl)
+      cardImg.resize(120, 175)
+      bg.composite(cardImg, x, y)
+      bg.print(font, x + 45, y - 40, `${i + 1}`)
+
+      x += 100
+      if (x > 1050) { x = 50; y += 190 }
+    } catch (e) {
+      bg.print(font, x, y, card.value)
+    }
+  }
+
+  return await bg.getBufferAsync(jimp.MIME_JPEG)
+}
+
+module.exports = {
+  userJoin,
+  startGame,
+  playCard,
+  drawCard,
+  getSession,
+  deleteSession,
+  canvas
+}