private void EnqueueEvent(NetEvent evt)
{
if (UnsyncedEvents)
{
ProcessEvent(evt);
}
else
{
lock (_netEventsQueue)
{
_netEventsQueue.Enqueue(evt);
}
}
}
private NetEvent CreateEvent(NetEventType type)
{
NetEvent evt = null;
if (_netEventsPool.Count > 0)
{
evt = _netEventsPool.Pop();
}
if (evt == null)
{
evt = new NetEvent();
}
evt.Type = type;
return(evt);
}
private void DoTimeoutBeginConnect(Socket socket, EndPoint endPoint)
{
IAsyncResult result = socket.BeginConnect(endPoint, OnSocketAsyncConnectFinish, socket);
if (this.socketConnectTimeOutMSec > 0 && result.AsyncWaitHandle.WaitOne(this.socketConnectTimeOutMSec, true) == false)
{
socket.Close();
NetEvent evt = this.netEventPool.GetObject();
evt.type = NetEventType.PeerConnectTimeOut;
evt.data = new SocketException((int)SocketError.TimedOut).Message;
NetCommand cmd = this.netCommandPool.GetObject();
cmd.type = NetCommandType.NetEventProxy;
cmd.data = evt;
this.netCommandQueue.Enqueue(cmd);
}
}
void NetEventFailedToConnect(NetEvent net_event)
{
if (state_ == State.JOINING)
{
if (net_event.error() == NetworkConnectionError.InvalidPassword)
{
SetState(State.JOIN_PASSWORD);
}
else
{
display_err_ = "" + net_event.error();
SetState(State.JOIN_FAIL);
}
}
ConsoleScript.Log("Failed to connect: " + net_event.error());
}
void NetEventDisconnectedFromServer(NetEvent net_event)
{
switch (net_event.network_disconnection())
{
case NetworkDisconnection.Disconnected:
ConsoleScript.Log("Cleanly disconnected from server");
break;
case NetworkDisconnection.LostConnection:
ConsoleScript.Log("Connection to server was lost unexpectedly");
break;
}
if (state_ == State.NONE || state_ == State.JOIN_SUCCESS || state_ == State.JOINING)
{
Application.LoadLevel(Application.loadedLevel);
}
}
private void OnConnected(NetEvent evt)
{
Log.Debug("I'm connected!");
_currentState = State.Playing;
Client = new GameClient(evt.Peer, false);
GameObject playerObj = Object.Instantiate(PlayerPrefab);
ControlledObject pco = new UccControlledObject
{
Entity = playerObj,
PlayerController = playerObj.GetComponent <CharacterController>(),
PLocomotion = playerObj.GetComponent <UltimateCharacterLocomotion>()
};
Client.ControlledObjectSys.CurrentlyControlledObject = pco;
}
public Queue <string[]> moveQueue = new Queue <string[]>(); // 移动消息队列
void Start()
{
ConfigManager <Gun> cm = new ConfigManager <Gun>();
Gun gun = cm.GetConfig(2);
print(gun.ID + " - " + gun.Name);
PlayerParent = GameObject.Find("PlayerList").transform;
NetEvent.AddEvent(list, netEventEnum.List);
NetEvent.AddEvent(leave, netEventEnum.Leave);
NetEvent.AddEvent(move, netEventEnum.Move);
GetListProto glp = new GetListProto();
glp.Timestamp = Tool.GetTimestamp();
string str = JsonUtility.ToJson(glp);
NetManager.Instance.Send(netEventEnum.GetList, str);
}
public void OnNetworkReceive(NetPeer peer, NetDataReader reader, DeliveryMethod deliveryMethod)
{
// byte[] raw = new byte[reader.AvailableBytes];
//reader.GetBytes (raw, reader.AvailableBytes);
//string str = System.Text.Encoding.ASCII.GetString (raw);
//ClientInput input = new ClientInput ();
//input.DecodeRawDataFromeString (str);
// if (input.ClinetID == _netClient.LocalPort) {
// Debug.Log("[YOU] inputed>" + input.ToString());
// } else {
// Debug.Log("[OTHER] inputed>"+ input.ToString());
// }
byte[] raw = new byte[reader.AvailableBytes];
reader.GetBytes(raw, reader.AvailableBytes);
string str = NetdataUltility.DecodeRaw(raw);
NetdataUltility.NetdataType dataType = NetdataUltility.NetdataType.UnknownData;
string decoded = "";
dataType = NetdataUltility.DepacketData(str, out decoded);
switch (dataType)
{
case NetdataUltility.NetdataType.EventData:
NetEvent nEvent = new NetEvent();
nEvent.Decode(decoded);
OnNetEvent(nEvent);
break;
case NetdataUltility.NetdataType.PlayerInputData:
ClientInput cInput = new ClientInput();
cInput.Decode(decoded);
ExecuteInpute(cInput);
break;
case NetdataUltility.NetdataType.SyncableData:
break;
case NetdataUltility.NetdataType.UnknownData:
//Maybe drop this data ??
Debug.Log("[GameClient] receved a unknownData form server !");
break;
}
}
private void OnSocketAsyncReceiveFinish(IAsyncResult result)
{
SocketReceiveStateObject stateObj = (SocketReceiveStateObject)result.AsyncState;
Socket socket = stateObj.socket;
int readBytes = 0;
try
{
readBytes = socket.EndReceive(result);
}
catch (ObjectDisposedException)
{
return;
}
catch (Exception e)
{
NetEvent evt = this.netEventPool.GetObject();
evt.type = NetEventType.NetWorkError;
evt.data = e.Message;
NetCommand cmd = this.netCommandPool.GetObject();
cmd.type = NetCommandType.NetEventProxy;
cmd.data = evt;
this.netCommandQueue.Enqueue(cmd);
return;
}
if (readBytes == 0)
{
NetEvent evt = this.netEventPool.GetObject();
evt.type = NetEventType.PeerClose;
NetCommand cmd = this.netCommandPool.GetObject();
cmd.type = NetCommandType.NetEventProxy;
cmd.data = evt;
this.netCommandQueue.Enqueue(cmd);
}
else
{
NetEvent evt = this.netEventPool.GetObject();
evt.type = NetEventType.RecvMessage;
evt.data = new byte[readBytes];
Buffer.BlockCopy(stateObj.buffer, 0, (byte[])evt.data, 0, readBytes);
this.netEventQueue.Enqueue(evt);
socket.BeginReceive(stateObj.buffer, 0, stateObj.buffer.Length, SocketFlags.None, OnSocketAsyncReceiveFinish, stateObj);
}
}
// 需要外部循环调用的
// 消息下发(主线程)
public static void Update()
{
// 从消息列表中获取消息
if (NetManager.MessageQueue.Count > 0)
{
string[] item = null;
lock (NetManager.MessageQueue) {
item = NetManager.MessageQueue.Peek();
}
string type = item[0];
string msg = item[1];
UILog.log.Add("接收到的消息：" + msg);
BaseProto date = JsonUtility.FromJson(msg, Type.GetType(type)) as BaseProto;
NetEvent.SendEvent((netEventEnum)date.protoType, date.returnFun()); // 发送事件
lock (NetManager.MessageQueue) {
NetManager.MessageQueue.Dequeue();
}
UILog.log.Add("接收到的消息类型：" + date.protoType);
}
}
private NetEvent CreateEvent(NetEventType type)
{
NetEvent evt = null;
if (type == NetEventType.Connect)
{
_connectedPeersCount++;
}
lock (_netEventsPool)
{
if (_netEventsPool.Count > 0)
{
evt = _netEventsPool.Pop();
}
}
if (evt == null)
{
evt = new NetEvent();
}
evt.Type = type;
return(evt);
}
private void OnNetEvent(NetEvent evt)
{
Log.Debug($"NetEvent: {evt.Type} ");
switch (evt.Type)
{
case NetEvent.EType.Connect:
OnConnected(evt);
break;
case NetEvent.EType.Receive:
Client.PacketStream.AddDataReceivedEvent(evt);
break;
case NetEvent.EType.Disconnect:
break;
case NetEvent.EType.ReceiveUnconnected:
break;
case NetEvent.EType.Error:
break;
case NetEvent.EType.ConnectionLatencyUpdated:
break;
case NetEvent.EType.DiscoveryRequest:
break;
case NetEvent.EType.DiscoveryResponse:
break;
case NetEvent.EType.ConnectionRequest:
break;
default:
throw new ArgumentOutOfRangeException();
}
}
private void React(NetEvent evt)
{
switch (evt.Type)
{
case NetEvent.EType.ConnectionRequest:
evt.ConnectionRequest.Accept(); // who needs security
break;
case NetEvent.EType.Connect:
HandleNewConnection(evt);
break;
case NetEvent.EType.Receive:
HandleNetworkReceive(evt);
break;
case NetEvent.EType.Disconnect:
break;
case NetEvent.EType.ReceiveUnconnected:
break;
case NetEvent.EType.Error:
break;
case NetEvent.EType.ConnectionLatencyUpdated:
break;
case NetEvent.EType.DiscoveryRequest:
break;
case NetEvent.EType.DiscoveryResponse:
break;
default:
throw new ArgumentOutOfRangeException();
}
}
public void TestNotificationPack()
{
int headerSize = NetEncoding.NOTIFICATION_HEADER_SIZE;
int maxPack = NetEncoding.MAX_NOTIFICATION_PACK;
int halfPack = (maxPack / 2) - headerSize;
NetEvent evnt1 = CreateFilled(NetConfig.DATA_MAXIMUM);
NetEvent evnt2 = CreateFilled(halfPack);
NetEvent evnt3 = CreateFilled(halfPack);
NetEvent evnt4 = CreateFilled(halfPack + 1);
// The buffer should fit this notification exactly.
TestNetEncoding.TestNotificationCase(maxPack, 1, evnt1);
// The buffer should fit these two notifications exactly.
TestNetEncoding.TestNotificationCase(maxPack, 2, evnt2, evnt3);
// The second notification should be one byte too big for the buffer.
TestNetEncoding.TestNotificationCase(halfPack + headerSize, 1, evnt3, evnt4);
// We should pack no bytes and read no notifications for this.
TestNetEncoding.TestNotificationCase(0, 0);
}
private void OnNetworkEvent(NetEvent nevent)
{
switch (nevent)
{
case NetEvent.ConnectedToMaster:
{
SetState(ModalState.SearchingForGame);
break;
}
case NetEvent.ConnectedToLobby:
{
break;
}
case NetEvent.RoomListUpdated:
{
break;
}
case NetEvent.CreatedRoom:
{
break;
}
case NetEvent.JoinedRoom:
{
SetState(ModalState.WaitingForPlayers);
break;
}
}
if (Models.Get <INetworkModel>().CurrentErrorMessage != string.Empty)
{
EventDispatcher.Broadcast(Notification, Models.Get <INetworkModel>().CurrentErrorMessage);
}
}
private void NetNodeOnEventReceived(object sender, EventArgs e)
{
if (sender is ProcNetNode node && e is EventReceivedArgs args)
{
NetEvent evt = JsonConvert.DeserializeObject <NetEvent>(args.Message);
if (evt != null)
{
int sourcePort = node.Port;
int amount = _expectedConnections.RemoveAll(m => m.Key == sourcePort && m.Value == evt.Peer.Port);
if (amount > 0)
{
Console.WriteLine($"Removed: {sourcePort} - {evt.Peer.Port}");
}
if (!_expectedConnections.Any())
{
Program.testSuccessEvent.Set();
}
}
}
}
protected void EnqueueEvent(NetEvent evt)
{
if (UnsyncedEvents)
{
ProcessEvent(evt);
}
else
{
lock (_netEventsQueue)
{
_netEventsQueue.Enqueue(evt);
}
}
}
protected NetEvent CreateEvent(NetEventType type)
{
NetEvent evt = null;
lock (_netEventsPool)
{
if (_netEventsPool.Count > 0)
{
evt = _netEventsPool.Pop();
}
}
if(evt == null)
{
evt = new NetEvent {DataReader = new NetDataReader()};
}
evt.Type = type;
return evt;
}
private void ProcessEvent(NetEvent evt)
{
switch (evt.Type)
{
case NetEventType.Connect:
_netEventListener.OnPeerConnected(evt.Peer);
break;
case NetEventType.Disconnect:
_netEventListener.OnPeerDisconnected(evt.Peer, evt.DisconnectReason, evt.AdditionalData);
break;
case NetEventType.Receive:
_netEventListener.OnNetworkReceive(evt.Peer, evt.DataReader);
break;
case NetEventType.ReceiveUnconnected:
_netEventListener.OnNetworkReceiveUnconnected(evt.RemoteEndPoint, evt.DataReader, UnconnectedMessageType.Default);
break;
case NetEventType.DiscoveryRequest:
_netEventListener.OnNetworkReceiveUnconnected(evt.RemoteEndPoint, evt.DataReader, UnconnectedMessageType.DiscoveryRequest);
break;
case NetEventType.DiscoveryResponse:
_netEventListener.OnNetworkReceiveUnconnected(evt.RemoteEndPoint, evt.DataReader, UnconnectedMessageType.DiscoveryResponse);
break;
case NetEventType.Error:
_netEventListener.OnNetworkError(evt.RemoteEndPoint, evt.AdditionalData);
break;
case NetEventType.ConnectionLatencyUpdated:
_netEventListener.OnNetworkLatencyUpdate(evt.Peer, evt.AdditionalData);
break;
}
//Recycle
evt.DataReader.Clear();
evt.Peer = null;
evt.AdditionalData = 0;
evt.RemoteEndPoint = null;
lock (_netEventsPool)
{
_netEventsPool.Push(evt);
}
}
public void Update()
{
for (;;)
{
NetEvent evt = null;
if (this.netEventQueue.TryDequeue(ref evt) == false)
{
break;
}
if (evt.type == NetEventType.ActiveClose)
{
this.GotoStatusConnected();
if (this.disconnectCb != null)
{
this.disconnectCb(true, "");
}
}
else if (evt.type == NetEventType.PeerCantConnect)
{
this.GotoStatusDisconnected();
if (this.connectCb != null)
{
this.connectCb(false, (string)evt.data);
}
}
else if (evt.type == NetEventType.PeerConnectTimeOut)
{
if (this.status == StatusType.Connecting)
{
this.GotoStatusDisconnected();
if (this.connectCb != null)
{
this.connectCb(false, (string)evt.data);
}
}
}
else if (evt.type == NetEventType.PeerConnected)
{
this.GotoStatusConnected();
if (this.connectCb != null)
{
this.connectCb(true, "");
}
}
else if (evt.type == NetEventType.PeerClose)
{
this.GotoStatusDisconnected();
if (this.disconnectCb != null)
{
this.disconnectCb(false, "");
}
}
else if (evt.type == NetEventType.RecvMessage)
{
if (this.recvMessageCb != null)
{
this.recvMessageCb((byte[])evt.data);
}
}
else if (evt.type == NetEventType.NetWorkError)
{
this.GotoStatusConnected();
if (this.disconnectCb != null)
{
this.disconnectCb(false, (string)evt.data);
}
}
this.ReturnNetEventObject(evt);
}
}
// Update is called once per frame
void Update()
{
NetEvent.ProcessOut();
}
void NetEventDisconnectedFromServer(NetEvent net_event)
{
switch(net_event.network_disconnection()){
case NetworkDisconnection.Disconnected:
ConsoleScript.Log("Proprement deconnecte du serveur");
break;
case NetworkDisconnection.LostConnection:
ConsoleScript.Log("La connexion au serveur a ete perdue de maniere inattendue");
break;
}
if(state_ == State.NONE || state_ == State.JOIN_SUCCESS || state_ == State.JOINING){
Application.LoadLevel(Application.loadedLevel);
}
}
void NetEventMasterServerEvent(NetEvent net_event)
{
switch(net_event.master_server_event()){
case MasterServerEvent.HostListReceived:
ConsoleScript.Log("Reçu une liste d'hôtes depuis le serveur maître.");
if(queued_join_game_name_.Length > 0){
JoinHostListGameByName(queued_join_game_name_);
queued_join_game_name_ = "";
}
break;
case MasterServerEvent.RegistrationFailedGameName:
ConsoleScript.Log("L'enregistrement a echoue car un nom de jeu vide a ete donne.");
break;
case MasterServerEvent.RegistrationFailedGameType:
ConsoleScript.Log("L'enregistrement a echoue car un type de jeu vide a ete donne.");
break;
case MasterServerEvent.RegistrationFailedNoServer:
ConsoleScript.Log("L'enregistrement a echoue car aucun serveur n'est en jeu.");
break;
case MasterServerEvent.RegistrationSucceeded:
ConsoleScript.Log("L'enregistrement au serveur maitre a reussi, confirmation recue.");
break;
}
}
// 销毁
private void OnDisable()
{
NetEvent.DelEvent(list, netEventEnum.List);
NetEvent.DelEvent(leave, netEventEnum.Leave);
NetEvent.DelEvent(move, netEventEnum.Move);
}
/// <summary>
/// Queues a new notification to be send out reliably during ticks.
/// </summary>
internal bool QueueNotification(NetEvent data)
{
int notificationCount = this.outgoing.Count;
if (notificationCount >= NetConfig.MaxPendingNotifications)
{
NetDebug.LogError("Notification queue full");
return false;
}
data.Sequence = this.notificationSeq++;
this.outgoing.Enqueue(data);
return true;
}
public void Enqueue(NetEvent <INetClient> e)
{
Mut.WaitOne();
Queue.Enqueue(e);
Mut.ReleaseMutex();
}
public async Task StepAsync(CancellationToken cancellationToken)
{
try
{
if (player != null)
{
var builder = new FlatBufferBuilder(1);
lock (world.Bodies) // wrong kind of lock but might do for now
{
// First try to focus camera on the player if they have
// a fleet alive;
var followFleet = player?.Fleet;
// if the player doesn't have a fleet alive
if (followFleet == null)
{
// check to see if they are spectating a fleet that's alive
if (SpectatingFleet != null && SpectatingFleet.Exists)
{
followFleet = SpectatingFleet;
}
}
if (followFleet == null)
{
// find someone else to watch
followFleet = Player.GetWorldPlayers(world)
.ToList()
.Where(p => p.IsAlive)
.OrderByDescending(p => p.Score * 10000 + (10000 - p.Fleet?.ID ?? 0))
.FirstOrDefault()
?.Fleet;
}
Body followBody = null;
// if we're watching a fleet, watch the center of their fleet
if (followFleet != null)
{
if (world.Hook.FollowFirstShip)
{
followBody = followFleet.Ships.FirstOrDefault();
}
else
{
var center = FleetMath.FleetCenterNaive(followFleet.Ships);
followBody = new Body
{
DefinitionTime = world.Time,
OriginalPosition = center,
Position = center,
Momentum = followFleet.FleetMomentum
};
}
}
// we've found someone to spectate, record it
if (followFleet != player?.Fleet && followFleet != SpectatingFleet)
{
SpectatingFleet = followFleet;
}
// if we haven't found anything to watch yet, watch the first ship we find
if (followBody == null)
{
followBody = player?.World.Bodies.OfType <Ship>().FirstOrDefault();
}
// if we haven't found anything to watch yet, watch anything
if (followBody == null)
{
followBody = player?.World.Bodies.FirstOrDefault();
}
if (followBody != null)
{
var size = 6000;
var viewportHeight = size * 2;
var viewportWidth = size * 2;
var playerViewport = new Envelope(
followBody.Position.X - viewportWidth / 2,
followBody.Position.Y - viewportHeight / 2,
followBody.Position.X + viewportWidth / 2,
followBody.Position.Y + viewportHeight / 2
);
BodyCache.Update(
world.BodiesNear(playerViewport).ToList(),
world.Time
);
var updates = BodyCache.BodiesByError();
var updateBodies = updates.Take((int)this.Bandwidth);
float VELOCITY_SCALE_FACTOR = 5000;
var updatedGroups = BodyCache.GroupsByError().ToList();
var groupsVector = NetWorldView.CreateGroupsVector(builder,
updatedGroups.Select(b =>
{
var serverGroup = b.GroupUpdated;
var caption = builder.CreateString(serverGroup.Caption ?? " ");
var color = builder.CreateString(serverGroup.Color ?? "");
var customData = builder.CreateString(serverGroup.CustomData ?? "");
var group = NetGroup.CreateNetGroup(builder,
group: serverGroup.ID,
type: (byte)serverGroup.GroupType,
captionOffset: caption,
zindex: serverGroup.ZIndex,
owner: serverGroup.OwnerID,
colorOffset: color,
customDataOffset: customData
);
return(group);
}).ToArray());
foreach (var update in updatedGroups)
{
update.GroupClient = update.GroupUpdated.Clone();
}
var groupDeletesVector = NetWorldView.CreateGroupDeletesVector(builder, BodyCache.CollectStaleGroups().Select(b =>
b.GroupUpdated.ID
).ToArray());
NetWorldView.StartUpdatesVector(builder, updateBodies.Count());
foreach (var b in updateBodies)
{
var serverBody = b.BodyUpdated;
var body = NetBody.CreateNetBody(builder,
Id: serverBody.ID,
DefinitionTime: serverBody.DefinitionTime,
originalPosition_X: (short)serverBody.OriginalPosition.X,
originalPosition_Y: (short)serverBody.OriginalPosition.Y,
velocity_X: (short)(serverBody.Momentum.X * VELOCITY_SCALE_FACTOR),
velocity_Y: (short)(serverBody.Momentum.Y * VELOCITY_SCALE_FACTOR),
OriginalAngle: (sbyte)(serverBody.OriginalAngle / MathF.PI * 127),
AngularVelocity: (sbyte)(serverBody.AngularVelocity * 10000),
Size: (byte)(serverBody.Size / 5),
Sprite: (ushort)serverBody.Sprite,
Mode: serverBody.Mode,
Group: serverBody.Group?.ID ?? 0);
}
var updatesVector = builder.EndVector();
foreach (var update in updateBodies)
{
update.BodyClient = update.BodyUpdated.Clone();
}
var deletesVector = NetWorldView.CreateDeletesVector(builder, BodyCache.CollectStaleBuckets().Select(b =>
b.BodyUpdated.ID
).ToArray());
var messages = player.GetMessages();
VectorOffset announcementsVector = new VectorOffset();
if (messages != null && messages.Any())
{
announcementsVector = NetWorldView.CreateAnnouncementsVector(builder, messages.Select(e =>
{
var stringType = builder.CreateString(e.Type);
var stringMessage = builder.CreateString(e.Message);
var stringExtraData = e.ExtraData != null
? builder.CreateString(JsonConvert.SerializeObject(e.ExtraData))
: new StringOffset();
NetAnnouncement.StartNetAnnouncement(builder);
NetAnnouncement.AddType(builder, stringType);
NetAnnouncement.AddText(builder, stringMessage);
if (e.ExtraData != null)
{
NetAnnouncement.AddExtraData(builder, stringExtraData);
}
NetAnnouncement.AddPointsDelta(builder, e.PointsDelta);
return(NetAnnouncement.EndNetAnnouncement(builder));
}).ToArray());
}
StringOffset customOffset = new StringOffset();
if (followFleet?.CustomData != null && followFleet.CustomData != CustomData)
{
customOffset = builder.CreateString(followFleet.CustomData);
}
NetWorldView.StartNetWorldView(builder);
// define camera
var cameraBody = NetBody.CreateNetBody(
builder,
Id: 0,
DefinitionTime: followBody?.DefinitionTime ?? 0,
originalPosition_X: (short)(followBody?.OriginalPosition.X ?? 0),
originalPosition_Y: (short)(followBody?.OriginalPosition.Y ?? 0),
velocity_X: (short)(followBody?.Momentum.X * VELOCITY_SCALE_FACTOR ?? 0),
velocity_Y: (short)(followBody?.Momentum.Y * VELOCITY_SCALE_FACTOR ?? 0),
OriginalAngle: (sbyte)(followBody?.OriginalAngle / MathF.PI / 127 ?? 0),
AngularVelocity: 0,
Size: 0,
Sprite: 0,
Mode: 0,
Group: 0
);
NetWorldView.AddCamera(builder, cameraBody);
NetWorldView.AddIsAlive(builder, player?.IsAlive ?? false);
NetWorldView.AddTime(builder, world.Time);
NetWorldView.AddUpdates(builder, updatesVector);
NetWorldView.AddDeletes(builder, deletesVector);
NetWorldView.AddGroups(builder, groupsVector);
NetWorldView.AddGroupDeletes(builder, groupDeletesVector);
if (messages != null && messages.Any())
{
NetWorldView.AddAnnouncements(builder, announcementsVector);
}
if (followFleet?.CustomData != null && followFleet.CustomData != CustomData)
{
NetWorldView.AddCustomData(builder, customOffset);
}
CustomData = followFleet?.CustomData;
var players = Player.GetWorldPlayers(world);
NetWorldView.AddPlayerCount(builder, (uint)world.AdvertisedPlayerCount);
NetWorldView.AddSpectatorCount(builder, (uint)players.Count(p => p.Connection?.IsSpectating ?? false));
NetWorldView.AddCooldownBoost(builder, (byte)((player?.Fleet?.BoostCooldownStatus * 255) ?? 0));
NetWorldView.AddCooldownShoot(builder, (byte)((player?.Fleet?.ShootCooldownStatus * 255) ?? 0));
NetWorldView.AddWorldSize(builder, (ushort)world.Hook.WorldSize);
if (followFleet != null)
{
// inform the client of which the fleet id
NetWorldView.AddFleetID(builder, (uint)followFleet.ID);
}
else
{
NetWorldView.AddFleetID(builder, 0);
}
var worldView = NetWorldView.EndNetWorldView(builder);
var newHash = world.Hook.GetHashCode();
if (HookHash != newHash)
{
this.Events.Enqueue(new BroadcastEvent
{
EventType = "hook",
Data = JsonConvert.SerializeObject(world.Hook)
});
}
HookHash = newHash;
var q = NetQuantum.CreateNetQuantum(builder, AllMessages.NetWorldView, worldView.Value);
builder.Finish(q.Value);
}
}
await this.SendAsync(builder.DataBuffer, cancellationToken);
if (LeaderboardTime != (world.Leaderboard?.Time ?? 0))
{
LeaderboardTime = (world.Leaderboard?.Time ?? 0);
builder = new FlatBufferBuilder(1);
var stringName = builder.CreateString(world.Leaderboard?.ArenaRecord?.Name ?? " ");
var stringColor = builder.CreateString(world.Leaderboard?.ArenaRecord?.Color ?? " ");
NetLeaderboardEntry.StartNetLeaderboardEntry(builder);
NetLeaderboardEntry.AddColor(builder, stringColor);
NetLeaderboardEntry.AddName(builder, stringName);
NetLeaderboardEntry.AddScore(builder, world.Leaderboard?.ArenaRecord?.Score ?? 0);
NetLeaderboardEntry.AddToken(builder, !string.IsNullOrEmpty(world.Leaderboard?.ArenaRecord?.Token));
var record = NetLeaderboardEntry.EndNetLeaderboardEntry(builder);
var entriesVector = NetLeaderboard.CreateEntriesVector(builder, world.Leaderboard.Entries.Select(e =>
{
// the strings must be created into the buffer before the are referenced
// and before the start of the entry object
stringName = builder.CreateString(e.Name ?? string.Empty);
stringColor = builder.CreateString(e.Color ?? string.Empty);
StringOffset stringModeData = new StringOffset();
if (e.ModeData != null)
{
stringModeData = builder.CreateString(JsonConvert.SerializeObject(e.ModeData));
}
// here's the start of the entry object, after this we can only use
// predefined string offsets
NetLeaderboardEntry.StartNetLeaderboardEntry(builder);
NetLeaderboardEntry.AddFleetID(builder, e.FleetID);
NetLeaderboardEntry.AddName(builder, stringName);
NetLeaderboardEntry.AddColor(builder, stringColor);
NetLeaderboardEntry.AddScore(builder, e.Score);
NetLeaderboardEntry.AddPosition(builder, FromPositionVector(builder, e.Position));
NetLeaderboardEntry.AddToken(builder, !string.IsNullOrEmpty(e.Token));
if (e.ModeData != null)
{
NetLeaderboardEntry.AddModeData(builder, stringModeData);
}
return(NetLeaderboardEntry.EndNetLeaderboardEntry(builder));
}).ToArray());
var stringType = builder.CreateString(world.Leaderboard.Type ?? string.Empty);
NetLeaderboard.StartNetLeaderboard(builder);
NetLeaderboard.AddEntries(builder, entriesVector);
NetLeaderboard.AddType(builder, stringType);
NetLeaderboard.AddRecord(builder, record);
var leaderboardOffset = NetLeaderboard.EndNetLeaderboard(builder);
builder.Finish(NetQuantum.CreateNetQuantum(builder, AllMessages.NetLeaderboard, leaderboardOffset.Value).Value);
await this.SendAsync(builder.DataBuffer, cancellationToken);
}
while (Events.Count > 0)
{
var e = Events.Dequeue();
var eventType = builder.CreateString(e.EventType);
var eventData = builder.CreateString(e.Data);
NetEvent.StartNetEvent(builder);
NetEvent.AddType(builder, eventType);
NetEvent.AddData(builder, eventData);
var eventOffset = NetEvent.EndNetEvent(builder);
builder.Finish(NetQuantum.CreateNetQuantum(builder, AllMessages.NetEvent, eventOffset.Value).Value);
await this.SendAsync(builder.DataBuffer, cancellationToken);
}
}
}
catch (WebSocketException)
{
//Console.WriteLine(e);
throw;
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
private void NetworkEventHandler(NetEvent netevent, string value)
{
_netEvent = netevent;
_value = value;
}
public void CallNetEvent(NetEvent <INetClient> e)
{
OnNetEvent.Invoke(e);
}
// 异步收包线程.
private void waitSocket()
{
Debug.Log("receiver");
int len;
while (true)
{
if (!clientSocket.Poll(-1, SelectMode.SelectRead))
{
Debug.Log("poll error");
Close();
}
len = clientSocket.Receive(buf.GetRaw(), 0, HEAD_SIZE,
SocketFlags.None);
if (len < 0)
{
Debug.Log("length error");
Close();
return;
}
Debug.Assert(len == HEAD_SIZE);
int payload_length = buf.GetShort(0);
//Debug.Log ("payload_length" + payload_length);
Debug.Assert(payload_length < BUFF_SIZE);
int want = payload_length;
int lenAll = 0;
buf.Clear();
SocketError socketError;
while (want > 0)
{
len = clientSocket.Receive(buf.GetRaw(), lenAll, want,
SocketFlags.None, out socketError);
want -= len;
lenAll += len;
}
// Debug.Log("receive length:" + lenAll+ " payload_length："
// + payload_length);
Debug.Assert(payload_length == lenAll);
var ms_byte = new byte[payload_length];
Array.Copy(buf.GetRaw(), 0, ms_byte, 0, payload_length);
var ms2 = new MemoryStream(ms_byte, 0, payload_length);
int cmd = ms2.ReadByte();
string eventName = EventName.GetEventName(cmd);
// ShowBytes("bytes:"+eventName+":", buf.GetRaw(), payload_length);
NetEvent.FireOut(eventName, new object[] { ms2 });
/*
* var protoPacket = ProtoBuf.Serializer.Deserialize<packet>(ms2);
* Debug.Log("receive packet.cmd:"+protoPacket.cmd);
* var eventname = MessageMap.GetEventName(protoPacket.cmd);
* Event.FireOut(eventname, new object[]{protoPacket.payload});
*/
}
}
private void NetworkEventHandler(NetEvent netevent) {
_netEvent = netevent;
}
private static NetEvent CreateEvent(NetEventType type, NetPeer peer)
{
NetEvent evnt = new NetEvent();
evnt.Initialize(type, peer);
return evnt;
}
public virtual string WriteEvent(NetEvent netEvent)
{
//TODO: not exactly finished
return($"<EVENT {netEvent.Name}>");
}
private static NetEvent CreateFilled(int length)
{
byte[] filled = new byte[2048];
for (int i = 0; i < filled.Length; i++)
filled[i] = (byte)(i % 256);
NetEvent evnt = new NetEvent();
evnt.Initialize(NetEventType.Notification, null);
evnt.ReadData(filled, 0, (ushort)length);
return evnt;
}
void NetEventFailedToConnectToMasterServer(NetEvent net_event)
{
if(state_ == State.JOIN){
display_err_ = ""+net_event.error();
SetState(State.MASTER_SERVER_FAIL);
}
ConsoleScript.Log("Impossible de se connecter au serveur maitre: "+net_event.error());
}
private void HandleNetworkReceive(NetEvent evt)
{
GameClient gc = Clients[evt.Peer.Id];
gc.PacketStream.AddDataReceivedEvent(evt);
}
private void ReturnNetEventObject(NetEvent evt)
{
evt.type = NetEventType.None;
evt.data = null;
this.netEventPool.ReturnObject(evt);
}
void NetEventFailedToConnect(NetEvent net_event){
if(state_ == State.JOINING){
if(net_event.error() == NetworkConnectionError.InvalidPassword){
SetState(State.JOIN_PASSWORD);
} else {
display_err_ = ""+net_event.error();
SetState(State.JOIN_FAIL);
}
}
ConsoleScript.Log("Failed to connect: "+net_event.error());
}
public void AddDataReceivedEvent(NetEvent evt)
{
_dataReceivedEvents.Add(evt);
}
void NetEventPlayerDisconnected(NetEvent net_event) {
NetworkPlayer player = net_event.network_player();
ConsoleScript.Log("Player "+player+" disconnected");
PlayerListScript.Instance().Remove(int.Parse(player.ToString()));
Network.RemoveRPCs(player);
Network.DestroyPlayerObjects(player);
}
private static NetEvent CreateStringEvent(string value)
{
byte[] bytes = Encoding.UTF8.GetBytes(value);
NetEvent evnt = new NetEvent();
evnt.Initialize(NetEventType.Notification, null);
evnt.ReadData(bytes, 0, (ushort)bytes.Length);
return evnt;
}
void Update()
{
if (current_song_ != target_song_)
{
if (music_.volume == 0.0f)
{
current_song_ = target_song_;
if (current_song_ != -1)
{
music_.clip = songs[current_song_];
}
else
{
music_.Stop();
}
}
else
{
music_.volume = Mathf.Max(0.0f, music_.volume - Time.deltaTime);
}
}
else if (current_song_ != -1)
{
music_.volume = Mathf.Min(MAX_SONG_VOLUME, music_.volume + Time.deltaTime);
}
if (!music_.isPlaying)
{
music_.Play();
}
NetEvent net_event = NetEventScript.Instance().GetEvent();
while (net_event != null)
{
switch (net_event.type())
{
case NetEvent.Type.SERVER_INITIALIZED:
NetEventServerInitialized();
break;
case NetEvent.Type.CONNECTED_TO_SERVER:
NetEventConnectedToServer();
break;
case NetEvent.Type.FAILED_TO_CONNECT:
NetEventFailedToConnect(net_event);
break;
case NetEvent.Type.FAILED_TO_CONNECT_TO_MASTER_SERVER:
NetEventFailedToConnectToMasterServer(net_event);
break;
case NetEvent.Type.MASTER_SERVER_EVENT:
NetEventMasterServerEvent(net_event);
break;
case NetEvent.Type.PLAYER_CONNECTED:
ConsoleScript.Log("Player " + net_event.network_player() + " connected");
networkView.RPC("SyncSongWithServer", RPCMode.Others, int.Parse(net_event.network_player().ToString()), current_song_, target_song_, music_.volume, music_.time);
break;
case NetEvent.Type.PLAYER_DISCONNECTED:
NetEventPlayerDisconnected(net_event);
break;
case NetEvent.Type.DISCONNECTED_FROM_SERVER:
NetEventDisconnectedFromServer(net_event);
break;
}
net_event = NetEventScript.Instance().GetEvent();
}
}
void NetEventFailedToConnectToMasterServer(NetEvent net_event) {
if(state_ == State.JOIN){
display_err_ = ""+net_event.error();
SetState(State.MASTER_SERVER_FAIL);
}
ConsoleScript.Log("Failed to connect to master server: "+net_event.error());
}
/// <summary>
/// Reads payload data from the given buffer.
/// </summary>
internal static bool ReadPayload(
Func<NetEventType, NetPeer, NetEvent> eventFactory,
NetPeer peer,
byte[] buffer,
int length,
out ushort sequence,
out NetEvent evnt)
{
evnt = null;
// Read header (already know the type)
sequence = NetEncoding.ReadU16(buffer, 1);
int position = NetEncoding.PAYLOAD_HEADER_SIZE;
ushort dataLength = (ushort)(length - position);
if ((position + dataLength) > length)
return false; // We're reading past the end of the packet data
evnt = eventFactory.Invoke(NetEventType.Payload, peer);
return evnt.ReadData(buffer, position, dataLength); ;
}
void NetEventMasterServerEvent(NetEvent net_event){
switch(net_event.master_server_event()){
case MasterServerEvent.HostListReceived:
ConsoleScript.Log("Received a host list from the master server.");
if(queued_join_game_name_.Length > 0){
JoinHostListGameByName(queued_join_game_name_);
queued_join_game_name_ = "";
}
break;
case MasterServerEvent.RegistrationFailedGameName:
ConsoleScript.Log("Registration failed because an empty game name was given.");
break;
case MasterServerEvent.RegistrationFailedGameType:
ConsoleScript.Log("Registration failed because an empty game type was given.");
break;
case MasterServerEvent.RegistrationFailedNoServer:
ConsoleScript.Log("Registration failed because no server is running.");
break;
case MasterServerEvent.RegistrationSucceeded:
ConsoleScript.Log("Registration to master server succeeded, received confirmation.");
break;
}
}
/// <summary>
/// Reads a length-prefixed notification block.
/// </summary>
private static int ReadNotification(
byte[] buffer,
int length,
int position,
NetEvent destination)
{
// Read the length we added
ushort dataLength = NetEncoding.ReadU16(buffer, position);
position += NetEncoding.NOTIFICATION_HEADER_SIZE;
// Avoid a crash if the packet is bad (or malicious)
if ((position + dataLength) > length)
return -1;
// Read the data into the event's buffer
if (destination.ReadData(buffer, position, dataLength) == false)
return -1;
return NetEncoding.NOTIFICATION_HEADER_SIZE + dataLength;
}
void NetEventDisconnectedFromServer(NetEvent net_event) {
switch(net_event.network_disconnection()){
case NetworkDisconnection.Disconnected:
ConsoleScript.Log("Cleanly disconnected from server");
break;
case NetworkDisconnection.LostConnection:
ConsoleScript.Log("Connection to server was lost unexpectedly");
break;
}
if(state_ == State.NONE || state_ == State.JOIN_SUCCESS || state_ == State.JOINING){
Application.LoadLevel(Application.loadedLevel);
}
}
public void EmitNetEvent(NetEvent <INetClient> e)
{
NetEventIn.Invoke(e);
}
