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);
}
