public override void enter(StateParam param)
{
// 确认当前道具选择
pushCommand <CommandCharacterSelectItem>(mPlayer);
CommandCharacterAddState cmdState = newCmd(out cmdState, true, true);
cmdState.mState = PLAYER_STATE.PS_SPRINT;
pushDelayCommand(cmdState, mPlayer);
}
// 通知所有玩家比赛开始
public void notifyAllPlayerGame()
{
foreach (var item in mPlayerList)
{
CommandCharacterAddState cmdState = newCmd(out cmdState);
cmdState.mState = PLAYER_STATE.PS_GAMING;
pushCommand(cmdState, item.Value);
}
}
//-----------------------------------------------------------------------------------------------------------------------
protected void onMoveDone(ComponentKeyFrameBase component, object userData, bool breakTremling, bool done)
{
if (breakTremling)
{
return;
}
CommandCharacterAddState cmdCharacterAddState = newCmd(out cmdCharacterAddState);
cmdCharacterAddState.mState = PLAYER_STATE.PS_SELECTED_ROLE;
pushCommand(cmdCharacterAddState, mPlayer);
}
public override void use(CharacterOther player)
{
// 如果已经在瞄准状态中,则不能使用
if (player.hasState(PLAYER_STATE.PS_AIM))
{
return;
}
// 给角色添加瞄准状态
CommandCharacterAddState cmdCharacterAddState = newCmd(out cmdCharacterAddState);
cmdCharacterAddState.mState = PLAYER_STATE.PS_AIM;
pushCommand(cmdCharacterAddState, player);
}
public override void execute()
{
Character character = mReceiver as Character;
Animation animation = character.getAnimation();
animation[GameDefine.ANIM_STARTING].time = 0.0f;
animation[GameDefine.ANIM_STARTING].speed = 1.0f;
animation.CrossFade(GameDefine.ANIM_STARTING);
animation.CrossFadeQueued(GameDefine.ANIM_RIDE);
CommandCharacterAddState cmd = newCmd(out cmd);
cmd.mState = PLAYER_STATE.PS_RIDING;
pushCommand(cmd, character);
}
public override void use(CharacterOther player)
{
// 添加加速状态
BOOL result = new BOOL();
CommandCharacterAddState cmdState = newCmd(out cmdState);
cmdState.mState = PLAYER_STATE.PS_SPRINT;
cmdState.mResult = result;
pushCommand(cmdState, player);
// 添加状态成功后移除背包中的道具
if (result.mValue)
{
CommandCharacterRemoveItem cmdRemove = newCmd(out cmdRemove);
cmdRemove.mItem = this;
pushCommand(cmdRemove, player);
}
}
public override void execute()
{
Character character = mReceiver as Character;
CharacterOther other = character as CharacterOther;
Animation anim = other.getAnimation();
anim.Play(GameDefine.ANIM_PRE_JUMP);
anim.PlayQueued(GameDefine.ANIM_START_JUMP);
float preJumpLength = anim.GetClip(GameDefine.ANIM_PRE_JUMP).length;
float startJumpLength = anim.GetClip(GameDefine.ANIM_START_JUMP).length;
// 动作播放完成后才进入跳跃状态
CommandCharacterAddState cmdAddState = newCmd(out cmdAddState, true, true);
cmdAddState.mState = PLAYER_STATE.PS_JUMP;
cmdAddState.mParam = new JumpParam(mJumpSpeed);
pushDelayCommand(cmdAddState, character, preJumpLength + startJumpLength);
}
public override void execute()
{
Character character = mReceiver as Character;
if (!character.isType(CHARACTER_TYPE.CT_OTHER))
{
return;
}
CharacterOther other = character as CharacterOther;
// 玩家有护盾时,攻击没有任何影响
if (other.hasState(PLAYER_STATE.PS_PROTECTED))
{
return;
}
if (mAttackSource == SCENE_ITEM.SI_LAND_MINE || mAttackSource == SCENE_ITEM.SI_MISSILE)
{
// 进入被攻击状态
CommandCharacterAddState cmdState = newCmd(out cmdState);
cmdState.mState = PLAYER_STATE.PS_ATTACKED;
pushCommand(cmdState, other);
// 设置角色的速度,当角色速度小于3km/h时,则不变,否则速度设置为3km/h
CommandCharacterChangeSpeed cmd = newCmd(out cmd, false);
cmd.mSpeed = Mathf.Min(MathUtility.KMHtoMS(3.0f), other.getCharacterData().mSpeed);
pushCommand(cmd, other);
// 播放摔倒动作
Animation animation = other.getAnimation();
animation.CrossFade(GameDefine.ANIM_FALL_DOWN);
// 当速度为0时,摔到后为站立状态,否则开始骑行
if (other.getCharacterData().mSpeed <= 0.01f)
{
animation.CrossFadeQueued(GameDefine.ANIM_STANDING);
}
else
{
animation.CrossFadeQueued(GameDefine.ANIM_RIDE);
}
// 同时需要降低硬件速度组件中从当前速度加速到目标速度的快慢
CharacterSpeedHardware speedHardware = other.getFirstComponent <CharacterSpeedHardware>();
speedHardware.setAcceleration(0.0f);
}
}
public override void execute()
{
Character character = mReceiver as Character;
Animation animation = character.getAnimation();
if (mVerticalSpeed >= GameDefine.FORCE_LAND_SPEED)
{
animation.Play(GameDefine.ANIM_FORCE_LANDING);
}
else
{
animation.Play(GameDefine.ANIM_LANDING);
}
float curSpeed = character.getCharacterData().mSpeed;
// 起跳时有水平方向的速度
if (curSpeed > 0.0f)
{
// 是否摇车
if (curSpeed >= GameDefine.SHAKE_BIKE_SPEED)
{
animation.CrossFadeQueued(GameDefine.ANIM_SHAKE_BIKE, 0.1f);
}
else
{
animation.CrossFadeQueued(GameDefine.ANIM_RIDE, 0.1f);
}
// 添加骑行状态
CommandCharacterAddState cmdState = newCmd(out cmdState);
cmdState.mState = PLAYER_STATE.PS_RIDING;
pushCommand(cmdState, character);
}
// 静止时原地起跳
else
{
animation.CrossFadeQueued(GameDefine.ANIM_STANDING, 0.1f);
// 添加休闲状态
CommandCharacterAddState cmdState = newCmd(out cmdState);
cmdState.mState = PLAYER_STATE.PS_IDLE;
pushCommand(cmdState, character);
}
}
protected override void onInit(SceneProcedure lastProcedure, string intent)
{
LayoutTools.LOAD_NGUI_SHOW(LAYOUT_TYPE.LT_SETTLEMENT, 10);
// 卸载除了角色展示以外的所有场景
mSceneSystem.unloadOtherScene(GameDefine.ROLE_DISPLAY);
// 激活场景,初始化场景
mSceneSystem.activeScene(GameDefine.ROLE_DISPLAY);
mSceneSystem.initScene(GameDefine.ROLE_DISPLAY);
// 设置摄像机位置
RoleDisplay roleDisplay = mSceneSystem.getScene <RoleDisplay>(GameDefine.ROLE_DISPLAY);
mCameraManager.getMainCamera().copyCamera(roleDisplay.mCameraPositionObject0);
// 给主角添加选中状态
CommandCharacterAddState cmdState = newCmd(out cmdState);
cmdState.mState = PLAYER_STATE.PS_ON_SELECT_ROLE;
pushCommand(cmdState, mCharacterManager.getMyself());
}
public override void execute()
{
Character character = mReceiver as Character;
// 无论是否完成比赛,都需要添加完成比赛的状态
CommandCharacterAddState cmdState = newCmd(out cmdState);
cmdState.mState = PLAYER_STATE.PS_FINISH;
pushCommand(cmdState, character);
// 如果是玩家自己,则显示是否比赛完成
if (character.isType(CHARACTER_TYPE.CT_MYSELF))
{
mScriptCircleTip.notifyFinishRace(mFinish);
}
// 移除瞄准状态
if ((character as CharacterOther).getStateMachine().hasState(PLAYER_STATE.PS_AIM))
{
CommandCharacterRemoveState cmdRemoveState = newCmd(out cmdRemoveState);
cmdRemoveState.mState = PLAYER_STATE.PS_AIM;
pushCommand(cmdRemoveState, character as CharacterOther);
}
}
public override void execute()
{
StartScene gameScene = (mReceiver) as StartScene;
if (gameScene.atProcedure(PROCEDURE_TYPE.PT_START_SELECT_ROLE))
{
CharacterOther curRole = mRoleSystem.getSelectedRole();
// 当前角色有SELECT_ROLE状态组,如果没有,则说明是第一次进入选人流程
if (curRole != null && curRole.hasStateGroup(STATE_GROUP.SG_SELECT))
{
// 当前角色显示完毕时才能切换角色,也不能选择相同的角色
if (!curRole.hasState(PLAYER_STATE.PS_SELECTED_ROLE) || mRoleSystem.getSelectedIndex() == mIndex)
{
return;
}
// 取消当前角色的选中
CommandCharacterAddState cmdUnSelect = newCmd(out cmdUnSelect);
cmdUnSelect.mState = PLAYER_STATE.PS_UN_SELECT_ROLE;
pushCommand(cmdUnSelect, curRole);
}
// 启动选择的角色
mRoleSystem.setSelectedIndex(mIndex);
CharacterOther character = mRoleSystem.getSelectedRole();
if (character != null)
{
CommandCharacterAddState cmdSelect = newCmd(out cmdSelect);
cmdSelect.mState = PLAYER_STATE.PS_ON_SELECT_ROLE;
pushCommand(cmdSelect, character);
// 通知布局
mScriptSelectRole.selectRole(mIndex);
if (mPlayAudio)
{
GameTools.PLAY_AUDIO_UI(mScriptGlobalAudio.getAudioWindow(), SOUND_DEFINE.SD_SELECTION_CHANGE);
}
}
}
}
public override void execute()
{
Character character = mReceiver as Character;
Animation animation = character.getAnimation();
if (mFadeStop)
{
// 倒播起步动作
animation[GameDefine.ANIM_STARTING].time = animation[GameDefine.ANIM_STARTING].clip.length;
animation[GameDefine.ANIM_STARTING].speed = -1.0f;
animation.CrossFade(GameDefine.ANIM_STARTING);
if (mFadeStanding)
{
animation.CrossFadeQueued(GameDefine.ANIM_STANDING);
}
else
{
animation.PlayQueued(GameDefine.ANIM_STANDING);
}
}
else
{
if (mFadeStanding)
{
animation.CrossFade(GameDefine.ANIM_STANDING);
}
else
{
animation.Play(GameDefine.ANIM_STANDING);
}
}
// 添加idle状态
CommandCharacterAddState cmdState = newCmd(out cmdState);
cmdState.mState = PLAYER_STATE.PS_IDLE;
pushCommand(cmdState, character);
}
public override void update(float elapsedTime)
{
if (mData.mSpeed > 0.0f)
{
// 判断当前方向是否合法
bool wrongDirection = directionCheck();
// 圈数检测,更新当前移动距离,反向检测,完成比赛检测
if (!wrongDirection)
{
int curPointIndex = mData.mCurWayPoint;
float runDistance = mWayPointManager.getRunDistance(mCharacter.getPosition(), ref curPointIndex, curPointIndex);
if (!mPassedPointList.Contains(curPointIndex))
{
mPassedPointList.Add(curPointIndex);
}
// 防止在游戏开始后 后退到终点线之前 导致已过路点添加错误 最后圈数检测错误
if (runDistance >= mWayPointManager.getTotalLength() / 2 && mPassedPointList.Count <= mWayPointManager.getPointCount() / 3)
{
mPassedPointList.Clear();
}
// 已经进入下一圈,并且上一次经过的是当前圈的最后一个路段,当前正处于第0个路段,并且已经完成了当前圈一半以上的路段
if (runDistance > 0.0f &&
curPointIndex == 0 && mPassedPointList[mPassedPointList.Count - 1] == mWayPointManager.getPointCount() - 1 &&
mPassedPointList.Count >= mWayPointManager.getPointCount() / 2)
{
// 圈数改变
mPassedPointList.Clear();
CommandCharacterCircleChanged cmdCircle = newCmd(out cmdCircle);
cmdCircle.mCircle = mData.mCircle + 1;
pushCommand(cmdCircle, mCharacter);
}
// 如果已经跑完比赛了,则将距离和路点清零
if (mCharacter.hasState(PLAYER_STATE.PS_FINISH))
{
curPointIndex = 0;
runDistance = 0.0f;
}
// 里程改变,必须在更新圈数后才能更新里程,因为计算里程会使用圈数
CommandCharacterDistanceChanged cmdDistance = newCmd(out cmdDistance, false);
cmdDistance.mWayPoint = curPointIndex;
cmdDistance.mDistance = runDistance;
pushCommand(cmdDistance, mCharacter);
mWrongDirectionTime = 0.0f;
//方向正确后退出游戏中的错误方向状态
if (mCharacter.hasState(PLAYER_STATE.PT_WRONG_DIRECTION))
{
CommandCharacterRemoveState cmdRemoveState = newCmd(out cmdRemoveState);
cmdRemoveState.mState = PLAYER_STATE.PT_WRONG_DIRECTION;
pushCommand(cmdRemoveState, mCharacter);
}
}
else
{
if (!mCharacter.hasState(PLAYER_STATE.PT_WRONG_DIRECTION))
{
mWrongDirectionTime += elapsedTime;
if (mWrongDirectionTime >= GameDefine.WRONG_DIRECTION_TIPS_TIME)
{
CommandCharacterAddState cmdState = newCmd(out cmdState);
cmdState.mState = PLAYER_STATE.PT_WRONG_DIRECTION;
pushCommand(cmdState, mCharacter);
mWrongDirectionTime = 0.0f;
}
}
}
}
base.update(elapsedTime);
}
public override void update(float elapsedTime)
{
base.update(elapsedTime);
int targetIndex = mWayPointManager.getPointIndexFromDistance(mData.mRunDistance + mTargetDistanceOffset, mData.mCurWayPoint);
float targetDirection = mWayPointManager.getPointDirection(targetIndex);
// 自身的朝向往目标点所在路段的朝向靠拢
float curDirection = mCharacter.getRotation().y;
MathUtility.adjustAngle180(ref curDirection);
float dirDelta = targetDirection - curDirection;
// 如果目标方向与当前方向的差值超过180,则转换到0-360再计算
if (Mathf.Abs(dirDelta) > 180.0f)
{
MathUtility.adjustAngle360(ref curDirection);
MathUtility.adjustAngle360(ref targetDirection);
dirDelta = targetDirection - curDirection;
}
mData.mTurnAngle = MathUtility.lerp(mData.mTurnAngle, dirDelta, 0.1f);
float curTargetSpeed = mAIBaseSpeed + mData.mNumber;
CharacterSpeedHardware speedHardware = mCharacter.getFirstComponent <CharacterSpeedHardware>();
if (!MathUtility.isFloatEqual(speedHardware.getTargetSpeed(), curTargetSpeed) && mCharacter.getProcessExternalSpeed())
{
CommandCharacterHardwareSpeed cmd = newCmd(out cmd);
cmd.mSpeed = curTargetSpeed;
cmd.mExternalSpeed = true;
pushCommand(cmd, mCharacter);
}
// 如果AI背包中有导弹,则一直搜寻可以瞄准的目标
int missileIndex = mCharacter.getPlayerPack().getFirstItemIndex(PLAYER_ITEM.PI_MISSILE);
if (missileIndex != -1 && !mCharacter.hasState(PLAYER_STATE.PS_AIM))
{
bool hasAvailableTarget = false;
SortedDictionary <int, CharacterOther> allCharacterList = mRoleSystem.getAllPlayer();
float playerDistance = mCharacter.getCharacterData().mRunDistance;
foreach (var item in allCharacterList)
{
if (item.Value != mCharacter)
{
float curDistance = item.Value.getCharacterData().mRunDistance - playerDistance;
if (MathUtility.isInRange(curDistance, 0.0f, GameDefine.MAX_LAUNCH_MISSILE_DISTANCE))
{
if (UnityUtility.whetherGameObjectInScreen(item.Value.getWorldPosition()))
{
hasAvailableTarget = true;
break;
}
}
}
}
if (hasAvailableTarget)
{
// 需要选中导弹
CommandCharacterSelectItem cmdSelect = newCmd(out cmdSelect);
cmdSelect.mIndex = missileIndex;
pushCommand(cmdSelect, mCharacter);
// 给角色添加瞄准状态
CommandCharacterAddState cmdCharacterAddState = newCmd(out cmdCharacterAddState);
cmdCharacterAddState.mState = PLAYER_STATE.PS_AIM;
pushCommand(cmdCharacterAddState, mCharacter);
}
}
}
