Cleaned characterMove event, moved some of its logic into char. move service

package-lock.json

@@ -1932,9 +1932,9 @@
       }
     },
     "node_modules/bullmq": {
-      "version": "5.41.0",
+      "version": "5.41.1",
-      "resolved": "https://registry.npmjs.org/bullmq/-/bullmq-5.41.0.tgz",
+      "resolved": "https://registry.npmjs.org/bullmq/-/bullmq-5.41.1.tgz",
-      "integrity": "sha512-GGfKu2DHGIvbnMtQjR/82wvWsdCaGxN5JGR3pvKd1mkDI9DsWn8r0+pAzZ6Y4ImWXFaetaAqywOhv2Ik0R2m3g==",
+      "integrity": "sha512-bVQGR4ARM+wRJSw66114AKwO8SwS2ZF5TIvwQ9NL6Iepq6f8jnG8EjMMXL8J1pyR1eNz5bOikPeED/8ErLU6FQ==",
       "license": "MIT",
       "dependencies": {
         "cron-parser": "^4.9.0",

src/entities/base/mapObject.ts

@@ -14,7 +14,7 @@ export class BaseMapObject extends BaseEntity {
   tags: string[] = []
 
   @Property({ type: 'json' })
-  pivotPoints: { x: number; y: number; }[] = []
+  pivotPoints: { x: number; y: number }[] = []
 
   @Property({ type: 'decimal', precision: 10, scale: 2 })
   originX = 0
@@ -64,7 +64,7 @@ export class BaseMapObject extends BaseEntity {
     return this.tags
   }
 
-  setPivotPoints(pivotPoints: { x: number; y: number; }[]) {
+  setPivotPoints(pivotPoints: { x: number; y: number }[]) {
     this.pivotPoints = pivotPoints
     return this
   }

src/events/gameMaster/assetManager/mapObject/update.ts

@@ -7,7 +7,7 @@ type Payload = {
   id: UUID
   name: string
   tags: string[]
-  pivotPoints: { x: number; y: number; }[]
+  pivotPoints: { x: number; y: number }[]
   originX: number
   originY: number
   frameRate: number

src/events/map/characterMove.ts

@@ -1,12 +1,13 @@
 import { BaseEvent } from '@/application/base/baseEvent'
 import { SocketEvent } from '@/application/enums'
 import type { MapEventTileWithTeleport } from '@/application/types'
+import type { Character } from '@/entities/character'
 import MapManager from '@/managers/mapManager'
 import MapCharacter from '@/models/mapCharacter'
 import MapEventTileRepository from '@/repositories/mapEventTileRepository'
 import CharacterService from '@/services/characterMoveService'
+import characterMoveService from '@/services/characterMoveService'
 import TeleportService from '@/services/characterTeleportService'
-import type {Character} from "@/entities/character";
 
 export default class CharacterMove extends BaseEvent {
   private readonly characterService = CharacterService
@@ -116,7 +117,7 @@ export default class CharacterMove extends BaseEvent {
         currentTile = path[i]
         nextTile = path[i + 1]
 
-        if (!currentTile || !nextTile || !this.isValidStep(currentTile, nextTile)) {
+        if (!currentTile || !nextTile || !characterMoveService.isValidStep(currentTile, nextTile)) {
           return
         }
 
@@ -127,11 +128,11 @@ export default class CharacterMove extends BaseEvent {
           .setPositionY(nextTile.positionY)
 
         // Check for map events at the next tile
-        const mapEventTile = await this.checkMapEvents(character, nextTile)
+        const mapEventTile = await characterMoveService.checkMapEvents(character.getMap().getId(), nextTile)
         if (mapEventTile) {
           if (mapEventTile.type === 'BLOCK') break
           if (mapEventTile.type === 'TELEPORT' && mapEventTile.teleport) {
-            await this.handleTeleportMapEventTile(mapEventTile as MapEventTileWithTeleport)
+            await characterMoveService.handleTeleportMapEventTile(character.id, mapEventTile as MapEventTileWithTeleport)
             return
           }
         }
@@ -154,43 +155,12 @@ export default class CharacterMove extends BaseEvent {
         lastMoveTime = Date.now()
       }
     } finally {
-      if (mapCharacter.isMoving && mapCharacter.currentPath === path) {
+      if (mapCharacter.isMoving) {
         this.finalizeMovement(mapCharacter)
       }
     }
   }
 
-  private isValidStep(current: { positionX: number; positionY: number }, next: { positionX: number; positionY: number }): boolean {
-    return Math.abs(next.positionX - current.positionX) <= 1 && Math.abs(next.positionY - current.positionY) <= 1
-  }
-
-  private async checkMapEvents(character: any, nextTile: { positionX: number; positionY: number }) {
-    const mapEventTileRepository = new MapEventTileRepository()
-    return mapEventTileRepository.getEventTileByMapIdAndPosition(character.getMap().getId(), Math.floor(nextTile.positionX), Math.floor(nextTile.positionY))
-  }
-
-  private async handleTeleportMapEventTile(mapEventTile: MapEventTileWithTeleport): Promise<void> {
-    const teleport = mapEventTile.getTeleport()
-    if (teleport) {
-      await TeleportService.teleportCharacter(this.socket.characterId!, {
-        targetMapId: teleport.getToMap().getId(),
-        targetX: teleport.getToPositionX(),
-        targetY: teleport.getToPositionY(),
-        rotation: teleport.getToRotation()
-      })
-    }
-  }
-
-  private broadcastMovement(character: Character, isMoving: boolean): void {
-    this.io.in(character.map.id).emit(SocketEvent.MAP_CHARACTER_MOVE, {
-      characterId: character.id,
-      positionX: character.getPositionX(),
-      positionY: character.getPositionY(),
-      rotation: character.getRotation(),
-      isMoving
-    })
-  }
-
   private finalizeMovement(mapCharacter: MapCharacter): void {
     // Clear any existing timeout
     if (this.movementTimeout) {
@@ -212,4 +182,14 @@ export default class CharacterMove extends BaseEvent {
       }
     }, this.STEP_DELAY * 2) // Increased delay to ensure all movement processing is complete
   }
+
+  private broadcastMovement(character: Character, isMoving: boolean): void {
+    this.io.in(character.map.id).emit(SocketEvent.MAP_CHARACTER_MOVE, {
+      characterId: character.id,
+      positionX: character.getPositionX(),
+      positionY: character.getPositionY(),
+      rotation: character.getRotation(),
+      isMoving
+    })
+  }
 }

src/services/characterMoveService.ts

@@ -1,7 +1,10 @@
 import { BaseService } from '@/application/base/baseService'
 import config from '@/application/config'
+import type { MapEventTileWithTeleport, UUID } from '@/application/types'
 import { Character } from '@/entities/character'
 import MapManager from '@/managers/mapManager'
+import MapEventTileRepository from '@/repositories/mapEventTileRepository'
+import TeleportService from '@/services/characterTeleportService'
 
 type Position = { positionX: number; positionY: number }
 export type Node = Position & { parent?: Node; g: number; h: number; f: number }
@@ -225,6 +228,27 @@ class CharacterMoveService extends BaseService {
       .filter((pos) => this.isValidPosition(pos, grid, end))
   }
 
+  isValidStep(current: { positionX: number; positionY: number }, next: { positionX: number; positionY: number }): boolean {
+    return Math.abs(next.positionX - current.positionX) <= 1 && Math.abs(next.positionY - current.positionY) <= 1
+  }
+
+  async checkMapEvents(map_id: UUID, nextTile: { positionX: number; positionY: number }) {
+    const mapEventTileRepository = new MapEventTileRepository()
+    return mapEventTileRepository.getEventTileByMapIdAndPosition(map_id, nextTile.positionX, nextTile.positionY)
+  }
+
+  async handleTeleportMapEventTile(character_id: UUID, mapEventTile: MapEventTileWithTeleport): Promise<void> {
+    const teleport = mapEventTile.getTeleport()
+    if (teleport) {
+      await TeleportService.teleportCharacter(character_id, {
+        targetMapId: teleport.getToMap().getId(),
+        targetX: teleport.getToPositionX(),
+        targetY: teleport.getToPositionY(),
+        rotation: teleport.getToRotation()
+      })
+    }
+  }
+
   private isValidPosition(pos: Position, grid: number[][], end: Position): boolean {
     return (
       pos.positionX >= 0 &&
@@ -280,10 +304,6 @@ class CharacterMoveService extends BaseService {
       distance: requestDistance
     }
   }
-
-  public isValidStep(current: { positionX: number; positionY: number }, next: { positionX: number; positionY: number }): boolean {
-    return Math.abs(next.positionX - current.positionX) <= 1 && Math.abs(next.positionY - current.positionY) <= 1
-  }
 }
 
 export default new CharacterMoveService()