I want to create something like Everquest, only anyone can extend it, and possibly modify it.
This is extremely similar to DarkLife and there may well be collaboration/exchange/complete fusion for various parts or the whole.
Here is a high-level strategic view of the project. This post will be edited as time goes on making it the Reference.
Goal of the project:
Create an MMORPG toolkit and context for creating an MMORPG-style environment
Philosophy of the project
Anyone can create a zone and add it to the MMORPG. Ideally anyone can add content and the system will integrate this seamlessly into the game. Ideally I can create a single avatar, with corresponding health, money, XP, and use him/her across all integrated zones.
How this would work - High level view
Each player will have an attachment that represents everything about them.
A set of API modules facilitate development of monsters, weapons and so on.
Between zones, a floating exchange-rate could be implemented for money and XP.
By using modular scripts that communicate using a well-defined Linked Messages interface we will move any secret-secret stuff into what will hopefully be a tiny tiny script/module, leaving anyone free to generate their own monsters, weapons and avatar types!
Deliverables
Documentation
- The project design (this post, will evolve iteratively)
Example implementations:
- Example monster (open except core)
- Example avatar token (open except core)
- Example weapon (open except core)
- Example spell implementation (open except core)
Core script modules:
These modules could be freely available (open) but would be closed prior to actual instantiation in the game world in order to lock them, eg with channel number.
- Zone exchange rate implementation modules: enforces XP and Money exchange-rates (locked module)
- Generic monster module(s): integrates a monster into the MMORPG (locked module)
- Generic weapon module(s): integrates a weapon into the MMORPG (locked module)
- Generic avatar module(s): integrates an avatar into the MMORPG (locked module)
Helper modules/systems:
- Zone exchange rate caculator system: calculates XP and Money exchange-rates (open modules)
MMORPG Library:
A set of modules that could be incorporated into monsters, weapons and avatars that provide functional abstraction and facilitate the rapid generation of these objects.
- Weapon API module: placeholder
- Monster API module: eg provides code for moving, pathing, basic AI and behavior
- Avatar API module: placeholder
How this would be used
Joe decides he wants to make a dungeon. He gets hold of copies of copies of the core, live modules and adds them to his weapons, monsters, and avatar token. He adds in the MMORPG Library API modules, and writes surrounding wrapper code to customize how his zone behaves.
People come and visit the zone. Hopefully. They play for a while and accumulate experience and money in this zone.
As time goes on, the system learns how easy it is to get xp and money in this zone and can compare this to other zones, in order to generate exchange rates.
The exchange rates set the equivalent xp and level as one moves between zones.
Now the MMORPG just got bigger! People can choose where they are going to level. Zones that are a posteriorae hard to level in get assigned a favorable exchange rate, and visa versa.
Priorities
Stuff to create a dungeon zone is priority 1.
Stuff to provide zone inter-compatibility is priority 2.
Risks
Risks outstanding for creating dungeon zone:
- Risk that unable to create convincing and fun monsters -> risk outstanding, prototype in progress
- Risk that convincing and fun monsters will be too resource intensive -> risk outstanding, awaiting results of prototyping
- Risk that demise of project owner would kill off existing implemented dungeons -> very low because all modules open in their non-instantiated form.
Risks outstanding for inter-zone compatibility:
- Risk that unable to implement xp equivalence detection
- Risk that unable to implement financial equivalence detection
- Risk that unable to implement object equivalence dection
- Risk that unable to implement xp interchange mechanism
- Ditto for finance
- Ditto for objects
-> risks for inter-zone compatibility will be looked at in more detail once technology for creating dungeon zones in place
Risks with Status=Closed
Make a sword to hit people -> prototyped, works ok
Make a sword to hit objects -> prototyped, works ok
Store life points and stuff, kill avatar as required -> prototyped, works ok
Details and Discussion
This section will provide implementation details.
Zone addition/modification
In order for the exchange rate system to work, we need to implement systems to handle zone modification. Worst case, we lock zones against modification and have all modifications as adds followed by deletes.
Use of objects between zones
To be decided.
Security
There is the possibility that a channel number, or other secure protocol parameter, will become widely-known at some point, compromising the stability of the game world.
To mitigate this we need to consider methods to:
- modify the channel number, or equivalent, throughout the effected gameworld
- segment the gameworld to limit the damage caused by any single breach.
As far as channel numbers, we might consider using a different channel per zone. The zone designer designates the appropriate channel number.
If the zone designer owns all objects in his/her zone, we can have the objects respond to a change_channel request, as long as it comes from his/her id.
In an initial project implementation, each avatar is local to the zone. In future updates, we might choose to conserve this, and to provide gateway systems to seamlessly move between zones. That allows us to shut down a compromised zone by removing it from the gateways systems.
Detailed Design - modules
Note: draft, for discussion purposes only
Introduction
We can split the required functionalities as follows:
- secure comms (in-channel shouts)
- receive damage
- receive effects
- send damage
- send effects
- stats (life, money...)
- AI (for monsters)
- movement (for monsters and possibly for avatars)
- control interface (for avatars)
We need to consider for each module the extent to which:
- it must be easily updatable
- it should be stable wrt changes
- it should be secure/locked wrt players and wrt zone designers
For the effects/damage modules, we basically need that we can flexibly add new weapons and effects into the game, whilst all objects already in the game will respond appropriately to them.
To this effect, we will split the damage/effect modules into receive and send. The send modules will be fairly flexible and can change with time. The receive modules must be very stable wrt new attacks.
Dynamically loaded scripts were considered but not retained for now because of the load they would impose on the sim motors.
Module design
Damage/effect receive modules will respond to six primitive attack types:
- directdamage(amount)
- damageovertime(amount, duration)
- movespeed(percent, duration) (can be more or less than 100%)
- attackspeed(percent, duration)
- attackpower(percent, duration)
- sensorpower(percent, duration)
Damage/effect send modules will use these primitives to create a range of attack types.
Projectiles can be implemented within this framework because the receive modules dont need to know with what they are being attacked, just the amount of damage inflicted.
The receive modules will be using Listens to sense attacks. Since scripts/modules are not threaded the listen must exit immediately, without undue delay, ie no llSleeps, and delegation to other events/scripts as necessary.
A stats module will store current avatar state, ie Life, Money, Movespeed, AttackSpeed, AttackPower, SensorPower.
Detailed design as at 24 November 2003:<==
Following systems will be created:
- CombatSystems GRI (GRI = "Game Rules Instantiation"

- Weapon/spell system
- Shield system
- Money system
Following modules will be created:
CombatSystems GRI system:
- Stats module
- Receive dmg module
- Send dmg module
Shield system:
- shield module
Weapon/spell system:
- weapon module
Money:
- money module
Money
Money will be stored as objects in your inventory. This makes life really easy for the developers. You can convert your money from different types at the bank. Money will communicate with other modules, ie GRI stuff, over ChannelMoney.
Shield System
Shields will work by replying to PROTECTIONPING messages. The shield module enforces their being worn as an attachment. The CombatSystem GRI will do periodic pings to work out how much armor you are wearing. Shield modules will send an INVCHNG message on attach and detach.
Shield will communicate with the CombatSystem GRI via ChannelShield.
Shield types
We will have the following shield types:
- AC (vs melee attacks)
- MR (vs magic attacks)
- Projectile (vs projectile attacks)
Note that shields are not linked to the CombatSystem GRI. All communications is via inter-object communiation (initially shouts)
Weapons/magic staves
Weapons/magic staves are separate objects from the CombatSystem GRI.
They are worn as attachmnets, and the weapon module enforces this.
Weapons will attack by being asked to do so by the player (via takecontrols or channel 0 or whatever).
Weapons cant directly attack anything, because they run on a separate channel, ChannelWpn. What they do is send an attack message to the CombatSystems GRI SendDmg module, which will validate it and broadcast it to the appropriate victim.
We will pipe weapons messages via the CombatSystems GRI to provide a certain amound of centralized validation, eg we can turn off certain rogue weapons, control cooldown and so on.
AS far as cooldown, two possibilities:
- global cooldown. EAch weapon has a cooldown associated with it, that it sends in its attack message to the CS GRI. The CS GRI blocks all further attacks, from any of this players weapons, until CoolDown has elapsed.
- Weapon specific cooldown. Certain weapons can bypass the global cooldown and be fired simultaneously
Weapons will send the following information in their attack message:
- attack type (DirectDamage, Reduce MoveSpeed, etc...)
- power
- duration
- attack substrate (magic/melee/projectile), which is used to trade off against shield types
Weapons can have a recharge time, and can have a limited ammunition/number of charges. Weapons are responsible for enforcing this.
DoTs
DoTs will be instantiated by firing an object at the target that "sticks" to him her for the duration of the effect. This can be visible (like a poison dart/arrow), or not. This makes life easy for the damage send/receive modules.
CombatSystems GRI Modules
The juicy bit, the core of the system!
There will be 3 or 4 base modules, which may be fusioned or fissioned as time goes on. Concretely these are scripts embedded in a single attached object, such as a bracelet.
The attached object is termed the "GRI Tag" and must be worn to take part in the game. If you take it off, you're out, and may be ejected from the land. To rejoin, just put it back on, but there will probably be a small delay during this respawn.
The GRI modules are:
- receive damage module
- send damage module
- stats module
- and possibly a secure comms module
Now you've seen the other systems, you can imagine what these will do, but read this anyway.
Receive damage module:
- responsible for receiving ATTACK messages from other Actors via the SecureComms module
- validates the ATTACK messages against currently cached shield stats, to generate actual damage inflicted.
- sends SUBSTRACTSTAT linked messages to the Stats module
- listens for STATCHANGE linked messages from the Stats modules and handles the Death condition
Handling the Death condition in the STATCHANGE event makes this work within an async comms framework.
The following damage can be received:
- DirectDamage (health stat)
- Mana (mana stat)
- AttackSpeed (AttackSpeed stat)
- AttackPower (AttackPower stat)
- AttackRange (AttackRange stat)
Send damage module:
- receives ATTACK messages from the weapons system (different attachment) on ChannelWeapon.
- modules them for currently cached attackspeed, attackpower and attackrange stats
- forwards them to the SecureComms module for onward transmission to the unfortunate target
- may or may not enforce global cooldown timing
This is a one-way pipeline and will work just fine with async comms.
Stats module
This stores the stats for the player.
Stats include:
- Health
- Mana
- AttackSpeed
- MoveSpeed
and probably AC, MR and Projectile Armor
To work within the async module comms framework, the stats module will send a broadcast linked message every time a stat changes, and other modules will cache the stats they are interested in. Coupling is minimal to the extent that the modules only cache what they're interestd in, so can add new stats variables without having to rebuild the entire GRI.
SecureComms module
Responsible for inter-Actor communication on ChannelInterActor.
It's a separate module becuase:
- means we can abstract the current shout system from the other modules, and migrate easily to direct object-to-object communication when we get it
- makes changing the ChannelInterActor number really easy
- it will encapsulate encryption and other stuff if we need
Other systems not covered here:
Monster AI. A module that can be placed in monsters to make them fun to kill.
Monster Move Module. Separate or fusioned with the Monter AI Module. Provides routines for making Monsters move about.
Other points
Sourceforge
Now possible. Good. For now, Alternative Scripting Library is fine. I think we had enough publicity for a while

Concepts
XP
There will be no XP. If you want to be tougher, buy better equipment!!!
Monster drops
You will get given money and / or equipment if you do something cool, like finish a mission. Killing rabbits will get you squat. Working as a team will get you really decent stuff.
Your rights to use this design:
You can freely use and derive from this design as long as this does doesn't affect my ability or rights to use and/or derive from the design myself, here or in any other game or on any other platform, to the extent to which this is enforceable.
Obviously if you send me derivatives, it will help me make future stuff.