Shifting Skill Tree

Question

I have been thinking of implementing a system like Wolcen does for their skill tree, however I want to use it for level unlocks.

Nodes grouped in segments and multiple segments from a ring (see picture attached)

Each inner segment touches two of the next outer ring' segments, and when each ring is rotated, the nodes are able to be connected the newly rotated section.

A static model of this is simple using a tree structure, where each segment is a tree-node in the tree and each tree-node contains an array of skill-nodes.

How would one achieve a the shifting functionality?

EDIT:

Starting State:

      1             Level 1 
    /   \ 
   2     3          Level 2
 /     /   \
4     7     8       Level 3

Trying to Achieve:

      1             Level 1 
    /   \ 
   3     2          Level 2
 /     /   \
4     7     8       Level 3

in other words, the children should not be affected of the parent shifting position.

Answer 1

Let's say you have two ordered lists of nodes that connect two rings. For this example:

• list1 is the more inner ring with nodes a b d c
• list2 is the more outer ring with nodes Q R S T

I'm going to refer to the nodes & edges between rings as 'spoke nodes & edges' and I'm going to assume that they line up in a one to one fashion. That means there will be the same number of spoke nodes connecting one ring to the next and each has exactly one spoke edge.

So maybe we have something like this:

Q-----R
|\   /|
| a-b |
| | | |
| d-c |
|/   \|
T-----S

To shift or rotate a ring, all you need to do is go through the spoke nodes of each list & shift the relevant connections:

rotateOuterRingBack(list1);

void rotateOuterRingBack(List<Nodes> list){
  Node tempSpokeNeighbor = list.get(0).getSpokeNeighbor();

  for(int a=0; a<list.size()-1; a++){
    Node currNode = list.get(a);
    Node nextNode = list.get((a+1)%list.size());
    Node currNode.setSpokeNeighbor(nextNode.getSpokeNeighbor));
    Node currNode.getSpokeNeighbor().setSpokeNeighbor(currNode);
  }
  Node lastNode = list.get(list.size()-1);
  Node lastNode.setSpokeNeighbor(tempSpokeNeighbor);
  Node lastNode.getSpokeNeighbor.setSpokeNeighbor(lastNode);
}

Applying this to the example given, the result would be:

R-----S
|\   /|
| a-b |
| | | |
| d-c |
|/   \|
Q-----T

Rotating in the opposite direction is similar, but requires traversing the list in the opposite direction.

This could be extended to handle ring to ring connections that aren't one to one - the basic idea remains the same, but the implementation gets more complex.