public void StartCampaignProgress()
{
string uid = "";
FactionType faction = this.player.Faction;
if (faction != FactionType.Empire)
{
if (faction == FactionType.Rebel)
{
uid = GameConstants.NEW_PLAYER_INITIAL_MISSION_REBEL;
}
}
else
{
uid = GameConstants.NEW_PLAYER_INITIAL_MISSION_EMPIRE;
}
CampaignMissionVO missionType = Service.Get <IDataController>().Get <CampaignMissionVO>(uid);
this.UnlockMission(missionType);
}
private void UnlockNextMission(CampaignMissionVO missionType)
{
CampaignVO campaignVO = this.sdc.Get <CampaignVO>(missionType.CampaignUid);
CampaignVO campaignVO2 = null;
CampaignMissionVO campaignMissionVO = null;
CampaignMissionVO campaignMissionVO2 = null;
foreach (CampaignVO current in this.sdc.GetAll <CampaignVO>())
{
if (current.UnlockOrder == campaignVO.UnlockOrder + 1 && current.Faction == campaignVO.Faction)
{
campaignVO2 = current;
break;
}
}
foreach (CampaignMissionVO current2 in this.sdc.GetAll <CampaignMissionVO>())
{
if (campaignVO2 != null && current2.CampaignUid == campaignVO2.Uid && current2.UnlockOrder == 1)
{
campaignMissionVO2 = current2;
}
if (current2.CampaignUid == missionType.CampaignUid && current2.UnlockOrder == missionType.UnlockOrder + 1)
{
campaignMissionVO = current2;
break;
}
}
if (campaignMissionVO != null)
{
Service.Get <StaRTSLogger>().Debug("Unlocking next mission in current campaign!");
this.UnlockMission(campaignMissionVO);
return;
}
if (campaignMissionVO2 != null)
{
Service.Get <StaRTSLogger>().Debug("Unlocking first mission in next campaign!");
this.UnlockMission(campaignMissionVO2);
return;
}
Service.Get <StaRTSLogger>().Debug("All missions for all campaigns are unlocked!");
}
public int GetTotalAttackDefendCampaignStarsEarned(CampaignVO campaignType)
{
if (!this.campaigns.ContainsKey(campaignType.Uid))
{
return(0);
}
int num = 0;
foreach (Mission current in this.missions.Values)
{
if (current.CampaignUid == campaignType.Uid)
{
CampaignMissionVO campaignMissionVO = Service.Get <IDataController>().Get <CampaignMissionVO>(current.Uid);
if (campaignMissionVO.MissionType == MissionType.Attack || campaignMissionVO.MissionType == MissionType.Defend)
{
num += current.EarnedStars;
}
}
}
return(num);
}
public bool CompleteMission(CampaignMissionVO vo, int starsEarned)
{
if (vo.Uid != null && this.missions.ContainsKey(vo.Uid))
{
Mission mission = this.missions[vo.Uid];
int earnedStars = mission.EarnedStars;
if (starsEarned > earnedStars)
{
float[] array = this.starsToPortion;
if (vo.StarsToPortion != null)
{
array = vo.StarsToPortion;
}
if (!vo.Grind)
{
mission.EarnedStars = starsEarned;
}
int campaignPoints = vo.CampaignPoints;
if (campaignPoints > 0)
{
int num = (int)(array[earnedStars] * (float)campaignPoints);
int num2 = (int)(array[starsEarned] * (float)campaignPoints);
uint num3 = (uint)(num2 - num);
if (this.campaigns.ContainsKey(vo.CampaignUid))
{
this.campaigns[vo.CampaignUid].Points += num3;
}
CurrentBattle currentBattle = Service.Get <BattleController>().GetCurrentBattle();
currentBattle.CampaignPointsEarn = num3;
}
Service.Get <AchievementController>().TryUnlockAchievementByValue(AchievementType.PveStars, this.GetTotalCampaignStarsEarnedInAllCampaigns());
}
if (!mission.Completed)
{
mission.Completed = true;
return(true);
}
}
return(false);
}
public int RemainingCampaignPointsForMission(CampaignMissionVO vo)
{
if (this.missions.ContainsKey(vo.Uid))
{
float[] array = this.starsToPortion;
if (vo.StarsToPortion != null)
{
array = vo.StarsToPortion;
}
int earnedStars = this.missions[vo.Uid].EarnedStars;
int campaignPoints = vo.CampaignPoints;
if (campaignPoints > 0)
{
int num = campaignPoints - (int)(array[earnedStars] * (float)campaignPoints);
if (num > 0)
{
return(num);
}
return(0);
}
}
return(vo.CampaignPoints);
}
public void GetMissionProgress(CampaignMissionVO mission, out int current, out int total)
{
if (!this.missions.ContainsKey(mission.Uid))
{
current = 0;
total = 1;
}
current = 0;
total = 0;
for (int i = 0; i < mission.Conditions.Count; i++)
{
Dictionary <string, int> counters = this.missions[mission.Uid].Counters;
ConditionVO conditionVO = mission.Conditions[i];
int startingValue = (counters != null && counters.ContainsKey(conditionVO.Uid)) ? counters[conditionVO.Uid] : 0;
AbstractCondition abstractCondition = ConditionFactory.GenerateCondition(conditionVO, null, startingValue);
int num;
int num2;
abstractCondition.GetProgress(out num, out num2);
current += num;
total += num2;
abstractCondition.Destroy();
}
}
private void UnlockMission(CampaignMissionVO missionType)
{
if (!this.progress.IsMissionLocked(missionType))
{
Service.Logger.Error("Unexpected attempt to add a mission that is already unlocked!");
return;
}
Mission mission = Mission.CreateFromCampaignMissionVO(missionType);
this.newChapterMissionFlag = true;
this.UpdateMissionsViewedPref(0);
this.progress.AddMission(missionType.Uid, mission);
if (missionType.UnlockOrder == 1 && !this.progress.Campaigns.ContainsKey(missionType.CampaignUid))
{
Campaign campaign = new Campaign();
campaign.Uid = missionType.CampaignUid;
campaign.Completed = false;
campaign.Points = 0u;
campaign.TimeZone = (float)Service.EnvironmentController.GetTimezoneOffset();
this.progress.AddCampaign(missionType.CampaignUid, campaign);
}
Service.EventManager.SendEvent(EventId.MissionUnlocked, missionType);
}
public void EndEncounter()
{
if (!this.activeDefenseBattle)
{
return;
}
this.eventManager.UnregisterObserver(this, EventId.EntityKilled);
if (this.currentMission.IsRaidDefense())
{
Service.RaidDefenseController.OnEndRaidDefenseMission(this.waves[this.currentWaveIndex].Encounter.Uid);
}
this.currentMission = null;
this.activeDefenseBattle = false;
this.currentCameraEvent = null;
for (int i = 0; i < this.timers.Count; i++)
{
this.timerManager.KillSimTimer(this.timers[i]);
}
this.timers.Clear();
this.cameraEvents.Clear();
this.numTimesEntityHit.Clear();
this.UnRegisterObservers();
Service.CurrentPlayer.DamagedBuildings = Service.BattleController.GetBuildingDamageMap();
}
public int GetMissionLootContrabandRemaining(CampaignMissionVO missionType)
{
return(this.GetMissionLootCurrencyRemaining(CurrencyType.Contraband, missionType));
}
public int GetMissionLootCreditsRemaining(CampaignMissionVO missionType)
{
return(this.GetMissionLootCurrencyRemaining(CurrencyType.Credits, missionType));
}
public int GetMissionLootMaterialsRemaining(CampaignMissionVO missionType)
{
return(this.GetMissionLootCurrencyRemaining(CurrencyType.Materials, missionType));
}
public void EraseMissionCheat(CampaignMissionVO missionType)
{
this.progress.EraseMission(missionType);
}
public void UnlockMissionCheat(CampaignMissionVO missionType)
{
this.UnlockMission(missionType);
}
public bool IsMissionCollected(CampaignMissionVO missionType)
{
return(this.missions.ContainsKey(missionType.Uid) && this.missions[missionType.Uid].Collected);
}
public static BattleInitializationData CreateBuffBaseBattleFromCampaignMissionVO(CampaignMissionVO vo, SquadWarBuffBaseData buffBaseData)
{
StaticDataController staticDataController = Service.StaticDataController;
BattleInitializationData battleInitializationData = BattleInitializationData.CreateBuffBaseBattleFromBattleTypeVO(vo.Map, buffBaseData);
battleInitializationData.MissionUid = vo.Uid;
battleInitializationData.BattleMusic = vo.BattleMusic;
battleInitializationData.AmbientMusic = vo.AmbientMusic;
battleInitializationData.VictoryConditions = vo.Conditions;
if (!string.IsNullOrEmpty(vo.FailureCondition))
{
battleInitializationData.FailureCondition = staticDataController.Get <ConditionVO>(vo.FailureCondition);
}
return(battleInitializationData);
}
public static string GetMissionDescription(CampaignMissionVO missionType)
{
return(Service.Get <Lang>().Get("mis_desc_" + missionType.Uid, new object[0]));
}
public Dictionary <string, int> GetMissionCounters(CampaignMissionVO missionType)
{
return((!this.missions.ContainsKey(missionType.Uid)) ? null : this.missions[missionType.Uid].Counters);
}
public void StartDefenseMissionAfterPreload(object cookie)
{
CampaignMissionVO mission = (CampaignMissionVO)cookie;
this.StartDefenseMission(mission);
}
public static AbstractMissionProcessor CreateProcessor(MissionConductor mission, CampaignMissionVO vo)
{
switch (vo.MissionType)
{
case MissionType.Attack:
return(new OffensiveCombatMissionProcessor(mission));
case MissionType.Defend:
case MissionType.RaidDefend:
return(new DefensiveCombatMissionProcessor(mission));
case MissionType.Own:
return(new OwnMissionProcessor(mission));
case MissionType.Event:
return(new MultiCombatEventMissionProcessor(mission));
case MissionType.Pvp:
return(new PvpStarsMissionProcessor(mission));
}
return(new AbstractMissionProcessor(mission));
}
private void OnMissionCompleted(CampaignMissionVO completedMission)
{
this.UpdateMissionItem(this.selectedMission.Uid, this.selectedMission, true);
this.InitMissionDetailGroup();
this.InitMissionGrid();
}
private void UpdateMissionItem(string itemUid, CampaignMissionVO missionType, bool selected)
{
UXSprite uXSprite = (!this.selectedCampaign.IsMiniCampaign()) ? this.missionGrid.GetSubElement <UXSprite>(itemUid, "SpriteObjectiveImage") : null;
if (uXSprite != null)
{
if (missionType.Grind)
{
uXSprite.SpriteName = "icoRecBattle";
}
else if (missionType.IsChallengeMission())
{
uXSprite.SpriteName = "IcoMissions";
}
else if (missionType.IsCombatMission())
{
uXSprite.SpriteName = ((missionType.MissionType != MissionType.Attack) ? "icoDefend" : "IcoAttack");
}
else if (missionType.HasPvpCondition() || missionType.MissionType == MissionType.Pvp)
{
uXSprite.SpriteName = "IcoWar";
}
else
{
uXSprite.SpriteName = "IcoBuild";
}
}
UXCheckbox uXCheckbox = (!this.selectedCampaign.IsMiniCampaign()) ? this.missionGrid.GetSubElement <UXCheckbox>(itemUid, "ButtonObjectiveCard") : this.missionGrid.GetSubElement <UXCheckbox>(itemUid, "ButtonObjectiveCardDifficulty");
uXCheckbox.Tag = missionType;
uXCheckbox.OnSelected = new UXCheckboxSelectedDelegate(this.OnMissionItemSelected);
uXCheckbox.Selected = selected;
uXCheckbox.RadioGroup = 0;
if (this.selectedCampaign.IsMiniCampaign())
{
UXLabel subElement = this.missionGrid.GetSubElement <UXLabel>(itemUid, "LabelDifficulty");
subElement.Text = LangUtils.GetMissionDifficultyLabel(itemUid);
uXCheckbox.Visible = !base.Player.CampaignProgress.IsMissionLocked(missionType);
return;
}
UXLabel subElement2 = this.missionGrid.GetSubElement <UXLabel>(itemUid, "LabelObjectiveNumber");
subElement2.Text = missionType.UnlockOrder.ToString();
UXSprite subElement3 = this.missionGrid.GetSubElement <UXSprite>(itemUid, "SpriteMissionCheck");
UXSprite subElement4 = this.missionGrid.GetSubElement <UXSprite>(itemUid, "SpriteIcoMissionLocked");
UXElement subElement5 = this.missionGrid.GetSubElement <UXElement>(itemUid, "ObjectiveStars");
UXSlider subElement6 = this.missionGrid.GetSubElement <UXSlider>(itemUid, "MissionSelectPbar");
if (base.Player.CampaignProgress.IsMissionInProgress(missionType) && missionType.MissionType != MissionType.Pvp)
{
int num;
int num2;
base.Player.CampaignProgress.GetMissionProgress(missionType, out num, out num2);
subElement6.Value = (float)num / (float)num2;
}
else
{
subElement6.Visible = false;
}
if (base.Player.CampaignProgress.IsMissionLocked(missionType))
{
uXCheckbox.Enabled = false;
uXSprite.Visible = false;
subElement3.Visible = false;
subElement5.Visible = false;
subElement6.Visible = false;
subElement4.Visible = true;
return;
}
subElement4.Visible = false;
subElement5.Visible = true;
int missionEarnedStars = base.Player.CampaignProgress.GetMissionEarnedStars(missionType);
for (int i = 1; i <= missionEarnedStars; i++)
{
UXSprite subElement7 = this.missionGrid.GetSubElement <UXSprite>(itemUid, "SpriteStar" + i);
subElement7.SpriteName = "CampaignStarOn";
}
if (missionType.Grind && base.Player.CampaignProgress.IsGrindComplete(missionType))
{
subElement3.Visible = true;
uXSprite.Visible = false;
}
else if (base.Player.CampaignProgress.IsMissionCompleted(missionType))
{
if (base.Player.CampaignProgress.IsMissionCollected(missionType))
{
subElement3.Visible = true;
uXSprite.Visible = false;
}
else
{
uXSprite.Visible = true;
subElement3.Visible = false;
}
}
else
{
subElement3.Visible = false;
}
}
private void InitMissionGrid()
{
CampaignMissionVO campaignMissionVO = null;
List <CampaignMissionVO> list = new List <CampaignMissionVO>();
foreach (CampaignMissionVO current in base.Sdc.GetAll <CampaignMissionVO>())
{
if (current.CampaignUid == this.selectedCampaign.Uid)
{
list.Add(current);
}
}
List <CampaignMissionVO> arg_85_0 = list;
if (PlanetDetailsMissionViewModule.< > f__mg$cache0 == null)
{
PlanetDetailsMissionViewModule.< > f__mg$cache0 = new Comparison <CampaignMissionVO>(PlanetDetailsMissionViewModule.CompareMissions);
}
arg_85_0.Sort(PlanetDetailsMissionViewModule.< > f__mg$cache0);
if (this.selectedCampaign.IsMiniCampaign())
{
this.missionGrid = this.screen.GetElement <UXGrid>("ObjectiveGridDifficulty");
this.missionGrid.SetTemplateItem("ObjectiveTemplateDifficulty");
this.screen.GetElement <UXGrid>("ObjectiveGrid").Visible = false;
}
else
{
this.missionGrid = this.screen.GetElement <UXGrid>("ObjectiveGrid");
this.missionGrid.SetTemplateItem("ObjectiveTemplate");
this.screen.GetElement <UXGrid>("ObjectiveGridDifficulty").Visible = false;
}
this.missionGrid.Clear();
int i = 0;
int count = list.Count;
while (i < count)
{
CampaignMissionVO campaignMissionVO2 = list[i];
string uid = campaignMissionVO2.Uid;
UXElement uXElement = this.missionGrid.CloneTemplateItem(uid);
this.missionGrid.AddItem(uXElement, i);
this.UpdateMissionItem(uid, campaignMissionVO2, false);
uXElement.Tag = campaignMissionVO2;
if (!base.Player.CampaignProgress.IsMissionLocked(campaignMissionVO2) && (campaignMissionVO == null || campaignMissionVO2.UnlockOrder > campaignMissionVO.UnlockOrder))
{
campaignMissionVO = campaignMissionVO2;
}
i++;
}
this.missionGrid.RepositionItems();
int j = 0;
int count2 = this.missionGrid.Count;
while (j < count2)
{
if (campaignMissionVO == (CampaignMissionVO)this.missionGrid.GetItem(j).Tag)
{
this.missionSelectIndexOnFrameDelay = j;
Service.ViewTimeEngine.RegisterFrameTimeObserver(this);
break;
}
j++;
}
this.InitMissionDetailGroup();
}
public Dictionary <string, int> GetCounters(CampaignMissionVO missionType)
{
return(this.progress.GetMissionCounters(missionType));
}
public bool CanReplay(CampaignMissionVO missionType)
{
return(missionType.Replayable || missionType.Grind || this.GetMissionEarnedStars(missionType) < missionType.MasteryStars);
}
public bool IsMissionLocked(CampaignMissionVO missionType)
{
return(!this.missions.ContainsKey(missionType.Uid) || this.missions[missionType.Uid].Locked);
}
public static string GetMissionTitle(CampaignMissionVO missionType)
{
return(Service.Get <Lang>().Get("mis_title_" + missionType.Uid, new object[0]));
}
protected override void SetupView()
{
base.GetElement <UXElement>("BattleResults").Visible = !this.isNonAttackerReplayView;
base.GetElement <UXElement>("ReplayResults").Visible = this.isNonAttackerReplayView;
BattleEntry battleEntry;
BattleType battleType;
if (this.isReplay)
{
battleEntry = Service.BattlePlaybackController.CurrentBattleEntry;
battleType = BattleType.Pvp;
}
else
{
CurrentBattle currentBattle = Service.BattleController.GetCurrentBattle();
battleEntry = currentBattle;
battleType = currentBattle.Type;
}
if (battleEntry == null)
{
Service.Logger.Error("Last battle is null");
return;
}
this.resultLabel.Text = ((!battleEntry.Won) ? this.lang.Get("DEFEAT", new object[0]) : this.lang.Get("VICTORY", new object[0]));
this.resultLabel.Visible = !this.isNonAttackerReplayView;
UXLabel element = base.GetElement <UXLabel>("LabelMissionResult");
if (battleEntry.FailedConditionUid != null)
{
this.resultLabel.Text = string.Empty;
this.resultFailureTitleLabel.Text = this.lang.Get("DEFEAT", new object[0]);
CampaignMissionVO mission = Service.StaticDataController.Get <CampaignMissionVO>(battleEntry.MissionId);
element.Text = LangUtils.GetMissionFailureMessage(mission);
}
else
{
this.resultFailureTitleLabel.Text = string.Empty;
element.Text = string.Empty;
}
this.percentLabel.Text = this.lang.Get("PERCENTAGE", new object[]
{
battleEntry.DamagePercent
});
bool flag = battleType == BattleType.Pvp;
bool flag2 = battleEntry.IsSpecOps();
this.attackMedalsLabel.Visible = flag;
this.defendMedalsLabel.Visible = flag;
this.attackMedalsIcon.Visible = flag;
this.defendMedalsIcon.Visible = flag;
if (this.seizedTable != null)
{
this.seizedTable.Clear();
}
CurrentPlayer currentPlayer = Service.CurrentPlayer;
BattleParticipant attacker = battleEntry.Attacker;
BattleParticipant defender = battleEntry.Defender;
bool flag3 = flag && attacker.TournamentRatingDelta != 0;
if (flag)
{
this.attackMedalsLabel.Text = this.CalculateMedalsGained(attacker).ToString();
this.defendMedalsLabel.Text = this.CalculateMedalsGained(defender).ToString();
bool flag4 = currentPlayer.PlayerId == attacker.PlayerId || battleEntry.SharerPlayerId == attacker.PlayerId;
this.AddSeizedItem("icoMedal", (!flag4) ? this.defendMedalsLabel.Text : this.attackMedalsLabel.Text, 6);
if (flag3)
{
this.AddSeizedItem(GameUtils.GetTournamentPointIconName(battleEntry.PlanetId), attacker.TournamentRatingDelta.ToString(), 7);
}
}
switch (battleType)
{
case BattleType.Pvp:
case BattleType.PveAttack:
case BattleType.PveFue:
case BattleType.ClientBattle:
this.AddSeizedItem("icoCollectCredit", this.lang.ThousandsSeparated(battleEntry.LootCreditsEarned), 1);
this.AddSeizedItem("icoMaterials", this.lang.ThousandsSeparated(battleEntry.LootMaterialsEarned), 2);
if (this.ShouldShowContrabandLoot(currentPlayer, battleType, battleEntry))
{
this.AddSeizedItem("icoContraband", this.lang.ThousandsSeparated(battleEntry.LootContrabandEarned), 3);
}
this.troopsLabel.Text = this.lang.Get("EXPENDED", new object[0]);
break;
case BattleType.PveDefend:
this.troopsLabel.Text = this.lang.Get("ATTACKED_BY", new object[0]);
this.seizedLabel.Visible = false;
break;
}
if (flag2)
{
if (battleType == BattleType.PveDefend)
{
this.AddSeizedItem("icoCampaignPoints", this.lang.Get("CAMPAIGN_POINTS", new object[]
{
this.lang.ThousandsSeparated((int)battleEntry.CampaignPointsEarn)
}), 5);
}
else
{
this.AddSeizedItem("icoCampaignPoints", this.lang.Get("CAMPAIGN_POINTS", new object[]
{
this.lang.ThousandsSeparated((int)battleEntry.CampaignPointsEarn)
}), 5);
}
}
if (this.seizedTable != null)
{
this.seizedTable.RepositionItemsFrameDelayed(new UXDragDelegate(this.OnSeizedRepositioned));
}
if (this.isNonAttackerReplayView)
{
this.SetupNonAttackerReplayView(battleEntry, attacker, defender, flag3);
}
else if (battleEntry.Won)
{
base.AnimateStars(battleEntry.EarnedStars);
}
base.InitTroopGrid("TroopsExpendedGrid", "TroopsExpendedTemplate", battleEntry);
this.troopsLabel.Visible = (this.troopGrid.Count > 0);
this.replayBattleButton.Visible = battleEntry.AllowReplay;
}
public static BattleInitializationData CreateFromDefensiveCampaignMissionVO(CampaignMissionVO vo)
{
StaticDataController staticDataController = Service.StaticDataController;
string uid = vo.Uid;
BattleInitializationData battleInitializationData = new BattleInitializationData();
CurrentPlayer currentPlayer = Service.CurrentPlayer;
battleInitializationData.Attacker = new BattleParticipant(vo.OpponentName, vo.OpponentName, FactionType.Invalid);
battleInitializationData.Defender = new BattleParticipant(currentPlayer.PlayerId, currentPlayer.PlayerName, currentPlayer.Faction);
battleInitializationData.PlanetId = currentPlayer.Map.Planet.Uid;
battleInitializationData.BattleType = BattleType.PveDefend;
battleInitializationData.MissionUid = vo.Uid;
BattleDeploymentData battleDeploymentData = new BattleDeploymentData();
battleDeploymentData.TroopData = new Dictionary <string, int>();
List <DefenseWave> list = DefensiveBattleController.ParseWaves(vo.Waves);
foreach (DefenseWave current in list)
{
List <DefenseTroopGroup> list2 = DefensiveBattleController.ParseTroopGroups(uid, current.Encounter.WaveGroup, 0);
foreach (DefenseTroopGroup current2 in list2)
{
if (battleDeploymentData.TroopData.ContainsKey(current2.TroopUid))
{
Dictionary <string, int> dictionary;
string troopUid;
(dictionary = battleDeploymentData.TroopData)[troopUid = current2.TroopUid] = dictionary[troopUid] + current2.Quantity;
}
else
{
battleDeploymentData.TroopData.Add(current2.TroopUid, current2.Quantity);
}
}
}
battleInitializationData.AttackerDeployableData = battleDeploymentData;
if (vo.Map != null)
{
battleInitializationData.BattleVO = staticDataController.Get <BattleTypeVO>(vo.Map);
battleInitializationData.AllowMultipleHeroDeploys = (battleInitializationData.BattleVO.MultipleHeroDeploys || vo.IsRaidDefense());
battleInitializationData.OverrideDeployables = battleInitializationData.BattleVO.OverridePlayerUnits;
battleInitializationData.BattleLength = battleInitializationData.BattleVO.BattleTime;
battleInitializationData.DefenderDeployableData = BattleDeploymentData.Copy(battleInitializationData.BattleVO);
}
else
{
battleInitializationData.DefenderDeployableData = BattleDeploymentData.CreateEmpty();
battleInitializationData.AllowMultipleHeroDeploys = vo.IsRaidDefense();
battleInitializationData.OverrideDeployables = false;
}
Inventory inventory = currentPlayer.Inventory;
battleInitializationData.LootCreditsAvailable = inventory.GetItemAmount("credits");
battleInitializationData.LootMaterialsAvailable = inventory.GetItemAmount("materials");
battleInitializationData.LootContrabandAvailable = inventory.GetItemAmount("contraband");
if (battleInitializationData.BattleLength == 0)
{
battleInitializationData.BattleLength = GameConstants.PVP_MATCH_DURATION;
}
battleInitializationData.BattleMusic = vo.BattleMusic;
battleInitializationData.AmbientMusic = vo.AmbientMusic;
battleInitializationData.VictoryConditions = vo.Conditions;
if (!string.IsNullOrEmpty(vo.FailureCondition))
{
battleInitializationData.FailureCondition = staticDataController.Get <ConditionVO>(vo.FailureCondition);
}
battleInitializationData.DisabledBuildings = new List <string>();
List <Contract> list3 = Service.ISupportController.FindAllContractsThatConsumeDroids();
for (int i = 0; i < list3.Count; i++)
{
if (list3[i].DeliveryType != DeliveryType.ClearClearable)
{
battleInitializationData.DisabledBuildings.Add(list3[i].ContractTO.BuildingKey);
}
}
battleInitializationData.IsReplay = false;
battleInitializationData.IsRevenge = false;
battleInitializationData.AllowReplay = false;
if (vo.IsRaidDefense() && Service.RaidDefenseController.SquadTroopDeployAllowed())
{
battleInitializationData.DefenderGuildTroopsAvailable = new Dictionary <string, int>();
List <SquadDonatedTroop> troops = Service.SquadController.StateManager.Troops;
for (int j = 0; j < troops.Count; j++)
{
string troopUid2 = troops[j].TroopUid;
int totalAmount = troops[j].GetTotalAmount();
if (battleInitializationData.DefenderGuildTroopsAvailable.ContainsKey(troopUid2))
{
Dictionary <string, int> dictionary;
string key;
(dictionary = battleInitializationData.DefenderGuildTroopsAvailable)[key = troopUid2] = dictionary[key] + totalAmount;
}
else
{
battleInitializationData.DefenderGuildTroopsAvailable.Add(troopUid2, totalAmount);
}
}
}
battleInitializationData.AttackerEquipment = null;
battleInitializationData.DefenderEquipment = BattleInitializationData.GetCurrentPlayerEquipment(battleInitializationData.PlanetId);
return(battleInitializationData);
}
public MissionCompleteScreen(CampaignMissionVO mission) : base("gui_mission_complete")
{
this.missionVO = mission;
}
public int GetMissionEarnedStars(CampaignMissionVO missionType)
{
return((!this.missions.ContainsKey(missionType.Uid)) ? 0 : this.missions[missionType.Uid].EarnedStars);
}
