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

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)
+  }
+}