TechbloxModdingAPI/GamecraftModdingAPI/Player.cs

using System;

using Unity.Mathematics;
using RobocraftX.Common;

using GamecraftModdingAPI.Players;
using GamecraftModdingAPI.Blocks;

namespace GamecraftModdingAPI
{
    /// <summary>
    /// An in-game player character. Any Leo you see is a player.
    /// </summary>
    public class Player
    {
        // static functionality
		private static PlayerEngine playerEngine = new PlayerEngine();

        /// <summary>
		/// Checks if the specified player exists.
        /// </summary>
		/// <returns>Whether the player exists.</returns>
        /// <param name="player">Player type.</param>
		public static bool Exists(PlayerType player)
        {
            switch (player)
            {
                case PlayerType.Remote:
                    return playerEngine.GetRemotePlayer() != uint.MaxValue;
                case PlayerType.Local:
                    return playerEngine.GetLocalPlayer() != uint.MaxValue;
            }
            return false;
        }

        /// <summary>
        /// Checks if the specified player exists.
        /// </summary>
        /// <returns>Whether the player exists.</returns>
		/// <param name="player">The player's unique identifier.</param>
        public static bool Exists(uint player)
        {
            return playerEngine.ExistsById(player);
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="T:GamecraftModdingAPI.Player"/> class.
        /// </summary>
        /// <param name="id">The player's unique identifier.</param>
        public Player(uint id)
        {
            this.Id = id;
            if (!Exists(id))
            {
                throw new PlayerNotFoundException($"No player with id {id} exists");
            }
            this.Type = playerEngine.GetLocalPlayer() == id ? PlayerType.Local : PlayerType.Remote;
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="T:GamecraftModdingAPI.Player"/> class.
        /// </summary>
        /// <param name="player">The player type. Chooses the first available player matching the criteria.</param>
        public Player(PlayerType player)
        {
            uint localId = playerEngine.GetLocalPlayer();
            switch (player)
            {
                case PlayerType.Local:
                    this.Id = playerEngine.GetLocalPlayer();
                    break;
                case PlayerType.Remote:
                    this.Id = playerEngine.GetRemotePlayer();
                    break;
            }
            if (this.Id == uint.MaxValue)
            {
                throw new PlayerNotFoundException($"No player of {player} type exists");
            }
            this.Type = player;
        }

        // object fields & properties

        /// <summary>
        /// The player's type. 
		/// The player type is always relative to the current client, not the game host.
        /// </summary>
        /// <value>The enumerated player type.</value>
		public PlayerType Type { get; }

        /// <summary>
        /// The player's unique identifier.
        /// </summary>
        /// <value>The identifier.</value>
		public uint Id { get; private set; }

        /// <summary>
        /// The player's current position.
        /// </summary>
        /// <value>The position.</value>
		public float3 Position
		{
			get
			{
				return playerEngine.GetLocation(Id);
			}

			set
			{
				playerEngine.SetLocation(Id, value, false);
			}
		}

        /// <summary>
        /// The player's current rotation.
        /// </summary>
        /// <value>The rotation.</value>
		public quaternion Rotation
		{
			get
			{
				return playerEngine.GetRotation(Id);
			}

			set
			{
				playerEngine.SetRotation(Id, value);
			}
		}

        /// <summary>
        /// The player's current velocity.
        /// </summary>
        /// <value>The velocity.</value>
		public float3 Velocity
		{
			get
			{
				return playerEngine.GetLinearVelocity(Id);
			}

            set
			{
				playerEngine.SetLinearVelocity(Id, value);
			}
		}

        /// <summary>
        /// The player's current angular velocity.
        /// </summary>
        /// <value>The angular velocity.</value>
		public float3 AngularVelocity
        {
            get
            {
                return playerEngine.GetAngularVelocity(Id);
            }

            set
            {
                playerEngine.SetAngularVelocity(Id, value);
            }
        }

        /// <summary>
        /// The player's mass.
        /// </summary>
        /// <value>The mass.</value>
        public float Mass
		{
			get
			{
				return 1f / playerEngine.GetMass(Id).InverseMass;
			}

			// FIXME: Setting mass doesn't do anything
			/*set
			{
				playerEngine.SetInverseMass(Id, 1f / value);
			}*/
		}

		private float _ping = -1f;

        /// <summary>
        /// The player's latest network ping time.
        /// </summary>
        /// <value>The ping (s).</value>
        public float Ping
		{
			get
			{
				float? temp = playerEngine.GetLastPingTime(Id, Type);
				if (temp.HasValue)
				{
					_ping = temp.Value;
				}
				return _ping;
			}
		}

        /// <summary>
        /// The player's initial health when entering Simulation (aka Time Running) mode.
        /// </summary>
        /// <value>The initial health.</value>
        public float InitialHealth
		{
			get => playerEngine.GetInitialHealth(Id);

			set
			{
				playerEngine.SetInitialHealth(Id, value);
			}
		}

        /// <summary>
        /// The player's current health in Simulation (aka Time Running) mode.
        /// </summary>
        /// <value>The current health.</value>
		public float CurrentHealth
        {
            get => playerEngine.GetCurrentHealth(Id);

            set
            {
				playerEngine.DamagePlayer(Id, CurrentHealth - value);
            }
        }

        /// <summary>
        /// Whether this <see cref="T:GamecraftModdingAPI.Player"/> is damageable.
        /// </summary>
        /// <value><c>true</c> if damageable; otherwise, <c>false</c>.</value>
        public bool Damageable
		{
			get => playerEngine.GetDamageable(Id);

			set
			{
				playerEngine.SetDamageable(Id, value);
			}
		}

        /// <summary>
        /// The player's lives when initially entering Simulation (aka Time Running) mode.
        /// </summary>
        /// <value>The initial lives.</value>
        public uint InitialLives
		{
			get => playerEngine.GetInitialLives(Id);

			set => playerEngine.SetInitialLives(Id, value);
		}

        /// <summary>
        /// The player's current lives in Simulation (aka Time Running) mode.
        /// </summary>
        /// <value>The current lives.</value>
		public uint CurrentLives
        {
            get => playerEngine.GetCurrentLives(Id);

            set => playerEngine.SetCurrentLives(Id, value);
        }

        /// <summary>
        /// Whether the Game Over screen is displayed for the player.
        /// </summary>
        /// <value><c>true</c> if game over; otherwise, <c>false</c>.</value>
        public bool GameOver
		{
			get => playerEngine.GetGameOverScreen(Id);
		}

        /// <summary>
        /// Whether the player is dead.
		/// If <c>true</c>, hopefully it was quick.
        /// </summary>
        /// <value><c>true</c> if dead; otherwise, <c>false</c>.</value>
        public bool Dead
		{
			get => playerEngine.IsDead(Id);
		}

        /// <summary>
        /// The player's selected block ID in their hand.
        /// </summary>
        /// <value>The selected block.</value>
		public BlockIDs SelectedBlock
		{
			get
			{
				return (BlockIDs)playerEngine.GetSelectedBlock(Id);
			}
		}

        /// <summary>
        /// The player's selected block color in their hand.
        /// </summary>
        /// <value>The selected block's color.</value>
		public BlockColors SelectedColor
        {
            get
            {
				return (BlockColors)playerEngine.GetSelectedColor(Id);
            }
        }

		/// <summary>
        /// The player's selected block colour in their hand.
        /// </summary>
        /// <value>The selected block's colour.</value>
		public BlockColors SelectedColour
        {
            get
            {
                return (BlockColors)playerEngine.GetSelectedColor(Id);
            }
        }

        // object methods

        /// <summary>
        /// Teleport the player to the specified coordinates.
        /// </summary>
        /// <param name="x">The x coordinate.</param>
        /// <param name="y">The y coordinate.</param>
        /// <param name="z">The z coordinate.</param>
        /// <param name="relative">If set to <c>true</c> teleport relative to the player's current position.</param>
        /// <param name="exitSeat">If set to <c>true</c> exit any seat the player is in.</param>
        public void Teleport(float x, float y, float z, bool relative = true, bool exitSeat = true)
		{
			float3 location = new float3(x, y, z);
			if (relative)
			{
				location += playerEngine.GetLocation(Id);
			}
			playerEngine.SetLocation(Id, location, exitSeat: exitSeat);
		}
        
        /// <summary>
        /// Returns the block the player is currently looking at.
        /// </summary>
        /// <param name="maxDistance">The maximum distance from the player (default is the player's building reach)</param>
        /// <returns>The block or null if not found</returns>
        public Block GetBlockLookedAt(float maxDistance = -1f)
        {
	        var egid = playerEngine.GetThingLookedAt(Id, maxDistance);
	        return egid.HasValue && egid.Value.groupID == CommonExclusiveGroups.OWNED_BLOCKS_GROUP
		        ? new Block(egid.Value)
		        : null;
        }
        
        /// <summary>
        /// Returns the rigid body the player is currently looking at during simulation.
        /// </summary>
        /// <param name="maxDistance">The maximum distance from the player (default is the player's building reach)</param>
        /// <returns>The block or null if not found</returns>
        public SimBody GetSimBodyLookedAt(float maxDistance = -1f)
        {
	        var egid = playerEngine.GetThingLookedAt(Id, maxDistance);
	        return egid.HasValue && egid.Value.groupID == CommonExclusiveGroups.SIMULATION_BODIES_GROUP
		        ? new SimBody(egid.Value)
		        : null;
        }

        // internal methods

        public static void Init()
		{
			Utility.GameEngineManager.AddGameEngine(playerEngine);
		}
    }
}