#### General usage of lichen
Primarily, lichen is geared towards an interactive story. You declare nodes, which typically start at ```root```. Each call to a node using ```next``` will pause the current node's execution, and start next iteration on the following node. Once that node is completed, it will automatically pick back up where the last node paused. Iterations will only step when there are emitted variables, so logic and functions are run through. If logic denotes skipping certain sections, then the same iteration step will continue on. That is to say each line of source in lichen does *not* relate to a step in the evaluation.
State data is typically declared ahead of time, using ```def``` blocks, however this is not necessary and blocks can be built on the fly by just specifying nested paths, eg: ```@some.thing true``` builds a ```some``` def block, with a ```thing``` field set to a ```true``` boolean. Writing all state must be prefixed with ```@``` and reading all state must be read from existing state data. That is to say, functions do not return data to be worked on-- they can only be written directly to state. For example, ```@some.thing (inc) 1 2 3``` would swap the value in ```some.thing``` from the result of the custom function ```inc```. This is assuming ```inc``` returned a value, which is optional on custom functions, in that case, nothing is written.
Logic is used to control the flow through a set of nodes, and allows for branching of the dialogue. Basic control flow such as ```if/or``` exists, as well can control state mutations using ```when```. All nodes naturally pop back to the originating node, and start back where it left off. So a call to the next node will eventually finish and each previous, originating node will start again. To control this behavior, you can specify special instructions so the evaluator will change this process. Examples include ```next:restart``` which will restart current node, or if specified with an argument, some other node. This restart is at the beginning of the node, and not where it left off. If you need early exits, ```next:back``` will pop off the current node being evaluated and head back to where the last node was evaluating. Read the [next enum](https://github.com/viperscape/lichen/blob/master/src/source.rs#L49) for more information on what's going on.