private void Post_OnCollision(object sender, PhysicsBodyComponent e)
{
ServerMPPlayer player = e.GameObject as ServerMPPlayer;
if (player != null)
{
CommandPost post = ((PhysicsBodyComponent)sender).GameObject as CommandPost;
if (post.Team == player.Team)
{
player.Refresh();
if (player.HasIntel)
{
CaptureIntel(player, player.Intel);
}
}
}
else if (e.GameObject is Intel intel)
{
if (intel.Holder == null)
{
CommandPost post = ((PhysicsBodyComponent)sender).GameObject as CommandPost;
if (post.Team != intel.Team)
{
CaptureIntel(intel.LastHolder as ServerMPPlayer, intel);
}
}
}
}
public override void Update(float deltaTime)
{
foreach (KeyValuePair <NetConnection, ServerMPPlayer> pair in players)
{
ServerMPPlayer player = pair.Value;
if (player.Health <= 0)
{
player.OnKilled();
if (OnPlayerKilled != null)
{
if (player.LastDamage != null)
{
OnPlayerKilled(player.LastDamage);
}
else
{
OnPlayerKilled(new PlayerDamage(player, 0, "Unknown"));
}
}
}
}
float timeAutoShift = DashCMD.GetCVar <float>("time_autoshift");
TimeOfDay += timeAutoShift * deltaTime;
base.Update(deltaTime);
}
public void OnCreatableInstantiated(NetCreatableInfo info, NetConnectionSnapshotState state)
{
ServerMPPlayer player = info.Creatable as ServerMPPlayer;
if (player != null)
{
NetConnection owner = state.Connection;
WriteDebug("[CSS] Created MPPlayer for {0}.", owner);
// Create the worldsnapshot for the the player
WorldSnapshot ws = state.WorldSnapshot;
// Add the current players to the snapshot
foreach (ServerMPPlayer plr in players.Values)
{
if (!ws.IsPlayerAdded(plr.StateInfo.Id))
{
ws.AddPlayer(plr.StateInfo.Id, false, true);
}
}
// Add the new player
players.Add(info.Id, player);
playersFromConnection.Add(player.StateInfo.Owner, player);
// Add the new player to each players state (including the new player's state)
foreach (NetConnectionSnapshotState otherState in snapshotComponent.ConnectionStates.Values)
{
otherState.WorldSnapshot.AddPlayer(info.Id, state == otherState, true);
}
}
}
public void DamagePlayer(ServerMPPlayer attacker, string weapon, ServerMPPlayer hitPlayer,
float damage, Vector3 attackOrigin)
{
if (hitPlayer.Health > 0)
{
// Deal damage
hitPlayer.Damage(attacker, damage, weapon);
// Send hit feedback to hitPlayer
NetConnectionSnapshotState state;
PlayerSnapshot pSnapshot;
if (snapshotComponent.ConnectionStates.TryGetValue(hitPlayer.StateInfo.Owner, out state))
{
if (state.WorldSnapshot.TryGetPlayer(hitPlayer.StateInfo.Id, out pSnapshot))
{
pSnapshot.HitFeedbackSnapshot.Hits.Add(attackOrigin);
}
}
// Send hit feedback to attacker
if (snapshotComponent.ConnectionStates.TryGetValue(attacker.StateInfo.Owner, out state))
{
if (state.WorldSnapshot.TryGetPlayer(attacker.StateInfo.Id, out pSnapshot))
{
pSnapshot.HitEnemy++;
}
}
}
}
public override void OnPlayerKilled(ServerMPPlayer killer, NetworkPlayer killerNetPlayer,
ServerMPPlayer assistant, NetworkPlayer assistantNetPlayer,
ServerMPPlayer killed, NetworkPlayer killedNetPlayer, string item)
{
// Update scores
if (killer == null)
{
// Update killed score
killedNetPlayer.Score += SCORE_SUICIDE_PENALTY;
}
else
{
// Update killer score
if (killer.Team == killed.Team)
{
killerNetPlayer.Score += SCORE_TEAMKILL_PENALTY;
}
else
{
killerNetPlayer.Score += SCORE_KILL;
}
// Update assistant score
if (assistant != null)
{
if (assistant.Team == killed.Team)
{
assistantNetPlayer.Score += SCORE_ASSIST_TEAMKILL_PENALTY;
}
else
{
assistantNetPlayer.Score += SCORE_ASSIST;
}
}
// Update team scores
if (killer.Team != killed.Team)
{
if (killer.Team == Team.A)
{
teamAScore++;
}
else if (killer.Team == Team.B)
{
teamBScore++;
}
}
// Announce score change
NetChannel.FireEventForAllConnections("Client_UpdateScores", RemoteFlag.None,
NetDeliveryMethod.ReliableOrdered, (short)teamAScore, (short)teamBScore);
}
base.OnPlayerKilled(killer, killerNetPlayer, assistant, assistantNetPlayer,
killed, killedNetPlayer, item);
// Add player to the respawn list
AddRespawn(killed.StateInfo.Owner, RESPAWN_TIME);
}
protected void DespawnPlayer(ServerMPPlayer player)
{
if (Players.Remove(player.StateInfo.Owner))
{
// Network destroy the player
objectComponent.NetworkDestroy(player.StateInfo.Id);
// Inform gamemode
OnPlayerRemoved(player.StateInfo.Owner, player);
}
}
protected ServerMPPlayer SpawnPlayer(NetConnection client, Vector3 position, Team team)
{
// Create the player
ServerMPPlayer player = new ServerMPPlayer(World, position, team);
// Instantiate over the network
objectComponent.NetworkInstantiate(player, "Client_CreatePlayer", client,
position.X, position.Y, position.Z, (byte)team);
return(player);
}
private void Post_OnCollision(object sender, PhysicsBodyComponent e)
{
ServerMPPlayer player = e.GameObject as ServerMPPlayer;
if (player != null)
{
CommandPost post = ((PhysicsBodyComponent)sender).GameObject as CommandPost;
if (post.Team == player.Team)
{
player.Refresh();
}
}
}
protected void DespawnAllPlayers()
{
// Despawn all players
ServerMPPlayer[] players = new ServerMPPlayer[Players.Count];
Players.Values.CopyTo(players, 0);
foreach (ServerMPPlayer player in players)
{
DespawnPlayer(player);
}
// Clean up
respawns.Clear();
Players.Clear();
}
private void ObjectComponent_OnCreatableDestroyed(object sender, NetCreatableInfo e)
{
ServerMPPlayer player = e.Creatable as ServerMPPlayer;
if (player != null)
{
// Update network player
NetworkPlayer netPlayer;
if (NetPlayerComponent.TryGetPlayer(e.Owner, out netPlayer))
{
netPlayer.CharacterId = null;
}
}
}
public virtual void OnPlayerKilled(ServerMPPlayer killer, NetworkPlayer killerNetPlayer,
ServerMPPlayer assistant, NetworkPlayer assistantNetPlayer,
ServerMPPlayer killed, NetworkPlayer killedNetPlayer, string item)
{
if (killer != null)
{
HandleKillStreak(killer, killerNetPlayer, 1);
}
if (assistant != null)
{
HandleKillStreak(assistant, assistantNetPlayer, 0.5f);
}
killed.KillStreak = 0;
DespawnPlayer(killed);
}
private void ObjectComponent_OnCreatableInstantiated(object sender, NetCreatableInfo e)
{
ServerMPPlayer player = e.Creatable as ServerMPPlayer;
if (player != null)
{
// Update network player
NetworkPlayer netPlayer = NetPlayerComponent.GetPlayer(e.Owner);
netPlayer.CharacterId = player.StateInfo.Id;
// Player is all set
Players.Add(player.StateInfo.Owner, player);
// Inform the rest of the gamemode
OnPlayerAdded(player.StateInfo.Owner, player);
}
}
void HandleKillStreak(ServerMPPlayer player, NetworkPlayer netPlayer, float killCredit)
{
float previousKillStreak = player.KillStreak;
player.KillStreak += killCredit;
if (AllowMelonLaunchers)
{
float previousMod = previousKillStreak % 7f;
float newMod = player.KillStreak % 7f;
if (newMod < previousMod)
{
player.NumMelons = Characters.Player.MAX_MELONS;
Screen.Chat($"{netPlayer.Name} has acquired the melon launcher!");
}
}
}
void CaptureIntel(ServerMPPlayer player, Intel intel)
{
intel.Return();
string team = intel.Team == Team.A ? "Red" : "Blue";
Screen.Chat(string.Format("The {0} intel has been captured!", team));
if (player != null)
{
player.DropIntel();
NetworkPlayer netPlayer;
if (NetPlayerComponent.TryGetPlayer(player.StateInfo.Owner, out netPlayer))
{
netPlayer.Score += SCORE_CAPTURE;
Screen.AddFeedItem(netPlayer.Name, "", World.GetTeamColor(player.Team),
"Captured", "Intel", World.GetTeamColor(player.Team == Team.A ? Team.B : Team.A));
}
}
else
{
Screen.AddFeedItem("?", null, World.GetTeamColor(intel.Team == Team.A ? Team.B : Team.A),
"Captured", "Intel", World.GetTeamColor(intel.Team));
}
if (intel.Team == Team.B)
{
teamAScore++;
}
else
{
teamBScore++;
}
if (teamAScore < SCORE_CAP && teamBScore < SCORE_CAP)
{
NetChannel.FireEventForAllConnections("Client_IntelCaptured", (byte)intel.Team);
}
NetChannel.FireEventForAllConnections("Client_UpdateScores",
(short)teamAScore, (short)teamBScore);
}
private void ObjectComponent_OnCreatableInstantiated(object sender, NetCreatableInfo creatable)
{
ServerMPPlayer player = creatable.Creatable as ServerMPPlayer;
if (player != null)
{
players.TryAdd(creatable.Owner, player);
AddGameObject(player);
}
else
{
GameObject gameObject = creatable.Creatable as GameObject;
AddGameObject(gameObject);
if (gameObject.HasComponent <PhysicsBodyComponent>())
{
physEntities.Add(creatable.Id, gameObject);
}
}
}
private void Intel_OnDropped(object sender, Player _player)
{
Intel intel = (Intel)sender;
ServerMPPlayer player = (ServerMPPlayer)_player;
string team = intel.Team == Team.A ? "Red" : "Blue";
Screen.Chat(string.Format("The {0} intel has been dropped!", team));
NetworkPlayer netPlayer;
if (NetPlayerComponent.TryGetPlayer(player.StateInfo.Owner, out netPlayer))
{
Screen.AddFeedItem(netPlayer.Name, "", World.GetTeamColor(player.Team),
"Dropped", "Intel", World.GetTeamColor(intel.Team));
}
NetChannel.FireEventForAllConnections("Client_IntelDropped", (byte)intel.Team);
}
public override void OnPlayerKilled(ServerMPPlayer killer, NetworkPlayer killerNetPlayer,
ServerMPPlayer assistant, NetworkPlayer assistantNetPlayer,
ServerMPPlayer killed, NetworkPlayer killedNetPlayer, string item)
{
// Update scores
if (killer == null)
{
// Update killed score
killedNetPlayer.Score += SCORE_SUICIDE_PENALTY;
}
else
{
// Update killer score
if (killer.Team == killed.Team)
{
killerNetPlayer.Score += SCORE_TEAMKILL_PENALTY;
}
else
{
killerNetPlayer.Score += SCORE_KILL;
}
// Update assistant score
if (assistant != null)
{
if (assistant.Team == killed.Team)
{
assistantNetPlayer.Score += SCORE_ASSIST_TEAMKILL_PENALTY;
}
else
{
assistantNetPlayer.Score += SCORE_ASSIST;
}
}
}
base.OnPlayerKilled(killer, killerNetPlayer, assistant, assistantNetPlayer, killed, killedNetPlayer, item);
// Add player to the respawn list
AddRespawn(killed.StateInfo.Owner, RESPAWN_TIME);
}
void ObjectComponent_OnCreatableDestroyed(object sender, NetCreatableInfo creatable)
{
ServerMPPlayer player = creatable.Creatable as ServerMPPlayer;
if (player != null)
{
// If a player was destroyed we need to remove
// anything associated with them.
player.Dispose();
players.TryRemove(creatable.Owner, out player);
}
else
{
GameObject gameObject = creatable.Creatable as GameObject;
if (gameObject.HasComponent <PhysicsBodyComponent>())
{
physEntities.Remove(creatable.Id);
}
gameObject.Dispose();
}
}
public override PlayerRaycastResult RaycastPlayers(Ray ray, float maxDist = float.MaxValue, params Player[] ignore)
{
bool sv_impacts = DashCMD.GetCVar <bool>("sv_impacts");
bool sv_hitboxes = DashCMD.GetCVar <bool>("sv_hitboxes");
ServerMPPlayer hitPlayer = null;
float? hitPlayerAt = null;
foreach (ServerMPPlayer otherPlayer in players.Values)
{
// Make sure we aren't ignoring this player
if (ignore.Length == 0 || !Array.Exists(ignore, (x => x == otherPlayer)))
{
Vector3 otherPlayerPosition;
float otherPlayerCamYaw;
if (rollbackTime.HasValue)
{
// We are applying rollback, so find the players old transform
int otherPlayerPing = DashCMD.GetCVar <bool>("rp_usetargetping") ? otherPlayer.StateInfo.Owner.Stats.Ping : 0;
int rollbackFrame = MathHelper.Clamp(otherPlayerPing + rollbackTime.Value, 0, 1000);
if (sv_hitboxes)
{
DashCMD.WriteLine("[RB] Rolling back bullet-player transform by {0}ms [target ping: {1}ms]",
ConsoleColor.Green, rollbackTime, otherPlayerPing);
}
PlayerTransform otherPlayerTransform = otherPlayer.RollbackTransform(Environment.TickCount - rollbackFrame);
otherPlayerPosition = otherPlayerTransform.Position;
otherPlayerCamYaw = otherPlayerTransform.CameraYaw;
}
else
{
// No rollback currently, use current transform
otherPlayerPosition = otherPlayer.Transform.Position;
otherPlayerCamYaw = otherPlayer.GetCamera().Yaw;
}
if (sv_hitboxes)
{
channel.FireEventForAllConnections("Client_RolledBackServerPlayer",
otherPlayerPosition.X, otherPlayerPosition.Y,
otherPlayerPosition.Z, (byte)otherPlayer.Team);
}
Ray newRay = new Ray(ray.Origin - otherPlayerPosition, ray.Direction);
float?dist;
// Check for intersection
if (newRay.Intersects(otherPlayer.GetOrientatedBoundingBox(otherPlayerCamYaw), out dist))
{
// If the distance is out of bounds, ignore
if (dist.Value > maxDist)
{
continue;
}
// Only update the intersected player if it was closer than the last
if (!hitPlayerAt.HasValue || dist.Value < hitPlayerAt.Value)
{
hitPlayer = otherPlayer;
hitPlayerAt = dist.Value;
}
}
}
}
if (hitPlayer != null)
{
return(new PlayerRaycastResult(ray, true, ray.Origin + ray.Direction * hitPlayerAt.Value, hitPlayerAt, hitPlayer));
}
else
{
return(new PlayerRaycastResult(ray));
}
}
private void World_OnPlayerKilled(PlayerDamage damageEvent)
{
ServerMPPlayer killer = (ServerMPPlayer)damageEvent.Attacker;
ServerMPPlayer assistant = (ServerMPPlayer)damageEvent.AttackerAssistant;
ServerMPPlayer killed = (ServerMPPlayer)damageEvent.Attacked;
string item = damageEvent.Cause;
if (killer == killed)
{
// Kill was actually suicide
killer = null;
}
// Killer only gets credit within 6.5s of players death
if (Environment.TickCount - damageEvent.DamagedAt >= 6500)
{
killer = null;
}
// Assistant only gets credit within 8s of players death
if (Environment.TickCount - damageEvent.AttackerAssistedAt >= 8000)
{
assistant = null;
}
// Get network players
string leftName = "", rightName = "", assistantName = "";
NetworkPlayer killerNetPlayer = null, killedNetPlayer = null, assistantNetPlayer = null;
if (killer != null && netPlayerComponent.TryGetPlayer(killer.StateInfo.Owner, out killerNetPlayer))
{
leftName = killerNetPlayer.Name;
}
if (killed != null && netPlayerComponent.TryGetPlayer(killed.StateInfo.Owner, out killedNetPlayer))
{
rightName = killedNetPlayer.Name;
}
if (assistant != null && netPlayerComponent.TryGetPlayer(assistant.StateInfo.Owner, out assistantNetPlayer))
{
assistantName = assistantNetPlayer.Name;
}
// Announce feed item
AddFeedItem(
leftName, assistantName,
killer != null ? World.GetTeamColor(killer.Team) : Color.White,
item,
rightName, killed != null ? World.GetTeamColor(killed.Team) : Color.White);
// Notify gamemode
currentGamemode.OnPlayerKilled(killer, killerNetPlayer, assistant, assistantNetPlayer, killed, killedNetPlayer, item);
// Debug
if (killer != null)
{
if (assistant != null)
{
DashCMD.WriteLine("[MatchScreen] '{0} + {1} [ {2} ] {3}'", leftName, assistantName, item, rightName);
}
else
{
DashCMD.WriteLine("[MatchScreen] '{0} [ {1} ] {2}'", leftName, item, rightName);
}
}
else
{
DashCMD.WriteLine("[MatchScreen] '[ {0} ] {1}'", item, rightName);
}
}
protected virtual void OnPlayerRemoved(NetConnection client, ServerMPPlayer player)
{
}
public override void FireBullet(Player _player, Vector3 origin, Vector3 dir, Vector3 recoil,
int blockDamage, float playerDamage, float maxDist = float.MaxValue)
{
ServerMPPlayer player = (ServerMPPlayer)_player;
bool sv_impacts = DashCMD.GetCVar <bool>("sv_impacts");
bool sv_hitboxes = DashCMD.GetCVar <bool>("sv_hitboxes");
int shooterPing = player.StateInfo.Owner.Stats.Ping;
int rollbackOffset = DashCMD.GetCVar <int>("rp_rollback_offset");
int bulletDelta = player.LastBulletDeltaTime;
if (sv_hitboxes)
{
DashCMD.WriteLine("[RB] Starting bullet {0}ms delta with {1}ms offset",
ConsoleColor.Green, bulletDelta, rollbackOffset);
}
// Raycast
BeginRollback(shooterPing + bulletDelta + rollbackOffset);
Ray ray = new Ray(origin, dir + recoil);
WorldRaycastResult result = Raycast(ray, true, maxDist, player);
EndRollback();
// Handle intersection
if (result.Intersects)
{
if (result.HitTerrain)
{
// Damage terrain
TerrainRaycastResult tResult = result.TerrainResult;
if (blockDamage > 0)
{
tResult.Chunk.DamageBlock(tResult.BlockIndex.Value, blockDamage);
}
}
else if (result.HitPlayer)
{
// Damage player
PlayerRaycastResult pResult = result.PlayerResult;
bool ff = DashCMD.GetCVar <bool>("mp_friendlyfire");
bool infh = DashCMD.GetCVar <bool>("ch_infhealth");
if (!infh && (ff || player.Team != pResult.Player.Team))
{
DamagePlayer(player, player.ItemManager.SelectedItem.GetType().Name, (ServerMPPlayer)pResult.Player,
playerDamage, origin);
if (sv_impacts)
{
DashCMD.WriteLine("[IMP] Hit player for {0} damage. Health After: {1}", playerDamage, pResult.Player.Health);
}
}
}
ImpactAt(result.IntersectionPosition.Value);
}
}
