public override bool Check(IDiplomaticContract diplomaticContract, global::Empire empireWhichProvides, global::Empire empireWhichReceives)
{
global::Game game = Services.GetService <IGameService>().Game as global::Game;
IDiplomaticContractRepositoryService service = game.Services.GetService <IDiplomaticContractRepositoryService>();
Predicate <DiplomaticContract> match = (DiplomaticContract contract) => (contract.EmpireWhichProposes == empireWhichProvides && contract.EmpireWhichReceives == empireWhichReceives) || (contract.EmpireWhichProposes == empireWhichReceives && contract.EmpireWhichReceives == empireWhichProvides);
int num = -100;
bool flag = false;
foreach (DiplomaticContract diplomaticContract2 in service.FindAll(match))
{
if (diplomaticContract2.State == DiplomaticContractState.Signed)
{
string[] diplomaticTermNames = this.DiplomaticTermNames;
for (int i = 0; i < diplomaticTermNames.Length; i++)
{
string termname = diplomaticTermNames[i];
if (termname.Contains("ToWar"))
{
flag = true;
}
if (!this.OnlyWhenProposer)
{
if (diplomaticContract2.Terms.Any((DiplomaticTerm term) => term.Definition.Name.ToString() == termname))
{
num = Mathf.Max(num, diplomaticContract2.TurnAtTheBeginningOfTheState);
}
}
else if (diplomaticContract2.Terms.Any((DiplomaticTerm term) => term.Definition.Name.ToString() == termname && term.EmpireWhichProvides == empireWhichProvides))
{
num = Mathf.Max(num, diplomaticContract2.TurnAtTheBeginningOfTheState);
}
}
}
}
if (flag)
{
match = ((DiplomaticContract contract) => contract.EmpireWhichProposes == empireWhichProvides || contract.EmpireWhichReceives == empireWhichProvides);
Func <DiplomaticTerm, bool> < > 9__4;
foreach (DiplomaticContract diplomaticContract3 in service.FindAll(match))
{
if (diplomaticContract3.State == DiplomaticContractState.Signed)
{
IEnumerable <DiplomaticTerm> terms = diplomaticContract3.Terms;
Func <DiplomaticTerm, bool> predicate;
if ((predicate = < > 9__4) == null)
{
predicate = (< > 9__4 = ((DiplomaticTerm term) => term is DiplomaticTermProposal && term.EmpireWhichProvides == empireWhichProvides && (term as DiplomaticTermProposal).ChosenEmpire == empireWhichReceives && term.Definition.Name == "AskToDeclareWar"));
}
if (terms.Any(predicate))
{
num = Mathf.Max(num, diplomaticContract3.TurnAtTheBeginningOfTheState);
}
}
}
}
return(base.Inverted ^ game.Turn - num >= this.Cooldown);
}
public override bool Check(IDiplomaticContract diplomaticContract, Empire empireWhichProvides, Empire empireWhichReceives)
{
Diagnostics.Assert(this.Prerequisites != null && this.Prerequisites.Length != 0);
int num = 0;
for (int i = 0; i < this.Prerequisites.Length; i++)
{
if (this.Prerequisites[i].Check(diplomaticContract, empireWhichProvides, empireWhichReceives))
{
num++;
}
}
bool flag;
switch (this.Operator)
{
case DiplomaticMetaPrerequisite.OperatorType.OR:
flag = (num > 0);
break;
case DiplomaticMetaPrerequisite.OperatorType.XOR:
flag = (num == 1);
break;
case DiplomaticMetaPrerequisite.OperatorType.NOR:
flag = (num == 0);
break;
case DiplomaticMetaPrerequisite.OperatorType.AND:
flag = (num == this.Prerequisites.Length);
break;
case DiplomaticMetaPrerequisite.OperatorType.NAND:
flag = (num < this.Prerequisites.Length);
break;
default:
throw new ArgumentOutOfRangeException("Operator");
}
return(base.Inverted ^ flag);
}
public override bool CanApply(IDiplomaticContract diplomaticContract, params string[] flags)
{
if (!base.CanApply(diplomaticContract, new string[0]))
{
return(false);
}
Diagnostics.Assert(base.EmpireWhichProvides != null && base.EmpireWhichReceives != null);
Diagnostics.Assert(base.EmpireWhichProvides.Index != base.EmpireWhichReceives.Index);
DepartmentOfTheTreasury agency = base.EmpireWhichProvides.GetAgency <DepartmentOfTheTreasury>();
DepartmentOfTheTreasury agency2 = base.EmpireWhichReceives.GetAgency <DepartmentOfTheTreasury>();
Diagnostics.Assert(agency != null && agency2 != null);
float num = -this.Amount;
if ((this.BufferedAmount != this.Amount || this.BufferedAmount == 0f) && !agency.IsTransferOfResourcePossible(base.EmpireWhichProvides, this.ResourceName, ref num))
{
return(false);
}
num = this.Amount;
return(agency2.IsTransferOfResourcePossible(base.EmpireWhichReceives, this.ResourceName, ref num));
}
public override bool CanApply(IDiplomaticContract diplomaticContract, params string[] flags)
{
if (!base.CanApply(diplomaticContract, new string[0]))
{
return(false);
}
Diagnostics.Assert(base.EmpireWhichProvides != null && base.EmpireWhichReceives != null);
DepartmentOfTheInterior agency = base.EmpireWhichProvides.GetAgency <DepartmentOfTheInterior>();
DepartmentOfTheInterior agency2 = base.EmpireWhichReceives.GetAgency <DepartmentOfTheInterior>();
Diagnostics.Assert(agency != null && agency2 != null);
City city = agency.Cities.FirstOrDefault((City match) => match.GUID == this.CityGUID);
if (city == null)
{
return(false);
}
if (city.BesiegingEmpire != null)
{
return(false);
}
if (diplomaticContract.EmpireWhichProposes.Index != base.EmpireWhichProvides.Index)
{
IGameService service = Services.GetService <IGameService>();
Diagnostics.Assert(service != null);
IVisibilityService service2 = service.Game.Services.GetService <IVisibilityService>();
Diagnostics.Assert(service2 != null);
District cityCenter = city.GetCityCenter();
if (cityCenter == null || !service2.IsWorldPositionExploredFor(cityCenter.WorldPosition, base.EmpireWhichReceives))
{
return(false);
}
}
if (base.Definition.Name == DiplomaticTermCityExchange.MimicsCityDeal)
{
if (agency.MainCity == city)
{
return(false);
}
if (base.EmpireWhichProvides.Faction.Affinity.Name == base.EmpireWhichReceives.Faction.Affinity.Name)
{
return(false);
}
if (city.IsInfected)
{
return(false);
}
if (base.EmpireWhichReceives.GetAgency <DepartmentOfPlanificationAndDevelopment>().HasIntegratedFaction(base.EmpireWhichProvides.Faction))
{
return(false);
}
if (agency2.InfectedCities.Any((City c) => c.LastNonInfectedOwner != null && (c.LastNonInfectedOwner == base.EmpireWhichProvides || c.LastNonInfectedOwner.Faction == base.EmpireWhichProvides.Faction)))
{
return(false);
}
}
int num = agency.Cities.Count;
int num2 = agency2.Cities.Count;
for (int i = 0; i < diplomaticContract.Terms.Count; i++)
{
DiplomaticTermCityExchange diplomaticTermCityExchange = diplomaticContract.Terms[i] as DiplomaticTermCityExchange;
if (diplomaticTermCityExchange != null && !(diplomaticTermCityExchange.CityGUID == this.CityGUID))
{
if (base.Definition.Name == DiplomaticTermCityExchange.MimicsCityDeal)
{
return(false);
}
if (diplomaticTermCityExchange.EmpireWhichProvides.Index == base.EmpireWhichProvides.Index)
{
num--;
num2++;
}
else if (diplomaticTermCityExchange.EmpireWhichProvides.Index == base.EmpireWhichReceives.Index)
{
num2--;
num++;
}
else
{
Diagnostics.LogError("Can't identify the empire which provides the term {0}.", new object[]
{
diplomaticTermCityExchange
});
}
}
}
num--;
num2++;
return(num >= 1 && num2 >= 1);
}
