protected override void SendNotMP(EPhotonMsg pMsgType, object[] pParams)
{
if (projectile.LocalImage)
{
projectile.LocalImage.Photon.HandleMsg(pMsgType, pParams);
}
}
sealed protected override bool CanSend(EPhotonMsg pMsgType)
{
if (!poolObject.IsPhotonInstantiated && isMultiplayer)
{
return(false);
}
if (view.ViewID == 0 && isMultiplayer)
{
if (pMsgType == EPhotonMsg.Pool_SetActive)
{
Debug.LogWarning("Cant send message yet. " + pMsgType);
}
else
{
Debug.LogError("Cant send message yet. " + pMsgType);
}
return(false);
}
switch (pMsgType)
{
//both sides can request return object to pool
case EPhotonMsg.Pool_ReturnToPool:
return(true);
case EPhotonMsg.Pool_SetActive:
return(IsMine);
}
return(CanSend2(pMsgType));
//return true;
}
protected override void HandleMsg(EPhotonMsg pReceivedMsg, object[] pParams, ByteBuffer bb)
{
switch (pReceivedMsg)
{
case EPhotonMsg.MainMenu_SyncGameInfo:
GameInitInfoS infoS = GameInitInfoS.GetRootAsGameInitInfoS(bb);
GameInitInfo gameInfo = GameInitInfo.Deserialize(infoS);
Debug.Log(gameInfo);
//reset current game info - DONT assign it
//it will be set from UI elements
brainiacs.GameInitInfo = new GameInitInfo();
mainMenu.GameSetup.OpenMain(gameInfo);
break;
case EPhotonMsg.MainMenu_SyncPlayerInfo:
PlayerInitInfoS playerInfoS = PlayerInitInfoS.GetRootAsPlayerInitInfoS(bb);
PlayerInitInfo playerInfo = PlayerInitInfo.Deserialize(playerInfoS);
mainMenu.GameSetup.SetupMain.UpdatePlayer(playerInfo);
break;
case EPhotonMsg.None:
default:
Debug.LogError("Message not handled");
break;
}
}
protected override void HandleMsg(EPhotonMsg pReceivedMsg, object[] pParams, ByteBuffer bb)
{
//Debug.Log($"Game HandleMsg {pReceivedMsg}");
switch (pReceivedMsg)
{
case EPhotonMsg.Game_PlayerLoadedScene:
if (!PhotonNetwork.IsMasterClient)
{
Debug.LogError("Only master should receive PlayerLoadedScene");
return;
}
PhotonPlayer player =
PhotonNetwork.CurrentRoom.GetPlayer((int)pParams[0]);
Debug.Log(player + " loaded game");
game.PlayerManager.OnRemotePlayerLoadedScene(player);
break;
//case EPhotonMsg.Game_Activate:
// game.Activate();
// break;
case EPhotonMsg.Game_Ui_ShowTimeValue:
int timeValue = (int)pParams[0];
game.UIGameTime.ShowTimeValue(timeValue);
break;
case EPhotonMsg.Game_UpdatePlayerScore:
int playerNumber = (int)pParams[0];
int kills = (int)pParams[1];
int deaths = (int)pParams[2];
game.Results.UpdatePlayerScore(playerNumber, kills, deaths);
break;
case EPhotonMsg.Game_EndGame:
GameResultInfoS infoS = GameResultInfoS.GetRootAsGameResultInfoS(bb);
GameResultInfo gameResultInfo = GameResultInfo.Deserialize(infoS);
Debug.Log("Game_SetGameResultInfo");
Debug.Log(gameResultInfo);
game.GameEnd.OnReceiveEndGame(gameResultInfo);
break;
case EPhotonMsg.Game_Lighting_SetMode:
bool night = (bool)pParams[0];
game.Lighting.SetMode(night);
break;
case EPhotonMsg.Game_HandleEffect:
EGameEffect effect = (EGameEffect)pParams[0];
game.GameEffect.HandleEffect(effect);
break;
default:
Debug.LogError("Message not handled");
break;
}
}
protected override bool CanSend3(EPhotonMsg pMsgType)
{
switch (pMsgType)
{
case EPhotonMsg.Special_Einstein_FallOn:
return(IsMine);
}
return(false);
}
protected override bool CanSend3(EPhotonMsg pMsgType)
{
switch (pMsgType)
{
case EPhotonMsg.Special_Flamethrower_OnDirectionChange:
return(IsMine);
}
return(false);
}
protected override bool CanSend(EPhotonMsg pMsgType)
{
if (pMsgType == EPhotonMsg.Map_Obstackle_DoCollisionEffect)
{
return(true);
}
return(false);
}
//[SerializeField] SpecialNobelMine mine = null;
protected override bool CanSend3(EPhotonMsg pMsgType)
{
if (pMsgType != EPhotonMsg.Special_Nobel_Spawn)
{
Debug.LogError("Cant send another message");
return(false);
}
return(IsMine);
}
sealed protected override bool CanSend2(EPhotonMsg pMsgType)
{
switch (pMsgType)
{
case EPhotonMsg.Special_Init:
return(IsMine);
}
return(CanSend3(pMsgType));
}
protected override bool CanSend3(EPhotonMsg pMsgType)
{
switch (pMsgType)
{
case EPhotonMsg.Special_Curie_StartTruck:
case EPhotonMsg.Special_Curie_Collide:
return(IsMine);
}
return(false);
}
protected override void SendNotMP(EPhotonMsg pMsgType, object[] pParams)
{
if (player.LocalImage)
{
player.LocalImage.Photon.HandleMsg(pMsgType, pParams);
}
else if (player.LocalImageOwner)
{
player.LocalImageOwner.Photon.HandleMsg(pMsgType, pParams);
}
}
private bool IsFlafbuffer(EPhotonMsg pMessage)
{
switch (pMessage)
{
case EPhotonMsg.MainMenu_SyncGameInfo:
case EPhotonMsg.MainMenu_SyncPlayerInfo:
case EPhotonMsg.Game_EndGame:
return(true);
}
return(false);
}
public void HandleMsg(EPhotonMsg pReceivedMsg, object[] pParams)
{
//var receivedMsg = (EPhotonMsg_MainMenu)objectArray[0];
if (DEBUG_LOG && !IsLogMsgIgnored(pReceivedMsg))
{
Debug.Log("HandleMsg " + pReceivedMsg);
}
byte[] bytes = IsFlafbuffer(pReceivedMsg) && pParams != null ? (byte[])pParams[0] : null;
ByteBuffer bb = IsFlafbuffer(pReceivedMsg) && bytes != null ? new ByteBuffer(bytes) : null;
HandleMsg(pReceivedMsg, pParams, bb);
}
/// <summary>
/// Send data to {target} (based on message type).
/// If game is not multiplayer the message wont send
/// and will be handled right away
/// </summary>
public void Send(EPhotonMsg pMsgType, params object[] pParams)
{
//if(DEBUG_LOG)
// Debug.Log("Send " + pMsgType + ", MP: " + isMultiplayer);
//todo: add timestamp to all messages?
//eg. neede for setting health
if (!CanSend(pMsgType))
{
if (DEBUG_LOG && !IsLogMsgIgnored(pMsgType))
{
Debug.Log(gameObject.name + " - cant send message: " + pMsgType);
}
return;
}
if (isMultiplayer)
{
if (!PhotonNetwork.IsConnected)
{
Debug.Log("Not connected - cant send message");
return;
}
if (DEBUG_LOG && !IsLogMsgIgnored(pMsgType))
{
Debug.Log("Send " + pMsgType);
}
RpcTarget target = GetMsgTarget(pMsgType);
view.RPC("HandleMsg", target, pMsgType, pParams);
}
else
{
if (DEBUG_LOG && !IsLogMsgIgnored(pMsgType))
{
Debug.Log("SendNotMP " + pMsgType);
}
if (debug_notMpMsgDelay > 0)
{
DoInTime(() => SendNotMP(pMsgType, pParams), debug_notMpMsgDelay);
}
else
{
SendNotMP(pMsgType, pParams);
}
}
}
protected override void HandleMsg3(EPhotonMsg pReceivedMsg, object[] pParams, ByteBuffer bb)
{
switch (pReceivedMsg)
{
case EPhotonMsg.Special_Einstein_FallOn:
Vector2 target = (Vector2)pParams[0];
bomb.FallOn(target);
break;
default:
OnMsgUnhandled(pReceivedMsg);
break;
}
}
protected override void HandleMsg(EPhotonMsg pReceivedMsg, object[] pParams, ByteBuffer bb)
{
switch (pReceivedMsg)
{
case EPhotonMsg.Map_Obstackle_DoCollisionEffect:
int obstackleId = (int)pParams[0];
MapObstackle obstackle = game.Map.GetObstackle(obstackleId);
obstackle.DoCollisionEffect(true);
break;
default:
Debug.LogError("Message not handled");
break;
}
}
protected override void HandleMsg3(EPhotonMsg pReceivedMsg, object[] pParams, ByteBuffer bb)
{
switch (pReceivedMsg)
{
case EPhotonMsg.Special_Nobel_Spawn:
int playerNumber = (int)pParams[0];
Player player = Game.Instance.PlayerManager.GetPlayer(playerNumber);
//mine.Spawn(player);
break;
default:
OnMsgUnhandled(pReceivedMsg);
break;
}
}
protected override void HandleMsg3(EPhotonMsg pReceivedMsg, object[] pParams, ByteBuffer bb)
{
//FlamethrowerController flamethrower = (FlamethrowerController)controller;
switch (pReceivedMsg)
{
case EPhotonMsg.Special_Flamethrower_OnDirectionChange:
EDirection dir = (EDirection)pParams[0];
flamethrower.OnDirectionChange(dir);
break;
default:
OnMsgUnhandled(pReceivedMsg);
break;
}
}
private RpcTarget GetMsgTarget(EPhotonMsg pMsgType)
{
switch (pMsgType)
{
case EPhotonMsg.Game_PlayerLoadedScene:
case EPhotonMsg.Game_UpdatePlayerScore: //only master keeps all player scores
return(RpcTarget.MasterClient);
//case EPhotonMsg_MainMenu.Play:
// return RpcTarget.All;
case EPhotonMsg.MainMenu_SyncGameInfo:
//return RpcTarget.AllViaServer; //debug
return(RpcTarget.Others);
}
return(RpcTarget.Others);
}
/// <summary>
/// Player can send data only if it is mine player and is inited.
/// There are execeptions.
/// </summary>
protected override bool CanSend2(EPhotonMsg pMsgType)
{
switch (pMsgType)
{
case EPhotonMsg.Player_InitPlayer:
case EPhotonMsg.Player_ShowWeapon:
return(true);
case EPhotonMsg.Player_AddKill:
case EPhotonMsg.Player_ApplyDamage:
case EPhotonMsg.Player_Push:
return(player.IsInited);
}
return(player.IsInitedAndMe);
}
protected override void HandleMsg2(EPhotonMsg pReceivedMsg, object[] pParams, ByteBuffer bb)
{
switch (pReceivedMsg)
{
case EPhotonMsg.Projectile_Spawn:
Vector2 projectileDirection = (Vector2)pParams[0];
EWeaponId weapon = (EWeaponId)pParams[1];
EDirection playerDirection = (EDirection)pParams[2];
projectile.SetSpawn(projectileDirection, weapon, playerDirection);
break;
default:
Debug.LogError(this.gameObject.name + " message not handled " + pReceivedMsg);
break;
}
}
/// <summary>
/// Debug for clearer output.
/// Skip too frequent and unnecessary messages
/// </summary>
private bool IsLogMsgIgnored(EPhotonMsg pMsgType)
{
switch (pMsgType)
{
case EPhotonMsg.Pool_SetActive:
return(!IsMine);
case EPhotonMsg.Player_ShowWeapon:
case EPhotonMsg.Player_ChangeDirection:
case EPhotonMsg.Player_UI_PlayerInfo_SetActiveWeapon:
case EPhotonMsg.Player_UI_PlayerInfo_SetAmmo:
case EPhotonMsg.Player_UI_PlayerInfo_SetHealth:
case EPhotonMsg.Player_UI_Scoreboard_SetScore:
return(true);
}
return(false);
}
protected override bool CanSend(EPhotonMsg pMsgType)
{
bool isMaster = brainiacs.PhotonManager.IsMaster();
switch (pMsgType)
{
//master keeps all player results, no need to send to clients
case EPhotonMsg.Game_UpdatePlayerScore:
return(!isMaster);
//only master send time
case EPhotonMsg.Game_Ui_ShowTimeValue:
case EPhotonMsg.Game_Lighting_SetMode:
return(isMaster);
}
return(true);
}
protected override bool CanSend2(EPhotonMsg pMsgType)
{
switch(pMsgType)
{
//master initiates
case EPhotonMsg.MapItem_Init:
return IsMine;
//explosion can be started on both sides
case EPhotonMsg.MapItem_DoExplosionEffect:
return true;
//only master can return items to pool (master owns all map items)
//case EPhotonMsg.MapItem_ReturnToPool:
// return !view.IsMine;
}
return false;
}
sealed protected override void HandleMsg(EPhotonMsg pReceivedMsg, object[] pParams, ByteBuffer bb)
{
switch (pReceivedMsg)
{
case EPhotonMsg.Pool_SetActive:
bool value = (bool)pParams[0];
poolObject.SetActive(value);
return;
case EPhotonMsg.Pool_ReturnToPool:
poolObject.ReturnToPool();
return;
//default:
// Debug.LogError(this.gameObject.name + " message not handled " + pReceivedMsg);
// break;
}
HandleMsg2(pReceivedMsg, pParams, bb);
}
protected override void HandleMsg3(EPhotonMsg pReceivedMsg, object[] pParams, ByteBuffer bb)
{
//SpecialCurieTruck truck = GetComponent<SpecialCurieTruck>();
switch (pReceivedMsg)
{
case EPhotonMsg.Special_Curie_StartTruck:
EDirection dir = (EDirection)pParams[0];
Vector2 pos = (Vector2)pParams[1];
truck.StartTruck(dir, pos);
break;
case EPhotonMsg.Special_Curie_Collide:
truck.Collide();
break;
default:
OnMsgUnhandled(pReceivedMsg); //call SpecialWeaponPhoton instead
break;
}
}
sealed protected override void HandleMsg2(EPhotonMsg pReceivedMsg, object[] pParams, ByteBuffer bb)
{
switch (pReceivedMsg)
{
case EPhotonMsg.Special_Init:
int playerNumber = (int)pParams[0];
Game.Instance.PlayerManager.OnAllPlayersAdded.AddAction(() => InitPrefab(playerNumber));
//todo: maybe no need to send playerNumber, get it from view.OwnerActorNr
break;
//case EPhotonMsg.Special_Use:
// controller.Use();
// break;
//case EPhotonMsg.Special_StopUse:
// controller.StopUse();
// break;
default:
HandleMsg3(pReceivedMsg, pParams, bb);
break;
}
}
protected override void HandleMsg2(EPhotonMsg pReceivedMsg, object[] pParams, ByteBuffer bb)
{
switch(pReceivedMsg)
{
case EPhotonMsg.MapItem_Init:
Vector2 pos = (Vector2)pParams[0];
MapItem.EType type = (MapItem.EType)pParams[1];
int subtypeIndex = (int)pParams[2];
item.Init(pos, type, subtypeIndex);
break;
case EPhotonMsg.MapItem_DoExplosionEffect:
item.DoExplosionEffect(true);
break;
//case EPhotonMsg.MapItem_ReturnToPool:
// item.ReturnToPool();
// break;
default:
OnMsgUnhandled(pReceivedMsg);
break;
}
}
protected override bool CanSend3(EPhotonMsg pMsgType)
{
return(true);
}
protected override void HandleMsg3(EPhotonMsg pReceivedMsg, object[] pParams, ByteBuffer bb)
{
}
