using System;

using Framework.Services;

namespace Framework.Actors.Platformer {

  /// <summary>How the character moves from the squatting stance</summary>
  public enum SquatMovementMode {

    /// <summary>The character is not allowed to moved around while squatting</summary>
    Prohibit,

    /// <summary>Movement while squatting results in slow sneaking walk</summary>
    /// <remarks>
    ///   Many first and third person games allow characters to move silently,
    ///   lowering their stance for careful foot placement.
    /// </remarks>
    Sneak,

    /// <summary>Movement while squatting results in going onto hands and feet</summary>
    /// <remarks>
    ///   The character will movement on hands and feet, allowing him/her to clear
    ///   long obstacles such as tunnels.
    /// </remarks>
    Crawl
    
  }

  /// <summary>How the character deals with ledges</summary>
  public enum LedgeHangMode {

    /// <summary>The character is not allowed to hang onto the respective ledge</summary>
    Prohibit,

    /// <summary>The character can hang from the respective ledge but not climb it</summary>
    /// <remarks>>
    ///   This is typically used for poles, bars and other ledges that provide no
    ///   support for the character's feet.   
    /// </remarks>
    HangOnly,

    /// <summary>The character can hang and climb onto the respective ledge</summary>
    /// <remarks>
    ///   This is typically used for walls where the character can hang onto the top
    ///   of the wall and pull him/herself up.
    /// </remarks> 
    HangAndClimb
    
  }
  
  /// <summary>Abilities a playable character possesses</summary>
  public class Abilities : ScriptComponent {

    /// <summary>Number of jumps the character can do (reset upon ground contact)</summary>
    /// <remarks>
    ///   <para>
    ///     Setting this number to zero prevents the character from jumping at all,
    ///     a value of 1 would allow normal jumping off the ground at 2 would allow
    ///     for one "air-jump" where the character gets an upwards impulse in mid-air.
    ///   </para>
    ///   <para>
    ///     Running off a platform also counts as one jump, so with this value set to 2,
    ///     after falling off a platform, the character can only jump off in mid-air once. 
    ///   </para>
    /// </remarks>
    public int JumpCount = 1;

    /// <summary>How high the character can jump with a normal jump</summary>
    /// <remarks>
    ///   Player-controlled characters can control their jump high by how long the jump
    ///   key is held. This is the maximum height the character will achieve when
    ///   the jump key is not released until the apex of the jump or later.
    /// </remarks>
    public float JumpHeight = 2.0f;
    
#if false
    /// <summary>How high the character can jump with a super jump</summary>
    /// <remarks>
    ///   A super jump is done from when squatting and allows the character to jump
    ///   extra high, but without much horizontal momentum (and leaving the character
    ///   vulnerable while stopping and preparing the jump). 
    /// </remarks>
    public float SuperJumpHeight = 3.0f;
#endif

    /// <summary>How much the character can be controlled during a jump or fall</summary>
    /// <remarks>
    ///   A factor of 1.0 means that the player can control the character's horizontal
    ///   movement in the air just as good as on the ground, a factor of 0.0 would prevent
    ///   the player from altering the character's trajectory at all after jumping off.
    /// </remarks>
    public float AirControlFactor = 1.0f;

    /// <summary>How fast the character moves horizontally when sneaking</summary>
    public float SneakingSpeed = 5.0f;
    
    /// <summary>How fast the character moves horizontally when walking</summary>
    public float WalkingSpeed = 10.0f;

    /// <summary>How fast the character moves horizontally when running</summary>
    public float RunningSpeed = 15.0f;
                                           
    /// <summary>How fast the character moves horizontally when dashing</summary>
    public float DashingSpeed = 25.0f;

    /// <summary>How quickly the character accelerates</summary>
    /// <remarks>
    ///   This goes for all movement speeds, so if the user holds the sprint key,
    ///   the character will accelerate quicker, still reaching the full speed
    ///   within this time.
    /// </remarks>
    public float SecondsToFullSpeed = 0.25f;

    /// <summary>How long the jump button needs to be held for maximum jump height</summary>
    /// <remarks>
    ///   <para>
    ///     If this is set to 0, the actor will always jump to the maximum height
    ///     without allowing the player to make smaller jumps. Other values indicate
    ///     the time for which the player has to hold the jump key to achieve maximum
    ///     height, allowing for smaller jumps by pressing the jump key for a shorter
    ///     duration
    ///   </para>
    ///   <para>
    ///     This works by 'boosting' the jump during the initial stage (applying
    ///     the required upwards force over a small time frame) rather than
    ///     applying the full force as a single impulse. Having extremely long boost
    ///     durations will not work because  
    ///   </para>
    /// </remarks>
    public float JumpBoostDuration = 0.25f;
  
    /// <summary>Speed at which the character can slide across the floor</summary>
    /// <remarks>
    ///   <para>
    ///     This is an action-movie styled slide where the character throws him/herself
    ///     onto the ground from a run and slides a short distance across the ground,
    ///     possibly clearing an obstacle or evading a bullet.
    ///   </para>
    ///   <para>
    ///     Setting the required speed to infinity effectively disables floor sliding.
    ///   </para> 
    /// </remarks>
    public float SpeedForFloorSlide = float.PositiveInfinity;

    /// <summary>Whether the character can move extra fast</summary>
    /// <remarks>>
    ///   This is a simple sprint function that makes the character move faster when
    ///   the player holds the 'sprint' button.
    /// </remarks>
    public bool CanSprint = false;

    /// <summary>Whether the character is able to burst into a high speed slide</summary>
    /// <remarks>
    ///   Dashing is a popular ability made famous by the Megaman games. The character
    ///   will assume a horizontal pose and receive a boost in speed for a short moment,
    ///   allowing him/her to slide under obstacles or cross a gap at high speed. 
    /// </remarks>
    public bool CanDash = false;

    /// <summary>How far the actor will dash when the dash key is pressed</summary>
    public float DashDistance = 2.0f;

    /// <summary>Whether the character can dash in mid-jump</summary>
    public bool CanAirDash = false;
   
    /// <summary>Whether the player can jump off walls</summary>
    public bool CanWallJump = false;

    // Decide this via a predicate function? Some walls work, some don't.
    //public Predicate<WallContactInfo> IsJumpableWall;
    
    // Decide this via a predicate function? Some walls work, some don't.
    //public Predicate<WallContactInfo> IsHangableWall;
    
    /// <summary>Whether the character can slide down on a wall</summary>
    /// <remarks>
    ///   If this is set with <see cref="WallHanging" /> prohibited, pressing into a wall will
    ///   always have the character slide down said wall. With <see cref="WallHanging" />
    ///   enabled, pressing into the wall will fix the character and sliding will only occur if  
    ///   the 'down' key is pressed at the same time.   
    /// </remarks>
    public bool CanWallSlide = false;

    // Decide this via a predicate function? Some walls work, some don't.
    //public Predicate<WallContactInfo> IsSlideableWall;

    /// <summary>Whether the character is able to hang onto a wall</summary>
    /// <remarks>>
    ///   How the character handles walls where he/she is able to grab the top of
    ///   the wall with his/her hands. See the documentation of the
    ///   <see cref="LedgeHangMode" /> enumeration for an exaplanation of the options.
    /// </remarks>
    public LedgeHangMode WallHanging = LedgeHangMode.Prohibit;

    /// <summary>Whether the character is able to hang onto a floating obstacle</summary>
    /// <remarks>>
    ///   How the character handles floating obstacles he/she is able to grab
    ///   the top of but has no foot support. Things like poles and floating platforms.
    ///   See the documentation of the <see cref="LedgeHangMode" /> enumeration for
    ///   an exaplanation of the options.
    /// </remarks>
    public LedgeHangMode PoleHanging = LedgeHangMode.Prohibit;

    /// <summary>Whether the character can squat, lowering his/her height</summary>
    /// <remarks>
    ///   This is an ability normally used for bullet avoidal. The character will
    ///   assume a squatting stance (knees bent, upper body upright). Together with
    ///   <see cref="CanSneak" /> it could also be used for silent movement.
    /// </remarks>
    public bool CanSquat = false;

    /// <summary>How movement is handled while the character is squatting</summary>
    /// <remarks>
    ///   See the documentation of the <see cref="SquatMovementMode" /> enumeration
    ///   for an explanation of the various modes.
    /// </remarks>
    public SquatMovementMode SquatMovement = SquatMovementMode.Prohibit;

#if false // Disabled by setting 'SpeedForFloorSlide' to infinity
    /// <summary>Whether the character can slide across the floor</summary>
    /// <remarks>
    ///   This is a move that can only be executed while running. The actor will
    ///   slide across the floor, rapidly losing momentum but possibly clearing
    ///   an obstacle or evading a projectile.
    /// </remarks>
    public bool CanSlide = false;
#endif
    
  }

} // namespace Framework.Actors.Platformer