Improved folder structures for better maintainability

src/events/Disconnect.ts

@@ -0,0 +1,23 @@
+import { Server } from "socket.io";
+import {TSocket} from "../utilities/Types";
+import ZoneManager from "../managers/ZoneManager";
+
+export default function (socket: TSocket, io: Server) {
+    socket.on('disconnect', (data: any) => {
+        if (!socket.user) {
+            console.log('User disconnected but had no user set');
+            return;
+        }
+
+        io.emit('user:disconnect', socket.user.id);
+
+        if (!socket.character) {
+            console.log('User disconnected but had no character set');
+            return;
+        }
+
+        ZoneManager.removeCharacterFromZone(socket.character.zoneId, socket.character);
+
+        io.emit('character:disconnect', socket.character.id);
+    });
+}

src/events/Login.ts

@@ -0,0 +1,9 @@
+import { Server } from "socket.io";
+import {TSocket} from "../utilities/Types";
+
+export default function (socket: TSocket, io: Server) {
+    socket.on('login', () => {
+        // return user data
+        socket.emit('logged_in', {user: socket.user});
+    });
+}

src/events/character/CharacterConnect.ts

@@ -0,0 +1,20 @@
+import { Socket, Server } from "socket.io";
+import {TSocket} from "../../utilities/Types";
+import CharacterRepository from "../../repositories/CharacterRepository";
+import {Character, User} from "@prisma/client";
+
+type SocketResponseT = {
+    character_id: number
+}
+
+export default function (socket: TSocket, io: Server) {
+    socket.on('character:connect', async (data: SocketResponseT) => {
+        console.log('character:connect requested', data);
+        try {
+            socket.character = await CharacterRepository.getByUserAndId(socket.user?.id as number, data.character_id) as Character;
+            socket.emit('character:connect', socket.character)
+        } catch (error: any) {
+            console.log('character:connect error', error);
+        }
+    });
+}

src/events/character/CharacterCreate.ts

@@ -0,0 +1,37 @@
+import { Server } from "socket.io";
+import {TSocket} from "../../utilities/Types";
+import {Character} from "@prisma/client";
+import CharacterRepository from "../../repositories/CharacterRepository";
+import {ZCharacterCreate} from "../../utilities/ZodTypes";
+
+export default function (socket: TSocket, io: Server) {
+    socket.on('character:create', async (data: any) => {
+        // zod validate
+        try {
+            data = ZCharacterCreate.parse(data);
+
+            const user_id = socket.user?.id as number;
+
+            // Check if character name already exists
+            const characterExists = await CharacterRepository.getByName(data.name);
+
+            if (characterExists) {
+                return socket.emit('notification', {message: 'Character name already exists'});
+            }
+
+            let characters: Character[] = await CharacterRepository.getByUserId(user_id) as Character[];
+
+            if (characters.length >= 4) {
+                return socket.emit('notification', {message: 'You can only have 4 characters'});
+            }
+
+            const character: Character = await CharacterRepository.create(user_id, data.name, 'player') as Character;
+            characters = [...characters, character];
+
+            socket.emit('character:create:success');
+            socket.emit('character:list', characters);
+        } catch (error: any) {
+            return socket.emit('notification', {message: error.errors[0]?.message ?? 'Invalid data'});
+        }
+    });
+}

src/events/character/CharacterDelete.ts

@@ -0,0 +1,30 @@
+import {Server} from "socket.io";
+import {TSocket} from "../../utilities/Types";
+import { Character, Zone } from '@prisma/client'
+import CharacterRepository from "../../repositories/CharacterRepository";
+
+type TypePayload = {
+    character_id: number;
+}
+
+type TypeResponse = {
+    zone: Zone;
+    characters: Character[];
+}
+
+export default function (socket: TSocket, io: Server) {
+    socket.on('character:delete', async (data: TypePayload, callback: (response: TypeResponse) => void) => {
+        // zod validate
+        try {
+            await CharacterRepository.deleteByUserIdAndId(socket.user?.id as number, data.character_id as number);
+
+            const user_id = socket.user?.id as number;
+            const characters: Character[] = await CharacterRepository.getByUserId(user_id) as Character[];
+
+            socket.emit('character:list', characters);
+        } catch (error: any) {
+            console.log(error);
+            return socket.emit('notification', {message: 'Character delete failed. Please try again.'});
+        }
+    });
+}

src/events/character/CharacterList.ts

@@ -0,0 +1,17 @@
+import { Socket, Server } from "socket.io";
+import {TSocket} from "../../utilities/Types";
+import {Character} from "@prisma/client";
+import CharacterRepository from "../../repositories/CharacterRepository";
+
+export default function CharacterList(socket: TSocket, io: Server) {
+    socket.on('character:list', async (data: any) => {
+        try {
+            console.log('character:list requested');
+            const user_id = socket.user?.id as number;
+            const characters: Character[] = await CharacterRepository.getByUserId(user_id) as Character[];
+            socket.emit('character:list', characters);
+        } catch (error: any) {
+            console.log('character:list error', error);
+        }
+    });
+}

src/events/character/CharacterMove.ts

@@ -0,0 +1,33 @@
+import { Server } from "socket.io";
+import {TSocket} from "../../utilities/Types";
+import CharacterRepository from "../../repositories/CharacterRepository";
+import ZoneManager from "../../managers/ZoneManager";
+
+type SocketResponseT = {
+    position_x: number,
+    position_y: number,
+}
+
+export default function (socket: TSocket, io: Server) {
+    socket.on('character:move', async (data: SocketResponseT) => {
+        try {
+            console.log('character:move requested', data);
+
+            if (!socket.character) {
+                console.log('character:move error', 'Character not found');
+                return;
+            }
+
+            socket.character.position_x = data.position_x;
+            socket.character.position_y = data.position_y;
+
+            await CharacterRepository.updatePosition(socket.character.id as number, data.position_x, data.position_y);
+            ZoneManager.updateCharacterInZone(socket.character.zoneId, socket.character);
+            console.log(socket.character);
+
+            io.in(socket.character.zoneId.toString()).emit('character:moved', socket.character);
+        } catch (error: any) {
+            console.log('character:move error', error);
+        }
+    });
+}

src/events/character/CharacterZoneLeave.ts

@@ -0,0 +1,48 @@
+import { Server } from "socket.io";
+import {TSocket} from "../../utilities/Types";
+import ZoneRepository from "../../repositories/ZoneRepository";
+import ZoneManager from "../../managers/ZoneManager";
+import {Character, Zone} from "@prisma/client";
+
+/**
+ * Handle character zone leave event
+ * @param socket
+ * @param io
+ */
+export default function (socket: TSocket, io: Server) {
+    socket.on('character:zone:leave', async () => {
+        console.log(`---Socket ${socket.character?.id} has leaved zone.`);
+
+        if (!socket.character) {
+            console.log('Socket leaved zone but had no character set');
+            return;
+        }
+
+        if (!socket.character.zoneId) {
+            console.log(`---Zone id not provided.`);
+            return;
+        }
+
+        const zone = await ZoneRepository.getById(socket.character.zoneId);
+
+        if (!zone) {
+            console.log(`---Zone not found.`);
+            return;
+        }
+
+        socket.leave(zone.id.toString());
+
+        socket.emit('character:zone:unload');
+
+        // let other clients know of new character
+        io.to(zone.id.toString()).emit('zone:character:leave', socket.character);
+
+        // add character to zone manager
+        ZoneManager.removeCharacterFromZone(zone.id, socket.character as Character);
+    });
+}
+
+/**
+ * Resources:
+ * https://stackoverflow.com/questions/6873607/socket-io-rooms-difference-between-broadcast-to-and-sockets-in
+ */

src/events/character/CharacterZoneRequest.ts

@@ -0,0 +1,48 @@
+import { Server } from "socket.io";
+import {TSocket} from "../../utilities/Types";
+import ZoneRepository from "../../repositories/ZoneRepository";
+import ZoneManager from "../../managers/ZoneManager";
+import {Character, Zone} from "@prisma/client";
+
+interface IPayload {
+    zoneId: number;
+}
+
+interface IResponse {
+    zone: Zone;
+    characters: Character[];
+}
+
+/**
+ * Handle character zone request event
+ * @param socket
+ * @param io
+ */
+export default function (socket: TSocket, io: Server) {
+    socket.on('character:zone:request', async (data: IPayload, callback: (response: IResponse) => void) => {
+        console.log(`---User ${socket.character?.id} has requested zone.`);
+
+        if (!data.zoneId) {
+            console.log(`---Zone id not provided.`);
+            return;
+        }
+
+        const zone = await ZoneRepository.getById(data.zoneId);
+
+        if (!zone) {
+            console.log(`---Zone not found.`);
+            return;
+        }
+
+        socket.join(zone.id.toString());
+
+        // send over zone and characters to socket
+        callback({zone, characters: ZoneManager.getCharactersInZone(zone.id)});
+
+        // let other clients know of new character
+        io.to(zone.id.toString()).emit('zone:character:join', socket.character);
+
+        // add character to zone manager
+        ZoneManager.addCharacterToZone(zone.id, socket.character as Character);
+    });
+}

src/events/gm/object/GmObjectList.ts

@@ -0,0 +1,26 @@
+import { Server } from "socket.io";
+import {TSocket} from "../../../utilities/Types";
+import { Object } from '@prisma/client'
+import ObjectRepository from '../../../repositories/ObjectRepository'
+
+interface IPayload {
+}
+
+/**
+ * Handle game master list object event
+ * @param socket
+ * @param io
+ */
+export default function (socket: TSocket, io: Server) {
+    socket.on('gm:object:list', async (data: any, callback: (response: Object[]) => void) => {
+
+        if (socket.character?.role !== 'gm') {
+            console.log(`---Character #${socket.character?.id} is not a game master.`);
+            return;
+        }
+
+        // get all objects
+        const objects = await ObjectRepository.getAll();
+        callback(objects);
+    });
+}

src/events/gm/object/GmObjectRemove.ts

@@ -0,0 +1,45 @@
+import { Server } from "socket.io";
+import {TSocket} from "../../../utilities/Types";
+import path from "path";
+import fs from "fs";
+import ObjectRepository from '../../../repositories/ObjectRepository'
+
+interface IPayload {
+    object: string;
+}
+
+/**
+ * Handle game master remove object event
+ * @param socket
+ * @param io
+ */
+export default function (socket: TSocket, io: Server) {
+    socket.on('gm:object:remove', async (data: IPayload, callback: (response: boolean) => void) => {
+
+        if (socket.character?.role !== 'gm') {
+            return;
+        }
+
+        try {
+            await ObjectRepository.delete(data.object);
+
+            // get root path
+            const public_folder = path.join(process.cwd(), 'public', 'objects');
+
+            // remove the tile from the disk
+            const finalFilePath = path.join(public_folder, data.object + '.png');
+            fs.unlink(finalFilePath, (err) => {
+                if (err) {
+                    console.log(err);
+                    callback(false);
+                    return;
+                }
+
+                callback(true);
+            });
+        } catch (e) {
+            console.log(e);
+            callback(false);
+        }
+    });
+}

src/events/gm/object/GmObjectUpdate.ts

@@ -0,0 +1,35 @@
+import { Server } from "socket.io";
+import {TSocket} from "../../../utilities/Types";
+import ObjectRepository from '../../../repositories/ObjectRepository'
+import { Object } from '@prisma/client'
+
+interface IPayload {
+  id: string;
+  name: string;
+  tags: string[];
+  origin_x: number;
+  origin_y: number;
+}
+
+/**
+ * Handle game master object update event
+ * @param socket
+ * @param io
+ */
+export default function (socket: TSocket, io: Server) {
+  socket.on('gm:object:update', async (data: IPayload, callback: (success: boolean) => void) => {
+
+    if (socket.character?.role !== 'gm') {
+      return;
+    }
+
+    try {
+      const object = await ObjectRepository.update(data.id, data.name, data.tags, data.origin_x, data.origin_y);
+
+      callback(true);
+    } catch (error) {
+      console.error(error);
+      callback(false);
+    }
+  });
+}

src/events/gm/object/GmObjectUpload.ts

@@ -0,0 +1,46 @@
+import { Server } from "socket.io";
+import { TSocket } from "../../../utilities/Types";
+import { writeFile } from "node:fs/promises";
+import path from "path";
+import fs from "fs/promises";
+import objectRepository from '../../../repositories/ObjectRepository'
+
+interface IObjectData {
+    [key: string]: Buffer;
+}
+
+/**
+ * Handle game master upload object event
+ * @param socket
+ * @param io
+ */
+export default function (socket: TSocket, io: Server) {
+    socket.on('gm:object:upload', async (data: IObjectData, callback: (response: boolean) => void) => {
+        try {
+            if (socket.character?.role !== 'gm') {
+                callback(false);
+                return;
+            }
+
+            const public_folder = path.join(process.cwd(), 'public', 'objects');
+
+            // Ensure the folder exists
+            await fs.mkdir(public_folder, { recursive: true });
+
+            const uploadPromises = Object.entries(data).map(async ([key, objectData]) => {
+                const object = await objectRepository.create('New object', 0, 0);
+                const uuid = object.id;
+                const filename = `${uuid}.png`;
+                const finalFilePath = path.join(public_folder, filename);
+                await writeFile(finalFilePath, objectData);
+            });
+
+            await Promise.all(uploadPromises);
+
+            callback(true);
+        } catch (error) {
+            console.error('Error uploading tile:', error);
+            callback(false);
+        }
+    });
+}

src/events/gm/sprite/List.ts

@@ -0,0 +1,26 @@
+import { Server } from "socket.io";
+import {TSocket} from "../../../utilities/Types";
+import { Sprite } from '@prisma/client'
+import SpriteRepository from '../../../repositories/SpriteRepository'
+
+interface IPayload {
+}
+
+/**
+ * Handle game master list sprite event
+ * @param socket
+ * @param io
+ */
+export default function (socket: TSocket, io: Server) {
+    socket.on('gm:sprite:list', async (data: any, callback: (response: Sprite[]) => void) => {
+
+        if (socket.character?.role !== 'gm') {
+            console.log(`---Character #${socket.character?.id} is not a game master.`);
+            return;
+        }
+
+        // get all sprites
+        const sprites = await SpriteRepository.getAll();
+        callback(sprites);
+    });
+}

src/events/gm/sprite/Remove.ts

@@ -0,0 +1,45 @@
+import { Server } from "socket.io";
+import {TSocket} from "../../../utilities/Types";
+import path from "path";
+import fs from "fs";
+import SpriteRepository from '../../../repositories/SpriteRepository'
+
+interface IPayload {
+    sprite: string;
+}
+
+/**
+ * Handle game master remove sprite event
+ * @param socket
+ * @param io
+ */
+export default function (socket: TSocket, io: Server) {
+    socket.on('gm:sprite:remove', async (data: IPayload, callback: (response: boolean) => void) => {
+
+        if (socket.character?.role !== 'gm') {
+            return;
+        }
+
+        try {
+            await SpriteRepository.delete(data.sprite);
+
+            // get root path
+            const public_folder = path.join(process.cwd(), 'public', 'sprites');
+
+            // remove the tile from the disk
+            const finalFilePath = path.join(public_folder, data.sprite + '.png');
+            fs.unlink(finalFilePath, (err) => {
+                if (err) {
+                    console.log(err);
+                    callback(false);
+                    return;
+                }
+
+                callback(true);
+            });
+        } catch (e) {
+            console.log(e);
+            callback(false);
+        }
+    });
+}

src/events/gm/sprite/Update.ts

@@ -0,0 +1,34 @@
+import { Server } from "socket.io";
+import {TSocket} from "../../../utilities/Types";
+import SpriteRepository from '../../../repositories/SpriteRepository'
+import { Sprite } from '@prisma/client'
+
+interface IPayload {
+  id: string;
+  name: string;
+  origin_x: number;
+  origin_y: number;
+}
+
+/**
+ * Handle game master sprite update event
+ * @param socket
+ * @param io
+ */
+export default function (socket: TSocket, io: Server) {
+  socket.on('gm:sprite:update', async (data: IPayload, callback: (success: boolean) => void) => {
+
+    if (socket.character?.role !== 'gm') {
+      return;
+    }
+
+    try {
+      const sprite = await SpriteRepository.update(data.id, data.name, data.origin_x, data.origin_y);
+
+      callback(true);
+    } catch (error) {
+      console.error(error);
+      callback(false);
+    }
+  });
+}

src/events/gm/sprite/Upload.ts

@@ -0,0 +1,46 @@
+import { Server } from "socket.io";
+import { TSocket } from "../../../utilities/Types";
+import { writeFile } from "node:fs/promises";
+import path from "path";
+import fs from "fs/promises";
+import spriteRepository from '../../../repositories/SpriteRepository'
+
+interface ISpriteData {
+    [key: string]: Buffer;
+}
+
+/**
+ * Handle game master upload sprite event
+ * @param socket
+ * @param io
+ */
+export default function (socket: TSocket, io: Server) {
+    socket.on('gm:sprite:upload', async (data: ISpriteData, callback: (response: boolean) => void) => {
+        try {
+            if (socket.character?.role !== 'gm') {
+                callback(false);
+                return;
+            }
+
+            const public_folder = path.join(process.cwd(), 'public', 'sprites');
+
+            // Ensure the folder exists
+            await fs.mkdir(public_folder, { recursive: true });
+
+            const uploadPromises = Object.entries(data).map(async ([key, spriteData]) => {
+                const sprite = await spriteRepository.create('New sprite', 0, 0);
+                const uuid = sprite.id;
+                const filename = `${uuid}.png`;
+                const finalFilePath = path.join(public_folder, filename);
+                await writeFile(finalFilePath, spriteData);
+            });
+
+            await Promise.all(uploadPromises);
+
+            callback(true);
+        } catch (error) {
+            console.error('Error uploading tile:', error);
+            callback(false);
+        }
+    });
+}

src/events/gm/tile/GmTileList.ts

@@ -0,0 +1,26 @@
+import { Server } from "socket.io";
+import {TSocket} from "../../../utilities/Types";
+import { Tile } from '@prisma/client'
+import TileRepository from '../../../repositories/TileRepository'
+
+interface IPayload {
+}
+
+/**
+ * Handle game master list tile event
+ * @param socket
+ * @param io
+ */
+export default function (socket: TSocket, io: Server) {
+    socket.on('gm:tile:list', async (data: any, callback: (response: Tile[]) => void) => {
+
+        if (socket.character?.role !== 'gm') {
+            console.log(`---Character #${socket.character?.id} is not a game master.`);
+            return;
+        }
+
+        // get all tiles
+        const tiles = await TileRepository.getAll();
+        callback(tiles);
+    });
+}

src/events/gm/tile/GmTileRemove.ts

@@ -0,0 +1,45 @@
+import { Server } from "socket.io";
+import {TSocket} from "../../../utilities/Types";
+import path from "path";
+import fs from "fs";
+import TileRepository from '../../../repositories/TileRepository'
+
+interface IPayload {
+    tile: string;
+}
+
+/**
+ * Handle game master remove tile event
+ * @param socket
+ * @param io
+ */
+export default function (socket: TSocket, io: Server) {
+    socket.on('gm:tile:remove', async (data: IPayload, callback: (response: boolean) => void) => {
+
+        if (socket.character?.role !== 'gm') {
+            return;
+        }
+
+        try {
+            await TileRepository.delete(data.tile);
+
+            // get root path
+            const public_folder = path.join(process.cwd(), 'public', 'tiles');
+
+            // remove the tile from the disk
+            const finalFilePath = path.join(public_folder, data.tile + '.png');
+            fs.unlink(finalFilePath, (err) => {
+                if (err) {
+                    console.log(err);
+                    callback(false);
+                    return;
+                }
+
+                callback(true);
+            });
+        } catch (e) {
+            console.log(e);
+            callback(false);
+        }
+    });
+}

src/events/gm/tile/GmTileUpdate.ts

@@ -0,0 +1,32 @@
+import { Server } from "socket.io";
+import {TSocket} from "../../../utilities/Types";
+import TileRepository from '../../../repositories/TileRepository'
+
+interface IPayload {
+  id: string;
+  name: string;
+  tags: string[];
+}
+
+/**
+ * Handle game master tile update event
+ * @param socket
+ * @param io
+ */
+export default function (socket: TSocket, io: Server) {
+  socket.on('gm:tile:update', async (data: IPayload, callback: (success: boolean) => void) => {
+
+    if (socket.character?.role !== 'gm') {
+      return;
+    }
+
+    try {
+      const Tile = await TileRepository.update(data.id, data.name, data.tags);
+
+      callback(true);
+    } catch (error) {
+      console.error(error);
+      callback(false);
+    }
+  });
+}

src/events/gm/tile/GmTileUpload.ts

@@ -0,0 +1,46 @@
+import { Server } from "socket.io";
+import { TSocket } from "../../../utilities/Types";
+import { writeFile } from "node:fs/promises";
+import path from "path";
+import fs from "fs/promises";
+import tileRepository from '../../../repositories/TileRepository'
+
+interface ITileData {
+    [key: string]: Buffer;
+}
+
+/**
+ * Handle game master upload tile event
+ * @param socket
+ * @param io
+ */
+export default function (socket: TSocket, io: Server) {
+    socket.on('gm:tile:upload', async (data: ITileData, callback: (response: boolean) => void) => {
+        try {
+            if (socket.character?.role !== 'gm') {
+                callback(false);
+                return;
+            }
+
+            const public_folder = path.join(process.cwd(), 'public', 'tiles');
+
+            // Ensure the folder exists
+            await fs.mkdir(public_folder, { recursive: true });
+
+            const uploadPromises = Object.entries(data).map(async ([key, tileData]) => {
+                const tile = await tileRepository.create('New tile');
+                const uuid = tile.id;
+                const filename = `${uuid}.png`;
+                const finalFilePath = path.join(public_folder, filename);
+                await writeFile(finalFilePath, tileData);
+            });
+
+            await Promise.all(uploadPromises);
+
+            callback(true);
+        } catch (error) {
+            console.error('Error uploading tile:', error);
+            callback(false);
+        }
+    });
+}

src/events/gm/zone/GmZoneEditorZoneCreate.ts

@@ -0,0 +1,45 @@
+import { Server } from "socket.io";
+import {TSocket} from "../../../utilities/Types";
+import ZoneRepository from "../../../repositories/ZoneRepository";
+import ZoneManager from "../../../managers/ZoneManager";
+import {Character, Zone} from "@prisma/client";
+
+interface IPayload {
+    name: string;
+    width: number;
+    height: number;
+}
+
+/**
+ * Handle game master zone create event
+ * @param socket
+ * @param io
+ */
+export default function (socket: TSocket, io: Server) {
+    socket.on('gm:zone_editor:zone:create', async (data: IPayload, callback: (response: Zone[]) => void) => {
+
+        if (socket.character?.role !== 'gm') {
+            console.log(`---Character #${socket.character?.id} is not a game master.`);
+            return;
+        }
+
+        console.log(`---GM ${socket.character?.id} has created a new zone via zone editor.`);
+        let zoneList: Zone[] = [];
+        try {
+            const zone = await ZoneRepository.create(
+              data.name,
+              data.width,
+              data.height,
+              Array.from({length: data.height}, () => Array.from({length: data.width}, () => 'blank_tile')),
+            );
+
+            zoneList = await ZoneRepository.getAll();
+            callback(zoneList);
+            // send over zone and characters to socket
+        } catch (e) {
+            console.error(e);
+            socket.emit('notification', {message: 'Failed to create zone.'});
+            callback(zoneList);
+        }
+    });
+}

src/events/gm/zone/GmZoneEditorZoneDelete.ts

@@ -0,0 +1,42 @@
+import { Server } from "socket.io";
+import {TSocket} from "../../../utilities/Types";
+import ZoneRepository from "../../../repositories/ZoneRepository";
+import ZoneManager from "../../../managers/ZoneManager";
+import {Character, Zone} from "@prisma/client";
+
+interface IPayload {
+    zoneId: number;
+}
+
+/**
+ * Handle game master zone delete event
+ * @param socket
+ * @param io
+ */
+export default function (socket: TSocket, io: Server) {
+    socket.on('gm:zone_editor:zone:delete', async (data: IPayload, callback: (response: boolean) => void) => {
+
+        if (socket.character?.role !== 'gm') {
+            console.log(`---Character #${socket.character?.id} is not a game master.`);
+            return;
+        }
+
+        console.log(`---GM ${socket.character?.id} has deleted a zone via zone editor.`);
+
+        try {
+            const zone = await ZoneRepository.getById(data.zoneId);
+
+            if (!zone) {
+                console.log(`---Zone not found.`);
+                return;
+            }
+
+            await ZoneRepository.delete(data.zoneId);
+
+            callback(true);
+        } catch (e) {
+            console.error(e);
+            callback(false);
+        }
+    });
+}

src/events/gm/zone/GmZoneEditorZoneList.ts

@@ -0,0 +1,31 @@
+import { Server } from "socket.io";
+import {TSocket} from '../../../utilities/Types'
+import { Zone } from '@prisma/client'
+import ZoneRepository from '../../../repositories/ZoneRepository'
+
+interface IPayload {}
+
+/**
+ * Handle game master list zones event
+ * @param socket
+ * @param io
+ */
+export default function (socket: TSocket, io: Server) {
+    socket.on('gm:zone_editor:zone:list', async (data: IPayload, callback: (response: Zone[]) => void) => {
+
+        if (socket.character?.role !== 'gm') {
+            console.log(`---Character #${socket.character?.id} is not a game master.`);
+            return;
+        }
+
+        console.log(`---GM ${socket.character?.id} has requested zone list via zone editor.`);
+
+        try {
+            const zones = await ZoneRepository.getAll();
+            callback(zones);
+        } catch (e) {
+            console.error(e);
+            callback([]);
+        }
+    });
+}

src/events/gm/zone/GmZoneEditorZoneRequest.ts

@@ -0,0 +1,42 @@
+import { Server } from "socket.io";
+import {TSocket} from "../../../utilities/Types";
+import ZoneRepository from "../../../repositories/ZoneRepository";
+import {Zone} from "@prisma/client";
+
+interface IPayload {
+    zoneId: number;
+}
+
+/**
+ * Handle game master zone request event
+ * @param socket
+ * @param io
+ */
+export default function (socket: TSocket, io: Server) {
+    socket.on('gm:zone_editor:zone:request', async (data: IPayload, callback: (response: Zone) => void) => {
+
+        if (socket.character?.role !== 'gm') {
+            return;
+        }
+
+        console.log(`---GM ${socket.character?.id} has requested zone via zone editor.`);
+
+        if (!data.zoneId) {
+            console.log(`---Zone id not provided.`);
+            return;
+        }
+
+        try {
+            const zone = await ZoneRepository.getById(data.zoneId);
+
+            if (!zone) {
+                console.log(`---Zone not found.`);
+                return;
+            }
+
+            callback(zone);
+        } catch (e) {
+            console.error(e);
+        }
+    });
+}

src/events/gm/zone/GmZoneEditorZoneUpdate.ts

@@ -0,0 +1,63 @@
+import { Server } from "socket.io";
+import {TSocket} from "../../../utilities/Types";
+import ZoneRepository from "../../../repositories/ZoneRepository";
+import ZoneManager from "../../../managers/ZoneManager";
+import { Character, Zone, ZoneEventTile, ZoneObject } from '@prisma/client'
+
+interface IPayload {
+    zoneId: number;
+    name: string;
+    width: number;
+    height: number;
+    tiles: string[][];
+    zoneEventTiles: ZoneEventTile[];
+    zoneObjects: ZoneObject[];
+}
+
+/**
+ * Handle game master zone update event
+ * @param socket
+ * @param io
+ */
+export default function (socket: TSocket, io: Server) {
+    socket.on('gm:zone_editor:zone:update', async (data: IPayload) => {
+
+        if (socket.character?.role !== 'gm') {
+            console.log(`---Character #${socket.character?.id} is not a game master.`);
+            return;
+        }
+
+        console.log(`---GM ${socket.character?.id} has updated zone via zone editor.`);
+
+        if (!data.zoneId) {
+            console.log(`---Zone id not provided.`);
+            return;
+        }
+
+        try {
+            let zone = await ZoneRepository.getById(data.zoneId);
+
+            if (!zone) {
+                console.log(`---Zone not found.`);
+                return;
+            }
+
+            await ZoneRepository.update(
+              data.zoneId,
+              data.name,
+              data.width,
+              data.height,
+              data.tiles,
+              data.zoneEventTiles,
+              data.zoneObjects
+            );
+
+            zone = await ZoneRepository.getById(data.zoneId);
+
+            // send over zone and characters to socket
+            socket.emit('gm:zone_editor:zone:load', zone);
+        } catch (error: any) {
+            console.log(`---Error updating zone: ${error.message}`);
+        }
+    });
+}