public static void StartUp(TestContext ctx)
{
Definer.Instance().Engine = Engine;
DamageTypeTemplate trueDamage = new DamageTypeTemplate(Engine, null, null, null, null);
trueDamage.Key = "T";
Engine.AddDamageType(trueDamage);
}
public void AddDamageType(DamageTypeTemplate damageType)
{
if (DamageTypes.ContainsKey(damageType.Key))
{
throw new MeException($"Attempted to add a damage type with key {damageType.Key} but it already exists");
}
DamageTypes.Add(damageType.Key, damageType);
}
public void LogDamage(Entity target, Entity source, DamageTypeTemplate typeTemplate, double amount, double resisted)
{
ResourceInstance hp = target.GetResource(Entity.HP_KEY);
string hpBar = Utils.Utility.getBar(hp.Value, hp.MaxAmount);
//string resist = Utils.Utility.DoubleEq(resisted,0.0)?"": $"({resisted} resisted)";
string msg = $"{target.Name} {hpBar} {(amount < 0 ? "" : "-")}{amount} {typeTemplate.Name} damage";
Log(msg);
}
public static void StartUp(TestContext context)
{
Engine.AddPlayer(MockPlayer);
Engine.AddEnemy(MockEnemy);
DamageTypeTemplate trueDamage = new DamageTypeTemplate(Engine, null, null, null, null);
trueDamage.Key = "T";
Engine.AddDamageType(trueDamage);
}
public DamageTypeTemplate FromJson(JObject json)
{
string mitigation = JsonUtils.GetValueOrDefault <string>(json, GcConstants.DamageType.MITIGATION, null);
string dodge = JsonUtils.GetValueOrDefault <string>(json, GcConstants.DamageType.DODGE, null);;
string crit = JsonUtils.GetValueOrDefault <string>(json, GcConstants.DamageType.CRIT, null);;
string critmod = JsonUtils.GetValueOrDefault <string>(json, GcConstants.DamageType.CRIT_MULT, null);;
DamageTypeTemplate template = new DamageTypeTemplate(_engine, mitigation, dodge, crit, critmod);
template.LoadBase(json);
return(template);
}
public static void StartUp(TestContext ctx)
{
Engine = new GameEngine(new DiscordLogHelper(new ConsoleLogger()));
Definer.Instance().Engine = Engine;
MockPlayer = new MockEntity(Engine)
{
Name = "MOCK_PLAYER", Key = "MOCK_KEY"
};
Engine.AddPlayer(MockPlayer);
DamageTypeTemplate trueDamage = new DamageTypeTemplate(Engine, null, null, null, null);
trueDamage.Key = "T";
Engine.AddDamageType(trueDamage);
}
public void LoadDamageTypesFromfile(string path)
{
DamageTypeReader reader = new DamageTypeReader(Engine);
JArray damageTypeJson = FileHandler.FromPath <JArray>(path);
foreach (JToken damageValue in damageTypeJson)
{
if (damageValue.Type != JTokenType.Object)
{
throw new MeException($"Expected a json object \"{path}\"at \"{damageValue}\".");
}
DamageTypeTemplate newSkill = reader.FromJson(damageValue.ToObject <JObject>());
AddDamageType(newSkill);
}
}
public static void StartUp(TestContext ctx)
{
Definer.Instance().Engine = Engine;
DamageTypeTemplate trueDamage = new DamageTypeTemplate(Engine, null, null, null, null);
trueDamage.Key = "T";
Engine.AddDamageType(trueDamage);
ResourceTemplate mana = new ResourceTemplate();
mana.Key = "MP";
ResourceTemplate hp = new ResourceTemplate();
hp.Key = Entity.HP_KEY;
Engine.GetPropertyManager().AddResource(hp);
Engine.GetPropertyManager().AddResource(mana);
Engine.GetCoreManager().DefaultSkillThreat = GcConstants.Core.DEFAULT_THREAT;
}
public static void StartUp(TestContext ctx)
{
CultureInfo ci = new CultureInfo("en-US");
Thread.CurrentThread.CurrentCulture = ci;
Console.WriteLine("START UP");
Engine = new GameEngine(new DiscordLogHelper(new ConsoleLogger()));
Definer.Instance().Engine = Engine;
BasePlayer = new MockEntity(Engine)
{
Name = "MOCK_PLAYER", Key = "MOCK_KEY"
};
Engine.AddPlayer(BasePlayer);
DamageTypeTemplate trueDamage = new DamageTypeTemplate(Engine, null, null, null, null);
trueDamage.Key = "T";
Engine.AddDamageType(trueDamage);
}
public static void StartUp(TestContext ctx)
{
Definer.Instance().Engine = Engine;
DamageTypeTemplate trueDamage = new DamageTypeTemplate(Engine, null, null, null, null);
trueDamage.Name = "true";
trueDamage.Key = "T";
Engine.AddDamageType(trueDamage);
ResourceTemplate res = new ResourceTemplate()
{
Key = "MP"
};
SkillCost nullCost = new SkillCost(res, TreeConverter.Build("0", Engine));
_testSkill = new SkillTemplate();
_testSkill.Type = SkillType.Cast;
_testSkill.Key = "TEST_CAST";
SkillLevelTemplate testLevelTemplate = new SkillLevelTemplate();
testLevelTemplate.Cooldown = TreeConverter.Build("3", Engine);
testLevelTemplate.Duration = TreeConverter.Build($"{LConstants.SourceKeyword}{LConstants.PROP_OP}INT", Engine);
testLevelTemplate.Interruptible = TreeConverter.Build("true", Engine);
testLevelTemplate.Formulas.Add(TreeConverter.Build($"{LConstants.HARM_F}({LConstants.TargetKeyword},{LConstants.SourceKeyword},{trueDamage.Key},10)", Engine));
testLevelTemplate.PushBack = TreeConverter.Build("true", Engine);
testLevelTemplate.Cost = nullCost;
_testSkill.ByLevel.Add(testLevelTemplate);
Engine.GetSkillManager().AddSkill(_testSkill);
BaseObject bDmg = new BaseObject()
{
Description = "", Key = "BASE_DMG", Name = "Base damage"
};
Engine.GetPropertyManager().BaseValues.Add("BASE_DMG", bDmg);
BaseObject intellect = new BaseObject()
{
Description = "", Key = "INT", Name = "Intellect"
};
Engine.GetPropertyManager().Attributes.Add("INT", intellect);
}
public override double TakeDamage(double amount, DamageTypeTemplate typeTemplate, Entity source, bool periodic = false)
{
if (typeTemplate.GetDodge(source, this))
{
if (!periodic)
{
Engine.Log().LogDodge(this, source);
}
return(0);
}
double actualAmount = typeTemplate.GetMitigatedAmount(amount, source, this);
double resisted = amount - actualAmount;
TakeActualDamage(actualAmount);
if (!periodic)
{
Engine.Log().LogDamage(this, source, typeTemplate, actualAmount, resisted);
}
return(actualAmount);
}
public static void StartUp(TestContext context)
{
DamageTypeTemplate trueDamage = new DamageTypeTemplate(Engine, null, null, null, null);
trueDamage.Key = "T";
trueDamage.Name = "true";
DamageTypeTemplate alwaysCrit = new DamageTypeTemplate(Engine, null, null, "100", "2");
alwaysCrit.Key = "AC";
alwaysCrit.Name = "always_crit";
DamageTypeTemplate alwaysDodge = new DamageTypeTemplate(Engine, null, "100", null, null);
alwaysDodge.Key = "AD";
alwaysDodge.Name = "always_dodge";
DamageTypeTemplate physical = new DamageTypeTemplate(Engine, $"{LConstants.NON_NEG_F}({LConstants.ValueKeyword}-{LConstants.TargetKeyword}{LConstants.PROP_OP}DEF)", null, null, null);
physical.Key = "P";
physical.Name = "physical";
Engine.AddDamageType(trueDamage);
Engine.AddDamageType(alwaysCrit);
Engine.AddDamageType(alwaysDodge);
Engine.AddDamageType(physical);
Engine.AddPlayer(BaseEntity);
}
public static void StartUp(TestContext context)
{
DamageTypeTemplate trueDamage = new DamageTypeTemplate(Engine, null, null, null, null);
trueDamage.Key = "T";
trueDamage.Name = "true";
Engine.AddDamageType(trueDamage);
ResourceTemplate res = new ResourceTemplate()
{
Key = "MP"
};
SkillCost nullCost = new SkillCost(res, TreeConverter.Build("0", Engine));
SkillCost notFree = new SkillCost(res, TreeConverter.Build("50", Engine));
_testSkill = new SkillTemplate();
_testSkill.Type = SkillType.Cast;
_testSkill.Key = "TEST_CAST";
SkillLevelTemplate testLevelTemplate = new SkillLevelTemplate();
testLevelTemplate.Cooldown = TreeConverter.Build("3", Engine);
testLevelTemplate.Duration = TreeConverter.Build($"{LConstants.SourceKeyword}{LConstants.PROP_OP}INT", Engine);
testLevelTemplate.Interruptible = TreeConverter.Build("true", Engine);
testLevelTemplate.Formulas.Add(TreeConverter.Build($"{LConstants.HARM_F}({LConstants.TargetKeyword},{LConstants.SourceKeyword},{trueDamage.Key},10)", Engine));
testLevelTemplate.PushBack = TreeConverter.Build("true", Engine);
testLevelTemplate.Cost = nullCost;
_testSkill.ByLevel.Add(testLevelTemplate);
_testChannelSkill = new SkillTemplate();
_testChannelSkill.Type = SkillType.Channel;
_testChannelSkill.Key = "TEST_CHANNEL";
SkillLevelTemplate testLevelTemplate2 = new SkillLevelTemplate();
testLevelTemplate2.Cooldown = TreeConverter.Build("120", Engine);
testLevelTemplate2.Duration = TreeConverter.Build("60", Engine);
testLevelTemplate2.Interval = TreeConverter.Build("10", Engine);
testLevelTemplate2.PushBack = TreeConverter.Build("true", Engine);
testLevelTemplate2.Interruptible = TreeConverter.Build("true", Engine);
testLevelTemplate2.Cost = nullCost;
MeNode channelFormula = TreeConverter.Build(
$"{LConstants.HARM_F}({LConstants.TargetKeyword},{LConstants.SourceKeyword},{trueDamage.Key},10)",
Engine);
Engine.GetSanitizer().SetHarmsToPeriodic(channelFormula);
testLevelTemplate2.Formulas.Add(channelFormula);
_testChannelSkill.ByLevel.Add(testLevelTemplate2);
_instantHarm = new SkillTemplate();
_instantHarm.Type = SkillType.Cast;
_instantHarm.Key = "HURT";
SkillLevelTemplate hurtLevelTemplate = new SkillLevelTemplate();
hurtLevelTemplate.Cooldown = TreeConverter.Build("0", Engine);
hurtLevelTemplate.Duration = TreeConverter.Build("0", Engine);
hurtLevelTemplate.PushBack = TreeConverter.Build("false", Engine);
hurtLevelTemplate.Interruptible = TreeConverter.Build("true", Engine);
hurtLevelTemplate.Formulas.Add(TreeConverter.Build($"{LConstants.HARM_F}({LConstants.TargetKeyword},{LConstants.SourceKeyword},{trueDamage.Key},10)", Engine));
hurtLevelTemplate.Cost = nullCost;
_instantHarm.ByLevel.Add(hurtLevelTemplate);
_unpushable = new SkillTemplate();
_unpushable.Type = SkillType.Cast;
_unpushable.Key = "NOPUSH";
SkillLevelTemplate unpushTemplate = new SkillLevelTemplate();
unpushTemplate.Cooldown = TreeConverter.Build("0", Engine);
unpushTemplate.Duration = TreeConverter.Build("5", Engine);
unpushTemplate.Interruptible = TreeConverter.Build("false", Engine);
unpushTemplate.PushBack = TreeConverter.Build("false", Engine);
unpushTemplate.Formulas.Add(TreeConverter.Build($"{LConstants.HARM_F}({LConstants.TargetKeyword},{LConstants.SourceKeyword},{trueDamage.Key},10)", Engine));
unpushTemplate.Cost = nullCost;
_unpushable.ByLevel.Add(unpushTemplate);
_costly = new SkillTemplate();
_costly.Type = SkillType.Cast;
_costly.Key = "COSTLY";
SkillLevelTemplate costlyTemplate = new SkillLevelTemplate();
costlyTemplate.Cooldown = TreeConverter.Build("0", Engine);
costlyTemplate.Duration = TreeConverter.Build("0", Engine);
costlyTemplate.Interruptible = TreeConverter.Build("true", Engine);
costlyTemplate.Formulas.Add(TreeConverter.Build($"{LConstants.HARM_F}({LConstants.TargetKeyword},{LConstants.SourceKeyword},{trueDamage.Key},10)", Engine));
costlyTemplate.PushBack = TreeConverter.Build("true", Engine);
costlyTemplate.Cost = notFree;
_costly.ByLevel.Add(costlyTemplate);
_skillUsingStat = new SkillTemplate();
_skillUsingStat.Type = SkillType.Cast;
_skillUsingStat.Key = "WITH_STAT";
SkillLevelTemplate withStaTemplate = new SkillLevelTemplate();
withStaTemplate.Cooldown = TreeConverter.Build("0", Engine);
withStaTemplate.Duration = TreeConverter.Build("0", Engine);
withStaTemplate.Interruptible = TreeConverter.Build("true", Engine);
withStaTemplate.Formulas.Add(TreeConverter.Build($"{LConstants.HARM_F}({LConstants.TargetKeyword},{LConstants.SourceKeyword},{trueDamage.Key},10*{LConstants.SourceKeyword}{LConstants.PROP_OP}STR+{LConstants.GET_PROP_F}({LConstants.SourceKeyword},{BASE_VALUE}))", Engine));
withStaTemplate.PushBack = TreeConverter.Build("true", Engine);
withStaTemplate.Cost = nullCost;
_skillUsingStat.ByLevel.Add(withStaTemplate);
}
public void AddDamageType(DamageTypeTemplate typeTemplate)
{
_damageTypeManager.AddDamageType(typeTemplate);
}
public static MeNode Build(MeNode parent, TokenNode node, IGameEngine engine)
{
MeNode newNode = null;
switch (node.Token.Type)
{
case TokenType.Function:
{
newNode = new MeNode(new MeVariable()
{
Value = Definer.Instance().Functions[node.Token.Value],
Type = VariableType.Function
});
break;
}
case TokenType.Operator:
{
newNode = new MeNode(new MeVariable()
{
Value = Definer.Instance().Operators[node.Token.Value],
Type = VariableType.Operator
});
break;
}
case TokenType.Variable:
{
//first, try a number
double result = 0;
bool success = double.TryParse(node.Token.Value, NumberStyles.Any, CultureInfo.InvariantCulture, out result);
if (success)
{
newNode = new MeNode(
new MeVariable()
{
Value = result, Type = VariableType.NumericValue
});
break;
}
//try a boolean
bool boolResult = false;
success = bool.TryParse(node.Token.Value, out boolResult);
if (success)
{
newNode = new MeNode(boolResult);
break;
}
//try a placeholder
if (node.Token.Value.StartsWith("$"))
{
newNode = new MeNode(
new MeVariable()
{
Value = node.Token.Value, Type = VariableType.PlaceHolder
});
break;
}
//try an entitiy
Entity tryEntity = engine.GetEntityByKey(node.Token.Value);
if (tryEntity != null)
{
newNode = new MeNode(
new MeVariable()
{
Value = tryEntity, Type = VariableType.Entity
});
break;
}
//try a damage typeTemplate
DamageTypeTemplate tryDamageTypeTemplate = engine.GeDamageType(node.Token.Value);
if (tryDamageTypeTemplate != null)
{
newNode = new MeNode(
new MeVariable()
{
Value = tryDamageTypeTemplate, Type = VariableType.DamageType
});
break;
}
/*
* MeVariable tryVariable = engine.GetVariable(node.Token.Final);
* if (tryVariable != null)
* {
* newNode = new MeNode(tryVariable);
* break;
* } */
//if nothing else is found, it must be a string
newNode = new MeNode(
new MeVariable()
{
Value = node.Token.Value, Type = VariableType.String
});
break;
}
}
foreach (TokenNode subNode in node.Parameters)
{
newNode.Leaves.Add(Build(newNode, subNode, engine));
}
newNode.Parent = parent;
return(newNode);
}
public void Init(IGameEngine engine)
{
if (_initialized)
{
return;
}
_initialized = true;
IOperatorDefiner[] opDefiners =
{
new PlusOperator(),
new MinusOperator(),
new PropertyOperator(),
new MultiplyOperator(),
new PowerOperator(),
new DivideOperator(),
new NotOperator(),
new GreaterOperator(),
new LesserOperator(),
new AssignOperator(),
new NumEqualsOperator()
};
foreach (IOperatorDefiner def in opDefiners)
{
AddOperator(def.DefineOperator());
}
Engine = engine;
AddFunction(LConstants.MAX_F,
(values, func) =>
{
func.CheckParamCount(values.Length);
double[] parameters = MeVariable.ToDoubleArray(values);
return(parameters.Max());
});
AddFunction(LConstants.FLOOR_F,
(values, func) =>
{
func.CheckParamCount(values.Length);
return(Math.Floor(values[0].ToDouble()));
}, 1);
AddFunction(LConstants.MIN_F,
(values, func) =>
{
func.CheckParamCount(values.Length);
double[] parameters = MeVariable.ToDoubleArray(values);
return(parameters.Min());
});
AddFunction(LConstants.ABS_F,
(values, func) =>
{
func.CheckParamCount(values.Length);
return(Math.Abs(values[0].ToDouble()));
}, 1);
AddFunction(LConstants.NON_NEG_F,
(values, func) =>
{
func.CheckParamCount(values.Length);
double value = values[0].ToDouble();
return(value > 0 ? value : 0);
}, 1);
AddFunction(LConstants.RANDOM_F,
(values, func) =>
{
func.CheckParamCount(values.Length);
return(new Random().Next((int)values[0].ToDouble(), (int)values[1].ToDouble()));
}, 2);
AddFunction(LConstants.HARM_F,
(values, func) =>
{
//func.CheckParamCount(values.Length);
MeVariable[] targets = values[0].ToArray();
Entity source = values[1].ToEntity();
DamageTypeTemplate damageTypeTemplate = values[2].ToDamageType();
double amount = values[3].ToDouble();
bool periodic = false;
if (values.Length > func.ParameterCount)
{
periodic = values[4].ToBoolean();
}
double totalAmt = 0;
foreach (MeVariable variable in targets)
{
totalAmt += variable.ToEntity().TakeDamage(amount, damageTypeTemplate, source, periodic);
}
return(totalAmt);
}, 4);
AddFunction(LConstants.HEAL_F,
(values, func) =>
{
func.CheckParamCount(values.Length);
MeVariable[] targets = values[0].ToArray();
Entity source = values[1].ToEntity();
double amount = values[2].ToDouble();
double totalAmt = 0;
foreach (MeVariable variable in targets)
{
totalAmt += variable.ToEntity().GetHealed(amount, source);
}
return(totalAmt);
}, 3);
AddFunction(LConstants.ARRAY_F,
(values, func) =>
{
func.CheckParamCount(values.Length);
return(new MeVariable()
{
Type = VariableType.Array, Value = values
});
});
AddFunction(LConstants.GET_PLAYERS_F,
(values, func) =>
{
func.CheckParamCount(values.Length);
Entity[] players = Definer.Instance().Engine.GetAllPlayers();
List <MeVariable> playerList = new List <MeVariable>();
foreach (Entity entity in players)
{
playerList.Add(entity);
}
return(new MeVariable()
{
Value = playerList.ToArray(), Type = VariableType.Array
});
}, 0);
AddFunction(LConstants.GET_ACTIVE_PLAYERS_F,
(values, func) =>
{
func.CheckParamCount(values.Length);
//TODO: Implement retrieving ONLY active players
Entity[] players = Definer.Instance().Engine.GetAllPlayers();
List <MeVariable> playerList = new List <MeVariable>();
foreach (Entity entity in players)
{
playerList.Add(entity);
}
return(new MeVariable()
{
Value = playerList.ToArray(), Type = VariableType.Array
});
}, 0);
AddFunction(LConstants.GET_PROP_F,
(values, func) =>
{
func.CheckParamCount(values.Length);
Entity entity = values[0].ToEntity();
string prop = values[1].ToMeString();
return(new MeVariable()
{
Value = new Property(entity, prop), Type = VariableType.Property
});
;
}, 2);
AddFunction(LConstants.IF_F,
(values, func) =>
{
//IF(CONDITION,THEN,ELSE)
func.CheckParamCount(values.Length);
bool condition = values[0].ToBoolean();
if (condition)
{
return(values[1].Execute());
}
else
{
return(values[2].Execute());
}
}, 3, new bool[] { true, false, false });
AddFunction(LConstants.ARR_RANDOM_F,
(values, func) =>
{
func.CheckParamCount(values.Length);
MeVariable[] input = values[0].ToArray();
int index = new Random().Next(0, input.Length);
return(input[index]);
}, 1);
AddFunction(LConstants.CHANCE_F,
(values, func) =>
{
func.CheckParamCount(values.Length);
double chance = values[0].ToDouble() * 10;
return(RPGEngine.Utils.Utility.Chance(chance));
}, 1);
AddFunction(LConstants.CAST_F,
(values, func) =>
{
//CAST(CASTER,TARGET,SKILL)
func.CheckParamCount(values.Length);
Entity caster = values[0].ToEntity();
Entity target = values[1].ToEntity();
string skillKey = values[2].ToMeString();
caster.Cast(target, skillKey);
return(null);
}, 3);
AddFunction(LConstants.ADD_MOD_F,
(values, func) =>
{
//MOD_VALUE(stat,Amount)
func.CheckParamCount(values.Length);
string stat = values[0].ToMeString();
double amount = values[1].ToDouble();
StatModifier mod = new StatModifier()
{
Amount = amount, StatKey = stat
};
return(new MeVariable {
Type = VariableType.StatModifier, Value = mod
});
}, 2);
AddFunction(LConstants.APPLY_F,
(values, func) =>
{
//APPLYSTATUS(target,Source,status_key,duration,amounts)
func.CheckParamCount(values.Length);
MeVariable[] targets = values[0].ToArray();
Entity source = values[1].ToEntity();
StatusTemplate effect = Definer.Instance().Engine.GetStatusByKey(values[2].ToMeString());
double duration = values[3].ToDouble();
double[] amounts = MeVariable.ToDoubleArray(values[4].ToArray());
func.CheckParamCount(values.Length);
foreach (MeVariable target in targets)
{
target.ToEntity().ApplyStatus(effect, source, duration, amounts);
}
return(null);
}, 5);
AddFunction(LConstants.GET_F,
(values, func) =>
{
func.CheckParamCount(values.Length);
string key = values[0].ToMeString();
return(Definer.Instance().Engine.GetVariable(key));;
}, 1);
AddFunction(LConstants.SAY_F,
(values, func) =>
{
func.CheckParamCount(values.Length);
Entity entity = values[0].ToEntity();
string msg = values[1].ToMeString();
Engine.Log().LogSay(entity, msg);
return(null);
}, 2);
AddFunction(LConstants.PUSH_BACK_F,
(values, func) =>
{
func.CheckParamCount(values.Length);
MeVariable[] entity = values[0].ToArray();
long amount = values[1].ToLong();
foreach (MeVariable var in entity)
{
var.ToEntity().AddPushback(amount);
}
return(null);
}, 2);
AddFunction(LConstants.REVIVE_F,
(values, func) =>
{
func.CheckParamCount(values.Length);
MeVariable[] entity = values[0].ToArray();
foreach (MeVariable var in entity)
{
var.ToEntity().Revive();
}
return(null);
}, 1);
AddFunction(LConstants.ADD_TO_RESOURCE_F,
(values, func) =>
{
func.CheckParamCount(values.Length);
MeVariable[] entity = values[0].ToArray();
string resourceKey = values[1].ToString();
double amount = values[2].ToDouble();
foreach (MeVariable var in entity)
{
var.ToEntity().AddToResource(resourceKey, amount);
}
return(null);
}, 3);
}
public abstract double TakeDamage(double amount, DamageTypeTemplate typeTemplate, Entity source, bool periodic = true);
