/// <summary>
/// Procédure appelée quand un message de type Data est reçu ;
/// elle trie les messages selon leur type et les traite.
/// </summary>
/// <param name="inc">Le message entrant</param>
public void TreatServerMessage(NetIncomingMessage inc)
{
ServerMessageTypes messageType = (ServerMessageTypes)inc.ReadByte();
switch (messageType)
{
case ServerMessageTypes.SendMapSeed:
MapSeed = inc.ReadInt32();
break;
case ServerMessageTypes.SendPlayerData:
RecievedPlayerData = new PlayerDataServer();
RecievedPlayerData.DecodeMessage(inc);
break;
case ServerMessageTypes.SendNewPlayerNotification:
SendNewPlayerNotification nplayer = new SendNewPlayerNotification();
nplayer.DecodeMessage(inc);
AddNewPlayer(nplayer.PlayerID, nplayer.Pseudo, nplayer.TeamNumber, nplayer.Weapon);
break;
case ServerMessageTypes.ConfirmArrival:
IsConnected = true;
break;
case ServerMessageTypes.NewBulletServer:
AddNewBullet(inc.ReadInt64(), inc.ReadFloat());
break;
case ServerMessageTypes.PlayerRespawn:
RespawnPlayer(inc.ReadInt64());
break;
case ServerMessageTypes.Death:
KillPlayer(inc.ReadInt64());
break;
case ServerMessageTypes.Disconnection:
PlayerDisconnect msg = new PlayerDisconnect();
msg.DecodeMessage(inc);
GamePage.PlayerList.RemoveAll(x => x.Id == msg.ID);
GamePage.PlayersToDraw.RemoveAll(x => x.Id == msg.ID);
foreach (Team team in Team.TeamList)
{
team.TeamPlayerList.RemoveAll(x => x.Id == msg.ID);
}
break;
default:
break;
}
}
/// <summary>
/// Envoie une notification de déconnexion aux autres joueurs
/// </summary>
/// <param name="Id">L'ID du joueur déconnecté</param>
/// <param name="inc">Le message entrant</param>
public void SendDisconnectionMessage(long Id, NetIncomingMessage inc)
{
foreach (NetConnection co in GameServer.Connections)
{
if (co != inc.SenderConnection)
{
NetOutgoingMessage outmsg = GameServer.CreateMessage();
PlayerDisconnect msg = new PlayerDisconnect(Id);
msg.EncodeMessage(outmsg);
GameServer.SendMessage(outmsg, co, NetDeliveryMethod.ReliableOrdered);
}
}
PlayerList.RemoveAll(x => x.Connection == inc.SenderConnection);
}
public void OnQuitYes()
{
PlayerDisconnect.SetActive(true);
LostGame = true;
Hashtable updateStats = new Hashtable();
int myAtk = (int)PhotonNetwork.LocalPlayer.CustomProperties["PlayerSlimeAttack"];
int myDef = (int)PhotonNetwork.LocalPlayer.CustomProperties["PlayerSlimeDefense"];
int mySpd = (int)PhotonNetwork.LocalPlayer.CustomProperties["PlayerSlimeSpeed"];
pi.losts++;
pi.mySlime.setAtk(CheckIfLower(pi.mySlime.getAtk() - Random.Range(1, (myAtk / 3))));
pi.mySlime.setDef(CheckIfLower(pi.mySlime.getDef() - Random.Range(1, (myDef / 3))));
pi.mySlime.setSpd(CheckIfLower(pi.mySlime.getSpd() - Random.Range(1, (mySpd / 3))));
PhotonNetwork.LocalPlayer.SetCustomProperties(updateStats);
}
public override void ReadPacket()
{
ReadHeaders(Packet);
// Read the byte flag representing which packets
// are included in this update
var dataPacketIdFlag = Packet.ReadUShort();
// Keep track of value of current bit
var currentTypeValue = 1;
for (var i = 0; i < Enum.GetNames(typeof(ClientPacketId)).Length; i++)
{
// If this bit was set in our flag, we add the type to the list
if ((dataPacketIdFlag & currentTypeValue) != 0)
{
DataPacketIds.Add((ClientPacketId)i);
}
// Increase the value of current bit
currentTypeValue *= 2;
}
if (DataPacketIds.Contains(ClientPacketId.PlayerConnect))
{
PlayerConnect.ReadData(Packet);
}
if (DataPacketIds.Contains(ClientPacketId.PlayerDisconnect))
{
PlayerDisconnect.ReadData(Packet);
}
if (DataPacketIds.Contains(ClientPacketId.PlayerEnterScene))
{
PlayerEnterScene.ReadData(Packet);
}
if (DataPacketIds.Contains(ClientPacketId.PlayerAlreadyInScene))
{
PlayerAlreadyInScene.ReadData(Packet);
}
if (DataPacketIds.Contains(ClientPacketId.PlayerLeaveScene))
{
PlayerLeaveScene.ReadData(Packet);
}
if (DataPacketIds.Contains(ClientPacketId.PlayerUpdate))
{
PlayerUpdates.ReadData(Packet);
}
if (DataPacketIds.Contains(ClientPacketId.EntityUpdate))
{
EntityUpdates.ReadData(Packet);
}
if (DataPacketIds.Contains(ClientPacketId.PlayerDeath))
{
PlayerDeath.ReadData(Packet);
}
if (DataPacketIds.Contains(ClientPacketId.PlayerTeamUpdate))
{
PlayerTeamUpdate.ReadData(Packet);
}
if (DataPacketIds.Contains(ClientPacketId.PlayerSkinUpdate))
{
PlayerSkinUpdate.ReadData(Packet);
}
if (DataPacketIds.Contains(ClientPacketId.PlayerEmoteUpdate))
{
PlayerEmoteUpdate.ReadData(Packet);
}
if (DataPacketIds.Contains(ClientPacketId.GameSettingsUpdated))
{
GameSettingsUpdate.ReadData(Packet);
}
}
public override Packet CreatePacket()
{
var packet = new Packet();
WriteHeaders(packet);
// Construct the ushort flag representing which packets are included
// in this update, we need a ushort since we have more than 8 possible packet IDs
ushort dataPacketIdFlag = 0;
// Keep track of value of current bit
ushort currentTypeValue = 1;
for (var i = 0; i < Enum.GetNames(typeof(ClientPacketId)).Length; i++)
{
// Cast the current index of the loop to a ClientPacketId and check if it is
// contained in the update type list, if so, we add the current bit to the flag
if (DataPacketIds.Contains((ClientPacketId)i))
{
dataPacketIdFlag |= currentTypeValue;
}
currentTypeValue *= 2;
}
packet.Write(dataPacketIdFlag);
if (DataPacketIds.Contains(ClientPacketId.PlayerConnect))
{
PlayerConnect.WriteData(packet);
}
if (DataPacketIds.Contains(ClientPacketId.PlayerDisconnect))
{
PlayerDisconnect.WriteData(packet);
}
if (DataPacketIds.Contains(ClientPacketId.PlayerEnterScene))
{
PlayerEnterScene.WriteData(packet);
}
if (DataPacketIds.Contains(ClientPacketId.PlayerAlreadyInScene))
{
PlayerAlreadyInScene.WriteData(packet);
}
if (DataPacketIds.Contains(ClientPacketId.PlayerLeaveScene))
{
PlayerLeaveScene.WriteData(packet);
}
if (DataPacketIds.Contains(ClientPacketId.PlayerUpdate))
{
PlayerUpdates.WriteData(packet);
}
if (DataPacketIds.Contains(ClientPacketId.EntityUpdate))
{
EntityUpdates.WriteData(packet);
}
if (DataPacketIds.Contains(ClientPacketId.PlayerDeath))
{
PlayerDeath.WriteData(packet);
}
if (DataPacketIds.Contains(ClientPacketId.PlayerTeamUpdate))
{
PlayerTeamUpdate.WriteData(packet);
}
if (DataPacketIds.Contains(ClientPacketId.PlayerSkinUpdate))
{
PlayerSkinUpdate.WriteData(packet);
}
if (DataPacketIds.Contains(ClientPacketId.PlayerEmoteUpdate))
{
PlayerEmoteUpdate.WriteData(packet);
}
if (DataPacketIds.Contains(ClientPacketId.GameSettingsUpdated))
{
GameSettingsUpdate.WriteData(packet);
}
_containsReliableData = DataPacketIds.Contains(ClientPacketId.PlayerConnect) ||
DataPacketIds.Contains(ClientPacketId.PlayerDisconnect) ||
DataPacketIds.Contains(ClientPacketId.PlayerEnterScene) ||
DataPacketIds.Contains(ClientPacketId.PlayerAlreadyInScene) ||
DataPacketIds.Contains(ClientPacketId.PlayerLeaveScene) ||
DataPacketIds.Contains(ClientPacketId.PlayerDeath) ||
DataPacketIds.Contains(ClientPacketId.PlayerTeamUpdate) ||
DataPacketIds.Contains(ClientPacketId.PlayerSkinUpdate) ||
DataPacketIds.Contains(ClientPacketId.GameSettingsUpdated);
packet.WriteLength();
return(packet);
}
public void OnPlayerDisconnect(Creature creature)
{
PlayerDisconnect.Raise(creature);
}
private void OnPlayerDisconnected(int peerId)
{
PlayerDisconnect?.Invoke(this, new PlayerEventArgs(peerId));
}
private void HandleCurrentEvents()
{
foreach (BaseEvent baseEvent in currentTick.Events)
{
switch (baseEvent.Type)
{
case EventType.MatchStarted:
MatchStarted?.Invoke(this, baseEvent);
break;
case EventType.RoundAnnounceMatchStarted:
break;
case EventType.RoundStart:
RoundStart?.Invoke(this, (RoundStartEvent)baseEvent);
break;
case EventType.RoundEnd:
RoundEnd?.Invoke(this, (RoundEndEvent)baseEvent);
break;
case EventType.WinPanelMatch:
WinPanelMatch?.Invoke(this, baseEvent);
break;
case EventType.RoundFinal:
break;
case EventType.LastRoundHalf:
break;
case EventType.RoundOfficiallyEnd:
RoundOfficiallyEnd?.Invoke(this, baseEvent);
break;
case EventType.RoundMVP:
RoundMVP?.Invoke(this, (RoundMVPEvent)baseEvent);
break;
case EventType.FreezetimeEnded:
FreezetimeEnded?.Invoke(this, baseEvent);
break;
case EventType.PlayerKilled:
PlayerKilled?.Invoke(this, (PlayerKilledEvent)baseEvent);
break;
case EventType.PlayerTeam:
PlayerTeam?.Invoke(this, (PlayerTeamEvent)baseEvent);
break;
case EventType.WeaponFired:
WeaponFired?.Invoke(this, (WeaponFiredEvent)baseEvent);
break;
case EventType.SmokeNadeStarted:
SmokeNadeStarted?.Invoke(this, (SmokeNadeStartedEvent)baseEvent);
break;
case EventType.SmokeNadeEnded:
SmokeNadeEnded?.Invoke(this, (SmokeNadeEndedEvent)baseEvent);
break;
case EventType.DecoyNadeStarted:
DecoyNadeStarted?.Invoke(this, (DecoyNadeStartedEvent)baseEvent);
break;
case EventType.DecoyNadeEnded:
DecoyNadeEnded?.Invoke(this, (DecoyNadeEndedEvent)baseEvent);
break;
case EventType.FireNadeStarted:
FireNadeStarted?.Invoke(this, (FireNadeStartedEvent)baseEvent);
break;
case EventType.FireNadeWithOwnerStarted:
FireNadeWithOwnerStarted?.Invoke(this, (FireNadeWithOwnerStartedEvent)baseEvent);
break;
case EventType.FireNadeEnded:
FireNadeEnded?.Invoke(this, (FireNadeEndedEvent)baseEvent);
break;
case EventType.FlashNadeExploded:
FlashNadeExploded?.Invoke(this, (FlashNadeExplodedEvent)baseEvent);
break;
case EventType.ExplosiveNadeExploded:
ExplosiveNadeExploded?.Invoke(this, (ExplosiveNadeExplodedEvent)baseEvent);
break;
case EventType.NadeReachedTarget:
NadeReachedTarget?.Invoke(this, (NadeReachedTargetEvent)baseEvent);
break;
case EventType.BombBeginPlant:
BombBeginPlant?.Invoke(this, (BombBeginPlantEvent)baseEvent);
break;
case EventType.BombAbortPlant:
BombAbortPlant?.Invoke(this, (BombAbortPlantEvent)baseEvent);
break;
case EventType.BombPlanted:
BombPlanted?.Invoke(this, (BombPlantedEvent)baseEvent);
break;
case EventType.BombDefused:
BombDefused?.Invoke(this, (BombDefusedEvent)baseEvent);
break;
case EventType.BombExploded:
BombExploded?.Invoke(this, (BombExplodedEvent)baseEvent);
break;
case EventType.BombBeginDefuse:
BombBeginDefuse?.Invoke(this, (BombBeginDefuseEvent)baseEvent);
break;
case EventType.BombAbortDefuse:
BombAbortDefuse?.Invoke(this, (BombAbortDefuseEvent)baseEvent);
break;
case EventType.PlayerHurt:
PlayerHurt?.Invoke(this, (PlayerHurtEvent)baseEvent);
break;
case EventType.Blind:
Blind?.Invoke(this, (BlindEvent)baseEvent);
break;
case EventType.PlayerBind:
PlayerBind?.Invoke(this, (PlayerBindEvent)baseEvent);
break;
case EventType.PlayerDisconnect:
PlayerDisconnect?.Invoke(this, (PlayerDisconnectEvent)baseEvent);
break;
case EventType.SayText:
SayText?.Invoke(this, (SayTextEvent)baseEvent);
break;
case EventType.SayText2:
SayText2?.Invoke(this, (SayText2Event)baseEvent);
break;
case EventType.PlayerJump:
PlayerJump?.Invoke(this, (PlayerJumpEvent)baseEvent);
break;
case EventType.PlayerFootstep:
PlayerFootstep?.Invoke(this, (PlayerFootstepEvent)baseEvent);
break;
case EventType.OtherDeath:
OtherDeath?.Invoke(this, (OtherDeathEvent)baseEvent);
break;
case EventType.EntitySpawned:
EntitySpawned?.Invoke(this, (EntitySpawnedEvent)baseEvent);
break;
case EventType.EntityRemoved:
EntityRemoved?.Invoke(this, (EntityRemovedEvent)baseEvent);
break;
default:
break;
}
}
}
