private void HandleServerEventKillDeathCountChangeEvent(KillDeathCountChange message)
{
if (message.VictimPeer == null)
{
return;
}
MissionPeer component = message.VictimPeer.GetComponent <MissionPeer>();
NetworkCommunicator attackerPeer = message.AttackerPeer;
MissionPeer killedPeer = attackerPeer != null?attackerPeer.GetComponent <MissionPeer>() : (MissionPeer)null;
if (component != null)
{
component.KillCount = message.KillCount;
component.AssistCount = message.AssistCount;
component.DeathCount = message.DeathCount;
component.Score = message.Score;
component.OnKillAnotherPeer(killedPeer);
if (message.KillCount == 0 && message.AssistCount == 0 && (message.DeathCount == 0 && message.Score == 0))
{
component.ResetKillRegistry();
}
}
if (this._missionScoreboardComponent == null)
{
return;
}
this._missionScoreboardComponent.PlayerPropertiesChanged(message.VictimPeer);
}
protected BodyProperties GetBodyProperties(
MissionPeer missionPeer,
BasicCultureObject cultureLimit)
{
NetworkCommunicator networkPeer = missionPeer.GetNetworkPeer();
if (networkPeer != null)
{
return(networkPeer.PlayerConnectionInfo.GetParameter <PlayerData>("PlayerData").BodyProperties);
}
Team team = missionPeer.Team;
BasicCharacterObject troopCharacter = MultiplayerClassDivisions.GetMPHeroClasses(cultureLimit).ToList <MultiplayerClassDivisions.MPHeroClass>().GetRandomElement <MultiplayerClassDivisions.MPHeroClass>().TroopCharacter;
MatrixFrame spawnFrame = this.SpawnComponent.GetSpawnFrame(team, troopCharacter.HasMount(), true);
AgentBuildData agentBuildData = new AgentBuildData(troopCharacter);
agentBuildData.Team(team);
agentBuildData.InitialFrame(spawnFrame);
agentBuildData.TroopOrigin((IAgentOriginBase) new BasicBattleAgentOrigin(troopCharacter));
agentBuildData.EquipmentSeed(this.MissionLobbyComponent.GetRandomFaceSeedForCharacter(troopCharacter));
agentBuildData.ClothingColor1(team.Side == BattleSideEnum.Attacker ? cultureLimit.Color : cultureLimit.ClothAlternativeColor);
agentBuildData.ClothingColor2(team.Side == BattleSideEnum.Attacker ? cultureLimit.Color2 : cultureLimit.ClothAlternativeColor2);
agentBuildData.IsFemale(troopCharacter.IsFemale);
agentBuildData.Equipment(Equipment.GetRandomEquipmentElements(troopCharacter, !(Game.Current.GameType is MultiplayerGame), seed: agentBuildData.AgentEquipmentSeed));
agentBuildData.BodyProperties(BodyProperties.GetRandomBodyProperties(agentBuildData.AgentIsFemale, troopCharacter.GetBodyPropertiesMin(), troopCharacter.GetBodyPropertiesMax(), (int)agentBuildData.AgentOverridenSpawnEquipment.HairCoverType, agentBuildData.AgentEquipmentSeed, troopCharacter.HairTags, troopCharacter.BeardTags, troopCharacter.TattooTags));
return(agentBuildData.AgentBodyProperties);
}
private bool HandleClientEventLobbyEquipmentUpdated(
NetworkCommunicator peer,
RequestTroopIndexChange message)
{
MissionPeer component = peer.GetComponent <MissionPeer>();
if (component == null)
{
return(false);
}
SpawnComponent missionBehaviour = this.Mission.GetMissionBehaviour <SpawnComponent>();
if (missionBehaviour == null)
{
return(false);
}
if (missionBehaviour.AreAgentsSpawning() && component.SelectedTroopIndex != message.SelectedTroopIndex)
{
component.SelectedTroopIndex = message.SelectedTroopIndex;
GameNetwork.BeginBroadcastModuleEvent();
GameNetwork.WriteMessage((GameNetworkMessage) new UpdateSelectedTroopIndex(peer, message.SelectedTroopIndex));
GameNetwork.EndBroadcastModuleEvent(GameNetwork.EventBroadcastFlags.ExcludeOtherTeamPlayers, peer);
if (this.OnEquipmentRefreshed != null)
{
this.OnEquipmentRefreshed(component);
}
}
return(true);
}
public void EquipmentUpdated()
{
if (GameNetwork.IsServer)
{
MissionPeer component = GameNetwork.MyPeer.GetComponent <MissionPeer>();
if (component.SelectedTroopIndex == component.NextSelectedTroopIndex)
{
return;
}
component.SelectedTroopIndex = component.NextSelectedTroopIndex;
GameNetwork.BeginBroadcastModuleEvent();
GameNetwork.WriteMessage((GameNetworkMessage) new UpdateSelectedTroopIndex(GameNetwork.MyPeer, component.SelectedTroopIndex));
GameNetwork.EndBroadcastModuleEvent(GameNetwork.EventBroadcastFlags.ExcludeOtherTeamPlayers, GameNetwork.MyPeer);
if (this.OnEquipmentRefreshed == null)
{
return;
}
this.OnEquipmentRefreshed(component);
}
else
{
MissionPeer component = GameNetwork.MyPeer.GetComponent <MissionPeer>();
GameNetwork.BeginModuleEventAsClient();
GameNetwork.WriteMessage((GameNetworkMessage) new RequestTroopIndexChange(component.NextSelectedTroopIndex));
GameNetwork.EndModuleEventAsClient();
}
}
public void OnCaptureResult(CaptureTheFlagCaptureResultEnum result)
{
if (GameNetwork.IsDedicatedServer || !GameNetwork.MyPeer.IsSynchronized)
{
return;
}
MissionPeer component = GameNetwork.MyPeer.GetComponent <MissionPeer>();
switch (result)
{
case CaptureTheFlagCaptureResultEnum.AttackersWin:
if (component == null)
{
break;
}
SoundEvent.PlaySound2D(component.Team.Side == BattleSideEnum.Attacker ? "event:/ui/mission/multiplayer/mp_victory" : "event:/ui/mission/multiplayer/mp_defeat");
break;
case CaptureTheFlagCaptureResultEnum.DefendersWin:
if (component == null)
{
break;
}
SoundEvent.PlaySound2D(component.Team.Side == BattleSideEnum.Defender ? "event:/ui/mission/multiplayer/mp_victory" : "event:/ui/mission/multiplayer/mp_defeat");
break;
}
}
private MissionPeer RemoveHittersAndGetAssistorPeer(
MissionPeer killerPeer,
Agent killedAgent)
{
Agent.Hitter assistingHitter = killedAgent.GetAssistingHitter(killerPeer);
foreach (Agent.Hitter hitter in killedAgent.HitterList.ToList <Agent.Hitter>())
{
if (hitter.HitterPeer != killerPeer && hitter != assistingHitter)
{
killedAgent.RemoveHitter(hitter.HitterPeer, hitter.IsFriendlyHit);
}
}
if (assistingHitter?.HitterPeer != null)
{
int scoreForAssist = this._gameMode.GetScoreForAssist(killedAgent);
if (!assistingHitter.IsFriendlyHit)
{
++assistingHitter.HitterPeer.AssistCount;
assistingHitter.HitterPeer.Score += scoreForAssist;
}
else
{
--assistingHitter.HitterPeer.AssistCount;
assistingHitter.HitterPeer.Score -= scoreForAssist;
}
}
return(assistingHitter?.HitterPeer);
}
private void OnAllAgentsFromPeerSpawnedFromVisuals(MissionPeer peer)
{
bool flag = peer.Team == this.Mission.AttackerTeam;
Team defenderTeam = this.Mission.DefenderTeam;
MultiplayerClassDivisions.MPHeroClass mpHeroClass = MultiplayerClassDivisions.GetMPHeroClasses(MBObjectManager.Instance.GetObject <BasicCultureObject>(flag ? MultiplayerOptions.OptionType.CultureTeam1.GetStrValue() : MultiplayerOptions.OptionType.CultureTeam2.GetStrValue())).ElementAt <MultiplayerClassDivisions.MPHeroClass>(peer.SelectedTroopIndex);
this.GameMode.ChangeCurrentGoldForPeer(peer, this.GameMode.GetCurrentGoldForPeer(peer) - mpHeroClass.TroopCost);
}
public void SetEarlyAgentVisualsDespawning(MissionPeer missionPeer, bool canDespawnEarly = true)
{
if (missionPeer == null || !this.AllowEarlyAgentVisualsDespawning(missionPeer))
{
return;
}
missionPeer.EquipmentUpdatingExpired = canDespawnEarly;
}
private void UnequipItem(EquipmentIndex itemIndex, MissionPeer peer)
{
Equipment playerEquipment = this._playerEquipments[peer];
if (playerEquipment[itemIndex].Item == null)
{
return;
}
this.UnequipItem(itemIndex, playerEquipment);
}
protected void SpawnEquipmentUpdated(MissionPeer lobbyPeer, Equipment equipment)
{
if (!GameNetwork.IsServer || lobbyPeer == null || (!this.SpawningBehaviour.CanUpdateSpawnEquipment(lobbyPeer) || !lobbyPeer.HasSpawnedAgentVisuals))
{
return;
}
GameNetwork.BeginBroadcastModuleEvent();
GameNetwork.WriteMessage((GameNetworkMessage) new EquipEquipmentToPeer(lobbyPeer.GetNetworkPeer(), equipment));
GameNetwork.EndBroadcastModuleEvent(GameNetwork.EventBroadcastFlags.None);
}
private void HandleServerEventCreateBannerForPeer(NetworkMessages.FromServer.CreateBanner message)
{
MissionPeer component = message.Peer.GetComponent <MissionPeer>();
if (component == null)
{
return;
}
component.Peer.BannerCode = message.BannerCode;
}
protected void ResetSpawnCounts()
{
foreach (NetworkCommunicator networkPeer in GameNetwork.NetworkPeers)
{
MissionPeer component = networkPeer.GetComponent <MissionPeer>();
if (component != null)
{
component.SpawnCountThisRound = 0;
}
}
}
public void ForfeitSpawning(NetworkCommunicator peer)
{
MissionPeer component = peer.GetComponent <MissionPeer>();
if (component == null || !component.HasSpawnedAgentVisuals || (!this.UseGold() || !this.RoundController.IsRoundInProgress))
{
return;
}
Mission.Current.GetMissionBehaviour <MultiplayerMissionAgentVisualSpawnComponent>().RemoveAgentVisuals(component, true);
this.ChangeCurrentGoldForPeer(component, -1);
}
public bool Check(MissionPeer peer)
{
foreach (MPPerkCondition condition in (IEnumerable <MPPerkCondition>) this.Conditions)
{
if (!condition.Check(peer))
{
return(false);
}
}
return(true);
}
protected override void HandleNewClientAfterSynchronized(NetworkCommunicator networkPeer)
{
MissionPeer component = networkPeer.GetComponent <MissionPeer>();
component.Team = this.Mission.AttackerTeam;
if (networkPeer.IsServerPeer)
{
return;
}
this._missionNetworkComponent?.OnPeerSelectedTeam(component);
}
public int GetScore(MissionPeer peer)
{
if (this._properties == null)
{
return(0);
}
string s = peer != null ? ((IEnumerable <MissionScoreboardComponent.ScoreboardHeader>) this._properties).Single <MissionScoreboardComponent.ScoreboardHeader>((Func <MissionScoreboardComponent.ScoreboardHeader, bool>)(x => x.Id == "score")).GetValueOf(peer) : ((IEnumerable <MissionScoreboardComponent.ScoreboardHeader>) this._properties).Single <MissionScoreboardComponent.ScoreboardHeader>((Func <MissionScoreboardComponent.ScoreboardHeader, bool>)(x => x.Id == "score")).GetValueOf(this.BotScores);
int result = 0;
int.TryParse(s, out result);
return(result);
}
private bool ServerPrepareAndSendMessage(
NetworkCommunicator fromPeer,
bool toTeamOnly,
string message)
{
if (fromPeer.IsMuted)
{
GameNetwork.BeginModuleEventAsServer(fromPeer);
GameNetwork.WriteMessage((GameNetworkMessage) new NetworkMessages.FromServer.ServerMessage("str_multiplayer_muted_message", true));
GameNetwork.EndModuleEventAsServer();
return(true);
}
if (!GameNetwork.IsDedicatedServer && fromPeer != GameNetwork.MyPeer && !this._mutedPlayers.Contains(fromPeer.VirtualPlayer.Id))
{
MissionPeer component1 = GameNetwork.MyPeer.GetComponent <MissionPeer>();
if (component1 == null)
{
return(false);
}
bool flag;
if (toTeamOnly)
{
if (component1 == null)
{
return(false);
}
MissionPeer component2 = fromPeer.GetComponent <MissionPeer>();
if (component2 == null)
{
return(false);
}
flag = component1.Team == component2.Team;
}
else
{
flag = true;
}
if (flag)
{
this.OnPlayerMessageReceived(fromPeer, message, toTeamOnly);
}
}
if (toTeamOnly)
{
ChatBox.ServerSendMessageToTeam(fromPeer, message);
}
else
{
ChatBox.ServerSendMessageToEveryone(fromPeer, message);
}
return(true);
}
public void PlayerPropertiesChanged(MissionPeer player)
{
if (GameNetwork.IsDedicatedServer)
{
return;
}
this.CalculateTotalNumbers();
if (this.OnPlayerPropertiesChanged == null || player.Team == null || player.Team == Mission.Current.SpectatorTeam)
{
return;
}
this.OnPlayerPropertiesChanged(player.Team.Side, player);
}
public override bool CheckForWarmupEnd()
{
int[] numArray = new int[2];
foreach (NetworkCommunicator networkPeer in GameNetwork.NetworkPeers)
{
MissionPeer component = networkPeer.GetComponent <MissionPeer>();
if (networkPeer.IsSynchronized && (component?.Team != null && component.Team.Side != BattleSideEnum.None))
{
++numArray[(int)component.Team.Side];
}
}
return(((IEnumerable <int>)numArray).Sum() >= MultiplayerOptions.OptionType.MaxNumberOfPlayers.GetIntValue());
}
public override void OnClearScene()
{
foreach (NetworkCommunicator networkPeer in GameNetwork.NetworkPeers)
{
MissionPeer component = networkPeer.GetComponent <MissionPeer>();
if (component != null)
{
component.BotsUnderControlAlive = 0;
component.BotsUnderControlTotal = 0;
component.ControlledFormation = (Formation)null;
}
}
}
public void PlayerPropertiesChanged(NetworkCommunicator player)
{
if (GameNetwork.IsDedicatedServer)
{
return;
}
MissionPeer component = player.GetComponent <MissionPeer>();
if (component == null)
{
return;
}
this.PlayerPropertiesChanged(component);
}
private void MakePlayerFormationCharge(NetworkCommunicator peer)
{
if (!peer.IsSynchronized)
{
return;
}
MissionPeer component = peer.GetComponent <MissionPeer>();
if (component.ControlledFormation == null || component.ControlledAgent == null)
{
return;
}
component.Team.GetOrderControllerOf(component.ControlledAgent).SetOrder(OrderType.Charge);
}
public override void OnAgentRemoved(
Agent affectedAgent,
Agent affectorAgent,
AgentState agentState,
KillingBlow killingBlow)
{
base.OnAgentRemoved(affectedAgent, affectorAgent, agentState, killingBlow);
if (!GameNetwork.IsServer || this.CurrentMultiplayerState == MissionLobbyComponent.MultiplayerGameState.Ending || agentState != AgentState.Killed && agentState != AgentState.Unconscious && agentState != AgentState.Routed || (affectedAgent == null || !affectedAgent.IsHuman))
{
return;
}
MissionPeer assistorPeer = affectorAgent?.MissionPeer != null?this.RemoveHittersAndGetAssistorPeer(affectorAgent.MissionPeer, affectedAgent) : (MissionPeer)null;
if (affectedAgent.MissionPeer != null)
{
this.OnPlayerDies(affectedAgent.MissionPeer, assistorPeer);
}
else
{
this.OnBotDies(affectedAgent, assistorPeer);
}
if (affectorAgent == null || !affectorAgent.IsHuman)
{
return;
}
if (affectorAgent != affectedAgent)
{
if (affectorAgent.MissionPeer != null)
{
this.OnPlayerKills(affectorAgent.MissionPeer, affectedAgent, assistorPeer);
}
else
{
this.OnBotKills(affectorAgent, affectedAgent);
}
}
else
{
if (affectorAgent.MissionPeer == null)
{
return;
}
affectorAgent.MissionPeer.Score -= this._gameMode.GetScoreForKill(affectedAgent);
this._missionScoreboardComponent.PlayerPropertiesChanged(affectorAgent.MissionPeer.GetNetworkPeer());
GameNetwork.BeginBroadcastModuleEvent();
GameNetwork.WriteMessage((GameNetworkMessage) new KillDeathCountChange(affectorAgent.MissionPeer.GetNetworkPeer(), affectedAgent.MissionPeer.GetNetworkPeer(), affectorAgent.MissionPeer.KillCount, affectorAgent.MissionPeer.AssistCount, affectorAgent.MissionPeer.DeathCount, affectorAgent.MissionPeer.Score));
GameNetwork.EndBroadcastModuleEvent(GameNetwork.EventBroadcastFlags.None);
}
}
protected override void OnEndMission()
{
if (!this.UseGold())
{
return;
}
foreach (NetworkCommunicator networkPeer in GameNetwork.NetworkPeers)
{
MissionPeer component = networkPeer.GetComponent <MissionPeer>();
if (component != null)
{
this.ChangeCurrentGoldForPeer(component, -1);
}
}
}
public override void OnMissionTick(float dt)
{
base.OnMissionTick(dt);
if (this._myEquipmentInitialized || GameNetwork.IsServer || !GameNetwork.IsMyPeerReady)
{
return;
}
MissionPeer component = GameNetwork.MyPeer.GetComponent <MissionPeer>();
if (component == null)
{
return;
}
this.AddPeerEquipment(component);
}
public void OnBotsControlledChanged(
MissionPeer missionPeer,
int botAliveCount,
int botTotalCount)
{
missionPeer.BotsUnderControlAlive = botAliveCount;
missionPeer.BotsUnderControlTotal = botTotalCount;
Action <NetworkCommunicator> controlledChangedEvent = this.OnBotsControlledChangedEvent;
if (controlledChangedEvent == null)
{
return;
}
controlledChangedEvent(missionPeer.GetNetworkPeer());
}
private void OnPeerEquipmentUpdated(MissionPeer peer)
{
if (!this.IsSpawningEnabled || !this.CanUpdateSpawnEquipment(peer))
{
return;
}
peer.HasSpawnedAgentVisuals = false;
Debug.Print("HasSpawnedAgentVisuals = false for peer: " + peer.Name + " because he just updated his equipment");
if (peer.ControlledFormation == null)
{
return;
}
peer.ControlledFormation.HasBeenPositioned = false;
peer.ControlledFormation.GroupSpawnIndex = 0;
}
private static void ServerSendMessageToTeam(NetworkCommunicator networkPeer, string message)
{
MissionPeer missionPeer = networkPeer.GetComponent <MissionPeer>();
if (missionPeer.Team == null)
{
return;
}
foreach (NetworkCommunicator communicator in GameNetwork.NetworkPeers.Where <NetworkCommunicator>((Func <NetworkCommunicator, bool>)(x => !x.IsServerPeer && x.IsSynchronized && x != networkPeer && x.GetComponent <MissionPeer>().Team == missionPeer.Team)))
{
GameNetwork.BeginModuleEventAsServer(communicator);
GameNetwork.WriteMessage((GameNetworkMessage) new NetworkMessages.FromServer.PlayerMessageTeam(networkPeer, message));
GameNetwork.EndModuleEventAsServer();
}
}
public static List <List <IReadOnlyPerkObject> > GetAvailablePerksForPeer(
MissionPeer missionPeer)
{
List <List <IReadOnlyPerkObject> > readOnlyPerkObjectListList = new List <List <IReadOnlyPerkObject> >();
if (missionPeer?.Team == null)
{
return(readOnlyPerkObjectListList);
}
MultiplayerClassDivisions.MPHeroClass heroClassForPeer = MultiplayerClassDivisions.GetMPHeroClassForPeer(missionPeer);
for (int index = 0; index < 3; ++index)
{
readOnlyPerkObjectListList.Add(heroClassForPeer.GetAllAvailablePerksForListIndex(index).ToList <IReadOnlyPerkObject>());
}
return(readOnlyPerkObjectListList);
}
public bool ShouldSpawnVisualsForServer(NetworkCommunicator spawningNetworkPeer)
{
if (GameNetwork.IsDedicatedServer)
{
return(false);
}
NetworkCommunicator myPeer = GameNetwork.MyPeer;
MissionPeer missionPeer = myPeer != null?myPeer.GetComponent <MissionPeer>() : (MissionPeer)null;
if (missionPeer == null)
{
return(false);
}
MissionPeer component = spawningNetworkPeer.GetComponent <MissionPeer>();
return(!this.IsGameModeHidingAllAgentVisuals && component.Team == missionPeer.Team || spawningNetworkPeer.IsServerPeer);
}
