Summary: In this post I want to discuss an aspect of game design that deals with the gamer designing or building an aspect of the game object which then interacts with the rest of the game objects, cpu-controlled or otherwise: User Designed Game Objects, or UDGOs for short. ---------------------------------------------------------------------------- Here is a basic schematic of the game mechanic: User -------------> [ Black box ] --------------> Results/Observed Behavior Input So for UDGOs a user inputs a design or strategy where a black box system (could be a deterministic physics system, for example) processes the output. The user inputs should be thoroughly explained to the user so that he may make strategic decisions regarding his design. The mechanics of the black box can be known or unknown. Usually the mechanics are unknown due to the complexity of the black box; however, the user can typically infer the output behavior of many inputs, although a large experimentation process may occur. Examples: 1. Armadillo Run (game homepage) The user in this game designs the configuration of the game objects whereby a black box physics system reveals in the gamer wins the level. According to website: "Armadillo Run is a physics-based puzzle game. You have to build structures with the purpose of getting an armadillo to a certain point in space. There is a selection of building materials, each with different properties, which can be combined to form almost anything. The realistic physics simulation gives you the freedom to solve each level in many different ways." 2. Alpha Centauri The user could design there own units! A user then could have control over what's important to them. See (strategywiki) 3. Programming Games (wikipedia entry) See the above wikipedia link for more detail, but basically the user inputs an AI for a robot or some other such creature that will do battle with other robots. A cool example of this is a space fleet control game (AI fleet commander). ---------------------------------------------------- So where am I going with all this? Well, #1 the use of UDGOs is more of a fringe design mechanic, so I wanted to contribute some history/definitions/etc. in this post to stimulate others to perhaps incorporate some aspect of this mechanic into their game designs. And, #2, I want to discuss the pros and cons of this concept with other game design posters on this forum. Perhaps we can come up with methods to accentuate the pros while reducing the cons.... Well the pros of the UDGO mechanic are: 1. Extreme user flexibility in design. 2. Many innovative and evolving solutions emerge when presented with a suitable black box system. 3. A high degree of skill stratification, i. e. its not just who can smash buttons quicker leading to an almost perfect bifurcation of players, those skilled versus unskilled, but rather a subtle distribution of skilled designs. Now the cons: 1. Too complex for the casual gamer. 2. Time consuming. 3. Gamer tires, quits, and goes to play a button smashing game. 4. For games with both a gaming and a designing phase: too much designing, not enough gaming. ------------------------------------------------------------------------ Lastly, how can the UDGO mechanic be implemented without too much complexity? Personally, I am trying to incorporate the UDGO mechanic into my design, most notably in the combat system. To completely abstract things here, think of a team/force/squad/etc. of 10 user designed combatants. The user designs the AI for the combatants to fight against a hard coded AI. The cpu team then consists of x combatants. A simple way to metricize the users design would be to see how many cpu combatants the users 10 combatants could eradicate. An example of user designed AI, in pseudo code could be: if (enemy.meters.away > 100) shoot with missile if (enemy.meters.away <= 100) shoot with rifle I am trying to come up with a way for the user to design the AI for his combatant units without going the whole writing an AI program... something simpler, yet I would like complex interactions and skill stratification to occur. Thanks for listening, any comments appreciated. Take it easy.

UDGO frameworks are pretty advance, you would find them only tackled by very experienced designers/programmers, due to the explosive combinatrix of features and the testing/deisgn needed to balance it.

Several note worth games have them as a core elements which i remeber:

-Master of Orion : you could design your own ships which lead to very invovled strategies and gameplay depeneding upon available technology.

-Shattered Galaxy : a mmorts which you designed your mechs. Didn't play it myself, but I did get a chance to speak to the developers at a GDC, they built a robust testing framework to test out the balance of the units.

-Master of Magic : you built your own mage and could customize your heros with items and enchantments.

-Heroes of Might and Magic4 : again another magic game where you can build your hero with items/enchantments.

-Diablo : again proably the best known, you take ur standard character and buff them out with items and skills you gain through exp plus their natural class attributes.

From a programming standpoint there are patterns you can use to implement UDGOs. Mostly avoid the OOP of inheritnace and go for composition pattern, where you build up a dynamic object through composition of smaller behaviroal objects. That's not the hard part, the hard part is defining a self consistent processing of these objects. They do spiral out of control as you add more elements the interaction between them becomes hard to manage and predict.

Ie magic resistance vs magic drain vs magic regeneration, each a unique small behavioral object, but how do they interact to produce a consistent behavior. I guess thats where design comes in.

Good Luck!

-ddn

Austue observations AngleWyrm, the problem bears some resemblance to solving constrainted programming problems which pop up in manafacturing and other industrires.

http://en.wikipedia.org/wiki/Constraint_programming

Also follow the link to Combinatorial optimization, which proably also applies.

They use some heavy duty AI programmaing techniques to solve these problems, and some of them are not solveable at all given the constraints we have ( ie within our lifetimes ).

-ddn

Quote:Original post by ddn3
UDGO frameworks are pretty advance, you would find them only tackled by very experienced designers/programmers, due to the explosive combinatrix of features and the testing/deisgn needed to balance it.

Thanks ddn3 for the comments. I realize that implementing a UDGO framework will require more time and effort, but as far as strategy goes I think it adds an interesting dimension to the game.

For example, I love the regular old game of chess. I still have the first wooden board I was given on Christmas when I was 6 or 7 years old. There is so much intricate strategy to chess as well as many tomes of information detailing these strategies. But what if you let the players design their pieces? It would be a different game, but the possibilities are endless.

You refer to the explosive combination of features... no doubt. But, I am always delighted when from a simple framework of rules, complex behavior arises.

Also, thanks for listing out some other games that use UDGOs; I will check these out.

I read about another game, Final Fantasy XII where the player could choose the AI for his characters, but I have not yet found the details (I do not own this game).

EDIT: ddn3, I am reading yr links in yr 2nd post too. Thanks. Well, at least I'll be learning some things if I ever get this off the ground.

Quote:Original post by AngleWyrm

Space Empires V gave it an admirable go with the ship strategies. The player could create their own named strategies:

Wow! Space Empires V! That is sort of what I am after. A very interesting find. I've not played this game, but based on yr post I will investigate further.

I like the idea of the "pick-n-choose" yr own AI with a series of check boxes.

Quote:Original post by AngleWyrm
Both of these examples can be distilled into one basic problem: filling n-dimensional choices space with successful outcomes. Each variable adds an axis, exponentially increasing it's volume. Pick any random point: Is it a successful/desirable outcome for the player?

Firstly, regarding the outcome for the player: I would like the outcomes to range from successful to hilarious. There should be room for failure/disappointment.

The way I see the problem is the following: we are basically creating a finite state machine (FSM). The FSM has inputs. Let's use my simple combatant example from the OP. Each combatant may have some variables associated with it:

1. position
2. weapon
3. speed/style of movement

So for the combatant under scrutiny, it would scan around. Then it would find its enemies. The inputs to its FSM would then be the (1), (2), & (3), shown above.

Then from these inputs the n-dimensional AI choices would emerge; emerge in the sense that the game designer would say, "That aspect will have a check box option," etc.

Once everything is processed, the outputs would then be the new inputs for the next round of FSM processing.

I see yr point about where the complexity lies. If we have a series of binary choices (the check boxes) then we have the states of the machine. Having only box (1) we could could only have two states of the machine: box(1) on/off. But if there were two boxes then the truth table would be:

box1 box2
0 0
0 1
1 0
1 1

This comes down to 2^n where n this the number of binary choice check boxes. For n = 10, we are at 1024 states....

I think I need just to implement a basic, rudimentary version with bare bones inputs and choices... get it off the ground and then try to increase its complexity. Also, perhaps it's time to dust off some of my FSM knowledge and review the information.

Thanks again, AngleWyrm. I was just expecting some casual responses/discussion and you go & type out that masterpiece. Thank you for the insight & effort. Hopefully, I can get something interesting off the ground.

Edit: just found out that Space Empires V has a demo... I'm checking it out.

I cant think of any good examples of such at the moment, but another way to register checkboxes, is not as say, many digits of the same number, but rather much like flags are used. A bunch of checkboxes with flag values that get all xor'd together.

Just a though, might help tone down the scale of complexity as far as coding is required. 4 binary choices and 4 flag choices is 64 total configurations, but is only needs coding for 16 binary types and 4 flags.