protected override PeerBase CreatePeer(InitRequest initRequest)
{
ClientPeer curPeer = new ClientPeer(initRequest.Protocol, initRequest.PhotonPeer);
log.Debug("One Peer is Created!");
// 注册Handler
RegisteHandler((byte)OperationCode.GetServer, new ServerPropertyHandler());
RegisteHandler((byte)OperationCode.Login, new LoginHandler());
RegisteHandler((byte)OperationCode.UserRegiste, new UserRegisteHandler());
RoleHandler roleHander = new RoleHandler();
RegisteHandler((byte)OperationCode.RoleHandler, roleHander);
RegisteHandler((byte)OperationCode.CreateRole, roleHander);
RegisteHandler((byte)OperationCode.ChooseRole, roleHander);
TaskHandler taskHandler = new TaskHandler();
RegisteHandler((byte)OperationCode.AddTask, taskHandler);
RegisteHandler((byte)OperationCode.GetTask, taskHandler);
RegisteHandler((byte)OperationCode.UpdateTask, taskHandler);
RoleInfoHandler roleinfoHandler = new RoleInfoHandler();
RegisteHandler((byte)OperationCode.AddRoleInfo, roleinfoHandler);
RegisteHandler((byte)OperationCode.UpdateRoleInfo, roleinfoHandler);
RegisteHandler((byte)OperationCode.GetRoleInfo, roleinfoHandler);
RegisteHandler((byte)OperationCode.AddGoodsList, roleinfoHandler);
RegisteHandler((byte)OperationCode.UpdateGoodsList, roleinfoHandler);
RegisteHandler((byte)OperationCode.GetGoodsList, roleinfoHandler);
RegisteHandler((byte)OperationCode.AddEquipList, roleinfoHandler);
RegisteHandler((byte)OperationCode.UpdateEquipList, roleinfoHandler);
RegisteHandler((byte)OperationCode.GetEquipList, roleinfoHandler);
SkillHandler skillhandler = new SkillHandler();
RegisteHandler((byte)OperationCode.GetSkill, skillhandler);
RegisteHandler((byte)OperationCode.AddSkill, skillhandler);
RegisteHandler((byte)OperationCode.UpdateSkill, skillhandler);
BattleHandler battleHandler = new BattleHandler();
RegisteHandler((byte)OperationCode.ForTeam, battleHandler);
RegisteHandler((byte)OperationCode.CancelTeam, battleHandler);
RegisteHandler((byte)OperationCode.SyncMove, battleHandler);
RegisteHandler((byte)OperationCode.SyncMoveAnim, battleHandler);
RegisteHandler((byte)OperationCode.RemoveTeamRole, battleHandler);
RegisteHandler((byte)OperationCode.SyncMoveDir, battleHandler);
MonsterHandler monsterHandler = new MonsterHandler();
RegisteHandler((byte)OperationCode.CreateMonster, monsterHandler);
RegisteHandler((byte)OperationCode.SyncMonsterMove, monsterHandler);
return(curPeer);
}
public BossActor(BossData boss, MonsterHandler handler, FloatingCombatTextInterface FCTInterface, BossBattleController controller)
{
this.boss = boss;
this.handler = handler;
this.Health = boss.MaxHealth;
this.FCTInterface = FCTInterface;
this.controller = controller;
this.speed = boss.Speed;
}
/// <summary>
/// 根据实例ID找到玩家或者技能宠物 -
/// </summary>
public static GameObject GetObjectByInstanceID(int _InstanceID)
{
GameObject go;
go = ObjectAccessor.getAOIObject(_InstanceID);
if (go == null)
{
go = MonsterHandler.GetInstance().FindMonsterByMonsterID(_InstanceID);
}
return(go);
}
// OnStateEnter is called when a transition starts and the state machine starts to evaluate this state
override public void OnStateEnter(Animator animator, AnimatorStateInfo stateInfo, int layerIndex)
{
CharacterHandler chandler = animator.gameObject.GetComponent <CharacterHandler>();
MonsterHandler mhandler = animator.gameObject.GetComponent <MonsterHandler>();
switch (animation)
{
case "Idle":
animator.GetComponent <SkeletonAnimation>().state.SetAnimation(trackIndex, animation, looping);
animator.GetComponent <SkeletonAnimation>().timeScale = 0.7f;
break;
case "Attack":
case "Skill":
case "Skill2":
//Debug.Log("Offensive Anim on " + animator.gameObject.name);
if (chandler != null)
{
chandler.Attack();
}
else if (mhandler != null)
{
mhandler.Attack();
}
break;
case "GetHit":
case "Die":
//Debug.Log("Hit Anim on " + animator.gameObject.name);
if (chandler != null)
{
chandler.Die();
}
else if (mhandler != null)
{
mhandler.Die();
}
break;
default:
//Debug.Log("State not handled: " + animation);
break;
}
}
// Warning!!!Warning!!!Warning!!!此处顶层分隔符使用“;” -
/// <summary>
/// 发起AI建议 -
/// </summary>
static void RquestCallAI(int MonsterID, int DecisionID, string DecisionData)
{
#if msr_AccumulateAI
AIDecisionData nData = new AIDecisionData();
nData.MonsterID = MonsterID;
nData.DecisionID = DecisionID;
nData.DecisionData = DecisionData;
MonsterHandler.RequestCallAI(nData);
#endif
#if !msr_AccumulateAI
//Debug.Log( "K________RquestCallAI!!!!!!!!!!!MonsterID = " + MonsterID + " Data = " + DecisionData );
ZMNetData zd = new ZMNetData((int)OpCode.Decision);
zd.writeInt(MonsterID);
zd.writeInt(DecisionID);
zd.writeString(DecisionData);
ZealmConnector.sendRequest(zd);
#endif
}
/// <summary>
/// 撤退 OrderType = 10 -
/// </summary>
public static void RequestFallBack(int MonsterID, int DecisionID, int OrderType, byte isMaxHP)
{
#if msr_AccumulateAI
AIDecisionData nData = new AIDecisionData();
nData.MonsterID = MonsterID;
nData.DecisionID = DecisionID;
nData.DecisionData = FallBackAIData(OrderType);
nData.isMaxHP = isMaxHP;
MonsterHandler.RequestFallBack(nData);
#endif
#if !msr_AccumulateAI
_AIData = "" + OrderType;
//Debug.Log( "K________Rquest FallBack!!!!!!!!!!!!MonsterID = " + MonsterID + " Data = " + _AIData );
ZMNetData zd = new ZMNetData((int)OpCode.DecisionFallBack);
zd.writeInt(MonsterID);
zd.writeInt(DecisionID);
zd.writeString(_AIData);
ZealmConnector.sendRequest(zd);
#endif
}
public static void ServerHandlerReceive(InPacket ip, Client gc)
{
var Header = ip.ReadShort(); // Read header
ip.ReadInt(); // Original length + CRC
ip.ReadInt();
#if DEBUG
Log.Hex("Received {0}({1}) packet from {2}: ", ip.Array, ((ClientOpcode)Header).ToString(), Header,
gc.Title);
#endif
switch ((ClientOpcode)Header)
{
// Game
case ClientOpcode.COMMAND_REQ:
GameHandler.Command_Req(ip, gc);
break;
case ClientOpcode.GAMELOG_REQ:
GameHandler.Game_Log_Req(ip, gc);
break;
case ClientOpcode.QUICK_SLOT_REQ:
GameHandler.Quick_Slot_Req(ip, gc);
break;
//2019-09-01 16:48 GMT+7
case ClientOpcode.CHARACTER_INFO_REQ: // OPCODE = 76 // Try Change test = E4
GameHandler.Character_Info_Req(ip, gc);
break;
case ClientOpcode.GAME_ISACTIVE:
GameHandler.GameisActive_Ack(ip, gc);
break;
// Shop
case ClientOpcode.NPC_SHOP_BUY_REQ:
NpcShopHandler.Buy_Req(ip, gc);
break;
case ClientOpcode.NPC_SHOP_SELL_REQ:
NpcShopHandler.Sell_Req(ip, gc);
break;
// Status
case ClientOpcode.CHAR_DAMAGE_REQ:
StatusHandler.Char_Damage_Req(ip, gc);
break;
case ClientOpcode.CHAR_DEAD_REQ:
StatusHandler.Char_Dead_Req(ip, gc);
break;
case ClientOpcode.CHAR_STATUP_REQ:
StatusHandler.Char_Statup_Req(ip, gc);
break;
case ClientOpcode.CHAR_FURY:
StatusHandler.Char_Fury_Req(ip, gc);
break;
// Inventory
case ClientOpcode.MOVE_ITEM_REQ:
InventoryHandler.MoveItem_Req(ip, gc);
break;
case ClientOpcode.INVEN_SELECTSLOT_REQ:
InventoryHandler.SelectSlot_Req(ip, gc);
break;
case ClientOpcode.USE_SPEND_REQ:
InventoryHandler.UseSpend_Req(ip, gc);
break;
case ClientOpcode.INVEN_USESPEND_REQ:
InventoryHandler.InvenUseSpendStart_Req(ip, gc);
break;
case ClientOpcode.INVEN_USESPEND_SHOUT_REQ:
case ClientOpcode.INVEN_USESPEND_SHOUT_ALL_REQ:
InventoryHandler.InvenUseSpendShout_Req(ip, gc);
break;
case ClientOpcode.PICKUP_ITEM:
InventoryHandler.PickupItem(ip, gc);
break;
// Skill
case ClientOpcode.SKILL_LEVELUP_REQ:
SkillHandler.SkillLevelUp_Req(ip, gc);
break;
//case ClientOpcode.USE_SKILL_REQ:
// SkillHandler.UseSkill_Req(ip, gc);
// break;
// Quest
case ClientOpcode.QUEST_ALL_REQ:
QuestHandler.Quest_All_Req(ip, gc);
break;
case ClientOpcode.QUEST_GIVEUP_REQ:
QuestHandler.Quest_GiveUp_Req(ip, gc);
break;
case ClientOpcode.QUEST_DONE_REQ:
QuestHandler.Quest_Done_Req(ip, gc);
break;
case ClientOpcode.QUEST_RETURN_REQ:
QuestHandler.Quest_Return_Req(ip, gc);
break;
case ClientOpcode.QUEST_DONE2_REQ:
QuestHandler.Quest_Done2_Req(ip, gc);
break;
case ClientOpcode.QUEST_UPDATE_REQ:
QuestHandler.Quest_Update_Req(ip, gc);
break;
// Map
case ClientOpcode.ENTER_WARP_ACK_REQ:
MapHandler.WarpToMap_Req(ip, gc);
break;
case ClientOpcode.CAN_WARP_ACK_REQ:
MapHandler.WarpToMapAuth_Req(ip, gc);
break;
// Monster
case ClientOpcode.ATTACK_MONSTER_REQ:
MonsterHandler.AttackMonster_Req(ip, gc);
break;
// Storage
case ClientOpcode.MOVE_ITEM_STORAGE_REQ:
StorageHandler.MoveItemToStorage(ip, gc);
break;
case ClientOpcode.MOVE_ITEM_TO_BAG_REQ:
StorageHandler.MoveItemToBag(ip, gc);
break;
case ClientOpcode.SAVE_MONEY_REQ:
StorageHandler.SaveStorageMoney(ip, gc);
break;
case ClientOpcode.GIVE_MONEY_REQ:
StorageHandler.GiveStorageMoney(ip, gc);
break;
// Coupon
case ClientOpcode.CASH_SN:
CouponHandler.Use_Coupon_Req(ip, gc);
break;
// Action
case ClientOpcode.P_WARP_C:
ActionHandler.p_Warp_c(ip, gc);
break;
case ClientOpcode.P_MOVE_C:
ActionHandler.p_Move_c(ip, gc);
break;
case ClientOpcode.P_JUMP_C:
ActionHandler.p_Jump_c(ip, gc);
break;
case ClientOpcode.P_SPEED_C:
ActionHandler.p_Speed_c(ip, gc);
break;
case ClientOpcode.P_ATTACK_C:
ActionHandler.p_Attack_c(ip, gc);
break;
//case ClientOpcode.P_DAMAGE_C:
// ActionHandler.p_Damage_c(ip, gc);
// break;
//case ClientOpcode.P_DEAD_C:
// ActionHandler.p_Dead_c(ip, gc);
// break;
case ClientOpcode.P_MOVE_C_2:
ActionHandler.p_Move_c_2(ip, gc);
break;
//case ClientOpcode.PET_MOVE_C:
// ActionHandler.Pet_Move_C(ip, gc);
// break;
//case ClientOpcode.PET_ATTACK_C:
// ActionHandler.Pet_Attack_C(ip, gc);
// break;
// Trade
case ClientOpcode.TRADE_INVITE_REQ:
TradeHandler.TradeInvite(ip, gc);
break;
case ClientOpcode.TRADE_INVITE_RESPONSE_REQ:
TradeHandler.TradeInviteResponses(ip, gc);
break;
case ClientOpcode.TRADE_READY_REQ:
TradeHandler.TradeReady(ip, gc);
break;
case ClientOpcode.TRADE_CONFIRM_REQ:
TradeHandler.TradeConfirm(ip, gc);
break;
case ClientOpcode.TRADE_CANCEL_REQ:
TradeHandler.TradeCancel(ip, gc);
break;
case ClientOpcode.TRADE_PUT_REQ:
TradeHandler.TradePutItem(ip, gc);
break;
// Party
case ClientOpcode.PARTY_INVITE_REQ:
PartyHandler.PartyInvite(ip, gc);
break;
case ClientOpcode.PARTY_INVITE_RESPONSES_REQ:
PartyHandler.PartyInviteResponses(ip, gc);
break;
case ClientOpcode.PARTY_LEAVE:
PartyHandler.PartyLeave(ip, gc);
break;
// PvP
case ClientOpcode.PVP_REQ:
PvPHandler.PvPInvite(ip, gc);
break;
case ClientOpcode.PVP_ACK_REQ:
PvPHandler.PvPInviteResponses(ip, gc);
break;
// PlayerShop
case ClientOpcode.PSHOP_OPEN_REQ:
PlayerShopHandler.OpenShop_Req(ip, gc);
break;
case ClientOpcode.PSHOP_SELLSTART_REQ:
PlayerShopHandler.SellStart_Req(ip, gc);
break;
case ClientOpcode.PSHOP_SELLEND_REQ:
PlayerShopHandler.SellEnd_Req(ip, gc);
break;
case ClientOpcode.PSHOP_INFO_REQ:
PlayerShopHandler.ShopInfo_Req(ip, gc);
break;
case ClientOpcode.PSHOP_BUYACK_REQ:
PlayerShopHandler.Buy_Req(ip, gc);
break;
// Fish
case ClientOpcode.FISH_REQ:
FishHandler.Fish_Req(ip, gc);
break;
// CashShop
//case ClientOpcode.CASHSHOP_LIST_REQ:
// CashShopHandler.CashShopList_Req(ip, gc);
// break;
case ClientOpcode.CASH_MGAMECASH_REQ:
CashShopHandler.MgameCash_Req(ip, gc);
break;
case ClientOpcode.CASH_BUY_REQ:
CashShopHandler.BuyCommodity_Req(ip, gc);
break;
case ClientOpcode.CASH_GIFT_REQ:
CashShopHandler.Gifts_Req(ip, gc);
break;
case ClientOpcode.CASH_TO_INVEN_REQ:
CashShopHandler.CommodityToInventory_Req(ip, gc);
break;
case ClientOpcode.ABILITY_RECOVER_REQ:
CashShopHandler.AbilityRecover_Req(ip, gc);
break;
case ClientOpcode.CASH_CHECKCHARNAME_REQ:
CashShopHandler.CheckName_Req(ip, gc);
break;
case ClientOpcode.DISMANTLE_REQ:
CashShopHandler.Dismantle_Req(ip, gc);
break;
// Pet
case ClientOpcode.PET_NAME_REQ:
PetHandler.Pet_Name_Req(ip, gc);
break;
case ClientOpcode.SPIRIT_MOVE_REQ:
SpiritHandler.SpiritMove(ip, gc);
break;
case ClientOpcode.EQUIPMENT_COMPOUND_REQ:
SpiritHandler.EquipmentCompound(ip, gc);
break;
case ClientOpcode.EVENTITEM_ACK:
TradeHandler.TradeEventItem(ip, gc);
break;
}
}
void RunBattleSimulation()
{
// 2 states - Select Action and Execute Action
// on select action set the actor to the current
// show the UI for where the default action will place them
switch (state)
{
case BossBattleState.EndOfTurn:
break;
case BossBattleState.NewTurn:
// Clean up the list of dead actors
List <BattleActor> removeList = new List <BattleActor>();
foreach (BattleActor actor in TurnOrder)
{
if (actor.Health <= 0f)
{
actor.StopCast();
battleInterface.RemoveActorPortrait(actor);
removeList.Add(actor);
deadActors.Add(actor);
if (actor is BossActor)
{
((BossActor)actor).handler.Die();
}
else
{
((HeroActor)actor).handler.Die();
}
}
}
bool bossKilled = false;
foreach (BattleActor actor in removeList)
{
if (actor is BossActor)
{
bossKilled = true;
}
TurnOrder.Remove(actor);
}
if (bossKilled)
{
// on allyDeathTrigger
foreach (BattleActor actor in TurnOrder)
{
if (actor is BossActor)
{
((BossActor)actor).OnAllyDeath();
}
}
}
currentActor = TurnOrder[0];
selector.GoToTarget(currentActor.GetGameObject().transform.position);
if (currentActor is HeroActor)
{
print(" --- [New Turn]\n Hero Turn: " + currentActor.Name);
}
else
{
print(" --- [New Turn]\n Boss Turn: " + currentActor.Name);
}
// Check if the current actor is stunned here and skip their turn
if (currentActor.IsStunned())
{
// Spawn text displaying this actor is stunned then return to restart this turn and choose a new actor
currentActor.UpdateStatusEffects(StatusTriggerTime.StartOfTurn);
currentActor.UpdateStatusEffects(StatusTriggerTime.EndOfTurn);
return;
}
// this position allows stun transitions to be delayed when stunned, we can move this above the stun code block to change this
if (currentActor is BossActor)
{
((BossActor)currentActor).UpdateTurnCount();
}
//Check for end of battle here
if (IsBattleComplete())
{
state = BossBattleState.EndOfBattle;
}
else
{
// Check if the actor has a skill waiting to be used
if (currentActor.HasQueuedSkill())
{
// Skip straight to the use the skill part of a turn
SelectSkill(currentActor.QueuedSkill);
ExecuteSkill(currentActor.QueuedSkillTarget, true);
currentActor.QueuedSkill = null;
currentActor.QueuedSkillTarget = null;
}
else
{
state = BossBattleState.SelectAction;
}
}
break;
case BossBattleState.SelectAction:
battleInterface.SetCurrentTurn(currentActor);
currentActor.UpdateStatusEffects(StatusTriggerTime.StartOfTurn);
// Load UI for the hero or hide it on enemy
if (currentActor is HeroActor)
{
// Reduce skill cooldowns by a turn
foreach (Skill skill in ((HeroActor)currentActor).hero.Skills)
{
/*if (((HeroActor) currentActor).hero.Skills[skill] > 0)
* ((HeroActor) currentActor).hero.Skills[skill] -= 1;*/
if (skill._cooldown > 0)
{
skill._cooldown--;
}
}
battleInterface.ShowMemberArea((HeroActor)currentActor);
SelectSkill(((HeroActor)currentActor).hero.Skills[((HeroActor)currentActor).hero.Skills.Count - 1]); // default skill selected
bossTurn = false;
}
else
{
SelectSkill(((BossActor)currentActor).boss.Skills[0]);
// Choose a skill based on how many targets
int targetCount = 0;
bool targetCasting = false;
foreach (HeroActor actor in Party)
{
if (actor.Health > 0)
{
targetCount++;
}
if (actor.QueuedSkill != null)
{
targetCasting = true;
}
}
Skill skillSelect = null;
foreach (Skill skill in ((BossActor)currentActor).boss.Skills)
{
if (skill._cooldown < 1 && skill.CanInterrupt)
{
skillSelect = skill;
}
}
// TODO put the interrupt AI chance on the boss data it self, current set to 25% of the time
if (targetCasting && Random.Range(0f, 1f) < 0.25f && skillSelect != null)
{
// Choose the skill that can interrupt
SelectSkill(skillSelect);
}
else if (targetCount > 2)
{
// It can be an AOE skill
bool hasAOE = false;
foreach (Skill skill in ((BossActor)currentActor).boss.Skills)
{
if (skill._cooldown < 1 && skill.TargetType != SkillTargetType.SingleTarget)
{
hasAOE = true;
SelectSkill(skill);
continue;
}
}
if (!hasAOE)
{
foreach (Skill skill in ((BossActor)currentActor).boss.Skills)
{
if (skill._cooldown < 1)
{
SelectSkill(skill);
continue;
}
}
}
}
else
{
// Not AOE skill
foreach (Skill skill in ((BossActor)currentActor).boss.Skills)
{
if (skill._cooldown < 1)
{
SelectSkill(skill);
continue;
}
}
}
// if target count is >= 3 then you can use an AOE skill
// otherwise use your best ability thats not an attack
// if no other abilities then use an attack
bossTurn = true;
}
state = BossBattleState.WaitForAction;
break;
case BossBattleState.ExecuteAction:
//print("Execute Action");
// Do Queued Actions then (if there is a heal on multiple members or an attack that hits multiple targets etc)
if (!PlayerPrefs.HasKey("tutorial_boss_battle_castable_skill"))
{
foreach (BattleActor actor in TurnOrder)
{
if (actor is BossActor && ((BossActor)actor).QueuedSkill != null)
{
StoryManager.Instance.DisplayStory("story_tutorial_boss_battle_interrupt");
PlayerPrefs.SetInt("tutorial_boss_battle_castable_skill", 1);
}
}
}
// go to the next actor
currentActor.UpdateStatusEffects(StatusTriggerTime.EndOfTurn);
//state = BossBattleState.NewTurn;
StartEndOfTurn();
break;
case BossBattleState.WaitForAction:
// Update the turn order position based on selected skill
if (bossTurn && bossActionRoutine == null)
{
AIActionSelect();
}
// Select skill from UI
// on target select add the ability to the queue and
if (Input.GetMouseButtonDown(0) && !bossTurn && executeActionRoutine == null)
{
// see what we tapped, but for now just use the action
RaycastHit2D hit = Physics2D.Raycast(Camera.main.ScreenToWorldPoint(Input.mousePosition), Vector2.zero);
//fctLocation = Camera.main.ScreenToWorldPoint(Input.mousePosition);
if (hit.collider != null)
{
BattleActor target = null;
//Debug.Log("Target Position: " + hit.collider.gameObject.transform.position + " | hit: " + hit.collider.gameObject.name);
CharacterHandler h_handler = hit.collider.gameObject.GetComponent <CharacterHandler>();
if (h_handler != null)
{
print("Have CharacterHandler");
// Is a hero
foreach (BattleActor hA in TurnOrder)
{
if (hA is HeroActor)
{
if (((HeroActor)hA).handler == h_handler)
{
target = hA;
}
}
}
print(target);
if (target != null)
{
ExecuteSkill(target);
}
}
MonsterHandler m_handler = hit.collider.gameObject.GetComponent <MonsterHandler>();
if (m_handler != null)
{
// Is a monster
foreach (BattleActor bA in TurnOrder)
{
if (bA is BossActor)
{
if (((BossActor)bA).handler == m_handler)
{
target = bA;
}
}
}
//print(target);
if (target != null)
{
ExecuteSkill(target);
}
}
}
}
break;
case BossBattleState.EndOfBattle:
bool heroStillExists = false;
bool bossStillExists = false;
foreach (BattleActor actor in TurnOrder)
{
if (actor is HeroActor)
{
heroStillExists = true;
}
if (actor is BossActor)
{
bossStillExists = true;
}
}
ActiveExploration activeZone = playerMan.SelectedBattle;
if (!bossStillExists)
{
// Player won
float chance = 0.2f + Mathf.Min((activeZone.TreasureFind / 3000f), 0.75f) * 0.8f;
for (int i = 0; i < dataMan.globalData.GetGlobalAsInt(GlobalProps.ZONE_MONSTER_COUNT); i++)
{
if (Random.Range(0f, 1f) <= chance)
{
LootCrateScreenInterface.GenerateLootCrate(activeZone, MagicFindBoostMultiplier: playerMan.GetBoost(BoostType.MagicFind));
}
}
for (int i = 0; i < activeZone.ChestsEarned; i++)
{
LootCrateScreenInterface.GenerateLootCrate(activeZone, MagicFindBoostMultiplier: playerMan.GetBoost(BoostType.MagicFind));
}
LootCrateScreenInterface.GenerateLootCrate(activeZone, TriggerInterfaceAfterLootCratesAdded, true, playerMan.GetBoost(BoostType.MagicFind));
}
else if (!heroStillExists)
{
// Player was defeated
StartCoroutine(ResurrectForGems(activeZone));
}
playerMan.CurrentLeaderSkill = null;
state = BossBattleState.ShowResults;
break;
case BossBattleState.ShowResults:
break;
}
}
