public void SetInPlay(ShiftCommand command) { shiftCommand = command; beingPulled = false; SnapToPosition(); gameObject.SetActive(true); }
public void Reset() { _A = 0; _B = 0; _command = ShiftCommand.NON; _result = 0; }
public void OnEndDrag(PointerEventData eventData) { if (beingPulled) { ShiftCommand insertBefore = feed.GetBestInsertBeforeCard(this); beingPulled = false; OnReleaseRobotCommand?.Invoke(this.shiftCommand, insertBefore); } }
private void SendSynchFeed() { for (int idx = 0, l = instructionsFeed.Count; idx < l; idx++) { if (instructionsFeed[idx].LeftOrOn(idx)) { instructionsFeed[idx] = ShiftCommand.MoveLeftFrom(instructionsFeed[idx].command, idx); } } OnSyncCommands?.Invoke(instructionsFeed, heldCard); }
IEnumerator <WaitForSeconds> WipeFeed() { heldCard = ShiftCommand.NothingHeld; //Remove what remains float flushSpeed = 0.1f; while (instructionsFeed.Count > 0) { ExecuteCommand(flushSpeed, false); yield return(new WaitForSeconds(flushSpeed)); } }
private void UIRobotCommand_OnReleaseRobotCommand(ShiftCommand command, ShiftCommand insertBefore) { if (!robotAlive || reachedGoal) { return; } if (!heldCard.SameAs(command)) { Debug.LogWarning(string.Format("Trying to insert card {0} that doesn't match what is held {1}.", command, heldCard)); return; } bool inserted = false; ShiftCommand insertion = ShiftCommand.NothingHeld; int position = 0; for (int i = 0, l = instructionsFeed.Count; i < l; i++) { if (inserted) { instructionsFeed[i] = ShiftCommand.JumpRight(instructionsFeed[i]); } else { if (instructionsFeed[i].SameAs(insertBefore)) { insertion = ShiftCommand.Insert(instructionsFeed[i], command.command); inserted = true; position = i; } } } if (inserted) { instructionsFeed.Insert(position, insertion); } else { instructionsFeed.Add(ShiftCommand.MoveLeftFrom(command.command, instructionsFeed.Count)); } heldCard = ShiftCommand.NothingHeld; OnSyncCommands?.Invoke(instructionsFeed, heldCard); }
private void DrawOne() { // Get new draw deck if needed if (drawDeck.Count == 0) { FlipTrash(); } // Get the card RobotCommand cmd = RobotCommand.NONE; if (drawDeck.Count > 0) { cmd = drawDeck[0]; drawDeck.RemoveAt(0); } // Insert card instructionsFeed.Add(ShiftCommand.MoveLeftFrom(cmd, instructionsFeed.Count)); // Inform subscribers SendSynchFeed(); }
private void UIRobotCommand_OnGrabRobotCommand(ShiftCommand command, ShiftCommand insertBefore) { if (reachedGoal || !robotAlive || !insertBefore.Held) { return; } for (int i = 0, l = instructionsFeed.Count; i < l; i++) { ShiftCommand card = instructionsFeed[i]; if (card.SameAs(command)) { instructionsFeed.RemoveAt(i); if (!heldCard.Empty) { Debug.LogWarning(string.Format("Picking up a second card {0} while holding {1}", card, heldCard)); trashDeck.Add(heldCard.command); } heldCard = ShiftCommand.Pickup(card); SendSynchFeed(); return; } } Debug.LogWarning(string.Format("Tried to pickup card {0}, but couldn't find it", command)); }
public bool SameAs(ShiftCommand other) { return(command == other.command && position == other.position && targetPosition == other.targetPosition); }
public void ShiftLeft(ShiftCommand command) { shiftCommand = command; SnapToPosition(); }
public void ShiftRight(ShiftCommand command) { shiftCommand = command; SnapToPosition(true); }
public static ShiftCommand Insert(ShiftCommand previousHolder, RobotCommand command) { return(new ShiftCommand(command, previousHolder.position, previousHolder.targetPosition)); }
public static ShiftCommand Remove(ShiftCommand previous) { return(new ShiftCommand(previous.command, previous.targetPosition, OUTSIDE_FEED)); }
public static ShiftCommand JumpRight(ShiftCommand previous) { return(new ShiftCommand(previous.command, previous.position + 1, previous.targetPosition + 1)); }
public static ShiftCommand Pickup(ShiftCommand previous) { return(new ShiftCommand(previous.command, previous.position, HELD)); }
public bool SameButShiftedRight(ShiftCommand other) { return(command == other.command && other.targetPosition == position); }
public bool SameButPickedUp(ShiftCommand other) { return(command == other.command && other.targetPosition == HELD && position == other.position); }
public void SetInPlay(ShiftCommand command, Sprite sprite) { image.sprite = sprite; SetInPlay(command); }
private bool ParseLine() { //A Blank line in the source file if (_text.Length == 0) { _type = SourceLineType.BLANK; _instruction = ARMInstruction.NOP; return(true); } //Line is a comment if (_text[0] == ';') { _type = SourceLineType.COMMENT; _instruction = ARMInstruction.NOP; return(true); } //Remove any comments from the line string temp = _text; int commentStartIndex = _text.IndexOf(';'); if (commentStartIndex > 0) { temp = _text.Remove(commentStartIndex); } //Trim white space temp = temp.Trim(); //Split into fields delimited by whitespace string[] fields = temp.Split(new char[] { ' ', '\t' }); //Is the first field a directive, label, or instruction? // Refactor into bool isDirective(string) Array typeArray = Enum.GetValues(typeof(SourceLineType)); foreach (SourceLineType st in typeArray) { if (fields[0].Equals(st.ToString())) { _type = st; _label = st.ToString(); _instruction = ARMInstruction.NOP; //Ignore any text following a directive to the assembler return(true); } } //MOV has 3 fields at this point: //MOV //R1,R1,LSL //#0x1 //Only one field, not a directive so must be a label if (fields.Length == 1) { _label = fields[0]; _type = SourceLineType.LABEL; _instruction = ARMInstruction.NOP; return(true); } //If there are 3 fields, the first must be a label, the second the instruction //and third operands, or theres is no label and a shift in the second field bool shiftOperation = false; foreach (string cmd in Enum.GetNames(typeof(ShiftCommand))) { if (fields[1].Contains(cmd)) { shiftOperation = true; break; } } int instructionIndex = 0; int operandIndex = 0; int shiftAmountIndex = 0; if (shiftOperation == true) { instructionIndex = 0; operandIndex = 1; shiftAmountIndex = 2; } else { //If there are 2 fields, the first must be the instruction and the second the operand //int labelIndex = fields.Length > 2 ? 0 : -1; instructionIndex = fields.Length > 2 ? 1 : 0; operandIndex = fields.Length > 2 ? 2 : 1; } //Store the label if present if ((fields.Length > 2) && (shiftOperation == false)) { _label = fields[0]; } //Instruction field contains instruction, condition code and set flags, or variable type bool foundInstruction = false; Array opArray = Enum.GetValues(typeof(ARMInstruction)); foreach (ARMInstruction op in opArray) { if (fields[instructionIndex].StartsWith(op.ToString())) { _type = SourceLineType.CODE; _instruction = op; foundInstruction = true; break; } } if (foundInstruction) { int instrLength = _instruction.ToString().Length; int codeLength = fields[instructionIndex].Length - instrLength; switch (codeLength) { case 0: { //No Condition or set flags directive _code = ConditionCode.AL; _setFlags = false; break; } case 1: { //Must be Set Flags directive only if (fields[instructionIndex][instrLength + 1] == 'S') { _setFlags = true; } else { //Single character should only be S - all condition codes are two characters _setFlags = false; return(false); } _code = ConditionCode.AL; break; } case 2: { //Must be a condition code only string codeString = fields[instructionIndex].Substring(instrLength, 2); Array ccArray = Enum.GetValues(typeof(ConditionCode)); foreach (ConditionCode cc in ccArray) { if (codeString.Equals(cc.ToString())) { _code = cc; break; } } _setFlags = false; break; } case 3: { //Must be a condition code then set flags string codeString = fields[instructionIndex].Substring(instrLength, 2); Array ccArray = Enum.GetValues(typeof(ConditionCode)); foreach (ConditionCode cc in ccArray) { if (codeString.Equals(cc.ToString())) { _code = cc; break; } } if (fields[instructionIndex][instrLength + 2] == 'S') { _setFlags = true; } else { //Character following condition code must only be S _setFlags = false; return(false); } break; } default: { //Invalid characters following instruction _setFlags = false; return(false); } } } else { //Not directive, label or instruction. Should be a variable definition. Array vtArray = Enum.GetValues(typeof(VariableType)); foreach (VariableType vt in vtArray) { if (fields[instructionIndex].Equals(vt.ToString())) { _type = SourceLineType.VARIABLE; _instruction = ARMInstruction.NOP; _code = ConditionCode.AL; _setFlags = false; } } } //Final field contains operands, split by commas string[] operands = fields[operandIndex].Split(new char[] { ',' }); //For a variable definition, store first operand only for now if (_type == SourceLineType.VARIABLE) { //Variable definitions typically have one operand, but some may have two to //perform operations with 64bit numbers //The type of the value to be assigned to the variable System.Globalization.NumberStyles type = System.Globalization.NumberStyles.HexNumber; string tempVar = operands[0]; if (tempVar[0] == '&') { type = System.Globalization.NumberStyles.HexNumber; tempVar = tempVar.Remove(0, 1); } else if (tempVar[0] == '#') { type = System.Globalization.NumberStyles.Number; tempVar = tempVar.Remove(0, 1); } else if (tempVar.StartsWith("0x")) { type = System.Globalization.NumberStyles.HexNumber; tempVar = tempVar.Remove(0, 2); } else { type = System.Globalization.NumberStyles.Number; } //temp now contains only a value, hex or decimal _variable = UInt32.Parse(tempVar, type); //Call the manager to add this to the memory representation Manager.GetInstance().AddData(_label, _variable); } else { //Operands are for an instruction //SWI &11 Op1 if (operands.Length == 1) { //Also check for B, BL offset values if (_instruction == ARMInstruction.SWI) { string val = operands[0]; //Remove '&' _Op1 = val.Remove(0, 1); } if (_instruction == ARMInstruction.B) { //store label to branch to if condition met _Op1 = operands[0]; } } else if (operands.Length == 2) { if (_instruction == ARMInstruction.CMP) { string val = operands[0]; //Remove 'R' val = val.Remove(0, 1); _Rn = Int32.Parse(val, System.Globalization.NumberStyles.Number); } else { //First operand is always Rd (destination register) string val = operands[0]; //Remove 'R' val = val.Remove(0, 1); _Rd = Int32.Parse(val, System.Globalization.NumberStyles.Number); } //Second operand will be stored in Op1 or Op2 //LDR R1,Value1 Rd, Op2 //LDR R2,Value1 Rd, Op2 //STR R1,Result Rd, Op2 if (_instruction == ARMInstruction.LDR || _instruction == ARMInstruction.STR) { //Store label for op2 _Op2 = operands[1]; } //MOV R1, R1 Rd, Op1 (register) //MOV R1, #1234 Rd, Op1 (immediate) //MVN R1, R1 Rd, Op1 (register) //CMP R1, R2 Rn, Op1 (register) else { //Need to store indication of register or immediate for analysis at run-time _Op1 = operands[1]; } } else { //First operand is always Rd (destination register) string val = operands[0]; //Remove 'R' val = val.Remove(0, 1); _Rd = Int32.Parse(val, System.Globalization.NumberStyles.Number); //ADD R1,R1,R2 Rd, Rn, Op1 if (_instruction == ARMInstruction.ADD) { string rnVal = operands[1]; rnVal = rnVal.Remove(0, 1); _Rn = Int32.Parse(rnVal, System.Globalization.NumberStyles.Number); //Need to store indication of register or immediate for analysis at run-time _Op1 = operands[2]; } //MOV R1,R1,LSL #0x1 Rd,Op1 //MOV R1,R1,LSL R2 Rd,Op1 //Shift by amount in R2 if (_instruction == ARMInstruction.MOV) { //MOV with 3 operands - must be a shift //shift op1 by the method in op2 by the amount in field[shiftIndex] _shift = true; //Destination Always a register - remove R indicator //Register contains the number that we want to shift string shiftRegVal = operands[1]; shiftRegVal = shiftRegVal.Remove(0, 1); _shiftRegister = Int32.Parse(shiftRegVal, System.Globalization.NumberStyles.Number); //Operand 2 contains the type of shift _shiftType = (ShiftCommand)Enum.Parse(typeof(ShiftCommand), operands[2]); //Shift amount immediate (&,# or register?) System.Globalization.NumberStyles type = System.Globalization.NumberStyles.HexNumber; string tempVar = fields[shiftAmountIndex]; if (tempVar[0] == '&') { type = System.Globalization.NumberStyles.HexNumber; tempVar = tempVar.Remove(0, 1); } else if (tempVar[0] == '#') { if (fields[shiftAmountIndex].StartsWith("#0x")) { type = System.Globalization.NumberStyles.HexNumber; tempVar = tempVar.Remove(0, 3); } else { type = System.Globalization.NumberStyles.Number; tempVar = tempVar.Remove(0, 1); } } else { type = System.Globalization.NumberStyles.Number; } //temp now contains only a value, hex or decimal _shiftAmount = Int32.Parse(tempVar, type); //Store shifter operand - if register then we use this value, otherwise use immediate value //stored in shiftAmount _Op1 = fields[shiftAmountIndex]; } //Need special case for SWP - uses Rm, Rd, Rn... } } return(true); }
public ShiftTableDefinition Add(ShiftCommand command) => new ShiftTableDefinition(base.Content.Union(new[] {command}));
private void RemoteController_OnSyncCommands(List <ShiftCommand> commands, ShiftCommand held) { int idC = 0; int lC = commands.Count; for (int idF = 0, lF = feed.Count; idF < lF; idF++) { var command = commands[idC]; var card = feed[idF]; // Card is where it should be, nothing to do if (card.shiftCommand.SameAs(command)) { idC++; continue; } // Card has moved leftward if (card.shiftCommand.SameButShiftedLeft(command)) { card.ShiftLeft(command); idC++; continue; } // Card needs to shift rightward if (card.shiftCommand.SameButShiftedRight(command)) { card.ShiftRight(command); idC++; continue; } // Card is picked up if (card.shiftCommand.SameButPickedUp(held)) { if (heldCard != null) { cardsNotInPlay.Add(heldCard); heldCard.NotInPlay(); } heldCard = card; feed.RemoveAt(idF); idF--; lF--; idC++; continue; } // Actually previously held card is now here if (heldCard != null && command.command == heldCard.shiftCommand.command) { heldCard.SetInPlay(command); feed.Insert(idF, heldCard); heldCard = null; lF++; continue; } // Remove card because not in play if (idF > 0) { Debug.LogWarning(string.Format("Lost track of UI Card {0}, this should not happen", card)); } card.NotInPlay(); cardsNotInPlay.Add(card); feed.RemoveAt(idF); idF--; lF--; continue; } if (idC != feed.Count) { Debug.LogWarning(string.Format("We have a gap in the feed, it should be {0} long, but is {1}", idC, feed.Count)); } // Fillout new cards while (idC < lC) { ShiftCommand command = commands[(int)idC]; if (!command.Empty) { var card = GetInactiveOrSpawn(); card.SetInPlay(command, cardSprites[(int)command.command]); feed.Add(card); } idC++; } //Deal with held card if (held.Empty && heldCard != null) { heldCard.NotInPlay(); cardsNotInPlay.Add(heldCard); heldCard = null; } else if (!held.Empty && heldCard != null && !held.SameAs(heldCard.shiftCommand)) { Debug.LogWarning(string.Format("Held card is wrong, this should not happen, expected {0}, but found {1} (updating)", held, heldCard.shiftCommand)); heldCard.SetInPlay(held, cardSprites[(int)held.command]); } }
public ShiftTableDefinition TryAdd(CoreTransition transition, IDictionary<Core, int> coreToIndex) => transition.Symbol is Terminal ? this.Add(ShiftCommand.Of(transition, coreToIndex)) : this;
public bool SameButShiftedLeft(ShiftCommand other) { return(command == other.command && targetPosition == other.position); }
private void opMov(int rd, string op1, bool shift, int shiftAmount, ShiftCommand shiftType, int shiftRegister) { if (shift == false) { //Rd <--- Op1 //Check op1 is reg or immediate or label... if (op1[0].Equals('R')) { string val = op1.Remove(0, 1); _registers[rd] = _registers[Int32.Parse(val)]; if (RegisterUpdated != null) { RegisterUpdated(rd); } } else { //assume is '#' - base 10 number string val = op1.Remove(0, 1); _registers[rd] = UInt32.Parse(val); if (RegisterUpdated != null) { RegisterUpdated(rd); } } } else { //If Shift Register, then set shift _bs.B to amount in register if (op1[0].Equals('R')) { string val = op1.Remove(0, 1); _bs.B = (int)_registers[Int32.Parse(val)]; } else { //Immediate - use shiftAmount already set _bs.B = shiftAmount; } //Put values in barrel shifter _bs.A = _registers[shiftRegister]; ///TODO: Animation from register to ALU _bs.Command = shiftType; //Perform the Shift... _bs.Calculate(); //Copy result into destination register - other registers reamin unchanged if (RegisterChangedFromBsResult != null) { RegisterChangedFromBsResult(rd); } _registers[rd] = _bs.Result; if (RegisterUpdated != null) { RegisterUpdated(rd); } } }