private object OnPlayerChat(PlayerIdentity identity, NetworkMessageInfo info, string message)
{
if (message.Trim().Length <= 1) return true;
var str = message.Substring(0, 1);
// Is it a chat command?
if (str.Equals("/") || str.Equals("!"))
{
// Get the arg string
var argstr = message.Substring(1);
// Parse it
string chatcmd;
string[] args;
ParseChatCommand(argstr, out chatcmd, out args);
if (chatcmd == null) return null;
// Handle it
if (!cmdlib.HandleChatCommand(identity, info, chatcmd, args))
{
ChatManager.Instance.AppendChatboxServerSingle($"<color=#b8d7a3>Unknown command: {chatcmd}</color>", info.sender);
return true;
}
return true;
}
return null;
}
private void OnSerializeNetworkView(BitStream stream, NetworkMessageInfo info)
{
if (started)
{
if (stream.isWriting)
{
int ss = 4;
int turn = 4;
int x = 9;
int y = 9;
if (sendState == 1 && isServer)
{
ss = sendState;
turn = app.controller.turns.Turn;
Debug.Log("Serwer Wysyłanie - SetUp: " + "State: " + ss + ", Turn " + turn + ", x, y :" + x + ", " + y);
}
else if (sendState == 1 && !isServer)
{
Debug.Log("Client Wysyłanie - SetUp: Waiting for setup, moj stan: " + sendState);
}
else if (sendState == 2 && !isServer)
{
Debug.Log("Client Wysyłanie - Waiting, moj stan: " + sendState);
ss = sendState;
}
else if (sendState == 2 && isServer)
{
Debug.Log("Serwer Wysyłanie - Waiting, moj stan: " + sendState);
ss = sendState;
}
else if (sendState == 3)
{
ss = sendState;
x = xToSend[0];
y = yToSend[0];
Debug.Log("Send Sendstate: " + ss + " mode: " + app.controller.gameMode.mode);
Debug.Log("Send Move: " + x + " - " + y + " mode: " + app.controller.gameMode.mode);
xToSend.RemoveAt(0);
yToSend.RemoveAt(0);
if (xToSend.Count == 0)
{
sendState = 2;
}
}
string all = ss.ToString() + turn.ToString() + x.ToString() + y.ToString();
int toSend = int.Parse(all);
Debug.Log("Do wysłania (klient/serwer): " + toSend);
stream.Serialize(ref toSend);
}
else
{
int recived = 4499;
stream.Serialize(ref recived);
Debug.Log("Odbieranie (Klient/Serwer): " + recived);
string all = recived.ToString();
Debug.Log("Odbieranie (Klient/Serwer): (string) " + all);
int ss = int.Parse(all [0].ToString());
int turn = int.Parse(all [1].ToString());
int x = int.Parse(all [2].ToString());
int y = int.Parse(all [3].ToString());
Debug.Log("Odbieranie (Klient/Serwer): " + "State: " + ss + ", Turn " + turn + ", x, y :" + x + ", " + y);
if (isServer && sendState == 1 && ss == 2)
{
Debug.Log("Serwer Odbieranie - SetUp: " + " Potwierdzenie ustawienia tury klienta");
app.controller.bluetooth.ServerClientMultiplayerWindow.SetActive(false);
this.ChangeState(2);
}
else if (!isServer && sendState == 1 && ss == 1)
{
app.controller.turns.SetTurnBeforeStart(turn);
app.controller.bluetooth.ServerClientMultiplayerWindow.SetActive(false);
Debug.Log("Client Odbieranie - SetUp: " + "Ustawiam ture na " + turn);
Debug.Log("Stan przed ustawieniem: " + sendState);
Debug.Log("Ustawiam na waiting (2)");
this.ChangeState(2);
Debug.Log("Stan po ustawieniu: " + sendState);
}
else if (ss == 3)
{
Debug.Log("Recive Move: " + x + " - " + y + " mode: " + app.controller.gameMode.mode);
PrepareClick(x, y);
}
}
}
}
void OnSerializeNetworkView(BitStream stream, NetworkMessageInfo info)
{
callIfExist(idOnSerializeNetworkView, stream, info);
}
private void B(NetworkMessageInfo info)
{
}
private void M(NetworkMessageInfo info)
{
ui.OnServerRestartPolling();
}
private void K(NetworkMessageInfo info)
{
ui.OnServerSelection(true);
}
private void I(NetworkMessageInfo info)
{
ui.OnServerImmediate(true);
}
private void G(NetworkMessageInfo info)
{
ui.OnServerCancel();
}
// Used to customize synchronization of variables in a script watched by a network view.
void OnSerializeNetworkView(BitStream stream, NetworkMessageInfo info)
{
AddMessage("OnSerializeNetworkView: " + info);
}
// Called on objects which have been network instantiated with Network.Instantiate.
void OnNetworkInstantiate(NetworkMessageInfo info)
{
AddMessage("OnNetworkInstantiate: " + info);
}
protected override void RunItem(LineFS t)
{
var model = GetProperty(new LineArgs
{
Path = _file.Path,
iLine = t.iLine,
Line = t.Text
});
if (model.Direction == NetworkDirection.Na)
{
return;
}
var networkMessageName = model.FindPropertyValue(Keywords.NETWORK_MESSAGE_NAME);
var dateTimeString = model.FindPropertyValue(Keywords.DATETIME);
DateTime dateTime;
DateTimeExt.TryParseWithTimeZoneRemoval(dateTimeString, out dateTime);
var x = new NetworkMessageInfo
{
Source = new NetworkPacketInfo
{
FilePath = _file.Path,
iLine = t.iLine,
Direction = model.Direction,
NetworkMessageName = networkMessageName,
DateTime = dateTime
}
};
string receiverIp = null;
string receiverPort = null;
string receiverHost = null;
string senderIp = null;
string senderPort = null;
string senderHost = null;
foreach (var prop in model.Properties)
{
if (prop.Value == null)
{
continue;
}
var value = prop.Value.ToString();
x.Source.Values.Add(new ValuePair
{
Name = prop.Name,
Value = value
});
switch (prop.Name)
{
case Keywords.RECEIVER_IP:
receiverIp = value;
break;
case Keywords.RECEIVER_HOST:
receiverHost = value;
break;
case Keywords.RECEIVER_PORT:
receiverPort = value;
break;
case Keywords.SENDER_IP:
senderIp = value;
break;
case Keywords.SENDER_HOST:
senderHost = value;
break;
case Keywords.SENDER_PORT:
senderPort = value;
break;
}
}
lock (Network)
{
switch (model.Direction)
{
case NetworkDirection.Na:
Log.Write("A direction of NA should never be added as a Node!", typeof(BuildFileNetworkMessagesLoop).FullName, MethodBase.GetCurrentMethod().Name);
break;
case NetworkDirection.Send:
case NetworkDirection.SendBlocking:
x.Source.Node = NodeBase.FormatIpAndHostHame(senderIp, senderHost);
if (!IsNullOrBlank(receiverIp) ||
!IsNullOrBlank(receiverPort) ||
!IsNullOrBlank(receiverHost))
{
AddNode(t, receiverIp, receiverPort, receiverHost, NodeSource.Remote, x);
}
if (!IsNullOrBlank(senderIp) ||
!IsNullOrBlank(senderPort) ||
!IsNullOrBlank(senderHost))
{
AddNode(t, senderIp, senderPort, senderHost, NodeSource.Local, x, _file.SourceType);
}
break;
case NetworkDirection.Receive:
x.Source.Node = NodeBase.FormatIpAndHostHame(receiverIp, receiverHost);
if (!IsNullOrBlank(senderIp) ||
!IsNullOrBlank(senderPort) ||
!IsNullOrBlank(senderHost))
{
AddNode(t, senderIp, senderPort, senderHost, NodeSource.Remote, x);
}
if (!IsNullOrBlank(receiverIp) ||
!IsNullOrBlank(receiverPort) ||
!IsNullOrBlank(receiverHost))
{
AddNode(t, receiverIp, receiverPort, receiverHost, NodeSource.Local, x, _file.SourceType);
}
break;
default:
throw new ArgumentOutOfRangeException();
}
var msg = Network.NetworkMessages.FirstOrDefault(n => n.Source.iLine == x.Source.iLine);
if (msg == null)
{
Network.NetworkMessages.Add(x);
}
else
{
msg.Source.Values = x.Source.Values;
}
}
}
private void AddNode(LineFS lineFs, string ip, string port, string hostName, NodeSource nodeSource, NetworkMessageInfo source, string sourceType = null)
{
if (_file.Start > _file.End)
{
throw new DateTimeExt.InvalidDateRangeException();
}
var node = new Node
{
Ip = ip,
Port = port,
Host = hostName,
iLine = lineFs.iLine,
Source = nodeSource,
SourceStart = _file.Start,
SourceEnd = _file.End
};
// Check if the Node already exists
var found =
Network.Nodes.Any(
n => n.Ip == node.Ip && n.Host == node.Host);
if (found)
{
return;
}
if (sourceType == null)
{
var results = NetworkMapService.GetNetworkMapFiles(lineFs.Text, source);
switch (results.Count)
{
case 0:
node.SourceType = Keywords.NO_FILE;
break;
case 1:
node.SourceType = results[0].File.SourceType;
break;
default:
node.SourceType = "Multiple Files";
break;
}
}
else
{
node.SourceType = sourceType;
}
// Here we would need to find the target file to determine Source Type
Network.Nodes.Add(node);
}
public static bool QueueOrExecute(IInterpTimedEventReceiver receiver, bool immediate, string tag, ref NetworkMessageInfo info, params object[] args)
{
MonoBehaviour behaviour = receiver as MonoBehaviour;
InterpTimedEvent evnt = New(behaviour, tag, ref info, args, immediate);
if (evnt == null)
{
return(false);
}
if (immediate)
{
InvokeDirect(evnt);
}
else if (!InterpTimedEventSyncronizer.available)
{
Debug.LogWarning("Not running event because theres no syncronizer available. " + tag, receiver as Object);
return(false);
}
return(true);
}
public static bool QueueOrExecute(IInterpTimedEventReceiver receiver, bool immediate, string tag, ref NetworkMessageInfo info)
{
return(QueueOrExecute(receiver, immediate, tag, ref info, emptyArgs));
}
public static bool Queue(IInterpTimedEventReceiver receiver, string tag, ref NetworkMessageInfo info, params object[] args)
{
return(QueueOrExecute(receiver, false, tag, ref info, args));
}
private void F(NetworkMessageInfo info)
{
ui.OnServerNoOp();
}
public NetworkSerializationEventArgs(BitStream bs, NetworkMessageInfo info)
{
m_BitStream = bs;
m_MessageInfo = info;
}
private void H(NetworkMessageInfo info)
{
ui.OnServerImmediate(false);
}
public NetworkInstantiateEventArgs(NetworkMessageInfo info)
{
m_MessageInfo = info;
}
private void J(NetworkMessageInfo info)
{
ui.OnServerSelection(false);
}
/// <summary>Called on objects which have been network instantiated with Network.</summary>Instantiate.</summary>
public virtual void OnNetworkInstantiate(NetworkMessageInfo info)
{
}
private void L(NetworkMessageInfo info)
{
ui.OnServerSelectionStale();
}
/// <summary>Used to customize synchronization of variables in a script watched by a network view.</summary>
public virtual void OnSerializeNetworkView(BitStream stream, NetworkMessageInfo info)
{
}
private void A(NetEntityID hit, NetworkMessageInfo info)
{
}
//---------------------------------------------------------------------
void OnSerializeNetworkView(BitStream stream, NetworkMessageInfo info)
{
// SENDING
if (stream.isWriting)
{
}
// RECEIVING
else
{
// Tachometer Values
stream.Serialize(ref vehicleSpeed);
stream.Serialize(ref vehicleRPM);
// Vehicle Positions
stream.Serialize(ref wbConcreteMixerPosition);
stream.Serialize(ref wbConcretePumpPosition);
stream.Serialize(ref wbDepositTipperPosition);
stream.Serialize(ref wbEscortSchleicherPosition);
stream.Serialize(ref wbExcavatorPosition);
stream.Serialize(ref wbFlatbedTruckPosition);
stream.Serialize(ref wbFlatTopCranePosition);
stream.Serialize(ref wbForkLiftPosition);
stream.Serialize(ref wbFrontLoaderPosition);
stream.Serialize(ref wbGeneratorTrailerPosition);
stream.Serialize(ref wbHalfpipeTruckPosition);
stream.Serialize(ref wbHeavyDutyTrailerPosition);
stream.Serialize(ref wbLittleFlabBedTruckPosition);
stream.Serialize(ref wbLittleHalfpipeTruckPosition);
stream.Serialize(ref wbLowLoaderTrailerPosition);
stream.Serialize(ref wbMiniExcavatorPosition);
stream.Serialize(ref wbPlattmakerPosition);
stream.Serialize(ref wbRotaryDrillingRigPosition);
stream.Serialize(ref wbTowerCranePosition);
stream.Serialize(ref wbTrailerPosition);
stream.Serialize(ref wbTrailerFlatbedPosition);
stream.Serialize(ref wbTrailerSmallPosition);
stream.Serialize(ref wbTruckCranePosition);
// Vehicle Rotations
stream.Serialize(ref wbConcreteMixerRotation);
stream.Serialize(ref wbConcretePumpRotation);
stream.Serialize(ref wbDepositTipperRotation);
stream.Serialize(ref wbEscortSchleicherRotation);
stream.Serialize(ref wbExcavatorRotation);
stream.Serialize(ref wbFlatbedTruckRotation);
stream.Serialize(ref wbFlatTopCraneRotation);
stream.Serialize(ref wbForkLiftRotation);
stream.Serialize(ref wbFrontLoaderRotation);
stream.Serialize(ref wbGeneratorTrailerRotation);
stream.Serialize(ref wbHalfpipeTruckRotation);
stream.Serialize(ref wbHeavyDutyTrailerRotation);
stream.Serialize(ref wbLittleFlabBedTruckRotation);
stream.Serialize(ref wbLittleHalfpipeTruckRotation);
stream.Serialize(ref wbLowLoaderTrailerRotation);
stream.Serialize(ref wbMiniExcavatorRotation);
stream.Serialize(ref wbPlattmakerRotation);
stream.Serialize(ref wbRotaryDrillingRigRotation);
stream.Serialize(ref wbTowerCraneRotation);
stream.Serialize(ref wbTrailerRotation);
stream.Serialize(ref wbTrailerFlatbedRotation);
stream.Serialize(ref wbTrailerSmallRotation);
stream.Serialize(ref wbTruckCraneRotation);
}
}
void OnNetworkInstantiate(NetworkMessageInfo info)
{
callIfExist(idOnNetworkInstantiate, info);
}
void ReceiveSerializeEvent(byte[] bytes, NetworkMessageInfo info)
{
Car.ReceiveSerializeEvent(bytes, info);
}
public void ReceiveBallsInMotion(int BallType, Vector3 Velocity, Vector3 Position, Quaternion Rotation, NetworkPlayer owner, NetworkMessageInfo info)
{
try
{
CreateBall(BallType, Velocity, Position, Rotation, owner);
}
catch (System.Exception e) { }
}
private void C(int name, NetworkMessageInfo info)
{
}
private void E(ContextMenuData options, NetworkMessageInfo info)
{
ui.OnServerMenu(options);
}
void SetDeltaTime(float serverTime, NetworkMessageInfo info)
{
deltaTime = serverTime - (float)info.timestamp;
Debug.Log("Network.time " + Network.time + " Time " + Time.time + " Delta " + deltaTime + " serverTime = " + serverTime.ToString());
}
