quasistellar / edgecase Goto Github PK

We need 3 times as many vertices to illuminate mesh surfaces correctly. Each face should have its own set of vertices with normals pointing in the same direction, so the lighting can know how to handle it. As you can see on the picture above, Unity cube has 24 vertices instead of usual 8 because each face needs its own 4 vertices with normals pointing perpendicular to the face.

Map centrosymmetry should be toggleable.

Should be implemented as a subclass of PerlinHeightMap.

Hexes currently use uv-maps with texture-based materials, which leads to blurry edges:

Furthermore, textures are heavy and overload the scene for no good reason.
We can avoid this problem by utilizing a shader:

• Color points which are less than N meters away from any edge with COLOR
• Color all other points black
• Set different N for the upper face and the sides

"Barycentric coordinates" and "wire-mesh techniques" may help.

More often than not generating large maps (100x100) produces this error:

System.Collections.Generic.Dictionary`2[TKey,TValue].get_Item (TKey key) (at <695d1cc93cca45069c528c15c9fdd749>:0)
Hex.UpdateColor () (at Assets/Scripts/Hex.cs:131)
MapGenerator.Start () (at Assets/Scripts/MapGenerator.cs:31)

Seems like it can't find a color in the Hex.ColorMap dictionary. Probably because of some broken perlin noise rounding that produces a value higher than the maximum height, since switching HeightVariation from 7 to 6 fixes the issue.

May want to switch to simplex noise.

Make camera rotatable by 60 degrees in both directions. Make sure the map doesn't clip through the camera planes and is displayed correctly.

Set distances between nearby hexes to 0, which reduces separating triangles (yellow) to nothing, and remove polygons in those triangles.

Issue for minor refactoring / typo fixing PRs.

Map-mesh consists of 2 submeshes, one of them represents tops of the hexes and the other one - their sides. This way we can assign to them 2 different materials. Here we need to change those materials so the map looks pretty and readable.

To swap between main menu and settings.

• #17
• #39
• #40

To avoid extra geometry it's better to have all map vertices contained in one mesh.
Hexes should be split apart from each other and connected like so:

Check how much it affects the performance.
Make sure to avoid vertices-per-mesh limit.

We may need different shapes of the playing field.
So there must be a generic interface for hexmaps, or a more generic class for hexmaps.

The current HexMap class can easily be modified to support arbitrary shapes.
And then the specific shape is the responsibility of the object's creator.

• #18
• #13
• #14
• #15
• #17
• #44
• #43
  
  Camera should be orthographical and fixed at a certain angle so elevating a hex overlaps the one behind it entirely. That elevated hex now becomes connected to the neighbours of the overlapped hex (see the picture).

Create a method to change the height of a hex. Possible parameters are: coordinates, height change, animation time.

Must be done to customize each hex individually.

The HexExistsAtPos method cannot be used to check if candidates for overlapping remain. This works for a hexagonal playing field, but will break for non-convex shapes.

Global hex shift: elevate all hexes based on one of their coordinates (so a plain map turns into a slope).
Check how this transformation affects performance.

50 hexes side:

	Hex = mesh	Map = mesh
Idle
Start
Running

Result: Map = mesh is much better

We need to be able to see sides of hexes located near the edge of the map.

Kernel and Utils don't belong to Unity so they don't have to be in Scripts

The camera should be orthographic for the impossible geometry mechanic to work. Its direction should be fixed in a way that allows hexes to overlap hexes behind them after elevating by 2.

Tweak the existing generation algorithm to produce smooth continuous terrain. Make the smoothness adjustable.

Mathf.PerlinNoise may help.

Now after #21 is done, we can add lighting with respect to our normal map. Add a directional light source and set it up so the map looks pretty and readable.

Add a way for hexes to know which hexes are currently their neighbours.

HeightMap can be replaced with HexMap<Height>.

PerlinHeightMap and FlatHeightMap can be replaced with PerlinHeightMapGenerator and FlatHeightMapGenerator.
They should just create and return a heightmap, instead of trying to be a heightmap.

1. player clicks on "end turn" button
2. end turn event happens (TurnEndEvent, context: player="player1")
3. display provider gets notified via subscription
4. display provider forms a request and sends it to kernel provider (request: {"player": "player1", "action": "end turn"})
5. kernel provider validates the request and produces an event (if the server is remote check if this player name and this IP are associated)
6. kernel gets notified via subscription (context: player="player1", action="end turn")
7. kernel handles the request, updating the state in its game model (current_player = player2)
8. kernel creates an event, notifying kernel provider about the result (TurnEndEvent, context: current_player="player2")
9. kernel provider gets notified via subscription
10. kernel provider sends appropriate requests to all the connected display providers
11. display providers produce an event (TurnEndEvent, context: current_player="player2")
12. display gets notified via subscription
13. display reacts to the event
    

Far away hexes can be rendered as their upper hexagons since sides are black anyway and edge lines are too narrow at these distances. This is also an extremely good optimization for the top-down view since all hexes are counted as far away and sides are completely invisible from this PoV.
This article may help.
Should be done after #1.

• #21
• #24
• #25
• #32
• #33