public object Get(Do request)
{
var cached = Cache.Get <GameObject>(request.target);
var v = new Vector3(request.x, request.y, request.z);
var transform = default(MoveResponse);
bool move = request.action == "move";
Exec.OnMain(() =>
{
if (cached == null)
{
cached = GameObject.Find(request.target);
Cache.Set <GameObject>(request.target, cached);
Debug.Log("not cached");
}
if (move)
{
cached.transform.position = Vector3.MoveTowards(cached.transform.position, v, 0.1f);
}
transform = new MoveResponse
{
x = cached.transform.position.x,
y = cached.transform.position.y,
z = cached.transform.position.z
};
}, true);
return(transform);
}
public async Task <MoveResponse> MakeMove(int playerId, int column)
{
MoveResponse response;
Logger.Info("Player{0} moved in column {1}", playerId, column);
IGame game = Logic.GetGameByPlayerId(playerId);
game.MakeMove(column);
if (game.Board.LastMove.IsConnected)
{
Logger.Info("Player{0} won!", playerId);
Logic.RunningGames.Remove(game);
response = new MoveResponse(null);
}
else
{
bool timeout = game.WaitForNextPlayer(1 * 10 * 1000);
if (!timeout)
{
Logger.Info("Timeout! Player{0} move timed out!", game.NextPlayer.OnlineId);
}
response = new MoveResponse(game.Board.LastMove, timeout);
}
return(await Task.Factory.StartNew(() => response));
}
public void TestMoveDown()
{
int[,] testTiles = new int[4, 4];
testTiles[0, 0] = 2;
testTiles[0, 1] = 0;
testTiles[0, 2] = 0;
testTiles[0, 3] = 0;
testTiles[1, 0] = 0;
testTiles[1, 1] = 2;
testTiles[1, 2] = 0;
testTiles[1, 3] = 0;
testTiles[2, 0] = 0;
testTiles[2, 1] = 0;
testTiles[2, 2] = 2;
testTiles[2, 3] = 0;
testTiles[3, 0] = 0;
testTiles[3, 1] = 0;
testTiles[3, 2] = 0;
testTiles[3, 3] = 2;
MoveResponse response = game.RegisterDirection(Direction.DOWN);
Assert.AreEqual(MoveResponse.CAN_MOVE, response);
Assert.AreEqual(2, testTiles[0, 3]);
Assert.AreEqual(2, testTiles[1, 3]);
Assert.AreEqual(2, testTiles[2, 3]);
Assert.AreEqual(2, testTiles[3, 3]);
}
public void MoveResponse_Cstr()
{
const int Expected_NumberOfSteps = 101;
var sut = new MoveResponse(Expected_NumberOfSteps);
Assert.Equal(Expected_NumberOfSteps, sut.CleanedVertices);
}
public MoveResponse PostMove(MoveRequest moveRequest)
{
var strategy = ResolveGameModeStrategy(moveRequest.GameMode);
var move = new Move(moveRequest.Row, moveRequest.Column, moveRequest.PlayerNumber);
var moveResult = strategy.OnMove(move, moveRequest.MatchId, moveRequest.Gameboard);
moveRequest.Players.ForEach(p =>
p.Score = ScoreKeeper.GetScoreForPlayer(p.Number, moveResult.Gameboard)
);
var response = new MoveResponse
{
Result = moveResult,
Players = moveRequest.Players
};
if (moveResult.IsEndOfMatch)
{
response.Winner = moveRequest
.Players
.OrderByDescending(p => p.Score)
.First( );
}
return(response);
}
private async void GetFirstMove(int playerId)
{
try
{
MoveResponse moveResponse = await proxy.GetFirstMove(playerId);
if (moveResponse?.MoveMade != null)
{
CurrentGame.MakeMove(moveResponse.MoveMade);
SendMove(moveResponse.MoveMade);
}
}
catch (TimeoutException ex)
{
string exceptionMessage = StringResources.TimeoutExceptionOccured("GetFirstMove", ex.Message);
logger?.Error(exceptionMessage);
throw new GameServerException(exceptionMessage, ex);
}
catch (FaultException ex)
{
string exceptionMessage = StringResources.ExceptionOccuredOnServerSide("GetFirstMove", ex.Message);
logger?.Error(exceptionMessage);
throw new GameServerException(exceptionMessage, ex);
}
catch (CommunicationException ex)
{
string exceptionMessage = StringResources.CommunicationProblemOccured("GetFirstMove", ex.Message);
logger?.Error(exceptionMessage);
throw new GameServerException(exceptionMessage, ex);
}
}
/// <summary>
///
/// </summary>
/// <param name="response"></param>
internal void OnMoveResponse(MoveResponse response)
{
if (response.MoveStatus == MoveStatus.Accepted)
{
var mv = new GameMove()
{
Index = ++this.index,
Row = response.Row,
Column = response.Column,
Color = CurrentPlayer.Color
};
// stores the move
this.Move(mv);
//
this.Status = response.GameStatus;
this.Winner = response.Player;
if (response.GameStatus != GameStatus.Continue)
{
this.GameOver?.Invoke(this,
new GameOverEventArgs()
{
Status = this.Status,
Winner = this.Winner,
WinningLine = response.WinningLine,
WinningLineCoords = response.WinningLineCoords,
Row = response.Row,
Column = response.Column
});
}
}
}
public object Get(Do request)
{
var cached = Cache.Get<GameObject>(request.target);
var v = new Vector3(request.x, request.y, request.z);
var transform = default(MoveResponse);
bool move = request.action == "move";
Exec.OnMain(() =>
{
if (cached == null)
{
cached = GameObject.Find(request.target);
Cache.Set<GameObject>(request.target, cached);
Debug.Log("not cached");
}
if (move)
{
cached.transform.position = Vector3.MoveTowards(cached.transform.position, v, 0.1f);
}
transform = new MoveResponse
{
x = cached.transform.position.x,
y = cached.transform.position.y,
z = cached.transform.position.z
};
}, true);
return transform;
}
public void ShouldInsertMoveResponses()
{
//arrange
var moveResponses = new MoveResponse[]
{
new MoveResponse()
{
Board = "____X____",
Outcome = GameState.XWin,
Player = Player.X,
Response = Move.Southern
},
new MoveResponse()
{
Board = "X__XX__OO",
Outcome = GameState.OWin,
Player = Player.O,
Response = Move.Northern
}
};
IEnumerable <MoveResponseRecord> responsesReceived = null;
MockLiteDatabase
.Setup(a => a.InsertBulk(It.IsAny <IEnumerable <MoveResponseRecord> >()))
.Callback <IEnumerable <MoveResponseRecord> >(a => responsesReceived = a);
//act
MoveResponseRepository.InsertMoveResponses(moveResponses);
//assert
var expectedMoveResponses = new MoveResponseRecord[]
{
new MoveResponseRecord()
{
Board = "____X____",
Outcome = GameState.XWin,
Player = Player.X,
Response = Move.Southern
},
new MoveResponseRecord()
{
Board = "X__XX__OO",
Outcome = GameState.OWin,
Player = Player.O,
Response = Move.Northern
}
};
MockLiteDatabase
.Verify(a => a.InsertBulk(It.IsAny <IEnumerable <MoveResponseRecord> >()), Times.Once());
MockLiteDatabase
.Verify(a => a.EnsureIndex(It.IsAny <Expression <Func <MoveResponseRecord, string> > >(), false), Times.Once());
expectedMoveResponses.ShouldAllBeEquivalentTo(responsesReceived);
}
/// <summary>
///
/// </summary>
/// <param name="message"></param>
private void HandleMoveResponse(MoveResponse message)
{
if (this.isCancelling)
{
return;
}
this.game.OnMoveResponse(message);
}
public ActionResult MoveDown(string id)
{
MoveRequest request = new MoveRequest();
request.ID = Guid.Parse(id);
MoveResponse response = _suctionModeService.MoveDown(request);
return(RedirectToAction("Index"));
}
public void MakeMoveShouldMakeWinningMoveForX()
{
//arrange
GameMock
.Setup(a => a.GameIsOver)
.Returns(false);
GameMock
.Setup(a => a.GameBoardString)
.Returns(AGameBoardString);
GameMock
.Setup(a => a.CurrentPlayer)
.Returns(Player.X);
var moveResponses = new MoveResponse[]
{
new MoveResponse()
{
Response = Move.Northern,
Outcome = GameState.XWin,
Board = "_________",
Player = Player.X
},
new MoveResponse()
{
Response = Move.Center,
Outcome = GameState.OWin,
Board = "_________",
Player = Player.X
},
new MoveResponse()
{
Response = Move.Southern,
Outcome = GameState.Tie,
Board = "_________",
Player = Player.X
}
};
MoveDataAccessMock
.Setup(a => a.FindMoveResponses(AGameBoardString, Player.X))
.Returns(moveResponses);
RandomMock
.Setup(a => a.Next(It.IsAny <int>()))
.Returns(0);
//act
OmniscientGod.MakeMove(GameMock.Object);
//assert
GameMock
.Verify(a => a.Move(Move.Northern), Times.Once());
}
public ActionResult UncreditService_MoveUp(string ID)
{
GeneralResponse response = new GeneralResponse();
MoveRequest request = new MoveRequest();
request.ID = Guid.Parse(ID);
MoveResponse move = _uncreditServiceService.MoveUp(request);
return(Json(response, JsonRequestBehavior.AllowGet));
}
public void ShouldFindMoveResults()
{
//arrange
GameMock
.Setup(a => a.GameBoardString)
.Returns(AGameBoardString);
GameMock
.Setup(a => a.CurrentPlayer)
.Returns(Player.X);
var moveResponses = new MoveResponse[]
{
new MoveResponse()
{
Response = Move.Northern,
Outcome = GameState.XWin,
Board = "_________",
Player = Player.X
},
new MoveResponse()
{
Response = Move.Center,
Outcome = GameState.OWin,
Board = "_________",
Player = Player.X
},
new MoveResponse()
{
Response = Move.Southern,
Outcome = GameState.Tie,
Board = "_________",
Player = Player.X
}
};
MoveDataAccessMock
.Setup(a => a.FindMoveResponses(AGameBoardString, Player.X))
.Returns(moveResponses);
//act
var results = OmniscientGod.FindMoveResults(GameMock.Object);
//assert
var expectedMoveResults = new MoveResult[]
{
new MoveResult(Move.Northern, GameState.XWin),
new MoveResult(Move.Center, GameState.OWin),
new MoveResult(Move.Southern, GameState.Tie)
};
results.ShouldAllBeEquivalentTo(expectedMoveResults);
}
public JsonResult DocumentStatus_MoveDown(Guid ID)
{
GeneralResponse response = new GeneralResponse();
MoveResponse move = new MoveResponse();
move = _documentStatusService.MoveDown(new MoveRequest()
{
ID = ID
});
return(Json(response, JsonRequestBehavior.AllowGet));
}
public JsonResult CreditService_MoveDown(Guid ID)
{
GeneralResponse response = new GeneralResponse();
MoveResponse move = new MoveResponse();
move = _creditServiceService.MoveDown(new MoveRequest()
{
ID = ID
});
return(Json(response, JsonRequestBehavior.AllowGet));
}
public JsonResult MoneyAccount_MoveDown(Guid ID)
{
GeneralResponse response = new GeneralResponse();
MoveResponse move = new MoveResponse();
move = _networkCenterPriorityService.MoveDown(new MoveRequest()
{
ID = ID
});
return(Json(response, JsonRequestBehavior.AllowGet));
}
public JsonResult MoneyAccount_MoveUp(Guid ID)
{
GeneralResponse response = new GeneralResponse();
MoveResponse move = new MoveResponse();
move = _moneyAccountService.MoveUp(new MoveRequest()
{
ID = ID
});
return(Json(response, JsonRequestBehavior.AllowGet));
}
public JsonResult SuctionModeDetail_MoveDown(Guid ID)
{
GeneralResponse response = new GeneralResponse();
MoveResponse move = new MoveResponse();
move = _suctionModeService.MoveDown(new MoveRequest()
{
ID = ID
});
return(Json(response, JsonRequestBehavior.AllowGet));
}
public JsonResult ProductPrices_MoveUp(Guid ID)
{
GeneralResponse response = new GeneralResponse();
MoveResponse move = new MoveResponse();
move = _productPriceService.MoveUp(new MoveRequest()
{
ID = ID
});
return(Json(response, JsonRequestBehavior.AllowGet));
}
public void KeyPress(Direction direction)
{
MoveResponse response = game.RegisterDirection(direction);
if (response == MoveResponse.END_GAME)
{
EndGame();
}
if (response == MoveResponse.CAN_MOVE)
{
DrawGame();
}
}
public MoveResponse MoveDown(MoveRequest request)
{
MoveResponse response = new MoveResponse();
// Current Agency is the Request
UncreditService currentUncreditService = new UncreditService();
currentUncreditService = _uncreditServiceRepository.FindBy(request.ID);
// Find the Previews Agency
UncreditService nextUncreditService = new UncreditService();
try
{
nextUncreditService = _uncreditServiceRepository.FindAll()
.Where(s => s.SortOrder > currentUncreditService.SortOrder)
.OrderBy(s => s.SortOrder)
.First();
}
catch (Exception ex)
{
}
if (currentUncreditService != null && nextUncreditService != null)
{
try
{
// replacing SortOrders
int current = (int)currentUncreditService.SortOrder;
int previews = (int)nextUncreditService.SortOrder;
currentUncreditService.SortOrder = previews;
nextUncreditService.SortOrder = current;
_uncreditServiceRepository.Save(currentUncreditService);
_uncreditServiceRepository.Save(nextUncreditService);
_uow.Commit();
}
catch (Exception ex)
{
response.ErrorMessages.Add(ex.Message);
return(response);
}
////response.success = true;
}
return(response);
}
public MoveResponse MoveDown(MoveRequest request)
{
MoveResponse response = new MoveResponse();
// Current Agency is the Request
DocumentStatus currentDocumentStatus = new DocumentStatus();
currentDocumentStatus = _documentStatusRepository.FindBy(request.ID);
// Find the Previews Agency
DocumentStatus nextDocumentStatus = new DocumentStatus();
try
{
nextDocumentStatus = _documentStatusRepository.FindAll()
.Where(s => s.SortOrder > currentDocumentStatus.SortOrder)
.OrderBy(s => s.SortOrder)
.FirstOrDefault();
}
catch (Exception ex)
{
}
if (currentDocumentStatus != null && nextDocumentStatus != null)
{
try
{
// replacing SortOrders
int current = (int)currentDocumentStatus.SortOrder;
int previews = (int)nextDocumentStatus.SortOrder;
currentDocumentStatus.SortOrder = previews;
nextDocumentStatus.SortOrder = current;
_documentStatusRepository.Save(currentDocumentStatus);
_documentStatusRepository.Save(nextDocumentStatus);
_uow.Commit();
}
catch (Exception ex)
{
response.ErrorMessages.Add(ex.Message);
return(response);
}
////response.success = true;
}
return(response);
}
public MoveResponse MoveUp(MoveRequest request)
{
MoveResponse response = new MoveResponse();
// Current Price is the Request
Product currentProduct = new Product();
currentProduct = _productRepository.FindBy(request.ID);
// Find the Previews Price
Product previewsProduct = new Product();
try
{
previewsProduct = _productRepository.FindAll()
.Where(s => s.SortOrder < currentProduct.SortOrder)
.OrderByDescending(s => s.SortOrder)
.First();
}
catch (Exception ex)
{
}
if (currentProduct != null && previewsProduct != null)
{
try
{
// replacing SortOrders
int current = (int)currentProduct.SortOrder;
int previews = (int)previewsProduct.SortOrder;
currentProduct.SortOrder = previews;
previewsProduct.SortOrder = current;
_productRepository.Save(currentProduct);
_productRepository.Save(previewsProduct);
_uow.Commit();
}
catch (Exception ex)
{
response.ErrorMessages.Add(ex.Message);
return(response);
}
////response.success = true;
}
return(response);
}
public MoveResponse MoveUp(MoveRequest request)
{
MoveResponse response = new MoveResponse();
// Current Agency is the Request
SuctionModeDetail currentSuctionModeDetail = new SuctionModeDetail();
currentSuctionModeDetail = _suctionModeDetailRepository.FindBy(request.ID);
// Find the Previews Agency
SuctionModeDetail previewsSuctionModedetail = new SuctionModeDetail();
try
{
previewsSuctionModedetail = _suctionModeDetailRepository.FindAll()
.Where(s => s.SortOrder < currentSuctionModeDetail.SortOrder)
.OrderByDescending(s => s.SortOrder)
.First();
}
catch (Exception ex)
{
}
if (currentSuctionModeDetail != null && previewsSuctionModedetail != null)
{
try
{
// replacing SortOrders
int current = (int)currentSuctionModeDetail.SortOrder;
int previews = (int)previewsSuctionModedetail.SortOrder;
currentSuctionModeDetail.SortOrder = previews;
previewsSuctionModedetail.SortOrder = current;
_suctionModeDetailRepository.Save(currentSuctionModeDetail);
_suctionModeDetailRepository.Save(previewsSuctionModedetail);
_uow.Commit();
}
catch (Exception ex)
{
response.ErrorMessages.Add(ex.Message);
return(response);
}
////response.success = true;
}
return(response);
}
public MoveResponse MoveDown(MoveRequest request)
{
MoveResponse response = new MoveResponse();
// Current Price is the Request
Level currentLevel = new Level();
currentLevel = _levelRepository.FindBy(request.ID);
// Find the Previews Price
Level nextLevel = new Level();
try
{
nextLevel = _levelRepository.FindAll()
.Where(s => s.SortOrder > currentLevel.SortOrder)
.OrderBy(s => s.SortOrder)
.First();
}
catch (Exception ex)
{
}
if (currentLevel != null && nextLevel != null)
{
try
{
// replacing SortOrders
int current = (int)currentLevel.SortOrder;
int previews = (int)nextLevel.SortOrder;
currentLevel.SortOrder = previews;
nextLevel.SortOrder = current;
_levelRepository.Save(currentLevel);
_levelRepository.Save(nextLevel);
_uow.Commit();
}
catch (Exception ex)
{
response.ErrorMessages.Add(ex.Message);
return(response);
}
////response.success = true;
}
return(response);
}
public MoveResponse MoveUp(MoveRequest request)
{
MoveResponse response = new MoveResponse();
// Current Agency is the Request
CreditService currentCreditService = new CreditService();
currentCreditService = _creditServiceRepository.FindBy(request.ID);
// Find the Previews Agency
CreditService previewsCreditService = new CreditService();
try
{
previewsCreditService = _creditServiceRepository.FindAll()
.Where(s => s.SortOrder < currentCreditService.SortOrder)
.OrderByDescending(s => s.SortOrder)
.First();
}
catch (Exception ex)
{
}
if (currentCreditService != null && previewsCreditService != null)
{
try
{
// replacing SortOrders
int current = currentCreditService.SortOrder;
int previews = previewsCreditService.SortOrder;
currentCreditService.SortOrder = previews;
previewsCreditService.SortOrder = current;
_creditServiceRepository.Save(currentCreditService);
_creditServiceRepository.Save(previewsCreditService);
_uow.Commit();
}
catch (Exception ex)
{
response.ErrorMessages.Add(ex.Message);
return(response);
}
////response.success = true;
}
return(response);
}
public MoveResponse MoveDown(MoveRequest request)
{
MoveResponse response = new MoveResponse();
// Current Agency is the Request
Network currentNetwork = new Network();
currentNetwork = _networkRepository.FindBy(request.ID);
// Find the Previews Agency
Network nextNetwork = new Network();
try
{
nextNetwork = _networkRepository.FindAll()
.Where(s => s.SortOrder > currentNetwork.SortOrder)
.OrderBy(s => s.SortOrder)
.First();
}
catch (Exception ex)
{
}
if (currentNetwork != null && nextNetwork != null)
{
try
{
// replacing SortOrders
int current = currentNetwork.SortOrder;
int previews = nextNetwork.SortOrder;
currentNetwork.SortOrder = previews;
nextNetwork.SortOrder = current;
_networkRepository.Save(currentNetwork);
_networkRepository.Save(nextNetwork);
_uow.Commit();
}
catch (Exception ex)
{
response.ErrorMessages.Add(ex.Message);
return(response);
}
////response.success = true;
}
return(response);
}
public void TestMoveStrategyAction()
{
//given
Strategy strategy = new MyAbstractStrategy(width, height, teamId, goalAreaSize);
MoveResponse moveResponse = new MoveResponse()
{
ClosestPiece = 4,
CurrentPosition = new Position() { X = position.X, Y = position.Y },
MadeMove = true
};
//when
strategy.UpdateMap(new Message<MoveResponse>(moveResponse), position);
//then
Assert.AreEqual(moveResponse.ClosestPiece, strategy.Board.Board[position.X, position.Y].DistToPiece);
}
public MoveResponse MakeMove(Guid gameId, Move move, string promotionType = null)
{
var game = gamesRepo.GetGame(gameId);
var variantService = gameTypeDispatcher.GetVariantService(game.GameType);
var moveCommand = variantService.MakeMove(game, move, promotionType);
var moveResponse = new MoveResponse
{
GameStatusModel = game.GameStatusModel,
MoveCommand = moveCommand
};
return(moveResponse);
}
public IActionResult Move(GameStatusRequest gameStatusRequest)
{
var direction = new List <string> {
"down", "left", "right", "up"
};
var rng = new Random();
var response = new MoveResponse
{
Move = direction[rng.Next(direction.Count)],
Shout = "I am moving!"
};
return(Ok(response));
}
