public static void triggerOnRegionUpdate()
{
if (NetworkEvents.onRegionUpdate != null)
{
NetworkEvents.onRegionUpdate();
}
}
public static void triggerOnFailed(int id)
{
if (NetworkEvents.onFailed != null)
{
NetworkEvents.onFailed(id);
}
}
public static void triggerOnDisconnecting()
{
if (NetworkEvents.onDisconnecting != null)
{
NetworkEvents.onDisconnecting();
}
}
public static void resubscribeEvents()
{
lock (NetworkClientManager.networkClients)
{
foreach (var client in NetworkClientManager.networkClients)
{
if (client.isConnected() && client.helloReceived)
{
if (client.presenceAddress.type != 'M' && client.presenceAddress.type != 'H')
{
continue;
}
// Get presences
client.sendData(ProtocolMessageCode.getRandomPresences, new byte[1] {
(byte)'R'
});
client.sendData(ProtocolMessageCode.getRandomPresences, new byte[1] {
(byte)'M'
});
client.sendData(ProtocolMessageCode.getRandomPresences, new byte[1] {
(byte)'H'
});
byte[] event_data = NetworkEvents.prepareEventMessageData(NetworkEvents.Type.all, new byte[0]);
client.sendData(ProtocolMessageCode.detachEvent, event_data);
subscribeToEvents(client);
}
}
}
}
public static void triggerOnHosted()
{
if (NetworkEvents.onHosted != null)
{
NetworkEvents.onHosted();
}
}
/// <summary>
/// Subscribes client to transactionFrom, transactionTo and balance
/// </summary>
/// <remarks>
/// This function is used to ensure that the remote endpoing has listed the correct IP and port information for their `PresenceList` entry.
/// </remarks>
/// <param name="endpoint">Target endpoint to verify for connectivity.</param>
public static void subscribeToEvents(RemoteEndpoint endpoint)
{
if (endpoint.presenceAddress.type != 'M' && endpoint.presenceAddress.type != 'H')
{
return;
}
// TODO TODO TODO events can be optimized as there is no real need to subscribe them to every connected node
// Subscribe to transaction events, for own addresses
var my_addresses = IxianHandler.getWalletStorage().getMyAddresses();
Cuckoo filter = new Cuckoo(my_addresses.Count());
foreach (var addr in my_addresses)
{
filter.Add(addr.address);
}
byte[] filter_data = filter.getFilterBytes();
byte[] event_data = NetworkEvents.prepareEventMessageData(NetworkEvents.Type.transactionFrom, filter_data);
endpoint.sendData(ProtocolMessageCode.attachEvent, event_data);
event_data = NetworkEvents.prepareEventMessageData(NetworkEvents.Type.transactionTo, filter_data);
endpoint.sendData(ProtocolMessageCode.attachEvent, event_data);
event_data = NetworkEvents.prepareEventMessageData(NetworkEvents.Type.balance, filter_data);
endpoint.sendData(ProtocolMessageCode.attachEvent, event_data);
}
public static void triggerOnReady()
{
if (NetworkEvents.onReady != null)
{
NetworkEvents.onReady();
}
}
public static void triggerOnConnected()
{
if (NetworkEvents.onConnected != null)
{
NetworkEvents.onConnected();
}
}
public void FireGun(Vector2 origin, Vector2 target, bool isSpecial, bool fireEvent = true)
{
Gun.FireBullet(origin, target, isSpecial);
if (fireEvent)
{
NetworkEvents.SendPlayerFired(origin, target, isSpecial);
}
}
public static void connectGUID(string guid, string password)
{
NetworkEvents.triggerOnConnecting();
if (Network.Connect(guid, password).ToString().ToLower() != "noerror")
{
NetworkTools.disconnect();
NetworkEvents.triggerOnFailed(0);
}
}
public static void connectIP(string ip, int port, string password)
{
NetworkEvents.triggerOnConnecting();
if (Network.Connect(ip, port, password).ToString().ToLower() != "noerror")
{
NetworkTools.disconnect();
NetworkEvents.triggerOnFailed(0);
}
}
public static void disconnect()
{
if (Network.isServer && ServerSettings.open)
{
NetworkTools.save();
}
NetworkEvents.triggerOnDisconnecting();
Network.Disconnect();
}
public ActionResult Test3()
{
List <Event> events = DL.DB.GetEvents();
NetworkEvents nw = new NetworkEvents();
//nw.AddEvents(DL.DB.GetEvents());
nw.AddEvents(events);
ViewBag.nw = nw;
return(View());
}
private static void subscribeToEvents(RemoteEndpoint endpoint)
{
CoreProtocolMessage.subscribeToEvents(endpoint);
byte[] friend_matcher = FriendList.getFriendCuckooFilter();
if (friend_matcher != null)
{
byte[] event_data = NetworkEvents.prepareEventMessageData(NetworkEvents.Type.keepAlive, friend_matcher);
endpoint.sendData(ProtocolMessageCode.attachEvent, event_data);
}
}
/// Check if ports were updated correctly
public void Test_Unique_Ports_In_Switch()
{
NetworkEvents nw = new NetworkEvents();
nw.AddEvent(new Event(1, DateTime.Now, "1.1.1.1", 11, "AABBCC000001", "New Device Added #1"));
nw.AddEvent(new Event(1, DateTime.Now, "1.1.1.1", 12, "AABBCC000002", "New Device Added #2"));
nw.AddEvent(new Event(1, DateTime.Now, "1.1.1.1", 12, "", "Device #2 Removed"));
Switch sw = nw.switches.Where(s => s.ip == "1.1.1.1").FirstOrDefault();
Assert.IsTrue(sw.ports.Count == 2);
}
private static void DoEvent(NetPacketReader reader)
{
NetworkEvents evt = (NetworkEvents)reader.GetByte();
if (!idToEvent.ContainsKey(evt))
{
return;
}
INetworkEvent netEvent = (INetworkEvent)Activator.CreateInstance(idToEvent[evt]);
netEvent.ReadPacket(reader);
netEvent.Invoke();
}
/// Add the same switches several times and check that the unique number of switches were added
public void TestUniqueSwitchesNumber()
{
NetworkEvents nw = new NetworkEvents();
nw.AddEvent(new Event(1, DateTime.Now, "1.1.1.1", 1, "AABBCC000001", "New Device Added #1"));
nw.AddEvent(new Event(2, DateTime.Now, "1.1.1.2", 1, "AABBCC000002", "New Device Added #2"));
nw.AddEvent(new Event(2, DateTime.Now, "1.1.1.2", 1, "AABBCC000003", "New Device Added #2 - AGAIN"));
nw.AddEvent(new Event(1, DateTime.Now, "1.1.1.1", 1, "AABBCC000004", "New Device Added #1 - AGAIN"));
// Check that only 2 Switches were added
int switches_count = nw.switches.Count;
Assert.IsTrue(switches_count == 2);
}
public static void resubscribeEvents()
{
lock (NetworkClientManager.networkClients)
{
foreach (var client in NetworkClientManager.networkClients)
{
if (client.isConnected() && client.helloReceived)
{
byte[] event_data = NetworkEvents.prepareEventMessageData(NetworkEvents.Type.all, new byte[0]);
client.sendData(ProtocolMessageCode.detachEvent, event_data);
subscribeToEvents(client);
}
}
}
}
private void Update()
{
if (Client.Instance == null || Time.time < nextUpdate || transform.position.Equals(prevPosition))
{
return;
}
float x = transform.position.x;
float y = transform.position.y;
nextUpdate = Time.time + UpdateRate;
prevPosition = transform.position;
NetworkEvents.SendPlayerPosition(x, y);
}
public void Update()
{
if (Player.model == null)
{
NetworkRegions.loaded = Time.realtimeSinceStartup;
}
else if (Time.realtimeSinceStartup - NetworkRegions.loaded > 1f)
{
NetworkRegions.region = NetworkRegions.getRegion(Player.model.transform.position);
if (NetworkRegions.region.x != NetworkRegions.lastRegion.x || NetworkRegions.region.y != NetworkRegions.lastRegion.y)
{
NetworkEvents.triggerOnRegionUpdate();
NetworkRegions.lastRegion = NetworkRegions.region;
}
}
}
private void Bank(CommandArgs args)
{
BetterNetworkUser user = args.sender;
Vector3 target = new UnityEngine.Vector3(-273.985F, 59.87F, -15.0616F);
user.position = target;
user.player.gameObject.GetComponent <Life> ().networkView.RPC("tellStatePosition", UnityEngine.RPCMode.All, new object[] {
target,
user.rotation
});
user.player.gameObject.GetComponent <NetworkInterpolation>().tellStatePosition_Pizza(target, user.rotation);
NetworkEvents.triggerOnRegionUpdate();
NetworkEvents.triggerOnRegionUpdate();
}
public void removeNetworkUser(NetworkPlayer player)
{
int indexFromPlayer = NetworkUserList.getIndexFromPlayer(player);
if (indexFromPlayer != -1)
{
if (Network.isServer)
{
Logger.LogConnection(NetworkUserList.users[indexFromPlayer].name + " Disconnected.");
// Server alert disabled..
// NetworkChat.sendAlert(string.Concat(NetworkUserList.users[indexFromPlayer].name, " disconnected."));
}
NetworkUserList.users.RemoveAt(indexFromPlayer);
NetworkEvents.triggerOnPlayersChanged();
}
}
// Deserializes a packet and calls the appropriate NetworkEvent method
public static void HandlePacket(ulong steamid, byte[] bytes, int length)
{
string buffer = Encoding.UTF8.GetString(bytes, 0, length);
// properties[0] == packet type
// properties[1-9] == values
string[] properties = buffer.Split(Constants.NetworkPacketDelimiter);
// Check that packet contains valid packet type
if (!int.TryParse(properties[0], out var packetType))
{
return;
}
// Call network event based on packet type
switch (packetType)
{
case (int)Constants.PacketType.PlayerPosition:
NetworkEvents.OnPlayerPosition(new PlayerPositionEventArgs(
steamid,
float.Parse(properties[1]),
float.Parse(properties[2])
)
);
break;
case (int)Constants.PacketType.PlayerSpawned:
NetworkEvents.OnPlayerSpawn(new PlayerSpawnedEventArgs(steamid));
break;
case (int)Constants.PacketType.PlayerFired:
NetworkEvents.OnPlayerFire(new PlayerFiredEventArgs(
steamid,
float.Parse(properties[1]),
float.Parse(properties[2]),
float.Parse(properties[3]),
float.Parse(properties[4]),
bool.Parse(properties[5])
)
);
break;
default:
throw new Exception($"Could not read packet type {properties[0]}");
}
}
/// Check port's devices
public void Test_Port_Devices()
{
NetworkEvents nw = new NetworkEvents();
nw.AddEvent(new Event(1, DateTime.Now, "1.1.1.1", 11, "AABBCC000001", "New Device Added #1"));
nw.AddEvent(new Event(1, DateTime.Now, "1.1.1.1", 12, "AABBCC000002", "New Device Added #2"));
nw.AddEvent(new Event(1, DateTime.Now, "1.1.1.1", 12, "", "Device #2 Removed"));
Switch sw = nw.switches.Where(s => s.ip == "1.1.1.1").FirstOrDefault();
Port prt11 = sw.ports.Where(p => p.id == 11).FirstOrDefault();
Port prt12 = sw.ports.Where(p => p.id == 12).FirstOrDefault();
Assert.IsTrue(prt11.current_device == "AABBCC000001");
Assert.IsTrue(prt12.current_device == "");
Assert.IsTrue(prt12.id == 12);
}
public void OnFailedToConnect(NetworkConnectionError data)
{
string lower = data.ToString().ToLower();
if (lower == "toomanyconnectedplayers")
{
NetworkEvents.triggerOnFailed(2);
}
else if (lower != "invalidpassword")
{
NetworkEvents.triggerOnFailed(0);
}
else
{
NetworkEvents.triggerOnFailed(1);
}
NetworkTools.disconnect();
}
/// <summary>
/// Teleports the home.
/// The object must contains the betternetworkuser and vector3 as original location!
/// </summary>
/// <returns>The home.</returns>
/// <param name="args">Arguments.</param>
private IEnumerator TeleportHome(object[] args)
{
Debug.Log("Teleport home coroutine started!");
BetterNetworkUser user = (BetterNetworkUser)args[0];
Vector3 originalPosition = (Vector3)args[1];
int i = 10;
bool result = false;
while (i > 0)
{
if (!user.position.Equals(originalPosition))
{
Reference.Tell(user.networkPlayer, "Teleportation cancelled");
result = false;
break;
}
if (i % 2 == 0)
{
NetworkManager.error("Teleporting to home in " + i / 2 + " seconds...", "Textures/Skills/survivalist", user.networkPlayer);
}
i--;
yield return(new WaitForSeconds(0.5f));
}
if (user.position.Equals(originalPosition))
{
this.teleportUserTo(user, this.playerHomes[user.steamid]);
Reference.Tell(user.networkPlayer, "Teleported home.");
NetworkEvents.triggerOnRegionUpdate();
this.usedHomeCommand[user.steamid] = UnityEngine.Time.realtimeSinceStartup;
yield return(result);
}
yield return(false);
}
private static void subscribeToEvents(RemoteEndpoint endpoint)
{
if (endpoint.presenceAddress.type != 'M')
{
return;
}
// Get presences
endpoint.sendData(ProtocolMessageCode.getRandomPresences, new byte[1] {
(byte)'R'
});
endpoint.sendData(ProtocolMessageCode.getRandomPresences, new byte[1] {
(byte)'M'
});
// TODO TODO TODO events can be optimized as there is no real need to subscribe them to every connected node
// Subscribe to transaction events
byte[] event_data = NetworkEvents.prepareEventMessageData(NetworkEvents.Type.transactionFrom, IxianHandler.getWalletStorage().getPrimaryAddress());
endpoint.sendData(ProtocolMessageCode.attachEvent, event_data);
event_data = NetworkEvents.prepareEventMessageData(NetworkEvents.Type.transactionTo, IxianHandler.getWalletStorage().getPrimaryAddress());
endpoint.sendData(ProtocolMessageCode.attachEvent, event_data);
event_data = NetworkEvents.prepareEventMessageData(NetworkEvents.Type.balance, IxianHandler.getWalletStorage().getPrimaryAddress());
endpoint.sendData(ProtocolMessageCode.attachEvent, event_data);
List <byte[]> match_addresses = FriendList.getHiddenMatchAddresses();
if (match_addresses != null)
{
foreach (var address in match_addresses)
{
event_data = NetworkEvents.prepareEventMessageData(NetworkEvents.Type.keepAlive, address);
endpoint.sendData(ProtocolMessageCode.attachEvent, event_data);
}
}
}
protected virtual void Start()
{
dying=false;
startHasRun = true;
OnEnable ();
GetComponent<log>().EnterLog("Wander");
netwEvents = gameObject.GetComponent<NetworkEvents> ();
netwRoundController = GameObject.Find("NetworkControlUnits").GetComponentInChildren<NetworkRoundController>();
}
public void addNetworkUser(string name, string nickname, string clan, string id, int status, int reputation, NetworkPlayer player)
{
NetworkUserList.users.Add(new NetworkUser(name, nickname, clan, id, status, reputation, player));
NetworkEvents.triggerOnPlayersChanged();
}
/** Starts searching for paths.
* If you override this function you should in most cases call base.Start () at the start of it.
* \see OnEnable
* \see RepeatTrySearchPath
*/
protected virtual void Start()
{
jumpTime=Time.time;
startHasRun = true;
OnEnable ();
GetComponent<log>().EnterLog("Search");
netwEvents = gameObject.GetComponent<NetworkEvents> ();
}
internal static extern SocketError WSAEnumNetworkEvents(
[In] SafeCloseSocket socketHandle,
[In] SafeWaitHandle Event,
[In, Out] ref NetworkEvents networkEvents);
void Start()
{
netwEvents = gameObject.GetComponent<NetworkEvents> ();
}
void Start()
{
// Initialization of last/target pos, rot, vel, timestamp values
lastPos = m_Player.Position.Get();
lastVel = m_Player.Velocity.Get();
lastRot = m_Player.Rotation.Get();
targetPos = lastPos;
targetRot = lastRot;
targetVel = lastVel;
lastTimestamp = 0;
targetTimestamp = 0;
if (networkView.viewID == uLink.NetworkViewID.unassigned) return;
isInitiaized = true;
// Following codes closes input and cameras for CREATOR and PROXY
if( !networkView.isMine )
{
m_Player.AllowGameplayInput.Set (false);
foreach (Transform child in gameObject.transform)
{
if(child.name == "FPSCamera")
{
foreach (Transform child2 in child.gameObject.transform)
{
if(child2.name == "WeaponCamera")
{
child2.transform.gameObject.GetComponent<Camera>().enabled = false;
break;
}
}
child.transform.gameObject.GetComponent<Camera>().enabled = false;
break;
}
}
}
// INITIALIZING DAMAGE BUFFER
damageToBeDone = 0f;
// INITIALIZING NETW EVENTS COMPONENT
netwEvents = gameObject.GetComponent<NetworkEvents> ();
if (!networkView.isMine) return;
enabled = false;
if (uLink.Network.isAuthoritativeServer && uLink.Network.isClient)
{
InvokeRepeating("SendToServer", 0, 1.0f / uLink.Network.sendRate);
}
}
private void Awake()
{
m_networkEvents = GameObject.Find("NetworkManager").GetComponent <NetworkEvents>();
Match.NetworkLobby = this;
}
void Start()
{
netwEvents = gameObject.GetComponent<NetworkEvents> ();
netwStateSync = gameObject.GetComponent<NetworkStateSync> ();
prevDamage = 0f;
}
