public void CheckAdjacentHexes(int diceRoll) { for (int i = 0; i < Hexes.Count; i++) { if (Hexes[i].GetComponent <ScriptBoardHex>().hexDieValue == diceRoll) { HexType resource = Hexes[i].GetComponent <ScriptBoardHex>().resource; switch (resource) { case HexType.BRICK: player.AddBricks(1); break; case HexType.GRAIN: player.AddWheat(1); break; case HexType.WOOD: player.AddLumber(1); break; case HexType.WOOL: player.AddWool(1); break; } } } }
private Canvas GetPieceInHandCanvas(Piece piece, double size, HexOrientation hexOrientation, bool disabled) { Point center = new Point(size, size); HexType hexType = (piece.Color == Core.Color.White) ? HexType.WhitePiece : HexType.BlackPiece; Shape hex = GetHex(center, size, hexType, hexOrientation); UIElement hexText = GetHexText(center, size, piece.PieceName, disabled); Canvas pieceCanvas = new Canvas { Height = size * 2, Width = size * 2, Margin = new Thickness(PieceCanvasMargin), Background = (piece.Color == Core.Color.White) ? WhiteHandStackPanel.Background : BlackHandStackPanel.Background, Name = EnumUtils.GetShortName(piece.PieceName) }; pieceCanvas.Children.Add(hex); pieceCanvas.Children.Add(hexText); // Add highlight if the piece is selected if (VM.AppVM.EngineWrapper.TargetPiece == piece.PieceName) { Shape highlightHex = GetHex(center, size, HexType.SelectedPiece, hexOrientation); pieceCanvas.Children.Add(highlightHex); } pieceCanvas.MouseLeftButtonUp += PieceCanvas_MouseLeftButtonUp; pieceCanvas.MouseRightButtonUp += CancelClick; return(pieceCanvas); }
/// <summary> /// Adds cells to array based on metrics, max width & max height /// </summary> /// <param name="x">X coord of cell in array</param> /// <param name="z">Z coord of cell in array</param> /// <param name="type"></param> /// <param name="isHill"></param> void CreateCell(int x, int z, HexType type, bool isHill) { Vector3 pos; pos.x = (x + z * 0.5f - z / 2) * (HexMetrics.innerRad * 2f); pos.y = 0f; pos.z = z * HexMetrics.outerRad * 1.5f; HexCell cell = cells[x, z] = Instantiate <HexCell>(cellPrefab); cell.transform.localPosition = pos; cell.coordinates = HexCoordinates.FromOffsetCoordinates(x, z); cell.name = "Hex Cell " + cell.coordinates.ToString(); if (type != null) { cell.Type = type; } else { cell.Type = HexType.types[HexType.typeKeys.ocean]; } cell.isHill = isHill; /*if (showCoords) * { * Text label = Instantiate<Text>(labelPrefab); * //label.rectTransform.SetParent(gridCanvas.transform, false); * label.rectTransform.anchoredPosition = new Vector2(pos.x, pos.z); * label.text = cell.coordinates.ToStringOnSeparateLines(); * }*/ AddCellToChunk(x, z, cell); }
public void SetNextType() { if (++Type >= HexType.Count) { Type = 0; } }
// Create hexmap indicator attached to hexcell public void GenerateHexType(HexCell cell, HexType type) { cell.hexType = type; // hexTypes[x+mapWidth*z] = type; if (type != HexType.Plain) { HexTypeInfo gm = null; if (type == HexType.Forest) { gm = Instantiate(hexPrefab_forest); } else if (type == HexType.Swamp) { gm = Instantiate(hexPrefab_swamp); } else if (type == HexType.Mountain) { gm = Instantiate(hexPrefab_mountain); } else if (type == HexType.Stones) { gm = Instantiate(hexPrefab_stones); } /*else if (type==HexType.Thorns) * gm = Instantiate(hexPrefab_thorns);*/ if (gm != null) { gm.ChangeType(type); gm.gameObject.transform.SetParent(cell.transform); gm.gameObject.transform.localPosition = Vector3.zero; } } }
public Hex ChangeHexes(int a, Hex hex) { int xHex = hex.x; int yHex = hex.y; float xPos = xHex * xOffset; if (yHex % 2 == 1) { xPos += xOffset / 2f; } hexes [xHex, yHex] = a; Destroy(hex.gameObject); HexType tt = hextypes [hexes [xHex, yHex]]; GameObject hex_go = Instantiate(tt.hexVisualPrefab, new Vector3(xPos, 0, yHex * zOffset), Quaternion.identity) as GameObject; hex_go.name = "Hex_" + xHex + "_" + yHex; hex_go.GetComponent <Hex> ().x = xHex; hex_go.GetComponent <Hex> ().y = yHex; hex_go.GetComponent <Hex> ().hexType = a; hex_go.GetComponent <Hex> ().CalculateResources(); hex_go.transform.SetParent(this.transform); hex_go.isStatic = true; return(hex_go.GetComponent <Hex> ()); }
public void CreateClump() { if (_clumpGrid == null) { InitializeGrid(); } _clumpGrid.ResetGrid(); _isLaser = false; _pieces = new List <HexPiece>(); _startingPositions = new Dictionary <HexPiece, Vector3>(); HexType clumpType = (HexType)Random.Range((int)HexType.Basic1, (int)HexType.Basic5 + 1); // Random.Range is Max _exclusive_ for ints int clumpSize = Random.Range(MinClumpSize, MaxClumpSize + 1); if (ClumpShape == ClumpShape.Random) { CreateRandomShapedClump(clumpType, clumpSize); } else if (ClumpShape == ClumpShape.Triangular) { CreateTriangularShapedClump(clumpType, clumpSize); } }
void GenerateMapVisual() { for (int x = 0; x < width; x++) { for (int y = 0; y < height; y++) { float xPos = x * xOffset; //Are we on an odd row? if (y % 2 == 1) { xPos += xOffset / 2f; } HexType tt = hextypes [hexes [x, y]]; GameObject hex_go = Instantiate(tt.hexVisualPrefab, new Vector3(xPos, 0, y * zOffset), Quaternion.identity) as GameObject; hex_go.name = "Hex_" + x + "_" + y; hex_go.GetComponent <Hex> ().x = x; hex_go.GetComponent <Hex> ().y = y; hex_go.transform.SetParent(this.transform); hex_go.isStatic = true; } } }
public int x, y; // index on the board public Hex(GameObject go, HexType type, int x, int y) { this.go = go; this.type = type; this.x = x; this.y = y; }
public Hex BuildingHex(int a, Hex hex) { int xHex = hex.x; int yHex = hex.y; float xPos = xHex * xOffset; if (yHex % 2 == 1) { xPos += xOffset / 2f; } hexes [xHex, yHex] = a; Destroy(hex.gameObject); HexType tt = hextypes [hexes [xHex, yHex]]; GameObject hex_go = Instantiate(tt.hexVisualPrefab, new Vector3(xPos, 0, yHex * zOffset), Quaternion.identity) as GameObject; hex_go.name = "Hex_" + xHex + "_" + yHex; hex_go.GetComponent <Hex> ().x = xHex; hex_go.GetComponent <Hex> ().y = yHex; hex_go.transform.SetParent(this.transform); hex_go.isStatic = true; GameObject.Find("MouseManager").GetComponent <NextTurnManager> ().AddBuilding(hex_go); return(hex_go.GetComponent <Hex> ()); }
/// <summary> /// /// </summary> /// <param name="addr"></param> /// <param name="type"></param> /// <param name="val"></param> /// <param name="isHighFirst"></param> /// <returns></returns> public static string ToHexLine(long addr, HexType type, byte[] val, bool isHighFirst = false) { string _return = ":"; byte checkSum = (byte)(val.Length); _return += checkSum.ToString("X2"); checkSum += (byte)(addr >> 8); checkSum += (byte)(addr); _return += addr.ToString("X4"); checkSum += (byte)(type); _return += ((byte)type).ToString("X2"); for (int i = 0; i < val.Length; i += 2) { if (isHighFirst) { _return += string.Format("{0:X2}{1:X2}", val[i + 1], val[i]); } else { _return += string.Format("{0:X2}{1:X2}", val[i], val[i + 1]); } checkSum += val[i]; checkSum += val[i + 1]; } checkSum = (byte)(0x100 - checkSum); _return += checkSum.ToString("X2"); _return += "\r\n"; return(_return); }
/// <summary> /// 将数据转换成HexLine /// </summary> /// <param name="addr"></param> /// <param name="type"></param> /// <param name="buffer"></param> /// <param name="isHighFirst"></param> /// <returns></returns> public static string ToHexLine(long addr, HexType type, byte[] buffer, bool isHighFirst = false) { string _return = ":"; byte crc = (byte)(buffer.Length); _return += crc.ToString("X2"); crc += (byte)(addr >> 8); crc += (byte)(addr); _return += addr.ToString("X4"); crc += (byte)(type); _return += ((byte)type).ToString("X2"); for (int i = 0; i < buffer.Length; i += 2) { if (isHighFirst) { _return += string.Format("{0:X2}{1:X2}", buffer[i + 1], buffer[i]); } else { _return += string.Format("{0:X2}{1:X2}", buffer[i], buffer[i + 1]); } crc += buffer[i]; crc += buffer[i + 1]; } crc = (byte)(0x100 - crc); _return += crc.ToString("X2"); _return += "\r\n"; return(_return); }
public static Color color(this HexType hexType) { switch (hexType) { case HexType.FOREST: return(new Color(56 / 255f, 142 / 255f, 60 / 255f, 1)); case HexType.PASTURE: return(new Color(139 / 255f, 195 / 255f, 74 / 255f, 1)); case HexType.DESERT: return(new Color(255 / 255f, 236 / 255f, 179 / 255f, 1)); case HexType.FIELD: return(new Color(255 / 255f, 235 / 255f, 59 / 255f, 1)); case HexType.HILLS: return(new Color(255 / 255f, 87 / 255f, 34 / 255f, 1)); case HexType.MOUNTAIN: return(new Color(97 / 255f, 97 / 255f, 97 / 255f, 1)); default: return(Color.black); } }
private static string GetCountForType(HexType hexType, World w) { const string stats = "Total {0} : {1} ({2}%)"; var totalHexesOfType = w.TotalHexesOfType(hexType); var percentage = totalHexesOfType/(double)w.TotalHexes * 100; return string.Format(stats, hexType, totalHexesOfType, percentage); }
public void SetHexType(HexType hexType) { this.HexType = hexType; if (HexType == HexType.PointyTop) { Hex.transform.Rotate(0, 0, 90); } }
public HexLibrary(HexType hexType, OffsetCoordinatesType offsetCoordinatesType, float hexSize) { _hex = hexType switch { HexType.FlatTopped => new HexFlatTopped(offsetCoordinatesType, hexSize), HexType.PointyTopped => new HexPointyTopped(offsetCoordinatesType, hexSize), _ => throw new ArgumentOutOfRangeException(nameof(hexType), hexType, $"HexType {hexType} is not supported.") }; }
public PathfinderDictionary FindAllPaths(HexCell hex, HexType typeFlags, int distance) { var queue = new PathfinderQueue(); var map = new PathfinderDictionary(); queue.Enqueue((hex.Position, hex.Position, 0)); TraverseAll(queue, map, typeFlags, distance); return(map); }
public bool ChangeCellState(HexCoordinates existingCoord, HexType newState) { if (_allCells.ContainsKey(existingCoord)) { _allCells[existingCoord] = newState; return(true); } return(false); }
public Hex(HexType type, int i) { Type = type; Occupant = null; Objective = new Objective(); Impassable = false; Placeable = false; Owner = null; }
public Hex(HexType type, Player player) { Type = type; Occupant = null; Objective = null; Impassable = false; Placeable = true; Owner = player; }
public static bool IsBiome(HexType hex) { return (hex == HexType.FireBiome || hex == HexType.WaterBiome || hex == HexType.EarthBiome || hex == HexType.GrowthBiome || hex == HexType.ShadowBiome || hex == HexType.PoisonBiome); }
public static bool IsElement(HexType hex) { return (hex == HexType.Fire || hex == HexType.Water || hex == HexType.Earth || hex == HexType.Growth || hex == HexType.Shadow || hex == HexType.Poison); }
public ScriptHex(Vector2 center, float size) { hexType = HexType.NONE; hexNum = 0; hexCenter = center; for (int i = 0; i < 6; i++) { hexCorners[i] = GenerateHexPoint(hexCenter, size, i); } }
public Hex(Index2D inx, Point center, HexType type, int height) { r = GlobalConst.DEFAULT_r; a = 2d / Math.Sqrt(3) * r; index = inx; this.type = type; this.height = height; if (type != HexType.Empty) render = new HexRender(DisplayType.GAME_SimpleGround, height, center); }
void SpawnLineOf(HexType type, Hex start, Hex end) { List <Hex> hexes; GridManager.Instance.DrawLineOnGrid(start, end, out hexes); foreach (Hex h in hexes) { h.Type = type; } }
float CostOfTile(int SourceX, int SourceY, int TargetX, int TargetY) { HexType ht = hexType[Hexes[TargetX, TargetY]]; float cost = ht.movementCost; if (SourceX != TargetX && SourceY != TargetY) { cost += 0.001f; } return(ht.movementCost); }
private HexPiece AddHexPieceToClump(HexType pieceType, Transform parent) { HexPiece newPiece = Instantiate(HexPiecePrefab, parent); newPiece.Type = pieceType; newPiece.clump = this; _pieces.Add(newPiece); _startingPositions[newPiece] = newPiece.transform.position; return(newPiece); }
public void createCard(HexType hexType) { Card card = Instantiate(cardPrefab).GetComponent <Card>(); //if (cardSize == Vector3.zero) cardSize = card.GetComponent<Renderer>().bounds.size; card.index = cards.Count; card.transform.parent = this.transform; card.hexType = hexType; cards.Add(card); reposition(); }
private void CreateRandomShapedClump(HexType clumpType, int clumpSize) { HexCell currentCell = _clumpGrid.GetCenterCell(); AddHexPieceToClump(clumpType, currentCell.transform); for (int i = 1; i < clumpSize; ++i) // For each remaining piece to be created { currentCell = currentCell.GetRandomEmptyNeighbour(); AddHexPieceToClump(clumpType, currentCell.transform); } }
void GenerateMapVisualHexes() { double r = 0, c = 0, z = 0; for (int x = 0; x < MapSizeX; x++) { if (x % 2 == 0) { r = 0; } else { r = 0.95; } for (int y = 0; y < MapSizeY; y++) { HexType ht = hexType[Hexes[x, y]]; //different levels of hex types (buffs, mountains, debuffs) switch (Hexes[x, y]) { case 0: z = 0; break; case 1: z = 0.5; break; case 2: z = -0.5; break; default: z = 0; break; } //Used to set the prefab on the map as well as able to get the object that was clicked on. GameObject gObject = (GameObject)Instantiate(ht.VisualHexPrefab, new Vector3((float)r, (float)c, (float)z), Quaternion.identity); gObject.name = "Hex_" + x + "_" + y; gObject.transform.SetParent(this.transform); gObject.GetComponent <ClickableHex>().clearSelectedUnit(); ClickableHex clickhex = gObject.GetComponent <ClickableHex>(); clickhex.HexX = x; clickhex.HexY = y; //Debug.Log(clickhex.HexX + " , " + clickhex.HexY); clickhex.map = this; r = r + 1.9; //X coordinates } c = c + 1.6; // Y coordinates } }
// Fill the selected hex with the public void Fill(HexType playerType) { // If the hex already has a type, return if (currentType != HexType.None) { return; } currentType = playerType; SetTileMesh(); GetComponent <MeshRenderer>().enabled = false; }
protected void SetForceField(bool b) { if (b) { type = CurrentHexType; CurrentHexType = HexType.WalledImpassable; Debug.Log("walled " + name); } else { CurrentHexType = type; Debug.Log("No longer walled " + name); } }
public void addResource(int playerIndex, int turn, HexType resource) { resourcesOnTurn[playerIndex][turn].Add(resource); }
void Awake() { hexType = HexType.Grass; roadBlock = null; setTexture (0); gameController = GameObject.Find ("GameController"); }
// Sets the type of the hexa and switces the texture public void setType(HexType type) { hexType = type; switch (type) { case HexType.Grass: setTexture (0); break; case HexType.Road: setTexture (1); break; case HexType.Mountain: //setTexture (2); break; case HexType.End: setTexture (3); break; } }
void Awake() { hexType = HexType.Grass; roadBlock = null; setTexture (0); gameController = GameObject.Find ("GameController"); selecter = GameObject.Find("MapHexaSelectHighlight"); }
void Awake() { hexType = new HexType(HexType.BlockType.Fire); }
public int TotalHexesOfType(HexType hexType) { return Hexes.Where(h => h.HexType == hexType).Count(); }
public ScriptHex() { hexType = HexType.NONE; hexNum = 0; }