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

src/socketEvents/zone/characterJoin.ts

@@ -0,0 +1,59 @@
+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 (io: Server, socket: TSocket) {
+  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()
+    }
+  })
+}

src/socketEvents/zone/characterLeave.ts

@@ -0,0 +1,50 @@
+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)
+    }
+  }
+}

src/socketEvents/zone/characterMove.ts

@@ -0,0 +1,144 @@
+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)
+  }
+}