public void TestWalkForward()
{
// Given
HyperGrid hyperGrid = new HyperGrid(8, 8, 8, 8);
HyperPosition playerPosition = new HyperPosition(0, 1, 0, 3);
HyperDirection playerDirection = new HyperDirection(Direction.east, Direction.up, Direction.north, Direction.left);
Player player = new Player(playerPosition, playerDirection);
Game game = new Game(player, hyperGrid);
for (int x = 0; x < 7; x++)
{
hyperGrid.setBlocked(x, 0, 0, 3);
}
//When
game.process(MoveIntent.forward);
Assert.AreEqual(new HyperPosition(1, 1, 0, 3), player.position, player.position.printOut());
game.process(MoveIntent.forward);
Assert.AreEqual(new HyperPosition(2, 1, 0, 3), player.position, player.position.printOut());
game.process(MoveIntent.forward);
Assert.AreEqual(new HyperPosition(3, 1, 0, 3), player.position, player.position.printOut());
game.process(MoveIntent.forward);
Assert.AreEqual(new HyperPosition(4, 1, 0, 3), player.position, player.position.printOut());
//Then
Assert.AreEqual(new HyperDirection(Direction.east, Direction.up, Direction.north, Direction.left), player.direction);
}
public static HyperPosition operator*(float3 fl3, HyperDistance hyd)
{
HyperPosition hyp = new HyperPosition {
prs = fl3, oct = new int3()
};
return(hyp * hyd);
}
protected override void OnUpdate()
{
if (flag)
{
return;
}
flag = true;
ComponentGroup planetGroup = GetComponentGroup(typeof(Planet), typeof(PlanetNoise));
ComponentGroup dataGroup = GetComponentGroup(typeof(PlanetSharedData));
ComponentDataArray <Planet> planetArray = planetGroup.GetComponentDataArray <Planet>();
ComponentDataArray <PlanetNoise> noiseArray = planetGroup.GetComponentDataArray <PlanetNoise>();
SharedComponentDataArray <PlanetSharedData> dataArray = dataGroup.GetSharedComponentDataArray <PlanetSharedData>();
GameObject prefab = dataArray[0].nodePrefab;
for (int i = 0; i < planetArray.Length; ++i)
{
Planet planet = planetArray[i];
PlanetNoise noise = noiseArray[i];
HyperDistance r = planet.radius;
for (int n = 0; n < 20; ++n)
{
Entity nodeEntity = EntityManager.Instantiate(prefab);
TerrainNode node = EntityManager.GetComponentData <TerrainNode>(nodeEntity);
node.level = 0;
node.planetData = planet;
node.noiseData = noise;
node.built = 0;
node.divided = 0;
node.hyperDistant = 1;
int idx = n * 3;
node.corner1 = icoVerts[idx];
node.corner2 = icoVerts[idx + 1];
node.corner3 = icoVerts[idx + 2];
EntityManager.SetComponentData(nodeEntity, node);
HyperPosition pos = math.normalize(node.corner1 + node.corner2 + node.corner3) * r;
PrecisePosition prspos = new PrecisePosition {
pos = pos.prs
};
EntityManager.SetComponentData(nodeEntity, prspos);
OctantPosition octpos = new OctantPosition {
pos = pos.oct
};
EntityManager.SetComponentData(nodeEntity, octpos);
}
}
}
public void PlayerOnWinPlayerWins()
{
// Given
HyperPosition playerStart = new HyperPosition(0, 0, 0, 0);
Player player = new Player(playerStart, HyperDirection.normal);
HyperGrid hyperGrid = new HyperGrid(8, 8, 8, 8);
Game game = new Game(player, hyperGrid, new HyperPosition(0, 0, 0, 0));
Assert.IsTrue(game.checkWon());
}
public void RotatingPlayerDoesntChangePosition()
{
//Given
HyperDirection dir = new HyperDirection(Direction.north, Direction.right, Direction.east, Direction.down);
HyperPosition pos = new HyperPosition(3, 3, 23, 1);
Player player = new Player(pos, dir);
//When
player.move(MoveResult.toRightSide).move(MoveResult.toUnseenLeft).move(MoveResult.toRightSide).move(MoveResult.toRightSide).move(MoveResult.toUnseenLeft).move(MoveResult.toUnseenLeft).move(MoveResult.toLeftSide);
//Then
Assert.AreEqual(new HyperPosition(3, 3, 23, 1), player.position);
}
public void MovePlayerNorth()
{
//Given
HyperDirection dir = new HyperDirection(Direction.north, Direction.up, Direction.west, Direction.left);
HyperPosition pos = new HyperPosition(6, 2, 1, 1);
Player player = new Player(pos, dir);
Assert.AreEqual(player.position.z, 1);
//When
player.move(MoveResult.forward);
//Then
Assert.AreEqual(player.position.z, 2);
}
public void PlayerMoveIntoUnseen()
{
//Given
HyperDirection startingDirection = new HyperDirection(Direction.east, Direction.up, Direction.north, Direction.right);
HyperPosition pos = new HyperPosition(0, 0, 0, 0);
Player player = new Player(pos, startingDirection);
player.move(MoveResult.toUnseenRight).move(MoveResult.forward).move(MoveResult.forward).move(MoveResult.forward).move(MoveResult.forward);
HyperPosition expectedPosition = new HyperPosition(0, 0, 0, -4);
HyperDirection expectedRotation = new HyperDirection(Direction.right, Direction.up, Direction.north, Direction.west);
Assert.AreEqual(expectedPosition, player.position);
Assert.AreEqual(expectedRotation, player.direction);
}
public void PlayerMoveForwardTwiceTurnLeftAndThenUp()
{
//Given
HyperDirection startingDirection = new HyperDirection(Direction.north, Direction.right, Direction.east, Direction.down);
HyperPosition pos = new HyperPosition(4, 0, 0, 0);
Player player = new Player(pos, startingDirection);
player.move(MoveResult.forward).move(MoveResult.forward).move(MoveResult.toLeftSide).move(MoveResult.upward);
HyperPosition expectedPosition = new HyperPosition(4, 0, 2, 0);
HyperDirection expectedRotation = new HyperDirection(Direction.right, Direction.east, Direction.north, Direction.down);
Assert.AreEqual(expectedPosition, player.position);
Assert.AreEqual(expectedRotation, player.direction, player.direction.discription());
}
public void MoveUpWallChangesDirectionNotPosition()
{
//Given
HyperDirection dir = new HyperDirection(Direction.up, Direction.west, Direction.south, Direction.left);
HyperPosition pos = new HyperPosition(3, 2, 1, 1);
Player player = new Player(pos, dir);
//When
player.move(MoveResult.upward);
//Then
HyperPosition expectedPosition = new HyperPosition(3, 2, 1, 1);
HyperDirection expectedRotation = new HyperDirection(Direction.west, Direction.down, Direction.south, Direction.left);
Assert.AreEqual(expectedPosition, player.position);
Assert.AreEqual(expectedRotation, player.direction);
}
public void MoveDownChangesPositionAndRotation()
{
//Given
HyperDirection dir = new HyperDirection(Direction.east, Direction.up, Direction.south, Direction.left);
HyperPosition pos = new HyperPosition(5, 2, 20, 8);
Player player = new Player(pos, dir);
//When
player.move(MoveResult.downward);
//Then
HyperPosition expectedPosition = new HyperPosition(6, 1, 20, 8);
HyperDirection expectedRotation = new HyperDirection(Direction.down, Direction.east, Direction.south, Direction.left);
Assert.AreEqual(expectedPosition, player.position);
Assert.AreEqual(expectedRotation, player.direction);
}
public void TestGameMovesPlayerDownAndForward()
{
// Given
HyperGrid hyperGrid = new HyperGrid(5, 5, 5, 5);
HyperPosition playerPosition = new HyperPosition(0, 1, 0, 0);
HyperDirection playerDirection = new HyperDirection(Direction.east, Direction.up, Direction.north, Direction.left);
Player player = new Player(playerPosition, playerDirection);
Game game = new Game(player, hyperGrid);
hyperGrid.setBlocked(0, 0, 0, 0);
//When
game.process(MoveIntent.forward);
//Then
Assert.AreEqual(new HyperPosition(1, 0, 0, 0), player.position);
}
public void MovePlayerForwardFourTimes()
{
//Given
HyperDirection dir = new HyperDirection(Direction.up, Direction.west, Direction.south, Direction.left);
HyperPosition pos = new HyperPosition(3, 2, 1, 1);
Player player = new Player(pos, dir);
Assert.AreEqual(player.position.y, 2);
//When
player.move(MoveResult.forward);
player.move(MoveResult.forward);
player.move(MoveResult.forward);
player.move(MoveResult.forward);
//Then
Assert.AreEqual(player.position.y, 6);
}
public void CreatePlayerWithPosition()
{
//Given
HyperDirection dir = new HyperDirection(Direction.east, Direction.up, Direction.north, Direction.left);
HyperPosition pos = new HyperPosition(0, 5, 0, 4);
Player player = new Player(pos, dir);
//Then
Assert.AreEqual(player.position.x, 0);
Assert.AreEqual(player.position.y, 5);
Assert.AreEqual(player.position.z, 0);
Assert.AreEqual(player.position.w, 4);
Assert.AreEqual(player.direction.facing, Direction.east);
Assert.AreEqual(player.direction.standing, Direction.up);
Assert.AreEqual(player.direction.toSide, Direction.north);
Assert.AreEqual(player.direction.unSeen, Direction.left);
}
public void RotatingPlayerFourTimesIsSameSpot()
{
//Given
HyperDirection startingDirection = new HyperDirection(Direction.north, Direction.right, Direction.east, Direction.down);
HyperPosition pos = new HyperPosition(3, 3, 23, 1);
Player player = new Player(pos, startingDirection);
player.move(MoveResult.toRightSide).move(MoveResult.toRightSide).move(MoveResult.toRightSide).move(MoveResult.toRightSide);
Assert.AreEqual(startingDirection, player.direction);
player.move(MoveResult.toLeftSide).move(MoveResult.toLeftSide).move(MoveResult.toLeftSide).move(MoveResult.toLeftSide);
Assert.AreEqual(startingDirection, player.direction);
player.move(MoveResult.toUnseenLeft).move(MoveResult.toUnseenLeft).move(MoveResult.toUnseenLeft).move(MoveResult.toUnseenLeft);
Assert.AreEqual(startingDirection, player.direction);
player.move(MoveResult.toUnseenRight).move(MoveResult.toUnseenRight).move(MoveResult.toUnseenRight).move(MoveResult.toUnseenRight);
Assert.AreEqual(startingDirection, player.direction);
}
public static HyperPosition operator*(HyperPosition hyp, HyperDistance hyd)
{
int octantSize = (int)HyperposStaticReferences.OctantSize;
HyperPosition a = hyp * hyd.prs;
int3 oct = a.oct + (hyd.oct * hyp.oct * octantSize);
float3 octF = hyp.prs * hyd.oct;
float3 overflow = octF % 1f;
octF -= overflow;
a.prs += overflow * octantSize;
overflow = math.floor(a.prs / octantSize);
a.prs -= overflow * octantSize;
octF += overflow;
return(new HyperPosition {
prs = a.prs, oct = oct + (int3)octF
});
}
public void process(MoveIntent intent)
{
switch (intent)
{
case MoveIntent.forward:
HyperPosition inFront = player.position.move(player.direction.facing);
HyperPosition inFrontBelow = inFront.move(player.direction.standing, -1);
if (hyperGrid.checkBlocked(inFront))
{
player.move(MoveResult.upward);
}
else if (hyperGrid.checkBlocked(inFrontBelow))
{
player.move(MoveResult.forward);
}
else
{
player.move(MoveResult.downward);
}
break;
case MoveIntent.turnRightSide:
player.move(MoveResult.toRightSide);
break;
case MoveIntent.turnLeftSide:
player.move(MoveResult.toLeftSide);
break;
case MoveIntent.turnRightUnseen:
player.move(MoveResult.toUnseenRight);
break;
case MoveIntent.turnLeftUnseen:
player.move(MoveResult.toUnseenLeft);
break;
}
}
public GridSlice orientationForDirection(HyperDirection hyperDirection, HyperPosition hyperPosition)
{
switch (hyperDirection.unSeen)
{
case Direction.left:
case Direction.right:
return(new GridSlice(WorldOrientation.xyz, hyperPosition.w));
case Direction.north:
case Direction.south:
return(new GridSlice(WorldOrientation.xyw, hyperPosition.z));
case Direction.east:
case Direction.west:
return(new GridSlice(WorldOrientation.yzw, hyperPosition.x));
case Direction.up:
case Direction.down:
return(new GridSlice(WorldOrientation.xzw, hyperPosition.y));
}
return(new GridSlice(WorldOrientation.xyz, hyperPosition.w));
}
public void TestGameMovesPlayerFourTimes()
{
// Given
HyperGrid hyperGrid = new HyperGrid(10, 10, 10, 10);
HyperPosition playerPosition = new HyperPosition(5, 5, 5, 5);
HyperDirection playerDirection = new HyperDirection(Direction.east, Direction.up, Direction.north, Direction.left);
Player player = new Player(playerPosition, playerDirection);
Game game = new Game(player, hyperGrid);
hyperGrid.setBlocked(5, 4, 5, 5);
// When
game.process(MoveIntent.forward);
game.process(MoveIntent.forward);
game.process(MoveIntent.forward);
//Then
Assert.AreEqual(new HyperPosition(4, 4, 5, 5), player.position);
Assert.AreEqual(new HyperDirection(Direction.up, Direction.west, Direction.north, Direction.left), player.direction);
game.process(MoveIntent.forward);
Assert.AreEqual(new HyperPosition(5, 5, 5, 5), player.position);
}
public void TestPlayerMovesUp()
{
// Given
HyperGrid hyperGrid = new HyperGrid(10, 10, 10, 10);
HyperPosition playerPosition = new HyperPosition(2, 2, 2, 0);
HyperDirection playerDirection = new HyperDirection(Direction.east, Direction.up, Direction.north, Direction.left);
Player player = new Player(playerPosition, playerDirection);
Game game = new Game(player, hyperGrid);
hyperGrid.setBlocked(2, 1, 2, 0);
hyperGrid.setBlocked(3, 1, 2, 0);
hyperGrid.setBlocked(4, 2, 2, 0);
hyperGrid.setBlocked(4, 3, 2, 0);
game.process(MoveIntent.forward);
Assert.AreEqual(new HyperPosition(3, 2, 2, 0), player.position, player.position.printOut());
game.process(MoveIntent.forward);
Assert.AreEqual(new HyperPosition(3, 2, 2, 0), player.position, player.position.printOut());
game.process(MoveIntent.forward);
Assert.AreEqual(new HyperPosition(3, 3, 2, 0), player.position, player.position.printOut());
}
//--------------------Methods for step by step grid creation---------
public void createPath(HyperPosition startPosition, Direction direction, int amount)
{
//Creates a path from one point to another
int x = startPosition.x;
int y = startPosition.y;
int z = startPosition.z;
int w = startPosition.w;
switch (direction)
{
case Direction.east:
for (int i = 0; i < amount; i++)
{
setBlocked(x + i, y, z, w);
}
break;
case Direction.west:
for (int i = 0; i < amount; i++)
{
setBlocked(x - i, y, z, w);
}
break;
case Direction.up:
for (int i = 0; i < amount; i++)
{
setBlocked(x, y + i, z, w);
}
break;
case Direction.down:
for (int i = 0; i < amount; i++)
{
setBlocked(x, y - i, z, w);
}
break;
case Direction.north:
for (int i = 0; i < amount; i++)
{
setBlocked(x, y, z + i, w);
}
break;
case Direction.south:
for (int i = 0; i < amount; i++)
{
setBlocked(x, y, z - i, w);
}
break;
case Direction.left:
for (int i = 0; i < amount; i++)
{
setBlocked(x, y, z, w + i);
}
break;
case Direction.right:
for (int i = 0; i < amount; i++)
{
setBlocked(x, y, z, w - i);
}
break;
}
}
protected override void OnUpdate()
{
for (int i = meshCreationSets.Count - 1; i >= 0; --i)
{
if (meshCreationSets[i].jobHandle.IsCompleted)
{
meshCreationSets[i].jobHandle.Complete();
if (EntityManager.Exists(meshCreationSets[i].entity))
{
Mesh mesh = new Mesh();
mesh.vertices = meshCreationSets[i].verts.ToArray();
mesh.triangles = meshCreationSets[i].tris.ToArray();
mesh.RecalculateNormals();
HPMeshInstanceRenderer r = EntityManager.GetSharedComponentData <HPMeshInstanceRenderer>(meshCreationSets[i].entity);
r.mesh = mesh;
EntityManager.SetSharedComponentData(meshCreationSets[i].entity, r);
TerrainNode node = EntityManager.GetComponentData <TerrainNode>(meshCreationSets[i].entity);
if (node.level != 0 && EntityManager.Exists(node.parentEntity))
{
TerrainNode parentNode = EntityManager.GetComponentData <TerrainNode>(node.parentEntity);
if (parentNode.divided == 1)
{
++parentNode.childrenBuilt;
if (parentNode.childrenBuilt == 4)
{
HPMeshInstanceRenderer parentR = EntityManager.GetSharedComponentData <HPMeshInstanceRenderer>(node.parentEntity);
parentR.mesh = null;
EntityManager.SetSharedComponentData(node.parentEntity, parentR);
}
EntityManager.SetComponentData(node.parentEntity, parentNode);
}
}
}
meshCreationSets[i].verts.Dispose();
meshCreationSets[i].tris.Dispose();
meshCreationSets.RemoveAt(i);
}
}
ComponentGroup nodeGroup = GetComponentGroup(typeof(TerrainNode), typeof(HPMeshInstanceRenderer), typeof(PrecisePosition), typeof(OctantPosition));
ComponentGroup camGroup = GetComponentGroup(typeof(Flycam), typeof(PrecisePosition), typeof(Rotation), typeof(OctantPosition));
ComponentGroup dataGroup = GetComponentGroup(typeof(PlanetSharedData));
SharedComponentDataArray <PlanetSharedData> planetDataArray = dataGroup.GetSharedComponentDataArray <PlanetSharedData>();
PlanetSharedData[] dataArray = new PlanetSharedData[planetDataArray.Length];
for (int i = 0; i < dataArray.Length; ++i)
{
dataArray[i] = planetDataArray[i];
}
EntityArray entityTempArray = nodeGroup.GetEntityArray();
Entity[] entityArray = new Entity[entityTempArray.Length];
for (int i = 0; i < entityArray.Length; ++i)
{
entityArray[i] = entityTempArray[i];
}
SharedComponentDataArray <HPMeshInstanceRenderer> meshCDArray = nodeGroup.GetSharedComponentDataArray <HPMeshInstanceRenderer>();
HPMeshInstanceRenderer[] meshArray = new HPMeshInstanceRenderer[meshCDArray.Length];
for (int i = 0; i < meshArray.Length; ++i)
{
meshArray[i] = meshCDArray[i];
}
ComponentDataArray <TerrainNode> nodeCDArray = nodeGroup.GetComponentDataArray <TerrainNode>();
TerrainNode[] nodeArray = new TerrainNode[nodeCDArray.Length];
for (int i = 0; i < nodeCDArray.Length; ++i)
{
nodeArray[i] = nodeCDArray[i];
}
ComponentDataArray <PrecisePosition> nodePosArray = nodeGroup.GetComponentDataArray <PrecisePosition>();
PrecisePosition[] posArray = new PrecisePosition[nodePosArray.Length];
for (int i = 0; i < nodePosArray.Length; ++i)
{
posArray[i] = nodePosArray[i];
}
ComponentDataArray <OctantPosition> nodeOctArray = nodeGroup.GetComponentDataArray <OctantPosition>();
OctantPosition[] octArray = new OctantPosition[nodePosArray.Length];
for (int i = 0; i < nodeOctArray.Length; ++i)
{
octArray[i] = nodeOctArray[i];
}
ComponentDataArray <PrecisePosition> camPosArray = camGroup.GetComponentDataArray <PrecisePosition>();
float3 camPos = camPosArray[0].pos;
ComponentDataArray <OctantPosition> camOctArray = camGroup.GetComponentDataArray <OctantPosition>();
int3 camOct = camOctArray[0].pos;
float octantSize = HyperposStaticReferences.OctantSize;
for (int i = 0; i < meshArray.Length; ++i)
{
if (nodeArray[i].built == 1 && nodeArray[i].divided == 0)
{
if (nodeArray[i].level < nodeArray[i].planetData.maxNodeLevels)
{
float3 corner0 = nodeArray[i].corner1;
float3 corner1 = nodeArray[i].corner2;
float3 corner2 = nodeArray[i].corner3;
HyperDistance sphereRadius = nodeArray[i].planetData.radius;
HyperPosition corner0Pos = corner0 * sphereRadius;
HyperPosition corner1Pos = corner1 * sphereRadius;
HyperDistance distToSubdivide = MathUtils.Distance(corner0Pos, corner1Pos)
* (PERCENT_DIST_TO_SUBDIVIDE_AT / 100f);
HyperPosition centerPos = GetNodeCenter(nodeArray[i]);
//if (UnityEngine.Random.Range(0, 20) == 2)
// Debug.Log(MathUtils.ToString(distToSubdivide) + "\n" + MathUtils.ToString(centerPos));
if (InSubdivideDist(camOct, camPos, centerPos.oct, centerPos.prs, distToSubdivide.oct, distToSubdivide.prs))
{
//Debug.Log(MathUtils.ToString(distToSubdivide) + "\n" + MathUtils.ToString(centerPos)
// + "\n" + camOct + " " + camPos);
Subdivide(entityArray[i], nodeArray[i], meshArray[i], dataArray[0],
distToSubdivide.prs, distToSubdivide.oct, centerPos.prs, centerPos.oct);
}
}
if (nodeArray[i].level > 0 && EntityManager.Exists(nodeArray[i].parentEntity))
{
HPMeshInstanceRenderer parentR
= EntityManager.GetSharedComponentData <HPMeshInstanceRenderer>(nodeArray[i].parentEntity);
//float dist = math.distance(camPos, nodeArray[i].parentCenter);
//HyperDistance dist = MathUtils.Distance(camOct, camPos,
// nodeArray[i].parentOctantCenter, nodeArray[i].parentPreciseCenter);
//if (parentR.mesh != null
// && (dist.octantDist < nodeArray[i].parentOctantSubdivideDist
// || (dist.octantDist == nodeArray[i].parentOctantSubdivideDist && dist.preciseDist < nodeArray[i].parentPreciseSubdivideDist)))
if (!InSubdivideDist(camOct, camPos, nodeArray[i].parentOctantCenter, nodeArray[i].parentPreciseCenter,
nodeArray[i].parentOctantSubdivideDist, nodeArray[i].parentPreciseSubdivideDist))
{
EntityManager.DestroyEntity(entityArray[i]);
}
}
}
else if (nodeArray[i].built == 0 && nodeArray[i].divided == 1)
{
float3 corner0 = nodeArray[i].corner1;
float3 corner1 = nodeArray[i].corner2;
float3 corner2 = nodeArray[i].corner3;
HyperDistance sphereRadius = nodeArray[i].planetData.radius;
HyperPosition corner0Pos = corner0 * sphereRadius;
HyperPosition corner1Pos = corner1 * sphereRadius;
HyperDistance distToSubdivide = MathUtils.Distance(corner0Pos, corner1Pos) * (PERCENT_DIST_TO_SUBDIVIDE_AT / 100f);
HyperPosition centerPos = GetNodeCenter(nodeArray[i]);
if (!InSubdivideDist(camOct, camPos, centerPos.oct, centerPos.prs, distToSubdivide.oct, distToSubdivide.prs))
{
nodeArray[i].divided = 0;
nodeArray[i].childrenBuilt = 0;
EntityManager.SetComponentData(entityArray[i], nodeArray[i]);
}
}
else if (nodeArray[i].built == 0 && nodeArray[i].divided == 0)
{
nodeArray[i].built = 1;
Planet planetData = nodeArray[i].planetData;
// rez is the number of vertices on one side of the mesh/triangle
// the part in parentheses is called the "Mersenne Number"
int rez = 2 + ((int)Mathf.Pow(2, planetData.meshSubdivisions) - 1);
// nTris is the number of tris in the mesh
int t = rez - 2;
int nTris = (t * (t + 1)) + (rez - 1);
// nVerts is the number of vertices in the mesh
// it is the formula for the "Triangle Sequence" of numbers
int nVerts = (rez * (rez + 1)) / 2;
NativeArray <Vector3> verts = new NativeArray <Vector3>(nVerts, Allocator.Persistent);
NativeArray <int> tris = new NativeArray <int>(nTris * 3, Allocator.Persistent);
HyperPosition centerPos = GetNodeCenter(nodeArray[i]);
HyperPosition camHyp = new HyperPosition {
prs = camPos, oct = camOct
};
HyperDistance dist = MathUtils.Distance(centerPos, camHyp);
//if (dist > planetData.hyperdistanceThreshold)
//{
// nodeArray[i].hyperDistant = 1;
// if(!EntityManager.HasComponent<HyperdistantMarker>(entityArray[i]))
// EntityManager.AddComponent(entityArray[i], typeof(HyperdistantMarker));
//}
//else
//{
// nodeArray[i].hyperDistant = 0;
// if (EntityManager.HasComponent<HyperdistantMarker>(entityArray[i]))
// EntityManager.RemoveComponent(entityArray[i], typeof(HyperdistantMarker));
//}
MeshBuildJob job = new MeshBuildJob();
job.node = nodeArray[i];
job.corner0 = nodeArray[i].corner3;
job.corner1 = nodeArray[i].corner2;
job.corner2 = nodeArray[i].corner1;
job.rez = rez;
job.nTris = nTris;
job.nVerts = nVerts;
job.verts = verts;
job.tris = tris;
JobHandle handle = job.Schedule();
JobHandle.ScheduleBatchedJobs();
MeshCreationSet mcs = new MeshCreationSet();
mcs.entity = entityArray[i];
mcs.jobHandle = handle;
mcs.verts = verts;
mcs.tris = tris;
meshCreationSets.Add(mcs);
EntityManager.SetComponentData(entityArray[i], nodeArray[i]);
}
}
}
static void exo2()
{
var lines = input.Split(Environment.NewLine, StringSplitOptions.RemoveEmptyEntries);
var currentActives = new HashSet <HyperPosition>();
for (int i = 0; i < lines.Length; i++)
{
var line = lines[i];
for (int j = 0; j < line.Length; j++)
{
if (line[j] == '#')
{
currentActives.Add(new HyperPosition(i, j, 0, 0));
}
}
}
var nextActives = new HashSet <HyperPosition>();
int maxPos = lines.Length;
for (int cycle = 0; cycle < 6; cycle++)
{
maxPos++;
for (int x = -maxPos; x <= maxPos; x++)
{
for (int y = -maxPos; y <= maxPos; y++)
{
for (int z = -maxPos; z <= maxPos; z++)
{
for (int w = -maxPos; w <= maxPos; w++)
{
int nbActive = 0;
for (int i = x - 1; i <= x + 1; i++)
{
for (int j = y - 1; j <= y + 1; j++)
{
for (int k = z - 1; k <= z + 1; k++)
{
for (int l = w - 1; l <= w + 1; l++)
{
if (!(i == x && j == y && k == z && l == w) &&
currentActives.Contains(new HyperPosition(i, j, k, l)))
{
nbActive++;
}
}
}
}
}
var position = new HyperPosition(x, y, z, w);
if (currentActives.Contains(position))
{
if (nbActive == 2 || nbActive == 3)
{
nextActives.Add(position);
}
}
else
{
if (nbActive == 3)
{
nextActives.Add(position);
}
}
}
}
}
}
var tmp = currentActives;
currentActives = nextActives;
nextActives = tmp;
nextActives.Clear();
Console.WriteLine();
Console.WriteLine($"cycle {cycle}");
}
Console.WriteLine(currentActives.Count);
}
public bool checkBlocked(HyperPosition position)
{
return(checkBlocked(position.x, position.y, position.z, position.w));
}
public void Execute()
{
Vector3[] vertices = new Vector3[nVerts];
int[] indices = new int[nTris * 3];
float dist01 = Vector3.Distance(corner0, corner1);
float dist12 = Vector3.Distance(corner1, corner2);
float lenAxis01 = dist01 / (rez - 1);
float lenAxis12 = dist12 / (rez - 1);
float3 add1 = math.normalize(corner1 - corner0) * lenAxis01;
float3 add2 = math.normalize(corner2 - corner1) * lenAxis12;
int vIdx = 0;
float octantSize = HyperposStaticReferences.OctantSize;
HyperDistance radius = node.planetData.radius;
//if (node.hyperDistant == 1)
// radius = radius / new HyperDistance { prs = 0f, oct = 1 };
for (int i = 0; i < rez; ++i)
{
for (int n = 0; n <= i; ++n)
{
vertices[vIdx] = corner0 + add1 * i + add2 * n;
float3 normal = (vertices[vIdx]).normalized;
float noiseVal = GetValue(normal, node.noiseData, node.level);
HyperPosition vertPos = normal * (radius + (noiseVal * node.noiseData.finalValueMultiplier));
//if (n == 0)
// Debug.Log(MathUtils.ToString(node.planetData.radius) + "\n" +
// MathUtils.ToString(noiseVal * node.noiseData.finalValueMultiplier) + "\n" +
// MathUtils.ToString(node.planetData.radius + (noiseVal * node.noiseData.finalValueMultiplier)));
HyperPosition nodeCenter = GetNodeCenter(node);
HyperPosition relativePos = vertPos - nodeCenter;
vertices[vIdx] = relativePos.prs + (float3)relativePos.oct * octantSize;
//vertices[vIdx] = normal * (node.planetData.radius + noiseVal * node.noiseData.finalValueMultiplier);
//vertices[vIdx] = normal * sphereRadius; //Use this line instead of above to gen a perfect sphere
++vIdx;
}
}
int indIdx = 0;
int rowStartIdx = 1;
int prevRowStartIdx = 0;
for (int row = 0; row < rez - 1; ++row)
{
bool upright = true;
int trisInRow = 1 + row * 2;
int vertsInRowBottom = row + 2;
int upTri = 0;
int downTri = 0;
for (int tri = 0; tri < trisInRow; ++tri)
{
if (upright)
{
indices[indIdx] = rowStartIdx + upTri + 1;
indices[indIdx + 1] = rowStartIdx + upTri;
indices[indIdx + 2] = prevRowStartIdx + upTri;
++upTri;
}
else
{
indices[indIdx] = prevRowStartIdx + downTri + 1;
indices[indIdx + 1] = rowStartIdx + downTri + 1;
indices[indIdx + 2] = prevRowStartIdx + downTri;
++downTri;
}
indIdx += 3;
upright = !upright;
}
prevRowStartIdx = rowStartIdx;
rowStartIdx += vertsInRowBottom;
}
verts.CopyFrom(vertices);
tris.CopyFrom(indices);
}
public static string ToString(HyperPosition hyp)
{
return(hyp.oct.ToString() + " : " + hyp.prs.ToString());
}
public static HyperDistance Distance(HyperPosition p1, HyperPosition p2)
{
if (Equals(p1.oct, p2.oct))
{
return(new HyperDistance {
oct = 0, prs = math.distance(p1.prs, p2.prs)
});
}
else
{
float octantSize = HyperposStaticReferences.OctantSize;
int3 octDist = p2.oct - p1.oct;
float3 prcDist;
if (octDist.x == 0)
{
prcDist.x = p2.prs.x - p1.prs.x;
}
else
{
int dir = octDist.x > 0 ? 1 : -1;
octDist.x -= dir;
if (dir == 1)
{
prcDist.x = (octantSize - p1.prs.x) + p2.prs.x;
}
else
{
prcDist.x = (octantSize - p2.prs.x) + p1.prs.x;
}
float overflowF = math.floor(prcDist.x / octantSize);
int overflow = (int)overflowF;
prcDist.x -= overflowF * octantSize;
octDist.x += overflow;
}
if (octDist.y == 0)
{
prcDist.y = p2.prs.y - p1.prs.y;
}
else
{
int dir = octDist.y > 0 ? 1 : -1;
octDist.y -= dir;
if (dir == 1)
{
prcDist.y = (octantSize - p1.prs.y) + p2.prs.y;
}
else
{
prcDist.y = (octantSize - p2.prs.y) + p1.prs.y;
}
float overflowF = math.floor(prcDist.y / octantSize);
int overflow = (int)overflowF;
prcDist.y -= overflowF * octantSize;
octDist.y += overflow;
}
if (octDist.z == 0)
{
prcDist.z = p2.prs.z - p1.prs.z;
}
else
{
int dir = octDist.z > 0 ? 1 : -1;
octDist.z -= dir;
if (dir == 1)
{
prcDist.z = (octantSize - p1.prs.z) + p2.prs.z;
}
else
{
prcDist.z = (octantSize - p2.prs.z) + p1.prs.z;
}
float overflowF = math.floor(prcDist.z / octantSize);
int overflow = (int)overflowF;
prcDist.z -= overflowF * octantSize;
octDist.z += overflow;
}
float octMag = math.length(octDist);
float overflow2 = octMag % 1f;
octMag -= overflow2;
float prcMag = math.length(prcDist) + (overflow2 * octantSize);
overflow2 = math.floor(prcMag / octantSize);
prcMag -= overflow2 * octantSize;
octMag += overflow2;
return(new HyperDistance {
oct = (int)octMag, prs = prcMag
});
}
}
public Player(HyperPosition position, HyperDirection direction)
{
this.position = position;
this.direction = direction;
}
public void TestWalkInCircle()
{
// Given
HyperGrid hyperGrid = new HyperGrid(10, 10, 10, 10);
HyperPosition playerPosition = new HyperPosition(2, 2, 2, 0);
HyperDirection playerDirection = new HyperDirection(Direction.east, Direction.up, Direction.north, Direction.left);
Player player = new Player(playerPosition, playerDirection);
Game game = new Game(player, hyperGrid);
hyperGrid.setBlocked(2, 1, 2, 0);
hyperGrid.setBlocked(3, 1, 2, 0);
hyperGrid.setBlocked(4, 1, 2, 0);
hyperGrid.setBlocked(5, 1, 2, 0);
hyperGrid.setBlocked(5, 1, 3, 0);
hyperGrid.setBlocked(5, 1, 4, 0);
hyperGrid.setBlocked(5, 1, 5, 0);
hyperGrid.setBlocked(5, 1, 6, 0);
hyperGrid.setBlocked(4, 1, 6, 0);
hyperGrid.setBlocked(3, 1, 6, 0);
hyperGrid.setBlocked(2, 1, 6, 0);
hyperGrid.setBlocked(1, 1, 6, 0);
hyperGrid.setBlocked(1, 1, 5, 0);
hyperGrid.setBlocked(1, 1, 4, 0);
hyperGrid.setBlocked(1, 1, 3, 0);
hyperGrid.setBlocked(1, 1, 2, 0);
game.process(MoveIntent.forward);
Assert.AreEqual(new HyperPosition(3, 2, 2, 0), player.position, player.position.printOut());
game.process(MoveIntent.forward);
Assert.AreEqual(new HyperPosition(4, 2, 2, 0), player.position, player.position.printOut());
game.process(MoveIntent.forward);
Assert.AreEqual(new HyperPosition(5, 2, 2, 0), player.position, player.position.printOut());
game.process(MoveIntent.turnRightSide);
Assert.AreEqual(new HyperPosition(5, 2, 2, 0), player.position, player.position.printOut());
Assert.AreEqual(new HyperDirection(Direction.north, Direction.up, Direction.west, Direction.left), player.direction);
game.process(MoveIntent.forward);
Assert.AreEqual(new HyperPosition(5, 2, 3, 0), player.position, player.position.printOut());
game.process(MoveIntent.forward);
Assert.AreEqual(new HyperPosition(5, 2, 4, 0), player.position, player.position.printOut());
game.process(MoveIntent.forward);
Assert.AreEqual(new HyperPosition(5, 2, 5, 0), player.position, player.position.printOut());
game.process(MoveIntent.forward);
Assert.AreEqual(new HyperPosition(5, 2, 6, 0), player.position, player.position.printOut());
game.process(MoveIntent.turnRightSide);
Assert.AreEqual(new HyperPosition(5, 2, 6, 0), player.position, player.position.printOut());
Assert.AreEqual(new HyperDirection(Direction.west, Direction.up, Direction.south, Direction.left), player.direction);
game.process(MoveIntent.forward);
Assert.AreEqual(new HyperPosition(4, 2, 6, 0), player.position, player.position.printOut());
game.process(MoveIntent.forward);
Assert.AreEqual(new HyperPosition(3, 2, 6, 0), player.position, player.position.printOut());
game.process(MoveIntent.forward);
Assert.AreEqual(new HyperPosition(2, 2, 6, 0), player.position, player.position.printOut());
game.process(MoveIntent.forward);
Assert.AreEqual(new HyperPosition(1, 2, 6, 0), player.position, player.position.printOut());
game.process(MoveIntent.turnRightSide);
Assert.AreEqual(new HyperPosition(1, 2, 6, 0), player.position, player.position.printOut());
Assert.AreEqual(new HyperDirection(Direction.south, Direction.up, Direction.east, Direction.left), player.direction);
game.process(MoveIntent.forward);
Assert.AreEqual(new HyperPosition(1, 2, 5, 0), player.position, player.position.printOut());
game.process(MoveIntent.forward);
Assert.AreEqual(new HyperPosition(1, 2, 4, 0), player.position, player.position.printOut());
game.process(MoveIntent.forward);
Assert.AreEqual(new HyperPosition(1, 2, 3, 0), player.position, player.position.printOut());
game.process(MoveIntent.forward);
Assert.AreEqual(new HyperPosition(1, 2, 2, 0), player.position, player.position.printOut());
}
private void Subdivide(Entity e, TerrainNode t, HPMeshInstanceRenderer r, PlanetSharedData d,
float parentPrcSubdivideDist, int parentOctSubdivideDist, float3 parentPrcCenter, int3 parentOctCenter)
{
Entity[] entities = new Entity[4];
TerrainNode[] nodes = new TerrainNode[4];
float3 corner0 = t.corner1;
float3 corner1 = t.corner2;
float3 corner2 = t.corner3;
for (int i = 0; i < 4; ++i)
{
entities[i] = EntityManager.Instantiate(d.nodePrefab);
nodes[i] = EntityManager.GetComponentData <TerrainNode>(entities[i]);
nodes[i].level = t.level + 1;
nodes[i].planetData = t.planetData;
nodes[i].noiseData = t.noiseData;
nodes[i].built = 0;
nodes[i].divided = 0;
nodes[i].childrenBuilt = 0;
nodes[i].parentEntity = e;
nodes[i].parentPreciseCenter = parentPrcCenter;
nodes[i].parentOctantCenter = parentOctCenter;
nodes[i].parentPreciseSubdivideDist = parentPrcSubdivideDist;
nodes[i].parentOctantSubdivideDist = parentOctSubdivideDist;
}
float3 mid01 = corner1 - corner0;
mid01 = corner0 + math.normalize(mid01) * (math.length(mid01) / 2f);
float3 mid02 = corner2 - corner0;
mid02 = corner0 + math.normalize(mid02) * (math.length(mid02) / 2f);
float3 mid12 = corner2 - corner1;
mid12 = corner1 + math.normalize(mid12) * (math.length(mid12) / 2f);
nodes[0].corner1 = corner0;
nodes[0].corner2 = mid01;
nodes[0].corner3 = mid02;
nodes[1].corner1 = mid01;
nodes[1].corner2 = corner1;
nodes[1].corner3 = mid12;
nodes[2].corner1 = mid02;
nodes[2].corner2 = mid12;
nodes[2].corner3 = corner2;
nodes[3].corner1 = mid02;
nodes[3].corner2 = mid01;
nodes[3].corner3 = mid12;
for (int i = 0; i < 4; ++i)
{
EntityManager.SetComponentData(entities[i], nodes[i]);
HyperPosition pos = math.normalize(nodes[i].corner1 + nodes[i].corner2 + nodes[i].corner3) * t.planetData.radius;
PrecisePosition prspos = new PrecisePosition {
pos = pos.prs
};
EntityManager.SetComponentData(entities[i], prspos);
OctantPosition octpos = new OctantPosition {
pos = pos.oct
};
EntityManager.SetComponentData(entities[i], octpos);
}
t.divided = 1;
t.built = 0;
EntityManager.SetComponentData(e, t);
}
// Creates an hyperportfolio from a list of portfolios and weights.
// Weight represents how much to weight the portfolio in the hyper portfolio
public static HyperPortfolio CreateHyperPortfolio(IEnumerable <Tuple <DisplayPortfolio, double> > ports)
{
var lastDate = ports.Max(p => p.Item1.EndQuarterDate);
var tupleLastDate = ports.Where(p => p.Item1.EndQuarterDate == lastDate);
var positions = new Dictionary <string, HyperPosition>();
var totalWeight = 0.0; // Aggregated weight used to normalize end result to 100%
foreach (var t in tupleLastDate)
{
var port = t.Item1;
var weight = t.Item2;
foreach (var pos in port.Positions)
{
HyperPosition hp;
var relativeWeight = pos.PercOfPortfolio * weight;
totalWeight += relativeWeight;
var key = FormHyperKey(pos);
if (positions.TryGetValue(key, out hp)) // Already owned
{
hp.Gurus.Add(port.DisplayName);
hp.NumberGurusOwning += 1;
hp.PercOfPortfolio += relativeWeight;
if (pos.Change > 0)
{
hp.NumberGurusBuying += 1;
}
if (pos.Change < 0)
{
hp.NumberGurusSelling += 1;
}
}
else // not yet owned
{
hp = new HyperPosition {
Cusip = pos.Cusip,
ClassTitle = pos.ClassTitle,
Name = pos.Name,
PutCall = pos.PutCall,
NumberGurusBuying = pos.Change > 0 ? 1 : 0,
NumberGurusSelling = pos.Change < 0 ? 1 : 0,
NumberGurusOwning = 1,
PercOfPortfolio = relativeWeight,
Gurus = new List <string>()
};
hp.Gurus.Add(port.DisplayName);
positions[key] = hp;
}
}
}
var resPositions = positions.Values;
// Normalize weights, I am sure there is a way to do it without another pass over the positions, but small numbers here
foreach (var hp in resPositions)
{
hp.PercOfPortfolio /= totalWeight;
}
// Check normalization is effective
Debug.Assert(resPositions.Sum(p => p.PercOfPortfolio) < 1.01 && resPositions.Sum(p => p.PercOfPortfolio) > 0.99);
// eye candy
var sortedRes = resPositions.OrderByDescending(hp => hp.PercOfPortfolio);
return(new HyperPortfolio {
EndQuarterDate = lastDate, NumberOfGurus = tupleLastDate.Count(), Positions = sortedRes
});
}
