I pulled these thoughts together on a request from nash. mithro asked me 
to post to the
development list as well, so here it is - a few thoughts on things that 
could be done that would
make the creation of rulesets more general and perhaps more attractive 
to newcomers.
------------------------------------------------------------------------------------------

At the end of last week nash asked me to give some thought as to how 
much of a ruleset the RDE
could be used to develop. At the moment there's not that much that it 
can be used for, aside from
things like components, properties, designs, resources, or planetary 
systems and the like. And entire
ruleset cannot be constructed from within the RDE. That does not mean 
that there cannot be, only
that at the present moment it is not possible. I have given some thought 
to the issue, however, and
believe that it would be possible to design the majority of a ruleset in 
a server-independent form if
a few things were to occur:

1) A basic set of Order types would be available for use by a ruleset 
from a server. That is, a ruleset
could choose to make use of a stock set of common Orders such as move 
orders, fleet construction
orders, colonization orders and the like. It would also be possible for 
the ruleset to not use the
available orders, or to simply extend and override the base Order with 
its own.

2) Any new major features (such as resources and trading as seen in 
TimTrader) should be implemented
in a server-agnostic format. Instead of writing the plumbing in Python, 
as is the case right now, the TPCL
language should be extended and exploited. In much the same fashion as 
Components affect the value
of a Property so too could TPCL (or rather, TPSL [Thousand Parsec 
Scripting Language]) code could
be written that allows Producers to generate Resources on a planet and 
the Consumers to consume those
same resources. With a bit of forethought, then, it would be a fairly 
simple process to put the majority of
the processing and functionality of the feature in a server-neutral 
format which could be stored, edited and
tested in the RDE.

Now, certainly not all Orders can apply to all rulesets. And different 
rulesets will have different variations on
the same Order. And it would not be the most efficient thing to do to go 
about interpreting TPSL code for all
of the interesting things that happen on the server. However I believe 
it should be a goal of the TP project to
make the building of new rulesets accessible and easy.

Games like Neverwinter Nights have such a large and active fan and 
hobbiest base because of the fact that it
is quick and easy to create objects or features and share them. More 
importantly it is extremely easy to use
the work that other people have already done in your own efforts. The 
more Orders that the servers can
provide for use by rulesets by default the quicker rulesets can get up 
and running. If the ruleset needs
functionality that isn't already present then it can be put in manually, 
hopefully to the benefit of all the other
rulesets as well.

The same applies to features. Making resources, for example, accessible 
and easily sharable would make it
more likely for people to make an effort at starting a creation of their 
own.

Anyway, those are my two cents (or rather, two ideas). I'm sure there's 
plenty that I haven't considered, but
it seems to me that there a bit of an opportunity being missed in some ways.

-Fro
_______________________________________________
tp-devel mailing list
[email protected]
http://www.thousandparsec.net/tp/mailman.php/listinfo/tp-devel

Reply via email to