private void UpdateVisionMarkers(IEnumerable <Vector3Int> visibleTiles) { ClearVisionMarkers(); foreach (Vector3Int tilePos in visibleTiles) { GameObject visionObj = Instantiate(tileVisionMarker, HexConverter.TileCoordToCartesianCoord(tilePos, 0.1f), Quaternion.identity); visionMarkers.Add(visionObj); } List <Vector3Int> borderEdges = hexMap.GetEdgePositions.TileBorders((visibleTiles)); foreach (Vector3Int edgePos in borderEdges) { EdgeAlignment orientation = HexUtility.GetEdgeAlignment(edgePos); float angle = HexUtility.anglebyEdgeAlignment[orientation]; GameObject edgeObj = GameObject.Instantiate( edgeVisionBorder, HexConverter.EdgeCoordToCartesianCoord(edgePos), Quaternion.Euler(0, angle, 0) ); visionMarkers.Add(edgeObj); } }
public static ReadOnlySpan <byte> Encode(AimeResponse response) { if (!_headers.TryGetValue(response.GetType(), out var header)) { throw new NotSupportedException("Not supported response type"); } Span <byte> packet = new byte[header.FrameLength]; packet.Write(header); packet.Write(response.Status, 8); switch (response) { case FeliCaLookupResponse fcLookup: packet.Write(HexUtility.HexToBytes(fcLookup.AccessCode), 36); break; case LookupResponse lookup: packet.Write(lookup.AimeId ?? -1, 32); packet.Write((byte)lookup.RegisterLevel, 36); break; case Lookup2Response lookup2: packet.Write(lookup2.AimeId ?? -1, 32); packet.Write((byte)lookup2.RegisterLevel, 36); break; case RegisterResponse register: packet.Write(register.AimeId ?? -1, 32); break; } return(packet); }
public void GettingWolrdCoordsFromHex_AndBack_ReturnsSameHex(int2 hex) { var point = new HexCell(hex).WorldPosition; var newHex = HexUtility.WorldPointToHex(point, 1); Assert.AreEqual(hex, newHex); }
private IEnumerator SpecialAttackDamageDelay(float a_timer) { //wait for timer before runing code yield return(new WaitForSeconds(a_timer)); //go though each tile and deal damage to the enemy foreach (Hex x in specialTiles) { //if there is a unit if (x.CurrentUnit != null) { //make sure we arent damaging the player or team if (x.CurrentUnit.Team != TEAM.player) { //deal damage to that unit x.CurrentUnit.TakeDamage(specialDamage[HexUtility.Distance(specialTiles[0], x) - 1], this); } } } //change the position of the camera to the position of the unit cameraController.transform.position = transform.position; //call the finished call back function specialFinishedFunc(); }
public void FindingHexNeighbours_BothFunctions_ReturnSameResults([ValueSource("OddAndEvenInt2")] int2 pos, [Values(2, 3, 4, 5, 7)] int level) { var actual = HexUtility.FindNeighbours(pos, level); var expected = HexUtility.DEPRECATE_FindNeighboursRecursive(pos, level); CollectionAssert.AreEquivalent(expected, actual); }
byte[] downLoadSector(byte[] bytes, byte cmd, uint sectorAddr) { byte[] txHex, hexReplace; int crc = 0; hexReplace = HexUtility.Replace(bytes, new byte[] { 0xEE }, new byte[] { 0xEE, 0xEE }); hexReplace = HexUtility.Replace(hexReplace, new byte[] { 0xAA }, new byte[] { 0xEE, 0xEA }); hexReplace = HexUtility.Replace(hexReplace, new byte[] { 0xCC }, new byte[] { 0xEE, 0xEC }); txHex = new byte[hexReplace.Length + 12]; txHex[3] = (byte)(bytes.Length >> 8); //NumberH txHex[4] = (byte)(bytes.Length); //NumberL txHex[5] = 64; //BlockSize txHex[6] = cmd; //Cmd txHex[7] = (byte)(sectorAddr >> 24); txHex[8] = (byte)(sectorAddr >> 16); txHex[9] = (byte)(sectorAddr >> 8); txHex[10] = (byte)(sectorAddr >> 0); Array.Copy(bytes, 0, txHex, 11, bytes.Length); for (int i = 0; i < bytes.Length + 8; i++) { crc = CRC16Byte(crc, txHex[i + 3]); } txHex[1] = (byte)(crc >> 8); //CRC_H txHex[2] = (byte)(crc); //CRC_L Array.Copy(hexReplace, 0, txHex, 11, hexReplace.Length); txHex = HexUtility.Replace(txHex, new byte[] { 0xAA }, new byte[] { 0xEE, 0xEA }); txHex = HexUtility.Replace(txHex, new byte[] { 0xCC }, new byte[] { 0xEE, 0xEC }); txHex[0] = 0xAA; //Head txHex[txHex.Length - 1] = 0xCC; //End return(txHex); }
private void UpdateReachableTileVisuals(List <Tile <MyTile> > reachableTiles) { foreach (GameObject g in reachableTilesMarkers) { Destroy(g); } reachableTilesMarkers.Clear(); foreach (Tile <MyTile> tile in reachableTiles) { GameObject tileObj = Instantiate(reachableMarker, tile.CartesianPosition, Quaternion.identity); tileObj.transform.position += new Vector3(0, 0.1f, 0); //0.1f = explicitly set y-Coord of the tile so it is slightly above the tiles of the map reachableTilesMarkers.Add(tileObj); } List <Vector3Int> borderEdges = hexMap.GetEdgePositions.TileBorders(reachableTiles); foreach (var edgePos in borderEdges) { EdgeAlignment orientation = HexUtility.GetEdgeAlignment(edgePos); float angle = HexUtility.anglebyEdgeAlignment[orientation]; GameObject edgeObj = Instantiate(edgeReachableBorder, HexConverter.EdgeCoordToCartesianCoord(edgePos), Quaternion.Euler(0, angle, 0)); reachableTilesMarkers.Add(edgeObj); } }
private void UpdateVisionMarkers(IEnumerable <Vector3Int> visibleTiles) { foreach (GameObject g in visionMarkers) { Destroy(g); } visionMarkers.Clear(); foreach (var tilePos in visibleTiles) { GameObject tileObj = Instantiate(tileVisionMarker, HexConverter.TileCoordToCartesianCoord(tilePos, 0.1f), Quaternion.identity); //0.1f = explicitly set y-Coord of the tile so it is slightly above the tiles of the map visionMarkers.Add(tileObj); } List <Vector3Int> borderEdges = hexMap.GetEdgePositions.TileBorders(visibleTiles); foreach (var edgePos in borderEdges) { EdgeAlignment orientation = HexUtility.GetEdgeAlignment(edgePos); float angle = HexUtility.anglebyEdgeAlignment[orientation]; GameObject edgeObj = Instantiate(edgeVisionBorder, HexConverter.EdgeCoordToCartesianCoord(edgePos), Quaternion.Euler(0, angle, 0)); visionMarkers.Add(edgeObj); } }
private void ChooseAreaToAttack() { if (turns == 1 || rechargeTurns == 0) { // Select Area to shoot to Hex furthestPlayerTile = null; if (Manager.instance.PlayerController.EarthUnit.IsDead || Manager.instance.PlayerController.EarthUnit == null) { furthestPlayerTile = Manager.instance.PlayerController.LightningUnit.CurrentTile; } else if (Manager.instance.PlayerController.LightningUnit.IsDead || Manager.instance.PlayerController.LightningUnit == null) { furthestPlayerTile = Manager.instance.PlayerController.EarthUnit.CurrentTile; } else { float distanceToEarth = Vector3.Distance(CurrentTile.transform.position, Manager.instance.PlayerController.EarthUnit.CurrentTile.transform.position); float distanceToLightning = Vector3.Distance(CurrentTile.transform.position, Manager.instance.PlayerController.LightningUnit.CurrentTile.transform.position); furthestPlayerTile = distanceToEarth > distanceToLightning ? Manager.instance.PlayerController.EarthUnit.CurrentTile : Manager.instance.PlayerController.LightningUnit.CurrentTile; } // Attack the hex behind the furthest player Hex hexToAttack = furthestPlayerTile.GetNeighbour(HexUtility.VecToHexDirection(furthestPlayerTile.transform.position - CurrentTile.transform.position)); tilesToAttack = Manager.instance.Grid.GetTilesWithinDistance(hexToAttack, 2, false, true).ToArray(); // Rotate to the direction StartCoroutine(Rotate(hexToAttack.transform.position)); // Highlight the area around the hex Manager.instance.HexHighlighter.HighLightArea(new List <Hex>(tilesToAttack), Color.yellow, Color.yellow, this, null, HighlightType.FLAME); readyToAttack = true; } }
public static String GetEditValue(Asn1Reader asn) { switch (asn.Tag) { case (Byte)Asn1Type.INTEGER: return(new Asn1Integer(asn.RawData).Value.ToString()); case (Byte)Asn1Type.BIT_STRING: return(HexUtility.GetHexEditString(new Asn1BitString(asn).Value)); case (Byte)Asn1Type.OBJECT_IDENTIFIER: Oid oid = new Asn1ObjectIdentifier(asn).Value; return(oid.Value); case (Byte)Asn1Type.BOOLEAN: case (Byte)Asn1Type.UTCTime: case (Byte)Asn1Type.GeneralizedTime: case (Byte)Asn1Type.UTF8String: case (Byte)Asn1Type.NumericString: case (Byte)Asn1Type.PrintableString: case (Byte)Asn1Type.TeletexString: case (Byte)Asn1Type.VideotexString: case (Byte)Asn1Type.IA5String: case (Byte)Asn1Type.VisibleString: case (Byte)Asn1Type.UniversalString: case (Byte)Asn1Type.BMPString: return(GetViewValue(asn)); default: return((asn.Tag & (Byte)Asn1Type.TAG_MASK) == 6 ? Encoding.UTF8.GetString(asn.GetPayload()) : HexUtility.GetHexEditString(asn.GetPayload())); } }
public void FindingHexNeighbours_ReturnsCorrectNeighbours_ForLevel1_Odd() { var neighbours = HexUtility.FindNeighbours(new int2(1, 1)); var expectedNneighbours = new[] { new int2(2, 1), new int2(0, 1), new int2(0, 2), new int2(1, 2), new int2(0, 0), new int2(1, 0) }; CollectionAssert.AreEquivalent(expectedNneighbours, neighbours); }
private FeliCaLookupResponse FeliCaLookup(FeliCaLookupRequest request) { string accessCode = HexUtility.HexToDecimalString(request.Idm).PadLeft(20, '0'); return(Ok(new FeliCaLookupResponse { AccessCode = accessCode })); }
private static AimeRequest DecodeRegisterRequest(ref ReadOnlySpan <byte> packet) { var request = new RegisterRequest(); DecodeMetadata(request, ref packet); request.AccessCode = HexUtility.BytesToHex(packet.Slice(32, 10)); return(request); }
private void Awake() { HexUtility.UpdateScale(1); Transform grid = GameObject.FindGameObjectWithTag("Grid").transform; holder = new GameObject("Highlight Container").transform; holder.position = new Vector3(0.0f, grid.position.y + 0.05f); }
public static List <Hex> FindPath(Hex a_starting, Hex a_target) { List <Hex> openSet = new List <Hex>(); HashSet <Hex> closedSet = new HashSet <Hex>(); openSet.Add(a_starting); while (openSet.Count > 0) { Hex current = openSet[0]; current.HScore = HexUtility.Distance(current, a_target); for (int i = 1; i < openSet.Count; i++) { if (openSet[i].FScore < current.FScore || (openSet[i].FScore == current.FScore && openSet[i].FScore < current.FScore)) { current = openSet[i]; } } closedSet.Add(current); openSet.Remove(current); if (current == a_target) { foreach (Hex node in closedSet) { node.GScore = 0; } return(RetracePath(a_starting, a_target)); } foreach (Hex neighbour in current.Neighbours) { if (!neighbour.IsTraversable || closedSet.Contains(neighbour)) { continue; } float newMovemntCostToNeighour = current.GScore + HexUtility.Distance(current, neighbour); if (newMovemntCostToNeighour < neighbour.GScore || !openSet.Contains(neighbour)) { neighbour.GScore = newMovemntCostToNeighour; neighbour.HScore = HexUtility.Distance(neighbour, a_target); neighbour.Parent = current; if (!openSet.Contains(neighbour)) { openSet.Add(neighbour); } } } } return(null); }
public void RgbToHexForCorrectLowercase() { // Arrange Byte r = 255; Byte g = 255; Byte b = 255; // Act and Assert Assert.AreEqual("ffffff", HexUtility.RgbToHexValue(r, g, b)); }
private static AimeRequest DecodeFeliCaLookupRequest(ref ReadOnlySpan <byte> packet) { var request = new FeliCaLookupRequest(); DecodeMetadata(request, ref packet); request.Idm = HexUtility.BytesToHex(packet.Slice(32, 8)); request.Pmm = HexUtility.BytesToHex(packet.Slice(40, 8)); return(request); }
public void GettingHexFromRealWorld_AndBack_ReturnsSameHex(Vector3 point, int2 expectedHex) { var originalHex = HexUtility.WorldPointToHex(point, 1); var centerOfHex = new HexCell(originalHex).WorldPosition; var newHex = HexUtility.WorldPointToHex(centerOfHex, 1); Assert.AreEqual(expectedHex, originalHex, "Original coordinates produced incorect hex cell"); Assert.AreEqual(originalHex, newHex, "Hexes should be the same before and after conversion"); }
public void RgbToHexForCorrectPadding() { // Arrange Byte r = 1; Byte g = 2; Byte b = 3; // Act and Assert Assert.AreEqual("010203", HexUtility.RgbToHexValue(r, g, b)); }
public void RgbToHexForValueZero() { // Arrange Byte r = 0; Byte g = 0; Byte b = 0; // Act and Assert Assert.AreEqual("000000", HexUtility.RgbToHexValue(r, g, b)); }
/// <summary> /// /// </summary> /// <param name="color"></param> /// <param name="fileName"></param> public void SaveInactiveAccentColorToRegFile(Color color, string fileName) { String bgrHex = "00" + HexUtility.RgbToHexValue(color.B, color.G, color.R); String textToWrite = Preamble + $"[{WindowCustomizationUtility.AccentColorKeyFullPath}]" + $"\r\n\"{WindowCustomizationUtility.InactiveAccentColorKeyName}\"=dword:{bgrHex}"; _fileSystem.File.WriteAllText(fileName, textToWrite); }
public void Render(List <Vector3Int> hexes) { foreach (var h in hexes) { var pos = HexUtility.PixelFromCubeCoord(h, size); var prism = Instantiate(tile, new Vector3(pos.x, 0f, pos.y), Quaternion.identity); prism.radius = size; prism.Render(); } }
//Should be sealed? protected override Mesh GenerateMesh() { Mesh m = new Mesh(); var hexPositions = HexUtility.Spiral(hexGridDist); m.vertices = GenerateVertices(hexPositions); m.normals = GenerateNormals(hexPositions, m.vertices); m.triangles = GenerateTriangles(hexGridDist); return(m); }
protected virtual Vector3[] GenerateVertices(List <Vector3Int> hexPositions) { Vector3[] verts = new Vector3[hexPositions.Count]; for (int i = 0; i < hexPositions.Count; i++) { var pos = HexUtility.PixelFromCubeCoord(hexPositions[i], 1f); verts[i] = new Vector3(pos.x, 0f, pos.y); } return(verts); }
static AimeSession() { var aes = new RijndaelManaged { BlockSize = 128, Key = HexUtility.HexToBytes("436f7079726967687428432953454741"), Mode = CipherMode.ECB, Padding = PaddingMode.Zeros }; _decryptor = aes.CreateDecryptor(); _encryptor = aes.CreateEncryptor(); }
/// Returns an List forming a line between 2 points. public static List <Vector3Int> GetLine(Vector3Int origin, Vector3Int target, float offsetFromOriginCenter, int trimStart, int trimEnd) { List <Vector3Int> lineCells = new List <Vector3Int>(); var dist = Distance(origin, target); for (int i = trimStart; i <= dist - trimEnd; i++) { Vector3 lerped = HexUtility.LerpCube(origin, target, offsetFromOriginCenter, (1f / dist) * i); Vector3Int cell = HexUtility.RoundCube(lerped); lineCells.Add(cell); } return(lineCells); }
// This test is a bit slow, so doing both things, checking Covered Area and Computed path public void Pathfinder_CoveredCells_AndPathSize_AreCorrectOnEmptyMap([ValueSource("OddAndEvenInt2")] int2 cellFrom, [ValueSource("SomeRandomInt2")] int2 cellTo) { var c = TestUtility.CreateContainer(); var pathfinder = c.Resolve <IHexPathfinder>(); var distance = HexUtility.ManhattanDistance(cellFrom, cellTo); var coveredCellsExpected = HexUtility.FindNeighbours(cellFrom, distance); var pathMap = pathfinder.FindAllPaths(cellFrom, HexType.Empty, distance); var coveredCellsActual = pathMap.CoveredCells(); var pathToDestination = pathMap.CalculatePath(cellTo); Assert.AreEqual(coveredCellsExpected.Length, coveredCellsActual.Count(), "Collection sizes were different"); CollectionAssert.AreEquivalent(coveredCellsExpected, coveredCellsActual, "Elements inside were different"); Assert.AreEqual(distance, pathToDestination.Count(), "Calculated path size was incorrect"); }
public Hex[] GetHexLine(Hex a_lhs, Hex a_rhs) { List <Hex> hexs = new List <Hex>(); int distance = HexUtility.Distance(a_lhs, a_rhs); float scale = HexUtility.outerRadius; for (int i = 0; i < distance; i++) { hexs.Add(GetHexFromPosition(Vector3.Lerp(a_lhs.transform.position, a_rhs.transform.position, scale / distance * i))); } return(hexs.ToArray()); }
static public MaterialStruct FindMaterialStructFromColour(Color col) { string hexId = HexUtility.colorToHex(col); Debug.Log("Find " + hexId); for (int i = 0; i < m_materialDataCopy.Length; i++) { var hex = m_materialDataCopy[i].m_hexCol; if (hex == hexId) { return(m_materialDataCopy[i]); } } return(null); }
protected override Vector3[] GenerateVertices(List <Vector3Int> hexPositions) { var verts = base.GenerateVertices(hexPositions); float perlinOffsetX = Random.Range(-10000f, 10000f); float perlinOffsetY = Random.Range(-10000f, 10000f); for (int i = 0; i < verts.Length; i++) { Vector2 pixel = HexUtility.PixelFromCubeCoord(hexPositions[i], 1f); float height = heightFactor * Mathf.PerlinNoise(perlinOffsetX + pixel.x * noiseSpaceStep, perlinOffsetY + pixel.y * noiseSpaceStep); verts[i] = new Vector3(verts[i].x, height, verts[i].z); } return(verts); }