More TP work

src/events/zone/characterMoveEvent.ts

@@ -1,13 +1,19 @@
 import { Server } from 'socket.io'
 import { TSocket, ExtendedCharacter } from '../../utilities/types'
 import { CharacterMoveService } from '../../services/character/characterMoveService'
-import { TeleportService } from '../../services/character/teleportService'
-import { MovementValidator } from '../../services/character/movementValidator'
+import { ZoneEventTileService } from '../../services/zoneEventTileService'
+import { MovementValidator } from '../../utilities/movementValidator'
 import { SocketEmitter } from '../../utilities/socketEmitter'
+import prisma from '../../utilities/prisma'
+import { ZoneEventTile, ZoneEventTileTeleport } from '@prisma/client'
+
+type ZoneEventTileWithTeleport = ZoneEventTile & {
+  teleport: ZoneEventTileTeleport | null
+}
 
 export default class CharacterMoveEvent {
   private characterMoveService: CharacterMoveService
-  private teleportService: TeleportService
+  private zoneEventTileService: ZoneEventTileService
   private movementValidator: MovementValidator
   private socketEmitter: SocketEmitter
 
@@ -16,7 +22,7 @@ export default class CharacterMoveEvent {
     private readonly socket: TSocket
   ) {
     this.characterMoveService = new CharacterMoveService()
-    this.teleportService = new TeleportService()
+    this.zoneEventTileService = new ZoneEventTileService()
     this.movementValidator = new MovementValidator()
     this.socketEmitter = new SocketEmitter(io, socket)
   }
@@ -47,11 +53,18 @@ export default class CharacterMoveEvent {
         break
       }
 
-      const teleport = await this.teleportService.checkForTeleport(character, position)
-      if (teleport) {
-        await this.characterMoveService.updatePosition(character, position, teleport.toZoneId)
-        await this.teleportService.handleTeleport(this.socket, character, teleport)
-        break
+      const zoneEventTile = await prisma.zoneEventTile.findFirst({
+        where: {
+          zoneId: character.zoneId,
+          type: 'TELEPORT',
+          positionX: Math.floor(position.x),
+          positionY: Math.floor(position.y)
+        },
+        include: { teleport: true }
+      }) as ZoneEventTileWithTeleport | null
+
+      if (zoneEventTile) {
+        await this.handleZoneEventTile(zoneEventTile)
       }
 
       await this.characterMoveService.updatePosition(character, position)
@@ -63,6 +76,21 @@ export default class CharacterMoveEvent {
     this.finalizeMovement(character)
   }
 
+  private async handleZoneEventTile(zoneEventTile: ZoneEventTileWithTeleport): Promise<void> {
+    const { character } = this.socket
+    if (!character) {
+      console.error('character:move error', 'Character not found')
+      return
+    }
+
+    const teleport = zoneEventTile.teleport
+    if (teleport) {
+      await this.characterMoveService.updatePosition(character, { x: teleport.toPositionX, y: teleport.toPositionY }, teleport.toZoneId)
+      await this.zoneEventTileService.handleTeleport(this.socket, character, teleport)
+      return
+    }
+  }
+
   private finalizeMovement(character: ExtendedCharacter): void {
     character.isMoving = false
     this.socketEmitter.emitCharacterMove(character)

src/services/character/characterMoveService.ts

@@ -10,6 +10,8 @@ export class CharacterMoveService {
   public async updatePosition(character: ExtendedCharacter, position: { x: number; y: number }, newZoneId?: number): Promise<void> {
     const oldZoneId = character.zoneId
 
+    console.log('newZoneId', newZoneId)
+
     Object.assign(character, {
       positionX: position.x,
       positionY: position.y,
@@ -30,7 +32,7 @@ export class CharacterMoveService {
         positionX: position.x,
         positionY: position.y,
         rotation: character.rotation,
-        zoneId: character.zoneId
+        zoneId: newZoneId
       }
     })
   }

src/services/character/teleportService.ts

@@ -1,37 +0,0 @@
-import { ExtendedCharacter, TSocket } from '../../utilities/types'
-import prisma from '../../utilities/prisma'
-import ZoneRepository from '../../repositories/zoneRepository'
-import ZoneManager from '../../managers/zoneManager'
-
-export class TeleportService {
-  public async checkForTeleport(character: ExtendedCharacter, position: { x: number; y: number }): Promise<any | null> {
-    return prisma.zoneEventTile.findFirst({
-      where: {
-        zoneId: character.zoneId,
-        type: 'TELEPORT',
-        positionX: Math.floor(position.x),
-        positionY: Math.floor(position.y)
-      },
-      include: { teleport: true }
-    })
-  }
-
-  public async handleTeleport(socket: TSocket, character: ExtendedCharacter, teleport: any): Promise<void> {
-    if (teleport.toZoneId === character.zoneId) return
-
-    const zone = await ZoneRepository.getById(teleport.toZoneId)
-    if (!zone) return
-
-    character.zoneId = teleport.toZoneId
-    character.positionX = teleport.toPositionX
-    character.positionY = teleport.toPositionY
-
-    socket.leave(character.zoneId.toString())
-    socket.join(teleport.toZoneId.toString())
-
-    socket.emit('zone:teleport', {
-      zone,
-      characters: ZoneManager.getCharactersInZone(zone.id)
-    })
-  }
-}

src/services/zoneEventTileService.ts

@@ -0,0 +1,26 @@
+import { ExtendedCharacter, TSocket } from '../utilities/types'
+import prisma from '../utilities/prisma'
+import ZoneRepository from '../repositories/zoneRepository'
+import ZoneManager from '../managers/zoneManager'
+import { ZoneEventTile, ZoneEventTileTeleport } from '@prisma/client'
+
+export class ZoneEventTileService {
+  public async handleTeleport(socket: TSocket, character: ExtendedCharacter, teleport: ZoneEventTileTeleport): Promise<void> {
+    if (teleport.toZoneId === character.zoneId) return
+
+    const zone = await ZoneRepository.getById(teleport.toZoneId)
+    if (!zone) return
+
+    character.zoneId = teleport.toZoneId
+    character.positionX = teleport.toPositionX
+    character.positionY = teleport.toPositionY
+
+    socket.leave(character.zoneId.toString())
+    socket.join(teleport.toZoneId.toString())
+
+    socket.emit('zone:teleport', {
+      zone,
+      characters: ZoneManager.getCharactersInZone(zone.id)
+    })
+  }
+}

src/utilities/movementValidator.ts

@@ -1,5 +1,5 @@
-import { ExtendedCharacter } from '../../utilities/types'
-import ZoneManager from '../../managers/zoneManager'
+import { ExtendedCharacter } from './types'
+import ZoneManager from '../managers/zoneManager'
 
 export class MovementValidator {
   public async isValidMove(character: ExtendedCharacter, position: { x: number; y: number }): Promise<boolean> {