public static void RenderMove(Vector2 from, Vector2 to)
{
var f = BoardRenderer.VectorToSquare(from);
var t = BoardRenderer.VectorToSquare(to);
var figure = chess.GetFigureAt(f);
string move = $"{figure}{f}{t}";
if (t == string.Empty || f == string.Empty || move.Length != 5 || chess == chess.Move(move))
{
//not valid move
BoardRenderer.ShowFigures(chess, Squares, Figures);
BoardRenderer.MarkSquaresFrom(chess, Squares);
return;
}
Debug.Log(move);
if (figure == 'P' && t[1] == '8' || figure == 'p' && t[1] == '1')
{
if (chess != chess.Move(move))
{
onPromotionMove = move;
BoardRenderer.ShowPromotionsFigures(Promotions, figure);
return;
}
}
chess = chess.Move(move);
BoardRenderer.ShowFigures(chess, Squares, Figures);
BoardRenderer.MarkSquaresFrom(chess, Squares);
}
/// <summary>
/// Occurs when this scene is entered
/// </summary>
public override void Enter()
{
// setup graphics resources
sbGUI = new SpriteBatch(GraphicsManager.Instance.Device);
sbFore = new SpriteBatch(GraphicsManager.Instance.Device);
sbBack = new SpriteBatch(GraphicsManager.Instance.Device);
font = Engine.Instance.Content.GetAsset <Font>(Constants.ASSET_FONT_CONSOLE);
camera = new Camera2();
boardRenderer = new BoardRenderer(manager.Client, camera);
unitRenderer = new UnitRenderer(boardRenderer, camera, manager.Client);
camera.Translation = boardRenderer.GetTileCentre(manager.Client.GetMyUnits()[0].Location);
camera.TranslationTarget = camera.Translation;
// set up gui elements
canvas = new Canvas(GraphicsManager.Instance.Viewport.Bounds);
ConsoleForm consoleForm = new ConsoleForm(canvas);
GUI_Map map = new GUI_Map(camera, manager.Client, boardRenderer, canvas);
GUI_StatusBar statusBar = new GUI_StatusBar(manager.Client, this, canvas);
GUI_EndTurn endTurn = new GUI_EndTurn(manager.Client, canvas);
CityList = new GUI_CityList(manager.Client, this, canvas);
UnitList = new GUI_UnitList(manager.Client, this, canvas);
UnitActions = new GUI_UnitActions(manager.Client, this, camera, boardRenderer, canvas);
CityManagment = new GUI_CityManagment(manager.Client, this, canvas);
GUI_NamePlates namePlates = new GUI_NamePlates(manager.Client, canvas, camera, boardRenderer);
TechTree = new GUI_Tech(manager.Client, this, canvas);
GameMenu = new GUI_GameMenu(manager.Client, this, canvas);
SocialPolicy = new GUI_SocialPolicy(manager.Client, this, canvas);
}
public void ReturnWelcomeMessage()
{
var result = _messageHandler.GetWelcomeMessage(_board);
var boardRenderer = new BoardRenderer(_board);
Assert.Equal("Welcome to Tic Tac Toe!\n\nHere's the current board:\n\n" + boardRenderer.ToText(), result);
}
// Start is called before the first frame update
void Start()
{
InitGameObjects(Squares, Figures, Promotions);
BoardRenderer.ShowFigures(Chess, Squares, Figures);
BoardRenderer.MarkSquaresFrom(Chess, Squares);
BoardRenderer.ShowPromotionsFigures(Promotions);
}
public static void RenderMove(Vector2 from, Vector2 to)
{
var f = BoardRenderer.VectorToSquare(from);
var t = BoardRenderer.VectorToSquare(to);
var figure = Chess.GetFigureAt(f);
string move = $"{figure}{f}{t}";
if (t == string.Empty || f == string.Empty || move.Length != 5 || Chess == Chess.Move(move))
{
BoardRenderer.ShowFigures(Chess, Squares, Figures);
BoardRenderer.MarkSquaresFrom(Chess, Squares);
return;
}
Debug.Log(move);
if (figure == 'P' && t[1] == '8' || figure == 'p' && t[1] == '1')
{
if (Chess != Chess.Move(move))
{
OnPromotionMove = move;
BoardRenderer.ShowPromotionsFigures(Promotions, figure);
return;
}
}
Chess = Chess.Move(move);
BoardRenderer.ShowFigures(Chess, Squares, Figures);
BoardRenderer.UnmarkSquares(Squares);
ChangeMoveColor();
}
public static void PickObject(Vector2 from)
{
if (!IsWhiteMove)
{
return;
}
if (OnPromotionMove != string.Empty)
{
int x = Convert.ToInt32(from.x);
if (OnPromotionMove[0] == 'P')
{
if (x == 2)
{
OnPromotionMove += 'Q';
}
if (x == 3)
{
OnPromotionMove += 'R';
}
if (x == 4)
{
OnPromotionMove += 'B';
}
if (x == 5)
{
OnPromotionMove += 'N';
}
}
else if (OnPromotionMove[0] == 'p')
{
if (x == 2)
{
OnPromotionMove += 'q';
}
if (x == 3)
{
OnPromotionMove += 'r';
}
if (x == 4)
{
OnPromotionMove += 'b';
}
if (x == 5)
{
OnPromotionMove += 'n';
}
}
Chess = Chess.Move(OnPromotionMove);
OnPromotionMove = string.Empty;
BoardRenderer.ShowPromotionsFigures(Promotions);
BoardRenderer.ShowFigures(Chess, Squares, Figures);
BoardRenderer.MarkSquaresFrom(Chess, Squares);
ChangeMoveColor();
return;
}
BoardRenderer.MarkSquaresTo(Chess, Squares, from);
}
public void ReturnWinMessage()
{
var result = _messageHandler.GetWinMessageAndBoard(_board);
var renderer = new BoardRenderer(_board);
Assert.Equal("Move accepted, well done you've won the game!\n\n" + renderer.ToText(), result);
}
static void Main(string[] args)
{
WriteIntro();
Game game;
IPlayer player1;
IPlayer player2;
do
{
game = new Game();
boardRenderer = new BoardRenderer(game.Board);
string name = GetPlayerName("player1");
player1 = new HumanPlayer(name, boardRenderer);
game.Join(player1);
player2 = new BotPlayer();
game.Join(player2);
Console.WriteLine();
} while (Play(game, player1, player2));
Console.WriteLine();
WriteLine("Thanks for playing ZNim. Play again soon! [press Enter to exit]", Console.ForegroundColor);
Console.ReadLine();
}
void Start()
{
var boardSettings = GetComponent <BoardSettings>();
rowCount = boardSettings.rows;
columnCount = boardSettings.columns;
cellWidth = boardSettings.cellWidth;
cellHeight = boardSettings.cellHeight;
boardWidth = columnCount * cellWidth;
boardHeight = rowCount * cellHeight;
#if (UNITY_ANDROID || UNITY_IO || UNITY_WP8)
input = new MobileInput();
#endif
#if (UNITY_STANDALONE || UNITY_EDITOR || UNITY_WEBPLAYER)
input = new StandaloneInput();
#endif
if (camera == null)
{
camera = Camera.main;
}
match3Game = new Match3Game(rowCount, columnCount, new HashSet <BlockColor> {
BlockColor.Yellow, BlockColor.Blue, BlockColor.Orange, BlockColor.Green, BlockColor.Red, BlockColor.Purple
});
boardRenderer = GetComponent <BoardRenderer>();
boardRenderer.SetGame(match3Game);
boardRenderer.Render();
StartCoroutine(MainLoop());
}
protected Board createBoard(int width, int height)
{
int fieldSize = 20;
BoardRenderer renderer = new BoardRenderer(this.canvas, width, height, fieldSize);
board = new Board(width, height, fieldSize, renderer);
return(board);
}
private void Draw()
{
Graphics.BeginDraw();
BoardRenderer.Render(Board);
Graphics.EndDraw();
}
public void ReturnAcceptedMoveMessage()
{
_board.AddMove(1, 1, "X");
var boardRenderer = new BoardRenderer(_board);
var result = _messageHandler.GetAcceptedMoveMessageAndBoard(_board);
Assert.Equal("Move Accepted, here's the current board:\n" + boardRenderer.ToText(), result);
}
void Start()
{
//"rnbqkbnr/ppPppp1p/8/8/8/8/PP1PPPpP/RNBQKBNR w KQkq - 0 1"
InitGameObjects(Squares, Figures, Promotions);
BoardRenderer.ShowFigures(chess, Squares, Figures);
BoardRenderer.MarkSquaresFrom(chess, Squares);
BoardRenderer.ShowPromotionsFigures(Promotions);
}
public void ThrowWhenCantGetValueFromBoard()
{
BoardRenderer boardRenderer = GetBoardRenderer(out Mock <BoardValueFetcher> boardValueFetcher, false);
Assert.Throws <Exception>(() => boardRenderer.Render(new AccessibleBoard {
AccessibleSize = 2
}));
}
private void CreateWindowAndRenderNewBoard()
{
board = new SquareBoard(TestValueProvider.BoardSize);
window = new Window(new DummyGameView(), new DummyGameController());
var boardCellFactory = new BoardCellFactory(new DummyGameController(), TestValueProvider.defaultImage);
boardRenderer = new BoardRenderer(window, board, boardCellFactory);
boardRenderer.Render();
}
public GUI_NamePlates(Client client, Canvas canvas, Camera2 camera, BoardRenderer boardRenderer)
{
this.client = client;
this.canvas = canvas;
this.camera = camera;
this.boardRenderer = boardRenderer;
LoadResources();
Show();
}
public GUI_UnitActions(Client client, SceneGame sceneGame, Camera2 camera, BoardRenderer boardRenderer, Canvas canvas)
{
this.client = client;
this.sceneGame = sceneGame;
this.camera = camera;
this.canvas = canvas;
this.boardRenderer = boardRenderer;
client.SelectedUnitChnaged += Client_SelectedUnitChnaged;
}
public static void PickObject(Vector2 from)
{
if (onPromotionMove != string.Empty)
{
int x = Convert.ToInt32(from.x);
if (onPromotionMove[0] == 'P')
{
if (x == 2)
{
onPromotionMove += 'Q';
}
if (x == 3)
{
onPromotionMove += 'R';
}
if (x == 4)
{
onPromotionMove += 'B';
}
if (x == 5)
{
onPromotionMove += 'N';
}
}
else if (onPromotionMove[0] == 'p')
{
if (x == 2)
{
onPromotionMove += 'q';
}
if (x == 3)
{
onPromotionMove += 'r';
}
if (x == 4)
{
onPromotionMove += 'b';
}
if (x == 5)
{
onPromotionMove += 'n';
}
}
chess = chess.Move(onPromotionMove);
onPromotionMove = string.Empty;
BoardRenderer.ShowPromotionsFigures(Promotions);
BoardRenderer.ShowFigures(chess, Squares, Figures);
BoardRenderer.MarkSquaresFrom(chess, Squares);
return;
}
BoardRenderer.MarkSquaresTo(chess, Squares, from);
}
public PieceEntity(PieceRenderer pieceRenderer, BoardRenderer boardRenderer, Piece piece)
{
Alive = true;
Name = "Piece";
Transform = new Transform();
Position = Point.Zero;
Piece = piece;
_pieceRenderer = pieceRenderer;
_boardRenderer = boardRenderer;
}
static void ShowSquare(int x, int y, bool marked = false)
{
string square = ((x + y) % 2 == 1) ? "whiteSquare" : "blackSquare";;
if (marked)
{
square += "Marked";
}
BoardRenderer.SetSprite(Squares[$"{x}{7 - y}"], square);
}
private BoardRenderer GetBoardRenderer(out Mock <BoardValueFetcher> boardValueFetcher, bool hasValue)
{
boardValueFetcher = new Mock <BoardValueFetcher>();
BoardRenderer boardRenderer = new BoardRenderer(boardValueFetcher.Object);
int? value = null;
string error = string.Empty;
boardValueFetcher.Setup(bvf => bvf.TryGetValueAt(It.IsAny <Board>(), It.IsAny <int>(), It.IsAny <int>(), out value, out error))
.Returns(hasValue);
return(boardRenderer);
}
public GUI_Map(Camera2 camera, Client client, BoardRenderer boardRenderer, Canvas canvas)
{
this.camera = camera;
this.boardRenderer = boardRenderer;
this.client = client;
this.canvas = canvas;
// load resources
blankTileSprite = new Sprite(boardRenderer.TileAtlas, "TILEUTIL_BLANK");
tileOutlineSprite = new Sprite(boardRenderer.TileAtlas, "TILEUTIL_OUTLINE");
Show();
}
public void ReturnEmptyBoard()
{
var board = new Board();
board.Initialise();
var renderer = new BoardRenderer(board);
var stringBoard = renderer.ToText();
var expectedString = "...\n...\n...\n";
Assert.Equal(expectedString, stringBoard);
}
public BoardEntity(BoardRenderer boardRenderer)
{
Alive = true;
Name = Id;
IsFalling = false;
Transform = new Transform();
_board = new Board(new Size(10, 20));
_boardRenderer = boardRenderer;
Movement = new BoardMovement(_board);
}
public void VarifyThatAllTheValuesAreRendered()
{
int? value = null;
string error = string.Empty;
BoardRenderer boardRenderer = GetBoardRenderer(out Mock <BoardValueFetcher> boardValueFetcher, true);
string renderedBoard = boardRenderer.Render(new AccessibleBoard {
AccessibleSize = 2
});
boardValueFetcher.Verify(bvf => bvf.TryGetValueAt(It.IsAny <Board>(), It.IsAny <int>(), It.IsAny <int>(), out value, out error),
Times.Exactly(4));
Assert.False(string.IsNullOrEmpty(renderedBoard));
}
public override void OnInspectorGUI()
{
DrawDefaultInspector();
BoardRenderer br = (BoardRenderer)target;
if (GUILayout.Button("Render"))
{
br.render();
}
//base.OnInspectorGUI();
}
public void ReturnFilledBoard()
{
var board = new Board();
board.Initialise();
board
.AddMove(1, 1, "X")
.AddMove(1, 3, "O")
.AddMove(2, 2, "X")
.AddMove(3, 3, "O");
var renderer = new BoardRenderer(board);
var stringBoard = renderer.ToText();
var expectedString = "X..\n.X.\nO.O\n";
Assert.Equal(expectedString, stringBoard);
}
public static void Initialize(int size)
{
Size = size;
Snake = new Entities.Snake(new Position {
X = 5, Y = Size / 2
});
var foodInitialRandom = new Random();
Food = new Food(new Position {
X = foodInitialRandom.Next(0, Size), Y = foodInitialRandom.Next(0, Size)
});
Renderer = new BoardRenderer(Size);
Renderer
.AddBlocks(Snake.GetBlocks(), 0)
.AddBlock(Food.GetBlock(), 1)
.Render();
}
public Game()
{
var basePath = Path.GetDirectoryName(Assembly.GetEntryAssembly()?.Location ?? "");
Directory.SetCurrentDirectory(basePath);
if (glfwInit() == 0)
{
throw new InvalidOperationException("Failed to initialize GLFW.");
}
glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
_window = glfwCreateWindow(1024, 768, "SameGame", IntPtr.Zero, IntPtr.Zero);
if (_window == IntPtr.Zero)
{
throw new InvalidOperationException("Failed to create window.");
}
_windowSizeCallback = (a, b, c) => OnWindowSize(a, b, c);
glfwSetWindowSizeCallback(_window, _windowSizeCallback);
_keyboardCallback = (a, b, c, d, e) => OnKeyboard(a, b, c, d, e);
glfwSetKeyCallback(_window, _keyboardCallback);
_mouseMoveCallback = (a, b, c) => OnMouseMove(a, b, c);
glfwSetCursorPosCallback(_window, _mouseMoveCallback);
_mouseButtonCallback = (a, b, c, d) => OnMouseButton(a, b, c, d);
glfwSetMouseButtonCallback(_window, _mouseButtonCallback);
GLUtils.CreateContext(_window, out _display, out _surface);
Graphics = new Graphics(this);
BoardRenderer = new BoardRenderer(Graphics);
Board = new Board(new RNG(100));
}
static public void ShowFigures()
{
for (int x = 0; x < 8; x++)
{
for (int y = 0; y < 8; y++)
{
int transY = 7 - y;
string key = $"{x}{transY}";
string figure = Chess.GetFigureAt(x, transY).ToString();
Figures[key].transform.position = Squares[$"{x}{y}"].transform.position;
if (Figures[key].name == figure)
{
continue;
}
BoardRenderer.SetSprite(Figures[key], figure);
Figures[key].name = figure;
}
}
}
protected Board createBoard(int width, int height)
{
int fieldSize = 20;
BoardRenderer renderer = new BoardRenderer (this.canvas, width, height, fieldSize);
board = new Board (width, height, fieldSize, renderer);
return board;
}
public TicTacToeGamePresenter(GameView game_view, Game game, BoardRenderer board_renderer)
{
_game_view = game_view;
_game = game;
_board_renderer = board_renderer;
}
