public void PlayerDrawCards()
{
game.Cards = new CardManager();
Card c1 = new TestCard();
Card c2 = new TestCard();
Card c3 = new TestCard();
Card c4 = new TestCard();
game.Cards.Deck.AddCard(c1);
game.Cards.Deck.AddCard(c2);
game.Cards.Deck.AddCard(c3);
game.Cards.Deck.AddCard(c4);
game.Players = new PlayerManager(1);
GamePlayer target = game.Players.GetPlayer(0);
Assert.AreEqual(target.Hand.GetSize(), 0);
bytes.push(InstructionFactory.Make_PlayerDrawCards(
LiteralFactory.CreatePlayerLiteral(target),
LiteralFactory.CreateIntLiteral(2)
));
game.ExecuteNext();
Assert.AreEqual(target.Hand.GetSize(), 2);
}
public InstructionFactoryTests()
{
_sut = InstructionFactory.Instance;
}
public void executeNext()
{
Instruction next = this.next();
try {
switch (next)
{
// FUNCTIONS
case Instruction.RANDOM_NUMBER: {
int upperBound = ReadIntLiteral(skipToNext);
push(LiteralFactory.CreateIntLiteral(UnityEngine.Random.Range(1, upperBound)));
break;
}
case Instruction.ADD: {
int a = ReadIntLiteral(skipToNext);
int b = ReadIntLiteral(skipToNext);
push(LiteralFactory.CreateIntLiteral(a + b));
break;
}
case Instruction.IF: {
int controlID = ReadIntLiteral(skipToNext);
Condition condition = ReadConditionLiteral(skipToNext);
List <byte> blockBytes = new List <byte>();
while (HasBytes())
{
byte b = pop();
if (b == (byte)Instruction.ENDIF)
{
int id = ReadIntLiteral(skipToNext);
if (id == controlID)
{
break;
}
else
{
blockBytes.Insert(0, (byte)Instruction.ENDIF);
blockBytes.InsertRange(0, LiteralFactory.CreateIntLiteral(id));
}
}
else
{
blockBytes.Insert(0, b);
}
}
if (condition.Evaluate())
{
push(blockBytes);
}
break;
}
case Instruction.UNLESS: {
int controlID = ReadIntLiteral(skipToNext);
Condition condition = ReadConditionLiteral(skipToNext);
List <byte> blockBytes = new List <byte>();
while (HasBytes())
{
byte b = pop();
if (b == (byte)Instruction.ENDIF)
{
int id = ReadIntLiteral(skipToNext);
if (id == controlID)
{
break;
}
else
{
blockBytes.Insert(0, (byte)Instruction.ENDIF);
blockBytes.InsertRange(0, LiteralFactory.CreateIntLiteral(id));
}
}
else
{
blockBytes.Insert(0, b);
}
}
if (!condition.Evaluate())
{
push(blockBytes);
}
break;
}
case Instruction.LIST_LENGTH: {
List <byte[]> list = ReadList(skipToNext);
push(LiteralFactory.CreateIntLiteral(list.Count));
break;
}
case Instruction.CARD_HAS_TAG: {
Card card = GM.ReadCardFromStack();
string tagName = ReadStringLiteral(skipToNext);
push(LiteralFactory.CreateConditionLiteral(
LiteralFactory.CreateBoolLiteral(card.HasTag(tagName)),
LiteralFactory.CreateBoolLiteral(true),
ConditionType.BOOL,
ConditionOperator.EQUAL
));
break;
}
case Instruction.PLAYER_IS_WINNING: {
GamePlayer player = GM.ReadPlayerFromStack();
bool winning = true;
foreach (GamePlayer otherPlayer in GM.Players.GetPlayers())
{
if (otherPlayer.Points > player.Points)
{
winning = false;
break;
}
}
push(LiteralFactory.CreateConditionLiteral(
LiteralFactory.CreateBoolLiteral(winning),
LiteralFactory.CreateBoolLiteral(true),
ConditionType.BOOL,
ConditionOperator.EQUAL
));
break;
}
case Instruction.PLAYER_IS_LOSING: {
GamePlayer player = GM.ReadPlayerFromStack();
bool losing = true;
foreach (GamePlayer otherPlayer in GM.Players.GetPlayers())
{
if (otherPlayer.Points < player.Points)
{
losing = false;
break;
}
}
push(LiteralFactory.CreateBoolLiteral(losing));
break;
}
case Instruction.MULTIPLY: {
int a = ReadIntLiteral(skipToNext);
int b = ReadIntLiteral(skipToNext);
push(LiteralFactory.CreateIntLiteral(a * b));
break;
}
case Instruction.LOOP: {
int id = ReadIntLiteral(skipToNext);
int num = ReadIntLiteral(skipToNext);
List <List <byte> > instructionArrays = new List <List <byte> >();
while (HasBytes())
{
if (peek() == (byte)Instruction.ENDLOOP)
{
pop();
int endloopID = ReadIntLiteral(skipToNext);
if (endloopID == id)
{
break;
}
else
{
List <byte> endloopBytes = new List <byte>(LiteralFactory.CreateIntLiteral(endloopID));
endloopBytes.Add((byte)Instruction.ENDLOOP);
instructionArrays.Insert(0, endloopBytes);
}
}
else
{
List <byte> arr = popInstruction(skipToNext);
instructionArrays.Insert(0, arr);
}
}
for (int n = 0; n < num; n++)
{
for (int m = 0; m < instructionArrays.Count; m++)
{
push(instructionArrays[m]);
}
}
break;
}
case Instruction.FOR_LOOP: {
int ID = ReadIntLiteral(skipToNext);
List <byte[]> items = ReadList(skipToNext);
List <List <byte> > instructionArrays = new List <List <byte> >();
while (HasBytes())
{
if (peek() == (byte)Instruction.ENDLOOP)
{
pop();
int endloopID = ReadIntLiteral(skipToNext);
if (endloopID == ID)
{
break;
}
else
{
List <byte> endloopBytes = new List <byte>(LiteralFactory.CreateIntLiteral(endloopID));
endloopBytes.Add((byte)Instruction.ENDLOOP);
instructionArrays.Insert(0, endloopBytes);
}
}
List <byte> arr = popInstruction(skipToNext);
instructionArrays.Insert(0, arr);
}
List <byte> idBytes = LiteralFactory.CreateIntLiteral(ID);
for (int i = 0; i < items.Count; i++)
{
List <byte> currentItem = new List <byte>(items[i]);
currentItem.Reverse();
List <byte> addToRegister = InstructionFactory.Make_AddToRegister(idBytes, currentItem);
for (int m = 0; m < instructionArrays.Count; m++)
{
push(instructionArrays[m]);
}
push(addToRegister);
}
break;
}
case Instruction.ADD_TO_REGISTER: {
int ID = ReadIntLiteral(skipToNext);
int size = ReadIntLiteral(skipToNext);
List <byte> bytes = pop(size);
register[ID] = bytes;
break;
}
case Instruction.PLACEHOLDER: {
int ID = ReadIntLiteral(skipToNext);
List <byte> fetch = new List <byte>(register[ID]);
fetch.Reverse();
push(fetch);
break;
}
// QUERIES
case Instruction.GET_ACTIVE_PLAYER: {
push(LiteralFactory.CreatePlayerLiteral(GM.Players.GetActivePlayer()));
break;
}
case Instruction.GET_ALL_OPPONENTS: {
push(LiteralFactory.CreateListLiteral(
new List <GamePlayer>(GM.Players.GetOpponents())
));
break;
}
case Instruction.GET_ALL_PLAYERS: {
push(LiteralFactory.CreateListLiteral(
new List <GamePlayer>(GM.Players.GetPlayers())
));
break;
}
case Instruction.GET_CARDS_IN_DECK: {
push(LiteralFactory.CreateListLiteral(
new List <Card>(GM.Cards.Deck.GetCards())
));
break;
}
case Instruction.GET_CARDS_IN_DISCARD: {
push(LiteralFactory.CreateListLiteral(
new List <Card>(GM.Cards.Discard.GetCards())
));
break;
}
case Instruction.GET_CARDS_IN_HAND: {
GamePlayer player = GM.ReadPlayerFromStack();
push(LiteralFactory.CreateListLiteral(
new List <Card>(player.Hand.GetCards())
));
break;
}
case Instruction.GET_PLAYER_POINTS: {
GamePlayer player = GM.ReadPlayerFromStack();
int points = player.Points;
push(LiteralFactory.CreateIntLiteral(points));
break;
}
case Instruction.READ_COUNTER: {
string key = ReadStringLiteral(skipToNext);
int count = GM.Variables.GetCounter(key);
push(LiteralFactory.CreateIntLiteral(count));
break;
}
case Instruction.BOOL_COMPARISON: {
bool operandA = ReadBoolLiteral(skipToNext);
byte operatorEnum = ReadEnumLiteral();
bool operandB = ReadBoolLiteral(skipToNext);
push(LiteralFactory.CreateConditionLiteral(
new CompareBool(operandA, operandB, (ConditionOperator)operatorEnum)
));
break;
}
case Instruction.NUM_COMPARISON: {
int operandA = ReadIntLiteral(skipToNext);
int operandB = ReadIntLiteral(skipToNext);
byte operatorEnum = ReadEnumLiteral();
push(LiteralFactory.CreateConditionLiteral(
new CompareNum(operandA, operandB, (ConditionOperator)operatorEnum)
));
break;
}
case Instruction.TARGET_PLAYER: {
GM.UI.PresentChoiceOfPlayers(new List <GamePlayer>(GM.Players.GetPlayers()), this);
break;
}
case Instruction.TARGET_OPPONENT: {
GM.UI.PresentChoiceOfPlayers(new List <GamePlayer>(GM.Players.GetOpponents()), this);
break;
}
case Instruction.TARGET_CARD_IN_DECK: {
GM.UI.PresentChoiceOfCards(new List <Card>(GM.Cards.Deck.GetCards()), this);
break;
}
case Instruction.TARGET_CARD_IN_DISCARD: {
GM.UI.PresentChoiceOfCards(new List <Card>(GM.Cards.Discard.GetCards()), this);
break;
}
case Instruction.TARGET_CARD_IN_HAND: {
GamePlayer player = GM.ReadPlayerFromStack();
GM.UI.PresentChoiceOfCards(new List <Card>(player.Hand.GetCards()), this);
break;
}
case Instruction.RANDOM_PLAYER: {
GamePlayer[] players = GM.Players.GetPlayers();
GamePlayer randomPlayer = players[UnityEngine.Random.Range(0, players.Length)];
push(LiteralFactory.CreatePlayerLiteral(randomPlayer));
break;
}
case Instruction.RANDOM_OPPONENT: {
GamePlayer[] opponents = GM.Players.GetOpponents();
GamePlayer randomOpponent = opponents[UnityEngine.Random.Range(0, opponents.Length)];
push(LiteralFactory.CreatePlayerLiteral(randomOpponent));
break;
}
case Instruction.RANDOM_CARD_IN_DECK: {
Card[] deckCards = GM.Cards.Deck.GetCards();
Card randomCard = deckCards[UnityEngine.Random.Range(0, deckCards.Length)];
push(LiteralFactory.CreateCardLiteral(randomCard));
break;
}
case Instruction.RANDOM_CARD_IN_DISCARD: {
Card[] discardCards = GM.Cards.Discard.GetCards();
Card randomCard = discardCards[UnityEngine.Random.Range(0, discardCards.Length)];
push(LiteralFactory.CreateCardLiteral(randomCard));
break;
}
case Instruction.RANDOM_CARD_IN_HAND: {
GamePlayer player = GM.ReadPlayerFromStack();
Card[] handCards = player.Hand.GetCards();
Card randomCard = handCards[UnityEngine.Random.Range(0, handCards.Length)];
push(LiteralFactory.CreateCardLiteral(randomCard));
break;
}
// EFFECTS
case Instruction.INCREMENT_PLAYER_POINTS: {
GamePlayer player = GM.ReadPlayerFromStack();
int pointsNum = ReadIntLiteral(skipToNext);
GM.SetPlayerPoints(player, player.Points + pointsNum);
break;
}
case Instruction.PLAYER_DRAW_CARD: {
GamePlayer player = GM.ReadPlayerFromStack();
int numCards = ReadIntLiteral(skipToNext);
for (int n = 0; n < numCards; n++)
{
GM.PlayerDrawCard(player);
}
break;
}
case Instruction.SET_COUNTER: {
string key = ReadStringLiteral(skipToNext);
int count = ReadIntLiteral(skipToNext);
GM.Variables.SetCounter(key, count);
break;
}
case Instruction.SET_PLAYER_DRAW: {
GamePlayer player = GM.ReadPlayerFromStack();
int num = ReadIntLiteral(skipToNext);
player.SetDrawPerTurn(num);
break;
}
case Instruction.SET_PLAYER_MAX_HAND: {
GamePlayer player = GM.ReadPlayerFromStack();
int num = ReadIntLiteral(skipToNext);
player.Hand.SetMax(num);
break;
}
case Instruction.SET_PLAYER_POINTS: {
GamePlayer player = GM.ReadPlayerFromStack();
int pointsNum = ReadIntLiteral(skipToNext);
GM.SetPlayerPoints(player, pointsNum);
break;
}
case Instruction.MOVE_TO_DECK: {
Card card = GM.ReadCardFromStack();
DeckLocation posEnum = (DeckLocation)ReadEnumLiteral();
card.Zone.MoveCard(GM.Cards.Deck, card.GetID());
GM.Cards.Deck.MoveLastAddedCard(posEnum);
break;
}
case Instruction.MOVE_TO_DISCARD: {
Card card = GM.ReadCardFromStack();
card.Zone.MoveCard(GM.Cards.Discard, card.GetID());
break;
}
}
} catch (UnexpectedByteException e) {
Debug.LogError(e);
} catch (StackFullException e) {
Debug.LogError(e);
} catch (StackEmptyException e) {
Debug.LogError(e);
}
}
private VisualInstructionUserControl InsertOutputInstructionAtRight(bool after, VisualInstructionUserControl visualInstruction, InstructionList instructions)
{
int index = 0;
int autToRetornInsertedInstruction = 0;
switch (visualOutputInstructions.Count)
{
case 0:
index = 0;
if (instructions.Count > 1)
{
instructions.InsertParallelBranch(InstructionList.ParallelBranchInsertionType.ParallelBranchCompleted);
autToRetornInsertedInstruction = -1;
}
break;
case 1:
index = VerifyPositionToInsert(after, visualInstruction, this.visualOutputInstructions);
if (index == 0)
{
instructions.InsertParallelBranch(InstructionList.ParallelBranchInsertionType.ParallelBranchInitialized);
line.Outputs.Insert(0, InstructionFactory.createInstruction(OperationCode.ParallelBranchNext));
InsertVisualInstructionAt(0, this.visualOutputInstructions, InstructionFactory.createInstruction(OperationCode.ParallelBranchNext));
line.Outputs.Insert(this.visualOutputInstructions.Count, InstructionFactory.createInstruction(OperationCode.ParallelBranchEnd));
InsertVisualInstructionAt(this.visualOutputInstructions.Count, this.visualOutputInstructions, InstructionFactory.createInstruction(OperationCode.ParallelBranchEnd));
}
else
{
instructions.InsertParallelBranch(InstructionList.ParallelBranchInsertionType.ParallelBranchFinalized);
autToRetornInsertedInstruction = -1;
line.Outputs.Insert(0, InstructionFactory.createInstruction(OperationCode.ParallelBranchBegin));
InsertVisualInstructionAt(0, this.visualOutputInstructions, InstructionFactory.createInstruction(OperationCode.ParallelBranchBegin));
index++;
}
break;
default:
index = VerifyPositionToInsert(false, visualInstruction, this.visualOutputInstructions);
switch (this.visualOutputInstructions[index].OpCode)
{
case OperationCode.ParallelBranchBegin:
instructions.InsertParallelBranch(InstructionList.ParallelBranchInsertionType.ParallelBranchInitialized);
line.Outputs[0].OpCode = OperationCode.ParallelBranchNext;
this.visualOutputInstructions[0].OpCode = OperationCode.ParallelBranchNext;
break;
case OperationCode.ParallelBranchNext:
instructions.InsertParallelBranchNext();
break;
case OperationCode.ParallelBranchEnd:
instructions.InsertParallelBranchNext();
break;
default:
instructions.InsertParallelBranchNext();
index++;
break;
}
break;
}
foreach (Instruction instruction in instructions)
{
line.Outputs.Insert(index, instruction);
InsertVisualInstructionAt(index, this.visualOutputInstructions, instruction);
index++;
}
return(this.visualOutputInstructions[index - 1 + autToRetornInsertedInstruction]);
}
public static IInstruction Parse(Token token) => InstructionFactory.CreateInstruction(Map[token]);
protected List <PsudoInstruction> CompileBlock(PsudoMethod method, int startLine, int endLine)
{
List <PsudoInstruction> list = new List <PsudoInstruction>();
for (int i = startLine; i <= endLine; i++)
{
try
{
switch (this.scanner.lineTypes[i])
{
case PsudoLineType.Variable:
PsudoVariableInfo vInfo = this.scanner.variableInfo.Find(
item => item.Line == i);
vInfo.Processed = true;
list.Add(new CreateLocalVariable(i, method, vInfo.Type, vInfo.Name, vInfo.Default));
break;
case PsudoLineType.StartDecision:
case PsudoLineType.StartStartDecision:
int end;
list.Add(CompileDecision(method, i, out end));
i = end;
break;
case PsudoLineType.StartLoop:
int end2;
list.Add(CompileLoop(method, i, out end2));
i = end2;
break;
case PsudoLineType.Instruction:
list.Add(InstructionFactory.CompileInstruction(
this.codeLines[i], i, method));
break;
// Nothing to do for the following
case PsudoLineType.StartMain:
case PsudoLineType.StartMethod:
case PsudoLineType.Whitespace:
case PsudoLineType.Comment:
case PsudoLineType.EndMethod:
break;
case PsudoLineType.EndDecision:
throw new Exception("Unexpected End Decision");
case PsudoLineType.EndLoop:
throw new Exception("Unexpected End Loop");
case PsudoLineType.EndClass:
case PsudoLineType.StartClass:
throw new Exception("Classes Not Supported Currently");
default:
throw new Exception(string.Format(
"Error Compiling Method \"{0}\" on Line #{1}",
method.Name, i + 1));
}
}
catch (Exception e)
{
this.Errors.Add(new CompileError(e.Message, i + 1));
}
}
return(list);
}
private ICollection <AddressableInstruction> ParseSource()
{
InstructionFactory instructionParser = new InstructionFactory();
// We parse the source and build a list of all source
// instructions (including comments), and a dictionary
// of executable instructions, indexed by their source
// starting address.
List <Instruction> sourceList = new List <Instruction>();
Dictionary <int, AddressableInstruction> instructionDictionary = new Dictionary <int, AddressableInstruction>();
Dictionary <String, AddressableInstruction> labeledInstructionDictionary = new Dictionary <string, AddressableInstruction>();
int instructionSourceAddress = 0;
int instructionSourceLineNumber = 0;
// Loop through each line of source code and create an instruction for it.
foreach (String sourceLine in _sourceCodeLines)
{
Instruction sourceInstruction = instructionParser.GenerateInstruction(sourceLine, instructionSourceLineNumber, instructionSourceAddress);
if (sourceInstruction != null)
{
AddressableInstruction addressableInstruction = sourceInstruction as AddressableInstruction;
if (addressableInstruction != null)
{
instructionDictionary.Add(instructionSourceAddress, addressableInstruction);
// If the instruction has a label, store a mapping so we can resolve labeled branches later.
if (!String.IsNullOrEmpty(addressableInstruction.Address.AddressLabel))
{
labeledInstructionDictionary.Add(addressableInstruction.Address.AddressLabel, addressableInstruction);
}
instructionSourceAddress += addressableInstruction.SourceLength;
}
sourceList.Add(sourceInstruction);
instructionSourceLineNumber++;
}
}
// Loop through each instruction and map each branch address to the destination instruction.
// This is done at the source level at this stage so we have a correctly mapped instruction
// tree before we start generating binary and create the actual addresses.
foreach (var instruction in instructionDictionary)
{
IBranchingInstruction branchingInstruction = instruction.Value as IBranchingInstruction;
if (branchingInstruction != null)
{
branchingInstruction.MapBranchAddress(instructionDictionary, labeledInstructionDictionary);
}
IAddressedOperands addressedOperandsInstruction = instruction.Value as IAddressedOperands;
if (addressedOperandsInstruction != null)
{
addressedOperandsInstruction.MapAddressedOperands(instructionDictionary, labeledInstructionDictionary);
}
AddressableMemoryInstruction memoryValue = instruction.Value as AddressableMemoryInstruction;
if (memoryValue != null)
{
memoryValue.MapMemoryValue(instructionDictionary, labeledInstructionDictionary);
}
}
return(instructionDictionary.Values);
}
public void EmitTypeAs(Type type)
{
Emit(InstructionFactory.GetFactory(type).TypeAs());
}
private void End() => Instructions.Add(InstructionFactory.Halt(InstructionLine));
public Instruction InsertToOutputs(Line line, InstructionList instructions)
{
int index = 0;
int auxToPositionInsertedInstruciton = 0;
switch (line.Outputs.Count)
{
case 0:
/// case 0: First instruction to output, add only one
/// instruction at output
index = 0;
if (instructions.Count > 1)
{
instructions.InsertParallelBranch(InstructionList.ParallelBranchInsertionType.ParallelBranchCompleted);
auxToPositionInsertedInstruciton = -1;
}
break;
case 1:
/// case 1: If exists one output instruction, insert parallel branch
/// automatically
// here 0=before, 1=after
if (index == 0)
{
/// prepare to insert before the actual object
instructions.InsertParallelBranch(InstructionList.ParallelBranchInsertionType.ParallelBranchInitialized);
/// insert parallel branch next before the actual object
//line.Outputs.Insert(0, new Instruction(OperationCode.ParallelBranchNext));
line.Outputs.Insert(0, InstructionFactory.createInstruction(OperationCode.ParallelBranchNext));
/// insert parallel branch end after the actual object
//line.Outputs.Insert(line.Outputs.Count, new Instruction(OperationCode.ParallelBranchEnd));
line.Outputs.Insert(line.Outputs.Count, InstructionFactory.createInstruction(OperationCode.ParallelBranchEnd));
}
else
{
instructions.InsertParallelBranch(InstructionList.ParallelBranchInsertionType.ParallelBranchFinalized);
auxToPositionInsertedInstruciton = -1;
line.Outputs.Insert(0, InstructionFactory.createInstruction(OperationCode.ParallelBranchBegin));
index++;
}
break;
default:
switch (line.Outputs[index].OpCode)
{
case OperationCode.ParallelBranchBegin:
instructions.InsertParallelBranch(InstructionList.ParallelBranchInsertionType.ParallelBranchInitialized);
line.Outputs[0].OpCode = OperationCode.ParallelBranchNext;
break;
case OperationCode.ParallelBranchNext:
instructions.InsertParallelBranchNext();
break;
case OperationCode.ParallelBranchEnd:
instructions.InsertParallelBranchNext();
break;
default:
instructions.InsertParallelBranchNext();
index++;
break;
}
break;
}
foreach (Instruction instruction in instructions)
{
line.Outputs.Insert(index, instruction);
index++;
}
return(line.Outputs[index - 1 + auxToPositionInsertedInstruciton]);
}
public void SetUp()
{
target = new InstructionFactory();
}
public void TestInstructionInstanciation()
{
List <IDefinition> empty = new List <IDefinition>();
List <IDefinition> one_int = new List <IDefinition> {
Scalar.Integer
};
List <IDefinition> dbl_int = new List <IDefinition> {
Scalar.Integer, Scalar.Integer
};
List <IDefinition> trp_int = new List <IDefinition> {
Scalar.Integer, Scalar.Integer, Scalar.Integer
};
Assert.IsTrue(InstructionFactory.CreateInstruction(InstructionFactory.INSTRUCTION_ID.AND, empty).GetType() == typeof(And));
Assert.IsTrue(InstructionFactory.CreateInstruction(InstructionFactory.INSTRUCTION_ID.OR, empty).GetType() == typeof(Or));
Assert.IsTrue(InstructionFactory.CreateInstruction(InstructionFactory.INSTRUCTION_ID.DIFFERENT, dbl_int).GetType() == typeof(Different));
Assert.IsTrue(InstructionFactory.CreateInstruction(InstructionFactory.INSTRUCTION_ID.EQUAL, dbl_int).GetType() == typeof(Equal));
Assert.IsTrue(InstructionFactory.CreateInstruction(InstructionFactory.INSTRUCTION_ID.GREATER, dbl_int).GetType() == typeof(Greater));
Assert.IsTrue(InstructionFactory.CreateInstruction(InstructionFactory.INSTRUCTION_ID.GREATER_EQUAL, dbl_int).GetType() == typeof(GreaterEqual));
Assert.IsTrue(InstructionFactory.CreateInstruction(InstructionFactory.INSTRUCTION_ID.LOWER, dbl_int).GetType() == typeof(Less));
Assert.IsTrue(InstructionFactory.CreateInstruction(InstructionFactory.INSTRUCTION_ID.LOWER_EQUAL, dbl_int).GetType() == typeof(LessEqual));
Assert.IsTrue(InstructionFactory.CreateInstruction(InstructionFactory.INSTRUCTION_ID.ACCESS, trp_int).GetType() == typeof(Access));
Assert.IsTrue(InstructionFactory.CreateInstruction(InstructionFactory.INSTRUCTION_ID.BINARY_AND, trp_int).GetType() == typeof(BinaryAnd));
Assert.IsTrue(InstructionFactory.CreateInstruction(InstructionFactory.INSTRUCTION_ID.BINARY_OR, trp_int).GetType() == typeof(BinaryOr));
Assert.IsTrue(InstructionFactory.CreateInstruction(InstructionFactory.INSTRUCTION_ID.XOR, trp_int).GetType() == typeof(Xor));
Assert.IsTrue(InstructionFactory.CreateInstruction(InstructionFactory.INSTRUCTION_ID.ADD, trp_int).GetType() == typeof(Add));
Assert.IsTrue(InstructionFactory.CreateInstruction(InstructionFactory.INSTRUCTION_ID.SUB, trp_int).GetType() == typeof(Substract));
Assert.IsTrue(InstructionFactory.CreateInstruction(InstructionFactory.INSTRUCTION_ID.DIV, trp_int).GetType() == typeof(Divide));
Assert.IsTrue(InstructionFactory.CreateInstruction(InstructionFactory.INSTRUCTION_ID.MUL, trp_int).GetType() == typeof(Multiplicate));
Assert.IsTrue(InstructionFactory.CreateInstruction(InstructionFactory.INSTRUCTION_ID.MOD, trp_int).GetType() == typeof(Modulo));
Assert.IsTrue(InstructionFactory.CreateInstruction(InstructionFactory.INSTRUCTION_ID.LEFT_SHIFT, trp_int).GetType() == typeof(LeftShift));
Assert.IsTrue(InstructionFactory.CreateInstruction(InstructionFactory.INSTRUCTION_ID.RIGHT_SHIFT, trp_int).GetType() == typeof(RightShift));
Assert.IsTrue(InstructionFactory.CreateInstruction(InstructionFactory.INSTRUCTION_ID.BINARY_NOT, dbl_int).GetType() == typeof(BinaryNot));
Assert.IsTrue(InstructionFactory.CreateInstruction(InstructionFactory.INSTRUCTION_ID.NOT, one_int).GetType() == typeof(Not));
Assert.IsTrue(InstructionFactory.CreateInstruction(InstructionFactory.INSTRUCTION_ID.INVERSE, dbl_int).GetType() == typeof(Inverse));
Assert.IsTrue(InstructionFactory.CreateInstruction(InstructionFactory.INSTRUCTION_ID.ENUM_SPLITTER, new List <IDefinition> {
new EnumType()
}).GetType() == typeof(EnumSplitter));
Assert.IsTrue(InstructionFactory.CreateInstruction(InstructionFactory.INSTRUCTION_ID.GETTER, new List <IDefinition> {
new Variable()
}).GetType() == typeof(Getter));
Assert.IsTrue(InstructionFactory.CreateInstruction(InstructionFactory.INSTRUCTION_ID.SETTER, new List <IDefinition> {
new Variable()
}).GetType() == typeof(Setter));
Assert.IsTrue(InstructionFactory.CreateInstruction(InstructionFactory.INSTRUCTION_ID.FUNCTION_CALL, new List <IDefinition> {
new Function()
}).GetType() == typeof(FunctionCall));
Assert.IsTrue(InstructionFactory.CreateInstruction(InstructionFactory.INSTRUCTION_ID.IF, empty).GetType() == typeof(If));
Assert.IsTrue(InstructionFactory.CreateInstruction(InstructionFactory.INSTRUCTION_ID.WHILE, empty).GetType() == typeof(While));
}
public List <byte> ExportEffect()
{
return(InstructionFactory.RunInstructionFactoryForNode(rootNode));
}
public void EmitNewArray(Type elementType)
{
Emit(InstructionFactory.GetFactory(elementType).NewArray());
}
public void Test_NormalInstructions()
{
var lst = new[] {
InstructionFactory.Add(reg1, reg2),
InstructionFactory.Add(reg1, constant),
InstructionFactory.Sub(reg1, reg2),
InstructionFactory.Sub(reg1, constant),
InstructionFactory.Xor(reg1, reg2),
InstructionFactory.Xor(reg1, constant),
InstructionFactory.And(reg1, reg2),
InstructionFactory.And(reg1, constant),
InstructionFactory.Or(reg1, reg2),
InstructionFactory.Or(reg1, constant),
InstructionFactory.Test(reg1, reg2),
InstructionFactory.Test(reg1, constant),
InstructionFactory.Shl(reg1, constant),
InstructionFactory.Shr(reg1, constant),
InstructionFactory.Cmp(reg1, reg2),
InstructionFactory.Cmp(reg1, constant),
InstructionFactory.Cmp(constant, reg2),
InstructionFactory.Mul(reg1),
InstructionFactory.Div(reg1),
InstructionFactory.Inc(reg1),
InstructionFactory.Dec(reg1),
InstructionFactory.Neg(reg1),
InstructionFactory.Not(reg1),
InstructionFactory.Call(fun),
InstructionFactory.Call(reg1),
InstructionFactory.Ret(),
InstructionFactory.Pop(reg1),
InstructionFactory.Push(reg1),
InstructionFactory.Jmp(reg1),
InstructionFactory.Cmove(reg1, reg2),
InstructionFactory.Cmovg(reg1, reg2),
InstructionFactory.Cmovge(reg1, reg2),
InstructionFactory.Cmovl(reg1, reg2),
InstructionFactory.Cmovle(reg1, reg2),
InstructionFactory.Cmovne(reg1, reg2),
InstructionFactory.Sete(reg1),
InstructionFactory.Setg(reg1),
InstructionFactory.Setge(reg1),
InstructionFactory.Setl(reg1),
InstructionFactory.Setle(reg1),
InstructionFactory.Setne(reg1)
};
foreach (var insn in lst)
{
Assert.IsFalse(insn.IsCopyInstruction);
Assert.IsFalse(insn.IsJumpInstruction);
Assert.IsFalse(insn.IsLabel);
Assert.IsNull(insn.Label);
}
}
public void EmitDefaultValue(Type type)
{
Emit(InstructionFactory.GetFactory(type).DefaultValue());
}
public void Get_Exception_Instruction_Test()
{
IInstructionFactory instructionFactory = new InstructionFactory();
var moveInstruction = instructionFactory.GetInstruction('I');
}
public LadderProgram ReadExecutable(string content, string projectName)
{
if (content.IndexOf("@laddermic.com") == -1)
{
throw new Exception("Executable has no Ladder content!");
}
OperationCode opCode = OperationCode.None;
int countOfEnds = 0;
int lineIndex = 0;
Address address;
AddressTypeEnum addressType;
int index = 0;
LadderProgram program = new LadderProgram();
program.Name = projectName;
program.device = DeviceFactory.CreateNewDevice();
addressingServices.AlocateIOAddressing(program.device);
addressingServices.AlocateAddressingMemoryAndTimerAndCounter(program, program.addressing.ListMemoryAddress, AddressTypeEnum.DigitalMemory, 10);
addressingServices.AlocateAddressingMemoryAndTimerAndCounter(program, program.addressing.ListTimerAddress, AddressTypeEnum.DigitalMemoryTimer, 10);
addressingServices.AlocateAddressingMemoryAndTimerAndCounter(program, program.addressing.ListCounterAddress, AddressTypeEnum.DigitalMemoryCounter, 10);
lineIndex = program.InsertLineAtEnd(new Line());
for (int position = content.IndexOf("@laddermic.com") + 15; position < content.Length; position++)
{
opCode = (OperationCode)Convert.ToChar(content.Substring(position, 1));
switch (opCode)
{
case OperationCode.None:
countOfEnds++;
break;
case OperationCode.LineEnd:
countOfEnds++;
if ((OperationCode)Convert.ToChar(content.Substring(position + 1, 1)) != OperationCode.None)
{
lineIndex = program.InsertLineAtEnd(new Line());
}
break;
case OperationCode.NormallyOpenContact:
case OperationCode.NormallyClosedContact:
countOfEnds = 0;
//Instruction instruction = new Instruction((OperationCode)opCode);
Instruction instruction = InstructionFactory.createInstruction(opCode);
addressType = (AddressTypeEnum)Convert.ToChar(content.Substring(position + 1, 1));
index = (Int32)Convert.ToChar(content.Substring(position + 2, 1));
address = addressingServices.Find(addressType, index);
if (address == null)
{
program.device.Pins[index - 1].Type = addressType;
addressingServices.RealocatePinAddressesByPinTypesFromDevice(program.device);
addressingServices.AlocateIOAddressing(program.device);
address = addressingServices.Find(addressType, index);
}
instruction.SetOperand(0, address);
position += 2;
program.Lines[lineIndex].Instructions.Add(instruction);
break;
case OperationCode.OutputCoil:
case OperationCode.Reset:
countOfEnds = 0;
{
InstructionList instructions = new InstructionList();
instructions.Add(InstructionFactory.createInstruction(opCode));
addressType = (AddressTypeEnum)Convert.ToChar(content.Substring(position + 1, 1));
index = (Int32)Convert.ToChar(content.Substring(position + 2, 1));
address = addressingServices.Find(addressType, index);
if (address == null)
{
program.device.Pins[index - 1].Type = addressType;
addressingServices.RealocatePinAddressesByPinTypesFromDevice(program.device);
addressingServices.AlocateIOAddressing(program.device);
address = addressingServices.Find(addressType, index);
}
instructions[instructions.Count - 1].SetOperand(0, address);
position += 2;
lineServices.InsertToOutputs(program.Lines[lineIndex], instructions);
instructions.Clear();
}
break;
case OperationCode.ParallelBranchBegin:
case OperationCode.ParallelBranchEnd:
case OperationCode.ParallelBranchNext:
countOfEnds = 0;
program.Lines[lineIndex].Instructions.Add(InstructionFactory.createInstruction(opCode));
break;
case OperationCode.Counter:
countOfEnds = 0;
{
InstructionList instructions = new InstructionList();
CounterInstruction counter = (CounterInstruction)InstructionFactory.createInstruction(opCode);
counter.SetAddress(addressingServices.Find(AddressTypeEnum.DigitalMemoryCounter, (Int32)Convert.ToChar(content.Substring(position + 1, 1))));
counter.setBoxType((int)Convert.ToChar(content.Substring(position + 2, 1)));
counter.setPreset((int)Convert.ToChar(content.Substring(position + 3, 1)));
instructions.Add(counter);
//instructions.Add(InstructionFactory.createInstruction(opCode));
//instructions[instructions.Count - 1].SetOperand(0, addressingServices.Find(AddressTypeEnum.DigitalMemoryCounter, (Int32)Convert.ToChar(content.Substring(position + 1, 1))));
//((Address)instructions[instructions.Count - 1].GetOperand(0)).Counter.Type = (Int32)Convert.ToChar(content.Substring(position + 2, 1));
//((Address)instructions[instructions.Count - 1].GetOperand(0)).Counter.Preset = (Int32)Convert.ToChar(content.Substring(position + 3, 1));
//instructions[instructions.Count - 1].SetOperand(1, ((Address)instructions[instructions.Count - 1].GetOperand(0)).Counter.Type);
//instructions[instructions.Count - 1].SetOperand(2, ((Address)instructions[instructions.Count - 1].GetOperand(0)).Counter.Preset);
position += 3;
lineServices.InsertToOutputs(program.Lines[lineIndex], instructions);
instructions.Clear();
}
break;
case OperationCode.Timer:
countOfEnds = 0;
{
InstructionList instructions = new InstructionList();
instructions.Add(InstructionFactory.createInstruction(opCode));
instructions[instructions.Count - 1].SetOperand(0, addressingServices.Find(AddressTypeEnum.DigitalMemoryTimer, (Int32)Convert.ToChar(content.Substring(position + 1, 1))));
((Address)instructions[instructions.Count - 1].GetOperand(0)).Timer.Type = (Int32)Convert.ToChar(content.Substring(position + 2, 1));
((Address)instructions[instructions.Count - 1].GetOperand(0)).Timer.TimeBase = (Int32)Convert.ToChar(content.Substring(position + 3, 1));
((Address)instructions[instructions.Count - 1].GetOperand(0)).Timer.Preset = (Int32)Convert.ToChar(content.Substring(position + 4, 1));
instructions[instructions.Count - 1].SetOperand(1, ((Address)instructions[instructions.Count - 1].GetOperand(0)).Timer.Type);
instructions[instructions.Count - 1].SetOperand(2, ((Address)instructions[instructions.Count - 1].GetOperand(0)).Timer.Preset);
instructions[instructions.Count - 1].SetOperand(4, ((Address)instructions[instructions.Count - 1].GetOperand(0)).Timer.TimeBase);
position += 4;
lineServices.InsertToOutputs(program.Lines[lineIndex], instructions);
instructions.Clear();
}
break;
}
/// end of codes
if (countOfEnds >= 2)
{
MicIntegrationServices p = new MicIntegrationServices();
//p.CreateFile("opcode.txt", content.Substring(content.IndexOf("@laddermic.com"), i - content.IndexOf("@laddermic.com") + 1));
//position = content.Length;
break;
}
}
return(program);
}
// Start is called before the first frame update
private void Start()
{
var cellBehaviorFirst = new Behavior("first");
cellBehaviorFirst.Cycle
.AddInstruction(
InstructionFactory.InstanceRandomNear(cellBehaviorFirst))
.EndCycle(false);
Instantiator.InstantiateSim(cellBehaviorFirst, Vector3.zero);
//PropertyTag amountTag = new PropertyTag("amount");
//var food = new Behavior("food");
//food.Properties.AddProperty(amountTag, 20);
//food.Cycle
// .AddInstruction(InstructionFactory.PropIncrement(amountTag, 10))
// .AddInstruction(InstructionFactory.CtrlNextIf(
// (sim) =>
// sim.Behavior.Properties.GetPropertyValue(
// amountTag) < 100))
// .AddInstruction(InstructionFactory.CtrlCurrentToIndexRelative(3))
// .AddInstruction(InstructionFactory.InstanceRandomNear(food))
// .AddInstruction(InstructionFactory.PropIncrement(amountTag, -50))
// .AddInstruction(InstructionFactory.CtrlNextIf(
// (sim =>
// sim.Behavior.Properties.GetPropertyValue(
// amountTag) <= 0)))
// .AddInstruction(InstructionFactory.SelfDestruction())
// .EndCycle(true);
//var eater = new Behavior("eater");
//var healthTag = new PropertyTag("health");
//eater.Properties.AddProperty(healthTag, 50);
//eater.Cycle
// .AddInstruction((sim, cycle) =>
// sim.GetComponent<Rigidbody2D>()
// .AddForce(new Vector2(Random.Range(-1.0f, 1.0f),
// Random.Range(-1.0f, 1.0f)) * 50)
// )
// .AddInstruction(InstructionFactory.CtrlNextIf((sim =>
// sim.Behavior.Properties.GetPropertyValue(
// healthTag) < 100)))
// .AddInstruction(InstructionFactory.CtrlCurrentToIndexRelative(3))
// .AddInstruction(
// InstructionFactory.PropIncrement(healthTag, -50))
// .AddInstruction(InstructionFactory.InstanceRandomNear(eater))
// .EndCycle(true);
//var table = new ReactionTable();
//table.AddReaction(eater.Tag, food.Tag,
// new Simulation.MessageTag("collide"),
// (callerSim, receiverSim) =>
// {
// callerSim.Behavior.Properties.IncrementValue(healthTag, 10);
// receiverSim.Behavior.Properties.IncrementValue(amountTag, -20);
// });
//food.Table = table;
//eater.Table = table;
//Instantiator.InstantiateSim(eater, Vector3.zero);
//Instantiator.InstantiateSim(food, Vector3.zero);
}
