private IPrimitive CreateMarketOrder(MetaAction action, string side)
{
var code = new CodeBlock();
code.Add("local current_serial = source:serial(period);");
var executeCommandCode = new CodeBlock();
executeCommandCode.Add("last_serial = current_serial;");
var oppositeSide = side == "B" ? "S" : "B";
var closeTradesCode = new CodeBlock();
closeTradesCode
.Add($"local trades = trading:FindTrade():WhenSide(\"{oppositeSide}\"):WhenCustomID(custom_id):All();")
.Add("for _, trade in ipairs(trades) do")
.Add(" trading:Close(trade);")
.Add("end");
executeCommandCode.Add(PrimitiveBuilder
.If("instance.parameters.close_on_opposite")
.Then(closeTradesCode)
.Build(_variables));
executeCommandCode.Add($"local command = trading:MarketOrder(source:instrument()):SetSide(\"{side}\"):SetDefaultAmount():SetCustomID(custom_id);");
AddStop(action, executeCommandCode);
AddLimit(action, executeCommandCode);
executeCommandCode.Add("command:Execute();");
code.Add(new IfStatement(new NotEqualPrimitive("last_serial", "current_serial"),
executeCommandCode, _variables, ""));
return(code);
}
/*
* Retorna a lista de ações descritas na lista de nós XML.
*/
protected Dictionary <string, MetaAction> getActions(XmlNodeList nodes, MetaUnit unit)
{
if (nodes != null)
{
IEnumerator ienum = (IEnumerator)nodes.GetEnumerator();
Dictionary <string, MetaAction> actionList = new Dictionary <string, MetaAction>();
MetaAction action;
XmlNode actionNode;
while (ienum.MoveNext())
{
actionNode = (XmlNode)ienum.Current;
action = new MetaAction();
action.Id = generator.genId();
action.Father = unit;
action.Name = actionNode.SelectSingleNode("identifier").InnerText;
List <Transition> trans = getTransitions(actionNode.SelectSingleNode("protocol").FirstChild, unit, Configuration.INITIAL_STATE, Configuration.FINAL_STATE, 2, 0);
action.Protocol = new Configuration(numStates, trans, numTransations);
actionList.Add(action.Name, action);
}
if (actionList.Count > 0)
{
return(actionList);
}
}
return(null);
}
/// <summary>
///
/// </summary>
/// <param name="action"></param>
/// <exception cref="StrategyGeneratorException"></exception>
/// <returns></returns>
private IPrimitive FormatAction(MetaAction action)
{
switch (action.ActionType)
{
case MetaActionType.Buy:
return(CreateMarketOrder(action, "B"));
case MetaActionType.Sell:
return(CreateMarketOrder(action, "S"));
case MetaActionType.Customizable:
return($"DoAction(source:instrument(), instance.parameters.{action.ActionId});".MakePrimitive());
case MetaActionType.Exit:
return("trading:CloseAllForInstrument(source:instrument());".MakePrimitive());
case MetaActionType.ExitBuy:
return("trading:CloseSideForInstrument(source:instrument(), \"B\");".MakePrimitive());
case MetaActionType.ExitSell:
return("trading:CloseSideForInstrument(source:instrument(), \"S\");".MakePrimitive());
case MetaActionType.EntryBuy:
return(CreateEntryOrder(action, "B"));
case MetaActionType.EntrySell:
return(CreateEntryOrder(action, "S"));
}
throw new NotSupportedActionException(action.ActionType, "Lua");
}
public static Image CreateImage(MetaAction source)
{
var result = new Image {
Source = source.Icon.ToBitmapSource()
};
result.SetValue(RenderOptions.BitmapScalingModeProperty, BitmapScalingMode.HighQuality);
return(result);
}
/// <summary>
/// Helper method for generating a MetaObject which calls a specific method on Dynamic w/ the
/// meta object array as the params.
/// </summary>
private MetaObject CallMethodNAry(MetaAction action, MetaObject[] args, string methodName)
{
return(new MetaObject(
Expression.Call(
GetLimitedSelf(),
typeof(DynamicObject).GetMethod(methodName, BindingFlags.NonPublic | BindingFlags.Instance),
ReplaceSelfWithAction(action, args)
),
GetRestrictions()
));
}
/// <summary>
/// Helper method for generating a MetaObject which calls a specific method on Dynamic
/// w/o any additional parameters.
/// </summary>
private MetaObject CallMethodUnary(MetaAction action, string methodName)
{
return(new MetaObject(
Expression.Call(
GetLimitedSelf(),
typeof(DynamicObject).GetMethod(methodName, BindingFlags.NonPublic | BindingFlags.Instance),
Expression.Constant(action)
),
GetRestrictions()
));
}
public void EndTargetPhase(MetaAction metaAction, ActionInfo actionInfo)
{
foreach (ui_ability_script b in buttonManager)
{
b.TurnOffHighlight();
}
ActionDist actions = metaAction.Execute(actionInfo);
this.board.world.ExecuteActionDist(actions);
this.EndTurn();
}
static void Main(string[] args)
{
Action Execute = delegate { };
MetaAction meta = MetaAction.Create(h => Execute += h, h => Execute -= h);
var prog = new ProgramTest(meta);
var subscription = prog.AddMethod();
Execute();
subscription.Dispose();
}
/// <summary>
/// Helper which returns an Expression array corresponding to the arguments minus
/// the DynamicObject instance (arg0) plus the MetaAction constant.
/// </summary>
private static Expression[] ReplaceSelfWithAction(MetaAction action, MetaObject[] args)
{
Expression[] paramArgs = new Expression[args.Length - 1];
for (int i = 0; i < paramArgs.Length; i++)
{
paramArgs[i] = Expression.ConvertHelper(args[i + 1].Expression, typeof(object));
}
return(new Expression[] {
Expression.Constant(action),
Expression.NewArrayInit(typeof(object), paramArgs)
});
}
public void Run(MetaAction action)
{
if (action.Protocol.Monitors == null || action.Protocol.Monitors.Count == 0)
{
br.ufc.pargo.hpe.connector.monitoring.Monitor monitor = new br.ufc.pargo.hpe.connector.monitoring.Monitor();
monitor.Add(this);
action.Protocol.AddMonitor(monitor);
}
Interpreter interpreter = new Interpreter(action);
interpreters.Add(interpreter);
interpreter.Go();
}
/// <summary>
///
/// </summary>
/// <param name="action"></param>
/// <param name="side"></param>
/// <exception cref="StrategyGeneratorException">On missing rate for the entry</exception>
/// <returns></returns>
private IPrimitive CreateEntryOrder(MetaAction action, string side)
{
if (action.Entry == null)
{
throw new StrategyGeneratorException($"No entry rate for the {action.Name}");
}
(string value, bool isValueInPips) = FormatOrderValue(action.Entry);
string entry = $":SetRate({value})";
var code = new CodeBlock();
code.Add($"local command = trading:EntryOrder(source:instrument()):SetSide(\"{side}\"):SetDefaultAmount(){entry}:SetCustomID(custom_id);");
AddStop(action, code);
AddLimit(action, code);
code.Add("command:Execute();");
return(code);
}
private void AddLimit(MetaAction action, CodeBlock code)
{
(string limitValue, bool isLimitValueInPips) = FormatOrderValue(action.Limit);
if (limitValue != null)
{
if (isLimitValueInPips)
{
code.Add($"command = command:SetPipLimit({limitValue});");
}
else
{
code.Add($"command = command:SetLimit({limitValue});");
}
}
else
{
code.Add(new IfStatement("instance.parameters.set_limit".MakePrimitive(),
"command = command:SetPipLimit(nil, instance.parameters.limit);".MakePrimitive(),
_variables, ""));
}
}
private void AddStop(MetaAction action, CodeBlock code)
{
(string stopValue, bool isStopValueInPips) = FormatOrderValue(action.Stop);
if (stopValue != null)
{
if (isStopValueInPips)
{
code.Add($"command = command:SetPipStop({stopValue});");
}
else
{
code.Add($"command = command:SetStop({stopValue});");
}
}
else
{
code.Add(new IfStatement("instance.parameters.set_stop".MakePrimitive(),
"command = command:SetPipStop(nil, instance.parameters.stop, instance.parameters.trailing_stop and instance.parameters.trailing or nil);".MakePrimitive(),
_variables, ""));
}
}
private void TargetPhase(MetaAction metaAction, KeyCode keyPressed)
{
ActionInfo actionInfo = new ActionInfo();
if (metaAction is TargetedMetaAction)
{
TargetedMetaAction targetAction = metaAction as TargetedMetaAction;
GameObject cursor = Instantiate((GameObject)Resources.Load(Player.cursorPf));
actionInfo.originId = this.id;
actionInfo.originPos = this.position;
cursor.GetComponent <TargetCursor>().Setup(this, targetAction.PotentialTargets(board, actionInfo), targetAction, actionInfo, keyPressed);
selectActionPhase = false;
}
else
{
actionInfo.originId = this.id;
actionInfo.originPos = this.position;
actionInfo.targetId = World.InvalidId;
actionInfo.targetPos = Board.InvalidPos;
EndTargetPhase(metaAction, actionInfo);
}
}
public void Run(string actionName)
{
//System.Diagnostics.Console.WriteLine("[ConfigurationManager.Run] iniciando a ação " + actionName);
MetaAction action = null;
if (unit != null && unit.Entity != null)
{
action = unit.Actions [actionName];
if (action != null)
{
Run(action);
}
else
{
throw new Exception("Invalid action name.");
}
}
else
{
throw new Exception("Null entity.");
}
}
public override string ToString()
{
string cname = "";
string s = "";
s += "type: " + type;
s += " | initialState: " + initialState;
s += " | finalState: " + finalState;
s += " | isElse: " + isElse;
if (type == TransitionType.SIMPLE && getExecutionAction() != null && getExecutionAction().MetaAction != null)
{
MetaAction maction = getExecutionAction().MetaAction;
s += " | action: " + maction.Name;
if (maction.Name != null)
{
if (maction.Father.Father.GetType().Name.Equals("MetaInnerComponent"))
{
cname = ((MetaInnerComponent)maction.Father.Father).Identifier;
}
else
{
cname = maction.Father.Father.Name;
}
}
s += " | slice: " + cname + "." + maction.Father.Name;
s += "(" + maction.Father.GetType().Name + ")";
}
if (type == TransitionType.SIMPLE && getExecutionAction().Condition != null)
{
s += " | condition: " + getExecutionAction().Condition;
}
return(s);
}
/*
* geração das transitions baseado no protocolo da ação.
*/
public List <Transition> getTransitions(XmlNode node, MetaUnit unit, int initial, int final, int numStates, int numTransations)
{
List <Transition> transitions = new List <Transition> ();
Queue <Transition> treat = new Queue <Transition> ();
//Console.WriteLine("Initial {0} | Final {1} | numStates {2} | numTrans {3}", initial, final, numStates, numTransations);
treat.Enqueue(new Transition(initial, final, node, numTransations++));
Transition t;
XmlNode pivotNode, child, guardNode;
XmlNodeList children;
XmlAttribute attr;
Condition condition;
int initialState, finalState;
bool repeat;
initialState = finalState = 0;
while (treat.Count > 0)
{
t = treat.Dequeue();
pivotNode = (XmlNode)t.Action;
t.Action = null;
transitions.Add(t);
condition = null;
attr = (XmlAttribute)pivotNode.Attributes.GetNamedItem("id");
if (attr != null)
{
t.AddId(attr.Value);
}
repeat = false;
attr = (XmlAttribute)pivotNode.Attributes.GetNamedItem("repeat");
if (attr != null)
{
repeat = attr.Value.Equals("true");
}
guardNode = pivotNode.SelectSingleNode("guard");
condition = null;
//Console.WriteLine("[XmlLoaderUtil.getTransitions] Ação a avaliar... {0}", pivotNode.Name);
if (pivotNode.Name.Equals("seq") || pivotNode.Name.Equals("par"))
{
if (guardNode != null)
{
condition = getCondition(guardNode);
Transition tElse;
initialState = numStates++;
if (condition != null) //condition nao é else.
{
transitions.Add(new Transition(t.InitialState, initialState, new ExecutionAction(null, condition), Transition.INTERNAL_TRANSITION));
tElse = new Transition(t.InitialState, t.FinalState, Configuration.LAMBDA_TRANSITION, Transition.INTERNAL_TRANSITION);
}
else
{
tElse = new Transition(t.InitialState, initialState, Configuration.LAMBDA_TRANSITION, Transition.INTERNAL_TRANSITION);
}
tElse.IsElse = true;
transitions.Add(tElse);
}
else
{
initialState = t.InitialState;
}
}
switch (pivotNode.Name)
{
case "seq":
children = pivotNode.ChildNodes;
for (int r = 0; r < children.Count; r++)
{
child = children.Item(r);
if (child.Name.Equals("guard"))
{
continue;
}
if (r == (children.Count - 1))
{
if (repeat)
{
finalState = t.InitialState;
}
else
{
finalState = t.FinalState;
}
}
else
{
finalState = numStates++;
}
treat.Enqueue(new Transition(initialState, finalState, child.FirstChild, numTransations++));
initialState = finalState;
}
break;
case "par":
children = pivotNode.ChildNodes;
if (repeat)
{
finalState = numStates++;
transitions.Add(new Transition(finalState, t.InitialState, Configuration.LAMBDA_TRANSITION, Transition.INTERNAL_TRANSITION));
}
else
{
finalState = t.FinalState;
}
for (int r = 0; r < children.Count; r++)
{
child = children.Item(r);
if (child.Name.Equals("guard"))
{
continue;
}
treat.Enqueue(new Transition(initialState, finalState, child.FirstChild, numTransations++));
}
break;
case "perform":
bool isElse = false;
initialState = t.InitialState;
finalState = t.FinalState;
child = pivotNode;
if (guardNode != null)
{
condition = getCondition(guardNode);
if (condition == null)
{
isElse = true;
}
}
attr = (XmlAttribute)child.Attributes.GetNamedItem("slice_id");
//Console.WriteLine("[XmlLoaderUtil.getTransitions] Avaliando ação sobre a fatia {0}", attr.Value);
string sliceName = "";
if (attr != null)
{
sliceName = attr.Value;
}
string methodName = child.Attributes.GetNamedItem("action_id").Value;
//Console.WriteLine("[XmlLoaderUtil.getTransitions] Avaliando ação {0}", methodName);
MetaAction selectedAction = null;
if (sliceName.Equals(""))
{
//Console.WriteLine("[XmlLoaderUtil.getTransitions] unit {0} | action {1}", unit.Name, methodName);
unit.Actions.TryGetValue(methodName, out selectedAction);
//Console.WriteLine("[XmlLoaderUtil.getTransitions] Action {0} encontrada? {1}",methodName, selectedAction != null);
if (selectedAction == null)
{
selectedAction = new MetaAction();
selectedAction.Id = generator.genId();
selectedAction.Name = methodName;
selectedAction.Father = unit;
unit.AddAction(methodName, selectedAction);
}
}
else
{
MetaSlice slice = null;
//Console.WriteLine("[XmlLoaderUtil.getTransitions] slice {0}", sliceName);
unit.Slices.TryGetValue(sliceName, out slice);
if (slice == null && candidateSlices != null)
{
candidateSlices.TryGetValue(sliceName, out slice);
}
if (slice != null)
{
//Console.WriteLine("[XmlLoaderUtil.getTransitions] slice {0} encontrada", sliceName);
if (slice.Unit.Actions != null)
{
foreach (MetaAction mact in slice.Unit.Actions.Values)
{
if (mact.Name.Equals(methodName))
{
selectedAction = mact;
break;
}
}
}
if (selectedAction == null)
{
selectedAction = new MetaAction();
selectedAction.Id = generator.genId();
selectedAction.Name = methodName;
selectedAction.Father = slice.Unit;
slice.Unit.AddAction(methodName, selectedAction);
}
}
}
if (selectedAction != null)
{
Transition tst = new Transition(initialState, finalState, new ExecutionAction(selectedAction, condition), numTransations++);
tst.IsElse = isElse;
transitions.Add(tst);
}
else
{
throw new Exception("Fatia inexistente nesta unidade: " + sliceName);
}
break;
default:
throw new Exception("invalid action: " + pivotNode.Name);
}
}
this.numStates = numStates;
this.numTransations = numTransations;
return(transitions);
}
public ExecutionAction(MetaAction mAction, Condition cond)
{
this.metaAction = mAction;
this.Condition = cond;
}
public ReconfigurationRequest loadRequest(string xml, MetaHashComponent component)
{
ReconfigurationRequest request = null;
Console.WriteLine("[XmlLoader.loadRequest] Iniciando carga de script de reconfiguração... ");
if (true /*validator.IsValid (REQUEST_XSD, xml)*/)
{
clear();
generator.setInitialCode(component.LastIdCode);
request = new ReconfigurationRequest();
XmlDocument document = new XmlDocument();
XmlNode nodeRequest, data;
document.Load(xml);
nodeRequest = document.SelectSingleNode("reconfigurationRequest");
data = nodeRequest.SelectSingleNode("targetComponent");
request.TargetComponent = data.InnerText;
//Console.WriteLine("[XmlLoader.LoadRequest] Obtendo componente alvo {0}", request.TargetComponent);
List <MetaParameter> parameterList = uLoader.getParameters(nodeRequest.SelectNodes("parameter"));
if (parameterList != null)
{
Console.WriteLine("[XmlLoader.LoadRequest] Carregando as reconfigurações estruturais...");
request.StructuralRequest = new StructuralReconfigurationRequest(parameterList);
}
BehavioralReconfigurationRequest behavioralRequest = null;
List <MetaInnerComponent> innerComponents = generateInnerComponents(nodeRequest.SelectNodes("innerComponent"));
//Console.WriteLine("[XmlLoader.LoadRequest] Tem innerComponent para adicionar? {0}", innerComponents != null);
if (innerComponents != null)
{
behavioralRequest = new BehavioralReconfigurationRequest();
Console.WriteLine("[XmlLoader.LoadRequest] Carregando novos componentes aninhados...");
//Console.WriteLine("[XmlLoader.LoadRequest] {0} InnerComponent(s) adicionado(s)", innerComponents.Count);
behavioralRequest.NewInnerComponents = innerComponents;
uLoader.CandidateInnerComponents = innerComponents;
}
uLoader.InnerComponents = innerComponents;
XmlNodeList changeActionList = nodeRequest.SelectNodes("changeAction");
if (changeActionList != null)
{
Console.WriteLine("[XmlLoader.LoadRequest] Carregando as reconfigurações comportamentais...");
IEnumerator ienum = changeActionList.GetEnumerator();
BehavioralChange change;
XmlNode changeNode;
if (behavioralRequest == null)
{
behavioralRequest = new BehavioralReconfigurationRequest();
}
XmlAttribute attr;
int initialCode;
int aditionalStates, aditionalTrans;
aditionalStates = aditionalTrans = 0;
while (ienum.MoveNext())
{
changeNode = (XmlNode)ienum.Current;
change = new BehavioralChange();
//Console.WriteLine("[XmlLoader.LoadRequest] Criando uma nova BehavioralChange");
initialCode = generator.getCurrentCode();
attr = (XmlAttribute)changeNode.Attributes.GetNamedItem("unit");
change.Unit = attr.Value;
//Console.WriteLine("[XmlLoader.LoadRequest] Unit a sofrer alteração: {0}", change.Unit);
MetaUnit u = component.Units[change.Unit];
if (u != null)
{
//Console.WriteLine("[XmlLoader.LoadRequest] Unit {0} encontrada!", change.Unit);
attr = (XmlAttribute)changeNode.Attributes.GetNamedItem("action");
change.Action = attr.Value;
//Console.WriteLine("[XmlLoader.LoadRequest] Ação a sofrer alteração: {0}", change.Action);
MetaAction a = u.Actions[change.Action];
if (a != null && !a.IsNative)
{
//Console.WriteLine("[XmlLoader.LoadRequest] Ação {0} encontrada!", change.Action);
attr = (XmlAttribute)changeNode.Attributes.GetNamedItem("type");
if (attr.Value.Equals("remove"))
{
change.Type = BehavioralChange.BehavioralChangeType.REMOVE;
}
else
{
change.Type = BehavioralChange.BehavioralChangeType.INCLUDE;
}
attr = (XmlAttribute)changeNode.Attributes.GetNamedItem("point");
change.Point = attr.Value;
//Console.WriteLine("[XmlLoader.LoadRequest] Ponto a sofrer alteração: {0}", change.Point);
Transition t = a.Protocol.getTransition(change.Point);
if (t != null)
{
//Console.WriteLine("[XmlLoader.LoadRequest] Ponto {0} encontrado.", change.Point);
change.NewSlices = uLoader.getSlices(changeNode.SelectNodes("slice"));
uLoader.CandidateSlices = change.NewSlices;
if (change.Type == BehavioralChange.BehavioralChangeType.INCLUDE)
{
//Console.WriteLine("[XmlLoader.LoadRequest] Obtendo novo protocolo");
change.Transitions = uLoader.getTransitions(changeNode.SelectSingleNode("protocol").FirstChild, u, t.InitialState, t.FinalState, a.Protocol.NumStates + aditionalStates, a.Protocol.LastTransationId + aditionalTrans);
aditionalStates = uLoader.NumStates - a.Protocol.NumStates;
aditionalTrans = uLoader.NumTransations - a.Protocol.LastTransationId;
//TODO remover
//Console.WriteLine("Transações de reconfiguração");
//foreach(Transition tst in change.Transitions) {
// Console.WriteLine(tst);
//}
}
else
{
change.Transitions = new List <Transition>();
change.Transitions.Add(new Transition(t.InitialState, t.FinalState, Configuration.LAMBDA_TRANSITION, a.Protocol.LastTransationId++));
}
}
else
{
throw new Exception("[XmlLoader.loadRequest] Ponto de reconfiguração não existe: " + change.Point);
}
}
else
{
throw new Exception("[XmlLoader.loadRequest] Ação a ser alterada não existe ou nãoo é uma configuração: " + change.Action);
}
}
else
{
throw new Exception("[XmlLoader.loadRequest] Unidade da ação a ser alterada não existe: " + change.Unit);
}
change.AditionalStates = generator.getCurrentCode() - initialCode;
behavioralRequest.AddChange(change);
}
}
request.BehavioralRequest = behavioralRequest;
component.LastIdCode = generator.getCurrentCode();
}
uLoader.CandidateSlices = null;
uLoader.CandidateInnerComponents = null;
Console.WriteLine("[XmlLoader.loadRequest] Carga de script realizada com sucesso!");
return(request);
}
/// <summary>
/// Helper method for generating a MetaObject which calls a specific method on Dynamic
/// w/o any additional parameters.
/// </summary>
private MetaObject CallMethodUnary(MetaAction action, string methodName)
{
return new MetaObject(
Expression.Call(
GetLimitedSelf(),
typeof(DynamicObject).GetMethod(methodName, BindingFlags.NonPublic | BindingFlags.Instance),
Expression.Constant(action)
),
GetRestrictions()
);
}
/// <summary>
/// Helper method for generating a MetaObject which calls a specific method on Dynamic w/ the
/// meta object array as the params.
/// </summary>
private MetaObject CallMethodNAry(MetaAction action, MetaObject[] args, string methodName)
{
return new MetaObject(
Expression.Call(
GetLimitedSelf(),
typeof(DynamicObject).GetMethod(methodName, BindingFlags.NonPublic | BindingFlags.Instance),
ReplaceSelfWithAction(action, args)
),
GetRestrictions()
);
}
/// <summary>
/// Helper which returns an Expression array corresponding to the arguments minus
/// the DynamicObject instance (arg0) plus the MetaAction constant.
/// </summary>
private static Expression[] ReplaceSelfWithAction(MetaAction action, MetaObject[] args)
{
Expression[] paramArgs = new Expression[args.Length - 1];
for (int i = 0; i < paramArgs.Length; i++) {
paramArgs[i] = Expression.ConvertHelper(args[i + 1].Expression, typeof(object));
}
return new Expression[] {
Expression.Constant(action),
Expression.NewArrayInit(typeof(object), paramArgs)
};
}
public ProgramTest(MetaAction meta)
{
_meta = meta;
}
public static void SetAction(DependencyObject element, MetaAction value)
{
element.SetValue(ActionProperty, value);
}
