private void GiveSlasherWeapon(EventManager.BaseEventPlayer eventPlayer)
{
Item item = ItemManager.Create(slasherWeapon);
if (item.contents != null && item.contents.availableSlots.Count > 0)
{
Item attachment = ItemManager.CreateByName(WEAPON_FLASHLIGHT_ITEM);
if (!attachment.MoveToContainer(item.contents))
{
attachment.Remove();
}
else
{
item.GetHeldEntity()?.SendMessage("SetLightsOn", true, SendMessageOptions.DontRequireReceiver);
}
}
item.MoveToContainer(eventPlayer.Player.inventory.containerBelt);
BaseProjectile baseProjectile = item.GetHeldEntity() as BaseProjectile;
if (baseProjectile != null)
{
Item ammo = ItemManager.Create(baseProjectile.primaryMagazine.ammoType, baseProjectile.primaryMagazine.capacity * 5);
ammo.MoveToContainer(eventPlayer.Player.inventory.containerMain);
}
}
internal override void OnEventPlayerDeath(EventManager.BaseEventPlayer victim, EventManager.BaseEventPlayer attacker = null, HitInfo info = null)
{
if (victim == null)
{
return;
}
victim.OnPlayerDeath(attacker, Configuration.RespawnTime);
if (attacker != null && victim != attacker && victim.Team != attacker.Team)
{
int score;
if (attacker.Team == EventManager.Team.B)
{
score = teamBScore += 1;
}
else
{
score = teamAScore += 1;
}
attacker.OnKilledPlayer(info);
if (Config.ScoreLimit > 0 && score >= Config.ScoreLimit)
{
winningTeam = attacker.Team;
InvokeHandler.Invoke(this, EndEvent, 0.1f);
return;
}
}
UpdateScoreboard();
base.OnEventPlayerDeath(victim, attacker);
}
internal override void OnEventPlayerDeath(EventManager.BaseEventPlayer victim, EventManager.BaseEventPlayer attacker = null, HitInfo info = null)
{
if (victim == null)
{
return;
}
victim.OnPlayerDeath(attacker, Configuration.RespawnTime);
if (attacker != null && victim != attacker)
{
attacker.OnKilledPlayer(info);
if (GetAlivePlayerCount() <= 1)
{
winner = attacker;
InvokeHandler.Invoke(this, EndEvent, 0.1f);
return;
}
}
UpdateScoreboard();
base.OnEventPlayerDeath(victim, attacker);
}
protected override void GetWinningPlayers(ref List <EventManager.BaseEventPlayer> winners)
{
if (winner == null)
{
if (eventPlayers.Count > 0)
{
int kills = 0;
for (int i = 0; i < eventPlayers.Count; i++)
{
EventManager.BaseEventPlayer eventPlayer = eventPlayers[i];
if (eventPlayer == null)
{
continue;
}
if (eventPlayer.Kills > kills)
{
winner = eventPlayer;
kills = eventPlayer.Kills;
}
}
}
}
if (winner != null)
{
winners.Add(winner);
}
}
protected override void OnPlayerSpawned(EventManager.BaseEventPlayer eventPlayer)
{
if (Status == EventManager.EventStatus.Started)
{
BroadcastToPlayer(eventPlayer, string.Format(GetMessage("Notification.LivesRemaining", eventPlayer.Player.userID), (eventPlayer as ChopperSurvivalPlayer).LivesRemaining));
}
}
internal override void OnEventPlayerDeath(EventManager.BaseEventPlayer victim, EventManager.BaseEventPlayer attacker = null, HitInfo info = null)
{
if (victim == null)
{
return;
}
attacker?.OnKilledPlayer(info);
if (victim == slasherPlayer || GetAlivePlayerCount() <= 1)
{
victim.AddPlayerDeath();
if (victim == slasherPlayer)
{
BroadcastToPlayers(GetMessage, "Notification.HuntedWin");
}
else
{
BroadcastToPlayers(GetMessage, "Notification.SlasherWin");
}
EndRound();
return;
}
victim.OnPlayerDeath(attacker, 0f);
UpdateScoreboard();
base.OnEventPlayerDeath(victim, attacker);
}
internal override void OnPlayerDeath(EventManager.BaseEventPlayer attacker = null, float respawnTime = 5)
{
AddPlayerDeath();
DestroyUI();
string message = string.Empty;
if (LivesRemaining <= 0)
{
int position = Event.GetAlivePlayerCount();
message = IsOutOfBounds ? string.Format(GetMessage("UI.Death.OOB.Kicked", Player.userID), ToOrdinal(position + 1), position) :
string.Format(GetMessage("UI.Death.Killed.Kicked", Player.userID), ToOrdinal(position + 1), position);
}
else
{
_respawnDurationRemaining = respawnTime;
InvokeHandler.InvokeRepeating(this, RespawnTick, 1f, 1f);
message = IsOutOfBounds ? GetMessage("UI.Death.OOB", Player.userID) :
GetMessage("UI.Death.Killed", Player.userID);
}
EMInterface.DisplayDeathScreen(this, message, LivesRemaining > 0);
}
private void EndRound()
{
slasherPlayer = null;
Timer.StopTimer();
IsPlayingRound = false;
GodmodeEnabled = true;
EnvSync.SendNetworkUpdateImmediate();
if (currentRound >= rounds)
{
Status = EventManager.EventStatus.Finished;
StartCoroutine(ResetPlayers());
InvokeHandler.Invoke(this, EndEvent, 5f);
}
else
{
StartCoroutine(ResetPlayers());
InvokeHandler.Invoke(this, StartRound, Configuration.TimeBetweenRounds);
BroadcastToPlayers(GetMessage, "Notification.RoundStartsIn", Configuration.TimeBetweenRounds);
}
}
private IEnumerator ResetPlayers()
{
List <EventManager.BaseEventPlayer> currentPlayers = Facepunch.Pool.GetList <EventManager.BaseEventPlayer>();
currentPlayers.AddRange(eventPlayers);
for (int i = 0; i < currentPlayers.Count; i++)
{
EventManager.BaseEventPlayer eventPlayer = currentPlayers[i];
if (eventPlayer != null)
{
if (eventPlayer.IsDead)
{
EventManager.ResetPlayer(eventPlayer.Player);
}
else
{
EventManager.StripInventory(eventPlayer.Player);
EventManager.ResetMetabolism(eventPlayer.Player);
EventManager.GiveKit(eventPlayer.Player, eventPlayer.Kit);
}
}
yield return(CoroutineEx.waitForEndOfFrame);
yield return(CoroutineEx.waitForEndOfFrame);
}
Facepunch.Pool.FreeList(ref currentPlayers);
}
internal override void OnEventPlayerDeath(EventManager.BaseEventPlayer victim, EventManager.BaseEventPlayer attacker = null, HitInfo info = null)
{
if (victim == null)
{
return;
}
if ((victim as CaptureTheFlagPlayer).IsCarryingFlag)
{
FlagController flagController = victim.Team == EventManager.Team.B ? TeamAFlag : TeamBFlag;
if (flagController.FlagHolder == victim)
{
flagController.DropFlag(true);
BroadcastToPlayers(GetMessage, "Notification.FlagDropped", victim.Player.displayName, flagController.Team, GetTeamColor(victim.Team), GetTeamColor(flagController.Team));
}
}
victim.OnPlayerDeath(attacker, Configuration.RespawnTime);
if (attacker != null && victim != attacker && victim.Team != attacker.Team)
{
attacker.OnKilledPlayer(info);
}
UpdateScoreboard();
base.OnEventPlayerDeath(victim, attacker);
}
internal override bool CanDealEntityDamage(EventManager.BaseEventPlayer attacker, BaseEntity entity, HitInfo hitInfo)
{
EventHelicopter eventHelicopter = entity.GetComponent <EventHelicopter>();
if (eventHelicopter == null)
{
return(false);
}
if (damageScaler != 1f)
{
hitInfo.damageTypes.ScaleAll(damageScaler);
}
int hitPoints;
if (!eventHelicopter.DealDamage(hitInfo, out hitPoints))
{
EventManager.ClearDamage(hitInfo);
}
(attacker as ChopperSurvivalPlayer).HitPoints += hitPoints;
return(true);
}
protected override void OnKitGiven(EventManager.BaseEventPlayer eventPlayer)
{
List <Item> list = Facepunch.Pool.GetList <Item>();
eventPlayer.Player.inventory.AllItemsNoAlloc(ref list);
bool isSlasher = eventPlayer == slasherPlayer;
for (int i = 0; i < list.Count; i++)
{
Item item = list[i];
if (!isSlasher && item.info.category == ItemCategory.Attire)
{
continue;
}
item.RemoveFromContainer();
item.Remove();
}
if (isSlasher)
{
EventManager.GiveKit(eventPlayer.Player, slasherKit);
GiveSlasherWeapon(eventPlayer);
}
else
{
GiveTorch(eventPlayer);
}
eventPlayer.Player.inventory.SendUpdatedInventory(PlayerInventory.Type.Belt, eventPlayer.Player.inventory.containerBelt);
}
private void GiveTorch(EventManager.BaseEventPlayer eventPlayer)
{
Item item = ItemManager.Create(torchItem);
item.MoveToContainer(eventPlayer.Player.inventory.containerBelt);
item.GetHeldEntity()?.SendMessage("SetLightsOn", true, SendMessageOptions.DontRequireReceiver);
}
internal override void OnPlayerDeath(EventManager.BaseEventPlayer attacker = null, float respawnTime = 5)
{
AddPlayerDeath(attacker);
DestroyUI();
BeginSpectating();
}
protected override void OnKitGiven(EventManager.BaseEventPlayer eventPlayer)
{
(eventPlayer as GunGamePlayer).GiveRankWeapon(weaponSet.CreateItem((eventPlayer as GunGamePlayer).Rank));
if (downgradeWeapon != null && eventPlayer.Player.inventory.GetAmount(downgradeWeapon.itemid) == 0)
{
eventPlayer.Player.GiveItem(ItemManager.Create(downgradeWeapon), BaseEntity.GiveItemReason.PickedUp);
}
}
internal override void OnPlayerTakeDamage(EventManager.BaseEventPlayer eventPlayer, HitInfo hitInfo)
{
EventManager.BaseEventPlayer attacker = EventManager.GetUser(hitInfo.InitiatorPlayer);
if (attacker != null)
{
EventManager.ClearDamage(hitInfo);
return;
}
base.OnPlayerTakeDamage(eventPlayer, hitInfo);
}
protected override void DisplayKillToChat(EventManager.BaseEventPlayer victim, string attackerName)
{
if (victim.IsOutOfBounds)
{
BroadcastToPlayers(GetMessage, "Notification.Death.OOB", victim.Player.displayName);
}
else
{
BroadcastToPlayers(GetMessage, "Notification.Death.Killed", victim.Player.displayName);
}
}
internal override void GetSpectateTargets(ref List <EventManager.BaseEventPlayer> list)
{
list.Clear();
for (int i = 0; i < eventPlayers.Count; i++)
{
EventManager.BaseEventPlayer eventPlayer = eventPlayers[i];
if (!eventPlayer.IsDead && eventPlayer != slasherPlayer)
{
list.Add(eventPlayer);
}
}
}
internal override void OnPlayerDeath(EventManager.BaseEventPlayer attacker = null, float respawnTime = 5)
{
AddPlayerDeath(attacker);
DestroyUI();
int position = Event.GetAlivePlayerCount();
string message = attacker != null?string.Format(GetMessage("UI.Death.Killed", Player.userID), attacker.Player.displayName, ToOrdinal(position + 1), position) :
IsOutOfBounds?string.Format(GetMessage("UI.Death.OOB", Player.userID), ToOrdinal(position + 1), position) :
string.Format(GetMessage("UI.Death.Suicide", Player.userID), ToOrdinal(position + 1), position);
EMInterface.DisplayDeathScreen(this, message, false);
}
internal override void OnEventPlayerDeath(EventManager.BaseEventPlayer victim, EventManager.BaseEventPlayer attacker = null, HitInfo hitInfo = null)
{
if (victim == null)
{
return;
}
victim.OnPlayerDeath(attacker, Configuration.RespawnTime);
if (attacker != null && victim != attacker)
{
if (Configuration.ResetHealthOnKill)
{
attacker.Player.health = attacker.Player.MaxHealth();
attacker.Player.SendNetworkUpdate(BasePlayer.NetworkQueue.Update);
}
attacker.OnKilledPlayer(hitInfo);
string attackersWeapon = GetWeaponShortname(hitInfo);
if (!string.IsNullOrEmpty(attackersWeapon))
{
if (KilledByRankedWeapon(attacker as GunGamePlayer, attackersWeapon))
{
(attacker as GunGamePlayer).Rank += 1;
if ((attacker as GunGamePlayer).Rank > weaponSet.Count)
{
winner = attacker;
InvokeHandler.Invoke(this, EndEvent, 0.1f);
return;
}
else
{
(attacker as GunGamePlayer).RemoveRankWeapon();
(attacker as GunGamePlayer).GiveRankWeapon(weaponSet.CreateItem((attacker as GunGamePlayer).Rank));
}
}
else if (KilledByDowngradeWeapon(attackersWeapon))
{
(victim as GunGamePlayer).Rank = Mathf.Clamp((victim as GunGamePlayer).Rank - 1, 1, weaponSet.Count);
}
}
}
UpdateScoreboard();
base.OnEventPlayerDeath(victim, attacker);
}
private EventManager.BaseEventPlayer GetRandomSlasher()
{
EventManager.BaseEventPlayer nextSlasher = remainingSlashers.GetRandom();
remainingSlashers.Remove(nextSlasher);
if (remainingSlashers.Count == 0)
{
remainingSlashers.AddRange(eventPlayers);
}
if (nextSlasher == null)
{
return(GetRandomSlasher());
}
return(nextSlasher);
}
private IEnumerator GiveSlasherWeapons()
{
for (int i = eventPlayers.Count - 1; i >= 0; i--)
{
EventManager.BaseEventPlayer eventPlayer = eventPlayers[i];
if (eventPlayer.IsDead || eventPlayer == slasherPlayer)
{
continue;
}
GiveSlasherWeapon(eventPlayer);
yield return(CoroutineEx.waitForEndOfFrame);
yield return(CoroutineEx.waitForEndOfFrame);
}
}
private void StartRound()
{
GodmodeEnabled = false;
IsPlayingRound = true;
EnvSync.SendNetworkUpdateImmediate();
currentRound += 1;
slasherPlayer = GetRandomSlasher();
StartCoroutine(ResetPlayers());
Timer.StartTimer(slasherTime, GetMessage("Timer.Slasher", 0UL), OnSlasherTimerExpired);
BroadcastToPlayers(GetMessage, "Notification.RoundStarted", slasherPlayer.Player.displayName);
UpdateScoreboard();
}
protected override void GetWinningPlayers(ref List <EventManager.BaseEventPlayer> winners)
{
if (winner == null)
{
if (eventPlayers.Count > 0)
{
int rank = 0;
int kills = 0;
for (int i = 0; i < eventPlayers.Count; i++)
{
GunGamePlayer eventPlayer = eventPlayers[i] as GunGamePlayer;
if (eventPlayer == null)
{
continue;
}
if (eventPlayer.Rank > rank)
{
winner = eventPlayer;
kills = eventPlayer.Kills;
rank = eventPlayer.Rank;
}
else if (eventPlayer.Rank == rank)
{
if (eventPlayer.Kills > rank)
{
winner = eventPlayer;
kills = eventPlayer.Kills;
rank = eventPlayer.Rank;
}
}
}
}
}
if (winner != null)
{
winners.Add(winner);
}
}
internal override void OnEventPlayerDeath(EventManager.BaseEventPlayer victim, EventManager.BaseEventPlayer attacker = null, HitInfo info = null)
{
if (victim == null)
{
return;
}
(victim as ChopperSurvivalPlayer).LivesRemaining -= 1;
if (GetPlayersRemainingCount() == 0)
{
victim.AddPlayerDeath(null);
InvokeHandler.Invoke(this, EndEvent, 0.1f);
return;
}
victim.OnPlayerDeath(attacker, Configuration.RespawnTime);
base.OnEventPlayerDeath(victim, attacker);
}
protected override void GetWinningPlayers(ref List <EventManager.BaseEventPlayer> winners)
{
if (winningTeam < EventManager.Team.None)
{
if (eventPlayers.Count > 0)
{
for (int i = 0; i < eventPlayers.Count; i++)
{
EventManager.BaseEventPlayer eventPlayer = eventPlayers[i];
if (eventPlayer == null)
{
continue;
}
if (eventPlayer.Team == winningTeam)
{
winners.Add(eventPlayer);
}
}
}
}
}
protected override float GetSecondScoreValue(EventManager.BaseEventPlayer eventPlayer) => eventPlayer.Deaths;
protected override float GetFirstScoreValue(EventManager.BaseEventPlayer eventPlayer) => eventPlayer.Kills;
protected override float GetFirstScoreValue(EventManager.BaseEventPlayer eventPlayer) => (eventPlayer as CaptureTheFlagPlayer).FlagCaptures;
protected override float GetSecondScoreValue(EventManager.BaseEventPlayer eventPlayer) => (eventPlayer as ChopperSurvivalPlayer).LivesRemaining;
