Munchkin-Proofing an RPG

[danielwang]

I wrote this a few months ago. Becuase it's hard to get someone who knows about RPGs I thought I'd put it out on the Org forums.

This should be better for writing more cracker-proof RPGs.
If they can find loopholes in a watertight system like this, they should be working for a law firm!
Oh wait, most munchkins are attorneys anyway.

Abstract:
A universal, open-platform RPG descriptor based on d20 concepts and .Net/SOAP component object models. Describes and defines various structures. Pending completion: a port of "MechWarrior" and "Legend of the Five Rings" to this model.

http://www.mechacker.com/docs/scitech/rpgdcom.doc

Coming up next at MECHACKER.COM:
Video compression and analysis algorithms
Increasing traffic model efficiency with robotic cars
Anime Dissertations, OS Bashing, Philosophy
And More!

[Lyrs]

plz don't use docs. i'm generally way too paranoid to dl word documents due to the fact that they can be infected.

why not just copy and paste everything?

/end

[Hoeya]

...probably because its huge.

[danielwang]

Note:
This is a text version and may not contain necessary graphics



A Role Playing Game Framework
Daniel Wang

Introduction
Throughout many role-playing games, there are often questions raised concerning open-platform scalability, compatibility, and order. While role-playing games are designed intuitively to be arbitrary and cooperative, there is often the need for an open system that allows for cross-expansion as well as a structured action system.

In this document I would like to explain the architecture that many existing systems, D20 and GURPS, are based on, and define a few principles that these are based on. I would also like to propose a few other standards, in order to ensure modular expandability and better component integration.

Please note that this framework is intended to assist in game development, not game play. The end user only needs to understand the directives on an object.

Objects
Any role playing system is based on objects. Each object has its own properties, attributes, and requirements. Certain objects simply exist, some can be used, and some are actively changing. However, all objects fall into sets of two categories: active and passive, interactive or objective.

A passive object does not run as a service, it simply exists. However, objects may be activated and still affect other characteristics. An active object however, continuously runs like any geyser, volcano, or other system.

An interactive object is simply a character. Although many objects may be interactive in a way of affect and effect, interactive objects are players, NPCs (GMIO), or characters. An objective character is just another module.

Each object is defined by several attributes, some may be local and some may be global. Many states are possible, each state or attribute can be volatile or nonvolatile, or be a read-only property.

Interactive objects or inputs are vastly different than other objects. A player is a dynamic input that affects the game and can call other objects through events. Another exception is the Game Master, or the seed input. The GM/DM controls the dynamic interactivity of the entire game, and has the ability to change events and objects.

Munchkin-proofing tip: All input is subject to GM approval, as well as events and such. It is important that all objects are trusted, similar to code. Please see “Role-Based Security” for more information on superseding objects.

Functions
A function is the called part of an object. A function is called by a player (input), event, or other method and performs certain actions, like a library. Each function has its main service which accepts calls like an API, this may be null. Other subroutines may be called internally or externally, and may initialize other services as needed.

Example: A Simple Fireball Spell
<?xml version=1.0>
<object proc class=obj.func.spell name=”fireball” version=0.99>
<meta name=”supersede” value=42400 />
<meta name=”access” value=700 />
<system name=”api” value=”passive”><classes>
Summon=summon()
</classes></system>
#define array UserAccess[main,Summon] = true;
#define var integer DefaultSpellStrength = 20;
void main() { return(0); } // The main thing
// This object is not Interactive and has no automatically run system
sub summon(str,target,,target[]) { // When this spell is summoned…
case select target
if case target == “” { // No target, must want to blow up everything…
close = get(_system.global.proximity(_me,0,20,0)); // Find out who’s close,
for each victim in close {
_system.global.DecrementHealth(,victim,str*3); }
_system.global.DecrementHealth(_me,str); }
if case target != “” {
for each victim in target[] {
_system.global.DecrementHealth(victim,str*3); }
_system.global.DecrementHealth(_me,str); }
else { fail; return(1); } end case; return(0);
end sub }
</object>
</xml>

Example on Services
A common example of a passive Service is the Listen Check. In Dungeons and Dragons, the Listen Check service is a function inside the Character container object. The Listen Check actively listens for audible events, and can be called by the player (e.g. “I listen for any abnormal sounds in the wall”). Additionally, the Listen Check Service is called by Directive Events on an Action Item, for example, to determine which characters repond first in a ambush.

Null Objects, Integration, Global Object
It may be noted that objects may be null and may be integrated as a part of a character or other event, or any other object. Anything that exists can be referred to as an object, so it may be possible to have a object act as storage (such as a known spell) or simply act as a routine (a magic spell) or both (nonvolatile conditions).

There is another default class called the Global object. This object controls what the characters (inputs) can do by default. For example, a default object dictate that knowledge objects can be copied in a specified number of turns, while objects such as money cannot be copied. Players can walk but cannot automatically fly. Like a global.asa or a stdio.h, this is the default action used.

Note: The global classes come as a default “common sense” library which’s purpose is to specify default abilities and functions so the GM doesn’t have to. It has a low supersede value and is usually overridden

Events
Each object or input may call events. Events are calls that, similar to SOAP, contain instruction, data, parameters and more. Events may change the attributes, content or code of other objects or a character.

Actions
Actions are functions or events called by inputs (players/characters), interactive objects, or Directives. An example of an action would be “I listen for any abnormal sounds”. Another example of a GM-generated input Action would be “The Human Resources bloke (NPC) suddenly drops his phone and runs for the door”.

Directives
Directives are human-readable instructions that are to be applied when called. Directives shall be in clear, concise language and shall be denoted by a call to _body.xml, where a directive is enclosed in a xml object of system/root directive.

Example
<?xml version=”1.0”>
<directive name=”d20”>
Roll one twenty-sided dice (icosahenron).
Return the integer displayed on the topmost face of the icosahedra.
</directive>
<meta codebase=”root”>
void Main() {
return _self.directive.d20(); }
</xml>

Directives via Role-Based Security
Role-based security is implemented in each object as a conflict resolution system. Since the objects and classes are trusted, this is not used as an ability sheet for restricting action but rather as a method for resolving a conflict.

For example, say, we have a player (input) call as object (sword) that has the ability to cut everything. However, the object (crystal) has the attribute that it cannot be cut, which overrides the global function of things being able to be cut.
If the GM calls that the crystal can be cut, the decision can be committed by replacing the infinite values for the object properties (cutting power vs. density and structure) to be relatively higher but having the crystal’s attributes reflected to say it can be cut. This usually means adjusting the directives to allow for this action.

Pass/Fail System

Note: Obviously, higher role-based values supersede those conflicting events with lower attributes. It the values are equal, it’s the GM’s call. If one is set higher or lower, it’s still “with GM approval”.

If a dice roll is required to complete a move, the dice roll is usually checked by the Global system or by the object itself using the probability library. However, it is also possible to specify Role-Based Supersede values as part of code.

Event Object Embedding
Per the Global default routines, objects and directives may be embedded inside Events, Objects, Actions, or any other object unless otherwise specified.

The Main routine automatically is run as a Service on an Event; however the subroutines and other directives do not run. Interfaces (APIs) are automatically assigned Role-Based security per Global default classes unless specified.

Order of Events
Although not completely covered, an order of events and decision system is a critical component in the RPG framework. However, since different scenarios present different needs, it is necessary to use separate modes of turn slots.

A key component of a turn-based system is input structure. At the most basic level, real-time (real-world) timeslots can be defined at the interrupt-feedback level. In a freeform state, players commit input one at a time, at any time after one player is done. In a 0-feedback level, turns take place based on slot-only. In a feedback-regressive system, other players may insert related actions in a hierarchical method after one player is done, up to the number of generations allowed.

Please note that other, role-based and chronological slot systems may apply and need to be taken into consideration. Every one is different.

Built in System/Root Objects
An optional Global Default class is included as a library to assist in game development.
The System/Root Library object is a system core module that acts as a kernel for transaction coordination. Additional d20 compatible libraries are available, as well as pre-defined templates.









Pre-defined System Objects

d() rnd() entropy(); Random Number Generation
The d20-compatible function d(int) shall return a equally-random generated whole unsigned integer from 1 to int. The enhanced function rnd(rng,est,int,parg) shall return integers from range denoted in standard d20 syntax. The entropy() function is used for recursive-regression to provide for sequence random generation where the seed device is not trusted.

Example
The sum of two random integers from 1-20, added to four
D20: 2d20+4
C: i = d(20) + d(20) + 4

The rnd() function uses the arguments [fabcdevwxyzn] to represent any side of a standard die, as well as supporting ranges. For example, a c/str(0-8) would be all numbers 0-8.

The entropy() function takes an input stream and a generation threshold, and purifies the stream by condensing number repetitions using regression.

where() location(); Location

If you’re doing a worldless or mapless RPG, then you don’t need to use where(). However arbritrary location is, it’s quite useful for those cases where a location conditional is needed. In situations such as a ranged attack, the location() function can be used to return the distance between two objects. Keep in mind, however, when using this for ranged attacks, that this function doesn’t return whether there is a line-of-sight or not. Use a directive and save some trouble.

[Lyrs]

*looks up half the vocab in dictionary*
*scratches head*

/end

[Simpi]

(a bit off-topic now)

No offense but if GM cannot put a leash on a munchkin player, he/she had it coming.

My group (which actually started way back in 1988 http://www.helsinki.fi/jarj/hysfk/kepeli/ ) recently 'acquired' a munchkin player who always wanted (we use 3rd ed. D&D) to use rules found in different supplements. IMO, the basic book is pretty much in balance and new books with prestige classes, etc. are just too unbalancing.

Anyway. His first character in 3rd* was a druid. Not very good in combat but otherwise good. After a two sessions he started complaining about that he cannot play it because 'he's too easy to kill, cannot take punishment, etc.

At the start of the third session, he announced that he's gonna roll a new character so it's gonna be ready when his current character bites the dust. Actually he made several and chose the best abilities. Then he made sure his druid was killed (by singlehandedly charging an ogre. He was on level 1) and poof, out came his new character whose all stats were over over 12.

At this point we got pissed off. I had agreed to run few sessions instead of our normal GM and he asked me to give him a lesson. To make long story short, he was hauled away to prison for arson (he was tricked by few thieves) and his character became a bitch for a gang of hobgoblins.

BUT. When he was arrested, he announced that he will create a new character because obviously his lawful good character had violated code of conduct and lost his powers(???). We then confronted him, saying that if character makes a mistake and is not killed, you will sure as hell NOT create a new one and then I made sure he played his character for one session in prison.

Did he learn his lesson? Don't know, but at least we haven't seen him for a month now. Hope it stays that way....

Remember. GM is THE GOD of game universe.

* We also play 1st ed. and he was there too but that's another story

[EarthCurrent]

Where's my Hackmaster!?