public override void init(ComponentOwner owner)
{
base.init(owner);
mPlayer = owner as CharacterOther;
mData = mPlayer.getCharacterData();
//mAvatar = mPlayer.getAvatar();
}
public override void execute()
{
Character character = mReceiver as Character;
CharacterOther player = character as CharacterOther;
if (player == null)
{
return;
}
// 移除瞄准状态
if (player.hasState(PLAYER_STATE.PS_AIM))
{
CommandCharacterRemoveState cmdState = newCmd(out cmdState);
cmdState.mState = PLAYER_STATE.PS_AIM;
pushCommand(cmdState, character);
}
PlayerPack pack = player.getPlayerPack();
int nextNotNullIndex = mIndex != -1 ? mIndex : pack.getNextNotEmptyIndex();
if (nextNotNullIndex == -1)
{
return;
}
pack.setItemIndex(nextNotNullIndex);
// 通知布局
if (player.isType(CHARACTER_TYPE.CT_MYSELF))
{
mScriptProps.showIndex(nextNotNullIndex);
}
}
public override void execute()
{
CharacterOther otherPlayer = mCharacterManager.getCharacter(mOtherPlayerGUID.mValue) as CharacterOther;
ScriptMahjongFrame mahjongFrame = mLayoutManager.getScript(LAYOUT_TYPE.LT_MAHJONG_FRAME) as ScriptMahjongFrame;
mahjongFrame.notifyInfo("正在等待玩家" + otherPlayer.getName() + "做出选择");
}
public override void init(ComponentOwner owner)
{
base.init(owner);
mCharacter = owner as CharacterOther;
mData = mCharacter.getCharacterData();
mAIBaseSpeed = mGameConfig.getFloatParam(GAME_DEFINE_FLOAT.GDF_AI_BASE_SPEED);
}
public override void execute()
{
string name = BinaryUtility.bytesToString(mName.mValue, Encoding.UTF8);
UnityUtility.logInfo("获得玩家数据 : " + mPlayerGUID + ", 名字 : " + name);
// 创建该玩家的实例
CommandCharacterManagerCreateCharacter cmdCreate = newCmd(out cmdCreate);
cmdCreate.mName = name;
cmdCreate.mID = mPlayerGUID.mValue;
cmdCreate.mCharacterType = CHARACTER_TYPE.CT_OTHER;
pushCommand(cmdCreate, mCharacterManager);
CharacterOther other = mCharacterManager.getCharacter(mPlayerGUID.mValue) as CharacterOther;
CharacterData data = other.getCharacterData();
data.mMoney = mMoney.mValue;
data.mHead = mHead.mValue;
data.mServerPosition = (PLAYER_POSITION)mPosition.mValue;
data.mBanker = mBanker.mValue;
data.mReady = mReady.mValue;
// 将该玩家加入房间
GameScene gameScene = mGameSceneManager.getCurScene();
CommandRoomJoin cmd = newCmd(out cmd);
cmd.mCharacter = other;
pushCommand(cmd, (gameScene as MahjongScene).getRoom());
}
public override void execute()
{
Character character = mReceiver as Character;
CharacterOther player = character as CharacterOther;
if (player == null)
{
return;
}
PlayerPack pack = player.getPlayerPack();
if (!pack.isFull())
{
int itemIndex = pack.addItem(mItemType);
// 如果获取道具的是玩家自己,通知游戏界面
if (player.isType(CHARACTER_TYPE.CT_MYSELF))
{
mScriptProps.addProps(mItemType, itemIndex);
GameTools.PLAY_AUDIO_UI(mScriptGlobalAudio.getAudioWindow(), SOUND_DEFINE.SD_GET_ITEM);
}
// 如果获取道具的是游戏中Al(直接使用游戏中的道具)
else
{
CharacterControllerAI characterControllerAI = player.getFirstActiveComponent <CharacterControllerAI>();
characterControllerAI.notifyAIGetBoxItem(pack.getCurItem());
}
}
}
public override void leave()
{
mAimTarget = null;
// 隐藏瞄准图标
if (mPlayer.isType(CHARACTER_TYPE.CT_MYSELF))
{
LayoutTools.HIDE_LAYOUT(LAYOUT_TYPE.LT_AIMING);
}
}
public void setConnectPlayer(CharacterOther player)
{
if (player != null)
{
mCanvas.setConnectParent(player.getObject(), new Vector3(0.0f, 1.0f, 0.0f));
}
else
{
mCanvas.setConnectParent(mScript.getRoot().mObject);
}
}
public void init(CharacterOther player)
{
mPlayer = player;
if (mRegisteList.Count == 0)
{
registePlayerItem <PlayerMissile>(PLAYER_ITEM.PI_MISSILE);
registePlayerItem <PlayerShield>(PLAYER_ITEM.PI_SHIELD);
registePlayerItem <PlayerTurbo>(PLAYER_ITEM.PI_TURBO);
registePlayerItem <PlayerLandMine>(PLAYER_ITEM.PI_LAND_MINE);
}
}
public override void execute()
{
Character character = mReceiver as Character;
if (!character.isType(CHARACTER_TYPE.CT_OTHER))
{
return;
}
CharacterOther other = character as CharacterOther;
other.getStateMachine().removeState(mState);
}
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 void startMahjong(List <int> playerIDList, List <List <MAHJONG> > handInList, List <List <MAHJONG> > huaList)
{
int playerCount = playerIDList.Count;
for (int i = 0; i < playerCount; ++i)
{
CharacterOther player = mCharacterManager.getCharacter(playerIDList[i]) as CharacterOther;
mPlayerIDList.Add(player.getCharacterData().mGUID, player);
mPlayerPositionList.Add(player);
}
mHandInList = handInList;
mHuaList = huaList;
}
public override void execute()
{
Character character = mReceiver as Character;
CharacterOther player = character as CharacterOther;
if (player == null)
{
return;
}
PlayerPack pack = player.getPlayerPack();
pack.useItem(mItemIndex);
}
public void createMyself(string name, int startIndex)
{
CommandCharacterManagerCreateCharacter cmdCreate = newCmd(out cmdCreate);
cmdCreate.mCharacterType = CHARACTER_TYPE.CT_MYSELF;
cmdCreate.mName = name;
pushCommand(cmdCreate, mCharacterManager);
CharacterOther player = mCharacterManager.getMyself();
player.getCharacterData().mStartIndex = startIndex;
player.initModel(mSelectRoleList[mSelectedIndex].getAvatar().getModelPath());
// 将玩家加入比赛角色列表,并确保位于第一个
mPlayerList.Add(player.getCharacterData().mNumber, player);
}
public override void execute()
{
Character character = mReceiver as Character;
CharacterOther other = character as CharacterOther;
if (other == null)
{
return;
}
other.notifyMissileLocked(mMissile, mLocked);
if (other.isType(CHARACTER_TYPE.CT_MYSELF) && other.isLockedByMissile())
{
mScriptAttackTip.notifyMissileLockPlayer(mLocked);
}
}
public override void onGameState()
{
int count = mRaceInfoList.Length;
for (int i = 0; i < count; ++i)
{
CharacterOther player = mRoleSystem.getPlayer(indexToNumber(i));
CharacterData data = player.getCharacterData();
mRaceInfoList[i].setCurCircle(data.mCircle);
mRaceInfoList[i].setSpeedMS(data.mSpeed);
mRaceInfoList[i].setRank(data.mRank);
mRaceInfoList[i].setMaxCircle(mRaceSystem.getCurGameTrack().mCircleCount);
mRaceInfoList[i].setConnectPlayer(player);
}
}
public override void execute()
{
Character character = mReceiver as Character;
if (!character.isType(CHARACTER_TYPE.CT_OTHER))
{
return;
}
CharacterOther other = character as CharacterOther;
bool ret = other.getStateMachine().addState(mState, mParam);
if (mResult != null)
{
mResult.mValue = ret;
}
}
public void OnTriggerEnter(Collider other)
{
// 角色之间的碰撞
if (other.gameObject.layer == GameUtility.mCharacterLayer)
{
CharacterOther otherPlayer = GameBase.mCharacterManager.getCharacter(other.name) as CharacterOther;
GameBase.mRaceSystem.addCollidePair(mPlayer, otherPlayer);
}
// 接触起跳点
else if (other.gameObject.layer == GameUtility.mJumpPointLayer && mPlayer.hasState(PLAYER_STATE.PS_GAMING))
{
CommandCharacterJump cmdJump = GameBase.newCmd(out cmdJump);
cmdJump.mJumpSpeed = GameDefine.JUMP_SPEED;
GameBase.pushCommand(cmdJump, mPlayer);
}
}
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);
}
// 创建用于比赛的玩家,number是玩家编号
public void createAI(string name, string model, int startIndex, int number)
{
// 创建玩家
CommandCharacterManagerCreateCharacter cmdCreate = newCmd(out cmdCreate);
cmdCreate.mCharacterType = CHARACTER_TYPE.CT_AI;
cmdCreate.mName = name;
pushCommand(cmdCreate, mCharacterManager);
CharacterOther player = mCharacterManager.getCharacter(name) as CharacterOther;
CharacterData data = player.getCharacterData();
data.mStartIndex = startIndex;
data.mNumber = number;
player.initModel(GameDefine.R_CHARACTER_PREFAB_PATH + model);
// 将玩家加入比赛角色列表
mPlayerList.Add(data.mNumber, player);
}
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 void createSelectRole(string name, string model, int id)
{
if (mCharacterManager.getCharacter(name) != null)
{
return;
}
CommandCharacterManagerCreateCharacter cmdCreate = newCmd(out cmdCreate);
cmdCreate.mCharacterType = CHARACTER_TYPE.CT_OTHER;
cmdCreate.mName = name;
cmdCreate.mID = id;
pushCommand(cmdCreate, mCharacterManager);
CharacterOther character = mCharacterManager.getCharacter(id) as CharacterOther;
character.initModel(GameDefine.R_CHARACTER_PREFAB_PATH + model);
mCharacterManager.activeCharacter(character, false);
mSelectRoleList.Add(character);
}
public void addCollidePair(CharacterOther player0, CharacterOther player1)
{
bool hasPair = false;
int count = mCollidePairList.Count;
for (int i = 0; i < count; ++i)
{
if (mCollidePairList[i].isPair(player0, player1))
{
hasPair = true;
break;
}
}
if (!hasPair)
{
mCollidePairList.Add(new CollidePair(player0, player1));
}
}
public override void execute()
{
Character character = mReceiver as Character;
if (!character.isType(CHARACTER_TYPE.CT_OTHER))
{
return;
}
CharacterOther charOther = character as CharacterOther;
CharacterSpeedHardware componentSpeed = character.getFirstActiveComponent <CharacterSpeedHardware>();
if (componentSpeed != null)
{
if (!mExternalSpeed || charOther.getProcessExternalSpeed())
{
componentSpeed.setHardwareSpeed(mSpeed, mDirectSpeed);
}
}
}
public override void init(ComponentOwner owner)
{
base.init(owner);
mCharacter = owner as CharacterOther;
if (mCharacter == null)
{
UnityUtility.logError("CharacterBikePhysics can only attach to CharacterOther!");
}
mData = mCharacter.getCharacterData();
mNormalFriction = mGameConfig.getFloatParam(GAME_DEFINE_FLOAT.GDF_NORMAL_FRICTION);
mMinUphillAngle = mGameConfig.getFloatParam(GAME_DEFINE_FLOAT.GDF_MIN_UPHILL_ANGLE);
mMaxUphillAngle = mGameConfig.getFloatParam(GAME_DEFINE_FLOAT.GDF_MAX_UPHILL_ANGLE);
mMinDownhillAngle = mGameConfig.getFloatParam(GAME_DEFINE_FLOAT.GDF_MIN_DOWNHILL_ANGLE);
mMaxDownhillAngle = mGameConfig.getFloatParam(GAME_DEFINE_FLOAT.GDF_MAX_DOWNHILL_ANGLE);
mMinUphillFriction = mGameConfig.getFloatParam(GAME_DEFINE_FLOAT.GDF_MIN_UPHILL_FRICTION);
mMaxUphillFriction = mGameConfig.getFloatParam(GAME_DEFINE_FLOAT.GDF_MAX_UPHILL_FRICTION);
mMinDownhillFriction = mGameConfig.getFloatParam(GAME_DEFINE_FLOAT.GDF_MIN_DOWNHILL_FRICTION);
mMaxDownhillFriction = mGameConfig.getFloatParam(GAME_DEFINE_FLOAT.GDF_MAX_DOWNHILL_FRICTION);
}
public override void update(float elapsedTime)
{
base.update(elapsedTime);
mAimCharacterList.Clear();
SortedDictionary <int, CharacterOther> allCharacterList = mRoleSystem.getAllPlayer();
float playerDistance = mPlayer.getCharacterData().mRunDistance;
foreach (var item in allCharacterList)
{
if (item.Value != mPlayer)
{
float curDistance = item.Value.getCharacterData().mRunDistance - playerDistance;
if (MathUtility.isInRange(curDistance, 0.0f, GameDefine.MAX_LAUNCH_MISSILE_DISTANCE))
{
if (UnityUtility.whetherGameObjectInScreen(item.Value.getWorldPosition()))
{
mAimCharacterList.Add(item.Value);
}
}
}
}
if (mAimCharacterList.Count == 0)
{
mAimTarget = null;
}
else
{
if (mAimTarget == null || !mAimCharacterList.Contains(mAimTarget))
{
int aim = MathUtility.randomInt(0, mAimCharacterList.Count - 1);
mAimTarget = mAimCharacterList[aim];
}
}
CommandCharacterAimTarget cmdAim = newCmd(out cmdAim, false);
cmdAim.mTarget = mAimTarget;
pushCommand(cmdAim, mPlayer);
if (mAimTarget != null && mPlayer.isType(CHARACTER_TYPE.CT_AI))
{
launchMissile();
}
}
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 use(CharacterOther player)
{
// 在角色当前位置放置一个地雷
Vector3 curRot = player.getRotation();
Vector3 dir = MathUtility.getVectorFromAngle(curRot.y * Mathf.Deg2Rad);
Vector3 pos = player.getPosition() - dir * 2.0f;
LandmineParam param = new LandmineParam();
param.mPosition = pos;
SceneLandMine landmine = mItemManager.createItem <SceneLandMine>(SCENE_ITEM.SI_LAND_MINE, param);
if (player.isType(CHARACTER_TYPE.CT_MYSELF))
{
GameTools.PLAY_AUDIO_OBJECT(landmine, SOUND_DEFINE.SD_PUT_LANDMINE);
}
// 使用后立即移除背包中的道具
CommandCharacterRemoveItem cmdRemove = newCmd(out cmdRemove);
cmdRemove.mItem = this;
pushCommand(cmdRemove, player);
}
public void init(CharacterOther player)
{
mPlayer = player;
registeState <JumpState>(PLAYER_STATE.PS_JUMP);
registeState <RidingState>(PLAYER_STATE.PS_RIDING);
registeState <IdleState>(PLAYER_STATE.PS_IDLE);
registeState <AimState>(PLAYER_STATE.PS_AIM);
registeState <AttackedState>(PLAYER_STATE.PS_ATTACKED);
registeState <ProtectedState>(PLAYER_STATE.PS_PROTECTED);
registeState <SprintState>(PLAYER_STATE.PS_SPRINT);
registeState <WrongDirectionState>(PLAYER_STATE.PT_WRONG_DIRECTION);
registeState <ReadyState>(PLAYER_STATE.PS_READY);
registeState <GamingState>(PLAYER_STATE.PS_GAMING);
registeState <FinishState>(PLAYER_STATE.PS_FINISH);
registeState <OnSelectRoleState>(PLAYER_STATE.PS_ON_SELECT_ROLE);
registeState <SelectedRoleState>(PLAYER_STATE.PS_SELECTED_ROLE);
registeState <UnSelectRoleState>(PLAYER_STATE.PS_UN_SELECT_ROLE);
if (mStateTypeList.Count != (int)PLAYER_STATE.PS_MAX)
{
UnityUtility.logError("not all player state registed!");
}
registeGroup(STATE_GROUP.SG_SELECT, false);
registeGroup(STATE_GROUP.SG_GAME, false);
registeGroup(STATE_GROUP.SG_RIDE, false);
registeGroup(STATE_GROUP.SG_BUFF, true);
// 为状态分组
assignGroup(STATE_GROUP.SG_SELECT, PLAYER_STATE.PS_ON_SELECT_ROLE);
assignGroup(STATE_GROUP.SG_SELECT, PLAYER_STATE.PS_SELECTED_ROLE);
assignGroup(STATE_GROUP.SG_SELECT, PLAYER_STATE.PS_UN_SELECT_ROLE);
assignGroup(STATE_GROUP.SG_GAME, PLAYER_STATE.PS_READY);
assignGroup(STATE_GROUP.SG_GAME, PLAYER_STATE.PS_FINISH);
assignGroup(STATE_GROUP.SG_GAME, PLAYER_STATE.PS_GAMING);
assignGroup(STATE_GROUP.SG_RIDE, PLAYER_STATE.PS_RIDING);
assignGroup(STATE_GROUP.SG_RIDE, PLAYER_STATE.PS_JUMP);
assignGroup(STATE_GROUP.SG_RIDE, PLAYER_STATE.PS_IDLE);
assignGroup(STATE_GROUP.SG_BUFF, PLAYER_STATE.PS_ATTACKED);
assignGroup(STATE_GROUP.SG_BUFF, PLAYER_STATE.PS_SPRINT);
assignGroup(STATE_GROUP.SG_BUFF, PLAYER_STATE.PS_PROTECTED);
assignGroup(STATE_GROUP.SG_BUFF, PLAYER_STATE.PS_AIM);
}
public override void execute()
{
Character character = mReceiver as Character;
CharacterOther player = character as CharacterOther;
if (player == null)
{
return;
}
PlayerPack pack = player.getPlayerPack();
int itemIndex = -1;
if (mItem != null)
{
itemIndex = pack.removeItem(mItem);
}
// 通知布局
if (player.isType(CHARACTER_TYPE.CT_MYSELF))
{
mScriptProps.removeProps(itemIndex);
}
pushCommand <CommandCharacterSelectItem>(player);
}
