private BaseResponse PlayerMove(int clientId, BasePacket packet)
{
PPlayerMove pPlayerMove = (PPlayerMove)packet;
PlayerDataEx playerData = World.PlayerDataGet(pPlayerMove.SessionToken);
if (playerData == null)
{
ThrowSessionError(packet.Type, packet.SessionToken);
return(null);
}
if (playerData.Player.Position != pPlayerMove.Position ||
playerData.Player.Direction != pPlayerMove.Direction)
{
_vCheckPosition.Validate(packet);
if (pPlayerMove.Direction == Direction.None)
{
playerData.StopMoving(pPlayerMove.Position);
}
else
{
playerData.StartMoving(pPlayerMove.Position, pPlayerMove.Direction);
}
RegisterWorldResponseForNearest(playerData, new RPlayerMove
{
PlayerId = playerData.Player.Id,
Position = pPlayerMove.Position,
Direction = pPlayerMove.Direction,
});
}
return(null);
}
private void UpdatePlayersPosition()
{
if (PlayerData == null)
{
return;
}
lock (_playersData)
{
foreach (int playerId in _playersData.Keys)
{
PlayerDataEx playerData = _playersData[playerId];
if (Engine.ValidateNewPlayerPosition(playerData, _map))
{
if (_myPlayerData.Player.Id == playerId && !_myPlayerData.GettingMapWindow &&
_myPlayerData.Player.Direction != Direction.None &&
_map.NeedsToLoadMapWindow(_myPlayerData, BORDER_AREA_SPACE_PART))
{
_myPlayerData.GettingMapWindow = true;
TCPClientDataSend(new PMapData
{
SessionToken = _sessionToken,
});
}
_somethingChanged = playerData.NeedUpdatePosition = true;
}
}
}
}
public bool PlayerAdd(long sessionToken, Player player)
{
if (!_sessionPlayers.ContainsKey(sessionToken))
{
PlayerDataEx playerData = new PlayerDataEx(player, _maps);
lock (_sessionPlayers) lock (_players)
{
_players.Add(playerData);
_sessionPlayers.Add(sessionToken, playerData);
return(true);
}
}
return(false);
}
private void WorldEngineProc()
{
while (Thread.CurrentThread.IsAlive && !_disposing)
{
lock (_players)
{
Parallel.For(0, _players.Count, i =>
{
PlayerDataEx playerData = _players[i];
EngineCheckPlayerPosition(playerData);
});
}
Thread.Sleep(1);
}
}
private BaseResponse Enter(int clientId, BasePacket packet)
{
PUserEnter pUserEnter = (PUserEnter)packet;
PlayerDataEx playerData = World.PlayerDataGet(pUserEnter.SessionToken);
if (playerData == null)
{
ThrowSessionError(packet.Type, packet.SessionToken);
return(null);
}
int maxScreenSide = Math.Max(pUserEnter.ScreenRes.Width, pUserEnter.ScreenRes.Height);
playerData.ScreenRes = new ShortSize(maxScreenSide, maxScreenSide);
List <Player> nearestPlayers = World.PlayersGetNearest(playerData);
ShortRect mapWindow;
byte[] mapData = World.MapWindowGet(playerData, out mapWindow);
ShortSize mapSize = new ShortSize(playerData.Map.Width, playerData.Map.Height);
ShortSize miniMapSize;
byte[] miniMapData = World.MiniMapGet(playerData, out miniMapSize);
RegisterWorldResponseForNearest(playerData, new RPlayerEnter
{
Player = playerData
});
return(new RUserEnter(pUserEnter)
{
MyPlayerId = playerData.Player.Id,
PlayersOnLocation = nearestPlayers,
MapSize = mapSize,
MapData = mapData,
MapWindow = mapWindow,
MiniMapData = miniMapData,
MiniMapSize = miniMapSize
});
}
public List <Player> PlayersGetNearest(Player player)
{
lock (_players)
{
List <Player> players = new List <Player>();
int playersCnt = _players.Count;
for (int i = 0; i < playersCnt; i++)
{
PlayerDataEx p = _players[i];
if (p.Player.MapId == player.MapId &&
p.Player.Position.CloseTo(player.Position, NEAREST_AREA_HALF_SIZE))
{
players.Add(p.Player);
}
}
return(players);
}
}
private BaseResponse MapData(int clientId, BasePacket packet)
{
PMapData pMapData = (PMapData)packet;
PlayerDataEx playerData = World.PlayerDataGet(pMapData.SessionToken);
if (playerData == null)
{
ThrowSessionError(packet.Type, packet.SessionToken);
return(null);
}
ShortRect mapWindow;
byte[] mapData = World.MapWindowGet(playerData, out mapWindow);
return(new RMapData(pMapData)
{
MapData = mapData,
MapWindow = mapWindow
});
}
public void DisconnectFromHost()
{
if (_tcpClient.IsConnected)
{
WriteLog("DisconnectFromHost");
TCPClientDataSend(new PUserLogout
{
SessionToken = _sessionToken
});
_sessionToken = 0;
IsMapLoaded = false;
_myPlayerData = null;
if (_tcpClient != null)
{
_tcpClient.Disconnect();
}
}
else
{
WriteLog("!DisconnectFromHost");
}
}
private BaseResponse PlayerRotate(int clientId, BasePacket packet)
{
PPlayerRotate pPlayerRotate = (PPlayerRotate)packet;
PlayerDataEx playerData = World.PlayerDataGet(pPlayerRotate.SessionToken);
if (playerData == null)
{
ThrowSessionError(packet.Type, packet.SessionToken);
return(null);
}
if (playerData.Player.Angle != pPlayerRotate.Angle)
{
playerData.Player.Angle = pPlayerRotate.Angle;
RegisterWorldResponseForNearest(playerData, new RPlayerRotate
{
PlayerId = playerData.Player.Id,
Angle = pPlayerRotate.Angle
});
}
return(null);
}
private void GameHostResponse(BaseResponse e)
{
if (e.HasError)
{
ReconnectToHost();
return;
}
switch (e.Type)
{
case PacketType.UserLogin:
RUserLogin userLogin = (RUserLogin) e;
_sessionToken = userLogin.SessionToken;
ShortSize screenRes = new ShortSize
(
Screen.PrimaryScreen.Bounds.Width,
Screen.PrimaryScreen.Bounds.Height
);
TCPClientDataSend(new PUserEnter
{
SessionToken = _sessionToken,
ScreenRes = screenRes
});
break;
case PacketType.UserEnter:
lock (_playersData)
{
RUserEnter userEnter = (RUserEnter) e; //!!!
_map.Setup(userEnter.MapSize);
_map.AppendMapData(userEnter.MapData, userEnter.MapWindow);
_map.AppendMiniMapData(userEnter.MiniMapData, userEnter.MiniMapSize);
OnMapChanged();
foreach (Player p in userEnter.PlayersOnLocation)
{
if (!_playersData.ContainsKey(p.Id))
{
_playersData.Add(p.Id, new PlayerDataEx(p));
}
}
_myPlayerData = _playersData[userEnter.MyPlayerId];
_playersRo = new ReadOnlyCollection<PlayerDataEx>(_playersData.Values.ToArray());
}
CenterTo((int) (_myPlayerData.Player.Position.X*_scaleFactor), //!!!
(int) (_myPlayerData.Player.Position.Y*_scaleFactor),
true);
break;
case PacketType.PlayerEnter:
lock (_playersData)
{
RPlayerEnter playerEnter = (RPlayerEnter) e;
if (!_playersData.ContainsKey(playerEnter.Player.Id) && _myPlayerData != null &&
playerEnter.Player.Id != _myPlayerData.Player.Id)
{
_playersData.Add(playerEnter.Player.Id, new PlayerDataEx(playerEnter.Player));
_playersRo = new ReadOnlyCollection<PlayerDataEx>(_playersData.Values.ToArray());
_somethingChanged = true; //!!!
}
}
break;
case PacketType.PlayerExit:
lock (_playersData)
{
RPlayerExit playerExit = (RPlayerExit) e;
if (_playersData.ContainsKey(playerExit.PlayerId) && _myPlayerData != null &&
playerExit.PlayerId != _myPlayerData.Player.Id)
{
_playersData.Remove(playerExit.PlayerId);
_playersRo = new ReadOnlyCollection<PlayerDataEx>(_playersData.Values.ToArray());
_somethingChanged = true; //!!!
}
}
break;
case PacketType.PlayerRotate:
lock (_playersData)
{
PlayerDataEx playerData;
RPlayerRotate playerRotate = (RPlayerRotate) e;
if (_playersData.TryGetValue(playerRotate.PlayerId, out playerData))
playerData.Player.Angle = playerRotate.Angle;
}
break;
case PacketType.PlayerMove:
lock (_playersData)
{
PlayerDataEx playerData;
RPlayerMove playerMove = (RPlayerMove) e;
if (_playersData.TryGetValue(playerMove.PlayerId, out playerData))
{
if (playerMove.Direction == Direction.None)
playerData.StopMoving(playerMove.Position);
else
playerData.StartMoving(playerMove.Position, playerMove.Direction);
}
}
break;
case PacketType.MapData:
RMapData mapData = (RMapData) e;
_map.AppendMapData(mapData.MapData, mapData.MapWindow); //!!!
_myPlayerData.GettingMapWindow = false;
break;
}
}
public void DisconnectFromHost()
{
if (_tcpClient.IsConnected)
{
WriteLog("DisconnectFromHost");
TCPClientDataSend(new PUserLogout
{
SessionToken = _sessionToken
});
_sessionToken = 0;
IsMapLoaded = false;
_myPlayerData = null;
if (_tcpClient != null)
{
_tcpClient.Disconnect();
}
}
else
{
WriteLog("!DisconnectFromHost");
}
}
private void EngineCheckPlayerPosition(PlayerDataEx playerData)
{
Engine.ValidateNewPlayerPosition(playerData, playerData.Map);
}
public byte[] MiniMapGet(PlayerDataEx playerData, out ShortSize miniMapSize)
{
miniMapSize = playerData.Map.MiniMapSize;
return(playerData.Map.GetMiniMap());
}
public byte[] MapWindowGet(PlayerDataEx playerData, out ShortRect mapWindow)
{
const float resCoef = MAP_WINDOW_RES_COEF / ConstMap.PIXEL_SIZE;
float dStartX, dStartY;
float dWidth = playerData.ScreenRes.Width * resCoef;
float dHeight = playerData.ScreenRes.Height * resCoef;
ShortPoint pos = playerData.Player.Position.ToShortPoint(ConstMap.PIXEL_SIZE);
switch (playerData.Player.Direction)
{
case Direction.N:
dStartX = pos.X - dWidth / 2;
dStartY = pos.Y - dHeight;
break;
case Direction.S:
dStartX = pos.X - dWidth / 2;
dStartY = pos.Y;
break;
case Direction.W:
dStartX = pos.X - dWidth;
dStartY = pos.Y - dHeight / 2;
break;
case Direction.E:
dStartX = pos.X;
dStartY = pos.Y - dHeight / 2;
break;
case Direction.NW:
dStartX = pos.X - dWidth / 1.1f;
dStartY = pos.Y - dHeight / 1.1f;
break;
case Direction.NE:
dStartX = pos.X - dWidth * 0.1f;
dStartY = pos.Y - dHeight / 1.1f;
break;
case Direction.SW:
dStartX = pos.X - dWidth / 1.1f;
dStartY = pos.Y - dHeight * 0.1f;
break;
case Direction.SE:
dStartX = pos.X - dWidth * 0.1f;
dStartY = pos.Y - dHeight * 0.1f;
break;
default:
dStartX = pos.X - dWidth / 2;
dStartY = pos.Y - dHeight / 2;
break;
}
int mapWidth = playerData.Map.Width, mapHeight = playerData.Map.Height;
ushort startX = (ushort)Math.Max(dStartX, 0);
ushort startY = (ushort)Math.Max(dStartY, 0);
ushort width = (ushort)Math.Floor(startX + dWidth > mapWidth
? dWidth - (startX + dWidth - mapWidth)
: dWidth);
ushort height = (ushort)Math.Floor(startY + dHeight > mapHeight
? dHeight - (startY + dHeight - mapHeight)
: dHeight);
mapWindow = new ShortRect(startX, startY, width, height);
return(playerData.Map.GetWindow(mapWindow.X, mapWindow.Y, mapWindow.Width, mapWindow.Height));
}
private void GameHostResponse(BaseResponse e)
{
if (e.HasError)
{
ReconnectToHost();
return;
}
switch (e.Type)
{
case PacketType.UserLogin:
RUserLogin userLogin = (RUserLogin)e;
_sessionToken = userLogin.SessionToken;
ShortSize screenRes = new ShortSize
(
Screen.PrimaryScreen.Bounds.Width,
Screen.PrimaryScreen.Bounds.Height
);
TCPClientDataSend(new PUserEnter
{
SessionToken = _sessionToken,
ScreenRes = screenRes
});
break;
case PacketType.UserEnter:
lock (_playersData)
{
RUserEnter userEnter = (RUserEnter)e; //!!!
_map.Setup(userEnter.MapSize);
_map.AppendMapData(userEnter.MapData, userEnter.MapWindow);
_map.AppendMiniMapData(userEnter.MiniMapData, userEnter.MiniMapSize);
OnMapChanged();
foreach (Player p in userEnter.PlayersOnLocation)
{
if (!_playersData.ContainsKey(p.Id))
{
_playersData.Add(p.Id, new PlayerDataEx(p));
}
}
_myPlayerData = _playersData[userEnter.MyPlayerId];
_playersRo = new ReadOnlyCollection <PlayerDataEx>(_playersData.Values.ToArray());
}
CenterTo((int)(_myPlayerData.Player.Position.X * _scaleFactor), //!!!
(int)(_myPlayerData.Player.Position.Y * _scaleFactor),
true);
break;
case PacketType.PlayerEnter:
lock (_playersData)
{
RPlayerEnter playerEnter = (RPlayerEnter)e;
if (!_playersData.ContainsKey(playerEnter.Player.Id) && _myPlayerData != null &&
playerEnter.Player.Id != _myPlayerData.Player.Id)
{
_playersData.Add(playerEnter.Player.Id, new PlayerDataEx(playerEnter.Player));
_playersRo = new ReadOnlyCollection <PlayerDataEx>(_playersData.Values.ToArray());
_somethingChanged = true; //!!!
}
}
break;
case PacketType.PlayerExit:
lock (_playersData)
{
RPlayerExit playerExit = (RPlayerExit)e;
if (_playersData.ContainsKey(playerExit.PlayerId) && _myPlayerData != null &&
playerExit.PlayerId != _myPlayerData.Player.Id)
{
_playersData.Remove(playerExit.PlayerId);
_playersRo = new ReadOnlyCollection <PlayerDataEx>(_playersData.Values.ToArray());
_somethingChanged = true; //!!!
}
}
break;
case PacketType.PlayerRotate:
lock (_playersData)
{
PlayerDataEx playerData;
RPlayerRotate playerRotate = (RPlayerRotate)e;
if (_playersData.TryGetValue(playerRotate.PlayerId, out playerData))
{
playerData.Player.Angle = playerRotate.Angle;
}
}
break;
case PacketType.PlayerMove:
lock (_playersData)
{
PlayerDataEx playerData;
RPlayerMove playerMove = (RPlayerMove)e;
if (_playersData.TryGetValue(playerMove.PlayerId, out playerData))
{
if (playerMove.Direction == Direction.None)
{
playerData.StopMoving(playerMove.Position);
}
else
{
playerData.StartMoving(playerMove.Position, playerMove.Direction);
}
}
}
break;
case PacketType.MapData:
RMapData mapData = (RMapData)e;
_map.AppendMapData(mapData.MapData, mapData.MapWindow); //!!!
_myPlayerData.GettingMapWindow = false;
break;
}
}
