public void OnStateQuit(AIAgent.STATE ass)
{
//if(_mmEffectMap != null)
//{
// _mmEffectMap.StopEffect();
//}
}
public FC_COMMAND_NETSTREAM(FC_COMMAND_NETSTREAM src)
{
_state = src._state;
_currentPosition = src._currentPosition;
_currentRotation = src._currentRotation;
_commandIndex = src._commandIndex;
timeStamp = src.timeStamp;
}
public bool GetStateToGo(int stateCount, ref AIAgent.STATE ret, ref float timeIdle, ref float timeWander)
{
ret = AIAgent.STATE.NONE;
if (_countsForJump == 0 || (_countsForJump > 0 && stateCount % _countsForJump == 0))
{
int c1 = 0;
int c2 = 0;
if (_chanceToIdle > 0)
{
ret = AIAgent.STATE.IDLE;
c1 = Random.Range(0, _chanceToIdle);
}
if (_chanceToWander > 0)
{
if (ret != AIAgent.STATE.NONE)
{
c2 = Random.Range(0, _chanceToWander);
if (c2 > c1)
{
ret = AIAgent.STATE.HESITATE;
c1 = c2;
}
}
else
{
ret = AIAgent.STATE.HESITATE;
}
}
if (_chanceToAttack > 0)
{
if (ret != AIAgent.STATE.NONE)
{
c2 = Random.Range(0, _chanceToAttack);
if (c2 > c1)
{
ret = AIAgent.STATE.ATTACK;
}
}
else
{
ret = AIAgent.STATE.ATTACK;
}
}
}
if (ret == AIAgent.STATE.IDLE)
{
timeIdle = _idleTime;
return(true);
}
else if (ret == AIAgent.STATE.HESITATE)
{
timeWander = _wanderTime;
return(true);
}
return(false);
}
public bool IsHit(ActionController target)
{
bool ret = false;
AIAgent.STATE ass = _owner.ACOwner.AIUse.AIStateAgent.CurrentStateID;
if (_owner.beActive && _coolDownTimeCount <= 0)
{
ret = true;
foreach (AIAgent.STATE state in _statesCantAutoIce)
{
if (state == ass)
{
ret = false;
break;
}
}
if (_owner.ACOwner.AIUse.CurrentSkill != null)
{
string sn = _owner.ACOwner.AIUse.CurrentSkill._skillName;
foreach (string skill in _skillCantAutoIce)
{
if (skill == sn)
{
ret = false;
break;
}
}
}
if (ret && Random.Range(0, 1f) <= _chanceToFireIce)
{
_coolDownTimeCount = _coolDownTime;
ret = true;
Vector3 dir = target.ThisTransform.localPosition - _owner.ACOwner.ThisTransform.localPosition;
dir.y = 0;
dir.Normalize();
if (dir != Vector3.zero)
{
_owner.ACOwner.ACRotateTo(dir, -1, true, true);
}
_owner.ACOwner.AIUse.GoToAttackForce(_iceSkillName, 0);
}
else
{
ret = false;
}
}
return(ret);
//if()
}
public bool IsHit(ActionController target)
{
bool ret = false;
if (_owner.beActive && _coolDownTimeCount <= 0)
{
ret = true;
AIAgent.STATE ass = _owner.ACOwner.AIUse.AIStateAgent.PreStateID;
AIAgent.STATE assc = _owner.ACOwner.AIUse.AIStateAgent.CurrentStateID;
foreach (AIAgent.STATE state in _statesCantAutoDefense)
{
if (state == ass && ass == assc)
{
ret = false;
break;
}
}
if (ret)
{
if (_owner.ACOwner.AIUse.CurrentSkill != null)
{
string sn = _owner.ACOwner.AIUse.CurrentSkill._skillName;
foreach (string skill in _skillCantAutoDefense)
{
if (skill == sn)
{
ret = false;
break;
}
}
}
}
if (ret)
{
ret = (Random.Range(0, 1f) <= _chanceToBlock);
}
if (ret)
{
_owner.ACOwner.AIUse.GoToAttackForce(_parrySkill, _parrySkillCombo);
_owner.ACOwner.AIUse.ParryTarget = target;
_coolDownTimeCount = _coolDownTime;
_owner.ACOwner.AIUse.SetActionSwitchFlag(FC_ACTION_SWITCH_FLAG.IN_GOD);
}
}
return(ret);
//if()
}
void UpdateSyncCommandForPVP()
{
if (!GameManager.Instance.IsPVPMode)
{
return;
}
_lastPos = _owner.ThisTransform.localPosition;
//set my pos
CommandManager.Instance._syncCommandScript._myPosition
= _lastPos;
_lastRot = _owner.ThisTransform.eulerAngles;
//set my rotation
CommandManager.Instance._syncCommandScript._myRotation
= _lastRot;
_lastAIState = _owner.AIUse.AIStateAgent.CurrentStateID;
//set my AI state
CommandManager.Instance._syncCommandScript._myAIState = _lastAIState;
}
public override AIAgent.STATE GetNextStateByRun(bool findedTarget, bool inFinding)
{
AIAgent.STATE state = AIAgent.STATE.MAX;
if (_owner.ACOwner.IsAlived)
{
if (findedTarget && _owner.TargetAC != null && _owner.TargetAC.IsAlived)
{
state = AIAgent.STATE.ATTACK;
}
else if (!inFinding)
{
state = AIAgent.STATE.IDLE;
}
else if (inFinding)
{
if (_owner.CanSeekTarget())
{
_owner.HandleInnerCmd(FCCommand.CMD.MOVE_TO_POINT, null, _owner.TargetAC.ThisTransform.localPosition, null, null);
}
else
{
_owner.HandleInnerCmd(FCCommand.CMD.STOP_IS_ARRIVE_POINT, null);
state = AIAgent.STATE.IDLE;
}
}
else
{
state = AIAgent.STATE.IDLE;
}
}
else
{
state = AIAgent.STATE.DEAD;
}
return(state);
}
public int CountHurtResult()
{
_currentStep = 0;
_frameCount = 0;
_stateWantToGo = AIAgent.STATE.NONE;
float speedScale = ((float)_hitStrength) / 100;
#if PVP_ENABLED
if (GameManager.Instance.IsPVPMode && _owner.ACOwner.IsClientPlayer)
{
//speedScale = 0.0f;
}
#endif
if (_owner.ACOwner.IsPlayerSelf && GameManager.Instance.IsPVPMode)
{
_hurtInfoForClient2.x = _hitDirection.x;
_hurtInfoForClient2.y = _hitDirection.z;
_hurtInfoForClient2.z = _effectTime;
CommandManager.Instance.SendCommandToOthers(FCCommand.CMD.CLIENT_HURT,
_owner.ACOwner.ObjectID, _owner.ACOwner.ThisTransform.localPosition,
_hurtInfoForClient, FC_PARAM_TYPE.QUATERNION,
_hurtInfoForClient2, FC_PARAM_TYPE.QUATERNION,
null, FC_PARAM_TYPE.NONE);
}
if (!_owner.ACOwner.SelfMoveAgent.IsOnGround)
{
speedScale += 0.2f;
}
if (_currentHitType == AttackHitType.KnockDown)
{
_inSky = true;
_owner.MoveByDirection(_hitDirection, _hitBackSpeed * speedScale, 99f, _hitBackDrag);
if (_canBeHitDown)
{
_stateWantToGo = AIAgent.STATE.STAND;
}
}
else if (_currentHitType == AttackHitType.KnockBack)
{
_owner.MoveByDirection(_hitDirection, _hitBackSpeed * speedScale, 99f, _hitBackDrag);
if (_canBeHitFly)
{
_stateWantToGo = AIAgent.STATE.IDLE;
}
}
else if (_currentHitType == AttackHitType.HitFly)
{
_inSky = true;
_isInFall = false;
if (_canBeHitUp)
{
//Debug.LogError("FC_HIT_TYPE.UP" + Time.realtimeSinceStartup);
//_owner.MoveByDirection(_hitDirection, _hitBackSpeed * speedScale, 1.2f, 0);
//_owner.MoveByDirection(_hitDirection, 0.1f, 0.1f, 0);
_owner.MoveByDirection(_hitDirection, _hitBackSpeed * speedScale, 99f, _hitBackDrag);
_stateWantToGo = AIAgent.STATE.STAND;
_owner.ACOwner.ACEffectByGravity(_hitUpSpeed, null, Vector3.up, 999, false, true);
}
else
{
_owner.MoveByDirection(_hitDirection, _hitBackSpeed * speedScale, 99f, _hitBackDrag);
}
}
else if (_currentHitType == AttackHitType.HurtFlash)
{
_owner.MoveByDirection(_hitDirection, _flashHurtSpeed * speedScale, 1f, _hurtSpeedDrag);
}
else if (_currentHitType == AttackHitType.HurtNormal)
{
//Debug.Log("FC_HIT_TYPE.HURT_NORMAL _hitDirection = " + _hitDirection + ", _normalHurtSpeed :" +_normalHurtSpeed + ",speedScale : " + speedScale + " , _hurtSpeedDrag =" +_hurtSpeedDrag );
_owner.MoveByDirection(_hitDirection, _normalHurtSpeed * speedScale, 1f, _hurtSpeedDrag);
}
else if (_currentHitType == AttackHitType.ParrySuccess)
{
_owner.MoveByDirection(_hitDirection, _parryBackSpeed * speedScale, 1f, _hurtSpeedDrag);
}
else if (_currentHitType == AttackHitType.ParryFail)
{
if (_sfxParryBreak != "")
{
SoundManager.Instance.PlaySoundEffect(_sfxParryBreak);
}
_owner.MoveByDirection(_hitDirection, _parryFailSpeed * speedScale, 0.3f, 6f);
}
else if (_currentHitType == AttackHitType.Dizzy)
{
_owner.StopMove();
}
else if (_currentHitType == AttackHitType.ForceBack)
{
// if(_owner.ACOwner.IsClientPlayer)
// {
// _owner.MoveByDirection(_hitDirection,_normalHurtSpeed*speedScale,0.2f,_hurtSpeedDrag);
// }
// else
// {
_owner.StopMove();
// }
}
else if (_currentHitType == AttackHitType.BlackHole)
{
_owner.StopMove();
}
#if xingtianbo
//else if(_currentHitType == AttackHitType.KnockDown)
//{
// _owner.StopMove();
// _stateWantToGo = AIAgent.STATE.STAND;
//}
#endif
else
{
_owner.StopMove();
}
_currentStep = 1;
_owner.IncreaseRage(RageAgent.RageEvent.HURT, _attackerType);
return((int)_currentHitType);
}
public override void IdleTaskChange(FCCommand.CMD cmd)
{
if (cmd == FCCommand.CMD.STATE_QUIT)
{
_owner.ACSetMoveMode(MoveAgent.MOVE_MODE.BY_ANIMATION);
}
else if (cmd == FCCommand.CMD.STATE_ENTER)
{
if (!_isFight)
{
_wanderTimeThisTime = -1;
_timeForIdleThisTime = Random.Range(_timeForIdleMin, _timeForIdleMax);
//_owner.ACSetMoveMode(MoveAgent.MOVE_MODE.BY_MOVE_MANUAL);
_haverWanderActionThisTime = _haveWanderAction;
AIAgent.STATE aas = AIAgent.STATE.IDLE;
if (_state._preState != null)
{
aas = _state._preState.CurrentStateID;
}
AIAgent.STATE ret = AIAgent.STATE.NONE;
if (_state._preState.CurrentStateID == AIAgent.STATE.BORN)
{
ret = AIAgent.STATE.ATTACK;
}
else if (_skillCount > 0 && aas == AIAgent.STATE.ATTACK && _afterSkill != null && _afterSkill.Count > 0)
{
foreach (StateToGoCondition stgc in _afterSkill)
{
if (stgc.GetStateToGo(_skillCount, ref ret, ref _timeForIdleThisTime, ref _wanderTimeThisTime))
{
break;
}
}
}
if (ret == AIAgent.STATE.ATTACK)
{
GoToAttack();
}
else if (ret == AIAgent.STATE.IDLE)
{
_haverWanderActionThisTime = false;
}
}
_owner.ACSetMoveMode(MoveAgent.MOVE_MODE.BY_ANIMATION);
HandleInnerCmd(FCCommand.CMD.DIRECTION_FOLLOW_FORWARD, null);
if (!_owner.IsPlayer)
{
_owner.ACStop();
}
}
else if (cmd == FCCommand.CMD.STATE_FINISH)
{
}
else if (cmd == FCCommand.CMD.STATE_DONE)
{
if (_isFight)
{
if (_haverWanderActionThisTime)
{
SetNextState(AIAgent.STATE.HESITATE);
}
else
{
GoToAttack();
}
}
else
{
SetNextState(AIAgent.STATE.IDLE);
}
}
}
public override bool HandleInnerCmd(FCCommand.CMD cmd, object param0, object param1, object param2, object param3)
{
bool ret = false;
if (_sAHandleCmd != null)
{
ret = _sAHandleCmd(cmd, param0, param1, param2, param3);
}
if (!ret)
{
switch (cmd)
{
//state
case FCCommand.CMD.STATE_GOTO:
{
AIAgent.STATE ast = (AIAgent.STATE)param0;
ret = SetNextState(ast);
break;
}
case FCCommand.CMD.STATE_ENTER:
switch (_state.CurrentStateID)
{
case STATE.RUN:
{
GotoNextPathPoint();
ret = true;
break;
}
case STATE.IDLE:
{
if (_faceTarget == null)
{
_owner.ACRotateTo(_targetDirection, -1, true, true);
}
break;
}
}
break;
case FCCommand.CMD.STATE_DONE:
{
switch (_state.CurrentStateID)
{
case STATE.BORN:
{
_owner.SetShipForSpeedAndForward(MoveAgent.ROTATE_FLAG.FOLLOW_SPEED);
_owner.ACSetMoveMode(MoveAgent.MOVE_MODE.BY_MOVE_MANUAL);
if (HasPathWay && !_controlByPlayer)
{
if (_pathway.HasPath)
{
_runOnPath = true;
SetNextState(AIAgent.STATE.RUN);
}
else
{
_runOnPath = false;
SetNextState(AIAgent.STATE.IDLE);
}
}
else
{
_runOnPath = false;
HandleInnerCmd(FCCommand.CMD.DIRECTION_FOLLOW_FORWARD, null);
SetNextState(AIAgent.STATE.IDLE);
}
ret = true;
break;
}
case STATE.RUN:
{
ret = SetNextState(AIAgent.STATE.IDLE);
break;
}
case STATE.IDLE:
{
ret = SetNextState(AIAgent.STATE.RUN);
break;
}
}
break;
}
case FCCommand.CMD.MOVE_TO_POINT:
{
Vector3 p = (Vector3)param1;
_owner.ACMove(ref p);
ret = true;
break;
}
//stop
case FCCommand.CMD.STOP:
_owner.ACStop();
ret = true;
break;
case FCCommand.CMD.STOP_IS_ARRIVE_POINT:
{
_targetDirection = _owner.ThisTransform.forward;
SetNextState(AIAgent.STATE.IDLE);
break;
}
//Set
case FCCommand.CMD.SET_TO_DEFAULT_SPEED:
{
ACOwner.CurrentSpeed = _owner.Data.TotalMoveSpeed;
ret = true;
break;
}
//direction
case FCCommand.CMD.DIRECTION_FOLLOW_FORWARD:
{
_owner.SetShipForSpeedAndForward(MoveAgent.ROTATE_FLAG.FOLLOW_SPEED);
ret = true;
break;
}
case FCCommand.CMD.DIRECTION_UNLOCK:
{
_owner.SetShipForSpeedAndForward(MoveAgent.ROTATE_FLAG.UNLOCK);
ret = true;
break;
}
//action
case FCCommand.CMD.ACTION_IS_AWAY_NPC:
{
Transform tf = (Transform)param1;
if (tf == _faceTarget)
{
_faceTarget = null;
}
ret = true;
break;
}
case FCCommand.CMD.ACTION_IS_NEAR_NPC:
{
Transform tf = (Transform)param1;
_faceTarget = tf;
ret = true;
break;
}
}
}
return(ret);
}
public override AIAgent.STATE GetNextStateByBorn()
{
AIAgent.STATE state = AIAgent.STATE.MAX;
state = AIAgent.STATE.IDLE;
return(state);
}
void OnPhotonSerializeView(PhotonStream stream, PhotonMessageInfo info)
{
if (!ObjectManager.Instance || ObjectManager.Instance.ObjectCount == 0)
{
return;
}
short myIndex = 0; //player index, 0~3 + NETWORK_ID_HERO_START
Vector3 pos = Vector3.zero; //player position
Vector3 rot = Vector3.zero; //player rotation , eularAngles
int cmdIdx = 0;
short ai_state = -1; //player AI state
if (stream.isWriting)
{
if (!IsWriteEnabled)
{
return;
}
if (_myAIState == AIAgent.STATE.MAX)
{
return;
}
ActionController ac = ObjectManager.Instance.GetObjectByNetworkID(_myIndex).fcObj as ActionController;
//output
myIndex = (short)_myIndex;
stream.Serialize(ref myIndex);
pos = ac.ThisTransform.localPosition;
_myRotation = ac.ThisTransform.eulerAngles;
_myAIState = ac.AIUse.AIStateAgent.CurrentStateID;
stream.Serialize(ref pos);
if (GameManager.Instance.IsPVPMode)
{
rot = _myRotation;
stream.Serialize(ref rot);
_myCmdIdx = CommandManager.Instance.GetNextCommandStreamID(_myIndex);
cmdIdx = _myCmdIdx;
stream.Serialize(ref cmdIdx);
ai_state = (short)_myAIState;
stream.Serialize(ref ai_state);
}
}
else
{
if (!IsReadEnabled)
{
return;
}
//read
stream.Serialize(ref myIndex);
_myIndex = myIndex;
stream.Serialize(ref pos);
_myPosition = pos;
if (GameManager.Instance.IsPVPMode)
{
stream.Serialize(ref rot);
_myRotation = rot;
//sync command stream index
stream.Serialize(ref cmdIdx);
_myCmdIdx = cmdIdx;
//ai state
stream.Serialize(ref ai_state);
_myAIState = (AIAgent.STATE)ai_state;
ecns._commandIndex = _myCmdIdx;
ecns._currentPosition = _myPosition;
ecns._currentRotation = _myRotation;
ecns._state = _myAIState;
ecns.timeStamp = info.timestamp;
CommandManager.Instance.WriteCommandToCache(_myIndex, _myPosition, true, _myCmdIdx, ecns);
}
}
}
/*void LateUpdate()
* {
* if(PhotonNetwork.room == null) return;
*
* if(!_isLerpEnabled || !_owner.IsClientPlayer) return;
*
* _owner.ThisTransform.localPosition = Vector3.Lerp( _owner._currPosition , _lerpToPos , SMOOTH * Time.deltaTime);
* if( Vector3.Distance(_owner.ThisTransform.localPosition , _lerpToPos) < 0.1f ){
* _isLerpEnabled = false;
* }
* }*/
public virtual bool HandleCommand(ref FCCommand ewd)
{
if (PhotonNetwork.room == null)
{
return(false);
}
switch (ewd._cmd)
{
case FCCommand.CMD.CLIENT_MOVE_TO_POINT:
{
if (ewd._param1Type != FC_PARAM_TYPE.VECTOR3)
{
Debug.LogError("get a CLIENT_MOVE_TO_POINT but param1 is not a vector3");
}
else
{
_owner._dataSync._position = (Vector3)ewd._param1;
return(true);
}
}
break;
case FCCommand.CMD.CLIENT_HURT:
{
if (ewd._param1Type != FC_PARAM_TYPE.VECTOR3 || ewd._param2Type != FC_PARAM_TYPE.VECTOR3)
{
Debug.LogError("get a CLIENT_HURT but param1 , 2 is not a vector3");
}
else
{
// Vector3 param1 = (Vector3)ewd._param1;
// FC_HIT_TYPE eht = (FC_HIT_TYPE)param1.x;
// bool isCritical = (param1.y == 0.0 ? false : true);
//int realDamage = (int)param1.z;
// Vector3 hitDirection = (Vector3)ewd._param2;
_owner.SelfMoveAgent.SetPosition(ewd._commandPosition);
//_owner.ACHandleHurt(eht , isCritical ,realDamage , hitDirection , true , true , false );
//Debug.Log("Get FCCommand.CMD.CLIENT_HURT !!!!!!!!!!!!! hitDir = " + hitDirection);
//CommandManager.Instance.SendFastToSelf(ref ewd);
return(true);
}
}
break;
case FCCommand.CMD.CLIENT_HURT_HP:
{
if (ewd._param1Type != FC_PARAM_TYPE.INT || ewd._param2Type != FC_PARAM_TYPE.INT)
{
Debug.LogError("get a CLIENT_HURT_HP but param1 is not a int");
}
else
{
_owner.ACReduceHP((int)ewd._param1, (int)ewd._param2, false, false, false, false);
// _owner._dataSync._hitPoint = (int)ewd._param1;
return(true);
}
}
break;
case FCCommand.CMD.CLIENT_THREAT:
{
if ((ewd._param1Type != FC_PARAM_TYPE.INT) || (ewd._param2Type != FC_PARAM_TYPE.INT))
{
Debug.LogError("get a CLIENT_THREAT but param is not a int");
}
else
{
//get player objid
OBJECT_ID player_ID = ObjectManager.Instance.GetObjectByNetworkID((int)ewd._param2);
if (player_ID == null)
{
Debug.LogError("receive increase threat but bad player");
}
//get player AC
ActionController target = player_ID.fcObj as ActionController;
//increase threat
_owner.ACIncreaseThreat((int)ewd._param1, false, target);
return(true);
}
}
break;
case FCCommand.CMD.CLIENT_LEVELUP:
{
if (ewd._param1Type != FC_PARAM_TYPE.INT)
{
Debug.LogError("get a CLIENT_LEVELUP but param is not a int");
}
else
{
//level up
_owner.OnLevelUp_FromNet((int)ewd._param1);
return(true);
}
}
break;
case FCCommand.CMD.CLIENT_CURRSTATE:
{
if (ewd._param1Type != FC_PARAM_TYPE.INT)
{
Debug.LogError("get a CLIENT_CURRSTATE_ID but param is not a int");
//}else if (ewd._param2Type != FC_PARAM_TYPE.FLOAT){
// Debug.LogError("get a CLIENT_CURRSTATE_ID but param2 is not float type");
}
else
{
_clientAICurrStateID = (AIAgent.STATE)ewd._param1;
//float y = (float)ewd._param2;
//Quaternion rotation = Quaternion.Euler(new Vector3(0, y, 0));
//Vector3 v3 = rotation * Vector3.forward;
//_owner.ACRotateTo(v3,-1,true,true);
return(true);
}
}
break;
case FCCommand.CMD.CLIENT_POTION_HP:
{
if (ewd._param1Type != FC_PARAM_TYPE.FLOAT || ewd._param2Type != FC_PARAM_TYPE.FLOAT)
{
Debug.LogError("get a CLIENT_POTION_HP but param is not a float");
}
else
{
//increase HP
_owner.ACEatPotion((float)ewd._param1, (float)ewd._param2, FCConst.POTION_TIME, FCPotionType.Health);
return(true);
}
}
break;
case FCCommand.CMD.CLIENT_POTION_ENERGY:
{
if (ewd._param1Type != FC_PARAM_TYPE.FLOAT || ewd._param2Type != FC_PARAM_TYPE.FLOAT)
{
Debug.LogError("get a CLIENT_POTION_ENERGY but param is not a float");
}
else
{
//increase EP
_owner.ACEatPotion((float)ewd._param1, (float)ewd._param2, FCConst.POTION_TIME, FCPotionType.Mana);
return(true);
}
}
break;
case FCCommand.CMD.CLIENT_REVIVE:
{
if (ewd._param1Type != FC_PARAM_TYPE.NONE)
{
Debug.LogError("get a CLIENT_REVIVE but param is not a float");
}
else
{
//revive now
//_owner.GoToRevive();
return(true);
}
}
break;
}
return(false);
}
