Implement Socket.io like provider using NestJS - socket.io

Question

I am new using NestJS, and I want to implement Socket.io like provider using NestJS.
I have this codes, but I am not sure how I need to do right the socket.module with provider:
socket.gateway.ts
import { Server } from 'socket.io';
import * as express from 'express';
import { createServer } from 'http';
import { WebSocketGateway, WebSocketServer } from '#nestjs/websockets';
import { Inject, Injectable } from '#nestjs/common';
const app = express();
const server = createServer(app);
const io = new Server(server);
interface IPlayer {
name: string;
position: { x: number; y: number; z: number };
rotation: { x: number; y: number; z: number };
health: number;
}
interface IEnemySpawnPoint {
position: { x: number; y: number; z: number };
rotation: { x: number; y: number; z: number };
}
#Injectable()
#WebSocketGateway()
export class SocketGateway {
#WebSocketServer()
SocketGateway(): void {
// global variables for the server
let enemies: IPlayer[] = [];
let playerSpawnPoints: IPlayer[] = [];
let clients: IPlayer[] = [];
io.on('connection', function (socket) {
let currentPlayer: IPlayer = {
name: 'unknown',
position: { x: 0, y: 0, z: 0 },
rotation: { x: 0, y: 0, z: 0 },
health: 0,
};
currentPlayer.name = 'unknown';
socket.on('player connect', function () {
console.log(currentPlayer.name + ' recv: player connect');
for (let i = 0; i < clients.length; i++) {
const playerConnected = {
name: clients[i].name,
position: clients[i].position,
rotation: clients[i].position,
health: clients[i].health,
};
// in your current game, we need to tell you about the other players.
socket.emit('other player connected', playerConnected);
console.log(
currentPlayer.name +
' emit: other player connected: ' +
JSON.stringify(playerConnected),
);
}
});
socket.on('play', function (data) {
console.log(
currentPlayer.name + ' recv: play: ' + JSON.stringify(data),
);
// if this is the first person to join the game init the enemies
let numberOfEnemies;
if (clients.length === 0) {
numberOfEnemies = data.enemySpawnPoints.length;
enemies = [];
data.enemySpawnPoints.forEach(function (
enemySpawnPoint: IEnemySpawnPoint,
) {
const enemy = {
name: guid(),
position: enemySpawnPoint.position,
rotation: enemySpawnPoint.rotation,
health: 100,
};
enemies.push(enemy);
});
playerSpawnPoints = [];
data.playerSpawnPoints.forEach(function (
_playerSpawnPoint: IEnemySpawnPoint,
) {
const playerSpawnPoint = {
name: guid(),
position: _playerSpawnPoint.position,
rotation: _playerSpawnPoint.rotation,
health: 100,
};
playerSpawnPoints.push(playerSpawnPoint);
});
}
const enemiesResponse = {
enemies: enemies,
};
// we always will send the enemies when the player joins
console.log(
currentPlayer.name +
' emit: enemies: ' +
JSON.stringify(enemiesResponse),
);
socket.emit('enemies', enemiesResponse);
const randomSpawnPoint =
playerSpawnPoints[
Math.floor(Math.random() * playerSpawnPoints.length)
];
currentPlayer = {
name: data.name,
position: randomSpawnPoint.position,
rotation: randomSpawnPoint.rotation,
health: 100,
};
clients.push(currentPlayer);
// in your current game, tell you that you have joined
console.log(
currentPlayer.name + ' emit: play: ' + JSON.stringify(currentPlayer),
);
socket.emit('play', currentPlayer);
// in your current game, we need to tell the other players about you.
socket.broadcast.emit('other player connected', currentPlayer);
});
socket.on('player move', function (data) {
console.log('recv: move: ' + JSON.stringify(data));
currentPlayer.position = data.position;
socket.broadcast.emit('player move', currentPlayer);
});
socket.on('player turn', function (data) {
console.log('recv: turn: ' + JSON.stringify(data));
currentPlayer.rotation = data.rotation;
socket.broadcast.emit('player turn', currentPlayer);
});
socket.on('player shoot', function () {
console.log(currentPlayer.name + ' recv: shoot');
const data = {
name: currentPlayer.name,
};
console.log(
currentPlayer.name + ' bcst: shoot: ' + JSON.stringify(data),
);
socket.emit('player shoot', data);
socket.broadcast.emit('player shoot', data);
});
socket.on('health', function (data) {
console.log(
currentPlayer.name + ' recv: health: ' + JSON.stringify(data),
);
// only change the health once, we can do this by checking the originating player
if (data.from === currentPlayer.name) {
let indexDamaged = 0;
if (!data.isEnemy) {
clients = clients.map(function (client, index) {
if (client.name === data.name) {
indexDamaged = index;
client.health -= data.healthChange;
}
return client;
});
} else {
enemies = enemies.map(function (enemy, index) {
if (enemy.name === data.name) {
indexDamaged = index;
enemy.health -= data.healthChange;
}
return enemy;
});
}
const response = {
name: !data.isEnemy
? clients[indexDamaged].name
: enemies[indexDamaged].name,
health: !data.isEnemy
? clients[indexDamaged].health
: enemies[indexDamaged].health,
};
console.log(
currentPlayer.name + ' bcst: health: ' + JSON.stringify(response),
);
socket.emit('health', response);
socket.broadcast.emit('health', response);
}
});
socket.on('message', function (message) {
console.log('message', message);
socket.emit('message', message);
});
socket.on('disconnect', function () {
console.log(
currentPlayer.name + ' recv: disconnect ' + currentPlayer.name,
);
socket.broadcast.emit('other player disconnected', currentPlayer);
console.log(
currentPlayer.name +
' bcst: other player disconnected ' +
JSON.stringify(currentPlayer),
);
for (let i = 0; i < clients.length; i++) {
if (clients[i].name === currentPlayer.name) {
clients.splice(i, 1);
}
}
});
});
console.log('--- server is running ...', process.env.PORT || 80);
function guid() {
function s4() {
return Math.floor((1 + Math.random()) * 0x10000)
.toString(16)
.substring(1);
}
return (
s4() +
s4() +
'-' +
s4() +
'-' +
s4() +
'-' +
s4() +
'-' +
s4() +
s4() +
s4()
);
}
}
}
socket.module.ts
import { Module } from '#nestjs/common';
import { SocketGateway } from '#src/socket/socket.gateway';
#Module({
providers: [
{
provide: 'SOCKET_CONNECTION',
useFactory: async (): Promise<SocketGateway> => {
return new SocketGateway();
},
},
],
})
export class SocketModule {}
main.ts
import { NestFactory } from '#nestjs/core';
import { AppModule } from './app.module';
import { Transport } from '#nestjs/microservices';
import { join } from 'path';
import helmet from 'helmet';
import { DocumentBuilder, SwaggerModule } from '#nestjs/swagger';
import * as dotenv from 'dotenv';
// import { Server } from 'http';
import { Server } from 'socket.io';
import * as express from 'express';
import { createServer } from 'http';
dotenv.config({ path: '.env' });
async function bootstrap(): Promise<void> {
const microservice = await NestFactory.createMicroservice(AppModule, {
transport: Transport.GRPC,
options: {
package: 'engine',
protoPath: join(__dirname, 'engine.proto'),
},
});
const app = await NestFactory.create(AppModule);
const config = new DocumentBuilder()
.setTitle('Engine')
.setDescription('The engine API description')
.setVersion('v1')
.build();
const document = SwaggerModule.createDocument(app, config);
SwaggerModule.setup('swagger', app, document);
const allowedOrigin = new RegExp(
JSON.parse(process.env.ALLOWED_ORIGIN).join('|'),
);
app.enableCors({
origin: allowedOrigin,
optionsSuccessStatus: 200,
});
app.use(helmet());
app.setGlobalPrefix('v1/api/', {
exclude: ['/health'],
});
await microservice.listen();
const expressApp = express();
const server = createServer(expressApp);
const io = new Server(server);
// set up the socket.io server to use the same port as the HTTP server
const PORT = process.env.PORT || 3000;
await app.listen(PORT);
}
bootstrap();
I tried many things but I thwy usually had errors, or didn't work. I am not sure if I did all right, so I will be glad to all kind of help and solutions.
I need to use socket.io, not websocket