Update Node Data

Save in Node

If Node changed

The Concept of Materials and Solvers

Die Idee ist das es oft node Werte gibt die sehr ähnlich sind und eigentlich den gleichen Code nutzen können. Sie haben die gleichen Arten von Abhängigleiten wie z.B. sie haben nur Abhängigkeiten zu anderen Node Werten des gleichen Material. Diese Node Werte gibt man einen eigenen Solver, der einen Tick für sie löst.

Vorteil

• Modulare entwicklung. -> Man kann eine Node hinzufügen ohne eine bestehende Generation zu verändern.
• Regel Design wird über Code umgesetzt -> Regeln können hoch individuell umgesetzt werden.

Nachteil

Polymorphismus notwendig. -> Kann in Rust mit Enums und mapped Traits umgesetzt werden. -> Aber keine große performance Kosten.

Fragen

• Ist es besser einen Solver für alles zu nutzten oder bietet die verschiedene Solver Idee genug Vorteile, damit sie sich lohnt?

Not empty?

Einen in nur ein Wert in einem Tick behandeln ???

Vorteil

• Keine Arbeit machen die nicht gemacht werden muss.

Nachteil

• Müssen meist nicht eh alle Werte gecheckt werden?
• Verbringt man denn nicht dann mehr Zeit damit den Wert zu finden als ihn wirklich upzudaten??

Idee: hybrid

Einzelne Werte checken aber wenn alle andere Werte der Node auch gecheckt werden müssen macht man das geleich auch.

Gibt es dafür eine gute Datenstruktur in der man das trival checken kann?

• Eine Bitmask pro Node ?
  • Ein Bit sagt update diese Node

Get all nodes of that materials

Get solver for Node

Tick Object (Update Loop)

Not empty?

Get all possible Nodes from rules

Get solver for Node

Tick Sceduler Design Idee

• Bitfield mit länge aller möglichen Werte
  • Optimal wenn es nicht mehr als 64 oder 128 Werte gibt.
  • Wenn es mehr gibt barucht man mehere variablen
  • GitHub - tower120/hi_sparse_bitset: Hierarchical sparse bitset
• Wenn eine Node geupdatet wird geht sie gleich durch alle Werte durch um sich den overhead vom setup zu sparen
• GitHub - bexxmodd/priq: Blazing fast Priority Queue that allows sorting for elements with partial ordering

Regeln die sich über die Zeit ändern

Regeln sind nicht entgültig sondern können sich ändern. (dynamische Objecte oder Animationen)

Beispiel

• Kugel rollt über Welt. Der Boden verformt sich um die Kugel herum.
• Natur wächst
• Gebäude zerfallen
• User Input

Challenges

• Heraus finden wann die Node geupdated werden muss. -> Eine Art Callback oder Task System???

Graph Idee

Nodes

• Eine Node kann verschiedene Werte haben.
• Jede dieser Werte hat Abhängigkeiten.
  • Nachbar Regeln
  • Globale Regeln
  • Regeln die sich über Zeit ändern
    • siehe eigene Notiz
• Die Abhängigkeiten der möglichen Werte bildet ein Graphen.
  • Dieser sollte nicht jeden Tick neu brechnet werden???
  • Wird benötigt für:
    • Heraus finden ob Wert aus Note entfert werden muss.
    • Herausfinden welche Nodes sich ändern müssen wenn sich diese Node ändert.
      • Bzw welche Werte anderer Nodes gecheckt werden müssen.

Rest Operation

• Füge alle Werte zu Node hinzu
  • Problem:
    • Alle können sehr viele sein -> Borad Phase Value elimination

Propergate Operation

• Ein Wert einer Node wurde als propergate maktiert
• Man holt sich diese Node und geht durch alle Abhängigkeiten durch.
  • Problem:
    • Abhängigkeiten wie Nachbarn müssen noch berechnet werden. -> Man könnte jede Abhängigkeit für jede Node vorberechnen. -> Ist das nicht zu viel Speicher?

Not empty?

Done

If Node changed

Was collapsed Set

Collapse priority queue

Get solver for Node

Get best node of all nodes that are possible

Collapse Node

Was rest set

Propergate priority queue

Check if was rest

Check if was collapsed

World

• Consists of Objects

Object

• Origen position and rotation
• Consists of Chunks of Nodes (32 x 32 x 32)

Node

• Every Node has a Material
• Has a Set of rules that need to accept for the node to be present. (All factors that affect the rules -> enviroment of Node)

Material Solver

Every Material has a Solver for nodes of that Material.

Solvers can calculate:

• All Nodes of that material. (Rest)
• All possible Nodes for position in object (Propergate)
• Best Node of possible Nodes (Collapse)

Node enviroment changed (User input)

Rest priority queue

Node Value Counter

Just a counter that stores of a node how many of its values are accepted

counter - 1 remove if == 0

Remove Value from Node

Select Value for Node

Node Value

Reliant Values

Vec of Node Value Pointers

Add Value to Node

Node Value

Required Nodes

All Nodes which has Values this Value requires -> Per Node a counter for number of accepted Values

Es werden nicht alle möglichen Werte auf einmal hinzugefügt, sondern man fügt nur nach Wunsch Werte hinzu

Eine Funktion die jeden Wert zu einer Node hinzufügt.

Das Object hat eine Node die Werte zu benachbarten Nodes hinzufügt.

Beim auswählen eines Werts muss der Couter erhöt werden.

Nodes Value gets removed

Go over all Reliant Values and decrease the counter. If the counter mark that node for removal

Problem with Lifetimes in Rust

std::cell - Rust Cells dont work Need to use RCs light Rc might be best option

Das hinzuzufügen von einem Wert kann dafür sorgen das andere Werte zu anderen Nodes hinzugefügt werden müssen.

Beim wieder entfernen oder zurücksetzten der Node muss der Couter verringert werden.

Global Value Counter

Just a counter that stores the number of values in a set of nodes

counter - 1 remove if > n

counter - 1 remove if < n

Min

Max / Exact

Vec with fixed Index

Just a vec but when remove replace with default. And store Index in a rotating vector. OR: https://crates.io/crates/fixed-index-vec

Nodes

uses Vec keeps indecies.

Value Req (Enum with match Trait dispatch )

https://crates.io/crates/enum_delegate

Node Values

every Node can have a set of values

Will be added and removed often

All Values that requires it

Vec of Value Req pointers

Werte andere Nodes

• Node hat einen oder mehere Werte.
• Node hat einen Wert nicht.

Es gibt eine bestimmte Menge an Werten

• Es gibt genau n Werte in dem ganzen Graph
• Es gibt min oder max n Werte im ganzen Graph
• Es gibt n Werte in einem Subset des Graphs

Ein Object ist in der nähe

-> custom function -> wann checkt man das???

Ein eine bestimmte Zeit ist vergangen

-> wann checkt man das???

ECS

entity_data - Rust GitHub - rust-gamedev/ecs_bench_suite: A suite of benchmarks designed to test and compare Rust ECS library performance across a variety of challenging circumstances.

Min

Der globale Node Wert hat einen Counter der speichert wie viele dieser Werte es gibt.

Max / Exact

Hier müssen nicht die möglichen sondern. Gewählten Werte gezählt werden.

Es gibt eine globale Node die einen Wert haben kann den es nur dann gibt, wenn diese Eigenschaft erfüllt ist. Den Node wert gibt es nur wenn es den globalen Node Wert gibt.

Für jede Node die Werte enthalten sollte. Hat man einen Counter. Wenn ein Wert gelöscht wird, wird der Counter bei allen Nodes die diesen Wert als Abhängigkeit haben reduziert.

Populate World

Init

1. Add value for one Node
2. PushValue to Add Queue

Add tick

1. Pop from Add Queue
2. Go over all reqs of Value
   1. Get Req Node Identifier
   2. Get Req Node form Identifier
      1. Req Node dosen't has Value
         1. Add Req Value to Node
         2. Link Req Value as Req of Value
         3. Push Req Value to Add Queue
      2. Req Node has Value 3. Link Req Value as Req of Value

Stone

Grass

Sand

Other Value 1

Other Value 2

Populate World V2

Init

1. Add Value to Node
2. Select Value for Node
3. Go over Reqs of Value
   1. Get Req Node
      1. Req Node has no Value
         1. Add all possible Values
      2. Req Node already Values
         1. Add

Unterschied zwischen den actuellen selcted Nodes und den letzten selected Nodes

On Selected changed

-> Value of one node is Selected

1. Go over all Reqs of that Node
   1. Get req Node
   2. Node has old selected value
      1. If the old selected value in reqs
         1. Set old selected Value to new selcetd value -> Done
      2. If not
         1. Un select value
         2. Add all possible Values
   3. Node has no selected Value
      1. Keep all values that are shared
         1. Values are empty
            1. fail
   4. Node has selected Value
      1. Check if reqs contains selected value
         1. If not
            1. fail

Change

Change

Summary

Change

Change

Change

Change

Change

Change

Summary

Every value for every node stores the Index of the change it has beed removed

If we want to select a value. We just go the the change and restore from the last summary

Saving old states and going back

History Node

1 Bit if summary 31 Change data or Summray Index

Change

Node Identifyer + removed Value Index -> 32 Bit sollte reichen

Summary

Zustand der Welt