public PartialViewResult ActivateCell(string x, string y) { int USERID = int.Parse(new JavaScriptSerializer().Serialize(Session["userid"])); int Column = int.Parse(x.Trim()); int Row = int.Parse(y.Trim()); GameLogicBLL gameService = new GameLogicBLL(); GameBoardModel grid = Globals.Grid; grid.Cells[Column, Row].IsVisited = true; Globals.numberClicks++; grid.Clicks = Globals.numberClicks; if (grid.Cells[Column, Row].IsLive) { gameService.PublishGameStats(grid, USERID, this.ElapsedTime()); return(EndGame()); } else { if (grid.Cells[Column, Row].LiveNeighbors == 0) { gameService.showNeighbors(Globals.Grid, Globals.Grid.Cells[Column, Row].Column, Globals.Grid.Cells[Column, Row].Row); } gameService.UpdateGrid(grid, USERID); } return(PartialView("Index", grid)); }
/// <summary> /// Constructor /// </summary> public BattlePage() { InitializeComponent(); GameBoardModel.Wipe(); int left = 0; foreach (PlayerInfoModel character in EngineViewModel.Engine.CharacterList) { MapObject location = GameBoardModel.Locations.Find(a => (a.x == left && a.y == 0)); location.Id = character.Id; location.ImageURI = character.ImageURI; location.MapObjectType = MapObjectEnum.Character; location.Selected = false; left++; } left = 0; foreach (PlayerInfoModel monster in EngineViewModel.Engine.MonsterList) { MapObject location = GameBoardModel.Locations.Find(a => (a.x == left && a.y == GameBoardModel.Size - 1)); location.Id = monster.Id; location.ImageURI = monster.ImageURI; location.MapObjectType = MapObjectEnum.Monster; location.Selected = false; left++; } RefreshGameBoard(); }
private void updatePlayerPos() { GameBoardModel gb = app.game_board_model; Vector3 dest = new Vector3(gb.player.col, gb.player.row, -.05f); player.transform.position = Vector3.Lerp(player.transform.position, dest, speed * Time.deltaTime); }
/// <summary> /// Get the closest item to the specified Player /// </summary> /// <param name="player"></param> /// <returns></returns> public int[] GetClosestItem(PlayerInfoModel player) { int[] PlayerLocation = GameBoardModel.GetPlayerLocation(player); int[] location = { Int32.MaxValue, Int32.MaxValue }; // Get closest Character int closestDistance = Int32.MaxValue; for (int x = 0; x < GameBoardModel.Size; ++x) { for (int y = 0; y < GameBoardModel.Size; ++y) { if (GameBoardModel.ItemLocations[x, y] != null) { int distance = GameBoardHelper.Distance(x, y, PlayerLocation[0], PlayerLocation[1]); if (distance < closestDistance) { location[0] = x; location[1] = y; } } } } return(location); }
/// <summary> /// Attack as a Turn /// /// Pick who to go after /// /// Determine the Attack score /// Determine the Defense score /// /// Do the Attack /// /// </summary> /// <param name="Attacker"></param> /// <returns></returns> public bool Attack(PlayerInfoModel Attacker) { // For Attack, Choose Who var TargetLocation = AttackChoice(Attacker); if (TargetLocation[0] == Int32.MaxValue) { return(false); } int[] attackerLocation = GameBoardModel.GetPlayerLocation(Attacker); int Distance = GameBoardHelper.Distance(attackerLocation[0], attackerLocation[1], TargetLocation[0], TargetLocation[1]); int AttackRange = 1; if (Attacker.Head != null) { AttackRange = ItemIndexViewModel.Instance.GetItem(Attacker.Head).Range; } if (Distance > AttackRange || Attacker.CurrentStamina < 3) { return(false); } // Do Attack PlayerInfoModel TargetModel = GameBoardModel.GetPlayer(TargetLocation[0], TargetLocation[1]); TurnAsAttack(Attacker, TargetModel); CurrentAttacker = new PlayerInfoModel(Attacker); CurrentDefender = new PlayerInfoModel(TargetModel); return(true); }
/// <summary> /// Clear the List between Rounds /// </summary> /// <returns></returns> private bool ClearLists() { GameBoardModel.Wipe(); ItemPool.Clear(); MonsterList.Clear(); return(true); }
private bool checkWin() { GameBoardModel gb = app.game_board_model; if (gb.player.currentTile == null) { return(false); } if (gb.player.currentTile.type != TileType.End) { return(false); } for (int row = 0; row < gb.height; row++) { for (int col = 0; col < gb.width; col++) { if (gb.board[row][col].type == TileType.Dirty) { return(false); } } } print("you win"); return(true); }
/// <summary> /// Crea las acciones asociadas a un movimiento /// </summary> internal void CreateActions(GameBoardModel board, MovementFigureModel movement, CellModel target, CellModel origin, PieceBaseModel.PieceType?targetPiece) { PieceBaseModel piece = board.SearchMoveTo(movement, target, origin); // Comprueba que se haya localizado la pieza que hizo el movimiento if (piece == null) { throw new Exceptions.GameReaderException($"No se encuentra ninguna pieza que pueda realizar el movimiento {movement.Text}"); } // Crea el movimiento CreateMoveAction(piece.Type, piece.Color, piece.Cell, target); // Crea la captura if (movement.Type == MovementFigureModel.MovementType.Capture || movement.Type == MovementFigureModel.MovementType.CaptureEnPassant) { CreateCaptureAction(board, targetPiece, GetNextColor(movement.Color), target); } // Crea la promoción if (movement.PromotedPiece != null) { // Crea un movimiento para eliminar el peón que se ha promocionado //? No llama a CreateCaptureAction porque si ha habido una captura en este mismo movimiento //? la pieza aún no se habrá eliminado del destino y por tanto nos creará una captura //? sobre la pieza que se ha eliminado ya Add(new ActionCaptureModel(piece.Type, movement.Color, target)); // Crea una promoción CreatePromoteAction(movement.PromotedPiece, movement.Color, target); } }
public void UpdateGrid(GameBoardModel grid, int userID) { // Send updated Grid to DB DAObusiness businessService = new DAObusiness(); businessService.UpdateGrid(grid, userID); }
public void OnGet() { Games = _igame.GetCurrentGame(); UserGame = _igame.GetUserGame(); navyBattlePieces = _igame.GetBoard(); GameBoard = new GameBoardModel(navyBattlePieces, UserGame, _igame.GetActiveUserId()); }
/// <summary> /// Crea una captura /// </summary> private void CreateCaptureAction(GameBoardModel board, PieceBaseModel.PieceType?piece, PieceBaseModel.PieceColor color, CellModel from) { PieceBaseModel targetPiece = board.Pieces.GetPiece(from); //? En ocasiones la pieza leída no es la real del tablero, por eso buscamos la pieza adecuada // Añade la pieza Add(new ActionCaptureModel(targetPiece?.Type ?? piece ?? PieceBaseModel.PieceType.Unknown, color, from)); }
private void InitGameBoard(int columnsCount, int rowsCount) { Buttons = new ObservableCollection <Button>(); gameBoardModel = new GameBoardModel() { GameField = CreateGameFieldArray(columnsCount, rowsCount) }; }
public async Task <HttpResponseMessage> Get(long id) { var player = ApplicationUser.GetCurrentPlayer(this.User); var game = await this.gameService.GetGameAsync(id); var result = new GameBoardModel(game, player); return(Request.CreateResponse(HttpStatusCode.OK, result)); }
// Load a new script internal bool LoadGame(ScriptInfo script) { var model = GameBoardModel.Create(this, script); if (model != null) { Launch(model); } return(model != null); }
/// <summary> /// Comprueba si la pieza se puede mover a una fila / columna /// </summary> public override bool CanMoveTo(GameBoardModel board, CellModel target, Movements.MovementFigureModel.MovementType type) { // Comprueba si es un movimiento horizontal / diagonal de un solo recuadro if (IsVerticalHorizontalMovement(target, true) || IsDiagonalMovement(target, true)) { return(IsLegal(board, target, type)); } // Si ha llegado hasta aquí es porque el movimiento no era legal return(false); }
/// <summary> /// Comprueba si la pieza se puede mover a una fila / columna /// </summary> public override bool CanMoveTo(GameBoardModel board, CellModel target, Movements.MovementFigureModel.MovementType type) { // Comprueba si puede mover if (IsDiagonalMovement(target, false)) { return(board.IsEmpty(Cell, target) && IsLegal(board, target, type)); } // Devuelve el valor que indica si puede mover return(false); }
public void UpdateGrid(GameBoardModel grid, int userid) { try { // Setup INSERT query with parameters string query = "UPDATE dbo.Grids SET ROWS = @Rows, COLS = @Cols, UserID = @UserID, HasWon = @HasWon, Clicks = @Clicks WHERE ID=@ID"; SqlCommand cmd = new SqlCommand(query, this.conn); cmd.Parameters.Add("@Rows", SqlDbType.Int, 11).Value = grid.Rows; cmd.Parameters.Add("@Cols", SqlDbType.Int, 11).Value = grid.Cols; cmd.Parameters.Add("@UserID", SqlDbType.Int, 11).Value = userid; cmd.Parameters.Add("@HasWon", SqlDbType.VarChar).Value = grid.HasWon; cmd.Parameters.Add("@Clicks", SqlDbType.Int, 11).Value = grid.Clicks; cmd.Parameters.Add("@ID", SqlDbType.Int, 11).Value = grid.ID; conn.Open(); cmd.ExecuteNonQuery(); conn.Close(); } catch (SqlException e) { throw e; } try { // Setup INSERT query with parameters string query = "UPDATE dbo.Cells SET Col = @Col, Row = @Row, IsLive = @IsLive, IsVisited = @IsVisited, LiveNeighbors = @LiveNeighbors, " + "GridID = @GridID WHERE ID=@ID"; // Create connection and command for (int y = 0; y < grid.Rows; y++) { for (int x = 0; x < grid.Cols; x++) { SqlCommand cmd = new SqlCommand(query, this.conn); cmd.Parameters.Add("@Col", SqlDbType.Int, 11).Value = grid.Cells[x, y].Column; cmd.Parameters.Add("@Row", SqlDbType.Int, 11).Value = grid.Cells[x, y].Row; cmd.Parameters.Add("@IsLive", SqlDbType.VarChar).Value = grid.Cells[x, y].IsLive; cmd.Parameters.Add("@IsVisited", SqlDbType.VarChar).Value = grid.Cells[x, y].IsVisited; cmd.Parameters.Add("@LiveNeighbors", SqlDbType.Int, 11).Value = grid.Cells[x, y].LiveNeighbors; cmd.Parameters.Add("@GridID", SqlDbType.Int, 11).Value = grid.ID; cmd.Parameters.Add("@ID", SqlDbType.Int, 11).Value = grid.Cells[x, y].ID; // Open the connection, execute INSERT, and close the connection conn.Open(); cmd.ExecuteNonQuery(); conn.Close(); } } } catch (SqlException e) { throw e; } }
public void OnGet() { Games = _igame.GetCurrentGame(); UserGames = _igame.GetUserGames(); for (int board = 0; board < UserGames.Count(); board++) { IList <NavyBattlePiece> navyBattlePieces = _igame.GetNavyBattlePieces(UserGames[board].Id); GameBoardModel newBoard = new GameBoardModel(navyBattlePieces, UserGames[board], _igame.GetActiveUserId()); GameBoardModels.Add(newBoard); } }
public async Task <IActionResult> GetGameStatus([FromHeader] string authToken) { var user = UserContext.User; var gameBoard = GameContext.GetContextByPlayer(user).GameBoard; //to do view model var gameBoardModel = new GameBoardModel(gameBoard); var result = await Task.Run(() => { return(gameBoardModel.GetInfo()); }); return(await SuccessResponse(result)); }
public void CreateGrid(GameBoardModel grid, int userid) { int gridID; try { // Setup INSERT query with parameters string query = "INSERT INTO dbo.Grids (Rows, Cols, UserID, HasWon, Clicks) " + "VALUES (@Rows, @Cols, @UserID, @HasWon, @Clicks) SELECT SCOPE_IDENTITY()"; SqlCommand cmd = new SqlCommand(query, this.conn); cmd.Parameters.Add("@Rows", SqlDbType.Int, 11).Value = grid.Rows; cmd.Parameters.Add("@Cols", SqlDbType.Int, 11).Value = grid.Cols; cmd.Parameters.Add("@UserID", SqlDbType.Int, 11).Value = userid; cmd.Parameters.Add("@HasWon", SqlDbType.VarChar).Value = grid.HasWon; cmd.Parameters.Add("@Clicks", SqlDbType.Int, 11).Value = grid.Clicks; conn.Open(); gridID = Convert.ToInt32(cmd.ExecuteScalar()); conn.Close(); } catch (SqlException e) { throw e; } try { // Setup INSERT query with parameters string query = "INSERT INTO dbo.Cells (Col, Row, IsLive, IsVisited, LiveNeighbors, GridID) " + "VALUES (@Col, @Row, @IsLive, @IsVisited, @LiveNeighbors, @GridID)"; // Create connection and command for (int y = 0; y < grid.Rows; y++) { for (int x = 0; x < grid.Cols; x++) { SqlCommand cmd = new SqlCommand(query, this.conn); cmd.Parameters.Add("@Col", SqlDbType.Int, 11).Value = grid.Cells[x, y].Column; cmd.Parameters.Add("@Row", SqlDbType.Int, 11).Value = grid.Cells[x, y].Row; cmd.Parameters.Add("@IsLive", SqlDbType.VarChar).Value = grid.Cells[x, y].IsLive; cmd.Parameters.Add("@IsVisited", SqlDbType.VarChar).Value = grid.Cells[x, y].IsVisited; cmd.Parameters.Add("@LiveNeighbors", SqlDbType.Int, 11).Value = grid.Cells[x, y].LiveNeighbors; cmd.Parameters.Add("@GridID", SqlDbType.Int, 11).Value = gridID; // Open the connection, execute INSERT, and close the connection conn.Open(); cmd.ExecuteNonQuery(); conn.Close(); } } } catch (SqlException e) { throw e; } }
// Attack or Move // Roll To Hit // Decide Hit or Miss // Decide Damage // Death // Drop Items // Turn Over #endregion Algrorithm /// <summary> /// Perform a turn and attack the target /// </summary> /// <param name="Attacker"></param> /// <returns></returns> public bool TakeTurn(PlayerInfoModel Attacker) { // Replenish Stamina Attacker.CurrentStamina = Attacker.BaseStamina; // Choose Action. Such as Move, Attack etc. // while an action is possible // If Nearest enemy in range and have an item, then Attack // If in range of an item, then move onto Item // if we don't have an item if (Attacker.Head == null) { // move to item int[] closestItem = GetClosestItem(Attacker); if (closestItem[0] != Int32.MaxValue && closestItem[1] != Int32.MaxValue) { // Move towards the Item, conserving 3 stamina for the attack Attacker.CurrentStamina = MoveTowards(Attacker, closestItem, 3, GameBoardModel.GetItem(closestItem[0], closestItem[1]).Name); } int[] PlayerLocation = GameBoardModel.GetPlayerLocation(Attacker); int[] newestClosest = GetClosestItem(Attacker); if (newestClosest[0] != Int32.MaxValue && newestClosest[1] != Int32.MaxValue && GameBoardHelper.Distance(newestClosest[0], newestClosest[1], PlayerLocation[0], PlayerLocation[1]) <= 1) { ItemModel temp = GameBoardModel.ItemLocations[newestClosest[0], newestClosest[1]]; Attacker.Head = temp.Id; Debug.WriteLine(Attacker.Name + " picked up " + temp.Name); GameBoardModel.ItemLocations[newestClosest[0], newestClosest[1]] = null; } } // then try an attack var attacks = Attack(Attacker); if (!attacks) { // move toward enemy int[] TargetLocation = AttackChoice(Attacker); if (TargetLocation[0] == Int32.MaxValue) { return(attacks); } } BattleScore.TurnCount++; return(attacks); }
public JsonResult TakeShot([FromBody] TakeShotViewModel shot) { GameBoardModel player = JsonConvert.DeserializeObject <GameBoardModel>(HttpContext.Session.GetString("player")); GameBoardModel opponentModel = JsonConvert.DeserializeObject <GameBoardModel>(HttpContext.Session.GetString("opponentModel")); ezbot opponent = new ezbot(opponentModel); Tuple <int, int> incomingShotGuess; //Resolve player shot var opponentHit = false; switch (opponent.ReceiveShot(shot.row, shot.col)) { case ShotStatus.Hit: opponentHit = true; break; case ShotStatus.Miss: opponentHit = false; break; case ShotStatus.OutofBounds: return(Json(new { modelResponse = opponent.model.Error })); } player.UpdateAfterShot(shot.row, shot.col, opponentHit); //Check for player win condition var playerWin = false; playerWin = opponent.model.CheckLose(); //Opponent takes a shot incomingShotGuess = opponent.TakeShot(); //Player Receives shot var playerHit = player.ReceiveShot(incomingShotGuess.Item1, incomingShotGuess.Item2); bool playerHitData = true; if (playerHit == ShotStatus.Hit) { playerHitData = true; } else if (playerHit == ShotStatus.Miss) { playerHitData = false; } opponent.model.UpdateAfterShot(incomingShotGuess.Item1, incomingShotGuess.Item2, playerHitData); //check for opponent win condition var opponentWin = false; opponentWin = player.CheckLose(); //return the results HttpContext.Session.SetString("player", JsonConvert.SerializeObject(player)); HttpContext.Session.SetString("opponentModel", JsonConvert.SerializeObject(opponent.model)); return(Json(new { win = new { playerWin = playerWin, opponentWin = opponentWin }, modelResponse = opponentHit, incomingShot = new { playerHit = playerHitData, row = incomingShotGuess.Item1, col = incomingShotGuess.Item2 } })); }
public override void OnNotification(string p_event_path, UnityEngine.Object p_target, params object[] p_data) { GameBoardModel gb = app.game_board_model; GameBoardEvent action = null; switch (p_event_path) { case "user.press.up": { ActorMoveEvent a = gameObject.AddComponent <ActorMoveEventUp>(); a.addActor(gb.player); action = a; break; } case "user.press.down": { ActorMoveEvent a = gameObject.AddComponent <ActorMoveEventDown>(); a.addActor(gb.player); action = a; break; } case "user.press.left": { ActorMoveEvent a = gameObject.AddComponent <ActorMoveEventLeft>(); a.addActor(gb.player); action = a; break; } case "user.press.right": { ActorMoveEvent a = gameObject.AddComponent <ActorMoveEventRight>(); a.addActor(gb.player); action = a; break; } case "user.undo": { GameBoardEvent a = gameObject.AddComponent <GameBoardUndoEvent>(); action = a; break; } } if (action != null) { gb.events.Enqueue(action); } }
private void updateMud() { GameBoardModel gb = app.game_board_model; for (int col = 0; col < gb.width; col++) { for (int row = 0; row < gb.height; row++) { bool muddy = (gb.board[row][col].type == TileType.Dirty); mud_array[row][col].gameObject.GetComponent <Renderer>().enabled = muddy; } } }
private void updateClean() { GameBoardModel gb = app.game_board_model; for (int col = 0; col < gb.width; col++) { for (int row = 0; row < gb.height; row++) { bool clean = (gb.board[row][col].type == TileType.Clean); clean_array[row][col].gameObject.GetComponent <Renderer>().enabled = clean; } } }
public GameBoardView() { this.InitializeComponent(); this.FormBorderStyle = FormBorderStyle.FixedSingle; var firstPlayer = new HumanPlayer("Koko", "X") { IsOnTurn = true }; var secondPlayer = new HumanPlayer("Boko", "O"); var gameBoardModel = new GameBoardModel(firstPlayer, secondPlayer); this.presenter = new GameBoardPresenter(this, gameBoardModel); }
//----- implementation ----- // Called to start a game previously selected void Launch(GameBoardModel model) { if (model == null) { return; } SetState(GameState.NewGame); _model = model; // reset AI params _model.ThinkTime = ThinkTime; _model.StepCount = StepCount; _model.MaxDepth = MaxDepth; _uimx.CloseCurrent(); StartCoroutine(FadeAndGo()); }
/// <summary> /// Crea las acciones de enroque /// </summary> internal void CreateCastleKingActions(GameBoardModel board, MovementFigureModel movement) { int row = movement.Color == PieceBaseModel.PieceColor.White ? 7 : 0; if (movement.Type == MovementFigureModel.MovementType.CastleKingSide) // enroque corto { CreateMoveAction(PieceBaseModel.PieceType.Rook, movement.Color, new CellModel(row, 7), new CellModel(row, 5)); CreateMoveAction(PieceBaseModel.PieceType.King, movement.Color, new CellModel(row, 4), new CellModel(row, 6)); } else // enroque largo { CreateMoveAction(PieceBaseModel.PieceType.Rook, movement.Color, new CellModel(row, 0), new CellModel(row, 3)); CreateMoveAction(PieceBaseModel.PieceType.King, movement.Color, new CellModel(row, 4), new CellModel(row, 2)); } }
void Start() { Items.FindAllGames(); var initial = Items.ScriptList.Find(s => s.Filename.ToLower() == InitialScript.ToLower()) ?? Items.ScriptList[0]; var model = GameBoardModel.Create(this, initial); if (model != null && InitialVariant > 0 && InitialVariant < model.GameList.Count) { model = model.Create(InitialVariant); } if (model == null) { Quit(); } Launch(model); }
/// <summary> /// Añade un movimiento a la lista /// </summary> private MovementFigureModel ParseMovement(GameBoardModel board, PieceBaseModel.PieceColor actualColor, Move move) { MovementFigureModel newMovement = new MovementFigureModel(); CellConversor cellConversor = new CellConversor(); // Asigna los datos newMovement.Color = actualColor; newMovement.Type = ConvertMovement(move.Type); newMovement.Text = move.ToString(); newMovement.IsCheck = move.IsCheck ?? false; newMovement.IsDoubleCheck = move.IsDoubleCheck ?? false; newMovement.IsCheckMate = move.IsCheckMate ?? false; switch (newMovement.Type) { case MovementFigureModel.MovementType.CastleKingSide: case MovementFigureModel.MovementType.CastleQueenSide: // Asigna la pieza de origen newMovement.OriginPiece = PieceBaseModel.PieceType.Rook; // Crea las acciones de enroque newMovement.Actions.CreateCastleKingActions(board, newMovement); break; default: PieceBaseModel.PieceType?targetPiece = null; // Asigna los datos newMovement.OriginPiece = ConvertPiece(move.Piece); targetPiece = ConvertPiece(move.TargetPiece); // Añade la pieza promocionada if (move.PromotedPiece != null) { newMovement.PromotedPiece = ConvertPiece(move.PromotedPiece); } // Crea las acciones newMovement.Actions.CreateActions(board, newMovement, cellConversor.ConvertCell(move.TargetSquare.Rank, move.TargetSquare.File), cellConversor.ConvertCell(move.OriginRank, move.OriginFile), targetPiece); break; } newMovement.Annotation = ConvertAnnotation(move.Annotation); // Ejecuta los movimientos sobre el tablero board.Execute(newMovement); // Devuelve el movimiento return(newMovement); }