The creation of dynamic textures in Worlds.

So, along with colors and size modifications, Worlds has to have to ability to utilize different patterns.
As such, a "Geek Code" method is needed to help with the creation of these patterns. This will have
various similarities with CSS, but instead of laying out web pages will produce 2D textures. With a
series of simple functions, Worlds should have the capability of describing nearly any pattern, and the
resulting pattern should be easily read with a key.

The syntax should generally be simple, with the first letter representing the type of element to be
created. This should be then followed by the elements respective arguments. Each element should be
separated with a space. The identifier element and it respective argument should have no spaces in
between. Elements are case sensitive. All non-numerical elements must be represented by a letter.
This is to allow numbers with more then one digit to be read. As well arguments for each structure are
surrounded by parentheses. This structure should become more clear later in this document.

In many patterns the use of shapes have a very important role. As such there should be a syntax,
represented with S with a numerical argument. A circle will be represented I or i.

Each pattern is used in conjunction with element, with each item being used has a higher layer then
then previous item. In this way a hierarchy can be established and more complex patterns can be
created. That way each pattern can be constructed with simple elements, and randomness can be
introduced to enforce uniqueness. Each element should be separated by the pipe symbol "|". So that
way each pattern can be represented by a series of differing elements. It should follow that items on
the left are on the bottom of items to the right of them.

As well Background elements should be put into place. While a background element does not have to
be the first, it is advisable due to the fact that the background will overlap any element below it. It is
simply a B with a color as its argument.

Another important element should be color. What color that can be implemented. This should be
represented by a C(xxxxxxxx) with each pair of x's a hex value, and are alpha, red, green and blue,
respectively. Color in this respect is not it's own element, but merely an attribute that can be applied to
other elements.

However, realism with single colors is rarely achieved, and as such Gradients are needed. Gradients
come in multiple forms. Gradients represented by a G are linear, while gradients represented by a g are
radial. To further complement gradients, there are color mash-ups represented with M. Gradients and
mash-ups are different, in that they require no arguments. Instead they are complimented with color
elements. These Color compliments are then placed inside parentheses, as such G(C(xxxxxxxx)-
C(xxxxxxxx)) Gradients have a range, with C(xxxxxxxx)-C(xxxxxxxx). This represents the range of
colors that will be in the gradient. For linear gradients, the color element on the left is the left side of
the gradient, and the color element on the right side of the gradient. For radial gradients the color
element on the left with be on the innermost and the color element on the right will be on the
outermost edge. For mash-ups there can be ranges and individual colors. Each range will progress in
its color wheel progression, not a numerical progression.

Repetition can be describes as in a CSS like way, except with a few more options. The repetition should
be represented by a R(x), with the x being replaced with either a Y, for repetition along the left side, y
for repetition on the right side. As well you can have X for repetition along the top, and x for repetition
along the bottom. Along with the standard x and y you can have V for repetition along all the edges,
and v for repeated pattern everywhere. For random placement, you can have R for random placement
with no overlap, and r for random placement for the allowance of overlap.
So to sum up repetition:

Y: Repeating pattern along the left side.

y: Repeating pattern along the right side.

X: Repeating pattern along the top.

x: Repeating pattern along the bottom.

V: Repeating pattern along all edges.

v: Repeating pattern everywhere.

R: Randomly placed elements, no overlap.

r: Randomly placed element, overlap allowed.

As well as the Rm there should be an integer following the syntax. This number should represent, in
pixels, the amount of space between the element. In the case of the random placement, it should be
the number of randomly place elements.

Another element that, like the gradient, cannot be by themselves, would be the size function, denoted
by s(number). The number inside would be be how big, length and width in pixels, the element would
be.

Another optional element, but one that can be used by itself is the distort function, denoted by
D(number number). Essentially what this does is stretch whatever it is applied to. If it is applied to an
element, then only that element is effected by the distort. If the distortion is by itself, then all
elements, below it, have the distortion applied to them.

Creating a text file with pattern.

The first line is the width and height of the patterned image. All will be square.

The second line on will be the pattern specifications. A polka-dotted example is as follows:

128

B(C00000000) | S(i) C(00FFC0CB) C(00A020F0) R(R 15)

For a more dynamic usage, any variable can be replaced with a '?'. These can be called within another
program to fill them in and create a more dynamic structure. How this is to be implemented it the
developers choice. This is not a required feature.