/// <summary>
/// Creates a new <see cref="PercentageOfLastReceivedMoveDamageCalculator"/> instance.
/// </summary>
/// <param name="percentage">The percentage of damage to deal.</param>
/// <param name="actionHistory">The action history.</param>
public PercentageOfLastReceivedMoveDamageCalculator(
int percentage,
IActionHistory actionHistory)
{
_percentage = percentage;
_actionHistory = actionHistory;
}
/// <summary>
/// Sets the built damage action to target the user of the move
/// containing the action that last affected the user.
/// </summary>
/// <param name="builder">The damage action builder.</param>
/// <param name="actionHistory">The action history.</param>
public static DamageActionBuilder Retaliates(
this DamageActionBuilder builder,
IActionHistory actionHistory)
{
return(builder.WithActionTargetCalculator(new RetaliationActionTargetCalculator(actionHistory))
.WithTag(DamageTags.Retaliation));
}
/// <summary>
/// Sets the built damage action to use percentage-of-last-received-move damage.
/// </summary>
/// <param name="builder">The damage action builder.</param>
/// <param name="percentage">The percentage of damage to deal.</param>
/// <param name="actionHistory">The action history.</param>
public static DamageActionBuilder PercentageOfLastReceivedMoveDamage(
this DamageActionBuilder builder,
int percentage,
IActionHistory actionHistory)
{
return(builder.WithDamageCalculator(new PercentageOfLastReceivedMoveDamageCalculator(percentage, actionHistory)));
}
/// <summary>
/// Sets the built damage action to use percentage-of-last-received-move damage.
/// </summary>
/// <param name="builder">The damage action builder.</param>
/// <param name="startingBasePower">The starting base power.</param>
/// <param name="linearFactor">The linear factor.</param>
/// <param name="random">The random number generator.</param>
/// <param name="actionHistory">The action history.</param>
public static DamageActionBuilder BasePowerIncreasesLinearlyWithUses(
this DamageActionBuilder builder,
int startingBasePower,
int linearFactor,
IRandom random,
IActionHistory actionHistory)
{
return(builder.WithDamageCalculator(new BasePowerIncreasesLinearlyWithUsesDamageCalculator(startingBasePower, linearFactor, random, actionHistory)));
}
public ActionManager(String[] labels, MyModuleParams setup)
{
this.m_setup = setup;
Actions = new List <MyMotivatedAction>();
for (int i = 0; i < labels.Length; i++)
{
Actions.Add(new MyMotivatedAction(labels[i], 0, setup));
}
this.AcitonHistory = new MyActionHistory(this, setup);
this.AcitonHistory.AddAllCurrentActions();
}
public ActionManager(int noPrimitiveActions, MyModuleParams setup)
{
this.m_setup = setup;
Actions = new List <MyMotivatedAction>();
for (int i = 0; i < noPrimitiveActions; i++)
{
Actions.Add(new MyMotivatedAction("" + i, 0, setup));
}
this.AcitonHistory = new MyActionHistory(this, setup);
this.AcitonHistory.AddAllCurrentActions();
}
/// <summary>
/// Creates a new <see cref="TurnBasedBattle"/> instance.
/// </summary>
/// <param name="moveProcessor">The move processor.</param>
/// <param name="actionHistory">The action history.</param>
/// <param name="gameOutput">The game output.</param>
/// <param name="characters">The characters in the battle.</param>
public TurnBasedBattle(
MoveProcessor moveProcessor,
IActionHistory actionHistory,
IGameOutput gameOutput,
IEnumerable <Character> characters)
{
_moveProcessor = moveProcessor;
_actionHistory = actionHistory;
_gameOutput = gameOutput;
_characters = characters;
}
/// <summary>
/// Creates a new <see cref="BasePowerIncreasesLinearlyWithUsesDamageCalculator"/> instance.
/// </summary>
/// <param name="startingBasePower">The starting amount of damage to deal.</param>
/// <param name="linearFactor">The linear factor.</param>
/// <param name="random">The random number generator.</param>
/// <param name="actionHistory">The action history.</param>
public BasePowerIncreasesLinearlyWithUsesDamageCalculator(
int startingBasePower,
int linearFactor,
IRandom random,
IActionHistory actionHistory)
{
_startingBasePower = startingBasePower;
_linearFactor = linearFactor;
_random = random ?? throw new ArgumentNullException(nameof(random));
_actionHistory = actionHistory ?? throw new ArgumentNullException(nameof(actionHistory));
}
static void Main(string[] args)
{
IActionHistory v3 = ActionHistory_V3.Instance;
v3.AddAction("hello 1");
v3.Save();
foreach (var item in v3.RetriveAllActions())
{
Console.WriteLine(item);
}
}
/// <summary>
/// Creates a new <see cref="DecreasesLinearlyWithUsesSuccessCalculator"/> instance.
/// </summary>
/// <param name="baseSuccessRate">The starting chance of success.</param>
/// <param name="linearFactor">The linear factor.</param>
/// <param name="minimumSuccessRate">The minimum success rate</param>
/// <param name="random">The random number generator.</param>
/// <param name="failureResult">The failure result.</param>
/// <param name="actionHistory">The action history.</param>
public DecreasesLinearlyWithUsesSuccessCalculator(
int baseSuccessRate,
int linearFactor,
int minimumSuccessRate,
Character user,
IRandom random,
MoveUseResult failureResult,
IActionHistory actionHistory)
{
_baseSuccessRate = baseSuccessRate;
_linearFactor = linearFactor;
_minimumSuccessRate = minimumSuccessRate;
_user = user;
_random = random ?? throw new ArgumentNullException(nameof(random));
_failureResult = failureResult;
_actionHistory = actionHistory ?? throw new ArgumentNullException(nameof(actionHistory));
}
/// <summary>
/// Sets the built move's success rate to decrease linearly each
/// time it is used.
/// </summary>
/// <param name="builder">The move builder.</param>
/// <param name="baseSuccess">The base success rate.</param>
/// <param name="linearFactor">The linear factor.</param>
/// <param name="minimumSuccessRate">The minimum success rate.</param>
/// <param name="random">The random number generator.</param>
/// <param name="failureResult">The result to return in the case of failure.</param>
/// <param name="actionHistory">The action history.</param>
public static MoveBuilder SuccessDecreasesLinearlyWithUses(
this MoveBuilder builder,
int baseSuccess,
int linearFactor,
int minimumSuccessRate,
Character user,
IRandom random,
MoveUseResult failureResult,
IActionHistory actionHistory)
{
return(builder.WithSuccessCalculatorFactory(
() => new DecreasesLinearlyWithUsesSuccessCalculator(
baseSuccess,
linearFactor,
minimumSuccessRate,
user,
random,
failureResult,
actionHistory
)
));
}
protected override int[] ChooseActions()
{
IActionHistory ah = m_rds.ActionManager.AcitonHistory;
Dictionary <int, float> importances = new Dictionary <int, float>();
int action;
float w;
for (int i = 0; i < m_learningParams.ActionLength; i++)
{
action = ah.GetActionExecutedBefore(i);
if (action != -1)
{
w = 1.0f - ((float)i / (float)m_learningParams.ActionLength);
if (importances.ContainsKey(action))
{
importances[action] += w;
}
else
{
importances.Add(action, w);
}
}
}
List <int> chosen = new List <int>();
foreach (var item in importances)
{
if (item.Value >= m_learningParams.ActionSubspacingThreshold)
{
chosen.Add(item.Key);
}
}
return(chosen.ToArray());
}
/// <summary>
/// Creates a new <see cref="RetaliationActionTargetCalculator"/> instance.
/// </summary>
/// <param name="actionHistory">The action history.</param>
public RetaliationActionTargetCalculator(IActionHistory actionHistory)
{
_actionHistory = actionHistory;
}
} // History
#endregion
#region Constructor
static ActionManager()
{
History = new SimpleHistory();
} // ActionManager