noxious/server
6
0
Fork 1
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Mass replace parameter order (socket,io)>(io,socket), worked on queueing system

Browse Source
This commit is contained in:
Dennis Postma
2024-09-21 23:54:52 +02:00
parent 10dc9df8a9
commit 9d6de8a1a9
36 changed files with 206 additions and 121 deletions
Download Patch File Download Diff File Expand all files Collapse all files

23
src/events/character/connect.ts
View File

@ -1,23 +0,0 @@
import { Server } from 'socket.io'
import { TSocket, ExtendedCharacter } from '../../utilities/types'
import CharacterRepository from '../../repositories/characterRepository'
import CharacterManager from '../../managers/characterManager'
type SocketResponseT = {
character_id: number
}
export default function (socket: TSocket, io: Server) {
socket.on('character:connect', async (data: SocketResponseT) => {
console.log('character:connect requested', data)
try {
const character = await CharacterRepository.getByUserAndId(socket?.user?.id as number, data.character_id);
if(!character) return;
socket.characterId = character.id;
CharacterManager.initCharacter(character as ExtendedCharacter);
socket.emit('character:connect', character)
} catch (error: any) {
console.log('character:connect error', error)
}
})
}

51
src/events/character/create.ts
View File

@ -1,51 +0,0 @@
import { Server } from 'socket.io'
import { TSocket } from '../../utilities/types'
import { Character } from '@prisma/client'
import CharacterRepository from '../../repositories/characterRepository'
import { ZCharacterCreate } from '../../utilities/zodTypes'
import prisma from '../../utilities/prisma'
import { gameLogger } from '../../utilities/logger'
export default function (socket: TSocket, io: Server) {
socket.on('character:create', async (data: any) => {
console.log('character:create requested', data)
// zod validate
try {
data = ZCharacterCreate.parse(data)
const user_id = socket.user?.id as number
// Check if character name already exists
const characterExists = await CharacterRepository.getByName(data.name)
if (characterExists) {
return socket.emit('notification', { message: 'Character name already exists' })
}
let characters: Character[] = (await CharacterRepository.getByUserId(user_id)) as Character[]
if (characters.length >= 4) {
return socket.emit('notification', { message: 'You can only have 4 characters' })
}
const character: Character = await prisma.character.create({
data: {
name: data.name,
userId: user_id
// characterTypeId: 1 // @TODO set to chosen character type
}
})
characters = [...characters, character]
socket.emit('character:create:success')
socket.emit('character:list', characters)
gameLogger.info('character:create success')
} catch (error: any) {
console.log(error)
gameLogger.error(`character:create error: ${error.message}`)
return socket.emit('notification', { message: 'Could not create character. Please try again (later).' })
}
})
}

30
src/events/character/delete.ts
View File

@ -1,30 +0,0 @@
import { Server } from 'socket.io'
import { TSocket } from '../../utilities/types'
import { Character, Zone } from '@prisma/client'
import CharacterRepository from '../../repositories/characterRepository'
type TypePayload = {
character_id: number
}
type TypeResponse = {
zone: Zone
characters: Character[]
}
export default function (socket: TSocket, io: Server) {
socket.on('character:delete', async (data: TypePayload, callback: (response: TypeResponse) => void) => {
// zod validate
try {
await CharacterRepository.deleteByUserIdAndId(socket.user?.id as number, data.character_id as number)
const user_id = socket.user?.id as number
const characters: Character[] = (await CharacterRepository.getByUserId(user_id)) as Character[]
socket.emit('character:list', characters)
} catch (error: any) {
console.log(error)
return socket.emit('notification', { message: 'Character delete failed. Please try again.' })
}
})
}

17
src/events/character/list.ts
View File

@ -1,17 +0,0 @@
import { Socket, Server } from 'socket.io'
import { TSocket } from '../../utilities/types'
import { Character } from '@prisma/client'
import CharacterRepository from '../../repositories/characterRepository'
export default function CharacterList(socket: TSocket, io: Server) {
socket.on('character:list', async (data: any) => {
try {
console.log('character:list requested')
const user_id = socket.user?.id as number
const characters: Character[] = (await CharacterRepository.getByUserId(user_id)) as Character[]
socket.emit('character:list', characters)
} catch (error: any) {
console.log('character:list error', error)
}
})
}

28
src/events/chat/gameMaster/alertCommand.ts
View File

@ -1,28 +0,0 @@
import { Server } from 'socket.io'
import { TSocket } from '../../../utilities/types'
import { getArgs, isCommand } from '../../../utilities/chat'
import CharacterRepository from '../../../repositories/characterRepository'
type TypePayload = {
message: string
}
export default function (socket: TSocket, io: Server) {
socket.on('chat:send_message', async (data: TypePayload, callback: (response: boolean) => void) => {
try {
if (!isCommand(data.message, 'alert')) return
const args = getArgs('alert', data.message)
if (!args) return
const character = await CharacterRepository.getByUserAndId(socket.user?.id as number, socket.characterId as number)
if (!character) return
io.emit('notification', { title: 'Message from GM', message: args.join(' ') })
callback(true)
} catch (error: any) {
console.log(`---Error sending message: ${error.message}`)
}
})
}

85
src/events/chat/gameMaster/teleportCommand.ts
View File

@ -1,85 +0,0 @@
import { Server } from 'socket.io'
import { TSocket } from '../../../utilities/types'
import { getArgs, isCommand } from '../../../utilities/chat'
import ZoneRepository from '../../../repositories/zoneRepository'
import CharacterManager from '../../../managers/characterManager'
import { gameMasterLogger } from '../../../utilities/logger'
type TypePayload = {
message: string
}
export default class TeleportCommandEvent {
constructor(
private readonly io: Server,
private readonly socket: TSocket
) {}
public listen(): void {
this.socket.on('chat:send_message', this.handleTeleportCommand.bind(this))
}
private async handleTeleportCommand(data: TypePayload, callback: (response: boolean) => void): Promise<void> {
try {
const character = CharacterManager.getCharacterFromSocket(this.socket);
if (!character) {
this.socket.emit('notification', { title: 'Server message', message: 'Character not found' })
return
}
if (!isCommand(data.message, 'teleport')) return
const args = getArgs('teleport', data.message)
if (!args || args.length !== 1) {
this.socket.emit('notification', { title: 'Server message', message: 'Usage: /teleport <zoneId>' })
return
}
const zoneId = parseInt(args[0], 10)
if (isNaN(zoneId)) {
this.socket.emit('notification', { title: 'Server message', message: 'Invalid zone ID' })
return
}
const zone = await ZoneRepository.getById(zoneId)
if (!zone) {
this.socket.emit('notification', { title: 'Server message', message: 'Zone not found' })
return
}
if (character.zoneId === zone.id) {
this.socket.emit('notification', { title: 'Server message', message: 'You are already in that zone' })
return
}
// Remove character from current zone
this.io.to(character.zoneId.toString()).emit('zone:character:leave', character.id)
this.socket.leave(character.zoneId.toString())
// Add character to new zone
this.io.to(zone.id.toString()).emit('zone:character:join', character)
this.socket.join(zone.id.toString())
character.zoneId = zone.id
character.positionX = 0
character.positionY = 0
character.resetMovement = true;
this.socket.emit('zone:character:teleport', {
zone,
characters: CharacterManager.getCharactersInZone(zone)
})
this.socket.emit('notification', { title: 'Server message', message: `You have been teleported to ${zone.name}` })
gameMasterLogger.info('teleport', `Character ${character.id} teleported to zone ${zone.id}`)
callback(true)
} catch (error: any) {
gameMasterLogger.error(`Error in teleport command: ${error.message}`)
this.socket.emit('notification', { title: 'Server message', message: 'An error occurred while teleporting' })
}
}
}

54
src/events/chat/sendMessage.ts
View File

@ -1,54 +0,0 @@
import { Server } from 'socket.io'
import { TSocket } from '../../utilities/types'
import CharacterRepository from '../../repositories/characterRepository'
import ZoneRepository from '../../repositories/zoneRepository'
import { isCommand } from '../../utilities/chat'
import { gameLogger } from '../../utilities/logger'
type TypePayload = {
message: string
}
export default class ChatMessageEvent {
constructor(
private readonly io: Server,
private readonly socket: TSocket
) {}
public listen(): void {
this.socket.on('chat:send_message', this.handleChatMessage.bind(this))
}
private async handleChatMessage(data: TypePayload, callback: (response: boolean) => void): Promise<void> {
try {
if (!data.message || isCommand(data.message)) {
callback(false)
return
}
const character = await CharacterRepository.getByUserAndId(this.socket.user?.id as number, this.socket.characterId as number)
if (!character) {
gameLogger.error('chat:send_message error', 'Character not found')
callback(false)
return
}
const zone = await ZoneRepository.getById(character.zoneId)
if (!zone) {
gameLogger.error('chat:send_message error', 'Zone not found')
callback(false)
return
}
callback(true)
this.io.to(zone.id.toString()).emit('chat:message', {
character: character,
message: data.message
})
} catch (error: any) {
gameLogger.error('chat:send_message error', error.message)
callback(false)
}
}
}

28
src/events/disconnect.ts
View File

@ -1,28 +0,0 @@
import { Server } from 'socket.io'
import { TSocket } from '../utilities/types'
import CharacterManager from '../managers/characterManager'
export default function (socket: TSocket, io: Server) {
socket.on('disconnect', async (data: any) => {
if (!socket.user) {
console.log('User disconnected but had no user set')
return
}
io.emit('user:disconnect', socket.user.id)
const character = CharacterManager.getCharacterFromSocket(socket);
if (!character) {
console.log('User disconnected but had no character set')
return
}
console.log('User disconnected along with their character')
await CharacterManager.removeCharacter(character)
io.in(character.zoneId.toString()).emit('zone:character:leave', character.id)
io.emit('character:disconnect', character.id)
})
}

28
src/events/gameMaster/assetManager/object/list.ts
View File

@ -1,28 +0,0 @@
import { Server } from 'socket.io'
import { TSocket } from '../../../../utilities/types'
import { Object } from '@prisma/client'
import ObjectRepository from '../../../../repositories/objectRepository'
import CharacterManager from '../../../../managers/characterManager'
import characterRepository from '../../../../repositories/characterRepository'
interface IPayload {}
/**
* Handle game master list object event
* @param socket
* @param io
*/
export default function (socket: TSocket, io: Server) {
socket.on('gm:object:list', async (data: any, callback: (response: Object[]) => void) => {
const character = await characterRepository.getById(socket.characterId as number);
if (!character) return callback([])
if (character.role !== 'gm') {
return callback([])
}
// get all objects
const objects = await ObjectRepository.getAll()
callback(objects)
})
}

53
src/events/gameMaster/assetManager/object/remove.ts
View File

@ -1,53 +0,0 @@
import { Server } from 'socket.io'
import { TSocket } from '../../../../utilities/types'
import path from 'path'
import fs from 'fs'
import prisma from '../../../../utilities/prisma'
import CharacterManager from '../../../../managers/characterManager'
import characterRepository from '../../../../repositories/characterRepository'
interface IPayload {
object: string
}
/**
* Handle game master remove object event
* @param socket
* @param io
*/
export default function (socket: TSocket, io: Server) {
socket.on('gm:object:remove', async (data: IPayload, callback: (response: boolean) => void) => {
const character = await characterRepository.getById(socket.characterId as number);
if (!character) return callback(false)
if (character.role !== 'gm') {
return callback(false)
}
try {
await prisma.object.delete({
where: {
id: data.object
}
})
// get root path
const public_folder = path.join(process.cwd(), 'public', 'objects')
// remove the tile from the disk
const finalFilePath = path.join(public_folder, data.object + '.png')
fs.unlink(finalFilePath, (err) => {
if (err) {
console.log(err)
callback(false)
return
}
callback(true)
})
} catch (e) {
console.log(e)
callback(false)
}
})
}

55
src/events/gameMaster/assetManager/object/update.ts
View File

@ -1,55 +0,0 @@
import { Server } from 'socket.io'
import { TSocket } from '../../../../utilities/types'
import prisma from '../../../../utilities/prisma'
import CharacterManager from '../../../../managers/characterManager'
import characterRepository from '../../../../repositories/characterRepository'
type Payload = {
id: string
name: string
tags: string[]
originX: number
originY: number
isAnimated: boolean
frameSpeed: number
frameWidth: number
frameHeight: number
}
/**
* Handle game master object update event
* @param socket
* @param io
*/
export default function (socket: TSocket, io: Server) {
socket.on('gm:object:update', async (data: Payload, callback: (success: boolean) => void) => {
const character = await characterRepository.getById(socket.characterId as number);
if (!character) return callback(false)
if (character.role !== 'gm') {
return callback(false)
}
try {
const object = await prisma.object.update({
where: {
id: data.id
},
data: {
name: data.name,
tags: data.tags,
originX: data.originX,
originY: data.originY,
isAnimated: data.isAnimated,
frameSpeed: data.frameSpeed,
frameWidth: data.frameWidth,
frameHeight: data.frameHeight
}
})
callback(true)
} catch (error) {
console.error(error)
callback(false)
}
})
}

71
src/events/gameMaster/assetManager/object/upload.ts
View File

@ -1,71 +0,0 @@
import { Server } from 'socket.io'
import { TSocket } from '../../../../utilities/types'
import { writeFile } from 'node:fs/promises'
import path from 'path'
import fs from 'fs/promises'
import prisma from '../../../../utilities/prisma'
import sharp from 'sharp'
import characterRepository from '../../../../repositories/characterRepository'
import { gameMasterLogger } from '../../../../utilities/logger'
interface IObjectData {
[key: string]: Buffer
}
export default class ObjectUploadEvent {
constructor(
private readonly io: Server,
private readonly socket: TSocket
) {}
public listen(): void {
this.socket.on('gm:object:upload', this.handleObjectUpload.bind(this))
}
private async handleObjectUpload(data: IObjectData, callback: (response: boolean) => void): Promise<void> {
try {
const character = await characterRepository.getById(this.socket.characterId as number);
if (!character) return callback(false)
if (character.role !== 'gm') {
return callback(false)
}
const public_folder = path.join(process.cwd(), 'public', 'objects')
// Ensure the folder exists
await fs.mkdir(public_folder, { recursive: true })
const uploadPromises = Object.entries(data).map(async ([key, objectData]) => {
// Get image dimensions
const metadata = await sharp(objectData).metadata()
const width = metadata.width || 0
const height = metadata.height || 0
const object = await prisma.object.create({
data: {
name: key,
tags: [],
originX: 0,
originY: 0,
frameWidth: width,
frameHeight: height
}
})
const uuid = object.id
const filename = `${uuid}.png`
const finalFilePath = path.join(public_folder, filename)
await writeFile(finalFilePath, objectData)
gameMasterLogger.info('gm:object:upload', `Object ${key} uploaded with id ${uuid}`)
})
await Promise.all(uploadPromises)
callback(true)
} catch (error: any) {
gameMasterLogger.error('gm:object:upload error', error.message)
callback(false)
}
}
}

46
src/events/gameMaster/assetManager/sprite/create.ts
View File

@ -1,46 +0,0 @@
import { Server } from 'socket.io'
import { TSocket } from '../../../../utilities/types'
import path from 'path'
import fs from 'fs/promises'
import prisma from '../../../../utilities/prisma'
import CharacterManager from '../../../../managers/characterManager'
import characterRepository from '../../../../repositories/characterRepository'
/**
* Handle game master new sprite event
* @param socket
* @param io
*/
export default function (socket: TSocket, io: Server) {
socket.on('gm:sprite:create', async (data: undefined, callback: (response: boolean) => void) => {
try {
const character = await characterRepository.getById(socket.characterId as number);
if (!character) return callback(false)
if (character.role !== 'gm') {
return callback(false)
}
const public_folder = path.join(process.cwd(), 'public', 'sprites')
// Ensure the folder exists
await fs.mkdir(public_folder, { recursive: true })
const sprite = await prisma.sprite.create({
data: {
name: 'New sprite'
}
})
const uuid = sprite.id
// Create folder with uuid
const sprite_folder = path.join(public_folder, uuid)
await fs.mkdir(sprite_folder, { recursive: true })
callback(true)
} catch (error) {
console.error('Error creating sprite:', error)
callback(false)
}
})
}

60
src/events/gameMaster/assetManager/sprite/delete.ts
View File

@ -1,60 +0,0 @@
import { Server } from 'socket.io'
import { TSocket } from '../../../../utilities/types'
import fs from 'fs'
import path from 'path'
import prisma from '../../../../utilities/prisma'
import CharacterManager from '../../../../managers/characterManager'
import { gameMasterLogger } from '../../../../utilities/logger'
type Payload = {
id: string
}
export default class GMSpriteDeleteEvent {
private readonly public_folder: string
constructor(
private readonly io: Server,
private readonly socket: TSocket
) {
this.public_folder = path.join(process.cwd(), 'public', 'sprites')
}
public listen(): void {
this.socket.on('gm:sprite:delete', this.handleSpriteDelete.bind(this))
}
private async handleSpriteDelete(data: Payload, callback: (response: boolean) => void): Promise<void> {
const character = CharacterManager.getCharacterFromSocket(this.socket);
if (character?.role !== 'gm') {
return callback(false)
}
try {
await this.deleteSpriteFolder(data.id)
await this.deleteSpriteFromDatabase(data.id)
gameMasterLogger.info(`Sprite ${data.id} deleted.`)
callback(true)
} catch (error: any) {
gameMasterLogger.error('gm:sprite:delete error', error.message)
callback(false)
}
}
private async deleteSpriteFolder(spriteId: string): Promise<void> {
const finalFilePath = path.join(this.public_folder, spriteId)
if (fs.existsSync(finalFilePath)) {
await fs.promises.rmdir(finalFilePath, { recursive: true })
}
}
private async deleteSpriteFromDatabase(spriteId: string): Promise<void> {
await prisma.sprite.delete({
where: {
id: spriteId
}
})
}
}

28
src/events/gameMaster/assetManager/sprite/list.ts
View File

@ -1,28 +0,0 @@
import { Server } from 'socket.io'
import { TSocket } from '../../../../utilities/types'
import { Sprite } from '@prisma/client'
import SpriteRepository from '../../../../repositories/spriteRepository'
import CharacterManager from '../../../../managers/characterManager'
import characterRepository from '../../../../repositories/characterRepository'
interface IPayload {}
/**
* Handle game master list sprite event
* @param socket
* @param io
*/
export default function (socket: TSocket, io: Server) {
socket.on('gm:sprite:list', async (data: any, callback: (response: Sprite[]) => void) => {
const character = await characterRepository.getById(socket.characterId as number);
if (!character) return callback([])
if (character.role !== 'gm') {
return callback([])
}
// get all sprites
const sprites = await SpriteRepository.getAll()
callback(sprites)
})
}

146
src/events/gameMaster/assetManager/sprite/update.ts
View File

@ -1,146 +0,0 @@
import { Server } from 'socket.io'
import { TSocket } from '../../../../utilities/types'
import prisma from '../../../../utilities/prisma'
import type { Prisma, SpriteAction } from '@prisma/client'
import path from 'path'
import { writeFile, mkdir } from 'node:fs/promises'
import sharp from 'sharp'
import CharacterManager from '../../../../managers/characterManager'
type SpriteActionInput = Omit<SpriteAction, 'id' | 'spriteId' | 'frameWidth' | 'frameHeight'> & {
sprites: string[]
}
type Payload = {
id: string
name: string
spriteActions: Prisma.JsonValue
}
interface ProcessedSpriteAction extends SpriteActionInput {
frameWidth: number
frameHeight: number
buffersWithDimensions: Array<{
buffer: Buffer
width: number | undefined
height: number | undefined
}>
}
export default function (socket: TSocket, io: Server) {
socket.on('gm:sprite:update', async (data: Payload, callback: (success: boolean) => void) => {
const character = CharacterManager.getCharacterFromSocket(socket);
if (character?.role !== 'gm') {
return callback(false)
}
try {
const parsedSpriteActions = validateSpriteActions(data.spriteActions)
const processedActions = await processSprites(parsedSpriteActions)
await updateDatabase(data.id, data.name, processedActions)
await saveSpritesToDisk(data.id, processedActions)
callback(true)
} catch (error) {
console.error('Error updating sprite:', error)
callback(false)
}
})
}
function validateSpriteActions(spriteActions: Prisma.JsonValue): SpriteActionInput[] {
try {
const parsed = JSON.parse(JSON.stringify(spriteActions)) as SpriteActionInput[]
if (!Array.isArray(parsed)) {
throw new Error('spriteActions is not an array')
}
return parsed
} catch (error) {
console.error('Error parsing spriteActions:', error)
throw error
}
}
async function processSprites(spriteActions: SpriteActionInput[]): Promise<ProcessedSpriteAction[]> {
return Promise.all(
spriteActions.map(async (spriteAction) => {
const { action, sprites } = spriteAction
if (!Array.isArray(sprites) || sprites.length === 0) {
throw new Error(`Invalid sprites array for action: ${action}`)
}
const buffersWithDimensions = await Promise.all(
sprites.map(async (sprite: string) => {
const buffer = Buffer.from(sprite.split(',')[1], 'base64')
const { width, height } = await sharp(buffer).metadata()
return { buffer, width, height }
})
)
const frameWidth = Math.max(...buffersWithDimensions.map((b) => b.width || 0))
const frameHeight = Math.max(...buffersWithDimensions.map((b) => b.height || 0))
return {
...spriteAction,
frameWidth,
frameHeight,
buffersWithDimensions
}
})
)
}
async function updateDatabase(id: string, name: string, processedActions: ProcessedSpriteAction[]) {
await prisma.sprite.update({
where: { id },
data: {
name,
spriteActions: {
deleteMany: { spriteId: id },
create: processedActions.map(({ action, sprites, originX, originY, isAnimated, isLooping, frameWidth, frameHeight, frameSpeed }) => ({
action,
sprites,
originX,
originY,
isAnimated,
isLooping,
frameWidth,
frameHeight,
frameSpeed
}))
}
}
})
}
async function saveSpritesToDisk(id: string, processedActions: ProcessedSpriteAction[]) {
const publicFolder = path.join(process.cwd(), 'public', 'sprites', id)
await mkdir(publicFolder, { recursive: true })
await Promise.all(
processedActions.map(async ({ action, buffersWithDimensions, frameWidth, frameHeight }) => {
const combinedImage = await sharp({
create: {
width: frameWidth * buffersWithDimensions.length,
height: frameHeight,
channels: 4,
background: { r: 0, g: 0, b: 0, alpha: 0 }
}
})
.composite(
buffersWithDimensions.map(({ buffer }, index) => ({
input: buffer,
left: index * frameWidth,
top: 0
}))
)
.png()
.toBuffer()
const filename = path.join(publicFolder, `${action}.png`)
await writeFile(filename, combinedImage)
})
)
}

67
src/events/gameMaster/assetManager/tile/delete.ts
View File

@ -1,67 +0,0 @@
import path from 'path'
import fs from 'fs/promises'
import { Server } from 'socket.io'
import { TSocket } from '../../../../utilities/types'
import prisma from '../../../../utilities/prisma'
import characterRepository from '../../../../repositories/characterRepository'
import { gameMasterLogger } from '../../../../utilities/logger'
type Payload = {
id: string
}
export default class GMTileDeleteEvent {
private readonly public_folder: string
constructor(
private readonly io: Server,
private readonly socket: TSocket
) {
this.public_folder = path.join(process.cwd(), 'public', 'tiles')
}
public listen(): void {
this.socket.on('gm:tile:delete', this.handleTileDelete.bind(this))
}
private async handleTileDelete(data: Payload, callback: (response: boolean) => void): Promise<void> {
const character = await characterRepository.getById(this.socket.characterId as number);
if (!character) return callback(false)
if (character.role !== 'gm') {
return
}
try {
gameMasterLogger.info(`Deleting tile ${data.id}`)
await this.deleteTileFromDatabase(data.id)
await this.deleteTileFile(data.id)
gameMasterLogger.info(`Tile ${data.id} deleted successfully.`)
callback(true)
} catch (error: any) {
gameMasterLogger.error('gm:tile:delete error', error.message)
callback(false)
}
}
private async deleteTileFromDatabase(tileId: string): Promise<void> {
await prisma.tile.delete({
where: {
id: tileId
}
})
}
private async deleteTileFile(tileId: string): Promise<void> {
const finalFilePath = path.join(this.public_folder, `${tileId}.png`)
try {
await fs.unlink(finalFilePath)
} catch (error: any) {
if (error.code !== 'ENOENT') {
throw error
}
gameMasterLogger.warn(`File ${finalFilePath} does not exist.`)
}
}
}

28
src/events/gameMaster/assetManager/tile/list.ts
View File

@ -1,28 +0,0 @@
import { Server } from 'socket.io'
import { TSocket } from '../../../../utilities/types'
import { Tile } from '@prisma/client'
import TileRepository from '../../../../repositories/tileRepository'
import CharacterManager from '../../../../managers/characterManager'
import characterRepository from '../../../../repositories/characterRepository'
interface IPayload {}
/**
* Handle game master list tile event
* @param socket
* @param io
*/
export default function (socket: TSocket, io: Server) {
socket.on('gm:tile:list', async (data: any, callback: (response: Tile[]) => void) => {
const character = await characterRepository.getById(socket.characterId as number);
if (!character) return
if (character.role !== 'gm') {
return
}
// get all tiles
const tiles = await TileRepository.getAll()
callback(tiles)
})
}

44
src/events/gameMaster/assetManager/tile/update.ts
View File

@ -1,44 +0,0 @@
import { Server } from 'socket.io'
import { TSocket } from '../../../../utilities/types'
import prisma from '../../../../utilities/prisma'
import CharacterManager from '../../../../managers/characterManager'
import characterRepository from '../../../../repositories/characterRepository'
type Payload = {
id: string
name: string
tags: string[]
}
/**
* Handle game master tile update event
* @param socket
* @param io
*/
export default function (socket: TSocket, io: Server) {
socket.on('gm:tile:update', async (data: Payload, callback: (success: boolean) => void) => {
const character = await characterRepository.getById(socket.characterId as number);
if (!character) return callback(false)
if (character.role !== 'gm') {
return
}
try {
const Tile = await prisma.tile.update({
where: {
id: data.id
},
data: {
name: data.name,
tags: data.tags
}
})
callback(true)
} catch (error) {
console.error(error)
callback(false)
}
})
}

54
src/events/gameMaster/assetManager/tile/upload.ts
View File

@ -1,54 +0,0 @@
import { Server } from 'socket.io'
import { TSocket } from '../../../../utilities/types'
import { writeFile } from 'node:fs/promises'
import path from 'path'
import fs from 'fs/promises'
import prisma from '../../../../utilities/prisma'
import characterRepository from '../../../../repositories/characterRepository'
import { gameMasterLogger } from '../../../../utilities/logger'
interface ITileData {
[key: string]: Buffer
}
/**
* Handle game master upload tile event
* @param socket
* @param io
*/
export default function (socket: TSocket, io: Server) {
socket.on('gm:tile:upload', async (data: ITileData, callback: (response: boolean) => void) => {
try {
const character = await characterRepository.getById(socket.characterId as number);
if (!character) return callback(false)
if (character.role !== 'gm') {
return
}
const public_folder = path.join(process.cwd(), 'public', 'tiles')
// Ensure the folder exists
await fs.mkdir(public_folder, { recursive: true })
const uploadPromises = Object.entries(data).map(async ([key, tileData]) => {
const tile = await prisma.tile.create({
data: {
name: 'New tile'
}
})
const uuid = tile.id
const filename = `${uuid}.png`
const finalFilePath = path.join(public_folder, filename)
await writeFile(finalFilePath, tileData)
})
await Promise.all(uploadPromises)
callback(true)
} catch (error) {
gameMasterLogger.error('Error uploading tile:', error)
callback(false)
}
})
}

52
src/events/gameMaster/zoneEditor/create.ts
View File

@ -1,52 +0,0 @@
import { Server } from 'socket.io'
import { TSocket } from '../../../utilities/types'
import ZoneRepository from '../../../repositories/zoneRepository'
import { Zone } from '@prisma/client'
import prisma from '../../../utilities/prisma'
import characterRepository from '../../../repositories/characterRepository'
import { gameMasterLogger } from '../../../utilities/logger'
type Payload = {
name: string
width: number
height: number
}
/**
* Handle game master zone create event
* @param socket
* @param io
*/
export default function (socket: TSocket, io: Server) {
socket.on('gm:zone_editor:zone:create', async (data: Payload, callback: (response: Zone[]) => void) => {
const character = await characterRepository.getById(socket.characterId as number);
if (!character) return
if (character.role !== 'gm') {
gameMasterLogger.info(`User ${character.id} tried to create zone but is not a game master.`)
return
}
gameMasterLogger.info(`User ${character.id} has created a new zone via zone editor.`)
let zoneList: Zone[] = []
try {
const zone = await prisma.zone.create({
data: {
name: data.name,
width: data.width,
height: data.height,
tiles: Array.from({ length: data.height }, () => Array.from({ length: data.width }, () => 'blank_tile'))
}
})
zoneList = await ZoneRepository.getAll()
callback(zoneList)
// send over zone and characters to socket
} catch (e) {
console.error(e)
socket.emit('notification', { message: 'Failed to create zoneEditor.' })
callback(zoneList)
}
})
}

49
src/events/gameMaster/zoneEditor/delete.ts
View File

@ -1,49 +0,0 @@
import { Server } from 'socket.io'
import { TSocket } from '../../../utilities/types'
import ZoneRepository from '../../../repositories/zoneRepository'
import prisma from '../../../utilities/prisma'
import characterRepository from '../../../repositories/characterRepository'
import { gameMasterLogger } from '../../../utilities/logger'
type Payload = {
zoneId: number
}
/**
* Handle game master zone delete event
* @param socket
* @param io
*/
export default function (socket: TSocket, io: Server) {
socket.on('gm:zone_editor:zone:delete', async (data: Payload, callback: (response: boolean) => void) => {
const character = await characterRepository.getById(socket.characterId as number);
if (!character) return
if (character.role !== 'gm') {
gameMasterLogger.info(`User ${character.id} tried to delete zone but is not a game master.`)
return
}
gameMasterLogger.info(`User ${character.id} has deleted a zone via zone editor.`)
try {
const zone = await ZoneRepository.getById(data.zoneId)
if (!zone) {
console.log(`---Zone not found.`)
return
}
await prisma.zone.delete({
where: {
id: data.zoneId
}
})
callback(true)
} catch (e) {
console.error(e)
callback(false)
}
})
}

35
src/events/gameMaster/zoneEditor/list.ts
View File

@ -1,35 +0,0 @@
import { Server } from 'socket.io'
import { TSocket } from '../../../utilities/types'
import { Zone } from '@prisma/client'
import ZoneRepository from '../../../repositories/zoneRepository'
import characterRepository from '../../../repositories/characterRepository'
import { gameMasterLogger } from '../../../utilities/logger'
interface IPayload {}
/**
* Handle game master list zones event
* @param socket
* @param io
*/
export default function (socket: TSocket, io: Server) {
socket.on('gm:zone_editor:zone:list', async (data: IPayload, callback: (response: Zone[]) => void) => {
const character = await characterRepository.getById(socket.characterId as number);
if (!character) return
if (character.role !== 'gm') {
gameMasterLogger.info(`User ${character.id} tried to list zones but is not a game master.`)
return
}
gameMasterLogger.info(`User ${character.id} has requested zone list via zone editor.`)
try {
const zones = await ZoneRepository.getAll()
callback(zones)
} catch (e) {
console.error(e)
callback([])
}
})
}

47
src/events/gameMaster/zoneEditor/request.ts
View File

@ -1,47 +0,0 @@
import { Server } from 'socket.io'
import { TSocket } from '../../../utilities/types'
import ZoneRepository from '../../../repositories/zoneRepository'
import { Zone } from '@prisma/client'
import characterRepository from '../../../repositories/characterRepository'
import { gameMasterLogger } from '../../../utilities/logger'
interface IPayload {
zoneId: number
}
/**
* Handle game master zone request event
* @param socket
* @param io
*/
export default function (socket: TSocket, io: Server) {
socket.on('gm:zone_editor:zone:request', async (data: IPayload, callback: (response: Zone) => void) => {
const character = await characterRepository.getById(socket.characterId as number);
if (!character) return
if (character.role !== 'gm') {
gameMasterLogger.info(`User ${character!.id} tried to request zone but is not a game master.`)
return
}
gameMasterLogger.info(`User ${character.id} has requested zone via zone editor.`)
if (!data.zoneId) {
gameMasterLogger.info(`User ${character.id} tried to request zone but did not provide a zone id.`)
return
}
try {
const zone = await ZoneRepository.getById(data.zoneId)
if (!zone) {
gameMasterLogger.info(`User ${character.id} tried to request zone ${data.zoneId} but it does not exist.`)
return
}
callback(zone)
} catch (e) {
console.error(e)
}
})
}

122
src/events/gameMaster/zoneEditor/update.ts
View File

@ -1,122 +0,0 @@
import { Server } from 'socket.io'
import { TSocket } from '../../../utilities/types'
import ZoneRepository from '../../../repositories/zoneRepository'
import { Zone, ZoneEventTileType, ZoneObject } from '@prisma/client'
import prisma from '../../../utilities/prisma'
import zoneManager from '../../../managers/zoneManager'
import characterRepository from '../../../repositories/characterRepository'
import { gameMasterLogger } from '../../../utilities/logger'
interface IPayload {
zoneId: number
name: string
width: number
height: number
tiles: string[][]
pvp: boolean
zoneEventTiles: {
type: ZoneEventTileType
positionX: number
positionY: number
teleport?: {
toZoneId: number
toPositionX: number
toPositionY: number
}
}[]
zoneObjects: ZoneObject[]
}
/**
* Handle game master zone update event
* @param socket
* @param io
*/
export default function (socket: TSocket, io: Server) {
socket.on('gm:zone_editor:zone:update', async (data: IPayload, callback: (response: Zone) => void) => {
const character = await characterRepository.getById(socket.characterId as number);
if (!character) return
if (character.role !== 'gm') {
gameMasterLogger.info(`User ${character.id} tried to update zone but is not a game master.`)
return
}
gameMasterLogger.info(`User ${character.id} has updated zone via zone editor.`)
if (!data.zoneId) {
gameMasterLogger.info(`User ${character.id} tried to update zone but did not provide a zone id.`)
return
}
try {
let zone = await ZoneRepository.getById(data.zoneId)
if (!zone) {
gameMasterLogger.info(`User ${character.id} tried to update zone ${data.zoneId} but it does not exist.`)
return
}
await prisma.zone.update({
where: {
id: data.zoneId
},
data: {
name: data.name,
width: data.width,
height: data.height,
tiles: data.tiles,
pvp: data.pvp,
zoneEventTiles: {
deleteMany: {
zoneId: data.zoneId // Ensure only event tiles related to the zone are deleted
},
// Save new zone event tiles
create: data.zoneEventTiles.map((zoneEventTile) => ({
type: zoneEventTile.type,
positionX: zoneEventTile.positionX,
positionY: zoneEventTile.positionY,
...(zoneEventTile.type === 'TELEPORT' && zoneEventTile.teleport
? {
teleport: {
create: {
toZoneId: zoneEventTile.teleport.toZoneId,
toPositionX: zoneEventTile.teleport.toPositionX,
toPositionY: zoneEventTile.teleport.toPositionY
}
}
}
: {})
}))
},
zoneObjects: {
deleteMany: {
zoneId: data.zoneId // Ensure only objects related to the zone are deleted
},
// Save new zone objects
create: data.zoneObjects.map((zoneObject) => ({
objectId: zoneObject.objectId,
depth: zoneObject.depth,
positionX: zoneObject.positionX,
positionY: zoneObject.positionY
}))
}
}
})
zone = await ZoneRepository.getById(data.zoneId)
if (!zone) {
gameMasterLogger.info(`User ${character.id} tried to update zone ${data.zoneId} but it does not exist.`)
return
}
callback(zone)
zoneManager.unloadZone(data.zoneId)
await zoneManager.loadZone(zone)
} catch (error: any) {
gameMasterLogger.error(`Error updating zone: ${error.message}`)
}
})
}

9
src/events/login.ts
View File

@ -1,9 +0,0 @@
import { Server } from 'socket.io'
import { TSocket } from '../utilities/types'
export default function (socket: TSocket, io: Server) {
socket.on('login', () => {
if (!socket.user) return
socket.emit('logged_in', { user: socket.user })
})
}

59
src/events/zone/characterJoin.ts
View File

@ -1,59 +0,0 @@
import { Server } from 'socket.io'
import { TSocket } from '../../utilities/types'
import ZoneRepository from '../../repositories/zoneRepository'
import { Character, Zone } from '@prisma/client'
import CharacterManager from '../../managers/characterManager'
import { gameLogger } from '../../utilities/logger'
interface IPayload {
// zoneId: number
}
interface IResponse {
zone: Zone
characters: Character[]
}
/**
* Handle character zone request event
* @param socket
* @param io
*/
export default function (socket: TSocket, io: Server) {
socket.on('zone:character:join', async (callback: (response: IResponse) => void) => {
try {
if (!socket.characterId) return
const character = CharacterManager.getCharacterFromSocket(socket);
if(!character) return
const zone = await ZoneRepository.getById(character.zoneId)
if (!zone) {
console.log(`---Zone not found.`)
return
}
if (character?.zoneId) {
socket.leave(character.zoneId.toString())
io.to(character.zoneId.toString()).emit('zone:character:leave', character)
}
socket.join(zone.id.toString())
// let other clients know of new character
io.to(zone.id.toString()).emit('zone:character:join', character)
// add character to zone manager
// ZoneManager.addCharacterToZone(zone.id, socket.character as Character)
// CharacterManager.initCharacter(character as ExtendedCharacter)
// ZoneManager.addCharacterToZone(zone.id, socket.character as Character)
// send over zone and characters to socket
callback({ zone, characters: CharacterManager.getCharactersInZone(zone) })
} catch (error: any) {
gameLogger.error(`Error requesting zone: ${error.message}`)
socket.disconnect()
}
})
}

50
src/events/zone/characterLeave.ts
View File

@ -1,50 +0,0 @@
import { Server } from 'socket.io'
import { TSocket } from '../../utilities/types'
import ZoneRepository from '../../repositories/zoneRepository'
import CharacterManager from '../../managers/characterManager'
import { gameLogger } from '../../utilities/logger'
export default class ZoneLeaveEvent {
constructor(
private readonly io: Server,
private readonly socket: TSocket
) {}
public listen(): void {
this.socket.on('zone:character:leave', this.handleZoneLeave.bind(this))
}
private async handleZoneLeave(): Promise<void> {
try {
const character = CharacterManager.getCharacterFromSocket(this.socket);
if (!character) {
gameLogger.error('zone:character:leave error', 'Character not found')
return
}
if (!character.zoneId) {
gameLogger.error('zone:character:leave error', 'Character not in a zone')
return
}
const zone = await ZoneRepository.getById(character.zoneId)
if (!zone) {
gameLogger.error('zone:character:leave error', 'Zone not found')
return
}
this.socket.leave(zone.id.toString())
// let other clients know of character leaving
this.io.to(zone.id.toString()).emit('zone:character:leave', character.id)
// remove character from zone manager
await CharacterManager.removeCharacter(character)
gameLogger.info('zone:character:leave', `Character ${character.id} left zone ${zone.id}`)
} catch (error: any) {
gameLogger.error('zone:character:leave error', error.message)
}
}
}

144
src/events/zone/characterMove.ts
View File

@ -1,144 +0,0 @@
import { Server } from 'socket.io'
import { TSocket, ExtendedCharacter } from '../../utilities/types'
import { CharacterMoveService } from '../../services/character/characterMoveService'
import { ZoneEventTileService } from '../../services/zoneEventTileService'
import prisma from '../../utilities/prisma'
import { ZoneEventTile, ZoneEventTileTeleport } from '@prisma/client'
import Rotation from '../../utilities/character/rotation'
import CharacterManager from '../../managers/characterManager'
import { gameLogger } from '../../utilities/logger'
import QueueManager from '../../managers/queueManager'
export type ZoneEventTileWithTeleport = ZoneEventTile & {
teleport: ZoneEventTileTeleport
}
export default class CharacterMove {
private characterMoveService: CharacterMoveService
private zoneEventTileService: ZoneEventTileService
private nextPath: { [index: number]: { x: number; y: number }[] } = []
private currentZoneId: {[index:number]: number} = []
constructor(
private readonly io: Server,
private readonly socket: TSocket
) {
this.characterMoveService = new CharacterMoveService()
this.zoneEventTileService = new ZoneEventTileService()
}
public listen(): void {
this.socket.on('character:initMove', this.handleCharacterMove.bind(this))
}
private async handleCharacterMove({ positionX, positionY }: { positionX: number; positionY: number }): Promise<void> {
let character = CharacterManager.getCharacterFromSocket(this.socket)
if (!character) {
gameLogger.error('character:move error', 'Character not found')
return
}
if (!character) {
gameLogger.error('character:move error', 'character has not been initialized?')
return
}
const path = await this.characterMoveService.calculatePath(character, positionX, positionY)
if (!path) {
this.io.in(character.zoneId.toString()).emit('character:moveError', 'No valid path found')
return
}
if (!character.isMoving && character.resetMovement) {
character.resetMovement = false
}
if (character.isMoving && !character.resetMovement) {
character.resetMovement = true
this.nextPath[character.id] = path
}
if (!character.isMoving && !character.resetMovement) {
character.isMoving = true
this.currentZoneId[character.id] = character.zoneId;
await this.moveAlongPath(character, path)
}
}
private async moveAlongPath(character: ExtendedCharacter, path: Array<{ x: number; y: number }>): Promise<void> {
for (let i = 0; i < path.length - 1; i++) {
const start = path[i]
const end = path[i + 1]
// if (!(await this.movementValidator.isValidMove(character, end))) {
// break
// }
if (CharacterManager.hasResetMovement(character)) {
break
}
character.rotation = Rotation.calculate(start.x, start.y, end.x, end.y)
const zoneEventTile = await prisma.zoneEventTile.findFirst({
where: {
zoneId: character.zoneId,
positionX: Math.floor(end.x),
positionY: Math.floor(end.y)
}
})
if (zoneEventTile) {
if (zoneEventTile.type === 'BLOCK') {
break
}
if (zoneEventTile.type === 'TELEPORT') {
const teleportTile = (await prisma.zoneEventTile.findFirst({
where: { id: zoneEventTile.id },
include: { teleport: true }
})) as ZoneEventTileWithTeleport
if (teleportTile) {
await this.handleZoneEventTile(teleportTile)
break
}
}
}
this.characterMoveService.updatePosition(character, end)
this.io.in(character.zoneId.toString()).emit('character:move', character)
await this.characterMoveService.applyMovementDelay()
}
if (CharacterManager.hasResetMovement(character)) {
character.resetMovement = false
if(this.currentZoneId[character.id] === character.zoneId) {
await this.moveAlongPath(character, this.nextPath[character.id])
} else {
delete this.currentZoneId[character.id];
character.isMoving = false;
}
} else {
this.finalizeMovement(character)
}
}
private async handleZoneEventTile(zoneEventTile: ZoneEventTileWithTeleport): Promise<void> {
const character = CharacterManager.getCharacterFromSocket(this.socket)
if (!character) {
gameLogger.error('character:move error', 'Character not found')
return
}
const teleport = zoneEventTile.teleport
if (teleport) {
await this.zoneEventTileService.handleTeleport(this.io, this.socket, character, teleport)
return
}
}
private finalizeMovement(character: ExtendedCharacter): void {
character.isMoving = false
this.io.in(character.zoneId.toString()).emit('character:move', character)
}
}