public Actor harvester = null; // the harvester to protect
#endregion Fields
#region Constructors
public HarvesterDefenseSquad(IranAI AI, SquadManager manager, SquadType squadtype, SquadRole squadrole)
: base(AI, manager, squadtype, squadrole)
{
this.AI = AI;
squadtype = SquadType.Tank;
SetMaxSquadSize(2);
}
public ShipSquad(IranAI AI, SquadManager manager, SquadType squadtype, SquadRole squadrole)
: base(AI, manager, squadtype, squadrole)
{
this.AI = AI;
squadtype = SquadType.Ship;
SetMaxSquadSize(2);
// isready = true; // Important for creating new squads, if this doesn't get set somewhere the squad size will be unlimited
}
public static void SetSquadMemberRole(Squad squad, string memberId, SquadRole role)
{
SquadMember squadMemberById = SquadUtils.GetSquadMemberById(squad, memberId);
if (squadMemberById != null)
{
squadMemberById.Role = role;
}
}
public static bool CanStartMatchmakingPrep(SquadController squadController, BuildingLookupController blc)
{
SquadRole role = squadController.StateManager.Role;
bool flag = role == SquadRole.Owner || role == SquadRole.Officer;
int highestLevelHQ = blc.GetHighestLevelHQ();
bool flag2 = highestLevelHQ >= GameConstants.WAR_PARTICIPANT_MIN_LEVEL;
SquadWarStatusType currentStatus = squadController.WarManager.GetCurrentStatus();
bool flag3 = currentStatus == SquadWarStatusType.PhaseCooldown || currentStatus == SquadWarStatusType.PhaseOpen;
SquadWarData currentSquadWar = squadController.WarManager.CurrentSquadWar;
bool flag4 = currentSquadWar == null || currentSquadWar.RewardsProcessed;
return(flag2 & flag & flag3 & flag4);
}
private void Refresh()
{
if (!this.finalConfirm)
{
SquadRole role = Service.Get <SquadController>().StateManager.Role;
bool visible = role == SquadRole.Owner || role == SquadRole.Officer;
this.buttonCancel.Visible = visible;
this.buttonBack.Visible = false;
this.buttonConfirm.Visible = false;
this.labelSquadQueue.Text = this.lang.Get("WAR_MATCHMAKE_TEXT", new object[0]);
return;
}
this.buttonCancel.Visible = false;
this.buttonBack.Visible = true;
this.buttonConfirm.Visible = true;
this.labelSquadQueue.Text = this.lang.Get("WAR_MATCHMAKE_CANCEL_CONFIRM_TEXT", new object[0]);
}
public static string GetSquadRoleDisplayName(SquadRole role)
{
string result = null;
switch (role)
{
case SquadRole.Member:
result = Service.Get <Lang>().Get("SQUAD_MEMBER", new object[0]);
break;
case SquadRole.Officer:
result = Service.Get <Lang>().Get("SQUAD_OFFICER", new object[0]);
break;
case SquadRole.Owner:
result = Service.Get <Lang>().Get("SQUAD_OWNER", new object[0]);
break;
}
return(result);
}
private bool IsSatisfied()
{
int num = Convert.ToInt32(this.prepareArgs[0], CultureInfo.InvariantCulture);
bool result = false;
SquadController squadController = Service.Get <SquadController>();
if (squadController.StateManager.GetCurrentSquad() == null)
{
if (num == 0)
{
result = true;
}
}
else
{
SquadRole role = squadController.StateManager.Role;
switch (num)
{
case 1:
result = true;
break;
case 2:
if (role == SquadRole.Owner || role == SquadRole.Officer)
{
result = true;
}
break;
case 3:
if (role == SquadRole.Owner)
{
result = true;
}
break;
}
}
return(result);
}
private bool IsSatisfied()
{
int num = Convert.ToInt32(this.prepareArgs[0]);
bool result = false;
SquadController squadController = Service.SquadController;
if (squadController.StateManager.GetCurrentSquad() == null)
{
if (num == 0)
{
result = true;
}
}
else
{
SquadRole role = squadController.StateManager.Role;
if (num != 3)
{
if (num != 2)
{
if (num == 1)
{
result = true;
}
}
else if (role == SquadRole.Owner || role == SquadRole.Officer)
{
result = true;
}
}
else if (role == SquadRole.Owner)
{
result = true;
}
}
return(result);
}
public static string GetSquadRoleDisplayName(SquadRole role)
{
string result = null;
if (role != SquadRole.Member)
{
if (role != SquadRole.Officer)
{
if (role == SquadRole.Owner)
{
result = Service.Lang.Get("SQUAD_OWNER", new object[0]);
}
}
else
{
result = Service.Lang.Get("SQUAD_OFFICER", new object[0]);
}
}
else
{
result = Service.Lang.Get("SQUAD_MEMBER", new object[0]);
}
return(result);
}
public override void RefreshView()
{
SquadController squadController = Service.SquadController;
SquadScreenState squadScreenState = squadController.StateManager.SquadScreenState;
SquadRole role = squadController.StateManager.Role;
bool flag = role == SquadRole.Owner || role == SquadRole.Officer;
bool flag2 = flag && Service.BuildingLookupController.GetHighestLevelHQ() > GameConstants.WAR_PARTICIPANT_MIN_LEVEL;
string squadName = squadController.StateManager.GetCurrentSquad().SquadName;
this.labelChatTitle.Text = this.lang.Get("SQUAD_CHAT_TITLE", new object[]
{
squadName
});
IState currentState = Service.GameStateMachine.CurrentState;
if (squadScreenState != SquadScreenState.Advancement && currentState is HomeState)
{
switch (squadController.WarManager.GetCurrentStatus())
{
case SquadWarStatusType.PhaseOpen:
if (!flag2)
{
this.btnStartWar.Visible = false;
return;
}
if (squadController.WarManager.IsCurrentSquadMatchmaking())
{
this.btnStartWar.Visible = true;
this.btnStartWar.SetDefaultColor(1f, 0f, 0f, 1f);
this.labelBtnStartWar.Text = this.lang.Get("WAR_BUTTON_CANCEL_MATCHMAKING", new object[0]);
}
else
{
this.btnStartWar.SetDefaultColor(1f, 1f, 1f, 1f);
this.labelBtnStartWar.Text = this.lang.Get("WAR_BUTTON_START_WAR", new object[0]);
if (squadController.WarManager.MatchMakingPrepMode)
{
this.btnStartWar.Visible = false;
}
else
{
this.btnStartWar.Visible = squadController.WarManager.CanStartSquadWar();
}
}
break;
case SquadWarStatusType.PhasePrep:
case SquadWarStatusType.PhasePrepGrace:
case SquadWarStatusType.PhaseAction:
case SquadWarStatusType.PhaseActionGrace:
case SquadWarStatusType.PhaseCooldown:
this.btnStartWar.SetDefaultColor(1f, 1f, 1f, 1f);
this.labelBtnStartWar.Text = this.lang.Get("SQUAD_WAR_VIEW_WAR", new object[0]);
this.btnStartWar.Visible = true;
break;
}
}
else
{
this.btnStartWar.Visible = false;
}
this.labelFilterBy.Visible = !this.btnStartWar.Visible;
}
protected override void OnScreenLoaded()
{
SquadController squadController = Service.SquadController;
bool flag = squadController.StateManager.GetCurrentSquad() != null;
SquadRole role = squadController.StateManager.Role;
bool flag2 = role == SquadRole.Owner || role == SquadRole.Officer;
int highestLevelHQ = Service.BuildingLookupController.GetHighestLevelHQ();
this.InitButtons();
UXLabel element = base.GetElement <UXLabel>("LabelTitle");
element.Text = this.lang.Get("WAR_START_TITLE", new object[0]);
string id;
string id2;
if (!flag)
{
id = "WAR_START_DESCRIPTION_NOSQUAD";
id2 = "WAR_START_BUTTON_TEXT_NOSQUAD";
}
else if (flag2)
{
if (highestLevelHQ >= GameConstants.WAR_PARTICIPANT_MIN_LEVEL)
{
id = "WAR_START_DESCRIPTION_OFFICER";
id2 = "WAR_START_BUTTON_TEXT";
}
else
{
id = "WAR_START_DESCRIPTION_OFFICER_INELIGIBLE";
id2 = "WAR_START_BUTTON_TEXT_NONOFFICER";
}
}
else
{
this.LogMemberAttemptingWarStart();
id = "WAR_START_DESCRIPTION_NONOFFICER";
id2 = "WAR_START_BUTTON_TEXT_NONOFFICER";
}
UXLabel element2 = base.GetElement <UXLabel>("LabelSquadWar");
element2.Text = this.lang.Get(id, new object[]
{
highestLevelHQ
});
TextureVO optional = Service.StaticDataController.GetOptional <TextureVO>("gui_textures_squadwar_start");
if (optional != null)
{
UXTexture element3 = base.GetElement <UXTexture>("SpriteNextImage");
element3.LoadTexture(optional.AssetName);
}
UXLabel element4 = base.GetElement <UXLabel>("LabelBtnNext");
element4.Text = this.lang.Get(id2, new object[0]);
UXButton element5 = base.GetElement <UXButton>("BtnNext");
element5.OnClicked = new UXButtonClickedDelegate(this.OnNextButtonClicked);
UXButton element6 = base.GetElement <UXButton>("BtnInfo");
element6.OnClicked = new UXButtonClickedDelegate(squadController.WarManager.ShowInfoScreen);
}
public void OnNewSquadMsgsReceived(List <SquadMsg> msgs)
{
bool flag = false;
Squad currentSquad = this.StateManager.GetCurrentSquad();
bool flag2 = false;
string playerId = Service.CurrentPlayer.PlayerId;
int i = 0;
int count = msgs.Count;
while (i < count)
{
SquadMsg squadMsg = msgs[i];
uint timeForNewMsgFiltering = this.GetTimeForNewMsgFiltering(squadMsg);
if (squadMsg.TimeSent >= timeForNewMsgFiltering)
{
bool flag3 = squadMsg.OwnerData == null || squadMsg.OwnerData.PlayerId == null;
bool flag4 = squadMsg.OwnerData != null && squadMsg.OwnerData.PlayerId == playerId;
switch (squadMsg.Type)
{
case SquadMsgType.Join:
case SquadMsgType.InviteAccepted:
case SquadMsgType.Leave:
flag = true;
break;
case SquadMsgType.JoinRequestAccepted:
{
string text = (squadMsg.SquadData == null) ? null : squadMsg.SquadData.Id;
if (flag4 && !string.IsNullOrEmpty(text))
{
this.StateManager.OnSquadJoinApplicationAccepted(text);
Squad currentSquad2 = this.StateManager.GetCurrentSquad();
this.ClearPrefsForNewSquad(currentSquad2.Level);
}
flag = true;
break;
}
case SquadMsgType.JoinRequestRejected:
{
string text2 = (squadMsg.SquadData == null) ? null : squadMsg.SquadData.Id;
if (flag3 && !string.IsNullOrEmpty(text2))
{
this.StateManager.OnSquadJoinApplicationRejected(text2);
}
break;
}
case SquadMsgType.Ejected:
if (flag3)
{
this.LeaveSquad(Service.Lang.Get("CURRENT_PLAYER_EJECTED", new object[0]));
}
else
{
SquadUtils.RemoveSquadMember(currentSquad, squadMsg.OwnerData.PlayerId);
}
flag = true;
break;
case SquadMsgType.Promotion:
case SquadMsgType.Demotion:
{
SquadRole role = (squadMsg.MemberData == null) ? SquadRole.Member : squadMsg.MemberData.MemberRole;
if (flag4)
{
this.StateManager.Role = role;
}
SquadUtils.SetSquadMemberRole(currentSquad, squadMsg.OwnerData.PlayerId, role);
break;
}
case SquadMsgType.TroopDonation:
if (squadMsg.DonationData != null && squadMsg.DonationData.RecipientId == playerId)
{
if (!string.IsNullOrEmpty(squadMsg.DonationData.RequestId))
{
SquadMsg msgById = this.MsgManager.GetMsgById(squadMsg.DonationData.RequestId);
if (msgById != null && msgById.RequestData != null && msgById.RequestData.IsWarRequest)
{
flag = true;
break;
}
}
string text3 = (squadMsg.OwnerData == null) ? null : squadMsg.OwnerData.PlayerId;
Dictionary <string, int> donations = squadMsg.DonationData.Donations;
if (text3 != null && donations != null)
{
SquadMember squadMemberById = SquadUtils.GetSquadMemberById(currentSquad, text3);
string donorName = (squadMemberById == null) ? null : squadMemberById.MemberName;
this.StateManager.OnSquadTroopsReceived(donations, text3, donorName);
}
}
break;
case SquadMsgType.WarMatchMakingBegin:
flag = true;
this.WarManager.OnWarMatchMakingBegin();
break;
case SquadMsgType.WarMatchMakingCancel:
if (!flag4)
{
this.WarManager.CancelMatchMaking();
}
flag = true;
break;
case SquadMsgType.WarStarted:
case SquadMsgType.WarBuffBaseAttackStart:
case SquadMsgType.WarBuffBaseAttackComplete:
case SquadMsgType.WarPlayerAttackStart:
case SquadMsgType.WarPlayerAttackComplete:
case SquadMsgType.WarEnded:
this.WarManager.HandleWarEventMsg(squadMsg);
break;
case SquadMsgType.WarPrepared:
flag = true;
break;
case SquadMsgType.SquadLevelUp:
flag2 = true;
this.OnSquadLeveledUp(squadMsg);
break;
case SquadMsgType.PerkUnlocked:
flag2 = true;
this.OnPerkUnlocked(squadMsg);
break;
case SquadMsgType.PerkUpgraded:
flag2 = true;
this.OnPerkUpgraded(squadMsg);
break;
case SquadMsgType.PerkInvest:
flag2 = true;
this.OnPerkInvestment(squadMsg);
break;
case SquadMsgType.Invite:
if (squadMsg.FriendInviteData != null && flag3)
{
SquadInvite invite = SquadMsgUtils.GenerateSquadInvite(squadMsg);
this.StateManager.AddSquadInvite(invite);
}
break;
case SquadMsgType.InviteRejected:
{
string text4 = (squadMsg.FriendInviteData == null) ? null : squadMsg.FriendInviteData.PlayerId;
if (text4 != null && flag3)
{
this.StateManager.PlayersInvitedToSquad.Remove(text4);
}
break;
}
}
SquadMsgType[] array = null;
switch (squadMsg.Type)
{
case SquadMsgType.JoinRequestAccepted:
case SquadMsgType.JoinRequestRejected:
array = new SquadMsgType[]
{
SquadMsgType.JoinRequest
};
break;
case SquadMsgType.Leave:
case SquadMsgType.Ejected:
array = new SquadMsgType[]
{
SquadMsgType.JoinRequest,
SquadMsgType.ShareBattle,
SquadMsgType.TroopRequest
};
break;
}
if (array != null && squadMsg.OwnerData != null)
{
this.MsgManager.RemoveMsgsByType(squadMsg.OwnerData.PlayerId, array);
}
}
i++;
}
if (flag2)
{
Service.PerkViewController.UpdateLastViewedPerkTime();
}
if (flag)
{
this.UpdateCurrentSquad();
}
}
public virtual void Tick()
{
if (members.Count() == 0) return;
// Check if enemy unit is nearby
if (AI.ticks % 25 == 0)
{
Actor leader = members.First();
var EnemyUnits = world.FindUnitsInCircle(leader.CenterLocation, 120)
.Where(a => AI.p.Stances[a.Owner] == Stance.Enemy);
if (EnemyUnits != null && EnemyUnits.Count() != 0)
{
EnemyNearby = true;
OnEnemyUnitsNearby(EnemyUnits);
}
else
{
EnemyNearby = false;
}
}
if (AI.ticks % 75 == 0 && !EnemyNearby)
{
if (IsReady() && squadrole == SquadRole.AttackBase) // we're ready to attack
{
// if we have a target update our move-to location
if (Target != null && !Target.IsDead() && !Target.Destroyed)
{
CPos Location = Target.Location;
Move(Location, false, 8);
}
else // if we don't have a target find one
{
Target = AI.ChooseEnemyTarget("nuke");
CPos Location = Target.Location;
Move(Location, false, 8);
}
}
if (!IsReady()) // While we're not ready check if squad is full, if it is set us to ready
{
isready = IsFull();
}
if ((squadrole == SquadRole.DefendBase) && (AI.ticks - manager.lastbasedamagetick > BaseDefenseTime))
{
AI.Debug("Squad: No attack for {0} secs, switching to attack mode.", BaseDefenseTime / 25);
squadrole = SquadRole.AttackBase;
}
if (squadrole == SquadRole.DefendBase)
{
// AI.Debug("Squad in DefendBase role");
}
}
}
public void SetSquadRole(SquadRole squadrole)
{
this.squadrole = squadrole;
}
public virtual void OnBaseDamage(Actor building, AttackInfo e)
{
// if (manager.squads.Where(s => s.GetSquadRole() == SquadRole.DefendBase).Count() < 2)
{
AI.Debug("switching to DefendBase role, base under attack");
squadrole = SquadRole.DefendBase;
// Move(building.Location, false, 8);
Attack(new[]{e.Attacker}, false);
}
if (squadrole == SquadRole.DefendBase)
{
// Move(building.Location, false, 8);
Attack(new[] { e.Attacker }, false);
}
}
public Squad(IranAI AI, SquadManager manager, SquadType squadtype, SquadRole squadrole)
{
this.AI = AI;
this.manager = manager;
this.squadtype = squadtype;
this.world = AI.world;
this.squadrole = squadrole;
members = new List<Actor>();
}
