public ControlPage()
{
this.InitializeComponent();
turn = Turn.none;
direction = Direction.none;
accelerometer = App.accelerometer;
bluetooth = App.bluetooth;
arduino = App.arduino;
if (accelerometer == null || bluetooth == null || arduino == null)
{
Frame.Navigate(typeof(MainPage));
return;
}
startButton.IsEnabled = true;
stopButton.IsEnabled = true;
disconnectButton.IsEnabled = true;
keepScreenOnRequest = new DisplayRequest();
keepScreenOnRequest.RequestActive();
App.arduino.pinMode(enableA, PinMode.OUTPUT);
App.arduino.pinMode(MotorA1, PinMode.OUTPUT);
App.arduino.pinMode(MotorA2, PinMode.OUTPUT);
App.arduino.pinMode(enableB, PinMode.OUTPUT);
App.arduino.pinMode(MotorB1, PinMode.OUTPUT);
App.arduino.pinMode(MotorB2, PinMode.OUTPUT);
arduino.digitalWrite(enableA, PinState.HIGH);
arduino.digitalWrite(enableB, PinState.HIGH);
}
public Category(string title, IRule rule, Turn turn, Dice dice)
{
Title = title;
_rule = rule;
_turn = turn;
_dice = dice;
}
public void AddTurn(Turn _turn)
{
if (m_trns == null) {
m_trns = new List<Turn> ();
}
m_trns.Add (_turn);
}
public Connect4Board()
{
columns = new Connect4Column[COLUMNS];
for (int i = 0; i < columns.Length; i++)
columns[i] = new Connect4Column();
turn = Turn.NOT_IN_SESSION;
}
public void SetUp()
{
_turn = Substitute.For<Turn>();
_dice = Substitute.For<Dice>();
_onesRule = Substitute.For<IRule>();
_category = new Category("Ones", _onesRule, _turn, _dice);
}
public DefaultMoveExecutor(string board, string newMove, Turn turn,
GameState gameState, string whiteKingPosition, string blackKingPosition, string lastMove,
bool whiteCanCastleKingSide, bool whiteCanCastleQueenSide, bool blackCanCastleKingSide,
bool blackCanCastleQueenSide)
{
FieldPosition whiteKing = FieldPosition.ParsePosition(whiteKingPosition);
FieldPosition blackKing = FieldPosition.ParsePosition(blackKingPosition);
this.oldState = new BoardModel(GetBoard(board), turn, gameState, whiteKing, blackKing,
whiteCanCastleKingSide, whiteCanCastleQueenSide, blackCanCastleKingSide, blackCanCastleQueenSide);
this.newState = new BoardModel(GetBoard(board), turn, gameState, whiteKing, blackKing,
whiteCanCastleKingSide, whiteCanCastleQueenSide, blackCanCastleKingSide, blackCanCastleQueenSide);
// Parse new move
string[] splt = newMove.Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
this.source = FieldPosition.ParsePosition(splt[0]);
this.dest = FieldPosition.ParsePosition(splt[1]);
if (lastMove != null)
{
// Parse last move
splt = lastMove.Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
this.lastMoveSource = FieldPosition.ParsePosition(splt[0]);
this.lastMoveDest = FieldPosition.ParsePosition(splt[1]);
}
this.sourcePiece = this.newState.Board[source.Row, source.Col];
}
public ControlPage()
{
this.InitializeComponent();
turn = Turn.none;
direction = Direction.none;
accelerometer = App.accelerometer;
bluetooth = App.bluetooth;
arduino = App.arduino;
if( accelerometer == null || bluetooth == null || arduino == null )
{
Frame.Navigate( typeof( MainPage ) );
return;
}
startButton.IsEnabled = true;
stopButton.IsEnabled = true;
disconnectButton.IsEnabled = true;
bluetooth.ConnectionLost += Bluetooth_ConnectionLost;
keepScreenOnRequest = new DisplayRequest();
keepScreenOnRequest.RequestActive();
App.arduino.pinMode( LR_DIRECTION_CONTROL_PIN, PinMode.OUTPUT );
App.arduino.pinMode( FB_DIRECTION_CONTROL_PIN, PinMode.OUTPUT );
App.arduino.pinMode( LR_MOTOR_CONTROL_PIN, PinMode.PWM );
App.arduino.pinMode( FB_MOTOR_CONTROL_PIN, PinMode.PWM );
App.arduino.pinMode(HEARTBEAT_LED_PIN, PinMode.OUTPUT);
}
void Start () {
runeBucket = new List<Rune>();
currentEffects = new List<StatusEffect>();
turn = new Turn();
animator = GetComponent<Animator>();
sprRend = GetComponent<SpriteRenderer>();
}
public void TurnCleanup() {
turn = new Turn();
currentEffects.Remove(StatusEffect.Confuse);
currentEffects.Remove(StatusEffect.Paralyse);
currentEffects.Remove(StatusEffect.Shield);
}
public GoldRush()
{
m_currentTurn = Turn.Start;
m_numbersLeft = new List<short>[3];
m_board = new short[Players, N];
for (int i = 0; i < Players; i++)
{
m_numbersLeft[i] = new List<short>();
}
for (short i = 1; i <= N; i++)
{
m_numbersLeft[User].Add(i);
m_numbersLeft[Opponent].Add(i);
m_numbersLeft[Computer].Add(i);
}
m_history = new Dictionary<string, List<short[]>>();
m_guaranteedPerson = new List<string>();
m_dateToPlayers = new Dictionary<DateTime, List<string>>();
m_isGuaranteedPerson = false;
m_joinDate = DateTime.MinValue;
Load();
// OptimalBet();
Go();
}
private static void BerzerkMovement(Turn gameLogTurn, int distance, Combatant active,
int speedNotFiring, int speedFiring, int direction, int enemyPos, int oldPos)
{
if (distance > 0)
{
// run to enemy!
gameLogTurn.Movement.Add(new Phase { Actor = active.Template, Message = active.Name + " runs towards the enemy in blind fury!", Relevance = Relevance.Medium, Icon = moveIcon});
var movement = speedNotFiring*direction;
int newPos = active.Position + (movement <= distance ? movement : distance);
if (newPos == enemyPos)
{
gameLogTurn.Movement.Add(new Phase { Actor = active.Template, Message = active.Name + " enters close combat!", Relevance = Relevance.High, Icon = chargeIcon });
active.Melee = true;
}
if (speedFiring <= Math.Abs(oldPos - newPos))
active.CanFire = true;
else
active.CanFire = false;
active.Position = newPos;
}
else
{
gameLogTurn.Movement.Add(new Phase { Actor = active.Template, Message = active.Name + " hurls himself into the melee!", Relevance = Relevance.Medium, Icon = chargeIcon });
active.CanFire = true;
}
}
public ControlPageMaisto()
{
this.InitializeComponent();
turn = Turn.none;
direction = Direction.none;
accelerometer = App.accelerometer;
bluetooth = App.bluetooth;
arduino = App.arduino;
if( accelerometer == null || bluetooth == null || arduino == null )
{
Frame.Navigate( typeof( MainPage ) );
return;
}
startButton.IsEnabled = true;
stopButton.IsEnabled = true;
disconnectButton.IsEnabled = true;
bluetooth.ConnectionLost += Bluetooth_ConnectionLost;
keepScreenOnRequest = new DisplayRequest();
keepScreenOnRequest.RequestActive();
App.arduino.pinMode( FORWARD_CONTROL_PIN, PinMode.OUTPUT );
App.arduino.pinMode( REVERSE_CONTROL_PIN, PinMode.OUTPUT );
App.arduino.pinMode( LEFT_CONTROL_PIN, PinMode.OUTPUT );
App.arduino.pinMode( RIGHT_CONTROL_PIN, PinMode.OUTPUT );
}
private static bool CheckForPairs(Turn thisGame)
{
var isPairs = false;
var firstValue = thisGame.CurrentDice[0].Value;
var quantityOfFirstValue = CountQuantityOfAValue(firstValue, thisGame);
var secondValue = firstValue;
var i = 0;
while (firstValue == secondValue && i < 6)
{
secondValue = thisGame.CurrentDice[i].Value;
i++;
}
var quantityOfSecondValue = CountQuantityOfAValue(secondValue, thisGame);
var thirdValue = firstValue;
var quantityOfThirdValue = 0;
i = 0;
while ((firstValue == thirdValue || secondValue == thirdValue) && i < 6)
{
thirdValue = thisGame.CurrentDice[i].Value;
i++;
}
if (i != 7)
quantityOfThirdValue = CountQuantityOfAValue(thirdValue, thisGame);
if (quantityOfFirstValue == 2 && quantityOfSecondValue == 2 && quantityOfThirdValue == 2)
isPairs = true;
return isPairs;
}
internal GlobalBoardTurn(Turn turn, Card draw)
{
PlayCard = turn.Card;
PlayIsDiscard = turn.Discard;
DrawCard = draw;
DrawLocation = turn.Draw;
}
void SetActionToFree()
{
actionTurn = Turn.free;
if(FreeAction != null){
FreeAction();
}
}
public void ExpectCanExecuteAlwaysFalseIfIfTurnNotStarted(GameCommand command)
{
var player = new Mock<IPlayer>();
var provider = new Mock<IStateProvider>();
var turn = new Turn(player.Object, provider.Object);
Assert.False(turn.CanExecute(command));
}
public TimerEventArgs(int seconds, int playerSeconds, int opponentSeconds, bool running, Turn turn)
{
Seconds = seconds;
Running = running;
PlayerSeconds = playerSeconds;
OpponentSeconds = opponentSeconds;
CurrentTurn = turn;
}
public void CreateTurnTest()
{
var player = new Mock<IPlayer>();
var provider = new Mock<IStateProvider>();
var turn = new Turn(player.Object, provider.Object);
Assert.Equal(player.Object, turn.Player);
}
private static bool CheckForSingles(Turn thisGame)
{
for (var i = 0; i < 6; i++)
if (thisGame.CurrentDice[i].State.Equals(DieState.Unclicked)
&& (thisGame.CurrentDice[i].Value == 1 || thisGame.CurrentDice[i].Value == 5))
return true;
return false;
}
// Use this for initialization
void Start()
{
Pturn = true;
AIturn = false;
instance = this;
endgamecanvas = GameObject.Find ("WinnerCanvas");
endgamecanvas.GetComponent<Canvas> ().enabled=false;
}
protected BaseSolver Add(Turn turn, string description = null)
{
if (description != null)
{
this.Description.Add(description);
}
this.Turns.Add(turn);
return this;
}
public void Init () {
level = new Level();
level.Init();
player = new Player();
player.pos = level.playerTile;
player.rotation = level.playerRotation;
turn = Turn.None;
enemies = new List<Enemy>();
}
public void NextTurn () {
if (turn == Turn.Player) {
turn = Turn.Enemies;
TakeEnemyTurns();
} else {
turn = Turn.Player;
player.NewTurn();
}
}
public static void endPlayerTurn()
{
current_turn = Turn.Enemy;
// entityManagerS.getMech().current_ap = entityManagerS.getMech().max_ap;
entityManagerS.getMech().destroySelectionHexes();
entityManagerS.getMech().allowSelectionHexesDraw();
enemy_enumerator = entityManagerS.getEnemies().GetEnumerator();
entityManagerS.getMech().current_ap = 0;
}
void nextTurn()
{
//restore all moved/used units to their prior colors.
Recolor();
//swap turns
turn = (turn == Turn.PLAYER) ? Turn.ENEMY : Turn.PLAYER;
turnDisplayScript.updateTurn(turn == Turn.PLAYER ? 0 : 1);
if (turn == Turn.PLAYER) nextRound(); //this should always be true. if we have first changed turns, and now are on the (primary) player's turn again, then we have completed a round.
//maybe do some graphical stuff here.
}
//-----END OF CONSTRUCTORS-----
//-----START OF MUTATOR METHODS-----
public void AddTurn(Turn newTurn)
{
int i = 0;
for (; i < turns.Count && newTurn.GetTime() < turns[i].GetTime(); i++)
{
//Most of the logic of incrementation and whatnot is done by the for above.
}
turns.Insert(i, newTurn);
}
// Update is called once per frame
void Update()
{
if(bIsFirstUpdate)
{
Player = GameObject.FindGameObjectWithTag("Player") as GameObject;
TheVoid = GameObject.FindGameObjectWithTag("TheVoid") as GameObject;
PlayerScript = Player.GetComponent<PlayerMovement>();
TheVoidScript = TheVoid.GetComponent<VoidAI>();
}
//print ("GameLoop UPDATE");
print ("Is Player Turn? : "+PlayerScript.GetIsPlayerTurn());
print ("Is Void's Turn? : "+TheVoidScript.GetIsVoidsTurn());
if(!PlayerScript.GetIsPlayerTurn() && !TheVoidScript.GetIsVoidsTurn())
{
//print ("+++++++++++++++++++++++VOID TURN++++++++++++++++++++++");
if(bIsFirstUpdate)
{
TheVoidScript.SetIsVoidsTurn(true);
bIsFirstUpdate=false;
lastTurn=Turn.VoidTurn;
}
else
if(lastTurn==Turn.VoidTurn)
{
print ("Player Turn");
//PASSE LE TOUR AU JOUEUR
TheVoidScript.SetIsVoidsTurn(false);
PlayerScript.SetIsPlayerTurn(true);
lastTurn=Turn.PlayerTurn;
}
else
if(lastTurn==Turn.PlayerTurn)
{
print ("Void Turn");
//PASSE LE TOUR A L'ENNEMI
TheVoidScript.SetIsVoidsTurn(true);
PlayerScript.SetIsPlayerTurn(false);
lastTurn=Turn.VoidTurn;
}
}
bHasPlayerWon=PlayerScript.GetHasWon();
bHasTheVoidWon=TheVoidScript.GetHasWon();
if(bHasPlayerWon || bHasTheVoidWon)
{
print ("============------------+++++++++GAME OVER+++++++++------------================");
Application.LoadLevel("gameOver");
}
}
public static Turn StringToTurn( string str)
{
//TODO...
// Debug.Log("Turn: string recieved: "+str);
Turn ret = new Turn();
string[] splitStr = str.Split(';');
foreach( string s in splitStr){
ret.Add(Order.StringToOrder(s));
}
return ret;
}
public BandController( RemoteDevice device ) : base( device )
{
connected = false;
turn = Turn.none;
direction = Direction.none;
Device.pinMode( LR_DIRECTION_CONTROL_PIN, PinMode.OUTPUT );
Device.pinMode( FB_DIRECTION_CONTROL_PIN, PinMode.OUTPUT );
device.pinMode( LR_MOTOR_CONTROL_PIN, PinMode.PWM );
device.pinMode( FB_MOTOR_CONTROL_PIN, PinMode.PWM );
}
public static bool CheckIfThereIsSomethingToScore(Turn thisGame)
{
if (NumberToBeChecked(thisGame) == 6)
{
if (CheckForSixOfAKind(thisGame) || CheckForPairs(thisGame) || CheckForRunOfSix(thisGame))
return true;
}
if (NumberToBeChecked(thisGame) >= 3)
if (CheckForThreeOfAKind(thisGame))
return true;
return CheckForSingles(thisGame);
}
public void It_Should_ReturnScoreForPairs_When_PlacedOnPairs_And_PairsIsValid()
{
//Arrange
var fiveMockDice = new List <IDie>
{
new EchoDie(1),
new EchoDie(1),
new EchoDie(2),
new EchoDie(3),
new EchoDie(4),
};
var turn = new Turn(fiveMockDice);
//turn.RollDice();
var scoreCard = new ScoreCard();
//Act
scoreCard.UpdateScoreCard(ScoreCategory.Pairs, turn.Dice);
//Assert
Assert.Equal(2, scoreCard.Total);
}
public LevelWithTurns(string[] words, int numberOfTurns, float time)
{
if (numberOfTurns <= 0)
{
throw new System.ArgumentOutOfRangeException(numberOfTurns + " is out of range.");
}
if (time <= 0.0f)
{
throw new System.ArgumentOutOfRangeException(time + " is out of range.");
}
turns = new Turn[numberOfTurns];
for (int i = 0; i < numberOfTurns; i++)
{
turns[i] = new Turn(words[i]);
}
indexCurrentTurn = 0;
this.time = time;
currentTurnTimeLeft = time;
}
public void It_Should_ReturnFiveValues_When_DiceAreRolled()
{
//arrange
var fiveMockDice = new List <IDie>
{
new RandomDie(),
new RandomDie(),
new RandomDie(),
new RandomDie(),
new RandomDie(),
};
var turn = new Turn(fiveMockDice);
//act
turn.RollDice();
//assert
foreach (var die in turn.Dice)
{
Assert.NotEqual(0, die.Value);
}
}
public static Turn Update(Turn turn, IPlayer blackPlayer, IPlayer whitePlayer, List <Step> steps)
{
if (steps.Count == 0)
{
if (turn == Turn.Black)
{
if (whitePlayer.PlayerState == PlayerState.Blocked)
{
turn = Turn.Black;
}
turn = Turn.White;
}
else// white turn
{
if (blackPlayer.PlayerState == PlayerState.Blocked)
{
turn = Turn.White;
}
turn = Turn.Black;
}
}
return(turn);
}
public static Step ConvertToStep(int slotIdSource, int slotIdDestination, Turn turn)
{
if (turn == Turn.White)
{
if (slotIdSource == int.MinValue)
{
slotIdSource = RulesContainer.FinishedSlotBlack;
}
return(new Step {
Value = slotIdDestination - slotIdSource
});
}
else // black turn
{
if (slotIdSource == int.MinValue)
{
slotIdSource = RulesContainer.FinishedSlotWhite;
}
return(new Step {
Value = slotIdSource - slotIdDestination
});
}
}
//↑
//↓创建棋子，被此脚本中Update ()调用
public void CreateChess(int i, int j, Turn which)
{
Last_x[Lasts] = i;
Last_y[Lasts] = j;
Lasts += 1;
CHess_UIM.ChessNumber = Lasts;
D_Time = 20;
StopDJS(true, true);
if (which == Turn.white)
{
Whites[Whites_i] = (GameObject)GameObject.Instantiate(White, new Vector3(ChessPos[i, j].x, ChessPos[i, j].y, -0.5f), White.transform.rotation);
Whites_i += 1;
chessTurn = Turn.black;
CHess_UIM.AddChessRoad(i, j, "白");
}
else if (which == Turn.black)
{
Blacks[Blacks_i] = (GameObject)GameObject.Instantiate(Black, new Vector3(ChessPos[i, j].x, ChessPos[i, j].y, -0.5f), Black.transform.rotation);
Blacks_i += 1;
chessTurn = Turn.white;
CHess_UIM.AddChessRoad(i, j, "黑");
}
}
protected virtual void FinishTurn()
{
if (currentTurn.objectivesFilled.Count > 0)
{
if (NotifyObjectivesFilled != null)
{
NotifyObjectivesFilled.Invoke(currentTurn.objectivesFilled);
}
// Not listened at the moment. Could replace the commands way
//else
// Debug.LogError("This should be listened to");
}
if (state == State.PLAYING_TURN && currentTurn.WasUseful())
{
history.Push(currentTurn);
}
state = State.IDLE;
currentTurn = null;
if (!CheckLevelFinished() && inputs.Count > 0)
{
ExecuteCommand(inputs.Dequeue());
}
}
public void It_Should_Return_SumOfFours_When_PlacedOnFours_And_GivenFours()
{
//Arrange
var fiveMockDice = new List <IDie>
{
new EchoDie(1),
new EchoDie(1),
new EchoDie(2),
new EchoDie(4),
new EchoDie(4),
};
var turn = new Turn(fiveMockDice);
turn.RollDice();
//Act
var foursCalculator = CategoryCalculatorFactory.CreateCalculator(ScoreCategory.Fours, turn.Dice);
//Assert
Assert.Equal(8, foursCalculator.Calculate());
}
IEnumerator displayDialog()
{
while (dialogueGenerator.hasNextOutput())
{
Turn turn = dialogueGenerator.getOutput();
string utterance = turn.utterance;
utterance = utterance.Replace("<agent1>", agent1.gameObject.GetComponent <AgentScript>().name);
utterance = utterance.Replace("<agent2>", agent2.gameObject.GetComponent <AgentScript>().name);
if ((string)(turn.participant) == "<agent1>")
{
agent1.gameObject.GetComponent <AgentScript>().SetCurrentPhrase(utterance);
agent2.gameObject.GetComponent <AgentScript>().SetCurrentPhrase("");
}
else
{
agent1.gameObject.GetComponent <AgentScript>().SetCurrentPhrase("");
agent2.gameObject.GetComponent <AgentScript>().SetCurrentPhrase(utterance);
}
yield return(new WaitForSeconds(turnTime));
}
agent1.gameObject.GetComponent <AgentScript>().SetCurrentPhrase("");
agent2.gameObject.GetComponent <AgentScript>().SetCurrentPhrase("");
}
private void AddToGreen()
{
if (_inputValue == -1)
{
return;
}
var turn = new Turn();
if (Settings.Instance.ColorScheme.RightToLeft)
{
turn.PointsRight = Convert.ToByte(_inputValue);
}
else
{
turn.PointsLeft = Convert.ToByte(_inputValue);
}
this.Match.AddTurn(turn);
_inputValue = -1;
}
private void OnEnterTurn(Turn oldturn, Turn newturn)
{
switch (newturn)
{
case Turn.Invalid:
break;
case Turn.Attacker:
{
m_attackerTeam.DoAttack();
}
break;
case Turn.Defender:
{
m_defenderTeam.DoAttack();
}
break;
default:
break;
}
}
public BoardState Apply(BoardState state, Turn turn)
{
if (turn is Move move)
{
var(f, c) = state[move.From] ?? throw new UserError($"There are no figure at {move.From}");
if (move.From == move.To)
{
throw new RuleViolationError(new RuleViolation("Figure can't move to the same cell"));
}
state = state.Without(move.From);
if (state[move.To].HasValue)
{
state = state.Without(move.To);
}
return(state.With(f, c, move.To));
}
throw new NotSupportedException();
}
public IPlayer NextTurn()
{
switch (_playerTurnAction)
{
case Turn.None:
_playerTurnAction = Turn.Roll;
break;
case Turn.Roll:
_playerTurnAction = Turn.Advance;
break;
case Turn.Advance:
_playerTurn = (_playerTurn + 1) % _players.Count();
_playerTurnAction = Turn.Roll;
break;
default:
throw new Exception("Unknown turn");
}
return(_players.ElementAt(_playerTurn));
}
public async Task ExecuteTurn(Turn turn)
{
Debug.Log($"Executando o turno de {BattlerName}.");
if (turn == null)
{
return;
}
if (turn.Skill.ApCost > CurrentAp)
{
Debug.LogError(
$"{BattlerName} tentou usar uma skill com custo maior que o EP Atual. SkillName: {turn.Skill.SkillName}, SkillCost: {turn.Skill.ApCost}, CurrentAp: {CurrentAp}");
}
CurrentAp -= turn.Skill.ApCost;
QueueAction(() => { BattleController.Instance.battleCanvas.battleInfoPanel.ShowInfo(turn.Skill.SkillName); });
await AnimateTurn(turn);
QueueAction(() => { BattleController.Instance.battleCanvas.battleInfoPanel.HideInfo(); });
}
public void Calculate()
{
int index = 0;
int count = vertices.Count;
Direction turn;
for (index = 0; index < count - 1; index++)
{
try
{
turn = Turn.GetDirection(vertices[index - 1], vertices[index], vertices[index + 1]);
}
catch
{
turn = Direction.FORWARD;
}
if (!withPrepend || index > 0)
{
waypoints.AddRange(new Segment(vertices[index], vertices[index + 1], turn).GetPath());
}
}
}
public void NextTurn()
{
//Called By the Next Turn Button
if (currentTurn.Equals(Turn.team1))
{
team1Done = true;
currentTurn = Turn.team2;
}
else
{
team2Done = true;
currentTurn = Turn.team1;
}
if (team1Done && team2Done)
{
textUpdate.UpdateTurnCountText();
team1Done = false;
team2Done = false;
}
actionBlocked = false;
ResetHighLights();
gameState = GameState.startTurn;
}
public void NewTurn()
{
if (!Game.GetCities().Any(x => this == x.Owner) && !Game.Instance.GetUnits().Any(x => this == x.Owner))
{
GameTask.Enqueue(Turn.GameOver(this));
}
if (_anarchy == 0 && Government is Anarchy)
{
if (Human == Game.CurrentPlayer)
{
GameTask.Enqueue(Show.ChooseGovernment);
}
else
{
Government = new Despotism();
}
}
if (_anarchy > 0)
{
_anarchy--;
}
}
public TimeSpan isEmpty(DateTime time, int DoctorId, int TypeId, int clinicId)
{
List <Turn> list = context.Doctors.Include("Turns").Include("Turns.TurnType").FirstOrDefault(d => d.Id == DoctorId && d.ClinicId == clinicId).Turns.OrderBy(d => d.StartDate).ToList();
Turn next = list.Where(a => a.StartDate > time).FirstOrDefault();
if (list.Where(a => a.StartDate == time).FirstOrDefault() == null)
{
if (next == null || next.StartDate >= time + context.TurnTypes.FirstOrDefault(t => t.Id == TypeId).Duration)
{
return(new TimeSpan());
}
else
{
TimeSpan distance;
distance = next.StartDate - time + next.TurnType.Duration;
return(distance);
}
}
else
{
return(list.Where(a => a.StartDate == time).FirstOrDefault().TurnType.Duration);
}
}
public void ConfirmTurnAlreadyConfirmed()
{
var returnTurn = new Turn(It.IsAny <Guid>(), It.IsAny <DateTime>(), It.IsAny <string>(), new List <int>())
{
Confirmed = true
};
var model = new ConfirmTurnModel()
{
TurnId = Guid.NewGuid()
};
_turnRepo.Setup(x => x.Get(It.IsAny <Guid>()))
.Returns(returnTurn)
.Verifiable();
//_turnRepo.Setup(x => x.Update(It.Is<Turn>(t => t.Confirmed == true)))
// .Verifiable();
//_uow.Setup(x => x.Save()).Verifiable();
Assert.Throws <TurnExceptionAlreadyEXist>(() => _service.Execute(model));
_turnRepo.VerifyAll();
_uow.VerifyAll();
}
private async void CompDrawAsync(object obj, Turn first)
{
MyPictureBox compClicked = obj as MyPictureBox;
await Task.Delay(1000);
if (first == Turn.Human)
{
for (int i = 0; i < 12; i++)
{
Invoke(new Action(() => compClicked.Image = imageCircle[i]));
await Task.Delay(50);
}
}
else
{
for (int i = 0; i < 12; i++)
{
Invoke(new Action(() => compClicked.Image = imageCross[i]));
await Task.Delay(50);
}
}
}
private static double GetAlternativeMatchScore(Turn eTurn, IList <ComparableItem> arComparableItemsA, IList <ComparableItem> arComparableItemsB, int iIndexInA, int iIncrementA, int iIndexInB, int iIncrementB)
/* suppose we find a similar element. are we sure this is the right one ? maybe the similarity is a chance similarity and doesn't originate from a common ancestor ?*/
/* so here is the part where we try to match the forced matched element with its best match in its vicinity*/
{
double dScore = 0;
int ii = 0;
if (eTurn == Turn.A)
{
for (ii = 0; ii < iIncrementB + 100 && ii + iIndexInA < arComparableItemsA.Count; ii++)
{
dScore = Math.Max(dScore, GetMatchScore(arComparableItemsA[ii].Node, arComparableItemsB[iIndexInB + iIncrementB].Node));
}
}
else if (eTurn == Turn.B)
{
for (ii = 0; ii < iIncrementA + 100 && ii + iIndexInB < arComparableItemsB.Count; ii++)
{
dScore = Math.Max(dScore, GetMatchScore(arComparableItemsA[iIndexInA + iIncrementA].Node, arComparableItemsB[ii].Node));
}
}
return(dScore);
}
// Updates the score, determines the trick winner, updates
// the states for the next trick, hides the played cards and
// deals a new card each.
private IEnumerator EndTrick()
{
yield return(new WaitForSeconds(endTrickWaitTime));
int trickPoints = GetTrickPoints();
int newScore = int.Parse(scoreDisplay.text) + trickPoints;
scoreDisplay.text = newScore.ToString();
bool playerWon = DidPlayerWin();
HideMovedCards();
if (!deck.IsEmpty())
{
DealCardEach(playerWon);
}
if (!playerHand.IsEmpty())
{
SetTurnOrder(playerWon);
}
refState = Turn.Finish;
}
/// <summary>
/// Called when a unit is destroyed to remove it from the turn list.
/// </summary>
/// <param name="unit">The unit that has been destroyed.</param>
public void UnitDestroyed(BattleUnit unit)
{
_livingUnits.Remove(unit);
Turn deadTurn = _turnOrder.FirstOrDefault(s => s.Unit == unit);
if (deadTurn != null)
{
Queue <Turn> restructure = new Queue <Turn>();
while (_turnOrder.Count > 0)
{
Turn turn = _turnOrder.Dequeue();
if (turn != deadTurn)
{
restructure.Enqueue(turn);
}
}
_turnOrder = restructure;
}
}
private void TimerTick(object sender, EventArgs e)
{
if (space == null)
{
return;
}
Turn control =
left
? Turn.Left
: right
? Turn.Right
: autopilotEnabled
? Autopilot(space.Rocket, space.Target)
: Turn.None;
space.Move(ClientRectangle, control);
if ((space.Rocket.Location - space.Target).Length < 40)
{
timer.Stop();
}
Invalidate();
Update();
}
private void selectAction()
{
if (Input.GetButtonDown("Horizontal"))
{
if (Input.GetAxis("Horizontal") > 0)
{
if (menuIndex == menuOptions.Length - 1)
{
menuIndex = 0;
}
else
{
menuIndex++;
}
}
else
{
if (menuIndex == 0)
{
menuIndex = menuOptions.Length - 1;
}
else
{
menuIndex--;
}
}
playSound(0);
}
else if (Input.GetKeyDown(KeyCode.X))
{
if (turn == Turn.P2Choice)
{
turn = Turn.P1Choice;
playSound(0);
}
}
}
private void setUp()
{
//Sets up the players and enemies
GameObject character1 = Instantiate(player1) as GameObject;
GameObject character2 = Instantiate(player2) as GameObject;
p1 = character1.GetComponent <Character> ();
p2 = character2.GetComponent <Character> ();
GameObject boss1 = Instantiate(bossObject) as GameObject;
boss = boss1.GetComponent <Enemy>();
boss.Slot = 1;
boss.setSlot();
boss.data().setMaxHealth(400);
boss.data().setAttack(50);
turnOrder = new GameObject[3];
//Manages enemy selection
selectedSlot = 0;
GameObject theCursor = Instantiate(cursor) as GameObject;
theCursor.GetComponent <Renderer>().enabled = false;
selector = theCursor.GetComponent <AnimationOffset>();
selector.setParent(boss.gameObject);
menuOptions = new string[4];
menuOptions[0] = "Attack";
menuOptions[1] = "Magic";
menuOptions[2] = "Items";
menuOptions[3] = "Flee";
menuIndex = 0;
turn = Turn.P1Choice;
nextTurn = Turn.P1Choice;
totalExpReward = 0;
}
/// <summary>
/// Шифр "Поворотная решетка".
/// </summary>
/// <param name="message"> Открытое сообщение. </param>
/// <param name="grid"> Трафарет. </param>
/// <param name="turn1"> Первый поворот. </param>
/// <param name="turn2"> Второй поворот. </param>
/// <param name="turn3"> Третий поворот. </param>
/// <param name="route"> Маршрут выписывания. </param>
/// <returns> Закрытое сообщение. </returns>
public static string RotaryGrid(string message, bool[,] grid, Turn turn1, Turn turn2, Turn turn3, Route route)
{
int n = grid.GetLength(0);
int m = grid.GetLength(1);
if (n * m < message.Length)
{
throw new ArgumentException("Недопустимый размер матрицы.");
}
message = message.Replace(' ', '_');
message = message.PadRight(n * m, '_');
char[,] table = new char[n, m];
int[] keyN = new int[n];
for (int i = 0; i < n; i++)
{
keyN[i] = n - i - 1;
}
int[] keyM = new int[m];
for (int i = 0; i < m; i++)
{
keyM[i] = m - i - 1;
}
table = InscribeWithGrid(table, grid, ref message);
grid = (turn1 == Turn.Vertically) ? PermutationTablesColumns(grid, keyM) :
PermutationTablesRows(grid, keyN);
table = InscribeWithGrid(table, grid, ref message);
grid = (turn2 == Turn.Vertically) ? PermutationTablesColumns(grid, keyM) :
PermutationTablesRows(grid, keyN);
table = InscribeWithGrid(table, grid, ref message);
grid = (turn3 == Turn.Vertically) ? PermutationTablesColumns(grid, keyM) :
PermutationTablesRows(grid, keyN);
table = InscribeWithGrid(table, grid, ref message);
return(GetStringFromTableByRoute(table, route));
}
/**
* Turns the wolf so now they are running in a new direction based on current inputs
* and the turnTrigger we're currently inside.
* @see Turn.cs for more information.
*/
private void turn()
{
if (turnTrigger == null)
{
Debug.LogWarning("A call to turn, but no turnTrigger object is set!");
return;
}
FacingDir newDirection = FacingDir.UP_RIGHT;
switch (facingDirection)
{
case FacingDir.UP_RIGHT: newDirection = leftPressed ? FacingDir.UP_LEFT : FacingDir.DOWN_RIGHT; break;
case FacingDir.UP_LEFT: newDirection = leftPressed ? FacingDir.DOWN_LEFT : FacingDir.UP_RIGHT; break;
case FacingDir.DOWN_RIGHT: newDirection = leftPressed ? FacingDir.UP_RIGHT : FacingDir.DOWN_LEFT; break;
case FacingDir.DOWN_LEFT: newDirection = leftPressed ? FacingDir.DOWN_RIGHT : FacingDir.UP_LEFT; break;
}
if (!turnTrigger.allowsDirection(newDirection))
{
return;
}
setFacingDirection(newDirection);
if (turnTrigger.centerOnTurn)
{
setPosition(turnTrigger.transform.position, true);
}
if (turnTrigger.onlyTurnOnce)
{
turnTrigger = null;
}
}
private void handleTurn(double lr)
{
//left and right turns work best using digital signals
if (lr < -LR_MAG)
{
//if we've switched directions, we need to be careful about how we switch
if (turn != Turn.left)
{
//make sure we aren't turning right
arduino.digitalWrite(RIGHT_CONTROL_PIN, PinState.LOW);
}
//start the motor by setting the pin high
arduino.digitalWrite(LEFT_CONTROL_PIN, PinState.HIGH);
turn = Turn.left;
}
else if (lr > LR_MAG)
{
if (turn != Turn.right)
{
//make sure we aren't turning left
arduino.digitalWrite(LEFT_CONTROL_PIN, PinState.LOW);
}
//start the motor by setting the pin high
arduino.digitalWrite(RIGHT_CONTROL_PIN, PinState.HIGH);
turn = Turn.right;
}
else
{
//stop any pins that may be high
arduino.digitalWrite(LEFT_CONTROL_PIN, PinState.LOW);
arduino.digitalWrite(RIGHT_CONTROL_PIN, PinState.LOW);
turn = Turn.none;
}
}
public void Input(string input, ulong userId = 1)
{
if (State != State.Active)
{
return;
}
LastPlayed = DateTime.Now;
int column = int.Parse(StripPrefix(input)) - 1;
if (!AvailableColumns(board).Contains(column))
{
return; // Column is full
}
DropPiece(board, column, Turn);
Time++;
if (FindWinner(board, Turn, Time, highlighted))
{
Winner = Turn;
}
else if (IsTie(board, Turn, Time))
{
Winner = Player.Tie;
}
if (Winner == Player.None)
{
Turn = Turn.OtherPlayer();
}
else
{
State = State.Completed;
Turn = Winner;
}
}
