// Use this for initialization
void Start()
{
// Find the ORIGIN Game Object
_gobOrigin = GameObject.FindGameObjectWithTag ("ORIGIN");
// Find UI objects
gobTxt_Size_X = GameObject.FindGameObjectWithTag ("TXT_SIZE_X");
gobTxt_Size_Y = GameObject.FindGameObjectWithTag ("TXT_SIZE_Y");
// Get the GridGenerator component attached to _gridGridGenerator
_grdGridGenerator = _gobOrigin.GetComponent<GridGenerator> () as GridGenerator;
// Get the Slider component attached to this Game Object
_sdrMySlide = gameObject.GetComponent<Slider> () as Slider;
// Get the Text component attached to text UI objects
txtSize_X = gobTxt_Size_X.GetComponent<Text> () as Text;
txtSize_Y = gobTxt_Size_Y.GetComponent<Text> () as Text;
// Get the maximum grid sizes
_iMaxX = _grdGridGenerator.iMaxX;
_iMaxY = _grdGridGenerator.iMaxY;
// Set the maximum value of this slider to the grid maximum
_sdrMySlide.maxValue = (bIsY) ? _iMaxY : _iMaxX;
// Set the max slider value to the maximum possible value
if (bControlsBoth) {
_sdrMySlide.maxValue = Mathf.Max(_iMaxX, _iMaxY);
}
// Set the value of this slider to the current grid size value
_sdrMySlide.value = (float)((bIsY) ? _grdGridGenerator.iMaxValY : _grdGridGenerator.iMaxValX);
}
// END CUT HERE
// BEGIN CUT HERE
public static void Main()
{
try {
GridGenerator ___test = new GridGenerator();
___test.run_test(-1);
} catch(Exception e) {
//Console.WriteLine(e.StackTrace);
Console.WriteLine(e.ToString());
}
}
private void Awake()
{
m_Grid = new Grid(8, 8);
var gg = new GridGenerator();
gg.Generate(m_Grid);
for (int i = 0; i < m_Grid.Width; i++) {
for (int j = 0; j < m_Grid.Height; j++) {
var nodeObject = (GameObject)Instantiate(m_NodePrefab, new Vector3(i, j, 0.0f), Quaternion.identity);
var sr = nodeObject.GetComponent<SpriteRenderer>();
var node = m_Grid[i, j];
if (node.GetType() == typeof(AdditionNode)) {
sr.sprite = m_GrassSprite;
} else {
sr.sprite = m_DirtSprite;
}
}
}
}
public void DrawMapInEditor()
{
if (tileMapSettings.createOuterWalls)
{
if (tileMapSettings.isVoxelMap)
{
///
/// Room Adder
//DrawMesh(DiscreteVoxelMeshGenerator.GenerateGridMesh(OuterWallsGenerator.CreateOuterWalls(MazeGenerator.ConvertToEmptyGrid(Sidewinder.CreateMaze(RandomRoomPlacementMazeAdder.AddRoomsToMaze(MazeGenerator.GenerateMazeGrid(mazeSettings), roomAdder), sidewinder))), tileMapSettings));
//DrawMesh(DiscreteVoxelMeshGenerator.GenerateGridMesh(OuterWallsGenerator.CreateOuterWalls(MazeGenerator.ConvertToEmptyGrid(MazeGenerator.GenerateMazeGrid(mazeSettings))), tileMapSettings));
///
/// Fractal
//DrawMesh(DiscreteVoxelMeshGenerator.GenerateGridMesh(OuterWallsGenerator.CreateOuterWalls(MazeGenerator.ConvertToEmptyGrid(RecursiveDivision.CreateMaze(MazeGenerator.GenerateMazeGrid(mazeSettings)))), tileMapSettings));
///
/// Eller
//DrawMesh(DiscreteVoxelMeshGenerator.GenerateGridMesh(OuterWallsGenerator.CreateOuterWalls(MazeGenerator.ConvertToEmptyGrid(Eller.CreateMaze(MazeGenerator.GenerateMazeGrid(mazeSettings)))), tileMapSettings));
///
/// Growing Tree
//DrawMesh(DiscreteVoxelMeshGenerator.GenerateGridMesh(OuterWallsGenerator.CreateOuterWalls(MazeGenerator.ConvertToEmptyGrid(GrowingTree.CreateMaze(MazeGenerator.GenerateMazeGrid(mazeSettings)))), tileMapSettings));
//DrawMesh(DiscreteVoxelMeshGenerator.GenerateGridMesh(OuterWallsGenerator.CreateOuterWalls(MazeGenerator.ConvertToEmptyGrid(GrowingTree.CreateMaze(MazeGenerator.GenerateMazeGrid(mazeSettings), null, x => x[x.Count-1]))), tileMapSettings));
//DrawMesh(DiscreteVoxelMeshGenerator.GenerateGridMesh(OuterWallsGenerator.CreateOuterWalls(MazeGenerator.ConvertToEmptyGrid(GrowingTree.CreateMaze(MazeGenerator.GenerateMazeGrid(mazeSettings), null, x => Random.value < 0.5f ? x[x.Count-1] : x[Random.Range(0, x.Count)]))), tileMapSettings));
///
/// Prim Weighted Cells
//DrawMesh(DiscreteVoxelMeshGenerator.GenerateGridMesh(OuterWallsGenerator.CreateOuterWalls(MazeGenerator.ConvertToEmptyGrid(PrimWeightedCells.CreateMaze(MazeGenerator.GenerateMazeGrid(mazeSettings)))), tileMapSettings));
///
/// Prim Same Weight
//DrawMesh(DiscreteVoxelMeshGenerator.GenerateGridMesh(OuterWallsGenerator.CreateOuterWalls(MazeGenerator.ConvertToEmptyGrid(PrimSameWeight.CreateMaze(MazeGenerator.GenerateMazeGrid(mazeSettings)))), tileMapSettings));
///
/// Kruskal
//DrawMesh(DiscreteVoxelMeshGenerator.GenerateGridMesh(OuterWallsGenerator.CreateOuterWalls(MazeGenerator.ConvertToEmptyGrid(RandomizedKruskal.CreateMaze(MazeGenerator.GenerateMazeGrid(mazeSettings)))), tileMapSettings));
///
/// Recursive Backtracker
//DrawMesh(DiscreteVoxelMeshGenerator.GenerateGridMesh(OuterWallsGenerator.CreateOuterWalls(MazeGenerator.ConvertToEmptyGrid(RecursiveBacktracker.CreateMaze(MazeGenerator.GenerateMazeGrid(mazeSettings)))), tileMapSettings));
///
/// Hunt and Kill
//DrawMesh(DiscreteVoxelMeshGenerator.GenerateGridMesh(OuterWallsGenerator.CreateOuterWalls(MazeGenerator.ConvertToEmptyGrid(HuntAndKill.CreateMaze(MazeGenerator.GenerateMazeGrid(mazeSettings)))), tileMapSettings));
///
/// Wilson
//DrawMesh(DiscreteVoxelMeshGenerator.GenerateGridMesh(OuterWallsGenerator.CreateOuterWalls(MazeGenerator.ConvertToEmptyGrid(Wilson.CreateMaze(MazeGenerator.GenerateMazeGrid(mazeSettings)))), tileMapSettings));
///
/// Aldous-Broder
//DrawMesh(DiscreteVoxelMeshGenerator.GenerateGridMesh(OuterWallsGenerator.CreateOuterWalls(MazeGenerator.ConvertToEmptyGrid(AldousBroder.CreateMaze(MazeGenerator.GenerateMazeGrid(mazeSettings)))), tileMapSettings));
///
/// Sidewinder
//DrawMesh(DiscreteVoxelMeshGenerator.GenerateGridMesh(OuterWallsGenerator.CreateOuterWalls(MazeGenerator.ConvertToEmptyGrid(Sidewinder.CreateMaze(MazeGenerator.GenerateMazeGrid(mazeSettings), sidewinder))), tileMapSettings));
///
/// Binary Tree
//DrawMesh(DiscreteVoxelMeshGenerator.GenerateGridMesh(OuterWallsGenerator.CreateOuterWalls(MazeGenerator.ConvertToEmptyGrid(BinaryTree.CreateMaze(MazeGenerator.GenerateMazeGrid(mazeSettings), btree))), tileMapSettings));
/// With Distances
//DistanceMazeGrid mazeGrid = (DistanceMazeGrid)BinaryTree.CreateMaze(MazeGenerator.GenerateMazeGrid(mazeSettings), btree);
//DrawMesh(DiscreteVoxelMeshGenerator.GenerateGridMesh(OuterWallsGenerator.CreateOuterWalls(MazeGenerator.ConvertToEmptyGrid(BinaryTree.CreateMaze(MazeGenerator.GenerateMazeGrid(mazeSettings), btree))), tileMapSettings));
//mazeGrid.distances = mazeGrid.values[0, 0].FindDistanceForAllReachableLinkedCells();
//Debug.Log(mazeGrid.ToString());
///
/// MAZES
/// ///
///
/// Settling
//SettlingRooms.PreprocessMap(tileMapSettings, settling);
//DrawMesh(DiscreteVoxelMeshGenerator.GenerateGridMesh(OuterWallsGenerator.CreateOuterWalls(SettlingRooms.ProcessMap(GridGenerator.GenerateEmptyGrid(tileMapSettings), settling)), tileMapSettings));
///
/// From prefab
//GridMapFromPrefabs.PreprocessMap(tileMapSettings, mapFromPrefab);
//DrawMesh(DiscreteVoxelMeshGenerator.GenerateGridMesh(OuterWallsGenerator.CreateOuterWalls(GridMapFromPrefabs.ProcessMap(GridGenerator.GenerateEmptyGrid(tileMapSettings), mapFromPrefab)), tileMapSettings));
///
/// Corridor
//RandomRoomWithCorridor.PreprocessMap(tileMapSettings, corridor);
//DrawMesh(DiscreteVoxelMeshGenerator.GenerateGridMesh(OuterWallsGenerator.CreateOuterWalls(RandomRoomWithCorridor.ProcessMap(GridGenerator.GenerateEmptyGrid(tileMapSettings), corridor)), tileMapSettings));
///
/// BSP
//BinarySpacePartitioning.PreprocessMap(tileMapSettings, bsp);
//DrawMesh(DiscreteVoxelMeshGenerator.GenerateGridMesh(OuterWallsGenerator.CreateOuterWalls(BinarySpacePartitioning.ProcessMap(GridGenerator.GenerateEmptyGrid(tileMapSettings), bsp)), tileMapSettings));
///
/// Random Room Placement
//RandomRoomPlacement.PreprocessMap(tileMapSettings, roomPlacement);
//DrawMesh(DiscreteVoxelMeshGenerator.GenerateGridMesh(OuterWallsGenerator.CreateOuterWalls(RandomRoomPlacement.ProcessMap(GridGenerator.GenerateEmptyGrid(tileMapSettings), roomPlacement)), tileMapSettings));
///
/// Diffusion Limited Aggregation
//DiffusionLimitedAggregation.PreprocessMap(tileMapSettings, difLimAgr);
//DrawMesh(DiscreteVoxelMeshGenerator.GenerateGridMesh(OuterWallsGenerator.CreateOuterWalls(DiffusionLimitedAggregation.ProcessMap(GridGenerator.GenerateEmptyGrid(tileMapSettings), difLimAgr)), tileMapSettings));
///
/// Random Worms
//RandomWorms.PreprocessMap(tileMapSettings, randomWorms);
//DrawMesh(DiscreteVoxelMeshGenerator.GenerateGridMesh(OuterWallsGenerator.CreateOuterWalls(RandomWorms.ProcessMap(GridGenerator.GenerateEmptyGrid(tileMapSettings), randomWorms)), tileMapSettings));
///
/// Random Walkers
//DrawMesh(DiscreteVoxelMeshGenerator.GenerateGridMesh(OuterWallsGenerator.CreateOuterWalls(RandomWalkers.ProcessMap(GridGenerator.GenerateEmptyGrid(tileMapSettings), randomWalkers)), tileMapSettings));
///
/// GameOfLife
//DrawMesh(DiscreteVoxelMeshGenerator.GenerateGridMesh(OuterWallsGenerator.CreateOuterWalls(GameOfLifeCave.ProcessMap(GridGenerator.GenerateEmptyGrid(tileMapSettings), gameOfLife)), tileMapSettings));
///
/// RandomRoomGrid
//RandomRoomSizeGrid.PreprocessMap(tileMapSettings, randomRoomGrid);
//DrawMesh(DiscreteVoxelMeshGenerator.GenerateGridMesh(OuterWallsGenerator.CreateOuterWalls(RandomRoomSizeGrid.ProcessMap(GridGenerator.GenerateEmptyGrid(tileMapSettings), randomRoomGrid)), tileMapSettings));
///
/// RoomGrid
//FixedRoomSizeGrid.PreprocessMap(tileMapSettings, roomGrid);
//DrawMesh(DiscreteVoxelMeshGenerator.GenerateGridMesh(OuterWallsGenerator.CreateOuterWalls(FixedRoomSizeGrid.ProcessMap(GridGenerator.GenerateEmptyGrid(tileMapSettings), roomGrid)), tileMapSettings));
/// RoomGrid + GameOfLife
//DrawMesh(DiscreteVoxelMeshGenerator.GenerateGridMesh(OuterWallsGenerator.CreateOuterWalls(FixedRoomSizeGrid.ProcessMap(GridGenerator.GenerateEmptyGrid(tileMapSettings), roomGrid, gameOfLife)), tileMapSettings));
///
///FisherYates
//DrawMesh(DiscreteVoxelMeshGenerator.GenerateGridMesh(OuterWallsGenerator.CreateOuterWalls(FisherYatesShuffle.ProcessMap(GridGenerator.GenerateEmptyGrid(tileMapSettings), fisherYates)), tileMapSettings));
///
/// Without Processing
//DrawMesh(DiscreteVoxelMeshGenerator.GenerateGridMesh(OuterWallsGenerator.CreateOuterWalls(GridGenerator.GenerateEmptyGrid(tileMapSettings)), tileMapSettings));
/// PointyHex test
//DrawMesh(DiscretePointyHexMeshGenerator.GenerateGridMesh(OuterWallsGenerator.CreateOuterWalls(GridGenerator.GenerateEmptyGrid(tileMapSettings)), tileMapSettings));
//DrawMesh(ContiguousPointyHexMeshGenerator.GenerateGridMesh(OuterWallsGenerator.CreateOuterWalls(GridGenerator.GenerateEmptyGrid(tileMapSettings)), tileMapSettings));
//DrawMesh(DiscreteSolidPointyHexMeshGenerator.GenerateGridMesh(OuterWallsGenerator.CreateOuterWalls(GridGenerator.GenerateEmptyGrid(tileMapSettings)), tileMapSettings));
//DrawMesh(DiscreteSolidPointyHexMeshGenerator.GenerateGridMesh(OuterWallsGenerator.CreateOuterWalls(FisherYatesShuffle.ProcessMap(GridGenerator.GenerateEmptyGrid(tileMapSettings), fisherYates)), tileMapSettings));
//DrawMesh(DiscreteSolidPointyHexMeshGenerator.GenerateGridMesh(OuterWallsGenerator.CreateOuterWalls(GameOfLifeCave.ProcessMap(GridGenerator.GenerateEmptyGrid(tileMapSettings), gameOfLife)), tileMapSettings));
/// Height maps
//DrawMesh(DiscreteSolidPointyHexMeshGenerator.GenerateTerrainMesh(GridGenerator.GenerateEmptyGrid(tileMapSettings).FillWholeGrid(CellType.Wall), tileMapSettings, HeightMapGenerator.GenerateHeightMap(heightMapSettings, new Vector2(0.0f, 0.0f), tileMapSettings.mapWidth, tileMapSettings.mapHeight)));
//DrawMesh(DiscreteVoxelMeshGenerator.GenerateTerrainMesh(GridGenerator.GenerateEmptyGrid(tileMapSettings), tileMapSettings, HeightMapGenerator.GenerateHeightMap(heightMapSettings, new Vector2(0.0f, 0.0f), tileMapSettings.mapWidth, tileMapSettings.mapHeight)));
/// Layers Height
//DrawMesh(DiscreteSolidPointyHexMeshGenerator.GenerateTerrainMesh(GridGenerator.GenerateEmptyGrid(tileMapSettings), tileMapSettings, HeightMapGenerator.GenerateHeightMap(heightMapSettings, new Vector2(0.0f, 0.0f), tileMapSettings.mapWidth, tileMapSettings.mapHeight), heightLayersSettings));
//DrawMesh(DiscreteVoxelMeshGenerator.GenerateTerrainMesh(GridGenerator.GenerateEmptyGrid(tileMapSettings), tileMapSettings, HeightMapGenerator.GenerateHeightMap(heightMapSettings, new Vector2(0.0f, 0.0f), tileMapSettings.mapWidth, tileMapSettings.mapHeight), heightLayersSettings));
//DrawMesh(DiscreteTerrainGenerator.GenerateDiscreteTerrainMesh(discreteTerrainSettings));
//DrawMesh(ContiguousTerrainGenerator.GenerateContiguousTerrainMesh(contiguousTerrainSettings));
HeightMap heightMap = ContiguousTerrainGenerator.GenerateContiguousTerrainHeightMap(contiguousTerrainSettings);
textureData.ApplyToMaterial(terrainMaterial);
textureData.UpdateMeshHeight(terrainMaterial, heightMap.minValue, heightMap.maxValue);
DrawMesh(ContiguousTerrainGenerator.GenerateContiguousTerrainFromHM(heightMap, contiguousTerrainSettings));
///
///IO Tests
///
/// Texture2D
//ExportMap.ExportGraphic(OuterWallsGenerator.CreateOuterWalls(FixedRoomSizeGrid.ProcessMap(GridGenerator.GenerateEmptyGrid(tileMapSettings), roomGrid)));
//DrawMesh(DiscreteVoxelMeshGenerator.GenerateGridMesh(ExportMap.ImportGraphic("f", "u", "c"), tileMapSettings));
/// TXT
//ExportMap.ExportText(OuterWallsGenerator.CreateOuterWalls(FixedRoomSizeGrid.ProcessMap(GridGenerator.GenerateEmptyGrid(tileMapSettings), roomGrid)));
//DrawMesh(DiscreteVoxelMeshGenerator.GenerateGridMesh(ExportMap.ImportText("f", "u", "c"), tileMapSettings));
/// Binary
/// BUG: FAILED TO WRITE\READ ARRAY => Need to make custom loader
//ExportMap.SaveDataBinary(OuterWallsGenerator.CreateOuterWalls(FixedRoomSizeGrid.ProcessMap(GridGenerator.GenerateEmptyGrid(tileMapSettings), roomGrid)));
//DrawMesh(DiscreteVoxelMeshGenerator.GenerateGridMesh(ExportMap.LoadDataBinary(), tileMapSettings));
/// JSON
//ExportMap.ExportJSON(OuterWallsGenerator.CreateOuterWalls(FixedRoomSizeGrid.ProcessMap(GridGenerator.GenerateEmptyGrid(tileMapSettings), roomGrid)));
//DrawMesh(DiscreteVoxelMeshGenerator.GenerateGridMesh(ExportMap.ImportJSON("f","u","c"), tileMapSettings));
}
else
{
if (tileMapSettings.isDiscrete)
{
DrawMesh(DiscreteMeshGenerator.GenerateGridMesh(OuterWallsGenerator.CreateOuterWalls(GridGenerator.GenerateEmptyGrid(tileMapSettings)), tileMapSettings));
}
else
{
DrawMesh(ContiguousMeshGenerator.GenerateGridMesh(OuterWallsGenerator.CreateOuterWalls(GridGenerator.GenerateEmptyGrid(tileMapSettings)), tileMapSettings));
}
}
}
else
{
if (tileMapSettings.isVoxelMap)
{
///RoomGrid
FixedRoomSizeGrid.PreprocessMap(tileMapSettings, roomGrid);
DrawMesh(DiscreteVoxelMeshGenerator.GenerateGridMesh(FixedRoomSizeGrid.ProcessMap(GridGenerator.GenerateEmptyGrid(tileMapSettings), roomGrid), tileMapSettings));
///FisherYates
//DrawMesh(DiscreteVoxelMeshGenerator.GenerateGridMesh(FisherYatesShuffle.ProcessMap(GridGenerator.GenerateEmptyGrid(tileMapSettings), fisherYates), tileMapSettings));
///Without Processing
//DrawMesh(DiscreteVoxelMeshGenerator.GenerateGridMesh(GridGenerator.GenerateEmptyGrid(tileMapSettings), tileMapSettings));
}
else
{
if (tileMapSettings.isDiscrete)
{
DrawMesh(DiscreteMeshGenerator.GenerateGridMesh(GridGenerator.GenerateEmptyGrid(tileMapSettings), tileMapSettings));
}
else
{
DrawMesh(ContiguousMeshGenerator.GenerateGridMesh(GridGenerator.GenerateEmptyGrid(tileMapSettings), tileMapSettings));
}
}
}
}
private void Start()
{
if (instance == null)
{
instance = this;
}
else
{
Destroy(gameObject);
}
width = Random.Range(3, 10);
depth = Random.Range(3, 10);
tiles = new TileScript[width * depth];
int tileNum = 0;
for (int i = 0; i < width; i++)
{
for (int j = 0; j < depth; j++)
{
GameObject thisTile = Instantiate(tile);
thisTile.transform.position = new Vector3(i, 0, j);
thisTile.transform.parent = gameObject.transform;
thisTile.GetComponent <TileScript>().tileNum = tileNum;
tiles[tileNum] = thisTile.GetComponent <TileScript>();
tileNum++;
}
}
cam.transform.position = new Vector3(width / 2, 10, depth / 2);
walls = Random.Range(4, 11);
for (int i = 0; i < walls; i++)
{
startPos = Random.Range(0, width * depth);
while (tiles[startPos].occupied == true)
{
startPos = Random.Range(0, width * depth);
}
GameObject thisWall = Instantiate(wall);
thisWall.transform.position = new Vector3(tiles[startPos].transform.position.x, 0.3f, tiles[startPos].transform.position.z);
tiles[startPos].occupied = true;
}
PlayerUnits = new Player[players];
for (int i = 0; i < players; i++)
{
startPos = Random.Range(0, (width * depth) / 2);
while (tiles[startPos].occupied == true)
{
startPos = Random.Range(0, (width * depth) / 2);
}
GameObject thisPlayer = Instantiate(player);
thisPlayer.GetComponent <Player>().movement = Random.Range(1, 3); // -----
if (thisPlayer.GetComponent <Player>().movement == 1)
{
thisPlayer.GetComponent <Player>().range = 2;
}
thisPlayer.transform.position = new Vector3(tiles[startPos].transform.position.x, 0.3f, tiles[startPos].transform.position.z);
thisPlayer.GetComponent <Player>().currentTile = startPos;
thisPlayer.GetComponent <Player>().isPlayer = true;
tiles[thisPlayer.GetComponent <Player>().currentTile].occupied = true;
tiles[thisPlayer.GetComponent <Player>().currentTile].occupant = thisPlayer.GetComponent <Player>();
for (int j = 0; j < PlayerUnits.Length; j++)
{
if (PlayerUnits[j] == null)
{
PlayerUnits[j] = thisPlayer.GetComponent <Player>();
break;
}
}
}
EnemyUnits = new Player[enemies];
for (int i = 0; i < enemies; i++)
{
startPos = Random.Range((width * depth) / 2, (width * depth));
while (tiles[startPos].occupied == true)
{
startPos = Random.Range((width * depth) / 2, (width * depth));
}
GameObject thisPlayer = Instantiate(player);
thisPlayer.GetComponent <Player>().movement = Random.Range(1, 3); // -----
if (thisPlayer.GetComponent <Player>().movement == 1)
{
thisPlayer.GetComponent <Player>().range = 2;
}
thisPlayer.transform.position = new Vector3(tiles[startPos].transform.position.x, 0.3f, tiles[startPos].transform.position.z);
thisPlayer.GetComponent <Player>().currentTile = startPos;
thisPlayer.GetComponent <Player>().isPlayer = false;
tiles[thisPlayer.GetComponent <Player>().currentTile].occupied = true;
tiles[thisPlayer.GetComponent <Player>().currentTile].occupant = thisPlayer.GetComponent <Player>();
for (int j = 0; j < EnemyUnits.Length; j++)
{
if (EnemyUnits[j] == null)
{
EnemyUnits[j] = thisPlayer.GetComponent <Player>();
break;
}
}
}
int coinFlip = Random.Range(1, 3);
if (coinFlip == 1)
{
PlayerTurn = false;
EndTurn();
}
if (coinFlip == 2)
{
PlayerTurn = true;
EndTurn();
}
}
// Start is called before the first frame update
void Start()
{
gridGenerator = GetComponentInParent <GridGenerator>();
}
private static Boolean KawigiEdit_RunTest(int testNum, int[] p0, int[] p1, Boolean hasAnswer, int p2)
{
Debug.Write("Test " + testNum + ": [" + "{");
for (int i = 0; p0.Length > i; ++i)
{
if (i > 0)
{
Debug.Write(",");
}
Debug.Write(p0[i]);
}
Debug.Write("}" + "," + "{");
for (int i = 0; p1.Length > i; ++i)
{
if (i > 0)
{
Debug.Write(",");
}
Debug.Write(p1[i]);
}
Debug.Write("}");
Debug.WriteLine("]");
GridGenerator obj;
int answer;
obj = new GridGenerator();
DateTime startTime = DateTime.Now;
answer = obj.generate(p0, p1);
DateTime endTime = DateTime.Now;
Boolean res;
res = true;
Debug.WriteLine("Time: " + (endTime - startTime).TotalSeconds + " seconds");
if (hasAnswer)
{
Debug.WriteLine("Desired answer:");
Debug.WriteLine("\t" + p2);
}
Debug.WriteLine("Your answer:");
Debug.WriteLine("\t" + answer);
if (hasAnswer)
{
res = answer == p2;
}
if (!res)
{
Debug.WriteLine("DOESN'T MATCH!!!!");
}
else if ((endTime - startTime).TotalSeconds >= 2)
{
Debug.WriteLine("FAIL the timeout");
res = false;
}
else if (hasAnswer)
{
Debug.WriteLine("Match :-)");
}
else
{
Debug.WriteLine("OK, but is it right?");
}
Debug.WriteLine("");
return(res);
}
void Awake()
{
gm = this;
gg = GetComponent<GridGenerator>();
player = (GameObject)Instantiate(PlayerPrefab, spawnPoint.position, spawnPoint.rotation);
}
// Start is called before the first frame update
void Start()
{
_gridGenerator = GetComponent <GridGenerator>(); // Setting the grid
// generator
}
private void Start()
{
gridGenerator = FindObjectOfType <GridGenerator>();
}
private void OnEnable()
{
t = (GridGenerator)target;
}
// Start is called before the first frame update
void Start()
{
Invoke("UpdatePos", 0.001f);
tileManager = GameObject.Find("TileManager").GetComponent <GridGenerator>();
// gameObject.transform.localScale = new Vector3(tileManager.gridWidth / 10, gameObject.transform.localScale.y, tileManager.gridHeight / 10);
}
private void Start()
{
generator = GameObject.Find("GridGenerator").GetComponent <GridGenerator>();
projectManager = GameObject.Find("ProjectManager").GetComponent <ProjectManager>();
parent_UI = transform.parent.gameObject;
}
private void Awake()
{
Instance = this;
}
// Use this for initialization
void Start()
{
// Find the Origin Game Object
_gobOrigin = GameObject.FindGameObjectWithTag ("ORIGIN");
// Get the GridGenerator component attached to the _gobOrigin Game Object
_genGrid = _gobOrigin.GetComponent<GridGenerator>() as GridGenerator;
// Initialize dicVariables
Dictionary<int, string> dicVariables = new Dictionary<int, string>();
// !!! DEBUG VALUES !!! //
/*dicVariables.Add("m", (1.0f).ToString());
dicVariables.Add("c", (1.0f).ToString());
PlotGraph ("LINEAR", dicVariables);
dicVariables.Add("a", (1.0f).ToString());
dicVariables.Add("b", (1.0f).ToString());
PlotGraph ("QUADRATIC", dicVariables);
dicVariables.Add("d", (1.0f).ToString());
PlotGraph ("CUBIC", dicVariables);
PlotGraph ("EXPONENTIAL", dicVariables);*/
}
System.Random random = new System.Random(); //To generate random numbers.
/// <summary>
/// To create a singleton for the generator
/// </summary>
private void Awake() => Instance = this;
public GridGeneratorTests()
{
shipRandomiser = ShipRandomiser.Instance();
gridGenerator = GridGenerator.Instance();
}
void Start()
{
gridGenerator = GridGenerator.GetInstance();
}
void Start()
{
ui = FindObjectOfType <UIContoller>();
layout = FindObjectOfType <GridGenerator>();
}
public void CreateGrid(int x, int y)
{
WorldPos worldPos = new WorldPos(x, y);
GameObject newGridObject = Instantiate(gridPrefab, new Vector3(x, y), Quaternion.Euler(Vector3.zero)) as GameObject;
if (isFogGenerator)
{
newGridObject.transform.position = new Vector3(x, y, -1);
newGridObject.layer = 8;
}
else
{
newGridObject.layer = 9;
}
newGridObject.transform.SetParent(gameObject.transform);
Grid newGrid = newGridObject.GetComponent <Grid>();
GridGenerator gen = new GridGenerator();
newGrid.pos = worldPos;
newGrid.world = this;
if (isFogGenerator || isRandom || !SaveAndLoadManager.LoadGrid(newGrid))
{
newGrid = gen.GridGen(newGrid, out isPointGenerated, out startingGrid, out startingPoint, isFogGenerator);
newGrid = gen.GridConnectionGen(newGrid);
newGrid = gen.GridItemGen(newGrid);
if (!isFogGenerator)
{
newGrid.SetTile(startingPoint.x, startingPoint.y, new GridTile(GridTile.TileTypes.Ground, GridTile.ContainedObject.StartingPoint));
}
}
//newGrid = gen.GridTileGen(newGrid, startingPoint.x, startingPoint.y, GridTile.TileTypes.Empty);
if (!isFogGenerator)
{
bool flag = false;
for (int xx = 0; xx < Grid.gridSize; xx++)
{
for (int yy = 0; yy < Grid.gridSize; yy++)
{
if (newGrid.tiles[xx, yy].containedObject == GridTile.ContainedObject.StartingPoint)
{
startingPoint = new WorldPos(xx, yy);
startingGrid = new WorldPos(xx, yy);
flag = true;
isPointGenerated = true;
continue;
}
}
if (flag)
{
continue;
}
}
levelManager.Spawn(newGrid);
}
grids.Add(worldPos, newGrid);
}
public bool CheckSurroundingHexagonColorsAndReturnLocked(bool isColorSwitch)
{
return(GridGenerator.CheckHexagonAround(_row, _col, isColorSwitch));
}
public void Awake()
{
Instance = this;
}
private void Start()
{
main = FindObjectOfType <Main>();
gridGenerator = FindObjectOfType <GridGenerator>();
}
void Aweke()
{
instance = this;
}
private IEnumerator RunGenerator(bool fromScratch)
{
//Run the initial generation if necessary.
if (fromScratch)
{
GridGenerator gen = new GridGenerator(XSize, YSize, ZSize, XOffset, YOffset, ZOffset);
while (!gen.IsDone)
yield return null;
Voxels = gen.Voxels;
}
//Generate the mesh data on a new thread.
List<Vector3> poses = new List<Vector3>();
List<int> indices = new List<int>();
System.Threading.Thread thr = new System.Threading.Thread(() => GenerateMeshData(poses, indices));
thr.Start();
while (thr.IsAlive)
yield return null;
//TODO: If there is too much mesh data, split this cell into four smaller ones.
//TODO: Calculate normals using Central Differences.
//Put the data into the mesh.
if (mesh == null)
{
mesh = new Mesh();
}
else
{
mesh.Clear();
}
mesh.vertices = poses.ToArray();
mesh.triangles = indices.ToArray();
mesh.RecalculateNormals();
mesh.UploadMeshData(false);
MeshCollider mc = GetComponent<MeshCollider>();
if (mc != null)
mc.sharedMesh = mesh;
cr = null;
}
void Start()
{
grid = GetComponent <GridGenerator>();
playerMoves = 0;
}
//public Transform seeker;
//public Transform destination;
private void Awake()
{
grid = GetComponent <GridGenerator>();
pathPlotter = GetComponent <PathPlotter>();
}
private void Start()
{
gridGenerator = Grid.GetComponent<GridGenerator>();
gridTransformation = gridGenerator.transform.worldToLocalMatrix * Matrix4x4.TRS(gridGenerator.transform.position, gridGenerator.transform.rotation, gridGenerator.transform.localScale);
}
public void Generate(EDifficulty eDifficulty)
{
Clean();
Difficulty = eDifficulty;
//
// Generator
Debug.Log("Generate grid");
float fTimeCounter = Time.realtimeSinceStartup;
GridGenerator generator = new GridGenerator();
var retVal = generator.Generate(eDifficulty);
Assert.IsTrue(retVal.Item1);
Debug.Log("Generated grid in " + (Time.realtimeSinceStartup - fTimeCounter));
m_aGridModel = retVal.Item2;
m_aGridModel.m_aAreaList.Sort();
m_iHeight = m_aGridModel.m_iHeight;
m_iWidth = m_aGridModel.m_iWidth;
//
// Solver
Debug.Log("Resolving grid");
fTimeCounter = Time.realtimeSinceStartup;
m_resolver = new Resolver();
m_resolver.Resolve(m_aGridModel);
Debug.Log("Resolved grid in " + (Time.realtimeSinceStartup - fTimeCounter));
//
// Game grid
m_aGridView = new GameObject[m_iHeight, m_iWidth];
// Set grid center in 0,0
float fCellSize = m_fCellSize;
float fHalfCellSize = fCellSize * 0.5f;
float fCellSpacing = m_fCellSpacing;
float fHalfCellSpacing = fCellSpacing * 0.5f;
if (m_iWidth % 2 != 0)
{
m_vTopLeft.x = -fHalfCellSize - (m_iWidth / 2) * (fCellSpacing + fCellSize);
}
else
{
m_vTopLeft.x = -fHalfCellSpacing - (m_iWidth / 2) * fCellSize - (m_iWidth / 2 - 1) * fCellSpacing;
}
if (m_iHeight % 2 != 0)
{
m_vTopLeft.y = fHalfCellSize + (m_iHeight / 2) * (fCellSpacing + fCellSize);
}
else
{
m_vTopLeft.y = fHalfCellSpacing + (m_iHeight / 2) * fCellSize + (m_iWidth / 2 - 1) * fCellSpacing;
}
float x = m_vTopLeft.x, y = m_vTopLeft.y;
for (int iHeight = 0; iHeight < m_iHeight; ++iHeight)
{
for (int iWidth = 0; iWidth < m_iWidth; ++iWidth)
{
m_aGridView[iHeight, iWidth] = Instantiate(m_cellPrefab, m_CellsContainer.transform);
m_aGridView[iHeight, iWidth].GetComponent <RectTransform>().anchoredPosition3D = new Vector3(x + fHalfCellSize, y - fHalfCellSize, 0.0f);
m_aGridView[iHeight, iWidth].GetComponent <Cell>().Initialize(iHeight, iWidth, fCellSize, this);
x += fCellSize + fCellSpacing;
m_iUsedCellCounter++;
}
x = m_vTopLeft.x;
y -= (fCellSize + fCellSpacing);
}
int nArea = m_aGridModel.m_aAreaList.Count;
for (int i = 0; i < nArea; ++i)
{
Area area = m_aGridModel.m_aAreaList[i];
area.Reset();
m_aGridView[area.x, area.y].GetComponent <Cell>().SetAreaSize(area.value);
}
m_bGridEnded = false;
fTimer = Time.time;
//
// Notify listeners
NotifyGameGridCreated(nArea);
}
// Start is called before the first frame update
void Start()
{
gameGrid = transform.parent.GetComponent <GridGenerator>();
}
// Start is called before the first frame update
void Start()
{
instance = this;
hackableObjects = new List <Hackable>();
terminals = new List <Terminal>();
tutorialInfo = FindObjectOfType <TutorialInfo>();
grid = FindObjectOfType <DungeonGrid>();
if (tutorialInfo)
{
generator = new GridGenerator(1, 0);
}
else
{
generator = TryMakeDungeonUntilSuccessful();
}
int[][] gridPlan = generator.GetGrid();
SetUpCamera(gridPlan.Length);
grid.GenerateGrid(gridPlan);
grid.GenerateSwitchTilesOn(generator.GetSwitchTilesOn());
grid.GenerateSwitchTilesOff(generator.GetSwitchTilesOff());
grid.GenerateRamps(generator.GetRamps());
grid.GenerateFirewalls(generator.GetFirewalls());
grid.GenerateDefenses(generator.GetDefences());
grid.GenerateTerminals(generator.GetTerminals());
grid.GenerateSwitches(generator.GetSwitches());
grid.GenerateSecurityHubs(generator.GetHubs());
if (tutorialInfo)
{
AssignEnemyTypes(ref generator, tutorialInfo.GetEnemies());
}
foreach (Room room in generator.rooms)
{
List <EnemyProgram> enemiesInRoom = grid.GenerateEnemies(room.GetEnemies());
grid.AssignPatrolRoutes(ref enemiesInRoom, room.patrolRoutes);
}
grid.GeneratePorts(generator.GetPorts());
grid.AssignTerminalControl(generator.GetTerminalControlledObjects());
foreach (Room room in generator.rooms)
{
if (room.isControlledByInternalTerminal)
{
room.ConnectTerminal(ref terminals);
}
room.ConnectSwitches();
}
RemoveUnusedTerminals();
grid.PlaceLoot(generator.GetLoot());
grid.PlaceObjective(generator.getMissionObj());
if (tutorialInfo)
{
CreatePlayerPrograms(tutorialInfo.tutorialPrograms);
}
else
{
CreatePlayerPrograms(MissionStatus.instance.selectedPrograms);
}
grid.CreateDeploymentZone(generator.GetDeploymentArea());
FindObjectOfType <CameraContol>().Configure();
grid.ExploreStartingArea(generator.GetDeploymentArea());
PrepareNextDeployment();
}
void Start()
{
_gridGenerator = GetComponentInParent <GridGenerator>();
_findMatches = GetComponentInParent <FindMatches>();
_soundManager = FindObjectOfType <SoundManager>();
}
public BattleshipController()
{
this.gridGenerator = GridGenerator.Instance();
this.gamePlayer = GamePlayer.Instance();
}
/// <summary>
/// Displays the NPC Object's Calculated Path Tiles using GL Functions.
/// </summary>
/// <param name="gridGen">The GridGenerator to Display the Calculated Path Tiles.</param>
private void DisplayPath(GridGenerator gridGen)
{
for (int i = 0; i < pathTiles.Count; i++)
{
GL.Color(Color.yellow);
GL.Vertex3(pathTiles[i].getGridSquareCentralOrigin().x, pathTiles[i].getGridSquareCentralOrigin().y, pathTiles[i].getGridSquareCentralOrigin().z);
GL.Vertex3(pathTiles[i].getGridSquareCentralOrigin().x, pathTiles[i].getGridSquareCentralOrigin().y + gridGen.GridHeight / 2, pathTiles[i].getGridSquareCentralOrigin().z);
GL.Color(Color.green);
GL.Vertex3(pathTiles[i].getGridSquareCentralOrigin().x - 0.5f, pathTiles[i].getGridSquareCentralOrigin().y, pathTiles[i].getGridSquareCentralOrigin().z);
GL.Vertex3(pathTiles[i].getGridSquareCentralOrigin().x - 0.5f, pathTiles[i].getGridSquareCentralOrigin().y + gridGen.GridHeight / 2, pathTiles[i].getGridSquareCentralOrigin().z);
GL.Color(Color.blue);
GL.Vertex3(pathTiles[i].getGridSquareCentralOrigin().x - 0.25f, pathTiles[i].getGridSquareCentralOrigin().y, pathTiles[i].getGridSquareCentralOrigin().z - 0.5f);
GL.Vertex3(pathTiles[i].getGridSquareCentralOrigin().x - 0.25f, pathTiles[i].getGridSquareCentralOrigin().y + gridGen.GridHeight / 2, pathTiles[i].getGridSquareCentralOrigin().z - 0.5f);
}
}
private void Start()
{
GameController.instance.songController.beat += SpawnBullets;
level = GameController.instance.level;
boss = FindObjectOfType <Boss>();
gridGenerator = FindObjectOfType <GridGenerator>();
foreach (BulletStats bulletStats in level.frames[0].bullets)
{
if (bulletStats.type.Contains("Battery"))
{
batteries.Add(Instantiate(GetBulletTypeFromGameObject(bulletStats.type), gridGenerator.GetPositionFromGrid(bulletStats.position), Quaternion.identity).GetComponent <Battery>());
}
}
for (int i = 0; i < level.frames.Length; i++)
{
int addAmount = 0;
List <BulletStats> warnings = new List <BulletStats>();
foreach (BulletStats bulletStats in level.frames[i].bullets)
{
Vector2 position = bulletStats.position;
if (!bulletStats.type.Contains("Battery") && !bulletStats.type.Contains("Warning") && !bulletStats.type.Contains("None"))
{
if (bulletStats.type.Contains("Laser"))
{
bool batteryLaser = (GetBatteryAtPosition(gridGenerator.GetPositionFromGrid(position + Vector2.up)) != null || GetBatteryAtPosition(gridGenerator.GetPositionFromGrid(position + Vector2.down)) || GetBatteryAtPosition(gridGenerator.GetPositionFromGrid(position + Vector2.right)) || GetBatteryAtPosition(gridGenerator.GetPositionFromGrid(position + Vector2.left)) != null || GetBatteryAtPosition(gridGenerator.GetPositionFromGrid(position + Vector2.one)) != null || GetBatteryAtPosition(gridGenerator.GetPositionFromGrid(position - Vector2.one)) != null || GetBatteryAtPosition(gridGenerator.GetPositionFromGrid(position + new Vector2(1, -1))) != null || GetBatteryAtPosition(gridGenerator.GetPositionFromGrid(position + new Vector2(-1, 1))) != null);
if (bulletStats.type == "RedLaser")
{
addAmount = (batteryLaser) ? 1 : 2;
warnings.Add(new BulletStats("RedLaserWarning", position, bulletStats.direction));
}
else if (bulletStats.type == "YellowLaser")
{
addAmount = (batteryLaser) ? 3 : 1;
warnings.Add(new BulletStats("YellowLaserWarning", position, bulletStats.direction));
}
else if (bulletStats.type == "OrangeLaser")
{
addAmount = (batteryLaser) ? 3 : 4;
warnings.Add(new BulletStats("OrangeLaserWarning", position, bulletStats.direction));
}
else if (bulletStats.type == "BlueLaser")
{
addAmount = (batteryLaser) ? 3 : 4;
warnings.Add(new BulletStats("BlueLaserWarning", position, bulletStats.direction));
}
else if (bulletStats.type == "GreenLaser")
{
addAmount = 2;
warnings.Add(new BulletStats("GreenLaserWarning", position, bulletStats.direction));
}
else if (bulletStats.type == "PurpleLaser")
{
addAmount = (batteryLaser) ? 5 : 4;
warnings.Add(new BulletStats("PurpleLaserWarning", position, bulletStats.direction));
}
}
else
{
addAmount = 1;
warnings.Add(new BulletStats(bulletStats.type + "Warning", position, bulletStats.direction));
}
}
}
if (addAmount > 0)
{
foreach (BulletStats warning in warnings)
{
for (int x = 1; x < addAmount + 1; x++)
{
int index = i - x;
if (index < 0)
{
index += level.amountOfFrames;
}
level.frames[index].bullets.Add(warning);
}
}
}
}
}
