void ReceiveCommand2v(int cmd, Vector3 vParam1, Vector3 vParam2, int networkID, int commandIndex, Vector3 commandPos, PhotonMessageInfo msgInfo)
{
Debug.Log("[RPC] [receive] command:" + (FCCommand.CMD)cmd + " obj:" + networkID + " from player:" + msgInfo.sender
+ " delayMS : " + ((int)((PhotonNetwork.time - msgInfo.timestamp) * 1000)).ToString());
//put the command into input command list
OBJECT_ID object_ID = ObjectManager.Instance.GetObjectByNetworkID(networkID);
if (object_ID == null)
{
Debug.Log("command target object is not exist: " + networkID);
}
else
{
FCCommand ewd = new FCCommand();
ewd.Set((FCCommand.CMD)cmd,
object_ID,
vParam1, FC_PARAM_TYPE.VECTOR3,
vParam2, FC_PARAM_TYPE.VECTOR3,
null, FC_PARAM_TYPE.NONE,
FCCommand.STATE.RIGHTNOW,
false);
WriteCommandToCache(object_ID.NetworkId, commandPos, false, commandIndex, ewd);
}
}
public bool Send(FCCommand.CMD cmd, OBJECT_ID objectID, FCCommand.STATE state, bool isHost)
{
bool ret = false;
if (state != FCCommand.STATE.RIGHTNOW)
{
FCCommand ewd = null;
if (_deActiveCommandList.Count != 0)
{
ewd = _deActiveCommandList[0];
_deActiveCommandList.Remove(ewd);
}
else
{
ewd = new FCCommand();
}
ewd.Set(cmd, objectID, state, isHost);
AddCmdToArray(ewd);
}
else
{
_fastCommand.Set(cmd, objectID, state, isHost);
if (objectID.HandleCommand(ref _fastCommand))
{
_fastCommand._objID = null;
ret = true;
}
else
{
//AddCmdToArray(ewd);
// may need to add it to command list
}
}
return(ret);
}
public override bool HandleCommand(ref FCCommand ewd)
{
int rootcmd = ((int)ewd._cmd / 100) * 100;
int subcmd = ((int)ewd._cmd);
bool canrun = true;
bool ret = false;
if (canrun)
{
if (rootcmd < 0 ||
(rootcmd == (int)FCCommand.CMD.MOVE && HasActionSwitchFlag(FC_ACTION_SWITCH_FLAG.CANT_MOVE))
)
{
canrun = false;
}
}
if (canrun)
{
switch ((FCCommand.CMD)rootcmd)
{
case FCCommand.CMD.MOVE:
if (_state != null && _state.CurrentStateID == AIAgent.STATE.IDLE)
{
ret = SetNextState(AIAgent.STATE.RUN);
}
break;
}
if (subcmd >= 0)
{
ret = HandleInnerCmd((FCCommand.CMD)subcmd, null, ewd._param1, ewd._param2, ewd._param3);
}
}
return(ret);
}
public override bool HandleCommand(ref FCCommand ewd)
{
switch (ewd._cmd)
{
case FCCommand.CMD.ATTACK_HIT_TARGET:
{
ActionController ac = ewd._param1 as ActionController;
Assertion.Check(ac != null);
EnemyInRange info = new EnemyInRange();
info._ac = ac;
info._timer = 0.0f;
_enemys.Add(info);
}
break;
case FCCommand.CMD.ATTACK_OUT_OF_RANGE:
{
ActionController ac = ewd._param1 as ActionController;
Assertion.Check(ac != null);
for (int i = _enemys.Count - 1; i >= 0; --i)
{
if (_enemys[i]._ac == ac)
{
_enemys.RemoveAt(i);
break;
}
}
}
break;
default:
break;
}
return(true);
}
public void Init(FCObject owner)
{
_owner = owner;
_isInMoveS = false;
_isInMoveD = false;
_isInNavPathFinding = false;
_currentSpeed = 0;
_moveDirection = Vector3.zero;
_fastCommand = new FCCommand();
_thisRigidBody = _owner.rigidbody;
if (_thisRigidBody != null)
{
_thisRigidBody.drag = 100;
_thisRigidBody.isKinematic = true;
}
_currentMoveLengthCount = 0;
_currentMoveLength = 0;
_characterController = _owner.GetComponent <CharacterController>();
_fastCommand.Set(FCCommand.CMD.STOP, owner.ObjectID, FCCommand.STATE.RIGHTNOW, true);
if (_navAgent != null)
{
_navAgent.radius = 0;
_navAgent.enabled = false;
_defaultRaduis = _navAgent.radius;
}
_rotateDirection = _owner.ThisTransform.forward;
if (_fallHeight <= 0)
{
_fallHeight = 1;
}
//_gReadAccel.y = FC_CONST.REAL_G;
}
public FCCommand ReadCommandFromCache2(int objID)
{
FC_COMMAND_NETSTREAM ecns = null;
FCCommand ewc = null;
FCCommand ret = null;
if (_commandCmdStreamCache.ContainsKey(objID))
{
List <FC_COMMAND_NETSTREAM> list = _commandCmdStreamCache[objID];
if (list.Count > 0)
{
ecns = list[0];
}
else
{
ecns = null;
}
}
else
{
ecns = null;
}
if (_commandRpcCache.ContainsKey(objID))
{
List <FCCommand> list = _commandRpcCache[objID];
if (list.Count > 0)
{
ewc = _commandRpcCache[objID][0];
if (ecns != null && ecns._commandIndex < ewc._cmdIndex)
{
ret = new FCCommand(ecns);
_commandCmdStreamCache[objID].RemoveAt(0);
}
else
{
ret = ewc;
// Debug.Log(string.Format("[rpc command] ReadCommandFromCache2 -- remove _commandIndex:{0} , _currentPosition:{1} , CMD = {2}" ,
// ewc._cmdIndex , ewc._commandPosition , ewc._cmd ));
_commandRpcCache[objID].RemoveAt(0);
}
}
else
{
ewc = null;
}
}
else
{
ewc = null;
}
if (ecns != null && ret == null)
{
ret = new FCCommand(ecns);
_commandCmdStreamCache[objID].RemoveAt(0);
}
return(ret);
}
//update and distribute input command list
private void UpdateInputCommanList()
{
//check input command list and distribute
int inputCommandListCount = _inputCommandList.Count;
if (inputCommandListCount > 0)
{
Debug.Log("[receive] command count: " + inputCommandListCount);
for (int i = 0; i < inputCommandListCount; i++)
{
//handle commands
FCCommand command = _inputCommandList[i];
Debug.Log("[receive] command : " + command._cmd);
switch (command._cmd)
{
case FCCommand.CMD.CLIENT_MOVE_TO_POINT:
case FCCommand.CMD.CLIENT_HURT:
case FCCommand.CMD.CLIENT_HURT_HP:
case FCCommand.CMD.CLIENT_THREAT:
case FCCommand.CMD.CLIENT_LEVELUP:
case FCCommand.CMD.CLIENT_CURRSTATE:
case FCCommand.CMD.CLIENT_POTION_HP:
case FCCommand.CMD.CLIENT_POTION_ENERGY:
case FCCommand.CMD.CLIENT_REVIVE:
{
//handle this right now, network agent will do it
_inputCommandList[i]._objID.HandleCommand(ref command);
}
break;
case FCCommand.CMD.DIE_NORMAL:
case FCCommand.CMD.ATTACK_WITH_SPEC_CONTS:
case FCCommand.CMD.ACTION_CANCEL:
{
//convert to self fast inner command
command._isHost = true;
CommandManager.Instance.SendFastToSelf(ref command);
}
break;
default:
{
Debug.LogError("receive command but cannot handle :" + command._cmd);
}
break;
}
}
//clear command list
_inputCommandList.Clear();
}
}
void Awake()
{
_fastCommand = new FCCommand();
_fastCommand.Set(FCCommand.CMD.STOP, null, FCCommand.STATE.RIGHTNOW, true);
_threatTable = new ThreatTable();
_threatTable._length = 4;
_threatTable._threatList = new int[_threatTable._length];
_threatTable._targetList = new ActionController[_threatTable._length];
_threatTable._count = 0;
}
public bool HandleCommand(ref FCCommand ewd)
{
if (!_fcObj.IsDestroyed)
{
return(_fcObj.HandleCommand(ref ewd));
}
else
{
return(true);
}
}
protected override void Awake()
{
base.Awake();
_isRangerBullet = true; // make me be enable to override function 'FireRange()'
_enemys = new System.Collections.Generic.List <EnemyInRange>();
_mask = (1 << LayerMask.NameToLayer("WALL"));
_mask |= (1 << LayerMask.NameToLayer("WALL_AIR"));
_mask |= (1 << LayerMask.NameToLayer("GROUND"));
_fastCommand = new FCCommand();
_fastCommand._param1 = this;
_fastCommand._cmd = FCCommand.CMD.HURT;
}
public FCCommand(FCCommand ewc)
{
_cmdIndex = ewc._cmdIndex;
_cmd = ewc._cmd;
_param1 = ewc._param1;
_param2 = ewc._param2;
_param3 = ewc._param3;
_param1Type = ewc._param1Type;
_param2Type = ewc._param2Type;
_param3Type = ewc._param3Type;
_objID = ewc._objID;
_state = ewc._state;
_isHost = ewc._isHost;
}
public void AddCmdToArray(FCCommand ewd)
{
List <FCCommand> ewdl = null;
if (_commandArray.ContainsKey((int)ewd._objID))
{
ewdl = _commandArray[(int)ewd._objID];
}
else
{
ewdl = new List <FCCommand>();
_commandArray[(int)ewd._objID] = ewdl;
}
ewdl.Add(ewd);
Send(FCCommand.CMD.NET_HAS_EVENT, ewdl[0], FC_PARAM_TYPE.OTHERS, ewdl[0]._objID, FCCommand.STATE.RIGHTNOW, true);
}
public bool SendFast(ref FCCommand ewd, FCObject eb)
{
if (ewd._cmd == FCCommand.CMD.INVALID)
{
return(false);
}
if (ewd._cmd == FCCommand.CMD.ATTACK_HIT_TARGET)
{
ActionController ac = ewd._param1 as ActionController;
if (ac.IsPlayerSelf)
{
//ac.
}
}
return(eb.ObjectID.HandleCommand(ref ewd));
}
public override bool HandleCommand(ref FCCommand ewd)
{
switch (ewd._cmd)
{
case FCCommand.CMD.ATTACK_HIT_TARGET:
{
ActionController target = ewd._param1 as ActionController;
HandleHitTarget.HandleHit(_owner, this, _damageType, target);
if (GetAttackInfo()._hitType == AttackHitType.ForceBack)
{
AIAgent aiAgent = _owner.gameObject.GetComponentInChildren <AIAgent>();
if (aiAgent != null)
{
aiAgent.AddHitBackList(target);
}
}
if (_hitSound != "")
{
SoundManager.Instance.PlaySoundEffect(_hitSound);
}
}
break;
case FCCommand.CMD.ATTACK_OUT_OF_RANGE:
{
ActionController target = ewd._param1 as ActionController;
if (GetAttackInfo()._hitType == AttackHitType.ForceBack)
{
AIAgent aiAgent = _owner.gameObject.GetComponentInChildren <AIAgent>();
if (aiAgent != null)
{
if (!GameManager.Instance.IsPVPMode)
{
aiAgent.RemoveHitBackList(target);
}
}
}
}
break;
}
return(true);
}
public override bool HandleCommand(ref FCCommand ewd)
{
switch (ewd._cmd)
{
case FCCommand.CMD.ATTACK_HIT_TARGET:
{
_targetList.Add((ewd._param1 as ActionController));
break;
}
case FCCommand.CMD.ATTACK_OUT_OF_RANGE:
{
_targetList.Remove((ewd._param1 as ActionController));
(ewd._param1 as ActionController).ACEffectByGravity(0, null, 0, true, false);
break;
}
}
return(true);
}
protected virtual void FirstInit()
{
_fastCommand = new FCCommand();
_fastCommand.Set(FCCommand.CMD.STOP, null, FCCommand.STATE.RIGHTNOW, true);
_thisObject = gameObject;
_selfCollider = _thisObject.collider;
if (_selfCollider.GetType().ToString().Contains("Sphere"))
{
_colliderType = COLLIDER_TYPE.Sphere;
}
else if (_selfCollider.GetType().ToString().Contains("Capsule"))
{
_colliderType = COLLIDER_TYPE.Capsule;
}
if (_parent != null && _parent.ObjectID.ObjectType == FC_OBJECT_TYPE.OBJ_BULLET)
{
((FCBullet)_parent)._damageReceiver = this;
DeActiveLogic();
}
}
public override bool HandleCommand(ref FCCommand ewd)
{
base.HandleCommand(ref ewd);
switch (ewd._cmd)
{
case FCCommand.CMD.ATTACK_HIT_TARGET:
{
if (_attackInfo._hitType == AttackHitType.BlackHole)
{
_targetList.Add((ewd._param1 as ActionController));
}
else if (_attackInfo._hitType == AttackHitType.Lock)
{
_targetList.Add((ewd._param1 as ActionController));
}
break;
}
}
return(true);
}
public override bool HandleCommand(ref FCCommand ewd)
{
switch (ewd._cmd)
{
case FCCommand.CMD.ATTACK_HIT_TARGET:
{
if (_attackInfo._hitType == AttackHitType.BlackHole)
{
_targetList.Add((ewd._param1 as ActionController));
}
else if (_attackInfo._hitType == AttackHitType.Lock)
{
_targetList.Add((ewd._param1 as ActionController));
}
ActionController target = ewd._param1 as ActionController;
IsHitSomeone(_owner, this, _damageType, target);
break;
}
}
return(true);
}
public override bool HandleCommand(ref FCCommand ewd)
{
switch (ewd._cmd)
{
case FCCommand.CMD.ATTACK_HIT_WALL:
if (!_deadByLifeOver)
{
_curBombPosition = BOMB_POSITION.AT_HIT_WALL;
Dead();
}
break;
case FCCommand.CMD.ATTACK_HIT_GROUND:
if (_shakePos == SHAKE_POS.AT_HIT_GROUND)
{
CameraController.Instance.StartCameraEffect(EnumCameraEffect.none, _shakeLevel, false);
}
if (_moveAgent != null)
{
_moveAgent.IsOnGround = true;
}
if (!_deadByLifeOver && _moveAgent.IsOnGround)
{
_curBombPosition = BOMB_POSITION.AT_HIT_GROUND;
Dead();
}
break;
case FCCommand.CMD.ATTACK_HIT_TARGET:
{
ActionController target = ewd._param1 as ActionController;
IsHitSomeone(_owner, this, _damageType, target);
}
break;
}
return(true);
}
public void ReadCommandFromCache(int objID, out FCCommand ewc, out FC_COMMAND_NETSTREAM ecns)
{
if (_commandCmdStreamCache.ContainsKey(objID))
{
List <FC_COMMAND_NETSTREAM> list = _commandCmdStreamCache[objID];
if (list.Count > 0)
{
ecns = list[0];
_commandCmdStreamCache[objID].RemoveAt(0);
}
else
{
ecns = null;
}
}
else
{
ecns = null;
}
if (_commandRpcCache.ContainsKey(objID))
{
List <FCCommand> list = _commandRpcCache[objID];
if (list.Count > 0)
{
ewc = _commandRpcCache[objID][0];
_commandRpcCache[objID].RemoveAt(0);
}
else
{
ewc = null;
}
}
else
{
ewc = null;
}
}
void ReceiveCommand2q(int cmd, Quaternion qParam1, Quaternion qParam2, int networkID, int commandIndex, Vector3 commandPos, PhotonMessageInfo msgInfo)
{
//put the command into input command list
OBJECT_ID object_ID = ObjectManager.Instance.GetObjectByNetworkID(networkID);
if (object_ID == null)
{
Debug.Log("command target object is not exist: " + networkID);
}
else
{
FCCommand ewd = new FCCommand();
ewd.Set((FCCommand.CMD)cmd,
object_ID,
qParam1, FC_PARAM_TYPE.QUATERNION,
qParam2, FC_PARAM_TYPE.QUATERNION,
null, FC_PARAM_TYPE.NONE,
FCCommand.STATE.RIGHTNOW,
false);
WriteCommandToCache(object_ID.NetworkId, commandPos, false, commandIndex, ewd);
}
}
public override bool HandleCommand(ref FCCommand ewd)
{
base.HandleCommand(ref ewd);
switch (ewd._cmd)
{
case FCCommand.CMD.ATTACK_HIT_TARGET:
if (!_deadByLifeOver)
{
if (_currentPerHitCount > 0)
{
_currentPerHitCount--;
if (_currentPerHitCount <= 0 && !_hitInfo[_step]._canPenetrate)
{
_inState = false;
_moveAgent.Stop();
}
}
}
break;
}
return(true);
}
public override bool HandleCommand(ref FCCommand ewd)
{
switch (ewd._cmd)
{
case FCCommand.CMD.ATTACK_HIT_TARGET:
{
ActionController ac = ewd._param1 as ActionController;
Assertion.Check(ac != null);
AddNewEnemy(ac);
}
break;
case FCCommand.CMD.ATTACK_OUT_OF_RANGE:
{
ActionController ac = ewd._param1 as ActionController;
Assertion.Check(ac != null);
// remove from waiting list.
_savedTarget.Remove(ac);
// remove from lightning chain.
foreach (BulletLightningBallChain blbc in _lightningChains)
{
if (blbc._target == ac)
{
blbc.End();
// seek new target.
AssignChainToNewTarget(blbc);
break;
}
}
}
break;
default:
break;
}
return(true);
}
//send msg to all clients except me
public void SendCommandToOthers(FCCommand.CMD cmd,
OBJECT_ID objID,
Vector3 commandPosition,
object param1,
FC_PARAM_TYPE p1Type,
object param2,
FC_PARAM_TYPE p2Type,
object param3,
FC_PARAM_TYPE p3Type
)
{
//single player will not send comment to others
if (PhotonNetwork.room == null)
{
return;
}
Debug.Log("[send] command:" + cmd + " , obj_network_id:" + objID.NetworkId);
//build command instance and add into output list
FCCommand ewd = new FCCommand(GetNextCommandStreamID(objID.NetworkId));
ewd.Set((FCCommand.CMD)cmd, objID, param1, p1Type, param2, p2Type, param3, p3Type,
FCCommand.STATE.RIGHTNOW, false);
ewd._commandPosition = commandPosition;
if (CheatManager.netDelay > 0)
{
StartCoroutine(AddCommand(ewd));
}
else
{
_outputCommandList.Add(ewd);
}
//
//_outputCommandList.Add(ewd);
}
void Awake()
{
_instance = this;
_fastCommand = new FCCommand();
_syncTypeFlag = new int[(int)FC_AI_TYPE.MAX];
for (int i = 0; i < _syncTypeFlag.Length; i++)
{
_syncTypeFlag[i] = 0;
Utils.SetFlag((int)FC_NET_SYNC_TYPE.HIT_PONIT, ref _syncTypeFlag[i]);
}
foreach (CommandFilters cfs in _cmdFiltersList)
{
foreach (FC_NET_SYNC_TYPE nst in cfs._typeList)
{
Utils.SetFlag((int)nst, ref _syncTypeFlag[(int)cfs._aiType]);
}
}
_commandStreamIdDic.Clear();
if (_useSyncMode && (_syncCommandScript == null))
{
if ((_syncCommandObjectPrefeb != null) && (PhotonNetwork.room != null))
{
//network instantiate sync obj
GameObject syncCommandObject = PhotonNetwork.Instantiate(_syncCommandObjectPrefeb.name,
transform.position, transform.rotation, 0) as GameObject;
_syncCommandScript = syncCommandObject.GetComponent <SyncCommand>();
if (_syncCommandScript == null)
{
Debug.LogError("error, sync command object do not have a sync script");
}
}
}
}
public void WriteCommandToCache(int netIndex, Vector3 commandPos, bool streamCommand, params object[] args)
{
OBJECT_ID objectID = ObjectManager.Instance.GetObjectByNetworkID(netIndex);
if (objectID == null)
{
Debug.LogError(string.Format("Object ID is not exist ! netIndex = {0} , isStreamCommand = {1} ", netIndex, streamCommand));
return;
}
int objID = (int)objectID;
ActionController ac = ObjectManager.Instance.GetObjectByNetworkID(netIndex).fcObj as ActionController;
//Debug.Log("ac object id = " + ac.ObjectID + ", object ID = " + objID);
//if(ac != null && ac.IsPlayer && GameManager.Instance.IsPVPMode)
if (GameManager.Instance.IsPVPMode)
{
int cidx = (int)args[0]; //command stream idx
if (streamCommand)
{
if (ac.AIUse.AIStateAgent.CurrentStateID == AIAgent.STATE.DEAD || ac.AIUse.AIStateAgent.CurrentStateID == AIAgent.STATE.REVIVE)
{
return;
}
if (!_commandCmdStreamCache.ContainsKey(objID))
{
_commandCmdStreamCache[objID] = new List <FC_COMMAND_NETSTREAM>();
}
List <FC_COMMAND_NETSTREAM> cpc = _commandCmdStreamCache[objID];
if ((cpc.Count > 0 && cpc[cpc.Count - 1]._commandIndex < cidx) ||
cpc.Count == 0)
{
FC_COMMAND_NETSTREAM ecns = new FC_COMMAND_NETSTREAM((FC_COMMAND_NETSTREAM)args[1]);
ecns._commandIndex = cidx;
if (ecns._state == AIAgent.STATE.HURT)
{
ac.AIUse.UpdateNetCommand(AIAgent.COMMAND_DONE_FLAG.IN_HURT_STATE);
}
//Debug.Log(string.Format("[stream command] _commandIndex:{0} , _currentPosition:{1} , _currentRotation{2} , _state{3}" ,
// ecns._commandIndex , ecns._currentPosition , ecns._currentRotation ,ecns._state));
cpc.Add(ecns);
//Debug.Log("add stream cmd to list : _myRotation = " + ecns._currentRotation + ", cmd idx = " + ecns._commandIndex);
}
}
else
{
if (!_commandRpcCache.ContainsKey(objID))
{
_commandRpcCache[objID] = new List <FCCommand>();
}
FCCommand ewc = new FCCommand((FCCommand)args[1]);
ewc._cmdIndex = cidx;
ewc._commandPosition = commandPos;
ewc._isRun = false;
ewc._needRunPerFrame = false;
ewc._canDrop = false;
//Debug.Log(string.Format("[rpc command] _commandIndex:{0} , _currentPosition:{1} , CMD = {2}" ,
// ewc._cmdIndex , ewc._commandPosition , ewc._cmd ));
_commandRpcCache[objID].Add(ewc);
if (ewc._cmd == FCCommand.CMD.CLIENT_HURT ||
ewc._cmd == FCCommand.CMD.ACTION_EOT ||
ewc._cmd == FCCommand.CMD.ATTACK_WITH_SPEC_CONTS)
{
//Debug.Log(Time.realtimeSinceStartup);
ac.AIUse.UpdateNetCommand();
}
//if find rpc command idx < player next command index or current
//replace command
//pre command may should return to array
// all rpc command should have position param
}
}
else
{
if (!streamCommand)
{
FCCommand ewc = (FCCommand)args[1];
ewc._cmdIndex = 0;
_inputCommandList.Add(ewc);
}
}
}
//update and distribute output command list
private void UpdateOutputCommanList()
{
//check output command list and distribute
int outputCommandListCount = _outputCommandList.Count;
if (outputCommandListCount > 0)
{
for (int i = 0; i < outputCommandListCount; i++)
{
//handle commands
FCCommand command = _outputCommandList[i];
// 0 param
if (command._param1Type == FC_PARAM_TYPE.NONE)
{
photonView.RPC("ReceiveCommand0",
PhotonTargets.OthersBuffered,
(int)command._cmd,
command._objID.NetworkId,
GetNextCommandStreamID(command._objID.NetworkId),
command._commandPosition);
continue;
}
// 1 param, vector
if ((command._param1Type == FC_PARAM_TYPE.VECTOR3) &&
(command._param2Type == FC_PARAM_TYPE.NONE))
{
photonView.RPC("ReceiveCommand1v",
PhotonTargets.Others,
(int)command._cmd,
(Vector3)command._param1,
command._objID.NetworkId,
GetNextCommandStreamID(command._objID.NetworkId),
command._commandPosition);
continue;
}
// 1 param, float
if ((command._param1Type == FC_PARAM_TYPE.FLOAT) &&
(command._param2Type == FC_PARAM_TYPE.NONE))
{
photonView.RPC("ReceiveCommand1f",
PhotonTargets.Others,
(int)command._cmd,
(float)command._param1,
command._objID.NetworkId,
GetNextCommandStreamID(command._objID.NetworkId),
command._commandPosition);
continue;
}
// 1 param, int
if ((command._param1Type == FC_PARAM_TYPE.INT) &&
(command._param2Type == FC_PARAM_TYPE.NONE))
{
photonView.RPC("ReceiveCommand1i",
PhotonTargets.Others,
(int)command._cmd,
(int)command._param1,
command._objID.NetworkId,
GetNextCommandStreamID(command._objID.NetworkId),
command._commandPosition);
continue;
}
// 2 param, int, int
if ((command._param1Type == FC_PARAM_TYPE.INT) &&
(command._param2Type == FC_PARAM_TYPE.INT) &&
(command._param3Type == FC_PARAM_TYPE.NONE))
{
photonView.RPC("ReceiveCommand1i2i",
PhotonTargets.Others,
(int)command._cmd,
(int)command._param1,
(int)command._param2,
command._objID.NetworkId,
GetNextCommandStreamID(command._objID.NetworkId),
command._commandPosition);
continue;
}
// 3 param, int, int, int
if ((command._param1Type == FC_PARAM_TYPE.INT) &&
(command._param2Type == FC_PARAM_TYPE.INT) &&
(command._param3Type == FC_PARAM_TYPE.INT))
{
photonView.RPC("ReceiveCommand1i2i3i",
PhotonTargets.Others,
(int)command._cmd,
(int)command._param1,
(int)command._param2,
(int)command._param3,
command._objID.NetworkId,
GetNextCommandStreamID(command._objID.NetworkId),
command._commandPosition);
continue;
}
// 3 param, int, int, float
if ((command._param1Type == FC_PARAM_TYPE.INT) &&
(command._param2Type == FC_PARAM_TYPE.INT) &&
(command._param3Type == FC_PARAM_TYPE.FLOAT))
{
photonView.RPC("ReceiveCommand1i2i3f",
PhotonTargets.Others,
(int)command._cmd,
(int)command._param1,
(int)command._param2,
(float)command._param3,
command._objID.NetworkId,
GetNextCommandStreamID(command._objID.NetworkId),
command._commandPosition);
continue;
}
// 2 param, float, float
if ((command._param1Type == FC_PARAM_TYPE.FLOAT) &&
(command._param2Type == FC_PARAM_TYPE.FLOAT))
{
photonView.RPC("ReceiveCommand1f2f",
PhotonTargets.Others,
(int)command._cmd,
(float)command._param1,
(float)command._param2,
command._objID.NetworkId,
GetNextCommandStreamID(command._objID.NetworkId),
command._commandPosition);
continue;
}
// 2 param, vector3 , vector3
if ((command._param1Type == FC_PARAM_TYPE.VECTOR3) &&
(command._param2Type == FC_PARAM_TYPE.VECTOR3))
{
photonView.RPC("ReceiveCommand2v",
PhotonTargets.Others,
(int)command._cmd,
(Vector3)command._param1,
(Vector3)command._param2,
command._objID.NetworkId,
GetNextCommandStreamID(command._objID.NetworkId),
command._commandPosition);
continue;
}
// 2 param, Quaternion , vector3
if ((command._param1Type == FC_PARAM_TYPE.QUATERNION) &&
(command._param2Type == FC_PARAM_TYPE.QUATERNION))
{
photonView.RPC("ReceiveCommand2q",
PhotonTargets.Others,
(int)command._cmd,
(Quaternion)command._param1,
(Quaternion)command._param2,
command._objID.NetworkId,
GetNextCommandStreamID(command._objID.NetworkId),
command._commandPosition);
continue;
}
}
//clear output command list
_outputCommandList.Clear();
}
}
private IEnumerator AddCommand(FCCommand ewd)
{
yield return(new WaitForSeconds(CheatManager.netDelay));
_outputCommandList.Add(ewd);
}
public virtual bool HandleCommand(ref FCCommand ewd)
{
return(true);
}
public bool SendFastToSelf(ref FCCommand ewd)
{
return(ewd._objID.HandleCommand(ref ewd));
}
