TechbloxModdingAPI/GamecraftModdingAPI/Players/PlayerEngine.cs

using System;
using System.Runtime.CompilerServices;

using RobocraftX.Character;
using RobocraftX.Character.Movement;
using RobocraftX.Common.Players;
using RobocraftX.Common.Input;
using RobocraftX.CR.MachineEditing.BoxSelect;
using RobocraftX.Physics;
using RobocraftX.Blocks.Ghost;
using RobocraftX.Character.Camera;
using RobocraftX.Character.Factories;
using Gamecraft.CharacterVulnerability;
using Gamecraft.CharacterVulnerability.Entities;
using Svelto.ECS;
using Unity.Mathematics;
using Unity.Physics;
using UnityEngine;

using GamecraftModdingAPI.Engines;

namespace GamecraftModdingAPI.Players
{
	internal class PlayerEngine : IApiEngine, IFactoryEngine
	{
		public string Name { get; } = "GamecraftModdingAPIPlayerGameEngine";

		public EntitiesDB entitiesDB { set; private get; }

		public bool isRemovable => false;

		public IEntityFactory Factory { set; private get; }

		private bool isReady = false;

		public void Dispose()
		{
			isReady = false;
		}

		public void Ready()
		{
			isReady = true;
		}

        public uint GetLocalPlayer()
		{
			if (!isReady) return uint.MaxValue;
			var localPlayers = entitiesDB.QueryEntities<PlayerIDStruct>(PlayersExclusiveGroups.LocalPlayers);
			if (localPlayers.count > 0)
			{
				return localPlayers[0].ID.entityID;
			}
			return uint.MaxValue;
		}

        public uint GetRemotePlayer()
		{
			if (!isReady) return uint.MaxValue;
			var localPlayers = entitiesDB.QueryEntities<PlayerIDStruct>(PlayersExclusiveGroups.RemotePlayers);
            if (localPlayers.count > 0)
            {
                return localPlayers[0].ID.entityID;
            }
			return uint.MaxValue;
		}

        public uint GetAllPlayerCount()
		{
			uint count = 0;
			foreach (ExclusiveGroupStruct eg in PlayersExclusiveGroups.AllPlayers)
			{
				count += entitiesDB.Count<PlayerIDStruct>(eg);
			}
			return count;
		}

        public uint GetLocalPlayerCount()
		{
			return entitiesDB.Count<PlayerIDStruct>(PlayersExclusiveGroups.LocalPlayers);
		}

		public uint GetRemotePlayerCount()
        {
            return entitiesDB.Count<PlayerIDStruct>(PlayersExclusiveGroups.RemotePlayers);
        }

        public bool ExistsById(uint playerId)
		{
			return entitiesDB.Exists<PlayerIDStruct>(playerId, PlayersExclusiveGroups.LocalPlayers)
			       || entitiesDB.Exists<PlayerIDStruct>(playerId, PlayersExclusiveGroups.RemotePlayers);
		}

        public float3 GetLocation(uint playerId)
		{
			ref var rbes = ref GetCharacterStruct<RigidBodyEntityStruct>(playerId, out bool exists);
			if (exists)
			{
				return rbes.position;
			}
			return float3.zero;
		}

		public bool SetLocation(uint playerId, float3 location, bool exitSeat = true)
		{
			var characterGroups = CharacterExclusiveGroups.AllCharacters;
			for (int i = 0; i < characterGroups.count; i++)
            {
                EGID egid = new EGID(playerId, characterGroups[i]);
				if (entitiesDB.Exists<RigidBodyEntityStruct>(egid))
                {
                    ref RigidBodyEntityStruct rbes = ref entitiesDB.QueryEntity<RigidBodyEntityStruct>(egid);
                    if (characterGroups[i] == CharacterExclusiveGroups.InPilotSeatGroup && exitSeat)
                    {
                        entitiesDB.QueryEntity<CharacterPilotSeatEntityStruct>(egid).instantExit = true;
                        entitiesDB.PublishEntityChange<CharacterPilotSeatEntityStruct>(egid);
                    }
					rbes.position = location;
					return true;
                }
            }
			return false;
		}

		public float3 GetRotation(uint playerId)
		{
			ref var rbes = ref GetCharacterStruct<RigidBodyEntityStruct>(playerId, out bool exists);
			if (exists)
			{
				return ((Quaternion) rbes.rotation).eulerAngles;
			}
			return default(float3);
		}

		public bool SetRotation(uint playerId, float3 value)
        {
	        ref var rbes = ref GetCharacterStruct<RigidBodyEntityStruct>(playerId, out bool exists);
            if (exists)
            {
	            Quaternion q = rbes.rotation;
	            q.eulerAngles = value;
	            rbes.rotation = q;
				return true;
            }
            return false;
        }

        public float3 GetLinearVelocity(uint playerId)
		{
			ref var rbes = ref GetCharacterStruct<RigidBodyEntityStruct>(playerId, out bool exists);
			if (exists)
            {
				return rbes.velocity;
            }
            return float3.zero;
		}

		public bool SetLinearVelocity(uint playerId, float3 value)
        {
	        ref var rbes = ref GetCharacterStruct<RigidBodyEntityStruct>(playerId, out bool exists);
			if (exists)
            {
                rbes.velocity = value;
				return true;
            }
			return false;
        }

		public float3 GetAngularVelocity(uint playerId)
        {
	        ref var rbes = ref GetCharacterStruct<RigidBodyEntityStruct>(playerId, out bool exists);
            if (exists)
            {
                return rbes.angularVelocity;
            }
            return float3.zero;
        }

        public bool SetAngularVelocity(uint playerId, float3 value)
        {
	        ref var rbes = ref GetCharacterStruct<RigidBodyEntityStruct>(playerId, out bool exists);
            if (exists)
            {
                rbes.angularVelocity = value;
                return true;
            }
            return false;
        }

		public PhysicsMass GetMass(uint playerId)
		{
			ref var rbes = ref GetCharacterStruct<RigidBodyEntityStruct>(playerId, out bool exists);
			if (exists)
            {
				return rbes.physicsMass;
            }
			return default(PhysicsMass);
		}

        public bool SetInverseMass(uint playerId, float inverseMass)
		{
			ref var rbes = ref GetCharacterStruct<RigidBodyEntityStruct>(playerId, out bool exists);
			if (exists)
            {
				rbes.physicsMass.InverseInertia = inverseMass;
                return true;
            }
            return false;
		}

		public float? GetLastPingTime(uint playerId, PlayerType type)
		{
			EGID egid = new EGID(playerId, PlayerGroupFromEnum(type));
			if (entitiesDB.Exists<PlayerNetworkStatsEntityStruct>(egid))
			{
				return entitiesDB.QueryEntity<PlayerNetworkStatsEntityStruct>(egid).lastPingTimeSinceLevelLoad;
			}
			return null;
		}

		public float GetInitialHealth(uint playerId)
		{
			ref var c = ref GetCharacterStruct<CharacterHealthEntityStruct>(playerId, out bool exists);
			if (exists)
            {
				return c.initialHealth;
            }
            return -1f;
		}

		public bool SetInitialHealth(uint playerId, float val)
        {
	        ref var c = ref GetCharacterStruct<CharacterHealthEntityStruct>(playerId, out bool exists);
			if (exists)
            {
                c.initialHealth = val;
				return true;
            }
			return false;
        }

		public float GetCurrentHealth(uint playerId)
        {
	        ref var c = ref GetCharacterStruct<CharacterHealthEntityStruct>(playerId, out bool exists);
			if (exists)
            {
                return c.currentHealth;
            }
            return -1f;
        }

		public bool SetCurrentHealth(uint playerId, float val)
        {
	        ref var c = ref GetCharacterStruct<CharacterHealthEntityStruct>(playerId, out bool exists);
			if (exists)
            {
                c.currentHealth = val;
				return true;
            }
            return false;
        }

		public bool DamagePlayer(uint playerId, float amount)
		{
			Factory.BuildEntity<DamageEntityDescriptor>(
				new EGID(CharacterVulnerabilityExclusiveGroups.NextDamageEntityId, CharacterVulnerabilityExclusiveGroups.CharacterDamageExclusiveGroup)
			).Init(new DamageEntityStruct
			{
				damage = amount,
				targetPlayerEntityId = playerId,
			});
			return true;
		}

		public bool GetDamageable(uint playerId)
        {
	        ref var c = ref GetCharacterStruct<CharacterHealthEntityStruct>(playerId, out bool exists);
			if (exists)
            {
                return c.canTakeDamageStat;
            }
            return false;
        }

        public bool SetDamageable(uint playerId, bool val)
        {
	        ref var ches = ref GetCharacterStruct<CharacterHealthEntityStruct>(playerId, out bool exists);
			if (exists)
            {
				ches.canTakeDamage = val;
				ches.canTakeDamage = val;
                return true;
            }
            return false;
        }

		public uint GetInitialLives(uint playerId)
        {
	        ref var c = ref GetCharacterStruct<CharacterLivesEntityComponent>(playerId, out bool exists);
            if (exists)
            {
                return c.initialLives;
            }
            return uint.MaxValue;
        }

        public bool SetInitialLives(uint playerId, uint val)
        {
	        ref var c = ref GetCharacterStruct<CharacterLivesEntityComponent>(playerId, out bool exists);
            if (exists)
            {
                c.initialLives = val;
                return true;
            }
            return false;
        }

		public uint GetCurrentLives(uint playerId)
        {
	        ref var c = ref GetCharacterStruct<CharacterLivesEntityComponent>(playerId, out bool exists);
			if (exists)
            {
				return c.currentLives;
            }
			return uint.MaxValue;
        }

        public bool SetCurrentLives(uint playerId, uint val)
        {
	        ref var c = ref GetCharacterStruct<CharacterLivesEntityComponent>(playerId, out bool exists);
			if (exists)
            {
				c.currentLives = val;
                return true;
            }
            return false;
        }

		public bool GetGameOverScreen(uint playerId)
		{
			ref var c = ref GetCharacterStruct<CharacterLivesEntityComponent>(playerId, out bool exists);
			if (exists)
			{
				return c.gameOverScreen;
            }
            return false;
		}

        public bool IsDead(uint playerId)
		{
			return entitiesDB.Exists<RigidBodyEntityStruct>(playerId, CharacterExclusiveGroups.DeadCharacters);
		}

        public int GetSelectedBlock(uint playerId)
        {
	        ref var c = ref GetCharacterStruct<EquippedPartStruct>(playerId, out bool exists);
			if (exists)
            {
				return c.SelectedDBPartID;
            }
			return ushort.MaxValue;
		}

		public byte GetSelectedColor(uint playerId)
        {
	        ref var c = ref GetCharacterStruct<EquippedColourStruct>(playerId, out bool exists);
            if (exists)
            {
				return c.indexInPalette;
            }
            return 255;
        }

        // reusable methods

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private ExclusiveGroup PlayerGroupFromEnum(PlayerType type)
		{
			return type == PlayerType.Local ? PlayersExclusiveGroups.LocalPlayers : PlayersExclusiveGroups.RemotePlayers; 
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public ref T GetCharacterStruct<T>(uint playerId, out bool exists) where T : unmanaged, IEntityComponent
        {
            var characterGroups = CharacterExclusiveGroups.AllCharacters;
            for (int i = 0; i < characterGroups.count; i++)
            {
                EGID egid = new EGID(playerId, characterGroups[i]);
                if (entitiesDB.Exists<T>(egid))
                {
	                exists = true;
                    return ref entitiesDB.QueryEntity<T>(egid);
                }
            }

            exists = false;
            T[] arr = new T[1];
            return ref arr[0]; //Return default value
        }

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
        public bool GetPlayerStruct<T>(uint playerId, out T s) where T : unmanaged, IEntityComponent
        {
            var playerGroups = PlayersExclusiveGroups.AllPlayers;
            for (int i = 0; i < playerGroups.count; i++)
            {
                EGID egid = new EGID(playerId, playerGroups[i]);
                if (entitiesDB.Exists<T>(egid))
                {
                    s = entitiesDB.QueryEntity<T>(egid);
                    return true;
                }
            }
            s = default;
            return false;
        }

        public EGID? GetThingLookedAt(uint playerId, float maxDistance = -1f)
        {
	        if (!entitiesDB.TryQueryMappedEntities<CharacterCameraRayCastEntityStruct>(
		        CameraExclusiveGroups.CameraGroup, out var mapper))
		        return null;
	        mapper.TryGetEntity(playerId, out CharacterCameraRayCastEntityStruct rayCast);
	        float distance = maxDistance < 0
		        ? GhostBlockUtils.GetBuildInteractionDistance(entitiesDB, rayCast,
			        GhostBlockUtils.GhostCastMethod.GhostCastProportionalToBlockSize)
		        : maxDistance;
	        if (rayCast.hit && rayCast.distance <= distance)
		        return rayCast.hitEgid;

	        return null;
        }

        public unsafe Block[] GetSelectedBlocks(uint playerid)
        {
	        if (!entitiesDB.Exists<BoxSelectStateEntityStruct>(playerid,
		        BoxSelectExclusiveGroups.BoxSelectVolumeExclusiveGroup))
		        return new Block[0];
	        var state = entitiesDB.QueryEntity<BoxSelectStateEntityStruct>(playerid,
		        BoxSelectExclusiveGroups.BoxSelectVolumeExclusiveGroup);
	        var blocks = entitiesDB.QueryEntity<SelectedBlocksStruct>(playerid,
		        BoxSelectExclusiveGroups.BoxSelectVolumeExclusiveGroup);
	        if (!state.active) return new Block[0];
	        var pointer = (EGID*) blocks.selectedBlocks.ToPointer();
	        var ret = new Block[blocks.count];
	        for (int j = 0; j < blocks.count; j++)
	        {
		        var egid = pointer[j];
		        ret[j] = new Block(egid);
	        }

	        return ret;
        }
	}
}