public static bool CanLeaveSquad()
{
bool result = true;
SquadController squadController = Service.Get <SquadController>();
CurrentPlayer currentPlayer = Service.Get <CurrentPlayer>();
Squad currentSquad = squadController.StateManager.GetCurrentSquad();
if (currentSquad == null)
{
return(result);
}
SquadWarStatusType currentStatus = squadController.WarManager.GetCurrentStatus();
if (currentStatus == SquadWarStatusType.PhaseCooldown)
{
return(result);
}
SquadMember squadMemberById = SquadUtils.GetSquadMemberById(currentSquad, currentPlayer.PlayerId);
if (squadController.WarManager.IsMemberInWarParty(squadMemberById.MemberID) || squadController.WarManager.IsSquadMemberInWarOrMatchmaking(squadMemberById))
{
result = false;
}
return(result);
}
private void OnUpdateSquadSuccess(SquadResponse response, object cookie)
{
Squad currentSquad = this.controller.StateManager.GetCurrentSquad();
if (currentSquad != null)
{
string currentWarId = currentSquad.CurrentWarId;
currentSquad.FromObject(response.SquadData);
this.controller.SyncCurrentPlayerRole();
bool flag = !string.IsNullOrEmpty(currentSquad.CurrentWarId);
if (flag && (this.controller.WarManager.CurrentSquadWar == null || currentSquad.CurrentWarId != currentWarId))
{
this.UpdateSquadWar(currentSquad.CurrentWarId, false);
}
else
{
SquadWarStatusType currentStatus = this.controller.WarManager.GetCurrentStatus();
if (flag && currentStatus == SquadWarStatusType.PhasePrep)
{
this.UpdateCurrentSquadWar();
}
else
{
Service.Get <EventManager>().SendEvent(EventId.SquadUpdateCompleted, null);
}
}
}
else
{
Service.Get <EventManager>().SendEvent(EventId.SquadUpdateCompleted, null);
}
Service.Get <EventManager>().SendEvent(EventId.SquadDetailsUpdated, null);
}
public static bool FillOutWarPhaseTimeRange(SquadWarData data, SquadWarStatusType type, out int startTime, out int endTime)
{
bool result = false;
startTime = 0;
endTime = 0;
if (data != null)
{
switch (type)
{
case SquadWarStatusType.PhasePrep:
case SquadWarStatusType.PhasePrepGrace:
result = true;
startTime = data.StartTimeStamp;
endTime = data.PrepEndTimeStamp;
break;
case SquadWarStatusType.PhaseAction:
case SquadWarStatusType.PhaseActionGrace:
result = true;
startTime = data.PrepEndTimeStamp;
endTime = data.ActionEndTimeStamp;
break;
case SquadWarStatusType.PhaseCooldown:
result = true;
startTime = data.ActionEndTimeStamp;
endTime = data.CooldownEndTimeStamp;
break;
}
}
return(result);
}
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);
}
public SquadWarSquadType GetCurrentDisplaySquad()
{
SquadWarManager warManager = Service.Get <SquadController>().WarManager;
SquadWarStatusType currentStatus = warManager.GetCurrentStatus();
SquadWarSquadType result = SquadWarSquadType.PLAYER_SQUAD;
if (currentStatus == SquadWarStatusType.PhasePrep || currentStatus == SquadWarStatusType.PhasePrepGrace)
{
result = SquadWarSquadType.PLAYER_SQUAD;
}
else if (currentStatus == SquadWarStatusType.PhaseAction || currentStatus == SquadWarStatusType.PhaseActionGrace || currentStatus == SquadWarStatusType.PhaseCooldown)
{
result = SquadWarSquadType.OPPONENT_SQUAD;
}
return(result);
}
public static bool IsTimeWithinSquadWarPhase(SquadWarData data, uint serverTime)
{
bool result = false;
if (data != null && (ulong)serverTime >= (ulong)((long)data.StartTimeStamp) && (ulong)serverTime < (ulong)((long)data.CooldownEndTimeStamp))
{
SquadWarStatusType warStatus = SquadUtils.GetWarStatus(data, Service.Get <ServerAPI>().ServerTime);
int num = 0;
int num2 = 0;
if (SquadUtils.FillOutWarPhaseTimeRange(data, warStatus, out num, out num2))
{
result = ((ulong)serverTime >= (ulong)((long)num) && (ulong)serverTime < (ulong)((long)num2));
}
}
return(result);
}
public void SelectBuilding(GameObject building)
{
Quaternion rotationTarget = Service.Get <WarBoardViewController>().GetRotationTarget(building.transform);
Quaternion planetRotation = Service.Get <WarBoardViewController>().GetPlanetRotation();
float num = rotationTarget.eulerAngles.x - planetRotation.eulerAngles.x;
if (num < -7.7f || num > 1.9f)
{
return;
}
SquadWarParticipantState participantState = this.GetParticipantState(building);
if (participantState == null)
{
return;
}
SquadWarManager warManager = Service.Get <SquadController>().WarManager;
SquadWarStatusType currentStatus = warManager.GetCurrentStatus();
if (currentStatus == SquadWarStatusType.PhaseCooldown)
{
return;
}
this.selectedBuilding = building;
Transform transform = building.transform;
if (transform.childCount > 0)
{
GameObject gameObject = transform.GetChild(0).gameObject;
this.outline.Init(gameObject, "PL_2Color_Mask_HoloBldg_Outline");
}
if (participantState != null)
{
Service.Get <EventManager>().SendEvent(EventId.WarBoardParticipantBuildingSelected, building);
}
}
public EatResponse OnEvent(EventId id, object cookie)
{
if (id <= EventId.SquadScreenOpenedOrClosed)
{
if (id != EventId.GameStateChanged)
{
if (id == EventId.SquadScreenOpenedOrClosed)
{
this.UpdatePollFrequency();
}
}
else
{
SquadWarManager warManager = this.controller.WarManager;
if (this.IsValidUpdateGameState() && warManager.WarExists())
{
this.UpdateSquadWar(warManager.CurrentSquadWar.WarId, true);
Service.Get <EventManager>().UnregisterObserver(this, EventId.GameStateChanged);
}
}
}
else if (id != EventId.SquadUpdated)
{
if (id != EventId.SquadServerMessage)
{
if (id == EventId.WarPhaseChanged)
{
SquadWarStatusType squadWarStatusType = (SquadWarStatusType)cookie;
this.UpdateCurrentSquadWar();
if (squadWarStatusType == SquadWarStatusType.PhaseCooldown)
{
this.controller.UpdateCurrentSquad();
}
}
}
else
{
SquadServerMessage squadServerMessage = (SquadServerMessage)cookie;
if (squadServerMessage.Messages != null)
{
if (this.serverMessages == null)
{
this.serverMessages = new List <SquadMsg>();
}
else
{
this.serverMessages.Clear();
}
uint num = 0u;
int i = 0;
int count = squadServerMessage.Messages.Count;
while (i < count)
{
SquadMsg squadMsg = SquadMsgUtils.GenerateMessageFromServerMessageObject(squadServerMessage.Messages[i]);
if (squadMsg != null)
{
this.serverMessages.Add(squadMsg);
if (!string.IsNullOrEmpty(squadMsg.NotifId) && squadMsg.TimeSent > num)
{
num = squadMsg.TimeSent;
}
}
i++;
}
if (num > 0u)
{
this.notifAdapter.ResetPollTimer(num);
}
this.OnNewSquadMsgs(this.serverMessages);
}
}
}
else if (cookie == null)
{
this.DisablePolling();
}
else
{
this.EnablePolling();
}
return(EatResponse.NotEaten);
}
public virtual void OnEnter()
{
Service.Get <UXController>().MiscElementsManager.RemoveGalaxyTournamentStatus();
HudConfig hudConfig = null;
BattleType battleType = this.battleData.BattleType;
switch (battleType)
{
case BattleType.Pvp:
hudConfig = new HudConfig(new string[]
{
"Currency",
"OpponentInfo",
"MedalInfo",
"ButtonHome",
"LabelBaseNameOpponent",
"TroopsGrid",
"LabelDeployInstructions",
"LabelCurrencyValueOpponent"
});
if (!this.battleData.IsRevenge)
{
hudConfig.Add("ButtonNextBattle");
}
break;
case BattleType.PveDefend:
hudConfig = new HudConfig(new string[]
{
"Currency",
"PlayerInfo",
"LabelBaseNameOpponent",
"LabelCurrencyValueOpponent",
"TroopsGrid",
"LabelDeployInstructions"
});
break;
case BattleType.PveAttack:
case BattleType.PveFue:
case BattleType.ClientBattle:
hudConfig = new HudConfig(new string[]
{
"Currency",
"OpponentInfo",
"ButtonHome",
"LabelBaseNameOpponent",
"TroopsGrid",
"LabelDeployInstructions",
"LabelCurrencyValueOpponent"
});
break;
case BattleType.PveBuffBase:
case BattleType.PvpAttackSquadWar:
{
hudConfig = new HudConfig(new string[]
{
"OpponentInfo",
"LabelBaseNameOpponent",
"WarAttack"
});
SquadWarManager warManager = Service.Get <SquadController>().WarManager;
bool flag = this.battleData.Attacker.PlayerFaction == this.battleData.Defender.PlayerFaction;
SquadWarStatusType currentStatus = warManager.GetCurrentStatus();
if (!flag)
{
hudConfig.Add("BuffsYoursSquadWars");
}
if (battleType != BattleType.PveBuffBase)
{
hudConfig.Add("BuffsOpponentsSquadWars");
}
if (this.battleData.Attacker.GuildId != this.battleData.Defender.GuildId && !warManager.IsCurrentlyScoutingOwnedBuffBase())
{
hudConfig.Add("WarAttackOpponent");
if (currentStatus == SquadWarStatusType.PhaseAction)
{
hudConfig.Add("TroopsGrid");
}
}
if (currentStatus == SquadWarStatusType.PhasePrep)
{
if (battleType == BattleType.PvpAttackSquadWar)
{
Service.Get <BuildingController>().EnterSelectMode();
}
else
{
Service.Get <BuildingController>().ExitAllModes();
}
}
break;
}
}
if (hudConfig != null)
{
Service.Get <UXController>().HUD.ConfigureControls(hudConfig);
}
}
public EatResponse OnEvent(EventId id, object cookie)
{
bool flag = false;
if (Service.IsSet <BaseLayoutToolController>())
{
flag = Service.Get <BaseLayoutToolController>().IsBaseLayoutModeActive;
}
switch (id)
{
case EventId.BuildingPurchaseModeStarted:
this.IsBuildingPendingPurchase = true;
this.hud.CurrentHudConfig.Remove("BtnActivateStash");
this.hud.RefreshView();
break;
case EventId.BuildingPurchaseModeEnded:
this.IsBuildingPendingPurchase = false;
if (!GameConstants.DISABLE_BASE_LAYOUT_TOOL)
{
this.hud.CurrentHudConfig.Add("BtnActivateStash");
this.hud.RefreshView();
}
break;
case EventId.BuildingStartedUpgrading:
case EventId.BuildingSelectedFromStore:
case EventId.BuildingSelectedSound:
break;
case EventId.BuildingSelected:
if (flag)
{
this.RefreshInstructionLabel();
this.RefreshCurrencyTray(true);
}
break;
case EventId.BuildingDeselected:
if (flag)
{
this.RefreshInstructionLabel();
this.RefreshCurrencyTray(false);
}
break;
default:
if (id == EventId.WarPhaseChanged)
{
if (!(Service.Get <GameStateMachine>().CurrentState is WarBaseEditorState))
{
Service.Get <StaRTSLogger>().Warn("Not in War Base Editor when responding to Squad War phase change");
}
else
{
SquadWarStatusType squadWarStatusType = (SquadWarStatusType)cookie;
if (squadWarStatusType != SquadWarStatusType.PhasePrep)
{
this.ShowForceExitAlert();
}
}
}
break;
}
return(EatResponse.NotEaten);
}
