139 lines
3.6 KiB
C#
139 lines
3.6 KiB
C#
using PkmnLib.Static.Moves;
|
|
|
|
namespace PkmnLib.Dynamic.Models;
|
|
|
|
/// <summary>
|
|
/// The different ways a move can be learned.
|
|
/// </summary>
|
|
public enum MoveLearnMethod
|
|
{
|
|
/// <summary>
|
|
/// We do not know the learn method.
|
|
/// </summary>
|
|
Unknown,
|
|
|
|
/// <summary>
|
|
/// The move is learned by leveling up.
|
|
/// </summary>
|
|
LevelUp,
|
|
|
|
/// <summary>
|
|
/// The move is learned when the Pokémon is hatched from an egg.
|
|
/// </summary>
|
|
Egg,
|
|
|
|
/// <summary>
|
|
/// The move is learned by using a tutor in the game.
|
|
/// </summary>
|
|
Tutor,
|
|
|
|
/// <summary>
|
|
/// The move is learned by using a TM or HM.
|
|
/// </summary>
|
|
Machine,
|
|
|
|
/// <summary>
|
|
/// The move is learned when the Pokémon changes form.
|
|
/// </summary>
|
|
FormChange,
|
|
}
|
|
|
|
/// <summary>
|
|
/// A learned move is the data attached to a Pokemon for a move it has learned. It has information
|
|
/// such as the remaining amount of users, how it has been learned, etc.
|
|
/// </summary>
|
|
public interface ILearnedMove
|
|
{
|
|
/// <summary>
|
|
/// The immutable move information of the move.
|
|
/// </summary>
|
|
IMoveData MoveData { get; }
|
|
|
|
/// <summary>
|
|
/// The maximal power points for this move.
|
|
/// </summary>
|
|
byte MaxPp { get; }
|
|
|
|
/// <summary>
|
|
/// The current power points for this move.
|
|
/// </summary>
|
|
byte CurrentPp { get; }
|
|
|
|
/// <summary>
|
|
/// The way the move has been learned.
|
|
/// </summary>
|
|
MoveLearnMethod LearnMethod { get; }
|
|
|
|
/// <summary>
|
|
/// Try and reduce the PP by a certain amount. If the amount is higher than the current uses,
|
|
/// return false. Otherwise, reduce the PP, and return true.
|
|
/// </summary>
|
|
bool TryUse(byte amount = 1);
|
|
|
|
/// <summary>
|
|
/// Set the remaining PP to the max amount of PP.
|
|
/// </summary>
|
|
void RestoreAllUses();
|
|
|
|
/// <summary>
|
|
/// Restore the remaining PP by a certain amount. Will prevent it from going above max PP.
|
|
/// </summary>
|
|
void RestoreUses(byte amount);
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public class LearnedMoveImpl : ILearnedMove
|
|
{
|
|
private byte _maxPpModification = 0;
|
|
|
|
/// <inheritdoc cref="LearnedMoveImpl" />
|
|
public LearnedMoveImpl(IMoveData moveData, MoveLearnMethod learnMethod)
|
|
{
|
|
MoveData = moveData;
|
|
LearnMethod = learnMethod;
|
|
CurrentPp = MaxPp;
|
|
}
|
|
|
|
public LearnedMoveImpl(IMoveData moveData, MoveLearnMethod learnMethod, byte pp)
|
|
: this(moveData, learnMethod)
|
|
{
|
|
CurrentPp = pp;
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public IMoveData MoveData { get; }
|
|
|
|
/// <inheritdoc />
|
|
public byte MaxPp => (byte)(MoveData.BaseUsages + _maxPpModification);
|
|
|
|
/// <inheritdoc />
|
|
public MoveLearnMethod LearnMethod { get; }
|
|
|
|
/// <summary>
|
|
/// The available power points for this move.
|
|
/// </summary>
|
|
public byte CurrentPp { get; private set; }
|
|
|
|
/// <summary>
|
|
/// Try to use the move. This subtracts the amount of PP from the current PP. If the amount requested is
|
|
/// higher than the current PP, this will return false, and the PP will not be reduced.
|
|
/// </summary>
|
|
public bool TryUse(byte amount = 1)
|
|
{
|
|
if (CurrentPp < amount)
|
|
return false;
|
|
|
|
CurrentPp -= amount;
|
|
return true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Restore the PP to the maximum amount of PP.
|
|
/// </summary>
|
|
public void RestoreAllUses() => CurrentPp = MaxPp;
|
|
|
|
/// <summary>
|
|
/// Restore the PP by a certain amount. This will prevent the PP from going above the maximum PP.
|
|
/// </summary>
|
|
public void RestoreUses(byte amount) => CurrentPp = (byte)Math.Min(CurrentPp + amount, MaxPp);
|
|
} |