private void HandleKey(char keyChar)
{
if ('1' == keyChar)
{
ScenceController.curScence = ScenceController.scenceDict["room"];
MsgListRoom msgListRoom = new MsgListRoom();
NetManagerEvent.Send(msgListRoom);
}
else if ('2' == keyChar)
{
}
else if ('3' == keyChar)
{
}
else if ('4' == keyChar)
{
}
else if ('5' == keyChar)
{
ScenceController.isLeavel = true;
NetManagerEvent.Close();
}
else
{
Handle();
}
}
public static void InitNet()
{
NetManagerEvent.AddListener("MsgEnter", OnEnter);
NetManagerEvent.AddListener("MsgMove", OnMove);
NetManagerEvent.AddListener("MsgLeave", OnLeave);
NetManagerEvent.AddListener("MsgAttack", OnAttack);
NetManagerEvent.AddListener("MsgRegistry", OnRegistry);
NetManagerEvent.AddListener("MsgLogin", OnLogin);
NetManagerEvent.AddListener("MsgListRoom", OnListRoom);
NetManagerEvent.AddListener("MsgEnterRoom", OnEnterRoom);
NetManagerEvent.AddListener("MsgGetRoomInfo", OnGetRoomInfo);
NetManagerEvent.AddListener("MsgLeaveRoom", OnLeaveRoom);
NetManagerEvent.AddListener("MsgPrepare", OnPrepare);
NetManagerEvent.AddListener("MsgUnprepare", OnUnprepare);
NetManagerEvent.AddListener("MsgStartBattle", OnStartBattle);
NetManagerEvent.AddListener("MsgEndBattle", OnEndBattle);
NetManagerEvent.Connect("192.168.1.178", 8888);
}
private IEnumerator WaitForConnectAndCall(NetManagerEvent NetEvent)
{
Debug.LogWarning("Need to reconect to take action");
while (!PhotonNetwork.connectedAndReady)
{
yield return(new WaitForSeconds(0.05f));
}
yield return(new WaitForSeconds(2f));
while (!PhotonNetwork.connectedAndReady)
{
yield return(new WaitForSeconds(0.05f));
} //double check
if (NetEvent != null)
{
NetEvent();
}
}
private void handleKey(ConsoleKey key)
{
switch (key)
{
case ConsoleKey.UpArrow:
player.Velocity.Veloctity = Component.Veloctity.up;
player.IsMove = true;
break;
case ConsoleKey.DownArrow:
player.Velocity.Veloctity = Component.Veloctity.down;
player.IsMove = true;
break;
case ConsoleKey.LeftArrow:
player.Velocity.Veloctity = Component.Veloctity.left;
player.IsMove = true;
break;
case ConsoleKey.RightArrow:
player.Velocity.Veloctity = Component.Veloctity.right;
player.IsMove = true;
break;
case ConsoleKey.Spacebar:
player.IsMove = false;
break;
case ConsoleKey.A:
if (player.AttchInterval == 5)
{
MsgAttack msgAttack = new MsgAttack();
msgAttack.playId = player.Id;
NetManagerEvent.Send(msgAttack);
player.AttchInterval = 1;
}
break;
default:
break;
}
}
public void Execute()
{
List <Sprite> players = scence.sprites.Where(spirte => spirte is Player).ToList();
foreach (Player player in players)
{
if (autoPlayer.Contains(player) && player.AttchInterval == 5)
{
MsgAttack msgAttack = new MsgAttack();
msgAttack.playId = player.Id;
NetManagerEvent.Send(msgAttack);
player.AttchInterval = 1;
}
else
{
if (player.AttchInterval < 5)
{
player.AttchInterval += 1;
}
}
}
}
public void Execute()
{
var sprites = scence.sprites;
//碰撞监听
Player player = (Player)sprites.Where(sprite => sprite.GetType() == typeof(Player) && sprite.Id == ScenceController.user.Userid).FirstOrDefault();
if (player != null)
{
List <Sprite> skills = sprites.Where(sprite => sprite.GetType() == typeof(Skill)).ToList();
for (int j = skills.Count - 1; j >= 0; j--)
{
if (player.Position.X == skills[j].Position.X && player.Position.Y == skills[j].Position.Y)
{
SpriteDestorySystem spriteDestorySystem = SpriteDestorySystem.GetSpriteDestorySystem();
spriteDestorySystem.sprites.Enqueue(player);
MsgLeave msgLeave = new MsgLeave
{
playId = player.Id
};
NetManagerEvent.Send(msgLeave);
}
}
}
}
public virtual Task Execute(IJobExecutionContext context)
{
NetManagerEvent.Update();
return(null);
}
// Start is called before the first frame update
private void Start()
{
// UDP Socket Listener/Sender initialization
_socket = new UdpSocket();
_socketListener = new AsyncUdpSocketListener(_socket);
_socketSender = new AsyncUdpSocketSender(_socket);
// Add to RingBuffer from listener async callbacks which happen off the main thread
_socketListener.ReceivedUdpMessageEvent += AddUdpMessageToReceivedBuffer;
// Init ring buffers
_receivedMessageBuffer = RingBuffer <UdpMessage> .Create(
ProducerType.Single,
UdpMessage.DefaultFactory,
256,
new BusySpinWaitStrategy());
_receivedMessagePoller = _receivedMessageBuffer.NewPoller();
_receivedMessageBuffer.AddGatingSequences(_receivedMessagePoller.Sequence);
_outgoingMessageBuffer = RingBuffer <OutgoingUdpMessage> .Create(
ProducerType.Single,
OutgoingUdpMessage.DefaultFactory,
256,
new BusySpinWaitStrategy());
_outgoingMessagePoller = _outgoingMessageBuffer.NewPoller();
_outgoingMessageBuffer.AddGatingSequences(_outgoingMessagePoller.Sequence);
// This makes a deep copy of the sent message before publishing it to the outgoing message buffer
// It makes a deep copy because the buffers containing the data in the main thread could change
// before the data has a chance to be copied into the ring buffer. Prob want to think of a way around this.. maybe more ring buffers
_outgoingUdpMessageSender = new RingBufferOutgoingUdpMessageSender(_outgoingMessageBuffer);
// The NetManager reactor. TODO: Benchmark and see if I have actually made any improvement by implementing disruptor
// Though I do like the idea of clearing up the locks and doing all the logic in the main thread esp since
// the game server will need to routinely access connected client info
RNetManager = new NetManager(null, _outgoingUdpMessageSender)
{
DisconnectTimeout = 600
};
RGameReactor.RNetManager = RNetManager;
_updateEvent = new GameEvent {
EventId = GameEvent.Event.Update
};
_tempEvent = new GameEvent(); // reusable event for the update loop
//if (!ShouldBind)
//{
//RNetManager.SimulateLatency = true;
RNetManager.SimulatePacketLoss = true;
// R_NetManager.SimulationMaxLatency = 10;
// R_NetManager.SimulationMinLatency = 0;
//}
_cancellationSource = new CancellationTokenSource();
_processOutgoing = new Thread(SendOutgoingUdpMessages)
{
IsBackground = true,
Name = "UdpServer"
};
// Every frame the previous frames events get replaced with new output events created by the NetManager reactor for that frame
_batchedEvents = new NetManagerEvent[MaxUdpMessagesPerFrame];
for (int i = 0; i < MaxUdpMessagesPerFrame; i++)
{
_batchedEvents[i] = new NetManagerEvent {
EventId = NetManagerEvent.Event.UdpMessage
}
}
;
// BIND
if (ShouldBind)
{
_socket.BindLocalIpv4(BindAddress, BindPort);
}
// CONNECT - TEMPORARY - NEEDS TO BE SOME SORT OF STATE MACHINE
if (ShouldConnect)
{
RNetManager.Connect(ConnectAddress, ConnectPort, "somekey");
}
// No point actually awaiting this call.. it kicks off a
// recurring execution where the finish method always calls the start method again
#pragma warning disable 4014
_socketListener.StartAsyncReceive();
#pragma warning restore 4014
// Start thread that polls for outgoing udp messages and sends them on the socket
_processOutgoing.Start(new object[] { _socketSender, _outgoingMessagePoller, _cancellationSource.Token });
// Start coroutine that will send the check timeout event
StartCoroutine("SendCheckTimeoutEvent");
}
