No. The nodes have a tag in their XML called map. For example, Another PC Tabber's map looks like 'PCs', where as the Abilities grid of that node looks like 'PC::Another PC Tabber'



So when you reference the software looks at the map.

So the text value of this map tag is just the full path of the parent container? That's pretty cheap to calculate on the fly. I do that a lot in the code. So anyway you have the full path to the parent; what do you do with it? And how is it different between the !# and the !! searches?

For example do you just take the partial path from the reference (eg "Abilities::(1,3)") and prefix the full path to the parent (eg "PCs::Tabber") and then look it up as a global?

No. I told you I don't do anything global with Traipse.

Ok, the !! .. !! reference using the exact reference and then appends the reference of the node it is in. Pretty simple. That is why a Text node can reference a grid if they are in the same container, because the map is the same.

The !# .. #! syntax iterates between the map that is sent and the reference that is sent and then appends what is missing to the map and removes what is not going to work.

Does that help?

i can't believe I have to explain this any further. Open the source and figure it out for yourself please. That is what I am doing with yours.

Well like I say you really need to be able to explain how it works to people. I am not stupid, I know the code and I've been thinking about this stuff or years but I can't tell what you're saying. Now, sure, I can go look at your code and I guess I will, but that won't work for most people. The interface needs to be intuitive, especially given OpenRPG's lack in the documentation department. But perhaps if I figure it out I can come up with a better way for you to explain it.

Alright, so your turn: what do you understand to be the new features I added (concerned with references that is)?

I will try again in one more post than post an answer to your question in another.



The reference model works like this:
When a node is loaded into or moved in the tree it is mapped and it's location becomes a tag in the node's XML. Examples:
Abilities map looks like "Tabber"
Name map looks like "Tabber::Details"

Child references work by adding the reference text to the node's map. Because the map works as describe, when Level references Name it grabs Level's map, ei "Tabber::Details" and then appends the reference text. So a reference like !!Name!! inside of Level returns "Tabber::Details::Name" for the system and turns it into a !@ .. @! reference.
That is how child references are created.

Pare references work in a similar fashion. First they need a tree map sent to them. Then they find the map of the node that reference syntax is in. Then the software iterates between the two, slicing off the top of one of them. So to reference Name from Super Attacks you need !#Details::Name#! Here is why.

Name's Map looks like "Tabber::Details"
Super Attacks map looks like "Tabber::Special"

The software finds that Tabber are the same and Details are the same so the software appends "Name" making a Root Reference !@Tabber::Details::Name@! which the older code can understand.

Understand now?

This is what I understand from the Standard game tree reference system. Keep in mind I just downloaded the new Dev software so I am not 100% on what has changed.

(1) The data is pulled from the wx.Tree module. All of the node XML data is taken from the PyData of the game tree.

(2) The reference system start at the top of the tree and works it's way down, finding the PyData Titles of the nodes in the tree root. When it has a match, the software then looks for the reference inside that node.

(3) The system has been explained as a method of being able to create a context sensitive format for players so they can move nodes around, but in all tests I have done it has failings. In the below example the Group node will not find the correct text node.



Even if I try !@Group-3::Text@! I do not get the result I need. Instead I need to use !@Group::Group-3::Text@! Requiring users to either rename or Index / Un Index. nodes. (A feature which I cannot find in the newest Standard Dev .. hrm?)

I don't completey understand how that works. I do understand the goal, but when I have tried applying what I am told it does not work very well.

(4) I understand the grids can be referenced by the name of the Row. While I like the idea that the users have a human readable format, it's very restrictive and I thought I would eventually make the syntax more of a background feature .. while still keeping it open enough for users to learn and develop with.

Where is the code for this implementation? I'm looking in (the Assembla project named) traipse_dev, is that wrong?

OK I understand the one you are calling "child" though I am not sure I would call them that because it's looking for a sibling not a child -- a child of the parent. Basically if you use the metaphor about a file system then your !!...!! notation is like the .. notation as in,



A better notation might be !@parent::........@! where "parent" is a reserved word. Or maybe !@local::......@! Depnds how you are implementing it to some extent.

Calling it Local or Child is not a huge issue. It is a Child reference to me because it has a parent. You can't enter !! .. !! into chat. In chat you need to use a Root Reference !@ .. @!. The syntax !! .. !! only works if the node is a Child .. hence Child Reference.

I am trying to reduce the amount of typing the user needs.

And yes, the source is in the Traipse_Dev trac.