public void OnJoinedRoom()
{
Room currentRoom = PhotonNetwork.room;
string mapName = currentRoom.GetMap();
m_roomMap = m_mapDatabase.GetMapWithMapName(mapName);
int gamemodeIndex = currentRoom.GetGamemode();
m_currenGameMode = (Mode)gamemodeIndex;
Debug.Log("Gamemode : " + m_currenGameMode);
//Instantiate MasterCLients Player
if (PhotonNetwork.isMasterClient)
{
Gamemode.AddPlayerToTeam(m_currenGameMode, PhotonNetwork.masterClient);
NetworkEventHandler.SyncSpawnNode(PhotonNetwork.player.GetPlayerTeam(), PhotonNetwork.masterClient);
m_pingroutine = StartCoroutine(SetPing());
}
SetPlayerCount();
IsRoomFull();
m_startInternalTimer = true;
}
/// <summary>
/// Raises an event.
/// </summary>
private void Raise <T>(NetworkEventHandler <T> handler, T args)
where T : EventArgs
{
if (handler != null)
{
handler(this, args);
}
}
// Update is called once per frame
void Update()
{
// 协议
NetworkEventHandler.Update();
TimerTaskQueue.Instance.Tick();
FrameTimerTaskHeap.Instance.Tick();
SequenceManager.Instance.Tick();
}
/// <summary>
/// 添加脚本对象要处理的网络协议Id及其响应方法
/// </summary>
/// <param name="id">协议Id</param>
/// <param name="handler">进行响应的方法</param>
protected void AddNetworkHandler(ProtoID id, NetworkEventHandler handler)
{
m_HandlerPairs.Add(new KeyValuePair <ProtoID, NetworkEventHandler> (id, handler));
// 如果脚本处于启用状态，要实时向网络管理器注册事件响应
if (this.enabled)
{
NetworkChangeManager.RegisterWeak(id, handler);
}
}
void OnDestroy()
{
NetworkClient.Instance.Stop();
NetworkEventHandler.Clear();
SequenceManager.Instance.Clear();
TimerTaskQueue.Instance.Reset();
FrameTimerTaskHeap.Instance.Reset();
IntEventDispatcher.Cleanup();
Logger.Instance.Stop();
}
public void OnPhotonPlayerConnected(PhotonPlayer newPlayer)
{
//Only MasterClient start Event to create Player
//newPlayer is the new joind Client
if (PhotonNetwork.isMasterClient)
{
Gamemode.AddPlayerToTeam(m_currenGameMode, newPlayer);
NetworkEventHandler.SyncSpawnNode(newPlayer.GetPlayerTeam(), newPlayer);
}
SetPlayerCount();
IsRoomFull();
}
void Awake()
{
DebugUtils.AddLogAction(DebugLog);
Properties cfg = Properties.Create("config.txt");
InitializeClient(cfg);
InitializeLogger(cfg);
TimerTaskQueue.Instance.Reset();
FrameTimerTaskHeap.Instance.Reset();
SequenceManager.Instance.Clear();
IntEventDispatcher.Cleanup();
NetworkEventHandler.Initialize();
ResourceManager.Initialize(ResourceLoadMode.AB, Application.streamingAssetsPath + "/PC", "PC");
}
void SpawnEvent()
{
Debug.Log("Match Handler Sends Spawn Event to Player");
if (PhotonNetwork.isMasterClient)
{
var m_photonPlayerList = PhotonNetwork.playerList;
//sending Spawn Information to each Client
foreach (PhotonPlayer pp in m_photonPlayerList)
{
NetworkEventHandler.SyncSpawnNode(pp.GetPlayerTeam(), pp);
}
m_isSpawned = true;
}
}
public bool AddHandler(string eventName, NetworkEventHandler eventHandler)
{
if (networkEventHandlers.ContainsKey(eventName))
{
return(false);
}
else
{
networkEventHandlers.Add(eventName, eventHandler);
timeSincePollMs.Add(eventName, float.MaxValue);
lastGetComplete.Add(eventName, true);
return(true);
}
}
/// <summary>
/// 注销 消息和事件的映射关系
/// </summary>
/// <param name="subject">消息Id</param>
/// <param name="observer">响应事件的委托方法</param>
public static void Unregister(ProtoID subject, NetworkEventHandler observer)
{
if (s_weakNetworkMsgMap.ContainsKey(subject))
{
WeakAction weakAction = new WeakAction(observer);
if (s_weakNetworkMsgMap[subject].Contains(weakAction))
{
s_weakNetworkMsgMap[subject].Remove(weakAction);
}
if (s_weakNetworkMsgMap[subject] == null)
{
s_weakNetworkMsgMap.Remove(subject);
}
}
}
static int RegisterCallBack(IntPtr L)
{
try
{
ToLua.CheckArgsCount(L, 3);
LuaFramework.NetworkManager obj = (LuaFramework.NetworkManager)ToLua.CheckObject <LuaFramework.NetworkManager>(L, 1);
Protocols.ProtoID arg0 = (Protocols.ProtoID)ToLua.CheckObject <Protocols.ProtoID>(L, 2);
NetworkEventHandler arg1 = (NetworkEventHandler)ToLua.CheckDelegate <NetworkEventHandler>(L, 3);
obj.RegisterCallBack(arg0, arg1);
return(0);
}
catch (Exception e)
{
return(LuaDLL.toluaL_exception(L, e));
}
}
static int RegisterShortCallBack(IntPtr L)
{
try
{
ToLua.CheckArgsCount(L, 3);
LuaFramework.NetworkManager obj = (LuaFramework.NetworkManager)ToLua.CheckObject <LuaFramework.NetworkManager>(L, 1);
ushort arg0 = (ushort)LuaDLL.luaL_checknumber(L, 2);
NetworkEventHandler arg1 = (NetworkEventHandler)ToLua.CheckDelegate <NetworkEventHandler>(L, 3);
obj.RegisterShortCallBack(arg0, arg1);
return(0);
}
catch (Exception e)
{
return(LuaDLL.toluaL_exception(L, e));
}
}
static void Main(string[] args)
{
// Create the NetworkDatagramHandler, NetworkEventHandler,
// and ServerState
var datagramHandler = new NetworkDatagramHandler(3000);
var state = new ServerState(datagramHandler);
var eventHandler = new NetworkEventHandler(datagramHandler, state);
Console.WriteLine("Server started - ready to recieve datagrams");
// Loop until Ctrl-C
while (true)
{
;
}
}
/// <summary>
/// Raise the failed event
/// </summary>
protected virtual void OnFailed(string message)
{
NetworkEventHandler tempEvent = Failed;
if (tempEvent != null)
{
try
{
tempEvent(this, new NetworkEventArgs(message));
}
catch (Exception ex)
{
if (!Log.SilentMode)
{
Log.Write(LogMessageSeverity.Error, LogWriteMode.Queued, ex, LogCategory, "Client exception thrown during failed event", ex.Message);
}
}
}
}
/// <summary>
/// 注册 消息Id和消息响应事件的回调
/// </summary>
/// <param name="subject">消息Id</param>
/// <param name="observer">响应事件的委托方法</param>
public static void RegisterStrong(ProtoID subject, NetworkEventHandler observer)
{
// 已经注册过的消息就在消息列表中追加处理事件
if (s_strongNetworkMsgMap.ContainsKey(subject))
{
if (s_strongNetworkMsgMap[subject].Contains(observer))
{
return;
}
s_strongNetworkMsgMap[subject].Add(observer);
}
// 注册新消息
else
{
List <NetworkEventHandler> actions = new List <NetworkEventHandler>();
actions.Add(observer);
s_strongNetworkMsgMap.Add(subject, actions);
}
}
/// <summary>
/// Raises the <see cref="NetworkUp"/> or <see cref="NetworkDown"/> event.
/// </summary>
/// <param name="sender">The <see cref="NetworkModule"/> that raised the event.</param>
/// <param name="state">The state of the network.</param>
protected virtual void OnNetworkEvent(NetworkModule sender, NetworkState state)
{
if (_OnNetwork == null)
{
_OnNetwork = new NetworkEventHandler(OnNetworkEvent);
}
if (Program.CheckAndInvoke(state == NetworkState.Up ? _NetworkUp : _NetworkDown, _OnNetwork, sender, state))
{
switch (state)
{
case NetworkState.Up:
_NetworkUp(sender, state);
break;
case NetworkState.Down:
_NetworkDown(sender, state);
break;
}
}
}
/// <summary>
/// 注册 消息Id和消息响应事件的回调
/// </summary>
/// <param name="subject">消息Id</param>
/// <param name="observer">响应事件的委托方法</param>
public static void RegisterWeak(ProtoID subject, NetworkEventHandler observer)
{
// 已经注册过的消息就在消息列表中追加处理事件
if (s_weakNetworkMsgMap.ContainsKey(subject))
{
WeakAction weakAction = new WeakAction(observer);
if (s_weakNetworkMsgMap[subject].Contains(weakAction))
{
return;
}
s_weakNetworkMsgMap[subject].Add(weakAction);
}
// 注册新消息
else
{
List <WeakAction> weakActions = new List <WeakAction>();
weakActions.Add(new WeakAction(observer));
s_weakNetworkMsgMap.Add(subject, weakActions);
}
}
public NetworkEventHandler NetworkEventHandler(LuaFunction func, LuaTable self, bool flag)
{
if (func == null)
{
NetworkEventHandler fn = delegate(Protocols.Protocol param0) { };
return(fn);
}
if (!flag)
{
NetworkEventHandler_Event target = new NetworkEventHandler_Event(func);
NetworkEventHandler d = target.Call;
target.method = d.Method;
return(d);
}
else
{
NetworkEventHandler_Event target = new NetworkEventHandler_Event(func, self);
NetworkEventHandler d = target.CallWithSelf;
target.method = d.Method;
return(d);
}
}
public async Task Connect(INetworkClient client)
{
await Initialize();
var transactionManager = new RelayTransactionManager();
var options = await client.ClientOptions;
var remote = await Remote;
var eventHandler = new NetworkEventHandler(this, client);
var clientService = new RelayClient(eventHandler, transactionManager);
var networkConnection = new NetworkConnection(this, clientService, eventHandler);
// Try to connect
transactionManager.SetEventLoop(true);
client.NetworkConnection = networkConnection;
await clientService.Connect(remote, options);
// Save active connections
_active.Add(new NetworkActiveService()
{
NetworkConnection = networkConnection,
TransactionManager = transactionManager
});
}
void RespawnPlayer()
{
m_currenGameMode = (Mode)PhotonNetwork.room.GetGamemode();
PhotonPlayer localPlayer = PhotonNetwork.player;
Teams.Team team = localPlayer.GetPlayerTeam();
switch (m_currenGameMode)
{
case Mode.TeamDeathMatch:
NetworkEventHandler.TeamBasedRespawn(team, localPlayer);
break;
case Mode.DeatchMatch:
NetworkEventHandler.RespawnRandomSpawnNode(localPlayer);
break;
}
m_countDown = m_respawnTime;
if (m_counter.gameObject.activeInHierarchy)
{
m_counter.gameObject.SetActive(false);
}
}
/// <summary>
/// Raises the <see cref="NetworkUp"/> or <see cref="NetworkDown"/> event.
/// </summary>
/// <param name="sender">The <see cref="NetworkModule"/> that raised the event.</param>
/// <param name="state">The state of the network.</param>
protected virtual void OnNetworkEvent(NetworkModule sender, NetworkState state)
{
if (_OnNetwork == null) _OnNetwork = new NetworkEventHandler(OnNetworkEvent);
if (Program.CheckAndInvoke(state == NetworkState.Up ? _NetworkUp : _NetworkDown, _OnNetwork, sender, state))
{
switch (state)
{
case NetworkState.Up:
_NetworkUp(sender, state);
break;
case NetworkState.Down:
_NetworkDown(sender, state);
break;
}
}
}
void Push_NetworkEventHandler(IntPtr L, NetworkEventHandler o)
{
ToLua.Push(L, o);
}
private void NetworkSwitch(object sender, NetworkEventHandler e)
{
OpenNetwork(e.GetNework());
}
public void RegisterCallBack(ProtoID _protoId, NetworkEventHandler _callback)
{
NetworkChangeManager.RegisterWeak(_protoId, _callback);
}
public NetworkConnection(NetworkConnectionManager manager, RelayClient clientService, NetworkEventHandler eventHandler)
{
_manager = manager;
_clientService = clientService;
_transactionManager = new NetworkTransactionManager();
eventHandler.Connected(this);
}
public void RegisterShortCallBack(UInt16 _protoId, NetworkEventHandler _callback)
{
NetworkChangeManager.RegisterStrong((ProtoID)_protoId, _callback);
}
public WeakAction(NetworkEventHandler action)
{
Method = action.Method;
Reference = new WeakReference(action.Target);
}
