Javascript Socket IO |为客户端分配字符的最佳方式是什么_Javascript_Node.js_Socket.io

Javascript Socket IO |为客户端分配字符的最佳方式是什么

javascript node.js socket.io

Javascript Socket IO |为客户端分配字符的最佳方式是什么,javascript,node.js,socket.io,Javascript,Node.js,Socket.io,所以现在我正在制作一个游戏，每当有人连接时，我给他们的客户端一个号码，我的服务器用这个号码来区分不同的角色。字符是数组中的对象，因此id为“0”的客户端将控制数组中的第一个对象然而，我很难决定当这个人离开时该做什么 server.js // Setup basic express server var express = require('express'); var app = express(); var server = require('http').createServer(app)

所以现在我正在制作一个游戏，每当有人连接时，我给他们的客户端一个号码，我的服务器用这个号码来区分不同的角色。字符是数组中的对象，因此id为“0”的客户端将控制数组中的第一个对象

然而，我很难决定当这个人离开时该做什么

server.js

// Setup basic express server
var express = require('express');
var app = express();
var server = require('http').createServer(app);
var io = require('socket.io')(server);
var port = process.env.PORT || 8082;

server.listen(port, function () {
  console.log('Server listening at port %d', port);
});

// Routing
app.use(express.static(__dirname + '/public'));

const speed = 5;
var hero1 = {
    x : 0,
    y : 0
}
var hero2 = {
    x : 0,
    y : 0
}
var hero3 = {
    x : 0,
    y : 0
}
var hero4 = {
    x : 0,
    y : 0
}
var hero5 = {
    x : 0,
    y : 0
}
var hero6 = {
    x : 0,
    y : 0
}
var allHeroes = [hero1, hero2, hero3, hero4, hero5, hero6];
var heroesOn = [];
function sendCoords() {
    io.sockets.emit("draw", heroesOn)
}

io.on('connection', function (socket) {
    socket.on('disconnect', function(){
        console.log(clients)
    });
    var clients = Object.keys(io.sockets.sockets)
    heroesOn.push(allHeroes[clients.length - 1]);
    console.log(clients)
    io.sockets.connected[clients[clients.length - 1]].emit("userId", clients.length - 1);
    socket.on("move", function(data) {
        if(heroesOn[data.user].x < 1) {
            data.a = false;
        } else if(data.a == true) {
            heroesOn[data.user].x = heroesOn[data.user].x - speed
        }
        if(heroesOn[data.user].y < 1) {
            data.w = false;
        } else if(data.w == true) {
            heroesOn[data.user].y = heroesOn[data.user].y - speed
        }
        if(heroesOn[data.user].y > 474) {
            data.s = false;
        } else if(data.s == true) {
            heroesOn[data.user].y = heroesOn[data.user].y + speed
        }
        if(heroesOn[data.user].x > 974) {
            data.d = false;
        } else if(data.d == true) {
            heroesOn[data.user].x = heroesOn[data.user].x + speed
        }
    })
})
setInterval(sendCoords, 1000/60)

//安装基本快速服务器
var express=需要（“express”）；
var-app=express（）；
var server=require（'http'）。createServer（应用程序）；
var io=require（'socket.io'）（服务器）；
var port=process.env.port | | 8082；
侦听（端口、函数（）{
console.log（'服务器在端口%d侦听'，端口）；
});
//路由
app.use（express.static（uu dirname+/public））；
恒速=5；
变量1={
x:0,，
y:0
}
var hero2={
x:0,，
y:0
}
var hero3={
x:0,，
y:0
}
var hero4={
x:0,，
y:0
}
变量5={
x:0,，
y:0
}
变量6={
x:0,，
y:0
}
var allheroses=[hero1，hero2，hero3，hero4，hero5，hero6]；
var heroesOn=[]；
函数sendCoords（）{
io.sockets.emit（“draw”，heroesOn）
}
io.on（'连接'，函数（套接字）{
socket.on（'disconnect'，function（））{
console.log（客户端）
});
var clients=Object.keys（io.sockets.sockets）
heroesOn.push（allHeroes[clients.length-1]）；
console.log（客户端）
io.sockets.connected[clients[clients.length-1].emit（“userId”，clients.length-1）；
socket.on（“移动”），函数（数据）{
if（heroesOn[data.user].x<1）{
数据a=假；
}else if（data.a==true）{
heroesOn[data.user].x=heroesOn[data.user].x-speed
}
if（heroesOn[data.user].y<1）{
data.w=假；
}else if（data.w==true）{
heroesOn[data.user].y=heroesOn[data.user].y-速度
}
if（heroesOn[data.user].y>474）{
data.s=假；
}else if（data.s==true）{
heroesOn[data.user].y=heroesOn[data.user].y+speed
}
if（heroesOn[data.user].x>974）{
数据d=假；
}else if（data.d==true）{
heroesOn[data.user].x=heroesOn[data.user].x+speed
}
})
})
设置间隔（sendCoords，1000/60）

client.js

$(function() {
    var socket = io();
    document.onkeydown = down;
    document.onkeyup = up;
    var canvas = document.querySelector('#canvas');
    var ctx = canvas.getContext('2d');
    var character = {
        user : 0,
        w : false,
        a : false,
        s : false,
        d : false
    }
    socket.on("userId", function(data) {
        console.log("got id")
        character.user = data;
    })
    function down(e) {
        socket.emit("move", character);
        if(e.keyCode == 87) {
            character.w = true;
        }
        if(e.keyCode == 65) {
            character.a = true;
        }
        if(e.keyCode == 83) {
            character.s = true;
        }
        if(e.keyCode == 68) {
            character.d = true;
        }
    }
    function up(e) {
        socket.emit("move", character);
        if(e.keyCode == 87) {
            character.w = false;
        }
        if(e.keyCode == 65) {
            character.a = false;
        }
        if(e.keyCode == 83) {
            character.s = false;
        }
        if(e.keyCode == 68) {
            character.d = false;
        }
    }
    setInterval(function() {

    }, 1000/60)
    socket.on("draw", function(data) {
        canvas.width=canvas.width;
        for(var i = 0; i < data.length; i++) {
            ctx.rect(data[i].x, data[i].y, 25, 25)
        }
        ctx.stroke();
    })

});

$（函数（）{
var socket=io（）；
document.onkeydown=向下；
document.onkeyup=up；
var canvas=document.querySelector（“#canvas”）；
var ctx=canvas.getContext（'2d'）；
变量字符={
用户：0，
w:错，
a:错，
s:错，
d:错
}
socket.on（“userId”，函数（数据）{
日志（“获取id”）
character.user=数据；
})
功能下降（e）{
socket.emit（“移动”，字符）；
如果（e.keyCode==87）{
字符w=真；
}
如果（e.keyCode==65）{
字符a=真；
}
如果（e.keyCode==83）{
字符s=真；
}
如果（e.keyCode==68）{
字符d=真；
}
}
功能启动（e）{
socket.emit（“移动”，字符）；
如果（e.keyCode==87）{
字符w=假；
}
如果（e.keyCode==65）{
字符a=假；
}
如果（e.keyCode==83）{
字符s=假；
}
如果（e.keyCode==68）{
字符d=假；
}
}
setInterval（函数（）{
}, 1000/60)
socket.on（“绘制”，函数（数据）{
canvas.width=canvas.width；
对于（变量i=0；i


当我控制英雄的客户端离开时，我该如何从英雄数组中移除英雄。
 < p>我会考虑使用一个地图（即一个对象）而不是一个数组来追踪你的英雄。例如，当客户端连接时：
var heroesOn = {}; // key: socketid, value: hero
var counter = 0;
io.on('connection', function (socket) {
  heroesOn[socket.id] = allHeroes[counter++];
  ...continue your code...
});

当插座断开时：
var heroesOn = {}; // key: socketid, value: hero
var counter = 0;
io.on('connection', function (socket) {
  heroesOn[socket.id] = allHeroes[counter++];
  ...continue your code...
});

socket.on('disconnect', function(socket){
    delete heroesOn[socket.id];
});

我会考虑使用一个地图（即一个对象）而不是一个数组来追踪你的英雄。例如，当客户端连接时：
var heroesOn = {}; // key: socketid, value: hero
var counter = 0;
io.on('connection', function (socket) {
  heroesOn[socket.id] = allHeroes[counter++];
  ...continue your code...
});

当插座断开时：
var heroesOn = {}; // key: socketid, value: hero
var counter = 0;
io.on('connection', function (socket) {
  heroesOn[socket.id] = allHeroes[counter++];
  ...continue your code...
});

socket.on('disconnect', function(socket){
    delete heroesOn[socket.id];
});

使用对象数组（英雄）。每个英雄都有一个ID和一个可用的属性。当客户端连接时，使用isAvailable=true
查找英雄并将其ID设置为客户端ID。当客户端断开连接时，使用客户端ID查找英雄并将isAvailable
设置为错误使用对象数组（英雄）。每个英雄都有一个ID和一个可用的属性。当客户端连接时，找到具有isAvailable=true
的英雄并将其ID设置为客户端ID。当客户端断开连接时，找到具有客户端ID的英雄并将isAvailable
设置为false