void OnEndBattleHandler(C2G.EndBattle packet, C2G.EndBattleAck ack)
{
MapStageDifficulty stage_info = Network.BattleStageInfo;
_battle_end_param = new EventParamBattleEnd();
_battle_end_param.end_type = packet.end_type;
_battle_end_param.is_boss = stage_info.MapInfo.MapType == "boss";
_battle_end_param.maxlevel_reward_mail_idxs = ack.maxlevel_reward_mail_idx;
if (packet.end_type != pe_EndBattle.Exit)
{
Network.PlayerInfo.UseEnergy(stage_info.Energy);
_battle_end_param.player_levelup = Network.PlayerInfo.UpdateExp(ack.player_exp_add_info);
_battle_end_param.creatures = new List <BattleEndCreature>();
m_TeamData.Creatures.ForEach(c => _battle_end_param.creatures.Add(c.creature.UpdateExp(ack.creature_exp_add_infos.Find(i => i.creature_idx == c.creature.Idx))));
_battle_end_param.add_goods = ack.add_goods;
_battle_end_param.loot_items = ack.loot_items;
_battle_end_param.loot_runes = ack.loot_runes;
_battle_end_param.loot_creatures = ack.loot_creatures.Select(c => c.creature_idx).ToList();
ack.loot_items.ForEach(i => ItemManager.Instance.Add(i));
ack.loot_runes.ForEach(i => RuneManager.Instance.Add(i));
ack.add_goods.ForEach(g => Network.PlayerInfo.AddGoods(g));
Network.Instance.LootCreatures(ack.loot_creatures, ack.loot_creatures_equip);
//int dead_count = dead_characters.Count;
_battle_end_param.clear_rate = 3;
MapClearDataManager.Instance.SetClearRate(stage_info, _battle_end_param.clear_rate);
}
GameMain.SetBattleMode(eBattleMode.None);
}
public static int CalculateBattleAvailableCount(MapStageDifficulty stage_info)
{
int battle_available_count = stage_info.TryLimit;
switch (stage_info.MapInfo.MapType)
{
case "event":
battle_available_count -= MapClearDataManager.Instance.GetMapDailyClearCount(stage_info.MapInfo.IDN, pe_Difficulty.Normal);
break;
case "boss":
battle_available_count -= MapClearDataManager.Instance.GetMapDailyClearCount(stage_info.MapInfo.IDN, pe_Difficulty.Normal);
break;
case "worldboss":
battle_available_count -= MapClearDataManager.Instance.GetMapDailyClearCount(stage_info.MapInfo.IDN, pe_Difficulty.Normal);
break;
case "weekly":
battle_available_count -= MapClearDataManager.Instance.GetMapDailyClearCount(stage_info.MapInfo.IDN);
break;
default:
battle_available_count = 10;
break;
}
return(battle_available_count);
}
public void SetNew(MapStageDifficulty stage_info)
{
pd_MapClearData clearData = CreateMapClearData(stage_info.MapInfo.IDN, stage_info.StageIndex, stage_info.Difficulty);
clearData.updated_at = Network.Instance.ServerTime;
Save();
}
void SetDifficulty(int index)
{
m_StageInfo = m_SelectedMap.Stages[0].Difficulty[index];
LabelTitle.text = m_StageInfo.ShowName;
LabelDungeonInfo.text = m_SelectedMap.Description + "\n";
LabelDungeonInfo.text += Localization.Get("WeeklyAvailable");
foreach (var tag in m_SelectedMap.AvailableTags)
{
LabelDungeonInfo.text += string.Format("[url={0}]{1}[/url] ", "Tag_" + tag, Localization.Get("Tag_" + tag));
}
RewardItemPrefab.Clear();
foreach (var reward in m_StageInfo.DropItems)
{
if (reward.IsShow == false)
{
continue;
}
var reward_item = RewardItemPrefab.GetNewObject <RewardItem>(GridRewards.transform, Vector3.zero);
reward_item.InitReward(reward);
}
GridRewards.Reposition();
ScrollViewRewards.ResetPosition();
}
//---------------------------------------------------------------------------
public void Init(MapStageDifficulty stage_info, MapCreatureInfo info)
{
short level = info.Level;
short grade = info.Grade;
if (info.CreatureType == eMapCreatureType.Boss && stage_info.MapInfo.MapType == "boss")
{
level = Boss.CalculateLevel(level, stage_info);
grade = Boss.CalculateGrade(level);
}
CreatureInfo = info;
for (int i = 0; i < m_Stars.Length; ++i)
{
m_Stars[i].gameObject.SetActive(i < grade);
}
m_Grid.Reposition();
InitCreatureInfo(info.CreatureInfo);
m_level.text = level.ToString();
m_Elite.gameObject.SetActive(info.CreatureType == eMapCreatureType.Elite);
m_Boss.gameObject.SetActive(info.CreatureType == eMapCreatureType.Boss);
gameObject.SetActive(true);
}
void Init(bool is_new)
{
MapInfo map_info = MapInfoManager.Instance.GetInfoByID("10001_boss");
m_LabelBossDesc.text = Localization.Format("LeftTryCount", (map_info.TryLimit - MapClearDataManager.Instance.GetMapDailyClearCount(map_info.IDN, pe_Difficulty.Normal)), map_info.TryLimit);
List <MapStageDifficulty> stages = map_info.Stages.Select(e => e.Difficulty[0]).ToList();
for (int i = 0; i < stages.Count; ++i)
{
MapStageDifficulty stage_info = stages[i];
BossSpot stage;
if (m_Spots.Count < i + 1)
{
GameObject dungeon = NGUITools.AddChild(BossLocation, BossSpotPrefab);
stage = dungeon.GetComponent <BossSpot>();
m_Spots.Add(stage);
}
else
{
stage = m_Spots[i];
}
stage.transform.localPosition = stage_info.MapPos;
stage.gameObject.name = stage_info.ID;
stage.Init(stage_info);
}
}
void OnEndWorldBossHandler(C2G.EndWorldBoss packet, C2G.EndWorldBossAck ack)
{
if (packet.end_type == pe_EndBattle.Exit)
{
GameMain.SetBattleMode(eBattleMode.None);
return;
}
MapStageDifficulty stage_info = Network.BattleStageInfo;
_battle_end_param = new EventParamWorldBossBattleEnd();
_battle_end_param.rank = ack.info.rank;
_battle_end_param.score = packet.score;
if (WorldBossInfo.Info != null)
{
_battle_end_param.rank_up = ack.info.rank - WorldBossInfo.Info.rank;
_battle_end_param.score_up = ack.info.score - WorldBossInfo.Info.score;
}
else
{
_battle_end_param.is_first = true;
}
WorldBossInfo.Info = ack.info;
Network.PlayerInfo.UseEnergy(stage_info.Energy);
MapClearDataManager.Instance.SetClearRate(stage_info, 3);
}
public void Init(MapStageDifficulty info)
{
StageInfo = info;
MapCreatureInfo creature = StageInfo.Waves[0].Creatures.Find(c => c.CreatureType == eMapCreatureType.Boss);
short level = CalculateLevel(creature.Level, StageInfo);
m_LevelText.text = level.ToString();
m_ProfileImage.spriteName = string.Format("profile_{0}", creature.CreatureInfo.ID);
m_Condition = StageInfo.CheckCondition;
bool is_lock = m_Condition != null;
m_Level.gameObject.SetActive(!is_lock);
m_Lock.gameObject.SetActive(is_lock);
m_ToggleAvailable.SetSpriteActive(!is_lock);
foreach (UISprite sprite in m_DisableSprite)
{
if (is_lock)
{
sprite.color = m_DisableColor;
}
else
{
sprite.color = Color.white;
}
}
gameObject.SetActive(true);
}
public override void SetParams(bool is_new, object[] parms)
{
base.SetParams(is_new, parms);
m_StageInfo = parms[0] as MapStageDifficulty;
Init();
}
public MapCondition CheckCondition()
{
switch (type)
{
case eMapCondition.MapClear:
{
MapInfo map_info = MapInfoManager.Instance.GetInfoByID(value);
MapStageInfo stage_info = map_info.Stages.Last();
pe_Difficulty difficulty = (pe_Difficulty)Enum.Parse(typeof(pe_Difficulty), value2);
var clear_data = MapClearDataManager.Instance.GetData(stage_info, difficulty);
if (clear_data == null || clear_data.clear_rate == 0)
{
return(this);
}
}
break;
case eMapCondition.MapStageClear:
{
pe_Difficulty difficulty = (pe_Difficulty)Enum.Parse(typeof(pe_Difficulty), value2);
MapStageDifficulty stage_info = MapInfoManager.Instance.GetStageInfoByID(value, difficulty);
var clear_data = MapClearDataManager.Instance.GetData(stage_info);
if (clear_data == null || clear_data.clear_rate == 0)
{
return(this);
}
}
break;
case eMapCondition.Weekly:
DayOfWeek cur_dow = Network.Instance.ServerTime.DayOfWeek;
DayOfWeek set_dow = (DayOfWeek)Enum.Parse(typeof(DayOfWeek), value);
if (cur_dow != set_dow)
{
return(this);
}
break;
case eMapCondition.Period:
DateTime begin_time = DateTime.Parse(value);
DateTime end_time = DateTime.Parse(value2);
if (begin_time > Network.Instance.ServerTime || end_time < Network.Instance.ServerTime)
{
return(this);
}
break;
case eMapCondition.Block:
return(this);
}
return(null);
}
public void OnDifficultChanged(GameObject obj)
{
UIToggle toggle = obj.GetComponentInChildren <UIToggle>();
//Debug.LogFormat("OnDifficultChanged({0}:{1})", obj.name, toggle.value);
if (toggle.value == true)
{
switch (obj.name)
{
case "NormalMap":
{
if (CurrentDifficulty == pe_Difficulty.Normal)
{
return;
}
CurrentDifficulty = pe_Difficulty.Normal;
m_DifficultyToggle.value = false;
}
break;
case "HardMap":
{
if (CurrentDifficulty == pe_Difficulty.Hard)
{
return;
}
if (MapInfo.IDN == 1)
{
var condition = MapInfo.CheckCondition(pe_Difficulty.Hard);
if (condition != null)
{
Tooltip.Instance.ShowMessage(condition.Condition);
m_ToggleDifficultyNormal.value = true;
return;
}
}
CurrentDifficulty = pe_Difficulty.Hard;
m_DifficultyToggle.value = true;
}
break;
}
var last_main_stage = MapClearDataManager.Instance.GetLastMainStage(CurrentDifficulty);
if (last_main_stage == null)
{
m_SelectedMapInfo = MapInfoManager.Instance.Values.First();
m_SelectStageInfo = m_SelectedMapInfo.Stages[0].Difficulty[(int)CurrentDifficulty];
}
else
{
m_SelectedMapInfo = MapInfoManager.Instance.GetInfoByIdn(last_main_stage.map_idn);
m_SelectStageInfo = m_SelectedMapInfo.Stages[last_main_stage.stage_index].Difficulty[(int)CurrentDifficulty];
}
GameMain.Instance.ChangeMenu(GameMenu.Dungeon, null);
}
}
static public short CalculateLevel(short boss_level, MapStageDifficulty stage_info)
{
var clear_data = MapClearDataManager.Instance.GetData(stage_info);
if (clear_data != null)
{
boss_level = (short)(boss_level + clear_data.clear_count);
}
return(boss_level);
}
void OnClickStage(DungeonSpot spot)
{
// SetCharacterPosition(spot.transform.position);
m_SelectStageInfo = spot.StageInfo;
MenuParams parms = new MenuParams();
parms.AddParam <MapStageDifficulty>(spot.StageInfo);
GameMain.Instance.ChangeMenu(GameMenu.DungeonInfo, parms);
}
public void Init(MapStageDifficulty stage_info, System.Action <MapStageDifficulty> callback)
{
m_StageInfo = stage_info;
m_labelTitle.text = stage_info.Name;
m_Toggle.value = false;
m_Toggle.Set(false);
this.callback = callback;
m_SpriteLock.gameObject.SetActive(stage_info.Condition != null && stage_info.Condition.CheckCondition() != null);
}
public bool IsNewClear(MapStageDifficulty stage_info)
{
pd_MapClearData clear_data = GetData(stage_info);
if (clear_data == null)
{
return(true);
}
return(clear_data.clear_count == 0);
}
override public bool Uninit(bool bBack)
{
base.Uninit();
if (bBack)
{
m_SelectedMapInfo = null;
m_SelectStageInfo = null;
}
return(true);
}
public void Init(MapStageDifficulty info, short rating)
{
StageInfo = info;
bool bAvailable = MapClearDataManager.Instance.AvailableStage(StageInfo);
if (bAvailable == false)
{
rating = 0;
}
if (bAvailable == false)
{
m_ToggleAvailable.SetSpriteActive(bAvailable);
}
else
{
if (StageInfo.Difficulty == PacketEnums.pe_Difficulty.Normal)
{
m_ToggleAvailable.spriteName = "dungeon_in_in_on";
}
else
{
m_ToggleAvailable.spriteName = "dungeon_in_in_on_hard";
}
}
gameObject.GetComponent <BoxCollider2D>().enabled = bAvailable;
if (rating <= 0)
{
m_Stars.SetActive(false);
}
else
{
m_Stars.SetActive(true);
for (int i = 0; i < m_ToggleRating.Length; ++i)
{
m_ToggleRating[i].SetSpriteActive(rating > i);
}
}
gameObject.SetActive(true);
if (info.StageType == eStageType.Boss)
{
m_BossParticle.Play();
}
else
{
m_BossParticle.Stop();
}
}
////////////////////////////////////////////////////////////////
override public bool Init(MenuParams parms)
{
m_StageInfo = parms.GetObject <MapStageDifficulty>();
if (m_Heroes != null)
{
m_Heroes.ForEach(e => DestroyImmediate(e.gameObject));
m_Heroes = null;
}
toggle_menus[0].value = true;
Init();
return(true);
}
////////////////////////////////////////////////////////////////
override public bool Init(MenuParams parms)
{
string menu_parm_1 = parms.GetObject <string>("menu_parm_1");
string menu_parm_2 = parms.GetObject <string>("menu_parm_2");
if (string.IsNullOrEmpty(menu_parm_2) == false && string.IsNullOrEmpty(menu_parm_1) == false)
{
CurrentDifficulty = (pe_Difficulty)Enum.Parse(typeof(pe_Difficulty), menu_parm_2);
m_SelectedMapInfo = MapInfoManager.Instance.GetInfoByID(menu_parm_1);
m_SelectStageInfo = m_SelectedMapInfo.Stages[0].Difficulty[(int)CurrentDifficulty];
}
if (Network.LastOpenContentsStageInfo != null)
{
Tooltip.Instance.CheckOpenContentsMapStageClear(Network.LastOpenContentsStageInfo);
Network.LastOpenContentsStageInfo = null;
}
if (Network.NewStageInfo != null)
{
m_SelectStageInfo = Network.NewStageInfo;
m_SelectedMapInfo = m_SelectStageInfo.MapInfo;
Network.NewStageInfo = null;
CurrentDifficulty = m_SelectStageInfo.Difficulty;
}
else if (m_SelectStageInfo == null)
{
var last_main_stage = MapClearDataManager.Instance.GetLastMainStage();
if (last_main_stage == null)
{
CurrentDifficulty = pe_Difficulty.Normal;
m_SelectedMapInfo = MapInfoManager.Instance.Values.First();
m_SelectStageInfo = m_SelectedMapInfo.Stages[0].Difficulty[(int)pe_Difficulty.Normal];
}
else
{
m_SelectedMapInfo = MapInfoManager.Instance.GetInfoByIdn(last_main_stage.map_idn);
m_SelectStageInfo = m_SelectedMapInfo.Stages[last_main_stage.stage_index].Difficulty[(int)last_main_stage.difficulty];
CurrentDifficulty = m_SelectStageInfo.Difficulty;
}
}
m_ToggleDifficultyNormal.value = CurrentDifficulty == pe_Difficulty.Normal;
m_ToggleDifficultyHard.value = CurrentDifficulty == pe_Difficulty.Hard;
m_DifficultyToggle.value = CurrentDifficulty == pe_Difficulty.Hard;
Init();
return(true);
}
public CutSceneInfo(XmlNode node)
{
XmlAttribute scene_type_attr = node.Attributes["scene_type"];
if (scene_type_attr != null)
{
SceneType = (eSceneType)Enum.Parse(typeof(eSceneType), scene_type_attr.Value);
map_id = node.Attributes["map_id"].Value;
stage_index = int.Parse(node.Attributes["stage_index"].Value);
StageInfo = MapInfoManager.Instance.GetInfoByID(map_id).Stages[stage_index].Difficulty[0];
}
else
{
SceneType = eSceneType.None;
}
}
public bool AvailableStage(MapStageDifficulty info)
{
if (info.MapInfo.CheckCondition(info.Difficulty) != null)
{
return(false);
}
int map_idn = info.MapInfo.IDN;
int stage_index = info.StageIndex;
pd_MapClearData clear_data = GetData(info);
if (clear_data != null)
{
return(true);
}
if (map_idn == 1 && stage_index == 0)
{
return(true);
}
if (stage_index == 0)
{
if (MapInfoManager.Instance.ContainsIdn(map_idn - 1))
{
MapInfo map_info = MapInfoManager.Instance.GetInfoByIdn(map_idn - 1);
clear_data = GetData(map_info.Stages.Last(), info.Difficulty);
if (clear_data != null && clear_data.clear_count > 0)
{
return(true);
}
}
}
if (stage_index != 0)
{
clear_data = GetData(map_idn, stage_index - 1, info.Difficulty);
if (clear_data != null && clear_data.clear_count > 0)
{
return(true);
}
}
return(false);
}
public MapStageDifficulty GetNextStageInfo(MapStageDifficulty stage_info)
{
var map_info = stage_info.MapInfo;
if (map_info.MapType == "boss")
{
return(null);
}
MapStageDifficulty next_stage_info = null;
if (map_info.MapType == "weekly")
{
if ((int)stage_info.Difficulty < stage_info.StageInfo.Difficulty.Count - 1)
{
next_stage_info = stage_info.StageInfo.Difficulty[(int)stage_info.Difficulty + 1];
}
}
else
{
if (stage_info.StageInfo.StageIndex >= map_info.Stages.Count - 1)
{
if (map_info.MapType == "main")
{
// next map
if (ContainsIdn(map_info.IDN + 1))
{
var next_map_info = GetInfoByIdn(map_info.IDN + 1);
next_stage_info = next_map_info.Stages[0].Difficulty[(int)stage_info.Difficulty];
}
}
}
else
{
next_stage_info = map_info.Stages[stage_info.StageInfo.StageIndex + 1].Difficulty[(int)stage_info.Difficulty];
}
}
return(next_stage_info);
}
public void SetStage(MapStageDifficulty stage_info)
{
m_StageInfo = stage_info;
LabelTitle.text = m_StageInfo.ShowName;
LabelDungeonInfo.text = m_StageInfo.Description;
RewardItemPrefab.Destroy();
foreach (var reward in m_StageInfo.DropItems)
{
if (reward.IsShow == false)
{
continue;
}
var reward_item = RewardItemPrefab.GetNewObject <RewardItem>(GridRewards.transform, Vector3.zero);
reward_item.InitReward(reward);
}
GridRewards.Reposition();
ScrollViewRewards.ResetPosition();
}
public void SetConditionText()
{
switch (type)
{
case eMapCondition.MapClear:
case eMapCondition.MapStageClear:
{
switch (type)
{
case eMapCondition.MapClear:
{
MapInfo map_info = MapInfoManager.Instance.GetInfoByID(value);
pe_Difficulty show_difficulty = (pe_Difficulty)Enum.Parse(typeof(pe_Difficulty), value2);
Condition = Localization.Format("StageConditionMapClear", map_info.GetShowName(show_difficulty));
}
break;
case eMapCondition.MapStageClear:
{
pe_Difficulty show_difficulty = (pe_Difficulty)Enum.Parse(typeof(pe_Difficulty), value2);
MapStageDifficulty stage_info = MapInfoManager.Instance.GetStageInfoByID(value, show_difficulty);
Condition = Localization.Format("StageConditionMapStageClear", stage_info.ShowName);
}
break;
}
}
break;
case eMapCondition.Block:
{
Condition = Localization.Get(value);
}
break;
}
}
public void CheckOpenContentsMapStageClear(MapStageDifficulty map_stage_info)
{
if (Tutorial.Instance.Completed == false)
{
return;
}
List <ContentsOpenInfo> opens = new List <ContentsOpenInfo>();
pe_Difficulty difficulty = map_stage_info.Difficulty;
if (map_stage_info.MapInfo.Stages[map_stage_info.MapInfo.Stages.Count - 1].Difficulty[(int)difficulty] == map_stage_info)
{
// map clear
MapInfoManager.Instance.CheckOpenContents(ref opens, eMapCondition.MapClear, map_stage_info.MapInfo.ID, difficulty.ToString());
}
// map stage clear
MapInfoManager.Instance.CheckOpenContents(ref opens, eMapCondition.MapStageClear, map_stage_info.ID, difficulty.ToString());
if (opens.Count > 0)
{
ShowTooltip(eTooltipMode.OpenContents, opens);
}
}
public void Init(bool back)
{
m_EventInfo = EventHottimeManager.Instance.GetInfoByID("worldboss", true);
if (m_EventInfo != null && (m_EventInfo.state == PacketInfo.pe_EventHottimeState.Hottime || m_EventInfo.state == PacketInfo.pe_EventHottimeState.WaitingHottime))
{
var map_info = MapInfoManager.Instance.GetInfoByIdn(m_EventInfo.Value);
if (map_info != null)
{
m_MapStageInfo = map_info.Stages[0].Difficulty[0];
var world_boss_info = m_MapStageInfo.Waves[0].Creatures.Find(c => c.CreatureType == eMapCreatureType.WorldBoss);
if (world_boss_info != null)
{
CharacterContainer.transform.parent.gameObject.SetActive(true);
CharacterContainer.Init(AssetManager.GetCharacterAsset(world_boss_info.CreatureInfo.ID, "default"), UICharacterContainer.Mode.UI_Normal, m_EventInfo.state == PacketInfo.pe_EventHottimeState.Hottime ? "idle" : "disabled", true);
LabelTitle.text = world_boss_info.CreatureInfo.Name;
}
}
}
foreach (CreatureInfo hero in m_MapStageInfo.Recommends)
{
var item = RecommendPrefabManager.GetNewObject <DungeonHeroRecommend>(RecommendGrid.transform, Vector3.zero);
item.Init(hero);
}
RecommendGrid.Reposition();
BestScoreLabel.text = Localization.Format("WorldBossBest", "-");
CurrentRankLabel.text = Localization.Format("WorldBossRank", "-");
TryCountLabel.text = Localization.Format("WorldBossTry", m_MapStageInfo.MapInfo.TryLimit - MapClearDataManager.Instance.GetMapDailyClearCount(m_MapStageInfo.MapInfo.IDN, PacketEnums.pe_Difficulty.Normal), m_MapStageInfo.MapInfo.TryLimit);
RefreshInfo();
Update();
Network.GameServer.JsonAsync <C2G.GetWorldBossInfo, C2G.GetWorldBossInfoAck>(new C2G.GetWorldBossInfo(), OnGetWorldBossInfo);
}
public bool SetClearRate(MapStageDifficulty stage_info, short clear_rate)
{
return(SetClearRate(stage_info.MapInfo.IDN, stage_info.StageIndex, clear_rate, stage_info.Difficulty));
}
static string m_BGMName = ""; //背景因为的名字
void ChangeBG(MenuInfo menu, int up_count = 0) //切换背景
{
string spriteName = "";
switch (menu.menu)
{
case GameMenu.MainMenu:
m_BGMName = "Main";
break;
case GameMenu.Boss:
case GameMenu.Dungeon:
case GameMenu.PVP:
m_BGMName = "Adventure";
break;
}
SoundManager.Instance.PlayBGM(m_BGMName); //播放背景音乐
switch (menu.menu)
{
case GameMenu.MainMenu:
spriteName = "000_main";
m_BG.material.SetColor("_GrayColor", colorZero);
break;
case GameMenu.HeroInfoDetail:
spriteName = "000_heroinfo";
m_BG.material.SetColor("_GrayColor", colorZero);
break;
case GameMenu.Dungeon:
spriteName = menu.GetComponent <Dungeon>().MapInfo.ID + "_map";
break;
case GameMenu.DungeonInfo:
{
MapStageDifficulty stage_info = menu.GetComponent <DungeonInfoMenu>().StageInfo;
if (stage_info.MapInfo.MapType == "boss")
{
spriteName = stage_info.BG_ID + "_D";
}
else
{
ChangeBG(GetParentMenu(up_count + 1), up_count + 1);
}
}
break;
case GameMenu.WorldBossInfo:
ChangeBG(GetParentMenu(up_count + 1), up_count + 1);
break;
case GameMenu.PVP:
case GameMenu.PVPDeckInfo:
spriteName = "000_pvp";
m_BG.material.SetColor("_GrayColor", colorZero);
break;
case GameMenu.HeroesEval:
spriteName = "000_hero_loot";
m_BG.material.SetColor("_GrayColor", colorZero);
break;
case GameMenu.Inventory:
case GameMenu.HeroesInfo:
case GameMenu.Mission:
case GameMenu.Store:
ChangeBG(GetParentMenu(up_count + 1), up_count + 1);
return;
case GameMenu.Boss:
spriteName = "000_boss_map";
m_BG.material.SetColor("_GrayColor", colorZero);
break;
case GameMenu.Training:
spriteName = "000_training";
m_BG.material.SetColor("_GrayColor", colorZero);
break;
case GameMenu.Community:
case GameMenu.Friends:
spriteName = "000_community";
m_BG.material.SetColor("_GrayColor", colorZero);
break;
}
if (string.IsNullOrEmpty(spriteName) == false)
{
Texture2D sp = AssetManager.LoadBG(spriteName);
m_BG.material.mainTexture = sp;
if (sp != null)
{
if (spriteName == "000_main")
{
if (m_BGAdd.material.mainTexture == null)
{
m_BGAdd.material.mainTexture = AssetManager.LoadBG(spriteName + "_add");
}
m_BGAdd.gameObject.SetActive(true);
}
else
{
m_BGAdd.gameObject.SetActive(false);
}
}
}
}
public BattleCreature(MapCreatureInfo map_creature_info, CharacterContainer character_container, float attack_next_time, GameObject hpBarPrefab, GameObject skillPrefab)
{
MapStageDifficulty stage_info = Network.BattleStageInfo;
IsTeam = false;
Info = map_creature_info.CreatureInfo;
SkinName = map_creature_info.SkinName;
MapCreature = map_creature_info;
Grade = map_creature_info.Grade;
Level = map_creature_info.Level;
GradePercent = map_creature_info.GradePercent;
Enchant = map_creature_info.Enchant;
if (map_creature_info.UseLeaderSkillType != pe_UseLeaderSkillType.Manual && Info.TeamSkill != null)
{
SetLeader(map_creature_info.UseLeaderSkillType, BattleStage.Instance.OnUseEnemyLeaderSkill);
}
switch (map_creature_info.CreatureType)
{
case eMapCreatureType.Elite:
Scale = 1.2f;
break;
case eMapCreatureType.Boss:
Scale = 1.4f;
if (stage_info.MapInfo.MapType == "boss")
{
Level = Boss.CalculateLevel(Level, stage_info);
Grade = Boss.CalculateGrade(Level);
Enchant = Boss.CalculateEnchant(Level);
GradePercent = CreatureInfoManager.Instance.Grades[Grade].enchants[Enchant].stat_percent * GameConfig.Get <float>("boss_grade_percent");
}
Battle.Instance.m_BossHP.Init(this);
break;
case eMapCreatureType.WorldBoss:
Scale = 2.5f;
BattleWorldboss.Instance.m_BossHP.Init(this, true);
IgnoreTween = true;
TextOffset = -20f;
// IsShowText = false;
break;
}
Stat = new CreatureStat(map_creature_info.GetStat(Level, GradePercent, Enchant));
AutoSkillIndex = map_creature_info.AutoSkillIndex;
InitCommon(character_container, attack_next_time, hpBarPrefab, skillPrefab);
if (map_creature_info.CreatureType == eMapCreatureType.WorldBoss)
{
HPBar.gameObject.SetActive(false);
}
foreach (SkillInfo skill_info in Info.Skills)
{
if (skill_info.Type != eSkillType.active)
{
continue;
}
Skills.Add(new BattleSkill(skill_info, this, map_creature_info.Level));
}
if (map_creature_info.PassiveInfos.Count > 0)
{
foreach (var passive_info in map_creature_info.PassiveInfos)
{
bool first = true;
var battle_skill = new BattleSkill(passive_info.SkillInfo, this, map_creature_info.Level);
foreach (var action in passive_info.SkillInfo.Actions)
{
ISkillBuff buff = SkillTarget.DoBuff(action, this, this, battle_skill, 0, null);
if (first == true && string.IsNullOrEmpty(passive_info.SkillInfo.ActionName) == false)
{
first = false;
var comp = AssetManager.GetCharacterPrefab("PassiveEtc_" + passive_info.SkillInfo.ActionName).GetComponent <CharacterActionBuffComponent>();
// comp.data.InitEffect();
CharacterActionBuff new_action = comp.data.CreateAction(comp, PlaybackTime, Character, 999f, false, 1f);
buff.Action = new_action;
}
}
}
var buff_worldboss = Buffs.Find(b => b.ActionInfo.actionType == eActionType.worldboss);
if (buff_worldboss != null)
{
Stat.HP = Stat.MaxHP = buff_worldboss.ActionInfo.value;
}
else
{
Stat.HP = Stat.MaxHP = Stat.Stat.MaxHP;
}
Stat.MP = Stat.Stat.ManaInit;
}
}
public TutorialInfo GetCutScene(eSceneType scene, MapStageDifficulty stage_info)
{
return(CutScenes.Find(e => (e as TutorialInfo).CutSceneInfo != null && (e as TutorialInfo).CutSceneInfo.StageInfo == stage_info &&
(e as TutorialInfo).CutSceneInfo.SceneType == scene) as TutorialInfo);
}
