static void Postfix(SGContractsWidget __instance, Contract contract)
{
SimGameState Sim = (SimGameState)ReflectionHelper.Helper.GetPrivateProperty(__instance, "Sim");
int MinSalvage = Sim.Constants.Finances.ContractFloorSalvageBonus;
int MaxSalvage = Sim.Constants.Salvage.DefaultSalvagePotential;
if (contract.Override.salvagePotential > -1)
{
MaxSalvage = contract.Override.salvagePotential;
}
else if (contract.SalvagePotential > -1)
{
MaxSalvage = contract.SalvagePotential;
}
if (MaxSalvage > 0)
{
MaxSalvage = MaxSalvage + MinSalvage;
}
TextMeshProUGUI NegSalvageMin = (TextMeshProUGUI)ReflectionHelper.Helper.GetPrivateField(__instance, "NegSalvageMin");
TextMeshProUGUI NegSalvageMax = (TextMeshProUGUI)ReflectionHelper.Helper.GetPrivateField(__instance, "NegSalvageMax");
NegSalvageMin.text = string.Format("{0} / {1}", Math.Floor(MinSalvage / 4f), MinSalvage);
NegSalvageMax.text = string.Format("{0} / {1}", Math.Floor(MaxSalvage / 4f), MaxSalvage);
}
public static void Postfix(SGContractsWidget __instance)
{
var sim = Traverse.Create(__instance).Property("Sim").GetValue <SimGameState>();
var contract = __instance.SelectedContract;
var actualSalvage = sim.Constants.Salvage.DefaultSalvagePotential;
if (contract.Override.salvagePotential > -1)
{
actualSalvage = contract.Override.salvagePotential;
}
else if (contract.SalvagePotential > -1)
{
actualSalvage = contract.SalvagePotential;
}
if (actualSalvage > 0)
{
var negSalvageSlider = Traverse.Create(__instance).Field("NegSalvageSlider").GetValue <HBSSliderInput>();
var negSalvage = negSalvageSlider.Value / negSalvageSlider.ValueMax;
actualSalvage = Mathf.FloorToInt(actualSalvage * negSalvage);
actualSalvage += sim.Constants.Finances.ContractFloorSalvageBonus;
}
var actualPrioritySalvage = Math.Min(7, Mathf.FloorToInt(actualSalvage * sim.Constants.Salvage.PrioritySalvageModifier));
Traverse.Create(__instance).Field("NegSalvageCurrent").GetValue <TextMeshProUGUI>().text = $"{actualPrioritySalvage} / {actualSalvage}";
}
public static void Postfix(SGContractsWidget __instance, Contract contract)
{
// Reset contractDisplayStyle
if (isOpportunityMission)
{
contract.Override.contractDisplayStyle = ContractDisplayStyle.BaseCampaignNormal;
}
}
static void Postfix(SGContractsWidget __instance, List <SGContractsListItem> ___listedContracts, List <Contract> contracts, ContractDisplayStyle?initialSelection = null)
{
//Main.modLog.LogMessage("ListContracts Called");
ContractCardController.Instance.lastContractSet = ___listedContracts;
foreach (SGContractsListItem listedContract in ___listedContracts)
{
GameObject fillObject = listedContract.gameObject.transform.findChild("ENABLED-bg-fill").gameObject;
if (fillObject != null)
{
bool priorityContract = listedContract.Contract.Override.contractDisplayStyle == ContractDisplayStyle.BaseCampaignStory;
bool campaignContract = listedContract.Contract.Override.contractDisplayStyle == ContractDisplayStyle.BaseCampaignRestoration;
bool flashpointContract = listedContract.Contract.IsFlashpointContract;
bool fpCampaignContract = listedContract.Contract.IsFlashpointCampaignContract;
Image filler = fillObject.GetComponent <Image>();
Color colour;
ContractCardFixup fixup = fillObject.GetComponent <ContractCardFixup>();
// Add this fixup component to the card, otherwise on first initialzation after loading a save or after a battle, the colours will revert to deafult
if (fixup == null)
{
fixup = fillObject.AddComponent <ContractCardFixup>();
}
if (flashpointContract || fpCampaignContract)
{
if (FlashPointController.Instance.getFlashpointContractColour(listedContract.Contract.Override.ID, fpCampaignContract, out colour))
{
filler.color = colour;
fixup.setColour(colour);
fixup.setUp(filler);
}
}
else
{
// leave priority & restoration campaign missions alone
if (!priorityContract && !campaignContract)
{
if (ContractCardController.Instance.getContractColour(listedContract.Contract, out colour))
{
//Main.modLog.LogMessage($"Before Colour: {filler.color.r}, {filler.color.g}, {filler.color.b}");
filler.color = colour;
fixup.setColour(colour);
fixup.setUp(filler);
//Main.modLog.LogMessage($"After Colour: {filler.color.r}, {filler.color.g}, {filler.color.b}");
}
}
}
}
else
{
Main.modLog.LogMessage("Failed to find fill object!");
}
}
}
public static void Postfix(SGContractsWidget __instance, List <SGContractsListItem> ___listedContracts)
{
for (int i = 0; i < ___listedContracts.Count; i++)
{
SGContractsListItem sgContractsListItem = ___listedContracts[i];
// Reset contractDisplayStyle
if (opportunityMissionIndexList.Contains(i))
{
sgContractsListItem.Contract.Override.contractDisplayStyle = ContractDisplayStyle.BaseCampaignNormal;
}
}
opportunityMissionIndexList.Clear();
}
public static bool Prefix(SGContractsWidget __instance)
{
try {
Flareup flareup = Utilities.currentFlareup();
if (flareup != null && __instance.SelectedContract.Name == flareup.currentContractName)
{
WIIC.modLog.Debug?.Write($"Blocking HandleEscapeKeypress. selected: {__instance.SelectedContract.Name}, selectedContract: {__instance.SelectedContract.Name}, flareupContract: {flareup.currentContractName}");
return(false);
}
}
catch (Exception e) {
WIIC.modLog.Error?.Write(e);
}
return(true);
}
public static void Postfix(SGContractsWidget __instance, ref int __result, Contract contract)
{
try
{
if (contract.IsOpportunityMission())
{
Logger.Info($"[SGContractsWidget_GetContractComparePriority_POSTFIX] Set {contract.Override.ID} to have highest sort order");
__result = -1;
}
}
catch (Exception e)
{
Logger.Error(e);
}
}
static void Postfix(SGContractsWidget __instance, GameObject ___ContractList)
{
Mod.Log.Trace?.Write($"SGCW:I - entered.");
RectTransform clRT = ___ContractList.GetComponent <RectTransform>();
if (clRT != null)
{
Vector3 ns = clRT.sizeDelta;
ns.y += 260;
clRT.sizeDelta = ns;
}
else
{
Mod.Log.Info?.Write("ContractList rectTransform is null!");
}
}
public static void Prefix(SGContractsWidget __instance, Contract contract)
{
try
{
if (contract.IsOpportunityMission())
{
isOpportunityMission = true;
Logger.Debug($"[SGContractsWidget_AddContract_PREFIX] {contract.Override.ID} is an opportunity mission");
// Temporarily set contractDisplayStyle
contract.Override.contractDisplayStyle = ContractDisplayStyle.BaseCampaignStory;
}
}
catch (Exception e)
{
Logger.Error(e);
}
}
public static void Postfix(SGContractsWidget __instance)
{
try {
Flareup flareup = Utilities.currentFlareup();
if (flareup != null && __instance.SelectedContract.Name == flareup.currentContractName)
{
WIIC.modLog.Debug?.Write($"Hiding widgets for NegotiateContract. selectedContract: {__instance.SelectedContract.Name}, flareupContract: {flareup.currentContractName}");
HBSButton backButton = (HBSButton)AccessTools.Field(typeof(SGContractsWidget), "NegotiateTitleBackButton").GetValue(__instance);
backButton.SetState(ButtonState.Disabled);
SGLeftNavDrawer leftDrawer = (SGLeftNavDrawer)AccessTools.Field(typeof(SGRoomManager), "LeftDrawerWidget").GetValue(WIIC.sim.RoomManager);
leftDrawer.gameObject.SetActive(false);
}
}
catch (Exception e) {
WIIC.modLog.Error?.Write(e);
}
}
static bool Prefix(SGContractsWidget __instance, ref int __result, Contract contract)
{
try
{
int difficulty = contract.Override.GetUIDifficulty();
if (Fields.settings.SortByRealDifficulty)
{
difficulty = contract.Difficulty;
}
int result = 100;
SimGameState Sim = (SimGameState)ReflectionHelper.InvokePrivateMethode(__instance, "get_Sim", null);
if (Sim.ContractUserMeetsReputation(contract))
{
if (contract.Override.contractDisplayStyle == ContractDisplayStyle.BaseCampaignRestoration)
{
result = 0;
}
else if (contract.Override.contractDisplayStyle == ContractDisplayStyle.BaseCampaignStory)
{
result = 1;
}
else if (contract.TargetSystem.Replace("starsystemdef_", "").Equals(Sim.CurSystem.Name))
{
result = difficulty + 1;
}
else
{
result = difficulty + 11;
}
}
else
{
result = difficulty + 21;
}
__result = result;
return(false);
}
catch (Exception e)
{
PersistentMapClient.Logger.LogError(e);
return(false);
}
}
public static void Postfix(SGContractsWidget __instance, Contract contract,
HBSTooltip ___ContractTypeTooltip)
{
string arg;
if (contract.IsPriorityContract)
{
arg = "Priority";
}
else
{
arg = contract.Override.ContractTypeValue.Name;
}
var text2 = string.Format("ContractType{0}", arg);
text2.Replace(" ", null);
var specDesc =
Descriptions.GetMissionSpecializationDescription(contract.Override.ContractTypeValue.Name);
if (!string.IsNullOrEmpty(text2) &&
sim.DataManager.Exists(BattleTechResourceType.BaseDescriptionDef, text2))
{
var def2 = sim.DataManager.BaseDescriptionDefs.Get(text2);
if (!string.IsNullOrEmpty(specDesc))
{
if (!def2.Details.Contains(specDesc))
{
var details = def2.GetLocalizedDetails();
details.Append(specDesc);
var deets = details.ToString();
Traverse.Create(def2).Field("localizedDetails").SetValue(details);
Traverse.Create(def2).Property("Details").SetValue(deets);
}
}
___ContractTypeTooltip.SetDefaultStateData(TooltipUtilities.GetStateDataFromObject(def2));
}
}
static bool Prefix(SGContractsWidget __instance)
{
try {
SimGameState Sim = (SimGameState)AccessTools.Property(typeof(SGContractsWidget), "Sim").GetValue(__instance, null);
if (__instance.SelectedContract.Override.travelOnly && !__instance.SelectedContract.IsPriorityContract && Sim.ActiveMechs.Count < 8)
{
string message = "Commander, a deployment is a longer term arrangement with an employer, that may require missions to be done without time between them for repairs. I strongly encourage you to only deploy on this arrangement if we are capable of fielding multiple lances with little or no time for repairs, just in case.";
PauseNotification.Show("Deployment", message,
Sim.GetCrewPortrait(SimGameCrew.Crew_Darius), string.Empty, true, delegate {
__instance.NegotiateContract(__instance.SelectedContract, null);
}, "Do it anyways", null, "Cancel");
return(false);
}
else
{
return(true);
}
}
catch (Exception e) {
Logger.LogError(e);
return(true);
}
}
public static void Prefix(SGContractsWidget __instance, List <SGContractsListItem> ___listedContracts)
{
try
{
for (int i = 0; i < ___listedContracts.Count; i++)
{
SGContractsListItem sgContractsListItem = ___listedContracts[i];
if (sgContractsListItem.Contract.IsOpportunityMission())
{
opportunityMissionIndexList.Add(i);
Logger.Debug($"[SGContractsWidget_AddContract_PREFIX] Contract at index {i} is an opportunity mission");
// Temporarily set contractDisplayStyle
sgContractsListItem.Contract.Override.contractDisplayStyle = ContractDisplayStyle.BaseCampaignStory;
}
}
}
catch (Exception e)
{
Logger.Error(e);
}
}
static bool Prefix(SGContractsWidget __instance, ref int __result, Contract contract)
{
try {
int difficulty = contract.Override.GetUIDifficulty();
if (WIIC.sim.ContractUserMeetsReputation(contract))
{
if (contract.Override.contractDisplayStyle == ContractDisplayStyle.BaseCampaignRestoration)
{
__result = 0;
}
else if (contract.Override.contractDisplayStyle == ContractDisplayStyle.HeavyMetalFlashpointCampaign)
{
__result = 1;
}
else if (contract.Override.contractDisplayStyle == ContractDisplayStyle.BaseCampaignStory)
{
__result = 2;
}
else if (contract.TargetSystem.Replace("starsystemdef_", "").Equals(WIIC.sim.CurSystem.Name))
{
__result = difficulty + 2;
}
else
{
__result = difficulty + 12;
}
}
else
{
__result = difficulty + 22;
}
} catch (Exception e) {
WIIC.modLog.Error?.Write(e);
}
return(false);
}
static bool Prefix(SGContractsWidget __instance)
{
try {
if (Fields.Deployment)
{
HBSSliderInput NegPaymentSlider = (HBSSliderInput)AccessTools.Field(typeof(SGContractsWidget), "NegPaymentSlider").GetValue(__instance);
HBSSliderInput NegSalvageSlider = (HBSSliderInput)AccessTools.Field(typeof(SGContractsWidget), "NegSalvageSlider").GetValue(__instance);
float cbill = NegPaymentSlider.Value / NegPaymentSlider.ValueMax;
float salvage = NegSalvageSlider.Value / NegSalvageSlider.ValueMax;
__instance.SelectedContract.SetNegotiatedValues(cbill, salvage);
Action <bool> contractAccepted = (Action <bool>)AccessTools.Field(typeof(SGContractsWidget), "contractAccepted").GetValue(__instance);
contractAccepted(false);
return(false);
}
else
{
return(true);
}
}
catch (Exception e) {
Logger.LogError(e);
return(true);
}
}
public static void Postfix(SGContractsWidget __instance, Contract contract, LocalizableText ___ContractLocationField, GameObject ___ContractLocation, GameObject ___ContractLocationArrow, GameObject ___TravelContractBGFill, GameObject ___TravelIcon, GameObject ___PriorityMissionStoryObject)
{
try
{
// Only for "normal" contracts with no negotiations
if (contract.IsOpportunityMission())
{
Logger.Debug($"[SGContractsWidget_PopulateContract_POSTFIX] {contract.Override.ID} is an opportunity mission");
StarSystem targetSystem = contract.GameContext.GetObject(GameContextObjectTagEnum.TargetStarSystem) as StarSystem;
___ContractLocationField.SetText("Opportunity Mission at {0}", new object[] { targetSystem.Name });
___ContractLocation.SetActive(true);
___ContractLocationArrow.SetActive(false);
//___TravelContractBGFill.SetActive(false);
___TravelIcon.SetActive(false);
__instance.ForceRefreshImmediate();
}
}
catch (Exception e)
{
Logger.Error(e);
}
}
public static void Postfix(SGContractsWidget __instance, Contract contract)
{
var sim = Traverse.Create(__instance).Property("Sim").GetValue <SimGameState>();
var actualSalvage = contract.SalvagePotential;
if (actualSalvage > 0)
{
if (contract.Override.contractDisplayStyle != ContractDisplayStyle.BaseCampaignNormal)
{
actualSalvage = Mathf.FloorToInt(contract.Override.salvagePotential * contract.PercentageContractSalvage);
}
actualSalvage += sim.Constants.Finances.ContractFloorSalvageBonus;
}
var actualPrioritySalvage = Math.Min(7, Mathf.FloorToInt(actualSalvage * sim.Constants.Salvage.PrioritySalvageModifier));
Traverse.Create(__instance).Field("MetaMaxSalvageField").GetValue <TextMeshProUGUI>().text = $"{actualPrioritySalvage} / {actualSalvage}";
// for some reason this is broken, I don't know exactly why this is yielding incorrect values, consider it's identical (I think)
// to the decompiled version. There must be something I'm missing.
//Traverse.Create(__instance).Field("MetaStorySalvageField").GetValue<TextMeshProUGUI>().text = $"{actualPrioritySalvage} / {actualSalvage}";
}
public static bool Prefix(ref bool __result, SimGameResultAction action, object additionalObject)
{
try
{
SimGameState simulation = UnityGameInstance.BattleTechGame.Simulation;
if (simulation == null || action.Type != SimGameResultAction.ActionType.System_AddContract)
{
return(true);
}
// In vanilla the SimGameResultAction.ActionType.System_AddContract is only used for travel-contracts (breadcrumbs)
// I use it to add custom contracts by custom events which need to have negotiations disabled as they are "self-employed opportunity contracts"
SimGameState.AddContractData addContractData = simulation.ParseContractActionData(action.value, action.additionalValues);
ContractOverride contractOverride = simulation.DataManager.ContractOverrides.Get(addContractData.ContractName).Copy();
ContractTypeValue contractTypeValue = contractOverride.ContractTypeValue;
// Call original method if contract is a breadcrumb (used by campaign a lot)
if (contractTypeValue.IsTravelOnly)
{
return(true);
}
// Custom handling
else
{
// Validate target system and enrich contractData
StarSystem targetSystem;
Logger.Debug($"[SimGameState_ApplyEventAction_PREFIX] addContractData.TargetSystem: {addContractData.TargetSystem}");
if (!string.IsNullOrEmpty(addContractData.TargetSystem))
{
string validatedSystemString = simulation.GetValidatedSystemString(addContractData.TargetSystem);
addContractData.IsGlobal = validatedSystemString != simulation.CurSystem.ID;
if (simulation.GetSystemById(validatedSystemString) != null)
{
targetSystem = simulation.GetSystemById(validatedSystemString);
}
else
{
throw new Exception("Couldn't find StarSystem for: " + validatedSystemString);
}
}
else
{
targetSystem = simulation.CurSystem;
}
Logger.Debug($"[SimGameState_ApplyEventAction_PREFIX] targetSystem.ID: {targetSystem.ID}");
// Internal helper method
IEnumerator InjectAdditionalContractRoutine()
{
while (!targetSystem.InitialContractsFetched)
{
yield return(new WaitForSeconds(0.2f));
}
InjectAdditionalContract();
yield break;
}
// Internal helper method
void InjectAdditionalContract(bool refresh = true)
{
// Get the contract
Contract contract = simulation.GetValidContractForContractDataAndSystem(addContractData, targetSystem);
targetSystem.SystemContracts.Add(contract);
if (refresh)
{
SGContractsWidget ___contractsWidget = (SGContractsWidget)AccessTools.Field(typeof(SGRoomController_CmdCenter), "contractsWidget").GetValue(simulation.RoomManager.CmdCenterRoom);
List <Contract> allContracts = simulation.GetAllCurrentlySelectableContracts(true);
ContractDisplayStyle?___contractDisplayAutoSelect = Traverse.Create(___contractsWidget).Field("contractDisplayAutoSelect").GetValue <ContractDisplayStyle?>();
___contractsWidget.ListContracts(allContracts, ___contractDisplayAutoSelect);
}
}
if (simulation.TimeMoving)
{
simulation.PauseTimer();
simulation.StopPlayMode();
}
// Need to check this as the initial contract fetching routine clears all existing contracts
Logger.Debug($"[SimGameState_ApplyEventAction_PREFIX] targetSystem.InitialContractsFetched: {targetSystem.InitialContractsFetched}");
if (!targetSystem.InitialContractsFetched)
{
SceneSingletonBehavior <UnityGameInstance> .Instance.StartCoroutine(InjectAdditionalContractRoutine());
return(false);
}
else
{
InjectAdditionalContract(false);
// Skip original method
return(false);
}
}
}
catch (Exception e)
{
Logger.Error(e);
return(true);
}
}