private void StartCampaign_Click(object sender, EventArgs e)
{
campaign = new Campaign(player, (int)missionNumber.Value, difficultyBar.Value);
campaign.Start();
Hide();
do
{
try
{
campaign.activeGame.ShowDialog();
}
catch (Exception f)
{
Trace.TraceError(f.ToString());
MessageBox.Show(f.ToString());
}
if (campaign.activeGame.dead)
{
MessageBox.Show("You have lost the campaign as you have died! Good luck next time!");
return;
}
if (campaign.activeGame.giveReward)
{
MissionResult worldView = GenerateRewardAndHeal(player, campaign.activeGame, campaign.mission, campaign.healthRegen, (double)(campaign.Round - 1) / campaign.numberOfGames, "Next Mission");
worldView.ShowDialog();
}
} while (campaign.Next());
MessageBox.Show("You have won!");
}
public static void Prefix(Contract __instance, MissionResult result, bool isGoodFaithEffort)
{
if (__instance != null && !__instance.ContractTypeValue.IsSkirmish)
{
SimGameState simulation = HBS.LazySingletonBehavior <UnityGameInstance> .Instance.Game.Simulation;
ModState.Employer = __instance.GetTeamFaction("ecc8d4f2-74b4-465d-adf6-84445e5dfc230");
SimGameReputation employerRep = simulation.GetReputation(ModState.Employer);
ModState.EmployerRep = employerRep;
ModState.EmployerRepRaw = simulation.GetRawReputation(ModState.Employer);
ModState.IsEmployerAlly = simulation.IsFactionAlly(ModState.Employer);
ModState.MRBRating = simulation.GetCurrentMRBLevel(); // Normalize to 0 indexing
Mod.Log.Info?.Write($"At contract start for employer: Employer:({ModState.Employer}): " +
$"employerRep:{ModState.EmployerRep} employerIsAllied:{ModState.IsEmployerAlly} " +
$"MRBRating: {ModState.MRBRating} MRBIndex: {Helper.MRBCfgIdx()}");
// Calculate the rollup, reputation and etc:
Mod.Log.Info?.Write($" -- Contract Rollup Idx: {Helper.MRBCfgIdx()} => " +
$"RawRollup: {Mod.Config.RollupMRBValue[Helper.MRBCfgIdx()]}");
RepCfg repCfg = Mod.Config.Reputation[Helper.FactionCfgIdx()];
Mod.Log.Info?.Write($" -- Faction Rep Idx: {Helper.FactionCfgIdx()} => " +
$"Reputation: {repCfg.Reputation} " +
$"RollupMultiComponent: {repCfg.RollupMultiComponent} RollupMultiMech: {repCfg.RollupMultiMech} " +
$"HoldbackTrigger: {repCfg.HoldbackTrigger} HoldbackValueCapMulti: {repCfg.HoldbackValueCapMulti}");
}
}
public override MissionResult Run(object ip)
{
CRecipe rec = (CRecipe)ip;
MissionResult statues = MissionResult.NORMAL;
statues = this.selfCheck();
if (statues != MissionResult.NORMAL)
{
return(statues);
}
statues = this.loadRecipe();
if (statues != MissionResult.NORMAL)
{
return(statues);
}
statues = this.checkRGVstatus();
if (statues != MissionResult.NORMAL)
{
return(statues);
}
statues = this.RunRecipe(rec);
return(statues);
}
private static BaseCommand GenerateVoteMissionCommand(GameModel model, Player player)
{
if (model.GamePhase != GamePhase.MissionVoting)
{
throw new GamePhaseException(model.GamePhase.ToString());
}
if (!model.CurrentMission.Team.Contains(player))
{
throw new NotOnTeamException();
}
if (model.CurrentMission.MissionVoteOf[player] != MissionResult.Unknown)
{
throw new TwiceVoteException();
}
MissionResult missionVote =
(Character.IsGoodRole(player.Role)) ?
MissionResult.Succeed :
MissionResult.Fail;
VoteMissionCommand command = new VoteMissionCommand(player.Id, missionVote);
return(command);
}
public static void Postfix(Contract __instance, MissionResult result, bool isGoodFaithEffort)
{
try {
Settings s = WIIC.settings;
WIIC.modLog.Debug?.Write($"Contract complete: {__instance.Name}, override: {__instance.Override.ID}");
Flareup flareup = Utilities.currentFlareup();
if (flareup == null || __instance.Name != flareup.currentContractName)
{
return;
}
int bonus = flareup.type == "Attack" ? s.attackBonusPerHalfSkull : s.raidBonusPerHalfSkull;
int newCost = __instance.MoneyResults + bonus * __instance.Difficulty;
WIIC.modLog.Info?.Write($"{flareup.type} contract complete, adding bonus. old money: {__instance.MoneyResults}, new: {newCost}, funds: {WIIC.sim.Funds}");
Traverse.Create(__instance).Property("MoneyResults").SetValue(newCost);
WIIC.modLog.Info?.Write($"Reading it back after setting: {__instance.MoneyResults}");
bonus = flareup.type == "Attack" ? s.attackBonusSalvage : s.raidBonusSalvage;
WIIC.modLog.Info?.Write($"Addng salvage. FinalSalvageCount: {__instance.FinalSalvageCount}, bonus: {bonus}");
Traverse.Create(__instance).Property("FinalSalvageCount").SetValue(__instance.FinalSalvageCount + bonus);
}
catch (Exception e) {
WIIC.modLog.Error?.Write(e);
}
}
public override void ExecuteCommand(GameModel model)
{
ValidateCommand(model);
model.GamePhase = GamePhase.GameOver;
if (model.Missions.Count(ms => ms != null && ms.MissionResult == MissionResult.Succeed) >= 3)
{
model.GameResult = MissionResult.Succeed;
model.DefeatReason = DefeatType.NotDefeated;
}
else if (model.Missions.Count(ms => ms != null && ms.MissionResult == MissionResult.Fail) >= 3)
{
model.GameResult = MissionResult.Fail;
model.DefeatReason = DefeatType.FailedMission;
}
else
{
model.GameResult = MissionResult.Fail;
model.DefeatReason = DefeatType.HammerRejected;
}
GameResult = model.GameResult;
DefeatReason = model.DefeatReason;
}
public override void OnMissionResultReady(MissionResult missionResult)
{
if (!missionResult.PlayerVictory)
{
return;
}
this.BattleObserver.BattleResultsReady();
}
internal MissionResult RunChangeCar_Loader(int carSideId, ChangeCarStep curStep)
{
// throw new NotImplementedException();
bool isLeft;
if (carSideId == 0)
{
isLeft = true;
}
else
{
isLeft = false;
}
ChangeCarCmd curCmd = new ChangeCarCmd(isLeft, true, curStep);
MissionResult result = CheckChangeCarLoader();
if (result != MissionResult.NORMAL)
{
return(result);
}
if (isLeft)
{
this.loaderItemNum_left = 0;
}
else
{
this.loaderItemNum_right = 0;
}
if (isLeft)
{
this._ChangeCar_Loader.Status = ChangeCarStatus.CHANGING_LEFT;
}
else
{
this._ChangeCar_Loader.Status = ChangeCarStatus.CHANGING_RIGHT;
}
// this.m_alarmManager.LedCarOut(isLeft,true);
this._ChangeCarTask_Loader = new Task <MissionResult>(this._ChangeCar_Loader.RunChangeCar_Loader, (object)(curCmd));
this._ChangeCarTask_Loader.Start();
return(MissionResult.START);
}
public void ValuateMissionVote()
{
if (Team == null)
{
throw new InvalidOperationException("Missionteam unitialized.");
}
if (MissionResult != MissionResult.Unknown)
{
throw new InvalidOperationException("MissionResult already valuated!");
}
MissionResult = CountMissionResult();
}
public static void Prefix(Contract __instance, MissionResult result, bool isGoodFaithEffort)
{
if (__instance != null && !__instance.ContractTypeValue.IsSkirmish)
{
SimGameState simulation = HBS.LazySingletonBehavior <UnityGameInstance> .Instance.Game.Simulation;
ModState.Employer = __instance.GetTeamFaction("ecc8d4f2-74b4-465d-adf6-84445e5dfc230");
SimGameReputation employerRep = simulation.GetReputation(ModState.Employer);
ModState.EmployerRep = employerRep;
ModState.EmployerRepRaw = simulation.GetRawReputation(ModState.Employer);
ModState.IsEmployerAlly = simulation.IsCareerFactionAlly(ModState.Employer);
ModState.MRBRating = simulation.GetCurrentMRBLevel() - 1; // Normalize to 0 indexing
Mod.Log.Info($"At contract start, Player has MRB:{ModState.MRBRating} Employer:({ModState.Employer}) EmployerRep:{ModState.EmployerRep} / EmployerAllied:{ModState.IsEmployerAlly}");
}
}
public override InquiryData OnEndMissionRequest(out bool canPlayerLeave)
{
canPlayerLeave = true;
if (!this.IsPlayerDead() && this.Mission.IsPlayerCloseToAnEnemy())
{
canPlayerLeave = false;
InformationManager.AddQuickInformation(GameTexts.FindText("str_can_not_retreat"));
}
else
{
MissionResult missionResult = (MissionResult)null;
if (!this.IsPlayerDead() && !this.MissionEnded(ref missionResult))
{
return(new InquiryData("", GameTexts.FindText("str_retreat_question").ToString(), true, true, GameTexts.FindText("str_ok").ToString(), GameTexts.FindText("str_cancel").ToString(), new Action(this.Mission.OnEndMissionResult), (Action)null));
}
}
return((InquiryData)null);
}
private void CreateMissionVoteCmd(MissionResult missionVote)
{
VoteMissionCommand command = new VoteMissionCommand(LocalPlayer.Id, missionVote);
try
{
command.ValidateCommand(GameModel);
}
catch (BaseException ex)
{
if (ex is VoteTypeException)
{
InfoText.text = "You character alignment is Good. You must vote with Succeed!";
}
return;
}
GameController.AddCommand(command);
}
public static MissionResult GenerateRewardAndHeal(HumanPlayer player, MainGameWindow mainWindow, Mission.Mission mission, int healthRegen, double progression, string closeButtonText)
{
//Reset troop stats
foreach (Weapon weapon in player.troop.weapons)
{
if (weapon.type != BaseAttackType.range)
{
weapon.SetAttacks(weapon.MaxAttacks());
}
}
player.mana.RawValue = player.mana.MaxValue().Value;
player.troop.health.RawValue += healthRegen;
player.troop.health.RawValue = player.troop.health.Value > player.troop.health.MaxValue().Value ? player.troop.health.MaxValue().Value : player.troop.health.Value;
List <Armour> loot = new List <Armour>();
if (mission.lootDead)
{
//Generate loot from dead players
List <Armour> lootableArmour = new List <Armour>();
foreach (var deadPlayer in mainWindow.killedPlayers)
{
lootableArmour.AddRange(deadPlayer.troop.armours);
}
lootableArmour = lootableArmour.OrderBy(a => World.World.random.Next()).ToList(); // I know it is not the most effiecent but that does not matter here
int chosen = 0;
foreach (var lootpiece in lootableArmour)
{
if (World.World.random.NextDouble() < 1d / (chosen + 1d))
{
lootpiece.active = false;
loot.Add(lootpiece);
chosen++;
}
}
}
//Show world map
MissionResult worldView = new MissionResult(player, progression, mission, loot, closeButtonText);
return(worldView);
}
public int Unload(int posId)
{
MissionResult r = this._MissionManager.RunUnloader(posId);
switch (r)
{
case MissionResult.START:
// MessageBox.Show("Mission Start");
break;
default:
MessageBox.Show("unloader Error " + r.ToString());
break;
}
// MessageBox.Show("finish");
return(1);
//return this.m_processManager.
//throw new NotImplementedException();
}
public void PerformTheMission_MissionFailed_ReturnMissionResult()
{
var missionResult = new MissionResult()
{
Success = false
};
_missionService.Setup(m => m.SolveMission(
It.IsAny <string>(),
It.IsAny <string>()))
.Returns(Task.FromResult(missionResult));
var result = _newbieWarrior.PerformTheMission(
_missionService.Object,
It.IsAny <string>(),
It.IsAny <string>());
Assert.That(result.Success, Is.EqualTo(false));
}
public override bool MissionEnded(ref MissionResult missionResult)
{
bool flag = false;
if (this._isEnemySideRetreating || this._isEnemySideDepleted)
{
missionResult = MissionResult.CreateSuccessful((IMission)this.Mission);
flag = true;
}
else if (this._isPlayerSideDepleted)
{
missionResult = MissionResult.CreateDefeated((IMission)this.Mission);
flag = true;
}
if (flag)
{
this._missionAgentSpawnLogic.StopSpawner();
}
return(flag);
}
public override void LoadTestData()
{
// TODO: Remove after testing
List <UserInfo> randos = Helper.GenerateFakeActivity();
var mresult = new MissionResult {
employer = Faction.Steiner,
target = Faction.Liao,
result = BattleTech.MissionResult.Victory,
systemName = "FOOBAR",
difficulty = 3,
awardedRep = 0,
planetSupport = 0,
};
foreach (UserInfo rando in randos)
{
string hashedID = String.Format("{0:X}", rando.companyName.GetHashCode());
Holder.connectionStore.Add(hashedID, rando);
Helper.RecordPlayerActivity(mresult, hashedID, rando.companyName, DateTime.UtcNow);
}
}
public void PerformTheMission_MissionSuccessful_ReturnTrue()
{
_warrior.Setup(w => w.ChooseTheBestMission(
It.IsAny <List <MissionInfo> >(),
It.IsAny <UserInfo>()))
.Returns(new MissionInfo());
var missionResult = new MissionResult {
Success = true
};
_warrior.Setup(w => w.PerformTheMission(
It.IsAny <IMissionService>(),
It.IsAny <string>(),
It.IsAny <string>()))
.Returns(missionResult);
var result = _missionBoard.PerformTheMission();
Assert.That(result, Is.EqualTo(true));
}
public override bool MissionEnded(ref MissionResult missionResult)
{
if (this.IsSallyOutOver)
{
missionResult = MissionResult.CreateSuccessful((IMission)this.Mission);
return(true);
}
if (this._checkState != SallyOutEndLogic.EndConditionCheckState.Active)
{
return(false);
}
foreach (Team team in (ReadOnlyCollection <Team>) this.Mission.Teams)
{
switch (team.Side)
{
case BattleSideEnum.Defender:
if (team.FormationsIncludingSpecial.Any <Formation>() && team.Formations.Any <Formation>((Func <Formation, bool>)(f => !TeamAISiegeComponent.IsFormationInsideCastle(f, false, 0.9f))))
{
this._checkState = SallyOutEndLogic.EndConditionCheckState.Idle;
return(false);
}
continue;
case BattleSideEnum.Attacker:
if (TeamAISiegeComponent.IsFormationGroupInsideCastle(team.FormationsIncludingSpecial, false, 0.1f))
{
this._checkState = SallyOutEndLogic.EndConditionCheckState.Idle;
return(false);
}
continue;
default:
continue;
}
}
this.IsSallyOutOver = true;
missionResult = MissionResult.CreateSuccessful((IMission)this.Mission);
return(true);
}
public override bool MissionEnded(ref MissionResult missionResult)
{
if (!this.IsDeploymentFinished)
{
return(false);
}
if (this.IsPlayerDead())
{
missionResult = MissionResult.CreateDefeated((IMission)this.Mission);
return(true);
}
if (this.Mission.GetMemberCountOfSide(BattleSideEnum.Attacker) == 0)
{
missionResult = this.Mission.PlayerTeam.Side == BattleSideEnum.Attacker ? MissionResult.CreateDefeated((IMission)this.Mission) : MissionResult.CreateSuccessful((IMission)this.Mission);
return(true);
}
if (this.Mission.GetMemberCountOfSide(BattleSideEnum.Defender) != 0)
{
return(false);
}
missionResult = this.Mission.PlayerTeam.Side == BattleSideEnum.Attacker ? MissionResult.CreateSuccessful((IMission)this.Mission) : MissionResult.CreateDefeated((IMission)this.Mission);
return(true);
}
static void Postfix(Contract __instance, MissionResult result)
{
try {
GameInstance game = LazySingletonBehavior <UnityGameInstance> .Instance.Game;
StarSystem system = game.Simulation.StarSystems.Find(x => x.ID == __instance.TargetSystem);
Faction oldOwner = system.Def.Owner;
if (result == MissionResult.Victory)
{
system = Helper.PlayerAttackSystem(system, game.Simulation, __instance.Override.employerTeam.faction, __instance.Override.targetTeam.faction, true);
}
else
{
system = Helper.PlayerAttackSystem(system, game.Simulation, __instance.Override.employerTeam.faction, __instance.Override.targetTeam.faction, false);
}
if (system.Def.Owner != oldOwner)
{
SimGameInterruptManager interruptQueue = (SimGameInterruptManager)AccessTools.Field(typeof(SimGameState), "interruptQueue").GetValue(game.Simulation);
interruptQueue.QueueGenericPopup_NonImmediate("Conquered", Helper.GetFactionName(system.Def.Owner, game.Simulation.DataManager) + " took " + system.Name + " from " + Helper.GetFactionName(oldOwner, game.Simulation.DataManager), true, null);
}
}
catch (Exception e) {
Logger.LogError(e);
}
}
public void AddMissionVote(Player player, MissionResult missionVote)
{
if (Team == null)
{
throw new InvalidOperationException("Missionteam uninitialized.");
}
if (missionVote == MissionResult.Unknown)
{
throw new ArgumentException("vote");
}
if (!Team.Contains(player))
{
throw new ArgumentException("player not in team");
}
if (MissionVoteOf[player] != MissionResult.Unknown)
{
throw new ArgumentException("player alrdy vote");
}
MissionVoteOf[player] = missionVote;
}
public override bool MissionEnded(ref MissionResult missionResult)
{
return(this.Mission.InputManager.IsKeyPressed(TaleWorlds.InputSystem.InputKey.Tab));
}
public static BaseCommand CommandFromString(String strCommand, GameModel model)
{
if (strCommand.StartsWith("EvaluateGameResult "))
{
String[] split = strCommand.Split(' ');
MissionResult gameResult = (MissionResult)Int32.Parse(split[1]);
DefeatType defeatType = (DefeatType)Int32.Parse(split[2]);
EvaluateGameResult command = new EvaluateGameResult();
command.GameResult = gameResult;
command.DefeatReason = defeatType;
return(command);
}
if (strCommand.StartsWith("EvaluateMissionVote "))
{
String[] split = strCommand.Split(' ');
MissionNumber missionNumber = (MissionNumber)Int32.Parse(split[1]);
EvaluateMissionVote command = new EvaluateMissionVote(missionNumber);
return(command);
}
if (strCommand.StartsWith("EvaluateTeamVote "))
{
String[] split = strCommand.Split(' ');
MissionNumber missionNumber = (MissionNumber)Int32.Parse(split[1]);
VoteNumber voteNumber = (VoteNumber)Int32.Parse(split[2]);
EvaluateTeamVote command = new EvaluateTeamVote(missionNumber, voteNumber);
return(command);
}
if (strCommand.StartsWith("PickTeam "))
{
String[] split = strCommand.Split(' ');
int leaderId = Int32.Parse(split[1]);
string teamCode = split[2];
int playerNum = teamCode.Length;
HashSet <int> playerTeamIds = new HashSet <int>();
for (int i = 0; i < teamCode.Length; i++)
{
if (teamCode[i] == '1')
{
playerTeamIds.Add(i);
}
}
PickTeamCommand command = new PickTeamCommand(leaderId, playerTeamIds, playerNum);
return(command);
}
if (strCommand.StartsWith("VoteMission "))
{
String[] split = strCommand.Split(' ');
int playerId = Int32.Parse(split[1]);
MissionResult missionVote = (MissionResult)Int32.Parse(split[2]);
VoteMissionCommand command = new VoteMissionCommand(playerId, missionVote);
return(command);
}
if (strCommand.StartsWith("VoteTeam "))
{
String[] split = strCommand.Split(' ');
int playerId = Int32.Parse(split[1]);
VoteType teamVote = (VoteType)Int32.Parse(split[2]);
VoteTeamCommand command = new VoteTeamCommand(playerId, teamVote);
return(command);
}
if (strCommand.StartsWith("ChangePlayer "))
{
String[] split = strCommand.Split(' ');
int playerId = Int32.Parse(split[1]);
PlayerType playerType = (PlayerType)Int32.Parse(split[2]);
String playerName = split[3];
ChangePlayerCommand command = new ChangePlayerCommand(playerId, playerType, playerName);
return(command);
}
throw new ArgumentException("Command string not found: " + strCommand);
}
public static void Postfix(Contract __instance, MissionResult result, bool isGoodFaithEffort)
{
SpecHolder.HolderInstance.emplRep = __instance.EmployerReputationResults;
var employer = __instance.Override.employerTeam.FactionDef.FactionValue.Name;
var target = __instance.Override.targetTeam.FactionDef.FactionValue.Name;
var employerRepMult = 1f;
var targetRepMult = 1f;
var contractPayOutMult = 1f;
SpecHolder.HolderInstance.kills = 0;
SpecHolder.HolderInstance.bounty = 0;
var playerUnits = UnityGameInstance.BattleTechGame.Combat.AllActors.Where(x => x.team.IsLocalPlayer);
foreach (var unit in playerUnits)
{
var p = unit.GetPilot();
var pKey = p.FetchGUID();
if (pKey == "NOTAPILOT")
{
continue;
}
var contractID = __instance.Override.ContractTypeValue.Name;
//processing mission outcomes
if (SpecHolder.HolderInstance.OpForSpecMap.ContainsKey(pKey))
{
var opSpecs = new List <OpForSpec>();
var employerRepMultTemp = new List <float>()
{
0f
};
foreach (var spec in SpecHolder.HolderInstance.OpForSpecMap[pKey])
{
opSpecs.AddRange(SpecManager.ManagerInstance.OpForSpecList.Where(x => x.OpForSpecID == spec));
}
foreach (var opSpec in opSpecs)
{
if (opSpec.factionID == target || opSpec.applyToFaction.Contains(target))
{
if (opSpec.repMult.ContainsKey(employer))
{
employerRepMultTemp.Add(opSpec.repMult[employer]);
//employerRepMult += (opSpec.repMult[employer]);
ModInit.modLog.LogMessage($"current employer [employer] reputation multiplier: {opSpec.repMult[employer]}");
}
if (opSpec.repMult.ContainsKey(employer_string))
{
employerRepMultTemp.Add(opSpec.repMult[employer_string]);
//employerRepMult += (opSpec.repMult[employer_string]);
ModInit.modLog.LogMessage($"current employer [employer_string] reputation multiplier: {opSpec.repMult[employer_string]}");
}
if (opSpec.repMult.ContainsKey(owner_string) && sim.CurSystem.OwnerValue.Name == employer)
{
employerRepMultTemp.Add(opSpec.repMult[owner_string]);
// employerRepMult += (opSpec.repMult[owner_string]);
ModInit.modLog.LogMessage($"current employer [owner_string] reputation multiplier: {opSpec.repMult[owner_string]}");
}
employerRepMult += employerRepMultTemp.Max();
if (opSpec.repMult.ContainsKey(target) && !opSpec.repMult.ContainsKey(target_string))
{
targetRepMult *= (opSpec.repMult[target]);
ModInit.modLog.LogMessage($"current target [target] reputation multiplier: {targetRepMult}");
}
if (!opSpec.repMult.ContainsKey(target) && opSpec.repMult.ContainsKey(target_string))
{
targetRepMult *= (opSpec.repMult[target_string]);
ModInit.modLog.LogMessage($"current target [target_string] reputation multiplier: {targetRepMult}");
}
if (opSpec.repMult.ContainsKey(target) && opSpec.repMult.ContainsKey(target_string))
{
targetRepMult *= Math.Min(opSpec.repMult[target], opSpec.repMult[target_string]);
ModInit.modLog.LogMessage($"current target [target && target_string] reputation multiplier: {targetRepMult}");
}
if (opSpec.cashMult.ContainsKey(employer) && !opSpec.cashMult.ContainsKey(employer_string))
{
contractPayOutMult += (opSpec.cashMult[employer]);
ModInit.modLog.LogMessage($"current contract payout multiplier: {contractPayOutMult}");
}
if (!opSpec.cashMult.ContainsKey(employer) && opSpec.cashMult.ContainsKey(employer_string))
{
contractPayOutMult += (opSpec.cashMult[employer_string]);
ModInit.modLog.LogMessage($"current contract payout multiplier: {contractPayOutMult}");
}
if (opSpec.cashMult.ContainsKey(employer) && opSpec.cashMult.ContainsKey(employer_string))
{
contractPayOutMult += Math.Max(opSpec.cashMult[employer_string], opSpec.cashMult[employer]);
ModInit.modLog.LogMessage($"current contract payout multiplier: {contractPayOutMult}");
}
}
}
if (SpecHolder.HolderInstance.OpForKillsTEMPTracker.ContainsKey(pKey))
{
if (SpecHolder.HolderInstance.OpForKillsTEMPTracker[pKey].ContainsKey(target))
{
SpecHolder.HolderInstance.kills += SpecHolder.HolderInstance.OpForKillsTEMPTracker[pKey][target];
ModInit.modLog.LogMessage($"OpForKillsTEMPTracker was {SpecHolder.HolderInstance.OpForKillsTEMPTracker[pKey][target]}");
}
foreach (var opSpec in opSpecs)
{
if (opSpec.factionID.Contains(target) || opSpec.applyToFaction.Contains(target))
{
if (opSpec.killBounty.ContainsKey(employer) &&
!opSpec.killBounty.ContainsKey(employer_string))
{
SpecHolder.HolderInstance.bounty += opSpec.killBounty[employer];
ModInit.modLog.LogMessage($"Kill bounty: {SpecHolder.HolderInstance.bounty}");
}
if (!opSpec.killBounty.ContainsKey(employer) &&
opSpec.killBounty.ContainsKey(employer_string))
{
SpecHolder.HolderInstance.bounty += opSpec.killBounty[employer_string];
ModInit.modLog.LogMessage($"Kill bounty: {SpecHolder.HolderInstance.bounty}");
}
if (opSpec.killBounty.ContainsKey(employer) &&
opSpec.killBounty.ContainsKey(employer_string))
{
SpecHolder.HolderInstance.bounty += Math.Max(opSpec.killBounty[employer], opSpec.killBounty[employer_string]);
ModInit.modLog.LogMessage($"Kill bounty: {SpecHolder.HolderInstance.bounty}");
}
}
}
}
}
var taggedMSpecCt = 0;
var taggedOPSpecCt = 0;
if (!ModInit.modSettings.TaggedMissionSpecsCountTowardMax)
{
foreach (var tag in ModInit.modSettings.taggedMissionSpecs)
{
if (p.pilotDef.PilotTags.Contains(tag.Key))
{
taggedMSpecCt += tag.Value.Count;
}
}
ModInit.modLog.LogMessage(
$"{taggedMSpecCt} tagged Mission Specs found for {p.Callsign}.");
foreach (var tag in ModInit.modSettings.taggedOpForSpecs)
{
if (p.pilotDef.PilotTags.Contains(tag.Key))
{
taggedOPSpecCt += tag.Value.Count;
}
}
}
//processing spec progress below
if (ModInit.modSettings.WhiteListMissions.Contains(contractID))
{
if (SpecHolder.HolderInstance.MissionsTracker.ContainsKey(pKey))
{
if (!SpecHolder.HolderInstance.MissionsTracker[pKey].ContainsKey(contractID))
{
SpecHolder.HolderInstance.MissionsTracker[pKey].Add(contractID, 0);
ModInit.modLog.LogMessage(
$"No key for {contractID} found in {p.Callsign}'s MissionsTracker. Adding it with default value 0.");
}
if (ModInit.modSettings.MissionSpecSuccessRequirement == 0 ||
(ModInit.modSettings.MissionSpecSuccessRequirement == 1 && isGoodFaithEffort) ||
(ModInit.modSettings.MissionSpecSuccessRequirement == 2 &&
result == MissionResult.Victory))
{
SpecHolder.HolderInstance.MissionsTracker[pKey][contractID] += 1;
ModInit.modLog.LogMessage(
$"Adding 1 to {p.Callsign}'s MissionsTracker for {contractID}");
}
var mspecsCollapsed = SpecManager.ManagerInstance.MissionSpecList.Where(x =>
SpecHolder.HolderInstance.MissionSpecMap[pKey].Any(y => y == x.MissionSpecID))
.Select(x => x.contractTypeID).Distinct().ToList();
if (SpecManager.ManagerInstance.MissionSpecList.Any(x => x.contractTypeID == contractID))
{
foreach (var missionSpec in SpecManager.ManagerInstance.MissionSpecList.Where(x =>
x.contractTypeID == contractID))
{
if (missionSpec.missionsRequired == 0)
{
ModInit.modLog.LogMessage(
$"{missionSpec.MissionSpecName} has 0 required missions set, ignoring.");
continue;
}
if ((SpecHolder.HolderInstance.MissionSpecMap[pKey].Count - taggedMSpecCt <
ModInit.modSettings.MaxMissionSpecializations) ||
(!ModInit.modSettings.MissionTiersCountTowardMax &&
(mspecsCollapsed.Count - taggedMSpecCt <
ModInit.modSettings.MaxMissionSpecializations) ||
mspecsCollapsed.Contains(missionSpec.contractTypeID)))
{
if (SpecHolder.HolderInstance.MissionsTracker[pKey][contractID] >=
missionSpec.missionsRequired && contractID == missionSpec.contractTypeID &&
!SpecHolder
.HolderInstance.MissionSpecMap[pKey]
.Contains(missionSpec.MissionSpecID))
{
ModInit.modLog.LogMessage(
$"{p.Callsign} has achieved {missionSpec.MissionSpecName} for {missionSpec.contractTypeID}!");
SpecHolder.HolderInstance.MissionSpecMap[pKey]
.Add(missionSpec.MissionSpecID);
if (!mspecsCollapsed.Contains(missionSpec.contractTypeID))
{
mspecsCollapsed.Add(missionSpec.contractTypeID);
}
}
}
else
{
ModInit.modLog.LogMessage(
$"{p.Callsign} already has the maximum, {mspecsCollapsed.Count}{ModInit.modSettings.MaxMissionSpecializations}, Mission Specializations!");
}
if (missionSpec.cashMult > 0 && SpecHolder.HolderInstance.MissionSpecMap[pKey]
.Any(y => y == missionSpec.MissionSpecID))
{
contractPayOutMult += (missionSpec.cashMult);
ModInit.modLog.LogMessage(
$"current contract payout multiplier: {contractPayOutMult} from {missionSpec.MissionSpecName}");
}
}
}
}
}
if (ModInit.modSettings.WhiteListOpFor.Contains(__instance.Override.targetTeam.FactionValue.Name) && SpecHolder.HolderInstance.OpForKillsTEMPTracker.ContainsKey(pKey))
{
if (SpecHolder.HolderInstance.OpForKillsTEMPTracker[pKey].Count <= 0)
{
return;
}
foreach (var key in SpecHolder.HolderInstance.OpForKillsTEMPTracker[pKey]?.Keys)
{
if (ModInit.modSettings.WhiteListOpFor.Contains(key))
{
if (!SpecHolder.HolderInstance.OpForKillsTracker[pKey].ContainsKey(key))
{
SpecHolder.HolderInstance.OpForKillsTracker[pKey].Add(key, 0);
ModInit.modLog.LogMessage(
$"No key for {key} found in {p.Callsign}'s OpForKillsTracker. Adding it with default value 0.");
}
SpecHolder.HolderInstance.OpForKillsTracker[pKey][key] +=
SpecHolder.HolderInstance.OpForKillsTEMPTracker[pKey][key];
ModInit.modLog.LogMessage(
$"Adding {SpecHolder.HolderInstance.OpForKillsTEMPTracker[pKey][key]} {key} kills to {p.Callsign}'s OpForKillsTracker");
}
}
}
var opforspecCollapsed = SpecManager.ManagerInstance.OpForSpecList.Where(x =>
SpecHolder.HolderInstance.OpForSpecMap[pKey].Any(y => y == x.OpForSpecID))
.Select(x => x.factionID).Distinct().ToList();
if (SpecHolder.HolderInstance.OpForSpecMap.ContainsKey(pKey) &&
(SpecHolder.HolderInstance.OpForKillsTracker.ContainsKey(pKey)))
{
foreach (var opforSpec in SpecManager.ManagerInstance.OpForSpecList)
{
if (opforSpec.killsRequired == 0)
{
ModInit.modLog.LogMessage(
$"{opforSpec.OpForSpecName} has 0 required kills set, ignoring.");
continue;
}
if ((SpecHolder.HolderInstance.OpForSpecMap[pKey].Count - taggedOPSpecCt <
ModInit.modSettings.MaxOpForSpecializations) ||
(!ModInit.modSettings.OpForTiersCountTowardMax &&
(opforspecCollapsed.Count - taggedOPSpecCt <
ModInit.modSettings.MaxOpForSpecializations) ||
opforspecCollapsed.Contains(opforSpec.factionID)))
{
foreach (var opfor in new List <string>(SpecHolder.HolderInstance.OpForKillsTracker[pKey]
.Keys))
{
if (SpecHolder.HolderInstance.OpForKillsTracker[pKey][opfor] >=
opforSpec.killsRequired && opfor == opforSpec.factionID && !SpecHolder
.HolderInstance.OpForSpecMap[pKey].Contains(opforSpec.OpForSpecID))
{
ModInit.modLog.LogMessage(
$"{p.Callsign} has achieved {opforSpec.OpForSpecName} against {opforSpec.factionID}!");
SpecHolder.HolderInstance.OpForSpecMap[pKey].Add(opforSpec.OpForSpecID);
if (!opforspecCollapsed.Contains(opforSpec.factionID))
{
opforspecCollapsed.Add(opforSpec.factionID);
}
}
}
}
else
{
ModInit.modLog.LogMessage(
$"{p.Callsign} already has the maximum, {opforspecCollapsed.Count}/{ModInit.modSettings.MaxOpForSpecializations}, OpFor Specializations!");
}
}
}
}
SpecHolder.HolderInstance.totalBounty = SpecHolder.HolderInstance.kills * SpecHolder.HolderInstance.bounty;
ModInit.modLog.LogMessage($"{SpecHolder.HolderInstance.totalBounty} in bounties awarded.");
var employerRep = Mathf.RoundToInt(__instance.EmployerReputationResults * employerRepMult);
var targetRep = Mathf.RoundToInt(__instance.TargetReputationResults * targetRepMult);
var contractPayout = Mathf.RoundToInt((__instance.MoneyResults * contractPayOutMult) + SpecHolder.HolderInstance.totalBounty);
ModInit.modLog.LogMessage($"Employer Reputation Change: {__instance.EmployerReputationResults} x {employerRepMult} = {employerRep}");
ModInit.modLog.LogMessage($"Target Reputation Change: {__instance.TargetReputationResults} x {targetRepMult} = {targetRep}");
ModInit.modLog.LogMessage($"Contract Payout: ({__instance.MoneyResults} x {contractPayOutMult}) + {SpecHolder.HolderInstance.totalBounty} = {contractPayout}");
Traverse.Create(__instance).Property("EmployerReputationResults").SetValue(employerRep);
Traverse.Create(__instance).Property("TargetReputationResults").SetValue(targetRep);
Traverse.Create(__instance).Property("MoneyResults").SetValue(contractPayout);
SpecHolder.HolderInstance.OpForKillsTEMPTracker = new Dictionary <string, Dictionary <string, int> >();
}
public VoteMissionCommand(int playerId, MissionResult missionVote)
{
PlayerId = playerId;
MissionVote = missionVote;
}
public abstract System PostMissionResult(MissionResult mresult, string CompanyName);
IEnumerator interpretationEvent()
{
catIndex = 0;
dogIndex = 0;
if (PuzzleManager.stageInfo.hasCat)
{
catArrow.gameObject.SetActive(true);
}
if (PuzzleManager.stageInfo.hasDog)
{
dogArrow.gameObject.SetActive(true);
}
yield return(new WaitForSeconds(catArrow.duration + secondsBetweenMoves));
while (catIndex < catInstructionList.list.Count || dogIndex < dogInstructionList.list.Count)
{
Utils.InstructionType catAction = Utils.InstructionType.WAIT, dogAction = Utils.InstructionType.WAIT;
if (PuzzleManager.stageInfo.hasCat && catIndex < catInstructionList.list.Count)
{
catArrow.target = catIndex;
}
if (PuzzleManager.stageInfo.hasDog && dogIndex < dogInstructionList.list.Count)
{
dogArrow.target = dogIndex;
}
if (catIndex < catInstructionList.list.Count)
{
catAction = catInstructionList.list[catIndex].GetComponent <InstructionListNode>().instructionType;
}
if (dogIndex < dogInstructionList.list.Count)
{
dogAction = dogInstructionList.list[dogIndex].GetComponent <InstructionListNode>().instructionType;
}
if (willCollide(catAction, dogAction))
{
missionFailed = true;
}
if (missionFailed)
{
break;
}
if (catIndex < catInstructionList.list.Count)
{
switch (catAction)
{
case Utils.InstructionType.MOVE_U:
moveCat('U');
break;
case Utils.InstructionType.MOVE_L:
moveCat('L');
break;
case Utils.InstructionType.MOVE_R:
moveCat('R');
break;
case Utils.InstructionType.MOVE_D:
moveCat('D');
break;
case Utils.InstructionType.GRAB_U:
StartCoroutine(grabCat('U'));
break;
case Utils.InstructionType.GRAB_L:
StartCoroutine(grabCat('L'));
break;
case Utils.InstructionType.GRAB_R:
StartCoroutine(grabCat('R'));
break;
case Utils.InstructionType.GRAB_D:
StartCoroutine(grabCat('D'));
break;
case Utils.InstructionType.WAIT:
waitCat();
if (!catIsWaiting)
{
continue;
}
break;
}
if (!catIsWaiting)
{
catNextStep();
}
}
if (dogIndex < dogInstructionList.list.Count)
{
switch (dogAction)
{
case Utils.InstructionType.MOVE_U:
moveDog('U');
break;
case Utils.InstructionType.MOVE_L:
moveDog('L');
break;
case Utils.InstructionType.MOVE_R:
moveDog('R');
break;
case Utils.InstructionType.MOVE_D:
moveDog('D');
break;
case Utils.InstructionType.GRAB_U:
StartCoroutine(grabDog('U'));
break;
case Utils.InstructionType.GRAB_L:
StartCoroutine(grabDog('L'));
break;
case Utils.InstructionType.GRAB_R:
StartCoroutine(grabDog('R'));
break;
case Utils.InstructionType.GRAB_D:
StartCoroutine(grabDog('D'));
break;
case Utils.InstructionType.WAIT:
waitDog();
if (!dogIsWaiting)
{
continue;
}
break;
}
if (!dogIsWaiting)
{
dogNextStep();
}
}
if (catIsWaiting && dogIndex >= dogInstructionList.list.Count)
{
missionFailed = true;
missionResult = MissionResult.Condition.CAT_WAITING_FAIL;
break;
}
if (dogIsWaiting && catIndex >= catInstructionList.list.Count)
{
missionFailed = true;
missionResult = MissionResult.Condition.DOG_WAITING_FAIL;
break;
}
yield return(new WaitForSeconds(secondsPerMove + secondsBetweenMoves));
}
yield return(new WaitForSeconds(1f));
if (!missionFailed)
{
missionResult = MissionResult.checkMissionResult(puzzleManager, catIsHoldingKind, dogIsHoldingKind);
if (missionResult != MissionResult.Condition.SUCCESS)
{
missionFailed = true;
}
}
endMenu.SetActive(true);
foreach (Text child in endMenu.GetComponentsInChildren <Text>())
{
if (child.name == "ResultText")
{
child.text = MissionResult.conditionNames[missionResult];
}
}
if (missionResult == MissionResult.Condition.SUCCESS)
{
SaveManager.SetFinishedMap(PuzzleManager.stageInfo.name.Substring("PuzzleStage".Length));
}
isInterpreting = false;
yield break;
}
public System PostMissionResultDepricated5(MissionResult mresult)
{
logger.Warn("WARNING: Deprecated method invoked: PostMissionResultDepricated5");
return(PostMissionResult(mresult, "UNKNOWN"));
}
public override bool MissionEnded(ref MissionResult missionResult) => this.Mission.MainAgent != null && !this.Mission.MainAgent.IsActive();
