public void OnClientConnected(H3Server server, Peer peer)
{
byte count = (byte)server._husks.Count;
byte max = server._config.PlayerLimit.Value;
var level = new LevelChangeMessage(HarmonyState.CurrentLevel);
var players = new PlayerJoinMessage[count];
{
var i = 0;
foreach (var husk in server._husks)
{
players[i++] = new PlayerJoinMessage(husk.Key, husk.Value.Latest);
}
}
peer.Send(new InitMessage(server._partyID, server.Secret, max, level, players));
// Find first available player ID.
byte id;
for (id = 0; id < byte.MaxValue; ++id)
{
if (!server._husks.ContainsKey(id))
{
break;
}
}
var peerHusk = new Husk(server._selfID == peer.ID);
server._peerIDs.Add(peer, id);
server._husks.Add(id, peerHusk);
// Initialize just-joined puppet on other clients
server.BroadcastExcept(peer, new PlayerJoinMessage(id, Timestamped <PlayerTransformsMessage> .Now(default)));
private static void ProcessPlayerJoinMessage(PlayerJoinMessage playerJoinMessage)
{
var prefab = Resources.Load <GameObject>("Prefabs/MainHero");
var instantiate = Object.Instantiate(prefab, new Vector3(0, 0, 0), Quaternion.identity);
instantiate.name = playerJoinMessage.PlayerId;
}
void OnData(DataStreamReader stream, int i)
{
NativeArray <byte> bytes = new NativeArray <byte>(stream.Length, Allocator.Temp);
stream.ReadBytes(bytes);
string recMsg = Encoding.ASCII.GetString(bytes.ToArray());
NetworkHeader header = JsonUtility.FromJson <NetworkHeader>(recMsg);
switch (header.cmd)
{
case Commands.HANDSHAKE:
HandshakeMsg hsMsg = JsonUtility.FromJson <HandshakeMsg>(recMsg);
Debug.Log("Handshake message received!");
break;
case Commands.PLAYER_UPDATE:
PlayerUpdateMsg puMsg = JsonUtility.FromJson <PlayerUpdateMsg>(recMsg);
Debug.Log("Player update message received!");
Debug.Log("Player List: " + serverPlayerList);
foreach (NetworkObjects.NetworkPlayer player in serverPlayerList)
{
if (player.id == puMsg.player.id)
{
player.cubeColor = puMsg.player.cubeColor;
player.cubPos = puMsg.player.cubPos;
player.cubRot = puMsg.player.cubRot;
}
}
break;
case Commands.PLAYER_BULLET:
PlayerBulletMsg pbMsg = JsonUtility.FromJson <PlayerBulletMsg>(recMsg);
Debug.Log("Player Bullet Fired!");
FireBulletForPlayers(pbMsg, m_Connections[i]);
break;
case Commands.PLAYER_JOINED:
PlayerJoinMessage pjMsg = JsonUtility.FromJson <PlayerJoinMessage>(recMsg);
Debug.Log("Player join message received!");
CreatePlayer(pjMsg, m_Connections[i]);
break;
case Commands.SERVER_UPDATE:
ServerUpdateMsg suMsg = JsonUtility.FromJson <ServerUpdateMsg>(recMsg);
Debug.Log("Server update message received!");
break;
case Commands.PLAYER_LEFT:
PlayerLeaveMsg plMsg = JsonUtility.FromJson <PlayerLeaveMsg>(recMsg);
Debug.Log("Player leave message recieved!");
OnDisconnect(int.Parse(plMsg.player.id));
break;
default:
Debug.Log("SERVER ERROR: Unrecognized message received!");
break;
}
}
private void AddPlayer(PlayerJoinMessage message)
{
var puppet = new Puppet(_log, _config.Puppet, () => _time, _tickDeltaTime);
puppet.ProcessTransforms(message.Transforms);
_players.Add(message.ID, puppet);
}
internal void AddPlayer(NetIncomingMessage msg)
{
int msgLength = msg.ReadInt32();
byte[] msgContents = msg.ReadBytes(msgLength);
PlayerJoinMessage joinMsg = (PlayerJoinMessage)SerializationHandler.ByteArrayToObject(msgContents);
PlayerAttributes player = new PlayerAttributes(joinMsg.name, joinMsg.playerID, joinMsg.isHost, new Vector2(joinMsg.posX, joinMsg.posY));
game.GameData.players.Add(player);
}
public void OnPlayerJoin(NetworkMessage message)
{
PlayerJoinMessage joinMessage = message.ReadMessage <PlayerJoinMessage>();
if (joinMessage == null)
{
return;
}
AddCharacter((int)joinMessage.characterId);
}
IEnumerator SendPlayerInformation()
{
yield return(new WaitForSeconds(0.2f));
Debug.Log("Creating Player");
PlayerJoinMessage pm = new PlayerJoinMessage();
pm.player.cubeColor = UnityEngine.Random.ColorHSV(0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f);
pm.player.cubPos = new Vector3(UnityEngine.Random.Range(-50.0f, 50.0f), 0.0f, UnityEngine.Random.Range(-50.0f, 50.0f));
pm.player.cubRot = new Quaternion();
pm.player.Username = PlayerPrefs.GetString("Player_Username");
pm.player.playerClass = (Classes)int.Parse(PlayerPrefs.GetString("Player_Class"));
pm.player.level = int.Parse(PlayerPrefs.GetString("Player_Level"));
pm.player.health = int.Parse(PlayerPrefs.GetString("Player_Health"));
pm.player.score = int.Parse(PlayerPrefs.GetString("Player_Score"));
SendToServer(JsonUtility.ToJson(pm));
while (true)
{
PlayerUpdateMsg pum = new PlayerUpdateMsg();
PlayerBulletMsg pbMsg = new PlayerBulletMsg();
foreach (NetworkObjects.NetworkPlayer player in playerList)
{
if (player.id == clientID)
{
pum.player.id = clientID;
pum.player.cube = player.cube;
pum.player.cubeColor = player.cubeColor;
pum.player.cubPos = player.cubPos;
pum.player.cubRot = player.cubRot;
if (pum.player.cube.GetComponent <Character>().bulletFired)
{
pbMsg.player = player;
pbMsg.clickedLocation = player.cube.GetComponent <Character>().clickPosition;
Debug.Log("Sending Bullet Message Over to Server");
SendToServer(JsonUtility.ToJson(pbMsg));
pbMsg.player.cube.GetComponent <Character>().bulletFired = false;
}
SendToServer(JsonUtility.ToJson(pum));
}
}
yield return(new WaitForSeconds(updateTime));
}
}
public override void OnServerAddPlayer(NetworkConnection conn, short playerControllerId, NetworkReader extraMessageReader)
{
if (playerSpawnDict == null)
{
AssignSpawns(storyNum);
}
if (extraMessageReader == null)
{
return;
}
PlayerJoinMessage message = extraMessageReader.ReadMessage <PlayerJoinMessage>();
if (message == null)
{
return;
}
if (playerManager.IsPlayerJoined(message.characterId))
{
return;
}
connectionIdCharacterId.Add(conn.connectionId, (int)message.characterId);
playerManager.AddCharacter((int)message.characterId);
CharacterSpec spec = playerManager
.FindCharacterSpecById((int)message.characterId);
GameObject player;
if (spec != null)
{
player = playerManager.InstantiateCharacter(spec, playerPrefab, GetPlayerSpawn(spec.FullName));
}
else
{
player = Instantiate(playerPrefab);
player.transform.position = GetStartPosition().position;
}
NetworkServer.AddPlayerForConnection(conn, player, playerControllerId);
Debug.Log("network server adding player");
//rpc call to all clients to assign info to prefabs
if (spec != null)
{
SpawnAllServerAndClientClues(player);
if (spec.FullName == this.murderer)
{
player.GetComponent <Player>().RpcSetInformation((int)message.characterId, true);
player.GetComponent <Player>().SetMurderer(true);
}
else
{
player.GetComponent <Player>().RpcSetInformation((int)message.characterId, false);
}
}
}
public override void OnClientConnect(NetworkConnection conn)
{
base.OnClientConnect(conn);
// you can send the message here, or wherever else you want
PlayerJoinMessage characterMessage = new PlayerJoinMessage
{
Deck = "",
Team = MatchSession.Current.LocalPlayer.Data.Team.Name
};
conn.Send(characterMessage);
}
void CreatePlayer(PlayerJoinMessage pjMsg, NetworkConnection c)
{
pjMsg.player.id = c.InternalId.ToString();
serverPlayerList.Add(pjMsg.player);
for (int i = 0; i < m_Connections.Length; i++)
{
//if (m_Connections[i] != c)
//{
SendToClient(JsonUtility.ToJson(pjMsg), m_Connections[i]);
//}
}
}
public void PlayerJoined(NetIncomingMessage msg)
{
int msgLength = msg.ReadInt32();
byte[] msgContents = msg.ReadBytes(msgLength);
PlayerJoinMessage joinMsg = (PlayerJoinMessage)SerializationHandler.ByteArrayToObject(msgContents);
PlayerAttributes player = new PlayerAttributes(joinMsg.name, joinMsg.playerID, joinMsg.isHost);
player.position = game.GameData.getSpawnPos();
game.GameData.players.Add(player);
gameServer.clientList.Add(new ClientInfo(msg.SenderConnection, player));
logger.Debug("Player with name " + player.playerName + " added");
ClientPlayerUpdate();
}
private void SendClientPlayerJoinMessage(string heroName)
{
var messageWrapper = new MessageWrapper();
var playerJoinMessage = new PlayerJoinMessage {
PlayerId = heroName
};
var playerJoinMessagePayload = JsonConvert.SerializeObject(playerJoinMessage);
messageWrapper.Payload = playerJoinMessagePayload;
messageWrapper.MessageType = MessageType.PlayerJoin;
var messageWrapperString = JsonConvert.SerializeObject(messageWrapper);
SendMessageToServer(messageWrapperString);
}
void OnPlayerJoin(NetworkConnection conn, PlayerJoinMessage message)
{
// playerPrefab is the one assigned in the inspector in Network
// Manager but you can use different prefabs per race for example
GameObject gameobject = Instantiate(playerPrefab);
// Apply data from the message however appropriate for your game
// Typically Player would be a component you write with syncvars or properties
NetworkedPlayerData player = gameobject.GetComponent <NetworkedPlayerData>();
player.Team = message.Team;
// TODO sync decks
// call this to use this gameobject as the primary controller
NetworkServer.AddPlayerForConnection(conn, gameobject);
}
public void JoinServer()
{
if (joined || client == null)
{
return;
}
joined = true;
Debug.Log("Player joining server");
Debug.Log(settings);
PlayerJoinMessage message = new PlayerJoinMessage(
1,
settings.CharacterId
);
ClientScene.AddPlayer(client.connection, 0, message);
//client.Send(PlayerJoinMessage.MESSAGE_TYPE, message);
}
public void StartNetworked(int port, string address, string playerSessionId, MonoBehaviour parent, DemoSettingsClient settings)
{
var spawnPoint = DemoSettings.GetSpawnPoint();
var playerConfig = DemoSettings.GetPlatformCharacterConfig();
var recieveByGuid = new Dictionary <string, MessageHandler>();
networkStream = NetworkApi.OpenOutbound(port, address, parent);
networkStream.Recieve.Add((opCode, message) => {
if (opCode == OpCode.PLAYER_ACCEPTED)
{
MessageHandler recieve = null;
var acceptMsg = (PlayerAcceptMessage)message;
var isSelf = acceptMsg.playerSessionId.Equals(playerSessionId);
Debug.Log("client (" + playerSessionId + ")" + " accepts (" + acceptMsg.playerGuid + ") as self? " + isSelf);
if (acceptMsg.playerSessionId.Equals(playerSessionId))
{
var spawned = GameObject.Instantiate(settings.playerPrefab, spawnPoint, Quaternion.identity);
var playerComp = spawned.GetComponent <PlayerCompClient>();
recieve = playerComp.RegisterNetwork(networkStream.Send, playerConfig, acceptMsg.PlayerGuid, acceptMsg.trustDistance);
}
else
{
var spawned = GameObject.Instantiate(settings.otherPlayerPrefab, spawnPoint, Quaternion.identity);
var playerComp = spawned.GetComponent <OtherPlayerCompClient>();
recieve = playerComp.RegisterNetwork(playerConfig, settings.interpolation);
}
recieveByGuid[acceptMsg.PlayerGuid] = recieve;
}
else
{
MessageHandler reciever = null;
var found = recieveByGuid.TryGetValue(PlayerGuidUtil.Get(message), out reciever);
if (found)
{
reciever?.Invoke(opCode, message);
}
}
return(1);
});
var joinMessage = new PlayerJoinMessage();
joinMessage.playerSessionId = playerSessionId;
networkStream.Send(OpCode.PLAYER_JOIN, joinMessage);
}
public void Update()
{
if (Input.GetKeyUp(closeKey))
{
outbound.Recieve.GetCancellation().Cancel();
}
if (Input.GetKeyUp(serverCloseKey))
{
inbound.Recieve.GetAcceptCancellation().Cancel();
}
if (Input.GetKey(sendKey))
{
var data = new PlayerJoinMessage();
data.playerSessionId = "1234";
outbound?.Send(OpCode.PLAYER_JOIN, data);
var data2 = new PlayerJoinMessage();
data2.playerSessionId = "xyz";
outbound?.Send(OpCode.PLAYER_JOIN, data2);
}
}
public void PlayerJoin(PlayerJoinMessage message)
{
_logger.LogInformation($"{message.Sender.SteamId} joined");
_world.Players.Add(message.Sender);
ServerPlayerSpawnMessage spawn = new ServerPlayerSpawnMessage
{
Position = new NetworkVector3(0f, 10f, 0f),
Player = message.Sender
};
_messageBroadcaster.Broadcast(spawn);
ServerPlayerListMessage list = new ServerPlayerListMessage
{
Players = _world.Players
};
_messageBroadcaster.Broadcast(list, message.Sender);
}
void OnConnect(NetworkConnection c)
{
m_Connections.Add(c);
Debug.Log("Accepted a connection, Number of Connections: " + m_Connections.Length);
Debug.Log("Number of Players currently in the game: " + serverPlayerList.Count());
// Example to send a handshake message:
HandshakeMsg m = new HandshakeMsg();
m.player.id = c.InternalId.ToString();
SendToClient(JsonUtility.ToJson(m), c);
foreach (NetworkObjects.NetworkPlayer player in serverPlayerList)
{
Debug.Log("Creating a new Player...");
PlayerJoinMessage pjMsg = new PlayerJoinMessage();
pjMsg.player = player;
SendToClient(JsonUtility.ToJson(pjMsg), c);
}
//NetworkObjects.NetworkPlayer connectingPlayer = new NetworkObjects.NetworkPlayer();
//connectingPlayer.id = c.InternalId.ToString();
//connectingPlayer.cubeColor = UnityEngine.Random.ColorHSV(0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f);
//connectingPlayer.cubPos = new Vector3(UnityEngine.Random.Range(-50.0f, 50.0f), 0.0f, UnityEngine.Random.Range(-50.0f, 50.0f));
//connectingPlayer.cubRot = new Quaternion();
//for (int i = 0; i < m_Connections.Length; i++)
//{
// if (m_Connections[i] != c)
// {
// PlayerJoinMessage pjMsg = new PlayerJoinMessage();
// pjMsg.player = connectingPlayer;
// SendToClient(JsonUtility.ToJson(pjMsg), m_Connections[i]);
// }
//}
}
void OnConnect(NetworkConnection c)
{
m_Connections.Add(c);
Debug.Log("Accepted a connection");
// Example to send a handshake message:
HandshakeMsg m = new HandshakeMsg();
m.player.id = c.InternalId.ToString();
SendToClient(JsonUtility.ToJson(m), c);
NetworkObjects.NetworkPlayer connectingPlayer = new NetworkObjects.NetworkPlayer();
connectingPlayer.id = c.InternalId.ToString();
connectingPlayer.cubeColor = UnityEngine.Random.ColorHSV(0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f);
connectingPlayer.cubPos = new Vector3(0.0f, 0.0f, 0.0f);
connectingPlayer.cubRot = new Quaternion();
for (int i = 0; i < m_Connections.Length; i++)
{
if (m_Connections[i] != c)
{
PlayerJoinMessage pjMsg = new PlayerJoinMessage();
pjMsg.player = connectingPlayer;
SendToClient(JsonUtility.ToJson(pjMsg), m_Connections[i]);
}
}
serverPlayerList.Add(connectingPlayer);
foreach (NetworkObjects.NetworkPlayer player in serverPlayerList)
{
PlayerJoinMessage pjMsg2 = new PlayerJoinMessage();
pjMsg2.player = player;
SendToClient(JsonUtility.ToJson(pjMsg2), c);
}
}
/// <summary>
/// Handles a data message (The bulk of all messages received, containing player movements, block places, etc)
/// </summary>
private void HandleDataMessage(NetIncomingMessage im)
{
if (im == null)
{
throw new ArgumentNullException(nameof(im));
}
var type = (MessageTypes)im.ReadByte();
switch (type)
{
case MessageTypes.Init:
{
var msg = new InitMessage(im, MessageContext.Client);
networkManager.Client.Events.Network.Game.InitReceived.Invoke(
new EventManager.NetEvents.GameServerEvents.InitEventArgs(msg));
break;
}
case MessageTypes.Banner:
{
var msg = new BannerMessage(im, MessageContext.Client);
networkManager.Client.Events.Network.Game.LobbyBannerReceived.Invoke(
new EventManager.NetEvents.GameServerEvents.BannerEventArgs(msg.Banner));
break;
}
case MessageTypes.LevelData:
{
var msg = new LevelDataMessage(im, MessageContext.Client);
networkManager.Client.Events.Network.Game.LevelDataReceived.Invoke(
new EventManager.NetEvents.GameServerEvents.LevelDataEventArgs(new Level(msg.Level,
networkManager.Client)));
break;
}
case MessageTypes.Chat:
{
var msg = new ChatMessage(im, MessageContext.Client);
networkManager.Client.Events.Network.Game.ChatReceived.Invoke(
new EventManager.NetEvents.GameServerEvents.ChatEventArgs(msg.Message));
break;
}
case MessageTypes.PlayerJoin:
{
var msg = new PlayerJoinMessage(im, MessageContext.Client);
networkManager.Client.Events.Network.Game.PlayerJoinReceived.Invoke(
new EventManager.NetEvents.GameServerEvents.PlayerJoinEventArgs(msg.Player));
break;
}
case MessageTypes.PingUpdate:
{
var msg = new PingUpdateMessage(im, MessageContext.Client);
networkManager.Client.Events.Network.Game.PingUpdateReceived.Invoke(
new EventManager.NetEvents.GameServerEvents.PingUpdateEventArgs(msg.Pings));
break;
}
case MessageTypes.BlockPlace:
{
if (networkManager.Client.Level != null)
{
var msg = new BlockPlaceMessage(im, MessageContext.Client);
networkManager.Client.Events.Network.Game.BlockPlaceMessageReceived.Invoke(
new EventManager.NetEvents.GameServerEvents.BlockPlacedEventArgs(networkManager.Client.Level,
msg.Point.X,
msg.Point.Y, msg.Layer, msg.Type));
}
break;
}
}
}
/// <summary>
/// Handles a data message (The bulk of all messages recieved, containing player movements, block places, etc)
/// </summary>
private void HandleDataMessage(NetIncomingMessage im)
{
MessageTypes messageType = (MessageTypes)im.ReadByte(); //Find the type of data message sent
switch (messageType)
{
case MessageTypes.Lobby: //Lobby list packet
{
if (Game.CurrentGameState == GameState.Lobby)
{
LobbyScreen screen = MainWindow.ScreenManager.Current as LobbyScreen;
LobbyMessage msg = new LobbyMessage(im);
screen.Name = msg.ServerName;
screen.Description = msg.Description;
screen.Intro = msg.Intro;
screen.Online = msg.Online;
screen.Rooms = msg.Rooms;
screen.Lobby.LoadRooms();
}
break;
}
case MessageTypes.PlayerJoin: //Player join message
{
PlayerJoinMessage user = new PlayerJoinMessage(im);
//Add player to map
Map.Players.Add(new Player(Map, Map.Spawn, user.Username, user.ID)
{
Tint = user.Color
});
//Add user to userlist
(MainWindow.ScreenManager.Current as GameScreen).PlayerList.Items.Add(user.Username);
if (user.ID != Game.MyID && recievedInit) //Broadcast join message to chat
{
(MainWindow.ScreenManager.Current as GameScreen).SystemChat(user.Username + " [color:LightGray]has[/color] [color:LightGreen]joined.[/color]");
}
if (user.Me)
{
//Let game know of it's own player
Game.MyID = user.ID;
Game.MyIndex = (byte)Map.Players.IndexOf(Map.Players.First(x => x.ID == Game.MyID));
Game.Me.Tint = Game.MyColor;
}
break;
}
case MessageTypes.PlayerLeave: //Player leave message
{
PlayerLeaveMessage user = new PlayerLeaveMessage(im);
//Remove player
if (user.ID != Game.MyID)
{
Player player = (Player)Map.PlayerFromID(user.ID);
Map.Players.Remove((Player)Map.PlayerFromID(user.ID));
(MainWindow.ScreenManager.Current as GameScreen).PlayerList.Items.Remove(player.Username);
(MainWindow.ScreenManager.Current as GameScreen).SystemChat(player.Username + " [color:LightGray]has[/color] [color:IndianRed]left.[/color]");
//Rebuild indexes
for (int i = 0; i < Map.Players.Count; i++)
{
Map.Players[i].Index = i;
if (Map.Players[i].ID == Game.MyID)
{
Game.MyIndex = (byte)i;
}
}
}
break;
}
case MessageTypes.PlayerStatus: //Player move message
{
if (Game.CurrentGameState == GameState.Game)
{
PlayerStateMessage user = new PlayerStateMessage(im);
Player player = (Player)Map.PlayerFromID(user.ID);
player.SimulationState.Position = user.Position.ToVector2();
player.SimulationState.Velocity = user.Velocity.ToVector2();
player.SimulationState.Movement = user.Movement.ToVector2();
if (!recievedInit) //If we have not recieved init (meaning we are not in game yet), set the initial positions directly so interpolation doesn't mess with them
{
player.DisplayState.Position = player.SimulationState.Position;
}
player.VirtualJump = user.IsJumping;
}
break;
}
case MessageTypes.Block: //Block place message
{
if (Game.CurrentGameState == GameState.Game)
{
BlockMessage msg = new BlockMessage(im);
BlockType block = BlockType.FromID(msg.BlockID);
if (Map.CanPlaceBlock(msg.X, msg.Y, msg.Z, block))
{
Map.Tiles[msg.X, msg.Y, msg.Z].Block = block;
}
}
break;
}
case MessageTypes.PlayerSmiley: //Smiley change message
{
if (Game.CurrentGameState == GameState.Game)
{
PlayerSmileyMessage msg = new PlayerSmileyMessage(im);
Player p = (Player)Map.PlayerFromID(msg.ID);
p.Smiley = msg.Smiley;
}
break;
}
case MessageTypes.PlayerMode: //Player mode change message
{
if (Game.CurrentGameState == GameState.Game)
{
PlayerModeMessage mode = new PlayerModeMessage(im);
Map.PlayerFromID(mode.ID).Mode = (PlayerMode)mode.Mode;
}
break;
}
case MessageTypes.Chat: //Chat message
{
if (Game.CurrentGameState == GameState.Game)
{
ChatMessage chat = new ChatMessage(im);
(MainWindow.ScreenManager.Current as GameScreen).AddChat(Map.PlayerFromID(chat.ID).Username, chat.Message);
}
break;
}
case MessageTypes.Init: //Initialization message with world data
{
Game.Map = new Bricklayer.Client.World.Map(game, 1, 1);
InitMessage msg = new InitMessage(im, Map);
Game.Map.Minimap = new Minimap(Game.Map, msg.Width, msg.Height)
{
Position = new Microsoft.Xna.Framework.Vector2(8, 8)
};
Game.Map.CreateCamera();
Game.CurrentGameState = GameState.Game;
(MainWindow.ScreenManager.Current as GameScreen).Show();
(MainWindow.ScreenManager.Current as GameScreen).SystemChat("Connected to [color:LightGray]" + Game.Host + ":" + Game.Port + "[/color]");
recievedInit = true;
break;
}
}
}
void OnData(DataStreamReader stream)
{
NativeArray <byte> bytes = new NativeArray <byte>(stream.Length, Allocator.Temp);
stream.ReadBytes(bytes);
string recMsg = Encoding.ASCII.GetString(bytes.ToArray());
NetworkHeader header = JsonUtility.FromJson <NetworkHeader>(recMsg);
Debug.Log("Got this: " + header.cmd);
switch (header.cmd)
{
case Commands.HANDSHAKE:
HandshakeMsg hsMsg = JsonUtility.FromJson <HandshakeMsg>(recMsg);
Debug.Log("Handshake message received!");
clientID = hsMsg.player.id;
Debug.Log("Id: " + clientID);
break;
case Commands.PLAYER_UPDATE:
PlayerUpdateMsg puMsg = JsonUtility.FromJson <PlayerUpdateMsg>(recMsg);
Debug.Log("Player update message received!");
break;
case Commands.PLAYER_BULLET:
PlayerBulletMsg pbMsg = JsonUtility.FromJson <PlayerBulletMsg>(recMsg);
Debug.Log("Player Bullet Fired Message Recieved!");
GameObject.Instantiate(bulletRef, (pbMsg.player.cubPos + (pbMsg.clickedLocation - pbMsg.player.cubPos).normalized), Quaternion.LookRotation((pbMsg.clickedLocation - pbMsg.player.cubPos).normalized));
break;
case Commands.PLAYER_JOINED:
PlayerJoinMessage pjMsg = JsonUtility.FromJson <PlayerJoinMessage>(recMsg);
Debug.Log("Player join message received!");
pjMsg.player.cube = Instantiate(cubeRef);
pjMsg.player.cube.GetComponent <Renderer>().material.SetColor("_Color", pjMsg.player.cubeColor);
if (pjMsg.player.id == clientID)
{
pjMsg.player.cube.GetComponent <Character>().networkManRef = this;
pjMsg.player.cube.GetComponent <Character>().playerRef = pjMsg.player;
}
else
{
pjMsg.player.cube.GetComponent <Character>().setStats();
}
playerList.Add(pjMsg.player);
break;
case Commands.SERVER_UPDATE:
suMsg = JsonUtility.FromJson <ServerUpdateMsg>(recMsg);
Debug.Log("Server update message received!");
foreach (NetworkObjects.NetworkPlayer clientPlayer in playerList)
{
if (clientPlayer.id == clientID)
{
}
else
{
foreach (NetworkObjects.NetworkPlayer serverPlayer in suMsg.players)
{
if (serverPlayer.id == clientPlayer.id)
{
clientPlayer.cube.transform.position = serverPlayer.cubPos;
}
else
{
}
}
}
}
break;
case Commands.PLAYER_LEFT:
PlayerLeaveMsg plMsg = JsonUtility.FromJson <PlayerLeaveMsg>(recMsg);
Debug.Log("Player Leave message received!");
KillClientPlayer(plMsg.player);
OnDisconnect();
break;
default:
Debug.Log("Unrecognized message received!");
break;
}
}
public void SetPluginVariable(string variable, string value)
{
if (variable.Equals("IGNORE"))
return;
ConsoleDebug(variable + " = " + value);
if (variable.Contains("Debug"))
debug = bool.Parse(value);
else if (variable.Contains("Add a message"))
{
if (value.Equals("Choose..."))
return;
Message message = null;
switch ((MessageTrigger)Enum.Parse(typeof(MessageTrigger), value))
{
case MessageTrigger.PLAYER_JOIN:
message = new PlayerJoinMessage(this, "Player Join Message #" + messages.Count, MessageType.SAY, MessageDestination.ALL, "");
break;
case MessageTrigger.PLAYER_SPAWN:
message = new PlayerSpawnMessage(this, "Player Spawn Message #" + messages.Count, MessageType.SAY, MessageDestination.ALL, "");
break;
case MessageTrigger.TICKET_COUNT:
message = new TicketCountMessage(this, "Ticket Count Message #" + messages.Count, MessageType.SAY, "", 0);
break;
case MessageTrigger.TIMED_COUNTER:
message = new TimedCounterMessage(this, "Timed Counter Message #" + messages.Count, MessageType.SAY, "", 0);
break;
}
messages.Add(message);
message.enable();
}
else if (variable.Contains("trigger"))
{
string name = variable.Substring(0, variable.IndexOf(" - ")).Trim();
if (name.Contains("|"))
name = name.Substring(0, name.IndexOf("|")).Trim();
if (value.Equals("Remove"))
{
Message toRemove = messages.Find((m) => m.name.Equals(name));
toRemove.disable();
messages.Remove(toRemove);
}
else
{
int toChangeLoc = -1;
for (int a = 0; a < messages.Count; a++)
if (messages[a].name.Equals(name))
{
toChangeLoc = a;
break;
}
if (toChangeLoc == -1)
{
//looks like an un-added message, must be loading settings
Message message = null;
switch ((MessageTrigger)Enum.Parse(typeof(MessageTrigger), value))
{
case MessageTrigger.PLAYER_JOIN:
message = new PlayerJoinMessage(this, name, MessageType.SAY, MessageDestination.ALL, "");
break;
case MessageTrigger.PLAYER_SPAWN:
message = new PlayerSpawnMessage(this, name, MessageType.SAY, MessageDestination.ALL, "");
break;
case MessageTrigger.TICKET_COUNT:
message = new TicketCountMessage(this, name, MessageType.SAY, "", 0);
break;
case MessageTrigger.TIMED_COUNTER:
message = new TimedCounterMessage(this, name, MessageType.SAY, "", 0);
break;
}
messages.Add(message);
message.enable();
}
else
{
messages[toChangeLoc].disable();
switch ((MessageTrigger)Enum.Parse(typeof(MessageTrigger), value))
{
case MessageTrigger.PLAYER_JOIN:
if (messages[toChangeLoc].GetType() == typeof(PlayerJoinMessage))
break;
messages[toChangeLoc] = new PlayerJoinMessage(messages[toChangeLoc]);
break;
case MessageTrigger.PLAYER_SPAWN:
if (messages[toChangeLoc].GetType() == typeof(PlayerSpawnMessage))
break;
messages[toChangeLoc] = new PlayerSpawnMessage(messages[toChangeLoc]);
break;
case MessageTrigger.TICKET_COUNT:
if (messages[toChangeLoc].GetType() == typeof(TicketCountMessage))
break;
messages[toChangeLoc] = new TicketCountMessage(messages[toChangeLoc]);
break;
case MessageTrigger.TIMED_COUNTER:
if (messages[toChangeLoc].GetType() == typeof(TimedCounterMessage))
break;
messages[toChangeLoc] = new TimedCounterMessage(messages[toChangeLoc]);
break;
}
messages[toChangeLoc].enable();
}
}
}
else
{
string name = variable.Substring(0, variable.IndexOf(" - ")).Trim();
if (name.Contains("|"))
name = name.Substring(0, name.IndexOf("|")).Trim();
Message message = messages.Find((m) => m.name.Equals(name));
if (message == null)
{
if (name.Contains("|"))
name = name.Substring(0, name.IndexOf("|")).Trim();
//looks like an un-added message, must be loading settings
message = new PlayerSpawnMessage(this, name, MessageType.SAY, MessageDestination.ALL, "");
messages.Add(message);
message.enable();
}
message.setVariable(variable, value);
}
}
