static void Init()
{
// Get existing open window or if none, make a new one:
BoardGenerator window = (BoardGenerator)EditorWindow.GetWindow(typeof(BoardGenerator));
window.Show();
}
// Use this for initialization
void Start()
{
boards = new Board[6];
boards[0] = new Board(sizeBoard, sizeBoard);
boards[1] = new Board(sizeBoard, sizeBoard);
boards[2] = new Board(sizeBoard, sizeBoard);
boards[3] = new Board(sizeBoard, sizeBoard);
boards[4] = new Board(sizeBoard, sizeBoard);
boards[5] = new Board(sizeBoard, sizeBoard);
plateau = GetComponent <BoardGenerator>();
plateau.initSize(sizeBoard);
pp = GetComponent <PositionPawn>();
positionPawns = GetComponent <PositionPawns>();
gameGoal = GetComponent <GameGoal>();
teamTurn = GetComponent <TeamTurn>();
plateau.DessinerEchiquier(boards);
positionPawns.PositionSomeTypePawns(plateau, boards);
gameGoal.InitGameGoal(positionPawns.GetPositions, boards);
// everything is ready
GameObject daddyGO = GameObject.Find("pawns");
foreach (PawnElement pe in daddyGO.GetComponentsInChildren <PawnElement>())
{
teamTurn.AddObserver(pe);
pe.PositionPawns = positionPawns;
}
}
// TODO: pool action fields
private void SpawnActionFields()
{
BoardGenerator board = GameController.Instance.board;
for (int i = 0; i < BoardGenerator.GridSize; ++i)
{
for (int j = 0; j < BoardGenerator.GridSize; ++j)
{
FieldScript targetField = board.GetField(i, j);
if (CheckMovement(targetField))
{
GameObject go;
ActionField af;
if (!targetField.occupied)
{
go = Instantiate(moveFieldPrefab);
af = go.GetComponent <MoveField>();
}
else
{
go = Instantiate(attackFieldPrefab);
af = go.GetComponent <AttackField>();
}
af.Set(this, targetField);
actionFields.Add(af);
}
}
}
}
public Ball(int i, int j, BoardGenerator bg, int x)
{
m_x = i;
m_y = j;
m_bg = bg;
setColor(x);
}
void Enter()
{
var board = new BoardGenerator().GenerateRandom(16, 3);
var game = new Game(board, GameRules.KeepSameRules, PieceType.GetRange(0, 3));
bc.SetGame(game, logo);
}
private void Start()
{
gm = GameManager.instance;
bg = BoardGenerator.instance;
gm.boardGenerator = bg;
gm.LoadPrefabs();
}
public override void ApplyEffect(Tile tile)
{
Unit user = GameplayManager.Instance.UnitSelected;
for (int i = 0; i < 1 + user.lvl; i++)
{
Unit inter = Component.Instantiate(Spawn_Control.Instance.Player).GetComponent <Unit>();
inter.c = "INTER";
inter.name = File.ReadAllLines(".\\name_list.txt")[Random.Range(0, 100)];
inter.lvl = user.lvl;
int stat = 20 * inter.lvl;
inter.hpMax = stat;
inter.currentHP = inter.hpMax;
inter.attack = stat;
inter.defense = stat;
inter.attackMental = stat;
inter.defenseMental = stat;
inter.speed = 70 * user.lvl;
inter.range = 3;
GameObject o = new GameObject("Inter " + i);
if (TurnManager.Instance.Team1.Contains(user))
{
TurnManager.Instance.Team1.Add(inter);
}
else
{
TurnManager.Instance.Team2.Add(inter);
}
TurnManager.Instance.turnOrder.Add(inter);
int temp = i;
int newx = user.CurrentTile.x + (i >= 2 ? 1 : -1);
int newy = user.CurrentTile.y + (i % 2 == 0 ? -1 : 1);
inter.MoveTo(BoardGenerator.tiles[BoardGenerator.CoordToIndex(newx, newy)], true);
}
}
// Use this for initialization
void Start()
{
VectorLine.SetEndCap("rounded", EndCap.Mirror, lineMaterial, capTex);
Vector3 size = exampleObject.GetComponentInChildren <SpriteRenderer> ().bounds.size;
objectWidth = size.x;
objectHeight = size.y;
boardWidth = objectWidth * width + paddingX * (width - 1) - objectWidth;
boardHeight = objectHeight * height + paddingY * (height - 1) - objectHeight;
selectedBlocks = new List <Block> ();
generator = new BoardGenerator(objectPrefabs.Count, width, height);
Game.Instance.setBoardManager(this);
createBoard();
positionBoard();
//gameObject.RotateBy(new Vector3(0, 0, -0.005f), 0.5f, 0, EaseType.easeInOutSine, LoopType.pingPong);
//InvokeRepeating("fillEmpty", 0.25f, 0.5f);
InvokeRepeating("updateRotation", 0.5f, 0.5f);
}
public void Setup()
{
_logger = new Logger();
var user = new User();
var boardPrinter = new ConsoleBoardPrinter();
var scoreManager = new ScoreManager();
_actionParser = new ActionParser();
_boardManager = new BoardManager();
_boardGenerator = new BoardGenerator();
// Delete all the scores at the start of each test.
scoreManager.DeleteAll();
//Setups the game
_gameManager = new GameManager(boardPrinter, _boardManager, _boardGenerator, _actionParser, scoreManager, user);
_boardOptions = new BoardOptions(new Vector2(5, 5), 5);
_board = _boardGenerator.GenerateBoard(_boardOptions);
// Generate all positions file
FileGenerator.GenerateAllPositions(_board);
}
public void BoardGenerator_GenerateBoard_Nominal()
{
for (var i = 0; i < 200; i++)
{
// Act
var(solvedBoard, playingBoard) = _boardGenerator.GenerateBoard(_gameConfig);
// Assert
foreach (var board in new[] { solvedBoard, playingBoard })
{
Assert.Equal(_height, board.Height);
Assert.Equal(_width, board.Width);
Assert.Equal(_height * _width, board.Cells.Length);
var nonNullCenterCellMovesCount = BoardGenerator.Moves(board.Cells[_height / 2, _width / 2]);
Assert.True(nonNullCenterCellMovesCount >= 2);
Assert.True(nonNullCenterCellMovesCount <= 3);
}
for (var row = 0; row < solvedBoard.Height; row++)
{
for (var col = 0; col < solvedBoard.Width; col++)
{
Assert.Equal(BoardGenerator.Moves(solvedBoard.Cells[row, col]), BoardGenerator.Moves(playingBoard.Cells[row, col]));
}
}
}
}
public void SpawnPlayers()
{
ParseTeam(Team1, true);
ParseTeam(Team2, false);
for (int i = 0; i < this.Team1.Count; i++)
{
Unit c = Team1 [i];
if (c != null)
{
c.MoveTo(BoardGenerator.tiles[BoardGenerator.CoordToIndex(0, i * 6)], true);
//c.GetComponentInParent<MeshRenderer>().material.color = Color.blue;
}
}
for (int i = 0; i < this.Team2.Count; i++)
{
Unit c = Team2 [i];
if (c != null)
{
c.MoveTo(BoardGenerator.tiles[BoardGenerator.CoordToIndex(49, i * 6)], true);
// c.GetComponent<MeshRenderer>().material.color = Color.red;
}
}
}
void InitBoard()
{
grid = boardRect.GetComponent <GridLayoutGroup>();
grid.constraint = GridLayoutGroup.Constraint.FixedColumnCount;
grid.constraintCount = boardColumnCount;
boardWidth = boardRect.sizeDelta.x;
boardHeight = boardRect.sizeDelta.y;
int numCells = boardColumnCount * boardRowCount;
for (int i = 0; i < numCells; i++)
{
CellSlot cellSlot = Instantiate(cellSlotPrefab, boardRect);
slotList.Add(cellSlot);
}
BoardEditor be = FindObjectOfType <BoardEditor>();
if (be != null)
{
be.LoadSlots();
}
BoardGenerator bg = GetComponent <BoardGenerator>();
if (bg != null)
{
bg.GenerateBoard();
}
}
public static GameState CreateCallState(GameState parent)
{
var hero = new Player(parent.Hero);
var villain = new Player(parent.Villain);
var toPlay = hero.IsToPlay ? hero : villain;
var callAmount = toPlay.Wager(parent.WagerToCall);
var newPot = parent.Pot + callAmount;
var board = parent.AnyAllIn ?
BoardGenerator.FillToRiver(parent.Board, parent.Street, hero.HoleCards) :
parent.Board;
var street = parent.AnyAllIn ? Street.Showdown : parent.Street.GetNextStreet();
hero.IsToPlay = hero.IsFirstToActAfterFlop() ? true : !hero.IsToPlay;
villain.IsToPlay = villain.IsFirstToActAfterFlop() ? true : !villain.IsToPlay;
var state = new GameState(
parent,
board,
street,
hero,
villain,
newPot,
0.0d,
Action.Call);
return(state);
}
public Game(IPlayer player)
{
this.player = player;
State = GameState.IN_PROCESS;
var generator = new BoardGenerator();
Board = generator.Generate(4, 4);
}
static void OpenWindow()
{
BoardGenerator window = (BoardGenerator)GetWindow(typeof(BoardGenerator));
window.minSize = new Vector2(50, 50);
window.maxSize = new Vector2(600, 100);
window.Show();
}
public override void OnInspectorGUI()
{
base.OnInspectorGUI();
BoardGenerator map = target as BoardGenerator;
map.GenerateBoard();
}
public Game()
{
player = null;
State = GameState.IN_PROCESS;
var generator = new BoardGenerator();
Board = generator.Generate(4, 4);
}
private void GenerateBoard()
{
_boardGenerator = GetComponent <BoardGenerator>();
_board = _boardGenerator.GenerateBoard(_boardBlueprint);
_boardMapper = new BoardMapper();
_boardMapper.MapNeighbours(_board);
}
private static void TryUpdateBoard(GameState state, Street streetToStartUpdateFrom)
{
if (!state.AnyAllIn)
{
state.Board = BoardGenerator.FillToRiver(
state.Board, streetToStartUpdateFrom, state.Hero.HoleCards);
}
}
public ActionResult Index()
{
var viewModel = new SudokuSolverViewModel()
{
Board = BoardGenerator.GenerateBoard().ToStringBoard()
};
return(View(viewModel));
}
public BoardGeneratorTests()
{
_height = 9;
_width = 9;
_gameConfig = new GameConfig {
Height = _height, Width = _width
};
_boardGenerator = new BoardGenerator();
}
public void BeginGame()
{
currentMaze = Instantiate(mazePrefab);
currentMaze.Generate();
SpawnCharacter(0);
SpawnCharacter(1);
myPlayer = 0;
FakeNetworkController.instance.SendTurnChange(0);
}
public void Setup()
{
board = FindObjectOfType <BoardGenerator>();
var graph = (GridGraph)AstarPath.active.data.graphs[0];
graph.SetDimensions(board.width, board.height, 1f);
graph.center = new Vector3(((float)board.width / 2) - 0.5f, ((float)board.height / 2) - 0.5f);
AstarPath.active.Scan();
}
public void GenerateHand_GeneratesTwoCards()
{
for (int i = 0; i < 1000; i++)
{
var hand = BoardGenerator.GenerateHand().ToString();
Assert.True(hand.Split(',').Length == 2, $"{hand}");
}
}
public void GenerateFlop_GeneratesThreeCards()
{
for (int i = 0; i < 1000; i++)
{
var hand = BoardGenerator.GenerateFlop().ToString();
Assert.True(hand.Split(',').Length == 3, $"{hand}");
}
}
public void Board_is_generated_correctly()
{
var gen = new BoardGenerator();
gen.MakeBoard();
var result = gen.PrintBoard();
Assert.AreEqual(17, result.Count(x => x == '#'));
}
public void Test()
{
Debug.Log("test");
//generate 5 boards
for (int i = 0; i < 5; i++)
{
Board b = BoardGenerator.GenerateBoard();
pm.BoardsInventory.Add(b);
}
}
public void TestSameSeedSameBoard()
{
const int seed = 123456789;
var generator = new BoardGenerator();
var boardSize = new Vector2(10, 10);
var board = generator.GenerateBoard(new BoardOptions(boardSize, 10, seed));
Assert.AreEqual(board, generator.GenerateBoard(new BoardOptions(boardSize, 10, seed)));
}
private BoardCell GetRandomCellToSpawnUnitAt(UnitTeam forTeam)
{
BoardGenerator boardGenerator = GameBoard.Instance.Generator;
int columns = boardGenerator.BoardSize.x;
int startIndex = forTeam.Side == TeamSide.Left ? 0 : columns - forTeam.SpawnColumns;
int endIndex = startIndex + forTeam.SpawnColumns - 1;
return(boardGenerator.GetRandomEmptyCellInColumnRange(startIndex, endIndex));
}
private void Awake()
{
if (instance)
{
Destroy(gameObject);
return;
}
instance = this;
player1Board = transform.FindDeepChild("Player1Board");
}
/// <summary>
/// Initialize this component inspector.
/// </summary>
void OnEnable()
{
// Cache a reference to the BoardGenerator.
generator = target as BoardGenerator;
}
