TechbloxModdingAPI/GamecraftModdingAPI/Player.cs

using System;

using Unity.Mathematics;

using GamecraftModdingAPI.Players;

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;
			}
		}

        // 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="playerId">The player's ID</param>
        /// <param name="entitiesDB">The entities DB</param>
        /// <param name="maxDistance">The maximum distance from the player (default is the player's building reach)</param>
        /// <returns>The block's EGID or null if not found</returns>
        public Block GetBlockLookedAt(float maxDistance = -1f)
        {
	        return playerEngine.GetBlockLookedAt(Id, maxDistance);
        }

        // internal methods

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