Variant The Party's Leader

Turn based RPGs have had years of existence; there are one character RPGs, like Diablo, Ever Quest, and Party RPGs like the Final Fantasies, Earth Bound and so on. In Party RPGs, most of the times (if not always) there is one character in particular who is, at least, a bit more important to the game's plot than the rest (cough Cloud), the Lead Character. What I'm about to propose is to modify the regular combat system rules to create one where the Leader's presence is what really matters; a turn based combat system I call RUSH.

To explain Rush, lets take the old Combat Queue out of the equation, and the party's size, is not importat at the moment. The fight begins and its the player's turn, there is no need to select the Leader since its traits and chance made it act first, and its going to be facing one of its Foes; both parties will be ignore at the moment, so imagine them busy with each other or running around the battlefield. The UI for selecting actions appears, the player makes its choice and it is executed at once, with no waiting nor need to know what the rest of the cast will do, the player just needs to focus on making that ability play out the best way possible.

Rush attack successful and will continue...

If successful then the Leader has the chance to use another ability, repeat the same one, or even let a different party member into action, over and over again, even if the Foe is downed; however, every time an action is played, the following ones get harder and harder to perform, until the player makes a bad roll and the ability is played out poorly, allowing the defending Foe to start its turn, if any is still available.

The Follow up!, a second action that can go on and on...

While being attack might seem harsh, the defender also has the chance to play against the ability, trying to outperform the attacker, not only to reduce the attacks effects but also, if the defender is good enough, its more likely that its turn might come up sooner. Now in the awesome case that both performed equally well, then a Duel kind of interaction must be played out, with a nice handicap on the attacker in the same way its actions get harder to pull, to check whose turn will it be.

Who will Rush whom this time..

This is it for now, I'll keep posting on the subject...
Thanks Pityu777 for the art!

Variant for Hit Points

My take on Hit Points. All video games make use of HP, characters get a value to represent how much damage they can take, and that is it. Maybe it seems simple for players, or everyone is just used to this.


Making Hit Points an integral part of the Action System, not only as a representation of a Character's "life" but more like the "Stamina Cost" required to be on combat and use any kind of actions, whether it is a special attack, asking for assistance, a defense opportunity; it is an interesting idea that I've had for a long time, that can by used for any kind of game (with characters). 


To balance the need for this costs, Regeneration is applied at the beginning of every turn/cycle. The ability to recover Stamina must be tied to one of the Character Traits, allowing for some Character to improve recovery, while a different Trait provides improved Stamina (meaning more stamina). For some reason, I've tied High Regen to Spell Casters and More Stamina to the Warrior kind, leaving Rogue style characters in the middle.

In my opinion, there are two ways that the Stamina/Regeneration system can be represented, and it is a duck or bunny situation here, the game can use character traits to either 1.-improve the stamina and regeneration- or, 2.-reduce all stamina costs-. It would be on the developer's side to decide what could be better to implement, so lets expand on this.

1. Traits that Increase Stamina/Regeneration; in this case, the values that are increased are those for the character, meaning that they get more max stamina, more regeneration per turn/cycle, while all actions have a fixed cost that never changes. This method uses real values, i.e. rice skeletal archer costs 10.
2. Traits that Lower Costs, in this scenario the action's costs get reduced as the character's level improves, and the characters trait's values are fixed; so instead of using a real value for representation, the best option is to use percentage, i.e. Cleave costs 2%.

The use of this Self Healing System, allows some interesting situations for players to experience, some examples can be:

• the abuse of a character's complete stamina in a Rush (*link next)
• to have the Leader rice after being defeated
• involving more characters to pay for the cost of another character's ability
• your pick here....

Turn based RPG Challenge

I stop with the Javacipt course from Mozzilla's U, since I took some of Code Academy's classes, but now it's time to write a bit about Game Design.

I took up a Came Carrier Guide challenge about old style RPGs combat systems, without posting it, and since then I have been changing this Google Doc about it constantly, but I believe that it's time to start sharing some lines from it.

Today lets begin with the idea at hand, a Turn Based Combat System where the player's party is a Group with a Leader. Most TBRPGs have a party but aside from the Leader having a special place on the game's main plot, it is no different from any other of the party members in combat, for the player that is. There are many examples of this in my SNES background as a Gamer, from all the Final Fantasys with Terra or Cloud as Leaders and Chrono Trigger where all characters had some sort of special interactions between them and Chrono, the Leader.

The following posts will develop more about the idea at hand.

The structure of FOR

As I read along the chapter 4, some things came into my consideration... considering the FOR statement.

Lets look at this piece d'code:

var mailArchive = {0: "Dear nephew, ... (mail number 1)",
                   1: "(mail number 2)",
                   2: "(mail number 3)"};

for (var current = 0; current in mailArchive; current++)
  print("Processing e-mail #", current, ": ", mailArchive[current]);

In this FOR the control variable current is located IN mailArchive, since the object has the values 0, 1, 2, and so on to be looked for, however when working with arrays the book gives us this code:

 var mailArchive = ["mail one", "mail two", "mail three"];

for (var current = 0; current < mailArchive.length; current++)
  print("Processing e-mail #", current, ": ", mailArchive[current]);

The control here is now handled by current being minor than the size of mailArchive, because now it does not have the values that where used with the object.
So it is important to note the different ways you can control a lop with different kinds of data.

Ex. 3.2 Inline...

Write a function greaterThan, which takes one argument, a number
>>function GreaterThan(argument) {

and returns a function that represents a test
>>  return function test(number) {

It returns a boolean: true if the given number is greater than the number that was used to create the test function, and false otherwise.
>>    return number > argument;
>>  };
>>}

When this returned function is called with a single number as argument
>>var gt10 = GeaterThan(10);

For this part I checked the answer...
>>show (gt10(9));

Lexical Scoping, nice!

First, writing about recursiveness, there is nothing more recursive than * power (base, exp -1), so it goes and goes until it reaches 0 and multiplied by 1. Too bad for the speed disadvantage of calling functions over and over...

Now, what can I say about Lexical scoping, seems great but its a little crazy to grasp at once, so here is my try at that using the makeAddFunction example.

makeAddFunction is created with one argument amount, and inside is just a function add with another argument number.
add returns the value of numer+amount and then makeAddFunction returns the result of the add function.
Here comes the important bit, the creation of 2 variables that will act as variations of the makeAddFunction, so we have the addTwo and addFive variables, both take the type makeAddFunction, one with one it's argument as 2 and the other as 5 (hence their names), this arguments are the values of  amount.
At the end they call this variables, with show, each with an extra argument, that will be passed to the add function inside makeAddFunction.

So we get this :   "show (addtwo(1) + addFive(1))"

that at the end is
"show (makeAddFuntion(2) add(1) + makeAddFunction(5) add(1))"

and this would be how it works, the value of addTwo/Five goes to number, because the makeAddFunctions had their arguments already given, in amount, while the variables addTwo/Five where created.

This way the programmer doesn't need to say "hey by the way, this little number at the end of addTwo, is the variable number that is inside the function, ok Js? good..." having the ability of getting a variation of functionality with less lines of code.

next the ex...

Functions...

So the 3rd chapter  is about functions, I describe them as small programs inside a program, you "summon it" by its name and give them the information they need in order to finish their job...

The simplest example would be the addition so instead let me tell you the subtraction the function will be named "sub" and in order for sub to subtract it needs the 2 values to subtract, so you tell sub that you need to take 3 from 9, and then sub will tell you it is 6.

Functions are what libraries are made of, a bunch of functions for specific works, like OpenGL for polygon graphics, OpenAL for sound, most languages have a Math library for heavy mathematical calculations, also another for network connections and so on.

The idea of Functions is not to copy-paste so much code, but just to call it every time you need to make that job, making the program jump to look for that functionality.

The Ex. 3 from the book is done like this:

function absolute(value) {
  var result = 1;
  if (value < 0) result = value * -1;
  else result = value;
  return result;
}