public override void OnPlayerDamageEvent(IPlayer player, IEntity entity, uint weapon, ushort damage)
{
base.OnPlayerDamageEvent(player, entity, weapon, damage);
if (!PlayerDamageAsyncEventHandler.HasEvents())
{
return;
}
var oldHealth = player.Health;
var oldArmor = player.Armor;
var oldMaxHealth = player.MaxHealth;
var oldMaxArmor = player.MaxArmor;
var playerReference = new PlayerRef(player);
var entityReference = new BaseObjectRef(entity);
Task.Run(async() =>
{
playerReference.DebugCountUp();
entityReference.DebugCountUp();
await PlayerDamageAsyncEventHandler.CallAsync(@delegate =>
@delegate(player, entity, oldHealth, oldArmor, oldMaxHealth, oldMaxArmor, weapon, damage));
entityReference.DebugCountDown();
playerReference.DebugCountDown();
playerReference.Dispose();
entityReference.Dispose();
});
}
public void OnPlayerLeft(NetworkRunner runner, PlayerRef player)
{
Util.Log($"{player.PlayerId} disconnected");
StartCoroutine(PlayerModel.Get(player).Co_RemovePlayer());
SetConnectionStatus(ConnectionStatus);
}
public void OnPlayerLeft(NetworkRunner runner, PlayerRef player)
{
Debug.Log("Player Left");
_despawnPlayerCallback(runner, player);
SetConnectionStatus(_status, "Player Left");
}
//AltAsync.OnPlayerEvent += OnPlayerEvent;
//...
/*class EventHandler
* {
* //...
* public void Call(IPlayer player, object[] args)
* {
* //...
* }
* }
*
* private EventHandler[] eventHandlers = new EventHandler[42];
*
* public async Task OnPlayerEvent(IPlayer player, string eventName, object[] args)
* {
* var number = FastStringToInt(eventName);
* if (eventHandlers.Length < number)
* {
* eventHandlers[number].Call(player, args);
* }
* }
*
* private static int FastStringToInt(string eventName)
* {
* var y = 0;
* for (var i = 0; i < eventName.Length; i++)
* y = y * 10 + (eventName[i] - '0');
* return y;
* }*/
public async void Bla2(IPlayer player)
{
using (var reference = new PlayerRef(player))
{
if (!reference.Exists)
{
return;
}
//TODO: how to prevent player exists check to happen here inside
//TODO: maybe create a PlayerRef struct from player native pointer and do all calls inside that struct
//TODO: other way would be make a counter in player that counts up on ref create and down on ref delete
//TODO: possible by adding addref and removeref methods to player class and counting the int up in them
player.Position = Position.Zero;
player.Rotation = Rotation.Zero;
}
await player.SetPositionAsync(new Position(1, 2, 3));
var unused = await player.GetPositionAsync();
await AltAsync.Do(() => { });
var unused2 = await AltAsync.Do(() =>
Alt.CreateVehicle(VehicleModel.Apc, new Position(1, 2, 3), new Rotation(1, 2, 3)));
}
public override void OnSyncedMetaDataChangeEvent(IEntity entity, string key, object value)
{
base.OnSyncedMetaDataChangeEvent(entity, key, value);
if (!SyncedMetaDataChangeAsyncDelegateHandlers.HasEvents())
{
return;
}
switch (entity)
{
case IPlayer playerEntity:
var playerEntityReference = new PlayerRef(playerEntity);
Task.Run(async() =>
{
await SyncedMetaDataChangeAsyncDelegateHandlers.CallAsync(@delegate =>
@delegate(entity, key, value));
playerEntityReference.Dispose();
});
break;
case IVehicle vehicleEntity:
var vehicleEntityReference = new VehicleRef(vehicleEntity);
Task.Run(async() =>
{
await SyncedMetaDataChangeAsyncDelegateHandlers.CallAsync(@delegate =>
@delegate(entity, key, value));
vehicleEntityReference.Dispose();
});
break;
default:
Task.Run(() => SyncedMetaDataChangeAsyncDelegateHandlers.CallAsyncWithoutTask(@delegate =>
@delegate(entity, key, value)));
break;
}
}
public void FinalizeTeams()
{
GameObject[] players = GameObject.FindGameObjectsWithTag("PlayerTag");
for (int i = 0; i < players.Length; i++)
{
PlayerRef temp = players[i].GetComponent <PlayerRef>();
int team = temp.team;
Player p = temp.player;
List <Player> alreadyIn;
bool exists = teamMembers.TryGetValue(team, out alreadyIn);
if (exists)
{
teamMembers.Remove(team);
alreadyIn.Add(p);
teamMembers.Add(team, alreadyIn);
}
else
{
List <Player> newPlayers = new List <Player>();
newPlayers.Add(p);
teamMembers.Add(team, newPlayers);
}
}
team0 = teamMembers[0];
team1 = teamMembers[teamMembers.Count - 1];
PhotonNetwork.LoadLevel("Dungeon");
}
//Filter the player currently logged in from the collection so that we can update the correct player's data. Insert updated version of the player's highscore collection.
public void UpdatePlayerData(PlayerRef player, HighScore highScore)
{
var playerFilter = Builders <PlayerRef> .Filter.Eq(x => x.Name, player.Name);
var update = Builders <PlayerRef> .Update.Set(o => o.ScoreCollection, UpdateCollectionItem(hsCollection, highScore));
var result = playerCollection.UpdateOneAsync(playerFilter, update).Result;
}
internal static void OnDesireTimer(object sender, ElapsedEventArgs e)
{
Alt.Log("OnDesireTimer Timer aufgerufen");
foreach (IPlayer player in Alt.Server.GetPlayers().ToList())
{
if (player == null)
{
continue;
}
using (var pRef = new PlayerRef(player))
{
if (!pRef.Exists)
{
return;
}
lock (player)
{
if (player.Exists && User.GetPlayerOnline(player) != 0)
{
int charId = User.GetPlayerOnline(player);
int random = new Random().Next(1, 1);
if (Characters.GetCharacterHunger(User.GetPlayerOnline(player)) > 0)
{
Characters.SetCharacterHunger(charId, (Characters.GetCharacterHunger(charId) - random));
if (Characters.GetCharacterHunger(charId) < 0)
{
Characters.SetCharacterHunger(charId, 0);
}
}
else
{
player.Health = (ushort)(player.Health - 3);
Characters.SetCharacterHealth(charId, player.Health);
HUDHandler.SendNotification(player, 1, 5000, $"Du hast Hunger.");
}
if (Characters.GetCharacterThirst(User.GetPlayerOnline(player)) > 0)
{
Characters.SetCharacterThirst(charId, (Characters.GetCharacterThirst(charId) - random));
if (Characters.GetCharacterThirst(charId) < 0)
{
Characters.SetCharacterThirst(charId, 0);
}
}
else
{
player.Health = (ushort)(player.Health - 5);
Characters.SetCharacterHealth(charId, player.Health);
HUDHandler.SendNotification(player, 1, 5000, $"Du hast Durst.");
}
Alt.Log($"Essen/Durst Anzeige update: {Characters.GetCharacterHunger(charId)} | {Characters.GetCharacterThirst(charId)}");
player.EmitLocked("Client:HUD:UpdateDesire", Characters.GetCharacterHunger(charId), Characters.GetCharacterThirst(charId)); //Hunger & Durst Anzeige aktualisieren
}
}
}
}
}
public void OnPlayerJoined(NetworkRunner runner, PlayerRef player)
{
if (runner.IsServer)
{
Debug.Log("Hosted Mode - Spawning Player");
InstantiatePlayer(runner, player);
}
// SetConnectionStatus(ConnectionStatus.Connected, "");
}
private void InstantiatePlayer(NetworkRunner runner, PlayerRef playerref)
{
if (_spawnWorldCallback != null && (runner.IsServer || runner.IsSharedModeMasterClient))
{
_spawnWorldCallback(runner);
_spawnWorldCallback = null;
}
_spawnPlayerCallback(runner, playerref);
}
private void Awake()
{
if (Instance == null)
{
Instance = this;
}
else
{
Destroy(gameObject);
}
}
void MakeSingleton()
{
if (instance == null)
{
instance = this;
}
else
{
Destroy(this);
}
}
//If an instance of this singleton exists, then destroy the gameobject (this means there are more than one)
//If an instance doesn't exist, create one
private void Awake()
{
if (Instance != null && Instance != this)
{
Debug.Log("Warning: found more than one instance of PlayerRef Singleton. Destroying " + gameObject.name + " gameobject.");
Destroy(gameObject);
}
else
{
Instance = this;
}
}
//Used in a situation where the player has already logged in when the game starts. (Once logged in, you log out only if log out button is pressed manually.)
public void SetDataIfLogin(string playerName)
{
LoginSuccess = true;
playerList = playerCollection.Find(new BsonDocument()).ToList();
foreach (var playerObject in playerList)
{
if (playerObject.Name.Equals(playerName))
{
player = playerObject;
hsCollection = player.ScoreCollection;
}
}
}
public override void ForEach(IBaseObjectCallback <IPlayer> baseObjectCallback)
{
foreach (var entity in GetAllEntities())
{
using var entityRef = new PlayerRef(entity);
if (!entityRef.Exists)
{
continue;
}
entityRef.DebugCountUp();
baseObjectCallback.OnBaseObject(entity);
entityRef.DebugCountDown();
}
}
public override void OnWeaponDamageEvent(IntPtr eventPointer, IPlayer sourcePlayer, IEntity targetEntity, uint weapon, ushort damage,
Position shotOffset, BodyPart bodyPart)
{
base.OnWeaponDamageEvent(eventPointer, sourcePlayer, targetEntity, weapon, damage, shotOffset, bodyPart);
if (!WeaponDamageAsyncEventHandler.HasEvents())
{
return;
}
var sourceReference = new PlayerRef(sourcePlayer);
switch (targetEntity)
{
case IPlayer targetPlayer:
{
var targetReference = new PlayerRef(targetPlayer);
Task.Run(async() =>
{
await WeaponDamageAsyncEventHandler.CallAsync(@delegate =>
@delegate(sourcePlayer, targetEntity, weapon, damage, shotOffset, bodyPart));
sourceReference.Dispose();
targetReference.Dispose();
});
break;
}
case IVehicle targetVehicle:
{
var targetReference = new VehicleRef(targetVehicle);
Task.Run(async() =>
{
await WeaponDamageAsyncEventHandler.CallAsync(@delegate =>
@delegate(sourcePlayer, targetEntity, weapon, damage, shotOffset, bodyPart));
sourceReference.Dispose();
targetReference.Dispose();
});
break;
}
default:
Task.Run(async() =>
{
await WeaponDamageAsyncEventHandler.CallAsync(@delegate =>
@delegate(sourcePlayer, targetEntity, weapon, damage, shotOffset, bodyPart));
sourceReference.Dispose();
});
break;
}
}
void OnCollisionEnter(Collision collision)
{
if (collision.collider.tag == "Player")
{
if (!runOnce)
{
PlayerRef.DecreaseHealth(35);
runOnce = true;
}
DestroyAsteroid();
}
else if (collision.collider.tag == "DeadZone" || collision.collider.tag == "Asteroid")
{
DestroyObject();
}
}
public override void OnPlayerRemoveEvent(IPlayer player)
{
base.OnPlayerRemoveEvent(player);
if (!PlayerRemoveAsyncEventHandler.HasEvents())
{
return;
}
var playerReference = new PlayerRef(player);
Task.Run(async() =>
{
await PlayerRemoveAsyncEventHandler.CallAsync(@delegate =>
@delegate(player));
playerReference.Dispose();
});
}
public override void OnCheckPointEvent(ICheckpoint checkpoint, IEntity entity, bool state)
{
base.OnCheckPointEvent(checkpoint, entity, state);
if (!CheckpointAsyncEventHandler.HasEvents())
{
return;
}
var checkpointReference = new CheckpointRef(checkpoint);
switch (entity)
{
case IPlayer playerEntity:
var playerEntityReference = new PlayerRef(playerEntity);
Task.Run(async() =>
{
await CheckpointAsyncEventHandler.CallAsync(@delegate => @delegate(checkpoint, entity, state));
checkpointReference.Dispose();
playerEntityReference.Dispose();
});
break;
case IVehicle vehicleEntity:
var vehicleEntityReference = new VehicleRef(vehicleEntity);
Task.Run(async() =>
{
await CheckpointAsyncEventHandler.CallAsync(@delegate => @delegate(checkpoint, entity, state));
checkpointReference.Dispose();
vehicleEntityReference.Dispose();
});
break;
default:
Task.Run(async() =>
{
await CheckpointAsyncEventHandler.CallAsync(@delegate => @delegate(checkpoint, entity, state));
checkpointReference.Dispose();
});
break;
}
Task.Run(async() =>
{
await CheckpointAsyncEventHandler.CallAsync(@delegate => @delegate(checkpoint, entity, state));
checkpointReference.Dispose();
});
}
public override void OnPlayerDamageEvent(IPlayer player, IEntity entity, uint weapon, ushort damage)
{
base.OnPlayerDamageEvent(player, entity, weapon, damage);
if (!PlayerDamageAsyncEventHandler.HasEvents())
{
return;
}
var oldHealth = player.Health;
var oldArmor = player.Armor;
var oldMaxHealth = player.MaxHealth;
var oldMaxArmor = player.MaxArmor;
var playerReference = new PlayerRef(player);
switch (entity)
{
case IPlayer playerEntity:
var playerEntityReference = new PlayerRef(playerEntity);
Task.Run(async() =>
{
await PlayerDamageAsyncEventHandler.CallAsync(@delegate =>
@delegate(player, entity, oldHealth, oldArmor, oldMaxHealth, oldMaxArmor, weapon, damage));
playerReference.Dispose();
playerEntityReference.Dispose();
});
break;
case IVehicle vehicleEntity:
var vehicleEntityReference = new VehicleRef(vehicleEntity);
Task.Run(async() =>
{
await PlayerDamageAsyncEventHandler.CallAsync(@delegate =>
@delegate(player, entity, oldHealth, oldArmor, oldMaxHealth, oldMaxArmor, weapon, damage));
playerReference.Dispose();
vehicleEntityReference.Dispose();
});
break;
default:
Task.Run(async() =>
{
await PlayerDamageAsyncEventHandler.CallAsync(@delegate =>
@delegate(player, entity, oldHealth, oldArmor, oldMaxHealth, oldMaxArmor, weapon, damage));
playerReference.Dispose();
});
break;
}
}
public override void OnExplosionEvent(IPlayer sourcePlayer, ExplosionType explosionType, Position position,
uint explosionFx)
{
base.OnExplosionEvent(sourcePlayer, explosionType, position, explosionFx);
if (!ExplosionAsyncEventHandler.HasEvents())
{
return;
}
var sourceReference = new PlayerRef(sourcePlayer);
Task.Run(async() =>
{
await ExplosionAsyncEventHandler.CallAsync(@delegate =>
@delegate(sourcePlayer, explosionType, position, explosionFx));
sourceReference.Dispose();
});
}
public override void OnPlayerWeaponChangeEvent(IntPtr eventPointer, IPlayer player, uint oldWeapon, uint newWeapon)
{
base.OnPlayerWeaponChangeEvent(eventPointer, player, oldWeapon, newWeapon);
if (!PlayerWeaponChangeAsyncDelegateHandlers.HasEvents())
{
return;
}
var playerRef = new PlayerRef(player);
Task.Run(async() =>
{
playerRef.DebugCountUp();
await PlayerWeaponChangeAsyncDelegateHandlers.CallAsync(@delegate =>
@delegate(player, oldWeapon, newWeapon));
playerRef.DebugCountDown();
playerRef.Dispose();
});
}
public override void OnFireEvent(IntPtr eventPointer, IPlayer player, FireInfo[] fires)
{
base.OnFireEvent(eventPointer, player, fires);
if (!FireAsyncDelegateHandlers.HasEvents())
{
return;
}
var playerRef = new PlayerRef(player);
Task.Run(async() =>
{
playerRef.DebugCountUp();
await FireAsyncDelegateHandlers.CallAsync(@delegate =>
@delegate(player, fires));
playerRef.DebugCountDown();
playerRef.Dispose();
});
}
public override void OnPlayerConnectEvent(IPlayer player, string reason)
{
base.OnPlayerConnectEvent(player, reason);
if (!PlayerConnectAsyncEventHandler.HasEvents())
{
return;
}
var playerReference = new PlayerRef(player);
Task.Run(async() =>
{
playerReference.DebugCountUp();
await PlayerConnectAsyncEventHandler.CallAsync(@delegate =>
@delegate(player, reason));
playerReference.DebugCountDown();
playerReference.Dispose();
});
}
public override void OnPlayerLeaveVehicleEvent(IVehicle vehicle, IPlayer player, byte seat)
{
base.OnPlayerLeaveVehicleEvent(vehicle, player, seat);
if (!PlayerLeaveVehicleAsyncEventHandler.HasEvents())
{
return;
}
var playerReference = new PlayerRef(player);
var vehicleReference = new VehicleRef(vehicle);
Task.Run(async() =>
{
await PlayerLeaveVehicleAsyncEventHandler.CallAsync(@delegate =>
@delegate(vehicle, player, seat));
playerReference.Dispose();
vehicleReference.Dispose();
});
}
public override void OnStartProjectileEvent(IntPtr eventPointer, IPlayer player, Position startPosition, Position direction,
uint ammoHash, uint weaponHash)
{
base.OnStartProjectileEvent(eventPointer, player, startPosition, direction, ammoHash, weaponHash);
if (!StartProjectileAsyncDelegateHandlers.HasEvents())
{
return;
}
var playerRef = new PlayerRef(player);
Task.Run(async() =>
{
playerRef.DebugCountUp();
await StartProjectileAsyncDelegateHandlers.CallAsync(@delegate =>
@delegate(player, startPosition, direction, ammoHash, weaponHash));
playerRef.DebugCountDown();
playerRef.Dispose();
});
}
public override void OnColShapeEvent(IColShape colShape, IEntity entity, bool state)
{
base.OnColShapeEvent(colShape, entity, state);
if (!ColShapeAsyncDelegateHandlers.HasEvents())
{
return;
}
var colShapeReference = new ColShapeRef(colShape);
switch (entity)
{
case IPlayer playerEntity:
var playerEntityReference = new PlayerRef(playerEntity);
Task.Run(async() =>
{
await ColShapeAsyncDelegateHandlers.CallAsync(@delegate =>
@delegate(colShape, entity, state));
playerEntityReference.Dispose();
colShapeReference.Dispose();
});
break;
case IVehicle vehicleEntity:
var vehicleEntityReference = new VehicleRef(vehicleEntity);
Task.Run(async() =>
{
await ColShapeAsyncDelegateHandlers.CallAsync(@delegate =>
@delegate(colShape, entity, state));
vehicleEntityReference.Dispose();
colShapeReference.Dispose();
});
break;
default:
Task.Run(async() =>
{
await ColShapeAsyncDelegateHandlers.CallAsync(@delegate =>
@delegate(colShape, entity, state));
colShapeReference.Dispose();
});
break;
}
}
public override void OnPlayerDeathEvent(IPlayer player, IEntity killer, uint weapon)
{
base.OnPlayerDeathEvent(player, killer, weapon);
if (!PlayerDeadAsyncEventHandler.HasEvents())
{
return;
}
var playerReference = new PlayerRef(player);
switch (killer)
{
case IPlayer playerKiller:
var playerKillerReference = new PlayerRef(playerKiller);
Task.Run(async() =>
{
await PlayerDeadAsyncEventHandler.CallAsync(@delegate =>
@delegate(player, killer, weapon));
playerReference.Dispose();
playerKillerReference.Dispose();
});
break;
case IVehicle vehicleKiller:
var vehicleKillerReference = new VehicleRef(vehicleKiller);
Task.Run(async() =>
{
await PlayerDeadAsyncEventHandler.CallAsync(@delegate =>
@delegate(player, killer, weapon));
playerReference.Dispose();
vehicleKillerReference.Dispose();
});
break;
default:
Task.Run(async() =>
{
await PlayerDeadAsyncEventHandler.CallAsync(@delegate =>
@delegate(player, killer, weapon));
playerReference.Dispose();
});
break;
}
}
// Update is called once per frame
void Update()
{
if (!moveTowardsPlayer)
{
asteroidTransform.position += Vector3.back * Time.deltaTime * movementSpeed;
}
else
{
float step = movementSpeed * Time.deltaTime;
transform.position = Vector3.MoveTowards(asteroidTransform.position, PlayerRef.instance.playerTransform.position, step);
//if it's moving towards player update IsInView check
_wasInView = _isInView;
_isInView = Check_ObjectIsInView();
//update warning blip list if there is a change in view
if (_wasInView && !_isInView || _isInView && !_wasInView) //this reads as 'if it was in view & it is not in view now || if it is in view & it wasn't in view'
{
WarningBlips.instance.UpdateList(this);
}
/* if(_isInView && !_wasInView)
* {
* //asteroid popped into view,show blip
* warningBlipObject.SetActive(true);
* warningBlipObject.GetComponent<EasyTween>().OpenCloseObjectAnimation();
* }
* else if (_wasInView && !_isInView)
* {
* //asteroid popped out of view,hide blip
* warningBlipObject.SetActive(false);
* }*/
}
if (applyDamage)
{
health -= Time.deltaTime * gazeInput.gazeTime * PlayerRef.instance.powerMultiplier;
if (health <= 0)
{
PlayerRef.IncreaseHealth(5);
DestroyAsteroid();
}
}
}
//Verify if user put the correct credentials on login menu and return a playerobject matching those credentials from the database if he did.
public PlayerRef GetPlayerByCredentials(string playerName, string pw)
{
playerList = playerCollection.Find(new BsonDocument()).ToList();
foreach (var playerObject in playerList)
{
if (playerObject.Name.Equals(playerName))
{
var decrypted = PasswordHandler.Decrypt(playerObject.Password, playerObject.Name);
if (decrypted.Equals(pw))
{
LoginSuccess = true;
player = playerObject;
hsCollection = playerObject.ScoreCollection;
}
else
{
LoginSuccess = false;
}
}
}
return(player);
}
