public tile getTileFromMercator(mercator me, int z) { px px = convert_mercator_to_px(me.me_x, me.me_y, z); tile Tile = convert_px_to_tile(px.px_x, px.px_y, z); return(Tile); }
bool depthSearch(int depth) { if (outOfBounds()) { return(false); } checkedTiles.Add(cursor); if (placedTiles[cursor.x, cursor.y] != null) { return(false); } if (depth > 0) { tile current = cursor; for (int i = 0; i < 6; i++) { cursor = current; MoveCursor(i); if (checkedTiles.Contains(cursor)) { continue; } bool b = depthSearch(depth - 1); if (b) { return(b); } } return(false); } return(true); }
public bool isInBoundsByAxis(ref Vector3 position, List <bool> travableTiles) { if (position.x < minX) { return(false); } if (position.x > maxX) { return(false); } if (position.z < minZ) { return(false); } if (position.z > maxZ) { return(false); } //checks if the type of the tile at index is true from the object's travableTile list //it finds the tile at the position, gets the tType and cast it as int to see if true in list tile atTile = getToTileByPosition(position); if (travableTiles[(int)atTile.tType]) { position = atTile.pos; return(true); } else { return(false); } }
public void addinstance() { tile[] tiles = new tile[64]; piece[] pieces = new piece[32]; for (int i = 0; i < 64; i++) { GameObject x = chessboard.GetComponent <chessboard> ().tiles [i]; tiles [i].a = x; tiles [i].top = x.GetComponent <tileprops> ().top; } for (int i = 0; i < 32; i++) { GameObject x = chessboard.GetComponent <chessboard> ().pieces [i]; pieces [i].a = x; if (x != null) { pieces [i].tile = x.GetComponent <chesspiece> ().tile; pieces [i].tem = x.transform.position; pieces [i].row = x.GetComponent <chesspiece> ().row; pieces [i].col = x.GetComponent <chesspiece> ().col; pieces [i].movecount = x.GetComponent <chesspiece> ().movecount; pieces [i].ptype = x.GetComponent <chesspiece> ().ptype; pieces [i].pcolor = x.GetComponent <chesspiece> ().pcolour; pieces [i].wkilled = x.GetComponent <chesspiece> ().tile.GetComponent <tileprops> ().killmove; if (pieces [i].wkilled == true) { Debug.Log("As"); } } } boardinstances.Add(tiles); pieceinstance.Add(pieces); movecount++; }
public void addTile(int x, int y, bool enemy) { tile newTile = new tile(); newTile.tilePosition = new Vector3(x * 1.05f, (-y + (x % 2) * .5f) * 1.12f, 0); newTile.battle = enemy; generatedMap.Add(newTile.tilePosition, newTile); }
} // call this in editor time after everything is done... and calculated; public void loadValues() { tiles = new tile[(width * overSampling), (height * overSampling)]; tile[] temp = new tile[tilesStorage.Count]; tilesStorage.CopyTo(temp); foreach (tile t in temp) { tiles[t.x, t.z] = t; //Debug.Log("While Copy t.type is"+t.type+" and tiles.type is"+tiles[t.x, t.z].type); } /* * for (int x = 0; x < tiles.GetLength(0); x++) { * for (int z = 0; z < tiles.GetLength(1); z++) { * * tiles[x,z] = tilesStorage[x+z*width]; * } * * }*/ //for (int x = 0; x < tiles.GetLength(0); x++) { // for (int z = 0; z < tiles.GetLength(1); z++) { // Debug.Log(tiles[x,z].type); // } // } } //call this in run time to load the data into the tiles agains
void SetupBlankBoard(int cols, int rows) { owner = new int[cols, rows]; tile_type = new type[cols, rows]; remaining = new int[cols, rows]; defense_type = new type[cols, rows]; defense = new int[cols, rows]; tiles = new tile[cols, rows]; for (int x = 0; x != cols; ++x) { for (int y = 0; y != rows; ++y) { owner[x, y] = -1; defense_type[x, y] = tile_type[x, y] = type.Empty; remaining[x, y] = 0; defense[x, y] = 0; tile nt = Instantiate <tile>(tilePrefab); //nt.GetComponent<Transform>().position = new Vector3((float)x, (float)y, 0f); nt.GetComponent <Transform>().position = new Vector3((float)x, (float)y + 10.0f + 10.0f * Random.value, 0f); nt.GetComponent <Rigidbody>().velocity = new Vector3(0f, -20.0f, 0f); nt.col = x; nt.row = y; nt.owner = -1; tiles[x, y] = nt; } } }
// Start is called before the first frame update void Start() { instance = this; Vector3 spawnPosition = startPoint.position; for (int i = 0; i < tilesToPreSpawn; i++) { spawnPosition -= tilePrefab.startPoint.localPosition; tile spawnedTile = Instantiate(tilePrefab, spawnPosition, Quaternion.identity) as tile; // if(tilesWithNoObstaclesTmp > 0) // { // spawnedTile.DeactivateAllObstacles(); // tilesWithNoObstaclesTmp--; // } // else // { spawnedTile.ActivateRandomObstacle(); // } spawnPosition = spawnedTile.endPoint.position; spawnedTile.transform.SetParent(transform); spawnedTiles.Add(spawnedTile); } }
public void init() { if (!finishTile) { finishTile = Instantiate(finishPrefab); } foreach (GameObject c in checkpoints) { Destroy(c); } checkpoints.Clear(); loadTiles(); //CreateGrid(); gridCollision(); if (grid[cursor.x, cursor.y].magnitude < 0) { do { cursor = new tile(Random.Range(0, gridSize), Random.Range(0, gridSize)); }while(grid[cursor.x, cursor.y].magnitude < 0); } for (int i = 0; i < 5; i++) { AutoTile(); tileHistory[i].GetComponent <trackTile>().fadeStart = false; } cullTrack = gameManager.self.gameType == gameManager.gameTypes.TRACKCULLING; }
public void FindSelectableTiles() { ComputeAdjacencyLists(JumpHeight, null); GetCurrentTile(); Queue <tile> process = new Queue <tile>(); process.Enqueue(currentTile); currentTile.visited = true; while (process.Count > 0) { tile t = process.Dequeue(); selectableTiles.Add(t); t.selectable = true; if (t.distance < move) { foreach (tile tile in t.adjacencyList) { if (!tile.visited) { tile.parent = t; tile.visited = true; tile.distance = 1 + t.distance; process.Enqueue(tile); } } } } }
public void add_tile(tile t) { if (t != null) { tiles.Add(t); } }
public List <tile> GetNeighbor(tile cur) { List <tile> p = new List <tile>(); Vector2 pos = cur.getPos(); int x = Mathf.RoundToInt(pos.x); int y = Mathf.RoundToInt(pos.y); if (y + 1 <= fieldHeight) { p.Add(tileField[(y + 1) * fieldWidth + x]); } if (y - 1 >= 0) { p.Add(tileField[(y - 1) * fieldWidth + x]); } if (x + 1 <= fieldWidth) { p.Add(tileField[y * fieldWidth + (x + 1)]); } if (x - 1 >= 0) { p.Add(tileField[y * fieldWidth + (x - 1)]); } return(p); }
bool MoveStack(Vector2 pos) { // check in bounds if (!CheckInBounds(pos)) { return(false); } else { tile targetTile = null; // find tile in pos foreach (tile t in tileList) { if (t.tilePos == pos) { targetTile = t; // highlight tile selectedTileTransform = (Transform)Instantiate(highlightTile, new Vector3(pos.x * tileSize, pos.y * tileSize, 0), Quaternion.identity); selectedTile = t; break; } } // are there more than one tokens on the stack if (targetTile.tokens.Count < 1) { return(false); } } return(true); }
bool noOneCloseEnough(int x, int y) { bool isOK = true; for (int i = x - 2; i <= x + 2; i++) { for (int j = y - 2; j <= y + 2; j++) { if ((x >= 0) && (x < WIDTH) && (y >= 0) && (y < HEIGHT)) { tile t = getTileXY(i, j); if ((t.whichType == tileTypes.ROAD) && (t.tStates != tileStates.FREE)) { isOK = false; break; } } } if (isOK == false) { break; } } return(isOK); }
tile[,] tiles; //2D array representation of all tile sin the world /** * Called on start, sets up the world making a size x size grid of water tiles * No PCG here, always runs teh same */ void Start() { tiles = new tile[size, size]; for (int i = 0; i < size; i++) { for (int j = 0; j < size; j++) { tiles[i, j] = new tile(Enums.TileID.sea, i, j); } } BuildContinent(); BuildContinent2(); for (int i = 0; i < montNumRanges; i++) { BuildMountains(); } SmoothContinent(); for (int i = 0; i < riverNum; i++) { SpawnRiver(); } setTundra(); setIce(); Camera.GetComponent <CameraScript>().setup(size); SetCoasts(); GenerateWorld(); }
static Tuple <tile, float, int, Vector3[]> getClosestTile(List <tile> tiles, Vector3 mousePos) { tile closest = null; Vector3[] closestEdgeVec = new Vector3[2]; int closestEdge = 0; float minDist = Mathf.Infinity; foreach (tile t in tiles) { float dist = Vector2.Distance(t.centre, mousePos); if (dist < minDist) { closest = t; minDist = dist; } } float minDistToEdge = Mathf.Infinity; for (int i = 0; i < closest.edges.Count; ++i) { float distToEdge = Vector2.Distance(helperFunctionsClass.edgeCentre(closest.edges[i]), mousePos); if (distToEdge < minDistToEdge) { minDistToEdge = distToEdge; closestEdgeVec = closest.edges[i]; closestEdge = i + 1; } } return(new Tuple <tile, float, int, Vector3[]>(closest, minDist, closestEdge, closestEdgeVec)); }
// // read_file - pre-condition : filename exists and is in the correct format. // post-condition: breakout data structures are initialised and // if successful level is returned else 0 is returned. // private int read_file(string filename, int level) { int row = 0; FileInfo f = new FileInfo(filename); StreamReader r = f.OpenText(); string line; do { line = r.ReadLine(); process_line(line, row); row++; } while (line != null); while (row < max_row) { for (int col = 0; col < max_col; col++) { grid[row, col] = new tile(); } row++; } return(level); }
// checsks if child is on the same team // add tile to needy neighbor list // updates totalt percent need //checks if most needy tile void howNeedy(tile tempTile, tile currentTile, List <tile> needyNeighbors, List <float> needs, ref float totalPercentNeed, ref float mostNeedy) { if (tempTile.tileType == currentTile.tileType && tempTile.currentEnergy < currentTile.currentEnergy && tempTile.currentEnergy < tempTile.maxEnergy) { // add tile to list of needy neighbros needyNeighbors.Add(tempTile); //calculate %need float tempP = (tempTile.maxEnergy - tempTile.currentEnergy) / tempTile.maxEnergy; ///add to list of needs needs.Add(tempP); // add to total percent need totalPercentNeed += tempP; //Debug.Log ("total Percent need : " + totalPercentNeed); // check if most need tile if (tempP > mostNeedy) { mostNeedy = tempP; //mostNeedyTile = needs.Count - 1; } } return; }
//find a singular zone; subfunction of zone void find_zone(int y, int x, Zone z) { tile t = maze [y, x]; if (!t.get_touch()) { t.set_zone(z); Debug.Log(t.get_zone().get_id()); t.touch(true); z.add_tile(t); if (t.get_northwall() == tile.Wall.none) { find_zone(y - 1, x, z); } if (t.get_westwall() == tile.Wall.none) { find_zone(y, x - 1, z); } if (t.get_eastwall() == tile.Wall.none) { find_zone(y, x + 1, z); } if (t.get_southwall() == tile.Wall.none) { find_zone(y + 1, x, z); } } }
public solver(field field, tile start, tile end) { this.field = field; this.start = start; this.end = end; visited = new List <tile>(); }
public Vector3 checkToRun(float range) { foreach (unfreindlyScript enemy in unFriendlyList) { Vector3 dist = new Vector3(duckTransform.position.x - enemy.unitTransform.position.x, 0, duckTransform.position.z - enemy.unitTransform.position.z); if (dist.magnitude < range) { playerActionSys.isHoldingDuck = false; //find a tile to move to tile atTile = tilingSys.getToTileByPosition(duckTransform.position); for (int row = -1; row < 2; row++) { for (int col = -1; col < 2; col++) { tile adjTile = tilingSys.getTilebyIndex((int)atTile.index2.x + col, (int)atTile.index2.y + row); if (duckBehaviourSys.traverseData.traversePossibilities[(int)adjTile.tType] && adjTile.walkable && !(col == 0 && row == 0)) { return(adjTile.pos + new Vector3(0, 1, 0)); } } } return(playerTransform.position); } } return(Vector3.zero); }
bool PlaceToken(Vector2 pos) { // find right tile tile targetTile = null; foreach (tile t in tileList) { if (t.tilePos == pos) { targetTile = t; break; } } // check if legal to place if (targetTile.stack < 4) { int yOffset = -3 + targetTile.stack * 2; Transform tokenObject = (Transform)Instantiate(discs[player - 1], new Vector3(pos.x * tileSize, pos.y * tileSize + yOffset, 0), Quaternion.identity); token tok = new token(); tok.tokenObject = tokenObject; tok.ownerPlayer = player; tok.tokenObject.transform.FindChild("sprite").GetComponent <SpriteRenderer>().sortingOrder = targetTile.stack; targetTile.tokens.Add(tok); targetTile.stack += 1; return(true); } return(false); }
private void UpdateMaterials(tile t, shadowMapRenderer r) { foreach (GameObject o in t.Objs) { MeshRenderer renderer = o.GetComponent <Renderer>() as MeshRenderer; if (renderer) { Material[] materials = renderer.sharedMaterials; foreach (Material mat in materials) { if (mat.HasProperty("_ShadowMap")) { //Debug.Log(mrenderer.ReflectionTexture); mat.SetTexture("_ShadowMap", r.shadowMap); } Matrix4x4 shadowMatrix = r.shadowCamera.projectionMatrix; if (SystemInfo.usesReversedZBuffer) { shadowMatrix [2, 0] = -shadowMatrix [2, 0]; shadowMatrix [2, 1] = -shadowMatrix [2, 1]; shadowMatrix [2, 2] = -shadowMatrix [2, 2]; shadowMatrix [2, 3] = -shadowMatrix [2, 3]; } shadowMatrix *= r.shadowCamera.worldToCameraMatrix; mat.SetMatrix("_shadowMatrix", shadowMatrix); } } } }
void initialize() { Light l = GetComponent <Light> (); if (!l) { return; } if (l.type != LightType.Directional) { return; } _tiles = new List <tile> (); _renderers = new List <shadowMapRenderer> (); _curTilesRenderers = new Dictionary <int, int> (); Bounds bb = GetBoundingBoxofSelectedObjects(); _numX = Mathf.CeilToInt(bb.extents.x * 2 / tileSize.x); _numY = Mathf.CeilToInt(bb.extents.z * 2 / tileSize.y); _startX = (float)(bb.center.x - tileSize.x * 0.5 * _numX); _startY = (float)(bb.center.z - tileSize.y * 0.5 * _numY); _height = (float)bb.center.y; //initialize tiles for (int j = 0; j < _numY; ++j) { for (int i = 0; i < _numX; ++i) { float posX = (float)(_startX + tileSize.x * 0.5 * (i + 1)); float posY = (float)(_startY + tileSize.y * 0.5 * (j + 1)); Vector2 pos = new Vector2(posX, posY); tile t = new tile(pos, tileSize); _tiles.Add(t); } } //initialize tiles objects list MeshRenderer[] renderers = FindObjectsOfType(typeof(MeshRenderer)) as MeshRenderer[]; for (int i = 0; i < renderers.Length; ++i) { if (m_ShadowLayers == (m_ShadowLayers | 1 << renderers[i].gameObject.layer)) { Bounds b = renderers[i].bounds; Vector2 opos = new Vector2(b.center.x, b.center.z); Vector2 osize = new Vector2(b.extents.x * 2, b.extents.z * 2); foreach (tile it in _tiles) { if (it.Contain(opos, osize)) { it.Objs.Add(renderers [i].gameObject); } } } } }
public tile convert_bingTile_to_baidu(int x, int y, int z) { var quadkey = tileToQuadkey(x, y, z); var merca = BingTest(quadkey); tile tie = getTileFromMercator(merca, z); return(tie); }
public void ComputeAdjacencyLists(float jumpHeight, tile target) { foreach (GameObject tile in tiles) { tile t = tile.GetComponent <tile>(); t.FindNeighbors(JumpHeight, target); } }
void OnTriggerEnter(Collider collider) { if (collider.CompareTag("tile")) { _cursorTile.position = collider.transform.position; _previousTile = collider.gameObject.GetComponent <tile>(); } }
public static bool isWithinMiningRange(tile Tile) { if (Vector2.Distance(Tile.currentRectangle.Location.ToVector2(), gameWorld.myCharacter.currentRectangle.Location.ToVector2()) < miningRange) { return(true); } return(false); }
public void FindNeighbors(float jumpHeight, tile target) { Reset(); CheckTile(Vector3.forward, jumpHeight, target); CheckTile(-Vector3.forward, jumpHeight, target); CheckTile(Vector3.right, jumpHeight, target); CheckTile(-Vector3.right, jumpHeight, target); }
public tile getTile(double lng, double lat, int z) { mercator point = convert_coord_to_mercator(lng, lat); px px = convert_mercator_to_px(point.me_x, point.me_y, z); tile Tile = convert_px_to_tile(px.px_x, px.px_y, z); return(Tile); }
public void updateAdjacentTiles(tile t) // update adjacent tiles AND this tile { t.update(); t.getAdjacent(1, 0).update(); t.getAdjacent(-1, 0).update(); t.getAdjacent(0, 1).update(); t.getAdjacent(0, -1).update(); }
private Dictionary<string, tile> GetTileMap(string tmfile, string widfile) { string tSep = Properties.Settings.Default.TilemapSep; bool oldmap = false; int oldlen = 0; List<int> widths = GetWidths(widfile); Dictionary<string, tile> tm = new Dictionary<string, tile>(); if (File.Exists(tmfile)) { using (StreamReader sr = new StreamReader(tmfile)) { int row = 0; while (!sr.EndOfStream) { string l = sr.ReadLine(); //detect if the seperator exists... if (l.Contains(tSep)) {//get the new tilemap format string[] lA = l.Split(new string[] {tSep}, StringSplitOptions.None); for (int col = 0; col < lA.Length; col++) { tile t = new tile(); t.col = col; t.row = row; t.width = GetWid(widths, col, row); if (!tm.ContainsKey(lA[col])) { tm.Add(lA[col], t); } } } else {//old tilemap if (oldlen == 0) { oldmap = true; oldlen = l.Length; } for (int col = 0; col < l.Length; col++) { tile t = new tile(); t.col = col; t.row = row; if (!tm.ContainsKey(l[col].ToString())) { tm.Add(l[col].ToString(), t); } else { int cinc = 0; string chk = l[col].ToString(); while (tm.ContainsKey(chk)) { cinc++; chk = l[col].ToString() + cinc; } tm.Add(chk, t); } } } row++; } } } if (oldmap) {//save in the new format... Will only need this once. using (StreamWriter sw = new StreamWriter(tmfile, false)) { int pos = 0; foreach (KeyValuePair<string, tile> t in tm) { if (pos == oldlen-1) { sw.WriteLine(t.Key); pos = -1; } else { sw.Write(t.Key + tSep); } pos++; } } } return tm; }
void RemoveBenefitsOfOldType(tile _tile) { if (tileToConvert.thisTileType == tile.tileType.structure_mining) { countMining -= 1; mineTiles.Remove(_tile); UpdateMinableTilesList(); } else if (tileToConvert.thisTileType == tile.tileType.structure_factory) { countFactory -= 1; RecalculateCosts(); } else if (tileToConvert.thisTileType == tile.tileType.structure_mill) { countMill -= 1; RecalculateCosts(); } else if (tileToConvert.thisTileType == tile.tileType.structure_residence) { countResidence -= 1; } else if (tileToConvert.thisTileType == tile.tileType.structure_community) { countCommunity -= 1; } else if (tileToConvert.thisTileType == tile.tileType.structure_gemMount) { inventoryGems -= 1; } else if (tileToConvert.thisTileType == tile.tileType.structure_sonar || tileToConvert.thisTileType == tile.tileType.structure_sonar_positive) { sonarList.Remove(_tile); } }
// This will be changed since we won't be satisfied with just a hexagon in the future // But the formula for locating tiles is useful! void generateHexMap(int size) { board = new tile[size * 2-1, size * 2-1]; for (int i=0; i<size * 2-1; i++) { for (int j=0; j<size * 2-1; j++) { board[i,j]=new tile(); } } Transform boardHolder = new GameObject ("Board").transform; Vector3 pieceposition; for(int i=1;i<size*2;i++){ for(int j=1;j<2*size-Mathf.Abs(size-i);j++){ //crazy math formulas for the actuall positions, don't delve in if you value your life! pieceposition= new Vector3 (tileSize*(Mathf.Abs(size-i)*0.5f+j-size),tileSize*ratio*(i-size),0f); GameObject instance = Instantiate(gameTile,pieceposition,Quaternion.identity) as GameObject; inputTile tileInfo = instance.GetComponent<inputTile>(); //the same craziness here tileInfo.tilePosition=new Vector2(j-0.5f*(size+i-Mathf.Abs(i-size)),i-size); instance.transform.SetParent (boardHolder); } } }
// look above and find the top of the current stack of blocks (the first non-empty block) tile FindTileAtTop(tile _tile) { tile _result = _tile.myNeighborUp; while (_result.myNeighborUp.thisTileType != tile.tileType.empty) { _result = _result.myNeighborUp; } return _result; }
// set neighbors for a tile in all directions void FindTileNeighbors(tile t) { foreach (tile t2 in allTiles) { if (t.thisTileY + 1 == t2.thisTileY && t.thisTileX == t2.thisTileX) { t.myNeighborUp = t2; } else if (t.thisTileY - 1 == t2.thisTileY && t.thisTileX == t2.thisTileX) { t.myNeighborDown = t2; } else if (t.thisTileX + 1 == t2.thisTileX && t.thisTileY == t2.thisTileY) { t.myNeighborRight = t2; } else if (t.thisTileX - 1 == t2.thisTileX && t.thisTileY == t2.thisTileY) { t.myNeighborLeft = t2; } } }
// Default implementation int FindBaseStrength(tile _tile) { return FindBaseStrength(_tile, null, -99); // "-99" is the signal for "null" in this case }
// Default implementation int FindBaseStrength(tile _tile, tile _tileToRemove) { return FindBaseStrength(_tile, _tileToRemove, -99); // "-99" is the signal for "null" in this case }
// Show contextual options for clicked tile void ContextOptions(tile _tile) { decisionPossibilities = new List<string>(); // add options available for all (or most) structure types decisionPossibilities.Add (decisionTextCancel); decisionPossibilities.Add (decisionTextDestroy); decisionPossibilities.Add (decisionTextRevert); // add re-enforcement options for all structure types if (_tile.levelOfReenforcement == 0) { decisionPossibilities.Add (decisionTextReenforce); } else if (_tile.levelOfReenforcement == 1) { decisionPossibilities.Add (decisionTextUnReenforce); decisionPossibilities.Add (decisionTextReenforce2); } else if (_tile.levelOfReenforcement == 2) { decisionPossibilities.Add (decisionTextUnReenforce); } // add options to specific structure types if (_tile.thisTileType == tile.tileType.structure) // if this is an empty structure { decisionPossibilities.Add (decisionTextResidence); // to add Residence decisionPossibilities.Add (decisionTextMining); // to add Mining if (inventoryGems > 0) { decisionPossibilities.Add (decisionTextMountGem); } // to add a Gem Mount (if you have any gems) decisionPossibilities.Remove (decisionTextRevert); // remove "revert" for this one (since it wouldn't do anything) } else if (_tile.thisTileType == tile.tileType.structure_residence) // if this is a residence { decisionPossibilities.Add (decisionTextCommunity); // convert to community center } else if (_tile.thisTileType == tile.tileType.structure_mining) // if this is a mining structure { decisionPossibilities.Add (decisionTextFactory); decisionPossibilities.Add (decisionTextMill); } else if (_tile.thisTileType == tile.tileType.structure_mill) // if this is a mill { } else if (_tile.thisTileType == tile.tileType.structure_factory) // if this is a factory { decisionPossibilities.Add(decisionTextSonar); } else if (_tile.thisTileType == tile.tileType.structure_community) // if this is a community { } else if (_tile.thisTileType == tile.tileType.structure_gemMount) // if this is a gem mount { } else if (_tile.thisTileType == tile.tileType.structure_sonar || _tile.thisTileType == tile.tileType.structure_sonar_positive) // if this is a sonar { } else if (_tile.thisTileType == tile.tileType.dirt) // if this is dirt { decisionPossibilities.Remove (decisionTextDestroy); decisionPossibilities.Remove (decisionTextRevert); } else if (_tile.thisTileType == tile.tileType.rock) // if this is rock { decisionPossibilities.Remove (decisionTextDestroy); decisionPossibilities.Remove (decisionTextRevert); } // Re-arrange options (make sure cancel is last, at least) if (decisionPossibilities.Contains(decisionTextCancel)) { decisionPossibilities.Remove(decisionTextCancel); decisionPossibilities.Add(decisionTextCancel); } makingDecision = true; isMenuOpen = true; tileToConvert = _tile; }
// look below the structure and find the strength of the supporting tiles int FindBaseStrength(tile _tile, tile _tileToRemove, int _valueToReplace) { int _result = 0; tile _tileInQuestion = _tile.myNeighborDown; // Start looking down at blocks while (_tileInQuestion.thisTileType != tile.tileType.empty) // Until you hit an empty block { if (_tileInQuestion == _tileToRemove && _valueToReplace == -99) { break; } // If you find the optional "tileToRemove", then stop there and consider that you've reached the bottom else if (_tileInQuestion == _tileToRemove) { _result += _valueToReplace; } // If you find the optional "tileToRemove" and you have a "valueToReplace", use that value in its place else if (_tileInQuestion.thisTileType == tile.tileType.dirt) // If it's dirt, add the strength of dirt { _result += strengthOfDirt; } else if (_tileInQuestion.thisTileType == tile.tileType.rock) // If it's rock, add the strength of rock { _result += strengthOfRock; } else if (_tileInQuestion.structureTypesNonLoadBearing.Contains(_tileInQuestion.thisTileType)) // If it's a non-load bearing structure, add that strength { _result += strengthOfStructures; } else if (_tileInQuestion.thisTileType == tile.tileType.bedrock) // If you hit "bedrock", then you're good for sure, just return positive { return 9999; } if (_tileInQuestion == _tileToRemove) // if this is the structure being removed/replaced, don't add in its re-enforcement { } else if (_tileInQuestion.levelOfReenforcement == 1 ) // if the structure is re-enforced, add that strength in { _result += strengthOfStructures_reenforced; } else if (_tileInQuestion.levelOfReenforcement == 2) // if the structure is double re-enforced, add that strength in { _result += strengthOfStructures_reenforced_2; } if (_tileInQuestion.myNeighborDown != null) // As long as there's a block below, move on to the next one to repeat the loop { _tileInQuestion = _tileInQuestion.myNeighborDown; } else { break; } if (_result < buildingMaxPressure) { return -1; } // If at any point you reach more than the "buildingMaxPressure", fail } return _result; }
// Convert structure based on context option chosen void ContextOptionChoice(tile _tile, string choice) { if (choice == decisionTextCancel) { return; } // If you chose cancel, then don't do anything else { // check if action is possible (unless you're just re-enforcing or un-re-enforcing) if (choice == decisionTextReenforce || choice == decisionTextReenforce2 || choice == decisionTextUnReenforce) { } else if (tileToConvert.thisTileType == tile.tileType.structure_residence) { if (!VerifyMeetPrereqs(0,0,0,-1,0) && choice != decisionTextCommunity) { CannotPerformAction("Cannot remove residence - there won't be enough for the workplaces\n(remove mines, or build another residence somewhere else)"); return; } } else if (tileToConvert.thisTileType == tile.tileType.structure_community) { if (!VerifyMeetPrereqs(0,0,0,0,-1)) { CannotPerformAction("Cannot remove community - there won't be enough for the residences\n(you need a community to sustain every " + ResidencesPerCommunity + " residences)"); return; } } else if (choice == decisionTextMining) { if (!VerifyMeetPrereqs(1,0,0,0,0)) { CannotPerformAction("Cannot build mine - not enough residences\n(1 residence sustains " + MinesPerResidence + " mine(s).)"); return; } } else if (choice == decisionTextResidence) { if (!VerifyMeetPrereqs(0,0,0,1,0)) { CannotPerformAction("Cannot build residence - not enough communities\n(you need a community to sustain every " + ResidencesPerCommunity + " residences)"); return; } } // Check costs and other requirements and perform type change if (choice == decisionTextDestroy) { if (!_tile.structureTypes.Contains(_tile.myNeighborUp.thisTileType)) // if the block above me is not a structure { if (FindBaseStrength(FindTileAtTop(_tile), _tile) >= 0) // make sure it's not structurally necessary before destroying it { RemoveBenefitsOfOldType(_tile); _tile.ChangeTileType(tile.tileType.empty); // set to empty inventoryDirt -= costToDestroyStructure; // pay resources } else { CannotPerformAction("Cannot destroy structure - structures rely on this block"); } } else { CannotPerformAction("Cannot destroy structure - structures rely on this block"); } } else if (choice == decisionTextRevert) // revert to empty { RemoveBenefitsOfOldType(_tile); _tile.ChangeTileType (tile.tileType.structure); // set to empty inventoryDirt -= costToRemodel; // pay resources } else if (choice == decisionTextReenforce && inventoryDirt - costOfStructure_reenforced >= 0) // re-enforce structure 1 { _tile.prop_levelOfReenforcement++; inventoryDirt -= costOfStructure_reenforced; } else if (choice == decisionTextReenforce2 && inventoryDirt - costOfStructure_reenforced_2 >= 0) // re-enforce structure 2 { _tile.prop_levelOfReenforcement++; inventoryDirt -= costOfStructure_reenforced_2; } else if (choice == decisionTextUnReenforce) // un-re-enforce structure { // find the strength it will be set back to int _tempStrength = 0; if (tileToConvert.structureTypes.Contains(tileToConvert.thisTileType)) { _tempStrength = strengthOfStructures; } else if (tileToConvert.thisTileType == tile.tileType.dirt) { _tempStrength = strengthOfDirt; } else if (tileToConvert.thisTileType == tile.tileType.rock || tileToConvert.thisTileType == tile.tileType.rockWithGem) { _tempStrength = strengthOfRock; } if (FindBaseStrength(FindTileAtTop(_tile), _tile, _tempStrength) >= 0 // make sure the structure doesn't rely on it || tileToConvert.myNeighborUp.thisTileType == tile.tileType.empty) // or if it's the top structure { _tile.prop_levelOfReenforcement = 0; inventoryDirt += costOfStructure_unReenforce; } else { CannotPerformAction("Cannot un-reenforce structure - structures rely on this block's re-enforcement"); } } else if (choice == decisionTextResidence && inventoryDirt - costOfStructure_residence >= 0) // change to residence { RemoveBenefitsOfOldType(_tile); _tile.ChangeTileType (tile.tileType.structure_residence); inventoryDirt -= costOfStructure_residence; countResidence++; } else if (choice == decisionTextMining && inventoryDirt - costOfStructure_mining >= 0) // change to mining { RemoveBenefitsOfOldType(_tile); _tile.ChangeTileType (tile.tileType.structure_mining); inventoryDirt -= costOfStructure_mining; countMining++; mineTiles.Add(_tile); UpdateMinableTilesList(); } else if (choice == decisionTextFactory && inventoryDirt - costOfStructure_factory >= 0) // change to factory { RemoveBenefitsOfOldType(_tile); _tile.ChangeTileType (tile.tileType.structure_factory); inventoryDirt -= costOfStructure_factory; countFactory++; RecalculateCosts(); } else if (choice == decisionTextMill && inventoryDirt - costOfStructure_mill >= 0) // change to mill { RemoveBenefitsOfOldType(_tile); _tile.ChangeTileType (tile.tileType.structure_mill); inventoryDirt -= costOfStructure_mill; countMill++; RecalculateCosts(); } else if (choice == decisionTextCommunity && inventoryDirt - costOfStructure_community >= 0) // change to community center { RemoveBenefitsOfOldType(_tile); _tile.ChangeTileType (tile.tileType.structure_community); inventoryDirt -= costOfStructure_community; countCommunity++; } else if (choice == decisionTextSonar && inventoryDirt - costOfStructure_sonar >= 0) // change to sonar { RemoveBenefitsOfOldType(_tile); inventoryDirt -= costOfStructure_sonar; sonarList.Add(_tile); // Add to sonar list UpdateAllSonar(); RecalculateCosts(); } else if (choice == decisionTextMountGem) // change to gem mount { if (inventoryGems > 0) // make sure you have a gem { if (_tile.myNeighborUp.thisTileType == tile.tileType.empty) // make sure there's no structure above { if (_tile.thisTileY >= gemHeightRequirement) // make sure the gem is being mounted high enough { RemoveBenefitsOfOldType(_tile); _tile.ChangeTileType (tile.tileType.structure_gemMount); inventoryGems--; countGemMount++; inventoryDirt += prizeDirtForMountingGem; } else { CannotPerformAction("Cannot mount Gem here - Gem must be mounted at least " + gemHeightRequirement + " above ground level"); } } else { CannotPerformAction("Cannot mount Gem here - Gem must be mounted on the top of a structure"); } } else { CannotPerformAction("Cannot mount Gem - You don't have any Gems"); } } else { CannotPerformAction("Not enough resources\n(Resources can be gained by mining or destroying other structures)"); } } }
/// <summary> /// returnerar den index som den givna tilen existerar i /// </summary> /// <param name="inTile"></param> /// <returns></returns> public int FindIndex_AtTile(tile inTile) { for (int i = 0; i < tileList.Count; i++) { if (tileList[i] == inTile) { return i; } } return -1; }
public bool Tile_IsAdjacentTo(tile tile1, tile tile2) { int[] temp = new int[3]; temp = tile1.XYZLibraryCoordinates(); temp[0]++; temp[1]++; //temp[2]; if (temp[0] == tile2.XYZLibraryCoordinates()[0] && temp[1] == tile2.XYZLibraryCoordinates()[1] && temp[2] == tile2.XYZLibraryCoordinates()[2]) { return true; } temp = tile1.XYZLibraryCoordinates(); temp[1]++; temp[2]++; //temp[2]; if (temp[0] == tile2.XYZLibraryCoordinates()[0] && temp[1] == tile2.XYZLibraryCoordinates()[1] && temp[2] == tile2.XYZLibraryCoordinates()[2]) { return true; } temp = tile1.XYZLibraryCoordinates(); temp[2]++; temp[0]--; //temp[2]; if (temp[0] == tile2.XYZLibraryCoordinates()[0] && temp[1] == tile2.XYZLibraryCoordinates()[1] && temp[2] == tile2.XYZLibraryCoordinates()[2]) { return true; } temp = tile1.XYZLibraryCoordinates(); temp[0]--; temp[1]--; //temp[2]; if (temp[0] == tile2.XYZLibraryCoordinates()[0] && temp[1] == tile2.XYZLibraryCoordinates()[1] && temp[2] == tile2.XYZLibraryCoordinates()[2]) { return true; } temp = tile1.XYZLibraryCoordinates(); temp[1]--; temp[2]--; //temp[2]; if (temp[0] == tile2.XYZLibraryCoordinates()[0] && temp[1] == tile2.XYZLibraryCoordinates()[1] && temp[2] == tile2.XYZLibraryCoordinates()[2]) { return true; } temp = tile1.XYZLibraryCoordinates(); temp[2]--; temp[0]++; //temp[2]; if (temp[0] == tile2.XYZLibraryCoordinates()[0] && temp[1] == tile2.XYZLibraryCoordinates()[1] && temp[2] == tile2.XYZLibraryCoordinates()[2]) { return true; } return false; }
/// <summary> /// </summary> /// <param name="tileIndex"></param> /// <param name="unitID"></param> /// <param name="postiveORnegative"></param> /// <param name="XYZ"></param> public void MoveUnit(int unitID, tile tileAt, tile tileTo, unitLib uLib) { if (tileAt.unitExists(unitID) && Tile_IsAdjacentTo(tileAt, tileTo) && uLib.unitList[uLib.FindIndexOfUnit_AtUnitID(unitID)].CurrentMovePoints > 0) { tileAt.removeUnit(unitID); tileTo.addUnit(unitID); uLib.unitList[uLib.FindIndexOfUnit_AtUnitID(unitID)].CurrentMovePoints--; } }
//finding the closest point //interate throught all points //if a point is closer store //loop //once you have gone through all of the points //the last stored point is the closest float checkDistance(tile target, tile source) { return Mathf.Pow(target.x - source.x, 2) + Mathf.Pow(target.y - source.y, 2); }
tile getRandomCoord() { tile coordinate = new tile (PseudoRng.Next (0, sizeX),PseudoRng.Next(0, sizeY)); return coordinate; }
void storeTiles() { mapData = new tile[sizeX, sizeY]; for(int y = 0; y < sizeY; y++) { for(int x = 0; x < sizeX; x++) { foreach(tile tile in myTiles) { if(tile.x == x && tile.y == y) { mapData[x,y]= tile; tile.tileContents = tileState.crossroad; break; //stops the loop because we fount the element } } if(mapData[x,y] == null) { mapData[x,y] = new tile(x,y); } } } }