public void SendRoomKill(int roomID, ulong ownerID)
{
if (killedRooms.Contains(roomID))
{
return;
}
if (activatedRooms.Contains(roomID))
{
activatedRooms.Remove(roomID);
}
MonklandSteamManager.DataPacket dataPacket = MonklandSteamManager.instance.GetNewPacket(GAMEMANAGEMENT_CHANNEL, RoomHandler);
BinaryWriter writer = MonklandSteamManager.instance.GetWriterForPacket(dataPacket);
//Writes the message type
writer.Write(RoomKillID);
//Send room ID that we want to activate
writer.Write(roomID);
writer.Write(ownerID);
MonklandSteamManager.instance.FinalizeWriterToPacket(writer, dataPacket);
MonklandSteamManager.instance.SendPacketToAll(dataPacket, false, EP2PSend.k_EP2PSendReliable);
requestedActivateRooms.Add(roomID);
MonklandUI.AddMessage("Sending killing of room " + roomID);
Debug.Log("Sending killing of room " + roomID);
killedRooms.Add(roomID);
}
public ulong SendForcewaitPacket(ulong id, CSteamID user)
{
//Tag this to be waiting
isForceWait = true;
//Send packet
{
MonklandSteamManager.DataPacket packet = MonklandSteamManager.instance.GetNewPacket(channelIndex, 0);
packet.priority = 0;
BinaryWriter writer = MonklandSteamManager.instance.GetWriterForPacket(packet, 1);
writer.Write(id);
MonklandSteamManager.instance.FinalizeWriterToPacket(writer, packet);
MonklandSteamManager.instance.SendPacket(packet, user, EP2PSend.k_EP2PSendReliable);
}
System.DateTime startTime = System.DateTime.Now;
//As long as we're supposed to wait
while (isForceWait)
{
//Read all packets
ReadPackets(true);
//Sleep for 10 ms
System.Threading.Thread.Sleep(10);
//If it's been 30 seconds and we haven't gotten a reply, return 0
if ((startTime - System.DateTime.Now).TotalSeconds > 30)
{
return(0);
}
}
return(replyValue);
}
public void DeactivateRoom(int roomName)
{
MonklandSteamManager.Log("[World] Sending room deactivate: " + roomName);
//if (string.IsNullOrEmpty(roomName)) { return; }
if (!roomDict.ContainsKey(playerID))
{
roomDict.Add(playerID, new List <int>());
}
if (roomDict[playerID].Contains(roomName))
{
roomDict[playerID].Remove(roomName);
}
MonklandSteamManager.DataPacket packet = MonklandSteamManager.instance.GetNewPacket(WORLD_CHANNEL, WorldHandler);
BinaryWriter writer = MonklandSteamManager.instance.GetWriterForPacket(packet);
//Write message type
writer.Write(Convert.ToByte(3));
writer.Write(roomName);
MonklandSteamManager.instance.FinalizeWriterToPacket(writer, packet);
//MonklandSteamManager.instance.SendPacket(packet, (CSteamID)managerID), EP2PSend.k_EP2PSendReliable);
MonklandSteamManager.instance.SendPacketToAll(packet, true, EP2PSend.k_EP2PSendReliable);
CheckForCommonRooms();
}
public void SendForcewaitReply(ulong response, CSteamID user)
{
MonklandSteamManager.DataPacket packet = MonklandSteamManager.instance.GetNewPacket(channelIndex, 0);
packet.priority = 0;
BinaryWriter writer = MonklandSteamManager.instance.GetWriterForPacket(packet, 2);
writer.Write(response);
MonklandSteamManager.instance.FinalizeWriterToPacket(writer, packet);
MonklandSteamManager.instance.SendPacket(packet, user, EP2PSend.k_EP2PSendReliable);
}
public void SendColor(UtilMessageType messageType)
{
MonklandSteamManager.DataPacket packet = MonklandSteamManager.instance.GetNewPacket(CHANNEL, UtilityHandler);
BinaryWriter writer = MonklandSteamManager.instance.GetWriterForPacket(packet);
if (!MonklandSteamManager.connectedPlayers.Contains(playerID))
{
return;
}
//Write message type
writer.Write(Convert.ToByte(messageType));
switch (messageType)
{
case UtilMessageType.BodyColorR:
//Write red body color
writer.Write(Convert.ToByte((int)(playerColors[MonklandSteamManager.connectedPlayers.IndexOf(playerID)].r * 255f)));
break;
case UtilMessageType.BodyColorG:
//Write green body color
writer.Write(Convert.ToByte((int)(playerColors[MonklandSteamManager.connectedPlayers.IndexOf(playerID)].g * 255f)));
break;
case UtilMessageType.BodyColorB:
//Write blue body color
writer.Write(Convert.ToByte((int)(playerColors[MonklandSteamManager.connectedPlayers.IndexOf(playerID)].b * 255f)));
break;
case UtilMessageType.EyeColorR:
//Write red eye color
writer.Write(Convert.ToByte((int)(playerEyeColors[MonklandSteamManager.connectedPlayers.IndexOf(playerID)].r * 255f)));
break;
case UtilMessageType.EyeColorG:
//Write green eye color
writer.Write(Convert.ToByte((int)(playerEyeColors[MonklandSteamManager.connectedPlayers.IndexOf(playerID)].g * 255f)));
break;
case UtilMessageType.EyeColorB:
//Write blue eye color
writer.Write(Convert.ToByte((int)(playerEyeColors[MonklandSteamManager.connectedPlayers.IndexOf(playerID)].b * 255f)));
break;
default:
//Write default color
writer.Write((byte)0);
break;
}
MonklandSteamManager.instance.FinalizeWriterToPacket(writer, packet);
MonklandSteamManager.instance.SendPacketToAll(packet, true, EP2PSend.k_EP2PSendReliableWithBuffering);
}
/*
* public void PlayerKilled(ulong playerDead)
* {
* MonklandSteamManager.DataPacket packet = MonklandSteamManager.instance.GetNewPacket(CHANNEL, UtilityHandler);
* BinaryWriter writer = MonklandSteamManager.instance.GetWriterForPacket(packet);
*
* //Write message type
* writer.Write((byte)UtilMessageType.PlayerDead);
* writer.Write(playerDead);
*
* MonklandSteamManager.instance.FinalizeWriterToPacket(writer, packet);
* MonklandSteamManager.instance.SendPacketToAll(packet, false, EP2PSend.k_EP2PSendReliable);
*
* Debug.Log($"Writing packet: {packet.data}");
* }
*/
public void SendViolence(Creature self, BodyChunk source, Creature.DamageType type, float damage)
{
/*
* Violence packet
* packetType
* damageType
* sourceType (player/scav/lizard)
* source ID
*/
if (self == null || AbstractPhysicalObjectHK.GetField(self.abstractPhysicalObject).networkObject)
{
return;
}
// Source ID field
MonklandSteamManager.DataPacket packet = MonklandSteamManager.instance.GetNewPacket(CHANNEL, UtilityHandler);
BinaryWriter writer = MonklandSteamManager.instance.GetWriterForPacket(packet);
// SourceTemplate
byte sourceTemplate = byte.MaxValue - 1;
try
{
sourceTemplate = (byte)(source.owner.abstractPhysicalObject as AbstractCreature).creatureTemplate.TopAncestor().type;
//sourceTemplate = (byte)((source.owner as Creature).abstractCreature.creatureTemplate.type);
}
catch (Exception e) { Debug.Log("Error getting source type " + e.Message); }
// SourceID
ulong sourceID = 0;
try
{
sourceID = (AbstractPhysicalObjectHK.GetField(source.owner.abstractPhysicalObject).owner);
}
catch { } //(Exception e) {/*Debug.Log()*/}
// Message type
writer.Write((byte)UtilMessageType.PlayerViolence);
// Damage type
writer.Write((byte)type);
// Damage
writer.Write((bool)(damage >= 1f));
// Source Template
writer.Write(sourceTemplate);
// Source ID
writer.Write(sourceID);
MonklandSteamManager.Log($"[GameMNG] Sending Player Violence: Type {type}, damage {damage} Source Template {(CreatureTemplate.Type)sourceTemplate}, Source ID {sourceID}");
MonklandSteamManager.instance.FinalizeWriterToPacket(writer, packet);
MonklandSteamManager.instance.SendPacketToAll(packet, false, EP2PSend.k_EP2PSendReliable);
}
public void SyncCycle()// Syncs rain values for all players called by manager before game loads
{
MonklandSteamManager.DataPacket packet = MonklandSteamManager.instance.GetNewPacket(WORLD_CHANNEL, WorldHandler);
BinaryWriter writer = MonklandSteamManager.instance.GetWriterForPacket(packet);
//Write message type
writer.Write(Convert.ToByte(1));
writer.Write(cycleLength);
writer.Write(timer);
MonklandSteamManager.instance.FinalizeWriterToPacket(writer, packet);
//MonklandSteamManager.instance.SendPacket(packet, target, EP2PSend.k_EP2PSendReliable);
MonklandSteamManager.instance.SendPacketToAll(packet, true, EP2PSend.k_EP2PSendReliable);
}
public void SendReady()
{
MonklandSteamManager.DataPacket packet = MonklandSteamManager.instance.GetNewPacket(CHANNEL, UtilityHandler);
BinaryWriter writer = MonklandSteamManager.instance.GetWriterForPacket(packet);
//Write message type
writer.Write((byte)0);
//Write if the player is ready
writer.Write(isReady);
MonklandSteamManager.instance.FinalizeWriterToPacket(writer, packet);
MonklandSteamManager.instance.SendPacketToAll(packet, false, EP2PSend.k_EP2PSendReliable);
}
public void SendPlayersToGame()
{
if (readiedPlayers.Count != MonklandSteamManager.connectedPlayers.Count)
{
return;
}
MonklandSteamManager.DataPacket packet = MonklandSteamManager.instance.GetNewPacket(DEFAULT_CHANNEL, UtilityHandler);
BinaryWriter writer = MonklandSteamManager.instance.GetWriterForPacket(packet);
//Write message type
writer.Write((byte)1);
MonklandSteamManager.instance.FinalizeWriterToPacket(writer, packet);
MonklandSteamManager.instance.SendPacketToAll(packet, false, EP2PSend.k_EP2PSendReliable);
}
public void SendPlayersToGame()
{
if (!isManager)
{
return;
}
readiedPlayers.Clear();
MonklandSteamManager.DataPacket packet = MonklandSteamManager.instance.GetNewPacket(CHANNEL, UtilityHandler);
BinaryWriter writer = MonklandSteamManager.instance.GetWriterForPacket(packet);
//Write message type
writer.Write((byte)UtilMessageType.SentToGame);
MonklandSteamManager.instance.FinalizeWriterToPacket(writer, packet);
MonklandSteamManager.instance.SendPacketToAll(packet, false, EP2PSend.k_EP2PSendReliable);
}
public void SendColor(int colorID)
{
MonklandSteamManager.DataPacket packet = MonklandSteamManager.instance.GetNewPacket(CHANNEL, UtilityHandler);
BinaryWriter writer = MonklandSteamManager.instance.GetWriterForPacket(packet);
if (!MonklandSteamManager.connectedPlayers.Contains(playerID))
{
return;
}
//Write message type
writer.Write(Convert.ToByte(colorID + 2));
if (colorID == 0) //colorID used to distiquish which color value is being sent
{
writer.Write(Convert.ToByte((int)(playerColors[MonklandSteamManager.connectedPlayers.IndexOf(playerID)].r * 255f))); //Write red body color
}
else if (colorID == 1)
{
writer.Write(Convert.ToByte((int)(playerColors[MonklandSteamManager.connectedPlayers.IndexOf(playerID)].g * 255f)));//Write green body color
}
else if (colorID == 2)
{
writer.Write(Convert.ToByte((int)(playerColors[MonklandSteamManager.connectedPlayers.IndexOf(playerID)].b * 255f)));//Write blue body color
}
else if (colorID == 3)
{
writer.Write(Convert.ToByte((int)(playerEyeColors[MonklandSteamManager.connectedPlayers.IndexOf(playerID)].r * 255f)));//Write red eye color
}
else if (colorID == 4)
{
writer.Write(Convert.ToByte((int)(playerEyeColors[MonklandSteamManager.connectedPlayers.IndexOf(playerID)].g * 255f)));//Write green eye color
}
else if (colorID == 5)
{
writer.Write(Convert.ToByte((int)(playerEyeColors[MonklandSteamManager.connectedPlayers.IndexOf(playerID)].b * 255f))); //Write blue eye color
}
else
{
writer.Write((byte)0); //Write default color
}
MonklandSteamManager.instance.FinalizeWriterToPacket(writer, packet);
MonklandSteamManager.instance.SendPacketToAll(packet, true, EP2PSend.k_EP2PSendReliableWithBuffering);
}
public void GameStart()
{
this.sessionTotalCycles++;
this.timer = 0;
if (!ingamePlayers.Contains(playerID))
{
ingamePlayers.Add(playerID);
}
if (!roomDict.ContainsKey(playerID))
{
roomDict.Add(playerID, new List <int>());
}
MonklandSteamManager.Log($"[World] Sending game start packet: {ingamePlayers.Count} players ingame");
foreach (ulong player in ingamePlayers)
{
MonklandSteamManager.Log(player);
}
gameRunning = true;
MonklandSteamManager.DataPacket packet = MonklandSteamManager.instance.GetNewPacket(WORLD_CHANNEL, WorldHandler);
BinaryWriter writer = MonklandSteamManager.instance.GetWriterForPacket(packet);
//Write message type
writer.Write(Convert.ToByte(0));
writer.Write(true);
MonklandSteamManager.instance.FinalizeWriterToPacket(writer, packet);
//MonklandSteamManager.instance.SendPacket(packet, (CSteamID)managerID), EP2PSend.k_EP2PSendReliable);
MonklandSteamManager.instance.SendPacketToAll(packet, true, EP2PSend.k_EP2PSendReliable);
if (isManager)
{
foreach (ulong pl in ingamePlayers)
{
if (pl != playerID)
{
SyncCycle((CSteamID)pl);
}
syncDelay = 1000;
}
}
}
public void GameEnd()
{
if (ingamePlayers.Contains(playerID))
{
ingamePlayers.Remove(playerID);
}
MonklandSteamManager.Log($"[World] Sending game end packet: {ingamePlayers.Count} players ingame");
roomDict.Clear();
roomDict.Add(playerID, new List <int>());
gameRunning = false;
MonklandSteamManager.DataPacket packet = MonklandSteamManager.instance.GetNewPacket(WORLD_CHANNEL, WorldHandler);
BinaryWriter writer = MonklandSteamManager.instance.GetWriterForPacket(packet);
//Write message type
writer.Write(Convert.ToByte(0));
writer.Write(false);
MonklandSteamManager.instance.FinalizeWriterToPacket(writer, packet);
//MonklandSteamManager.instance.SendPacket(packet, (CSteamID)managerID), EP2PSend.k_EP2PSendReliable);
MonklandSteamManager.instance.SendPacketToAll(packet, true, EP2PSend.k_EP2PSendReliable);
}
public void Send(PhysicalObject physicalObject, List <ulong> targets)
{
try
{
if (physicalObject == null || targets == null || targets.Count == 0 || physicalObject.room == null || physicalObject.room.abstractRoom == null)
{
return;
}
MonklandSteamManager.DataPacket packet = MonklandSteamManager.instance.GetNewPacket(CHANNEL, UtilityHandler);
BinaryWriter writer = MonklandSteamManager.instance.GetWriterForPacket(packet);
if ((physicalObject as PhysicalObject) is Player)
{
writer.Write((byte)PacketType.Player);
writer.Write(physicalObject.room.abstractRoom.name);
writer.Write((physicalObject.abstractPhysicalObject as patch_AbstractPhysicalObject).dist);
WorldCoordinateHandler.Write(physicalObject.abstractPhysicalObject.pos, ref writer);
PlayerHandler.Write(physicalObject as PhysicalObject as Player, ref writer);
}
else
{
return;
}
MonklandSteamManager.instance.FinalizeWriterToPacket(writer, packet);
foreach (ulong target in targets)
{
if (MonklandSteamManager.WorldManager.ingamePlayers.Contains(target))
{
if (target != playerID)
{
MonklandSteamManager.instance.SendPacket(packet, (CSteamID)target, EP2PSend.k_EP2PSendUnreliableNoDelay);
}
}
}
}catch (Exception e)
{
Debug.LogError(e);
}
}
public void SendRoomKillRequest(AbstractRoom absRoom)
{
if (requestedKillRooms.Contains(absRoom.index))
{
return;
}
MonklandSteamManager.DataPacket dataPacket = MonklandSteamManager.instance.GetNewPacket(GAMEMANAGEMENT_CHANNEL, RoomHandler);
BinaryWriter writer = MonklandSteamManager.instance.GetWriterForPacket(dataPacket);
//Writes the message type
writer.Write(RoomKillRequestID);
//Send room ID that we want to activate
writer.Write(absRoom.index);
MonklandSteamManager.instance.FinalizeWriterToPacket(writer, dataPacket);
MonklandSteamManager.instance.SendPacket(dataPacket, (CSteamID)NetworkGameManager.managerID, EP2PSend.k_EP2PSendReliable);
requestedKillRooms.Add(absRoom.index);
MonklandUI.AddMessage("Requested realization of room " + absRoom.index);
Debug.Log("Requested killing of room " + absRoom.index);
}
public void ActivateRoom(string roomName)
{
if (!roomDict.ContainsKey(playerID))
{
roomDict.Add(playerID, new List <string>());
}
if (!roomDict[playerID].Contains(roomName))
{
roomDict[playerID].Add(roomName);
}
MonklandSteamManager.DataPacket packet = MonklandSteamManager.instance.GetNewPacket(WORLD_CHANNEL, WorldHandler);
BinaryWriter writer = MonklandSteamManager.instance.GetWriterForPacket(packet);
//Write message type
writer.Write(Convert.ToByte(2));
writer.Write(roomName);
MonklandSteamManager.instance.FinalizeWriterToPacket(writer, packet);
//MonklandSteamManager.instance.SendPacket(packet, (CSteamID)managerID), EP2PSend.k_EP2PSendReliable);
MonklandSteamManager.instance.SendPacketToAll(packet, true, EP2PSend.k_EP2PSendReliable);
CheckForCommonRooms();
}
