Updated create and update calls to services

src/models/zoneCharacter.ts

@@ -1,5 +1,5 @@
 import { Character } from '@prisma/client'
-import prisma from '../utilities/prisma'
+import { CharacterService } from '../services/character/characterService'
 
 class ZoneCharacter {
   public readonly character: Character
@@ -11,15 +11,8 @@ class ZoneCharacter {
   }
 
   public async savePosition() {
-    await prisma.character.update({
+    const characterService = new CharacterService()
-      where: { id: this.character.id },
+    await characterService.updateCharacterPosition(this.character.id, this.character.positionX, this.character.positionY, this.character.rotation, this.character.zoneId)
-      data: {
-        positionX: this.character.positionX,
-        positionY: this.character.positionY,
-        rotation: this.character.rotation,
-        zoneId: this.character.zoneId
-      }
-    })
   }
 }
 

src/services/character/characterService.ts

@@ -1,15 +1,16 @@
 import { AStar } from '../../utilities/character/aStar'
 import ZoneManager from '../../managers/zoneManager'
+import prisma from '../../utilities/prisma'
 import Rotation from '../../utilities/character/rotation'
 import { gameLogger } from '../../utilities/logger'
-import { Character } from '@prisma/client'
+import { Character, CharacterGender, CharacterRace } from '@prisma/client'
 
 interface Position {
   x: number
   y: number
 }
 
-export class CharacterMoveService {
+export class CharacterService {
   private static readonly MOVEMENT_DELAY_MS = 250
 
   public updatePosition(character: Character, position: Position, newZoneId?: number): void {
@@ -48,10 +49,32 @@ export class CharacterMoveService {
   }
 
   public async applyMovementDelay(): Promise<void> {
-    await new Promise((resolve) => setTimeout(resolve, CharacterMoveService.MOVEMENT_DELAY_MS))
+    await new Promise((resolve) => setTimeout(resolve, CharacterService.MOVEMENT_DELAY_MS))
   }
 
   private isValidPosition(position: Position): boolean {
     return Number.isFinite(position.x) && Number.isFinite(position.y) && position.x >= 0 && position.y >= 0
   }
+
+  async create(name: string, userId: number) {
+    return prisma.character.create({
+      data: {
+        name,
+        userId
+        // characterTypeId: 1 // @TODO set to chosen character type
+      }
+    })
+  }
+
+  async updateCharacterPosition(id: number, positionX: number, positionY: number, rotation: number, zoneId: number) {
+    await prisma.character.update({
+      where: { id },
+      data: {
+        positionX,
+        positionY,
+        rotation,
+        zoneId
+      }
+    })
+  }
 }

src/socketEvents/character/create.ts

@@ -2,8 +2,8 @@ import { Server } from 'socket.io'
 import { TSocket } from '../../utilities/types'
 import { Character } from '@prisma/client'
 import CharacterRepository from '../../repositories/characterRepository'
+import { CharacterService } from '../../services/character/characterService'
 import { ZCharacterCreate } from '../../utilities/zodTypes'
-import prisma from '../../utilities/prisma'
 import { gameLogger } from '../../utilities/logger'
 import { ZodError } from 'zod'
 
@@ -38,13 +38,8 @@ export default class CharacterCreateEvent {
         return this.socket.emit('notification', { message: 'You can only have 4 characters' })
       }
 
-      const character: Character = await prisma.character.create({
+      const characterService = new CharacterService()
-        data: {
+      const character: Character = await characterService.create(data.name, user_id)
-          name: data.name,
-          userId: user_id
-          // characterTypeId: 1 // @TODO set to chosen character type
-        }
-      })
 
       characters = [...characters, character]
 

src/socketEvents/zone/characterMove.ts

@@ -1,8 +1,7 @@
 import { Server } from 'socket.io'
 import { TSocket, ZoneEventTileWithTeleport } from '../../utilities/types'
-import { CharacterMoveService } from '../../services/character/characterMoveService'
+import { CharacterService } from '../../services/character/characterService'
 import { ZoneEventTileService } from '../../services/zoneEventTileService'
-import prisma from '../../utilities/prisma'
 import Rotation from '../../utilities/character/rotation'
 import { gameLogger } from '../../utilities/logger'
 import ZoneManager from '../../managers/zoneManager'
@@ -10,7 +9,7 @@ import ZoneCharacter from '../../models/zoneCharacter'
 import zoneEventTileRepository from '../../repositories/zoneEventTileRepository'
 
 export default class CharacterMove {
-  private readonly characterMoveService = new CharacterMoveService()
+  private readonly characterService = new CharacterService()
   private readonly zoneEventTileService = new ZoneEventTileService()
 
   constructor(
@@ -35,7 +34,7 @@ export default class CharacterMove {
       await new Promise((resolve) => setTimeout(resolve, 100))
     }
 
-    const path = await this.characterMoveService.calculatePath(zoneCharacter.character, positionX, positionY)
+    const path = await this.characterService.calculatePath(zoneCharacter.character, positionX, positionY)
     if (!path) {
       this.io.in(zoneCharacter.character.zoneId.toString()).emit('character:moveError', 'No valid path found')
       return
@@ -67,9 +66,9 @@ export default class CharacterMove {
         break
       }
 
-      this.characterMoveService.updatePosition(character, end)
+      this.characterService.updatePosition(character, end)
       this.io.in(character.zoneId.toString()).emit('character:move', zoneCharacter)
-      await this.characterMoveService.applyMovementDelay()
+      await this.characterService.applyMovementDelay()
     }
 
     // Only finalize if this path wasn't interrupted