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