public static MeNode ReplacePropeties(MeNode tree, Entity origin)
{
List <MeNode> leaves = new List <MeNode>();
foreach (MeNode leaf in tree.Leaves)
{
leaves.Add(ReplacePropeties(leaf, origin));
}
MeNode node = null;
if (tree.Value.Type == VariableType.String && origin.HasProperty(tree.Value.ToMeString()))
{
MeNode[] nodeLeaves = new MeNode[2] {
new MeNode(origin), tree
};
Operator prop = Definer.Instance().Operators[LConstants.PROP_OP];
node = new MeNode(new MeVariable()
{
Type = VariableType.Operator, Value = prop
});
node.Leaves.AddRange(nodeLeaves);
}
else
{
node = new MeNode(tree.Value);
}
node.Leaves.AddRange(leaves);
return(node);
}
public void Initialize()
{
UIWindowCameraRoot = ComponentTool.FindChild("UI_Root", null);
if (null == UIWindowCameraRoot)
{
Debuger.LogError("can't load ui root ");
return;
}
m_UIRoot = UIWindowCameraRoot.GetComponent <UIRoot>();
m_UICamera = ComponentTool.FindChildComponent <Camera>("Camera", UIWindowCameraRoot);
m_UpdateStore = new List <Action>();
m_RemoveingUpdateList = new List <Action>();
m_bIsUpdateListBusy = false;
m_WindowStore = new Dictionary <int, WindowBase>();
m_WindowIndexStore = new Dictionary <int, WindowIndexStruct>();
m_LayerIndexStore = new Dictionary <WindowLayer, LayerInfo>();
m_ActivedWindowQueue = new Dictionary <WindowLayer, List <WindowBase> >();
m_LayerIndexStore.Add(WindowLayer.Window, new LayerInfo(0, 20, ComponentTool.FindChild("LayerWindow", UIWindowCameraRoot)));
m_LayerIndexStore.Add(WindowLayer.Tip, new LayerInfo(21, 40, ComponentTool.FindChild("LayerTip", UIWindowCameraRoot)));
//register window
Definer.RegisterWindow();
m_bIsOnUpdateStore = false;
}
public DefinitionsTests()
{
var simpleTypeChecker = new SimpleTypeHelper();
var complexTypeHelper = new ComplexTypeHelper();
_definer = new Definer(simpleTypeChecker, complexTypeHelper);
_defContextFormatter = new DefContextFormatter(simpleTypeChecker, Encoding.Unicode);
}
public void Initialize()
{
m_StageSceneStore = new Dictionary <GameStateType, string>();
m_StageHandlerStore = new Dictionary <GameStateType, StageBase>();
m_StageHandlerFactoryStore = new Dictionary <GameStateType, Type>();
Definer.RegisterStage();
}
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 SocketClosed()
{
Definer.DoCollection();
BasicCollection();
//change to login panel
StageManager.Instance.ChangeState(GameStateType.LoginState);
}
public static TokenNode MakeTree(Token[] postfix)
{
Stack <TokenNode> nodeStack = new Stack <TokenNode>();
foreach (Token tok in postfix)
{
switch (tok.Type)
{
case TokenType.LeftParen:
{
nodeStack.Push(new TokenNode(tok));
break;
}
case TokenType.Operator:
{
TokenNode node = new TokenNode(tok);
for (int i = 0; i < Definer.Instance().Operators[tok.Value].ParameterCount; ++i)
{
if (nodeStack.Count == 0 || nodeStack.Peek().Token.Type == TokenType.LeftParen)
{
throw new MeException("Parameter(s) missing for operator " + tok.Value + " .");
}
node.Parameters.Add(nodeStack.Pop());
}
nodeStack.Push(node);
node.Parameters.Reverse();
break;
}
case TokenType.Function:
{
TokenNode node = new TokenNode(tok);
while (nodeStack.Count != 0 && nodeStack.Peek().Token.Type != TokenType.LeftParen)
{
node.Parameters.Add(nodeStack.Pop());
}
if (nodeStack.Count == 0)
{
throw new MeException("No parenthesis found for function " + tok.Value + " .");
}
nodeStack.Pop();
node.Parameters.Reverse();
nodeStack.Push(node);
break;
}
case TokenType.Variable:
{
nodeStack.Push(new TokenNode(tok));
break;
}
}
}
return(nodeStack.Pop());
}
public void TimeOut()
{
Definer.DoCollection();
BasicCollection();
// try to reconnect
StageManager.Instance.ChangeState(GameStateType.ReConnectState);
AudioPlayer.Instance.Destructor();
}
public void OperatorTestCanExecute()
{
MeVariable[] vec = { 10, 11 };
MeVariable[] vec2 = { new MeVariable()
{
Value = "yass"
}, 20 };
Assert.IsTrue(Definer.Instance().Operators[LConstants.PLUS_OP].CanExecute(vec));
Assert.IsFalse(Definer.Instance().Operators[LConstants.PLUS_OP].CanExecute(vec2));
}
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);
}
private static void ShuntOperators(List <Token> postfix, Stack <Token> opStack, Operator op)
{
Token nextTok = opStack.Count == 0 ? null : opStack.Peek();
while (nextTok != null &&
nextTok.Type == TokenType.Operator &&
((op.LeftAsoc && op.Precedence <= Definer.Instance().Operators[nextTok.Value].Precedence) ||
(op.Precedence < Definer.Instance().Operators[nextTok.Value].Precedence))
)
{
postfix.Add(opStack.Pop());
nextTok = opStack.Count == 0 ? null : opStack.Peek();
}
}
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);
}
static void Main(string[] args)
{
//Translator t = new Translator();
//var response = t.GetTranslationAsync(new TranslateRequestModel { Dest = new System.Globalization.CultureInfo("en"), From = new System.Globalization.CultureInfo("en"), Phrase = "words" });
Definer d = new Definer();
var response = d.GetDefinitionAsync(new Model.DefinitionRequestModel {
Language = new System.Globalization.CultureInfo("en"), Phrase = "words"
});
foreach (var tuc in response.Result.Tuc)
{
System.Console.WriteLine("Phrase: " + tuc.Phrase.Text);
foreach (var meaning in tuc.Meanings)
{
System.Console.WriteLine("{0} {1}", meaning.Language, meaning.Text);
}
}
System.Console.ReadKey();
}
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 GameEngine(ILogHelper log)
{
Definer.Instance().Init(this);
_propertyManager = new PropertyManager();
_propertyManager.Engine = this;
_skillManager = new SkillManager();
_skillManager.Engine = this;
_coreManager = new CoreManager();
_coreManager.Engine = this;
_playerManager = new PlayerManager();
_damageTypeManager = new DamageTypeManager();
_damageTypeManager.Engine = this;
_statusManager = new StatusManager();
_statusManager.Engine = this;
_statManager = new StatManager(this);
_playerManager.Engine = this;
_classManager = new ClassManager();
_classManager.Engine = this;
_duelManager = new DuelManager();
_duelManager.Engine = this;
_log = log;
Players = new Dictionary <string, Entity>();
Enemies = new Dictionary <string, Entity>();
Timer = new MockTimer();
Sanit = new Sanitizer(this);
DeclaredVariables = new Dictionary <string, MeVariable>();
commandsQueue = new ConcurrentQueue <Command>();
_nextSave = Timer.GetFuture(GameConstants.SAVE_INTERVAL);
}
public Operator DefineOperator()
{
return(Utils.MakeOperator(LConstants.ASSIGN_OP, -1, true, (values, op) =>
{
op.CheckParamCount(values.Length);
string key = values[0].ToMeString();
MeVariable leftSide = Definer.Instance().Engine.GetVariable(key);
MeVariable rightSide = values[1];
if (rightSide.Type == VariableType.String)
{
rightSide = Definer.Instance().Engine.GetVariable(rightSide.Value.ToString());
}
if (leftSide == null)
{
Definer.Instance().Engine.AddVariable(key, rightSide);
}
else
{
Definer.Instance().Engine.SetVariable(key, rightSide);
}
return null;
}, new Validator(
(variables, operation) => true), 2));
}
public static TokenType GetType(string str)
{
if (Definer.Instance().IsFunction(str))
{
return(TokenType.Function);
}
if (Definer.Instance().IsOperator(str))
{
return(TokenType.Operator);
}
if (Definer.Instance().IsLeftParen(str))
{
return(TokenType.LeftParen);
}
if (Definer.Instance().IsRightParen(str))
{
return(TokenType.RightParen);
}
if (Definer.Instance().IsSeparator(str))
{
return(TokenType.Separator);
}
return(TokenType.Variable);
}
public static void StartUp(TestContext ctx)
{
Definer.Instance().Engine = Engine;
}
public BinaryFormatter(Encoding encoding)
{
var simpleTypeHelper = new SimpleTypeHelper();
_definer = new Definer(simpleTypeHelper, new ComplexTypeHelper());
_defContextFormatter = new DefContextFormatter(simpleTypeHelper, encoding);
}
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 static Token[] Tokenize(string expression)
{
List <Token> result = new List <Token>();
string sanitized = expression;
string current = "";
bool inString = false;
int i = 0;
while (i < sanitized.Length)
{
char c = sanitized[i];
if (c == '"')
{
if (inString)
{
Token stringToken = new Token(current);
result.Add(stringToken);
current = "";
}
inString = !inString;
}
else if (inString)
{
current += c;
}
else if (Definer.Instance().Ignore(c))
{
}
else if (!Definer.Instance().IsSpecialChar(c))
{
current += c;
}
else if (c == '-')
{
if (current.Length != 0)
{
Token testToken = new Token(current);
if (testToken.Type == TokenType.Variable)
{
result.Add(testToken);
current = "";
}
}
if (result.Count == 0)
{
current = "-";
}
else
{
Token prev = result.Last();
switch (prev.Type)
{
case TokenType.Function:
throw new Exception(
$"Found minus after function with no (, function:\"{prev.Value}\".");
case TokenType.Variable:
case TokenType.RightParen:
result.Add(new Token(char.ToString(c)));
break;
default:
current = "-";
break;
}
}
//eventually consider -=
}
else
{
if (current.Length != 0)
{
result.Add(new Token(current));
current = "";
}
if (i < sanitized.Length - 1 && Definer.Instance().IsOperatorChar(c) && Definer.Instance().IsOperatorChar(sanitized[i + 1]))
{
string possibleOp = char.ToString(c) + sanitized[i + 1];
if (Definer.Instance().IsOperator(possibleOp))
{
result.Add(new Token(possibleOp));
++i;
}
}
else
{
result.Add(new Token(char.ToString(c)));
}
}
++i;
}
if (current.Length != 0)
{
result.Add(new Token(current));
}
return(result.ToArray());
}
public static void StartUp(TestContext ctx)
{
Definer.Instance().Engine = Engine;
Engine.GetCoreManager().ExpFormula = TreeConverter.Build($"{LConstants.ExpPrevKeyword}*1.1+50*2^{LConstants.FLOOR_F}({LConstants.LevelKeyword}/5.0)", Engine);
Engine.SetStartExp(StartExp);
}
public static Token[] ToPostfix(Token[] infix)
{
List <Token> postFix = new List <Token>();
Stack <Token> opStack = new Stack <Token>();
Token lastFunction = null;
Token prevTok = null;
foreach (Token tok in infix)
{
switch (tok.Type)
{
case TokenType.Variable:
{
postFix.Add(tok);
break;
}
case TokenType.Function:
{
opStack.Push(tok);
lastFunction = tok;
break;
}
case TokenType.Separator:
{
if (prevTok != null && prevTok.Type == TokenType.Operator)
{
throw new MeException("Missing parameter(s) for operator " + prevTok.Value + " .");
}
while (opStack.Count != 0 && opStack.Peek().Type != TokenType.LeftParen)
{
postFix.Add(opStack.Pop());
}
if (opStack.Count == 0)
{
if (lastFunction == null)
{
throw new MeException("Unexpected separator Key.");
}
else
{
throw new MeException("Error while parsing function " + lastFunction.Value + " .");
}
}
break;
}
case TokenType.Operator:
{
if (prevTok != null && (prevTok.Type == TokenType.Separator || prevTok.Type == TokenType.LeftParen))
{
throw new MeException("Missing parameter(s) for operator " + tok.Value + " .");
}
Operator op = Definer.Instance().Operators[tok.Value];
ShuntOperators(postFix, opStack, op);
opStack.Push(tok);
break;
}
case TokenType.LeftParen:
{
if (prevTok != null)
{
if (prevTok.Type == TokenType.Function)
{
postFix.Add(tok);
}
}
opStack.Push(tok);
break;
}
case TokenType.RightParen:
{
if (prevTok != null && prevTok.Type == TokenType.Operator)
{
throw new MeException("Missing parameter(s) for operator " + prevTok.Value + " .");
}
while (opStack.Count != 0 && opStack.Peek().Type != TokenType.LeftParen)
{
postFix.Add(opStack.Pop());
}
if (opStack.Count == 0)
{
throw new MeException("Mismatched parenthesis after" + prevTok.Value + " .");
}
opStack.Pop();
if (opStack.Count != 0 && opStack.Peek().Type == TokenType.Function)
{
postFix.Add(opStack.Pop());
}
break;
}
}
prevTok = tok;
}
while (opStack.Count != 0)
{
Token tok = opStack.Pop();
if (tok.Type == TokenType.LeftParen || tok.Type == TokenType.RightParen)
{
throw new MeException("Mismatched parenthesis after" + prevTok.Value + " .");
}
postFix.Add(tok);
}
return(postFix.ToArray());
}
public static void StartUp(TestContext context)
{
Engine.AddPlayer(MockPlayer);
Definer.Instance().Engine = Engine;
}
