public void ServerPlayerDropWeapon(Server server, PlayerObjectComponent playerObjectComponent, int weaponIndex)
{
var playerWeapons = playerObjectComponent.State.Weapons;
var equippedWeaponState = playerWeapons[weaponIndex];
if ((equippedWeaponState == null))
{
return;
}
var weaponObjectState = new WeaponObjectState
{
Id = server.GenerateNetworkId(),
Type = equippedWeaponState.Type,
BulletsLeftInMagazine = equippedWeaponState.BulletsLeftInMagazine,
BulletsLeftOutOfMagazine = equippedWeaponState.BulletsLeftOutOfMagazine,
RigidBodyState = new RigidBodyState
{
Position = playerObjectComponent.HandsPointObject.transform.position,
EulerAngles = Vector3.zero,
Velocity = Vector3.zero,
AngularVelocity = Vector3.zero
}
};
WeaponSpawnerSystem.Instance.SpawnLocalWeaponObject(weaponObjectState);
playerObjectComponent.State.Weapons[weaponIndex] = null;
}
public Ray GetShotRay(PlayerObjectComponent playerObjectComponent)
{
return(new Ray(
playerObjectComponent.CameraPointObject.transform.position,
playerObjectComponent.CameraPointObject.transform.forward
));
}
public void ServerPlayerDropGrenades(Server server, PlayerObjectComponent playerObjectComponent, int grenadeSlotIndex)
{
var playerGrenadeSlots = playerObjectComponent.State.GrenadeSlots;
var grenadeSlot = playerGrenadeSlots[grenadeSlotIndex];
if ((grenadeSlot == null) || (grenadeSlot.GrenadeCount == 0))
{
return;
}
for (var i = 0; i < grenadeSlot.GrenadeCount; i++)
{
var grenadeState = new GrenadeState
{
Id = server.GenerateNetworkId(),
Type = grenadeSlot.GrenadeType,
RigidBodyState = new RigidBodyState
{
Position = playerObjectComponent.HandsPointObject.transform.position,
EulerAngles = Vector3.zero,
Velocity = Vector3.zero,
AngularVelocity = Vector3.zero
},
IsActive = false,
TimeUntilDetonation = null
};
GrenadeSpawnerSystem.Instance.SpawnLocalGrenadeObject(grenadeState);
}
playerGrenadeSlots[grenadeSlotIndex] = null;
}
public void ShowWeaponFireEffects(PlayerObjectComponent playerObjectComponent, Ray aimRay)
{
ShowMuzzleFlash(playerObjectComponent);
var weapon = playerObjectComponent.State.CurrentWeapon;
if (weapon != null)
{
if (weapon.Type == WeaponType.SniperRifle)
{
CreateSniperBulletTrail(aimRay);
}
var equippedWeaponComponent = PlayerObjectSystem.Instance.GetEquippedWeaponComponent(playerObjectComponent);
if (equippedWeaponComponent != null)
{
var weaponAudioSource = equippedWeaponComponent.GetComponent <AudioSource>();
weaponAudioSource?.PlayOneShot(weapon.Definition.ShotSound, 0.5f);
equippedWeaponComponent.Animator.Play("Recoil");
}
if (weapon.Definition.IsHitScan)
{
foreach (var shotRay in WeaponSystem.Instance.ShotRays(weapon.Definition, aimRay))
{
CreateBulletHole(playerObjectComponent, shotRay);
}
}
}
}
public void ClientPlayerTryToShoot(Client client, PlayerObjectComponent playerObjectComponent)
{
if (playerObjectComponent.State.CanShoot)
{
client.ClientPeer.CallRpcOnServer("ServerOnPlayerTriggerPulled", client.ClientPeer.reliableChannelId, new
{
playerId = playerObjectComponent.State.Id,
shotRay = GetShotRay(playerObjectComponent)
});
// predict the shot
var shotRay = GetShotRay(playerObjectComponent);
WeaponSystem.Instance.ShowWeaponFireEffects(playerObjectComponent, shotRay);
playerObjectComponent.State.RecoilTimeLeft = playerObjectComponent.State.CurrentWeapon.Definition.RecoilTime;
}
else
{
var equippedWeaponComponent = GetEquippedWeaponComponent(playerObjectComponent);
var weaponAudioSource = equippedWeaponComponent.GetComponent <AudioSource>();
weaponAudioSource?.PlayOneShot(OsFps.Instance.GunDryFireSound, 0.7f);
}
playerObjectComponent.State.CurrentWeapon.TimeSinceLastShot = 0;
}
public Vector2 GetPlayerLookDirAngles(PlayerObjectComponent playerObjectComponent)
{
return(new Vector2(
playerObjectComponent.CameraPointObject.transform.localEulerAngles.x,
playerObjectComponent.transform.eulerAngles.y
));
}
private PlayerLagCompensationSnapshot GetLagCompensationSnapshot(PlayerObjectComponent playerObjectComponent, float currentTime)
{
return(new PlayerLagCompensationSnapshot
{
Time = currentTime,
Position = playerObjectComponent.transform.position,
LookDirAngles = GetPlayerLookDirAngles(playerObjectComponent)
});
}
public void Jump(PlayerObjectComponent playerObjectComponent)
{
Assert.IsNotNull(playerObjectComponent);
var playerVelocity = playerObjectComponent.Rigidbody.velocity;
var newPlayerVelocity = new Vector3(playerVelocity.x, OsFps.PlayerInitialJumpSpeed, playerVelocity.z);
playerObjectComponent.Rigidbody.velocity = newPlayerVelocity;
}
private void DrawPlayerInput(PlayerObjectComponent playerObjectComponent)
{
var relativeMoveDirection = GetRelativeMoveDirection(playerObjectComponent.State.Input);
var playerYAngle = playerObjectComponent.transform.eulerAngles.y;
var horizontalMoveDirection = Quaternion.Euler(new Vector3(0, playerYAngle, 0)) * relativeMoveDirection;
var moveRay = new Ray(playerObjectComponent.transform.position + Vector3.up, horizontalMoveDirection);
Debug.DrawLine(moveRay.origin, moveRay.origin + moveRay.direction);
}
public void ServerDamagePlayer(Server server, PlayerObjectComponent playerObjectComponent, float damage, PlayerObjectComponent attackingPlayerObjectComponent)
{
if (!playerObjectComponent.State.IsAlive || (damage <= 0))
{
return;
}
var playerObjectState = playerObjectComponent.State;
var damageToShield = Mathf.Min(damage, playerObjectState.Shield);
playerObjectState.Shield -= damageToShield;
var damageToHealth = damage - damageToShield;
playerObjectState.Health -= damageToHealth;
playerObjectState.TimeUntilShieldCanRegen = OsFps.TimeAfterDamageUntilShieldRegen;
var playerComponent = FindPlayerComponent(playerObjectState.Id);
var playerState = playerComponent.State;
if (!playerObjectState.IsAlive)
{
for (var i = 0; i < playerObjectComponent.State.Weapons.Length; i++)
{
ServerPlayerDropWeapon(server, playerObjectComponent, i);
}
for (var i = 0; i < playerObjectComponent.State.GrenadeSlots.Length; i++)
{
ServerPlayerDropGrenades(server, playerObjectComponent, i);
}
// The player object will be destroyed later by the RemoveDeadPlayerSystem.
playerState.RespawnTimeLeft = OsFps.RespawnTime;
// Update scores
playerState.Deaths++;
if (attackingPlayerObjectComponent != null)
{
var attackingPlayerId = attackingPlayerObjectComponent.State.Id;
var attackingPlayerComponent = FindPlayerComponent(attackingPlayerId);
attackingPlayerComponent.State.Kills++;
}
// Send message.
server.ServerPeer.CallRpcOnAllClients("ClientOnReceiveChatMessage", server.ServerPeer.reliableSequencedChannelId, new
{
playerId = (uint?)null,
message = GetKillMessage(playerObjectComponent, attackingPlayerObjectComponent)
});
}
}
public void ShowMuzzleFlash(PlayerObjectComponent playerObjectComponent)
{
GameObject muzzleFlashObject = Object.Instantiate(
OsFps.Instance.MuzzleFlashPrefab, Vector3.zero, Quaternion.identity
);
var barrelExitObject = playerObjectComponent.HandsPointObject.FindDescendant("BarrelExit");
muzzleFlashObject.transform.SetParent(barrelExitObject.transform, false);
Object.Destroy(muzzleFlashObject, OsFps.MuzzleFlashDuration);
}
private string GetKillMessage(PlayerObjectComponent killedPlayerObjectComponent, PlayerObjectComponent attackerPlayerObjectComponent)
{
var killedPlayerComponent = FindPlayerComponent(killedPlayerObjectComponent.State.Id);
var attackerPlayerComponent = (attackerPlayerObjectComponent != null)
? FindPlayerComponent(attackerPlayerObjectComponent.State.Id)
: null;
return((attackerPlayerObjectComponent != null)
? string.Format("{0} killed {1}.", attackerPlayerComponent.State.Name, killedPlayerComponent.State.Name)
: string.Format("{0} died.", killedPlayerComponent.State.Name));
}
public void SetShieldAlpha(PlayerObjectComponent playerObjectComponent, float alpha)
{
foreach (var meshRenderer in playerObjectComponent.GetComponentsInChildren <MeshRenderer>())
{
var shieldDownMaterial = meshRenderer.materials
.FirstOrDefault(m => m.name.Contains(OsFps.Instance.ShieldDownMaterial.name));
if (shieldDownMaterial != null)
{
shieldDownMaterial.SetFloat(OsFps.ShieldDownMaterialAlphaParameterName, alpha);
}
}
}
public EquippedWeaponComponent GetEquippedWeaponComponent(PlayerObjectComponent playerObjectComponent)
{
foreach (Transform weaponTransform in playerObjectComponent.HandsPointObject.transform)
{
var equippedWeaponComponent = weaponTransform.gameObject.GetComponent <EquippedWeaponComponent>();
if (equippedWeaponComponent != null)
{
return(equippedWeaponComponent);
}
}
return(null);
}
public RaycastHit?GetClosestValidRaycastHitForGunShot(Ray shotRay, PlayerObjectComponent shootingPlayerObjectComponent)
{
var raycastHits = Physics.RaycastAll(shotRay);
var closestValidRaycastHit = raycastHits
.OrderBy(raycastHit => raycastHit.distance)
.Select(raycastHit => (RaycastHit?)raycastHit)
.FirstOrDefault(raycastHit =>
{
var hitPlayerObject = raycastHit.Value.collider.gameObject.FindObjectOrAncestorWithTag(OsFps.PlayerTag);
return((hitPlayerObject == null) || (hitPlayerObject != shootingPlayerObjectComponent.gameObject));
});
return(closestValidRaycastHit);
}
public void OnDestroy(PlayerObjectComponent playerObjectComponent)
{
var client = OsFps.Instance.Client;
if (client != null)
{
if (playerObjectComponent.State.Id == client.PlayerId)
{
client.DetachCameraFromPlayer();
}
PlayerObjectSystem.Instance.ShowPlayerDeathEffects(playerObjectComponent.transform.position + Vector3.up);
}
}
public void ServerPlayerFinishReload(PlayerObjectComponent playerObjectComponent)
{
var weapon = playerObjectComponent.State.CurrentWeapon;
if (weapon == null)
{
return;
}
var bulletsUsedInMagazine = weapon.Definition.BulletsPerMagazine - weapon.BulletsLeftInMagazine;
var bulletsToAddToMagazine = (ushort)Mathf.Min(bulletsUsedInMagazine, weapon.BulletsLeftOutOfMagazine);
weapon.BulletsLeftInMagazine += bulletsToAddToMagazine;
weapon.BulletsLeftOutOfMagazine -= bulletsToAddToMagazine;
}
public void CreateBulletHole(PlayerObjectComponent playerObjectComponent, Ray shotRay)
{
var possibleHit = WeaponSystem.Instance.GetClosestValidRaycastHitForGunShot(shotRay, playerObjectComponent);
if (possibleHit != null)
{
var raycastHit = possibleHit.Value;
var bulletHolePosition = raycastHit.point + (0.01f * raycastHit.normal);
var bulletHoleOrientation = Quaternion.LookRotation(-raycastHit.normal);
var bulletHole = Object.Instantiate(
OsFps.Instance.BulletHolePrefab, bulletHolePosition, bulletHoleOrientation, raycastHit.transform
);
Object.Destroy(bulletHole, 5);
}
}
public void ServerFireHitscanWeapon(
Server server, PlayerObjectComponent shootingPlayerObjectComponent,
WeaponDefinition weaponDefinition, Ray aimRay, float secondsToRewind
)
{
var shootingPlayerObjectState = shootingPlayerObjectComponent.State;
ServerRewindPlayers(secondsToRewind);
foreach (var shotRay in WeaponSystem.Instance.ShotRays(weaponDefinition, aimRay))
{
ServerApplyHitscanShot(server, shootingPlayerObjectComponent, weaponDefinition, shotRay);
}
ServerUnRewindPlayers();
}
public bool IsPlayerGrounded(PlayerObjectComponent playerObjectComponent)
{
var sphereRadius = 0.4f;
var spherePosition = playerObjectComponent.transform.position + new Vector3(0, 0.3f, 0);
var intersectingColliders = Physics.OverlapSphere(spherePosition, sphereRadius);
return(intersectingColliders.Any(collider =>
{
var otherPlayerObjectComponent = collider.gameObject.FindComponentInObjectOrAncestor <PlayerObjectComponent>();
return (
(otherPlayerObjectComponent == null) ||
(otherPlayerObjectComponent.State.Id != playerObjectComponent.State.Id)
);
}));
}
public void ServerPlayerTryToPickupWeapon(
Server server, PlayerObjectComponent playerObjectComponent, WeaponComponent weaponComponent
)
{
var playerState = playerObjectComponent.State;
if (!playerState.IsAlive)
{
return;
}
var weaponObjectState = weaponComponent.State;
var playersMatchingWeapon = playerState.Weapons.FirstOrDefault(
w => (w != null) && (w.Type == weaponComponent.State.Type)
);
if (playerState.HasEmptyWeapon)
{
var emptyWeaponIndex = System.Array.FindIndex(playerState.Weapons, w => w == null);
playerState.Weapons[emptyWeaponIndex] = ToEquippedWeaponState(weaponObjectState);
playerState.CurrentWeaponIndex = (byte)emptyWeaponIndex;
Object.Destroy(weaponComponent.gameObject);
}
else if (playersMatchingWeapon != null)
{
var numBulletsPickedUp = WeaponSystem.Instance.ServerAddBullets(
playersMatchingWeapon, weaponObjectState.BulletsLeft
);
WeaponSystem.Instance.ServerRemoveBullets(weaponObjectState, numBulletsPickedUp);
if (weaponObjectState.BulletsLeft == 0)
{
Object.Destroy(weaponComponent.gameObject);
}
}
else
{
// drop current weapon
ServerPlayerDropWeapon(server, playerObjectComponent, playerState.CurrentWeaponIndex);
// pick up other weapon
playerState.Weapons[playerState.CurrentWeaponIndex] = ToEquippedWeaponState(weaponObjectState);
Object.Destroy(weaponComponent.gameObject);
}
}
public void ApplyLagCompensationSnapshot(
PlayerObjectComponent playerObjectComponent, PlayerLagCompensationSnapshot snapshot
)
{
playerObjectComponent.transform.position = snapshot.Position;
ApplyLookDirAnglesToPlayer(playerObjectComponent, snapshot.LookDirAngles);
if (OsFps.ShowLagCompensationOnServer)
{
var tmpCube = GameObject.CreatePrimitive(PrimitiveType.Cube);
tmpCube.transform.position = snapshot.Position + (2 * new float3(0, 1, 0));
tmpCube.transform.localScale = 0.25f * Vector3.one;
tmpCube.transform.eulerAngles = new Vector3(snapshot.LookDirAngles.x, snapshot.LookDirAngles.y);
Object.DestroyImmediate(tmpCube.GetComponent <BoxCollider>());
Object.Destroy(tmpCube, 2);
}
}
public void Reload(PlayerObjectComponent playerObjectComponent)
{
ClientPeer.CallRpcOnServer("ServerOnPlayerReloadPressed", ClientPeer.reliableChannelId, new
{
playerId = playerObjectComponent.State.Id
});
playerObjectComponent.State.ReloadTimeLeft = playerObjectComponent.State.CurrentWeapon.Definition.ReloadTime;
playerObjectComponent.State.RecoilTimeLeft = -1;
var equippedWeaponComponent = PlayerObjectSystem.Instance.GetEquippedWeaponComponent(playerObjectComponent);
var audioSource = equippedWeaponComponent?.GetComponent <AudioSource>();
audioSource?.PlayOneShot(OsFps.Instance.ReloadSound, 0.5f);
equippedWeaponComponent.Animator.Play("Reload");
}
public void ServerPlayerStartReload(PlayerObjectComponent playerObjectComponent)
{
var playerObjectState = playerObjectComponent.State;
if (!playerObjectState.IsAlive)
{
return;
}
var weapon = playerObjectState.CurrentWeapon;
if (weapon == null)
{
return;
}
playerObjectState.ReloadTimeLeft = weapon.Definition.ReloadTime;
playerObjectComponent.State.RecoilTimeLeft = -1;
}
private void ClientUpdateThisPlayer(Client client, PlayerObjectComponent playerObjectComponent)
{
var playerObjectState = playerObjectComponent.State;
playerObjectState.Input = GetCurrentPlayersInput();
var unscaledDeltaMouse = new Vector2(Input.GetAxis("Mouse X"), Input.GetAxis("Mouse Y"));
var deltaMouse = client.GetMouseSensitivityForZoomLevel() * unscaledDeltaMouse;
playerObjectState.LookDirAngles = new Vector2(
Mathf.Clamp(MathfExtensions.ToSignedAngleDegrees(playerObjectState.LookDirAngles.x - deltaMouse.y), -90, 90),
Mathf.Repeat(playerObjectState.LookDirAngles.y + deltaMouse.x, 360)
);
if (Input.GetButtonDown("Reload") && playerObjectState.CanReload)
{
client.Reload(playerObjectComponent);
}
if (playerObjectState.Input.IsFirePressed)
{
var wasTriggerJustPulled = Input.GetButtonDown("Fire");
if (
playerObjectState.CanTryToFireWeapon &&
(wasTriggerJustPulled || playerObjectState.CurrentWeapon.Definition.IsAutomatic)
)
{
ClientPlayerTryToShoot(client, playerObjectComponent);
}
}
if (Input.GetButtonDown("Throw Grenade") && playerObjectState.CanThrowGrenade)
{
ClientThrowGrenade(client, playerObjectState);
}
if (Input.GetButtonDown("Switch Grenade"))
{
ClientSwitchGrenadeType(client, playerObjectState);
}
}
public void RequestSwitchWeapons(PlayerObjectComponent playerObjectComponent, int weaponIndex)
{
Assert.IsNotNull(playerObjectComponent);
var playerObjectState = playerObjectComponent.State;
if (weaponIndex == playerObjectState.CurrentWeaponIndex)
{
return;
}
// Send message to server.
ClientPeer.CallRpcOnServer("ServerOnChangeWeapon", ClientPeer.reliableSequencedChannelId, new
{
playerId = playerObjectState.Id,
weaponIndex = (byte)weaponIndex
});
ZoomLevel = 0;
}
public void ServerFireRocketLauncher(
Server server, PlayerObjectComponent shootingPlayerObjectComponent, Ray shotRay
)
{
var rocketState = new RocketState
{
Id = server.GenerateNetworkId(),
RigidBodyState = new RigidBodyState
{
Position = shotRay.origin + shotRay.direction,
EulerAngles = Quaternion.LookRotation(shotRay.direction, Vector3.up).eulerAngles,
Velocity = OsFps.RocketSpeed * shotRay.direction,
AngularVelocity = Vector3.zero
},
ShooterPlayerId = shootingPlayerObjectComponent.State.Id
};
var rocket = RocketSystem.Instance.SpawnLocalRocketObject(rocketState);
// Make grenade ignore collisions with thrower.
GameObjectExtensions.IgnoreCollisionsRecursive(rocket, shootingPlayerObjectComponent.gameObject);
}
public void ServerShoot(
Server server, PlayerObjectComponent shootingPlayerObjectComponent, Ray shotRay, float secondsToRewind
)
{
var shootingPlayerObjectState = shootingPlayerObjectComponent.State;
if (!shootingPlayerObjectState.CanShoot)
{
return;
}
var playerObjectComponent = FindPlayerObjectComponent(shootingPlayerObjectState.Id);
if (playerObjectComponent == null)
{
return;
}
var weaponState = shootingPlayerObjectState.CurrentWeapon;
var weaponDefinition = weaponState.Definition;
if (weaponState.Definition.IsHitScan)
{
ServerFireHitscanWeapon(server, shootingPlayerObjectComponent, weaponDefinition, shotRay, secondsToRewind);
}
else
{
if (weaponDefinition.Type == WeaponType.RocketLauncher)
{
ServerFireRocketLauncher(server, shootingPlayerObjectComponent, shotRay);
}
}
weaponState.BulletsLeftInMagazine--;
weaponState.TimeSinceLastShot = 0;
shootingPlayerObjectState.RecoilTimeLeft = weaponDefinition.RecoilTime;
}
public void ServerPlayerThrowGrenade(Server server, PlayerObjectComponent playerObjectComponent)
{
var playerObjectState = playerObjectComponent.State;
if (!playerObjectState.CanThrowGrenade)
{
return;
}
var throwRay = GetShotRay(playerObjectComponent);
throwRay.origin += (0.5f * throwRay.direction);
var currentGrenadeSlot = playerObjectState.GrenadeSlots[playerObjectState.CurrentGrenadeSlotIndex];
var grenadeState = new GrenadeState
{
Id = server.GenerateNetworkId(),
Type = currentGrenadeSlot.GrenadeType,
IsActive = true,
TimeUntilDetonation = null,
RigidBodyState = new RigidBodyState
{
Position = throwRay.origin,
EulerAngles = Quaternion.LookRotation(throwRay.direction, Vector3.up).eulerAngles,
Velocity = OsFps.GrenadeThrowSpeed * throwRay.direction,
AngularVelocity = Vector3.zero
},
ThrowerPlayerId = playerObjectState.Id
};
var grenadeObject = GrenadeSpawnerSystem.Instance.SpawnLocalGrenadeObject(grenadeState);
// Make grenade ignore collisions with thrower.
GameObjectExtensions.IgnoreCollisionsRecursive(grenadeObject, playerObjectComponent.gameObject);
currentGrenadeSlot.GrenadeCount--;
playerObjectState.TimeUntilCanThrowGrenade = OsFps.GrenadeThrowInterval;
}
public void ServerApplyHitscanShot(
Server server, PlayerObjectComponent shootingPlayerObjectComponent,
WeaponDefinition weaponDefinition, Ray shotRay
)
{
var possibleHit = WeaponSystem.Instance.GetClosestValidRaycastHitForGunShot(shotRay, shootingPlayerObjectComponent);
if (possibleHit != null)
{
var hit = possibleHit.Value;
var hitPlayerObject = hit.collider.gameObject.FindObjectOrAncestorWithTag(OsFps.PlayerTag);
if ((hitPlayerObject != null) && (hitPlayerObject != shootingPlayerObjectComponent.gameObject))
{
var hitPlayerObjectComponent = hitPlayerObject.GetComponent <PlayerObjectComponent>();
var isHeadShot = hit.collider.gameObject.name == OsFps.PlayerHeadColliderName;
var damage = !isHeadShot
? weaponDefinition.DamagePerBullet
: weaponDefinition.HeadShotDamagePerBullet;
ServerDamagePlayer(
server, hitPlayerObjectComponent, damage, shootingPlayerObjectComponent
);
}
if (hit.rigidbody != null)
{
hit.rigidbody.AddForceAtPosition(5 * shotRay.direction, hit.point, ForceMode.Impulse);
}
}
if (OsFps.ShowHitScanShotsOnServer)
{
WeaponSystem.Instance.CreateHitScanShotDebugLine(shotRay, OsFps.Instance.ServerShotRayMaterial);
}
}
