Seeding method to encourage failure...

[soggie]

I've been thinking about Random Number Generations (RNG) for quite some time as I'm designing my system, and am trying to fiddle around with pre-seeding or normal seeds.

For the uninitiated, a seed is a number you pass into a random number generator to generate a... well, number. If you pass the same seed into the generator, it will always generate the same results.

Computers use the RNG to simulate dice rolls. And if I went with the normal seeding method (using system time to seed), a player can keep trying on a lock until he rolls a successful lockpick check. Or, in the event of a critical failure (he breaks the lock), all he needs to do is to reload a previous save.

I believe mechanisms like this forces the player into a mindset than failure is not an option. What if however, my game's mechanics allow players to learn through errors too?

Say if you successfully steal an item from a person, you get 10XP. But if you fail the steal, you get 5 + Wisdom modifier XP too.

Failure should be encouraged in a game, I believe. Especially so in an RPG, where failure should be allowed and accommodated as a gameplay device. When the player get used to failing in certain task, he will gradually get used to the fact that his character is not a god and is not perfect.

Will this pre-seeding (seed using character creation time) make an RPG more enjoyable, making choices more meaningful, or will it just be an annoyance?

Opinions appreciated.

 

[DraQ]

Will this pre-seeding (seed using character creation time) make an RPG more enjoyable, making choices more meaningful, or will it just be an annoyance?

Opinions appreciated.

For things like randomized world generation, definitely use pre-seeding at the start of new game. For success rolls, however, if the game is complex and allows player to do a lot of things, seeding every possible action individually may become not feasible, and generating a stack of pre-seeded generic rolls is exploitable as player can learn their order, reload and fish out the good outcomes by performing inconsequential actions in-between.

Given that player is already given a powerful probability manipulation device - save and load - there is really no way around it using randomization. What I would do is just penalize reloads by applying negative modifiers. Admittedly, this would be difficult to balance, as those modifiers should not irreversibly fuck player up, but they should be bad enough that any failure not resulting in game over would be preferable to reloading.

 

[spectre]

I have an organic hatred for preseeding. If I ever find one, I always try to break the system by reloading and doing things in different order. Mostly did this in Civ 4, when continously losing troops in these 99% chance to win battles. Then they brought back the magical "random seed" option and all was well again.

Say if you successfully steal an item from a person, you get 10XP. But if you fail the steal, you get 5 + Wisdom modifier XP too.

Not a bad idea, I thought of a different system for 'learn through use' systems: Say, your skill goes from 1 to 100,
if teh skill value is 1-24 (novice), you gain exp in this skill by successful checks.
25 and above, it gets reversed, you gain exp by failed checks only.

Alternatively, we can add Int or Wis to the mix by making it add exp to skill even if check result doesnt allow for it normally(ie. with godly int/wis you learn the skill regardless of result).

I think such an approach gives a nice well rounded feel to the system:

(o)In the beginning of learing a skill you need successes to motivate you.
(o)Experts need to constantly look for challenges to develop.
(o)Intelligent/wise people tend to ponder on their actions more and analyze them to draw conclusions regardless of result.

 

[Orgasm]

Computers use the RNG to simulate dice rolls. And if I went with the normal seeding method (using system time to seed), a player can keep trying on a lock until he rolls a successful lockpick check. Or, in the event of a critical failure (he breaks the lock), all he needs to do is to reload a previous save.

Why do you even care how the random() function works? It gets you a pseudo random number, you got what you want. Now you can do anything with it in your high level language. You can add it as a modifier to your characters skill or just use it for the check in a completely random system. Btw, you didnt say how your system/skills/checks work.

I believe mechanisms like this forces the player into a mindset than failure is not an option. What if however, my game's mechanics allow players to learn through errors too?

It certainly shows that failure is bad. Now the core question is, how much of a spanking for fucking up is good and how much is bad. This is what you are trying to figure out, imo.

Example:
Light punishment. Chara in Dragon Age dies. Stands up. You heal his "heavy" injuries.

Medium punishment. Chara in Baldurs Gate dies. You need an expensive Ressurect scroll. Perma death is there too.

Hard punishment. Chara in Dungeon Crawl dies. Fucking restart.

Knights of the Chalice tries all.

All those games are played by different audiences but with crossover. How much of an audience do you want? =)

Say if you successfully steal an item from a person, you get 10XP. But if you fail the steal, you get 5 + Wisdom modifier XP too.
Failure should be encouraged in a game, I believe. Especially so in an RPG, where failure should be allowed and accommodated as a gameplay device. When the player get used to failing in certain task, he will gradually get used to the fact that his character is not a god and is not perfect.

Again, the core of this is defining how harsh your punishment for failure is. Its a gradient you can shift how you want, searching for your audience.

Will this pre-seeding (seed using character creation time) make an RPG more enjoyable, making choices more meaningful, or will it just be an annoyance?

For whom?

For me, it would not make the game more enjoyable by itself because its fluff.
Choices are made meaningful through consequences. The more diverse, the better.
There are certainly people here, who are annoyed by randomness in any form in their games.

 

[DraQ]

Say if you successfully steal an item from a person, you get 10XP. But if you fail the steal, you get 5 + Wisdom modifier XP too.

Not a bad idea, I thought of a different system for 'learn through use' systems: Say, your skill goes from 1 to 100,
if teh skill value is 1-24 (novice), you gain exp in this skill by successful checks.
25 and above, it gets reversed, you gain exp by failed checks only.

Alternatively, we can add Int or Wis to the mix by making it add exp to skill even if check result doesnt allow for it normally(ie. with godly int/wis you learn the skill regardless of result).

I think such an approach gives a nice well rounded feel to the system:

(o)In the beginning of learing a skill you need successes to motivate you.
(o)Experts need to constantly look for challenges to develop.
(o)Intelligent/wise people tend to ponder on their actions more and analyze them to draw conclusions regardless of result.

So, you propose an anti-grindan system?

I have long since invented a better one:

Max XP gain (for skill use) is multiplied by success probability on failure and failure probability on success. This encourages player to seek about 50-50 challenge when developing skills, as obvious success and obvious failure don't teach you anything - according to the formula p*(1-p). XP gain can be further modified by intelligence or whatever the fuck you might want.

There, solved.

As for failures, there is one more way - make failures not immediately obvious and let the player dig himself in. Maybe the player should notice that he has been infected by potentially deadly, and costly to cure disease several days after infection. Maybe the guards shouldn't rush in immediately after player botches covering his traces after commiting a crime (murder, burglary), but only aftersome time, after getting notified by witnesses or examining the traces. Etc.
Then, the price for getting rid of the consequences would automatically include losing up to several hours of gameplay.

 

[soggie]

Computers use the RNG to simulate dice rolls. And if I went with the normal seeding method (using system time to seed), a player can keep trying on a lock until he rolls a successful lockpick check. Or, in the event of a critical failure (he breaks the lock), all he needs to do is to reload a previous save.

Why do you even care how the random() function works? It gets you a pseudo random number, you got what you want. Now you can do anything with it in your high level language. You can add it as a modifier to your characters skill or just use it for the check in a completely random system. Btw, you didnt say how your system/skills/checks work.

I'm talking about the seed, not how the RNG works. Like I said, if the seed is tied to the system time (which is a different value every time you reload a save game), you have unlimited chances to fail a task before you eventually succeed. Which means your character with 5% lockpick skill can still get into a maximum security prison as long as the skill check caps the minimum check rate at 1%.

On the other hand, if I use ( game creation time + action index ) where action index is a ID of that particular action in the game's event database, it will fail no matter how many times the player reloads or perform other actions in the game. This is where I can force the player to accept that failing IS an option in the game, and to sooth the butthurt I give XP for failing.

It certainly shows that failure is bad. Now the core question is, how much of a spanking for fucking up is good and how much is bad. This is what you are trying to figure out, imo.

Example:
Light punishment. Chara in Dragon Age dies. Stands up. You heal his "heavy" injuries.

Medium punishment. Chara in Baldurs Gate dies. You need an expensive Ressurect scroll. Perma death is there too.

Hard punishment. Chara in Dungeon Crawl dies. Fucking restart.

Knights of the Chalice tries all.

All those games are played by different audiences but with crossover. How much of an audience do you want? =)

I'm planning to implement failure as a mechanism in the game, where failing a task might open up doors that otherwise a player won't get by succeeding in that task.

For example, a player tries to convince a villager to let him go into the cave to investigate the strange sound coming from it. The check fails and the villager goes in alone, only to scream for help. The player goes in and saves the villager from a big bad bear and in turn is given a unique family rifle for saving the villager's life.

My point is, I want failure to be something players can live with.

(PS: As for how my skill check works, here's a link to my blog post: Weekly Update #5)

I think such an approach gives a nice well rounded feel to the system:

(o)In the beginning of learing a skill you need successes to motivate you.
(o)Experts need to constantly look for challenges to develop.
(o)Intelligent/wise people tend to ponder on their actions more and analyze them to draw conclusions regardless of result.

Max XP gain (for skill use) is multiplied by success probability on failure and failure probability on success. This encourages player to seek about 50-50 challenge when developing skills, as obvious success and obvious failure don't teach you anything - according to the formula p*(1-p). XP gain can be further modified by intelligence or whatever the fuck you might want.

This is a good idea. Could this be the holy grail to a use-based progression system? This can be done with a simple mathematical formula to draw a bell curve.

 

[ecliptic]

You could just individually hash each possible action in the game. As long as you deterministically come up with a way to get the indentifier, you don't even need to worry about saving these action hash values.

i.e. Stealing from NPC 23 result is the result of number generation with seed (NPC_NumericIdentifier + StealSkillNumericIdentifier)

Of course, use different identifiers for different skills and different objects.

Doesn't matter how much the user reloads, does different actions, etc. etc. Any time he steals from this guy, it will give the above value.

The only real exploit is that he can load his game, and try to steal again after raising his steal skill, and that might be successful due to the higher skill, even with the resultant number being the same.

But this is unavoidable without somehow transferring some portion of the game state along even without the user saving his game, which is an awful idea.

 

[DraQ]

You could just individually hash each possible action in the game. As long as you deterministically come up with a way to get the indentifier, you don't even need to worry about saving these action hash values.

i.e. Stealing from NPC 23 result is the result of number generation with seed (NPC_NumericIdentifier + StealSkillNumericIdentifier)

Of course, use different identifiers for different skills and different objects.

Doesn't matter how much the user reloads, does different actions, etc. etc. Any time he steals from this guy, it will give the above value.

Not exactly a good idea as some action should yield random results rather than repeated result when repeated - attack rolls anyone?

You could probably use the number of attempt as well, but that starts to become somewhat shitty.

 

[soggie]

You could just individually hash each possible action in the game. As long as you deterministically come up with a way to get the indentifier, you don't even need to worry about saving these action hash values.

i.e. Stealing from NPC 23 result is the result of number generation with seed (NPC_NumericIdentifier + StealSkillNumericIdentifier)

Of course, use different identifiers for different skills and different objects.

Doesn't matter how much the user reloads, does different actions, etc. etc. Any time he steals from this guy, it will give the above value.

The only real exploit is that he can load his game, and try to steal again after raising his steal skill, and that might be successful due to the higher skill, even with the resultant number being the same.

But this is unavoidable without somehow transferring some portion of the game state along even without the user saving his game, which is an awful idea.

Great idea. Hashing the Success Rate formula would be better. As for a person improving his steal skills and then trying again, well, this is the original intent, isn't it?

If you can't do it now, leave and get better. When you ARE better, come back and try again.

Here's how my Success Rate check works:

Normalized Success Probability = 122 - ( Skill - ( Attribute x 5 + Level ) )
Success Rate = ( Normalized Success Probability * 0.357 ) - Efficiency Level

The success rate ranges from 5 to 95.

The hash can be:

Initiator ID + Target ID + Initiator Skill/Attribute + Initiator Level + Target Attribute/Resistance + Target Level + Initiator Efficiency + Target Efficiency

That should cover all variables.

Not exactly a good idea as some action should yield random results rather than repeated result when repeated - attack rolls anyone?

You could probably use the number of attempt as well, but that starts to become somewhat shitty.

Which is what I'm trying to prevent in the first place - keep reloading for that critical hit.

 

[DraQ]

Which is what I'm trying to prevent in the first place - keep reloading for that critical hit.

Except I don't know a single person who will reload for a relatively minor thing like attack roll, and attacking someone and getting the exact same result from subsequent attack is just plain stupid. Hashing with #of attempt as well would prevent that, but I'm not entirely comfortable with such determinism.

What do you think of delaying consequences whenever possible and punishing reloads when there is a game in progress with hidden negative modifiers?

 

[soggie]

Except I don't know a single person who will reload for a relatively minor thing like attack roll, and attacking someone and getting the exact same result from subsequent attack is just plain stupid. Hashing with #of attempt as well would prevent that, but I'm not entirely comfortable with such determinism.

What do you think of delaying consequences whenever possible and punishing reloads when there is a game in progress with hidden negative modifiers?

I think maybe this is a misconception on what I'm trying to achieve, sorry about that.

It doesn't mean that all your attack rolls will yield the same result. First, we look at the random number array generated upon seeding:

5 <-- first attack roll, success
6 <-- second attack roll, success
8 <-- third attack roll, success
9 <-- fourth attack roll, success
2 <-- fifth attack roll, FAIL

Upon failure, the character reloads on the forth attack roll, hoping that the fifth attack roll will yield different results.

However, using the pre-seed function, the fifth attack will ALWAYS fail, regardless of how many times he loaded. The only way to change this destiny is to increase his weapon skill BEFORE rolling the fifth attack roll, which REDUCES the difficulty that he is rolling against.

 

[Awor Szurkrarz]

People reload after failed skill checks and attack rolls ?

 

[soggie]

People reload after failed skill checks and attack rolls ?

I do. Because succeeding is more fun than failing. If only failing is equally interesting...

 

[Awor Szurkrarz]

What's the point of having skill checks in the first place, then?
You could simply succeed automatically or if you want challenge, simply test player's skills.

 

[DraQ]

People reload after failed skill checks and attack rolls ?

I do. Because succeeding is more fun than failing.

But failing is more interesting than reloading, unless it really breaks something badly.

If only failing is equally interesting...

That's the first problem, fiddling with RNG seeds won't make the failure interesting. While different seeds have their uses, I don't think making the rolls deterministic is a good one.
First, it can potentially break the game, if for example player suffers from a bad streak during a plot-critical battle.
Second, it becomes less viable the more complex the system becomes because in a very complex system, the knowledge of determinism becomes a good weapon against it on its own - for example, if I could magically fortify my skills, I would know exactly when I don't have to, if I had a party, I would know when to alternate between characters to ensure unreasonably high success rate, etc.
Third, it may cause nonsensical behaviour if it's used to balance the situations when skill should logically be usable repeatedly until successful.

The first thing is to make the game actually accomodate failure and make it interesting. The second is dissuading reloading - delayed consequences, bad luck when reload is detected (notice that if player exits and restarts the game to avoid it, he does a fine job punishing himself on his own, and will still try to limit the annoyance to minimum), etc.

To sum it up - the game should be as much of an asshole as possible, but try to throw player a rope whenever he ends up in grave trouble, unless said trouble is entirely self inflicted.

 

[soggie]

People reload after failed skill checks and attack rolls ?

I do. Because succeeding is more fun than failing.

But failing is more interesting than reloading, unless it really breaks something badly.

If only failing is equally interesting...

That's the first problem, fiddling with RNG seeds won't make the failure interesting. While different seeds have their uses, I don't think making the rolls deterministic is a good one.
First, it can potentially break the game, if for example player suffers from a bad streak during a plot-critical battle.
Second, it becomes less viable the more complex the system becomes because in a very complex system, the knowledge of determinism becomes a good weapon against it on its own - for example, if I could magically fortify my skills, I would know exactly when I don't have to, if I had a party, I would know when to alternate between characters to ensure unreasonably high success rate, etc.
Third, it may cause nonsensical behaviour if it's used to balance the situations when skill should logically be usable repeatedly until successful.

The first thing is to make the game actually accomodate failure and make it interesting. The second is dissuading reloading - delayed consequences, bad luck when reload is detected (notice that if player exits and restarts the game to avoid it, he does a fine job punishing himself on his own, and will still try to limit the annoyance to minimum), etc.

To sum it up - the game should be as much of an asshole as possible, but try to throw player a rope whenever he ends up in grave trouble, unless said trouble is entirely self inflicted.

I agree on the bolded part. Like I mentioned previously, I plan to implement a failure mechanism where failing a skill challenge does not mean the player is set back on a particular task. Instead, most of the time it will open up different aspects of the storyline, leading to a completely different gameplay experience compared to what would have transpired if the action had been successful initially.

Take for example, in JA2 you surrender. Instead of game over, you are taken to a prison and that opens up a completely different branch on the plot.

The idea is to discourage the player from thinking that failing a skill check is equivalent to being penalized with an inferior gaming experience.

Third, it may cause nonsensical behaviour if it's used to balance the situations when skill should logically be usable repeatedly until successful.

Not sure I got this one right. Can you give some example scenarios?

 

[DraQ]

Not sure I got this one right. Can you give some example scenarios?

About any situation in which you can re-attempt some task uninterrupted and in which you can count on eventually succeeding - shooting an object off a tree with a bow, (barring critical failures) lockpicking or spellcasting if the success is actually possible with your skill level, etc.

 

[soggie]

Not sure I got this one right. Can you give some example scenarios?

About any situation in which you can re-attempt some task uninterrupted and in which you can count on eventually succeeding - shooting an object off a tree with a bow, (barring critical failures) lockpicking or spellcasting if the success is actually possible with your skill level, etc.

Which shouldn't be a problem whether it is pre-seeded or not, isn't it?

You shoot the first arrow, and the current sequence of random numbers denote that you fail. So you take another shot, which will use the next number in the sequence, which might mean that you succeed in the shot.

Now compared to this scenario: You try to hack a computer, which will lock you out after 3 tries. You save the game before attempting, and then fail on all 3 tries. You don't get to try again if you reload the game - you just have to live with the fact that you fucked up the hacking attempt and have to find other ways into the vault-of-infinite-knowledge.

Reverting to my OP, I need to clarify that the pre-seed mechanism is to prevent players from reattempting tasks that has a failure penalty scenario. Shooting an apple from a tree does not have a failure penalty - the apple is there whether you shoot it or not. But failing to hack a computer within the limited number of retries does have a penalty - you are locked out of the system and guards are called in.

It is the latter scenario that I want to prevent players from meta-gaming, where reloading a previous save allows them infinite chances at failing the task until they succeed.

 

[crufty]

would it be better to have a single save, and not let players reload?

 

[soggie]

would it be better to have a single save, and not let players reload?

You mean like Diablo?

I think reloading save games to explore different methods of solving the same problem is a valid way of utilizing said mechanism. The only thing I think is an abuse of this mechanism is to utilize it to force a success on a normally impossible task for the player's character.

Or did I get it wrong?

 

[crufty]

pretty sure most people use saves to retry failures.


maybe chapter / milestone saves?

 

[Awor Szurkrarz]

How about cutting out all the filler combat and keeping the game length reasonable with a reasonable branching storyline, so that it could be replayed with many characters?

 

[DraQ]

would it be better to have a single save, and not let players reload?

Obligatory ironman is not necessarily a good idea if the game isn't a roguelike. MMO style resurrection (see Diablo 2) is even worse.

 

[crufty]

would it be better to have a single save, and not let players reload?

Obligatory ironman is not necessarily a good idea if the game isn't a roguelike. MMO style resurrection (see Diablo 2) is even worse.

true though seems like that is what op is going for though?

why not keep an action stack as part of the save. So at any point in time, player can unwind back to some other earlier point, an improvement over save, die, reload (though net effect is identical).

this would tie into a consistent rng. if i take an action, undo, then repeat action, I should always get the same result....maybe?

party gets in bar fight w/orc. fighter goes to attack an orc...critical fumble, fighter chops off own arm. player undo's to pre-bar fight. this time he positions mage in a better spot, fires off a good spell, orc is near death. fighter goes in for kill:

does he still chop off own arm (the event is: fighter attacks orc) or is it a new event (fighter attacking damaged orc).

edit: the more i think about it, the more i like. perhaps the event list is wiped clean after level up...level 1 rogue picks a lock...fails. ALWAYS fails. Until level up...try again. Success! Maybe. Or failure...

 

[J1M]

Didn't read the thread. Best solution to this for skill systems is: you only gain a skill-up on failure.

Example: pick pocketing. If you succeed, you get an item. If you fail, you get a skill point and cannot pick that person again.