alternative to hp0? and dead?

I'm looking for a way to set up an afterlife section of the game, and have been met with mixed results.

I've added a flag called "@ghost" similar to the @immortal, it's true or false. It starts off false, and when you die, it is set to true.

When you die in my game, instead of going to game over, you go to an option screen that allows you to continue or end the game. If you end the game, then it acts normal. If you continue,

your character appears on the Ghost Map with partial transparency (like a ghost).

For now, I've got the actors set to 1 hit point while there, so I can at least test out the functions.

I have a stat that's basically @willpower, and the idea is you don't "die" as a ghost until this hits zero, at which point you continue back at "start" in the ghost map, and since all the cool stuff including how to become alive again is no where near the "start' of the map, you obviously don't want to keep dying, any more than someone playing Super Mario wants to keep getting sent back to level 1-1.

so here's the dilemma:
I have @ghost
and @willpower

and I want it to say "if @ghost is true, then in battle, check @willpower, NOT @hp for dying"

This of course will make sense in the ghost world because most of their attacks are supposed to do willpower (i.e. psychic) damage.

Otherwise, the @willpower stat is just a clone of Spell points.

in Game Party, I made some changes in the all_dead? method

Code: [Select]

  def all_dead?
    # If number of party members is 0
    if $game_party.actors.size == 0
      return false
    end
    # If an actor is in the party with 0 or more HP
    for actor in @actors
     
  #============================   
      if actor.ghost == true
        if actor.willpwer > 0
          return false
        end
      elsif actor.ghost == false
        if actor.hp > 0
          return false
        end
      else
        return false
      end
  #============================   
    end
    # All members dead
    return true
  end


this appeared to have results.

this was used in conjunction with these changes in game battler 1:

Code: [Select]

def dead?
    #return (@hp == 0 and not @immortal)
    return (@hp == 0 and not (@ghost or @immortal))
  end
  #--------------------------------------------------------------------------
  # * Decide Existance: similar to having no hp
  #--------------------------------------------------------------------------
  def exist?
    #return (not @hidden and (@hp > 0 or @immortal))
    return (not @hidden and (@hp > 0 or @ghost or @immortal))
  end


basically exploiting the immortal code for something by itself creates a weird effect where if all your hp = 0 you die, but if you combine it with the 'if ghost...check willpower' effect in my previous post, it acts very differently.

I combined it with

Code: [Select]

if @battler.ghost == true
          self.opacity = 100
        else
          self.opacity = 255
        end


in Sprite Battler, which makes the ghosts in your party semi-transparent during battle. I'll probably do a similar effect for Sprite Character, although I plan on linking "through" to the opacity and strength = nil. That's part of of the longer thinking process: ghosts get set to N/A stamina, and instead of seeing "HP 550/550" or whatever, when they are ghosts, it should display "Willpower 550/550" etc. When you see stamina (a new stat I have governing hit points), it should be set to N/A or 0.

I've got to find a way to make the logic work for the 'I don't have a stamina stat, therefore I don't get effected by Stamina dependent effects". So far, the zero hit points thing just means I can take damage all day long with no result - the damage displays, but the actor never falls below 0 hp.

The strength thing is going to use a similar idea - your physical strength as a floaty ghost is N/A so you can't lift anything, including weight based equipment, so things like your armor and weapons get dropped wherever you die/left with your corpse. (cant take it with you). In addition to figuring out how to wipe inventory, I should probably make an exception to the rule like soul-linked, or whatever, or otherwise make spirit items akin to Yuyuhakushu.

The most dramatic effect with strength N/A is going to be passing through doors, but I haven't yet created strength based doorways, and many doorways are just transport points, making the idea kind of quirky and 'common event' based at best. Ok im babbling now. 

it took a while to figure out, but I eventually figured out how to use items to turn actors back into mortals after being ghosts. I used a tonic effect as shown below, in Game battler 3:

Code: [Select]

  if hit_result == true
      # Calculate amount of recovery
      if ((item.scope == 5 or item.scope == 6) and self.hp == 0)
        if self.ghost == true
          self.ghost = false
        end
      end
      recover_hp = maxhp * item.recover_hp_rate / 100 + item.recover_hp
      recover_sp = maxsp * item.recover_sp_rate / 100 + item.recover_sp
      if recover_hp < 0
        recover_hp += self.pdef * item.pdef_f / 20
        recover_hp += self.mdef * item.mdef_f / 20
        recover_hp = [recover_hp, 0].min
      end
 

I've also been able to attack the willpower of the actors, but only through common events triggered by skills on enemies, and only a specific actor, such as

Code: [Select]

$game_actors[2].willpower -= 25


ok, so i started calling @willpower @resolve because it takes up less text space on the screen,

[game battler 3]

Code: [Select]

    # If hit occurs
    if hit_result == true
      # If physical attack has power other than 0
      if skill.power != 0 and skill.atk_f > 0
        # State Removed by Shock
        remove_states_shock
        # Set to effective flag
        effective = true
      end
      # Substract damage from HP/Resolve if 20: can be expanded for stat attack
      # needs to be a for-loop to check for '20'
      if skill.element_set[0] == 20
      last_rp = self.resolve
        self.resolve -= self.damage
        effective |= self.resolve != last_rp 
      else
        last_hp = self.hp
        self.hp -= self.damage
        effective |= self.hp != last_hp
      end


and I created an element #20 titled "spirit attack", and made a skill called "soul blade" and stuck it on one of the monsters in the ghost world. Basically, any skill with the 'spirit attack" element checked will do resolve/willpower damage instead of hp.

It works, but I then noticed something odd about the combat. When the characters fall below 0 resolve/will, they don't "poof" out, and in fact they keep acting, until the last guy goes below 0.

This is clearly the kind of thing I anticipated when making this thread, and I'm kind of glad I kept coming back here with progress checks, because the errors I'm seeing after all this work are the same as the subject title.   

ok, so i fixed more problems,

Code: [Select]

  #--------------------------------------------------------------------------
  # * Decide Incapacitation: makes character NOT a battler - clone for ghost?
  #--------------------------------------------------------------------------
  def dead?
    #return (@hp == 0 and not @immortal)
    return (@hp == 0 and not ((@ghost and @resolve > 0) or @immortal))
  end
  #--------------------------------------------------------------------------
  # * Decide Existance: similar to having no hp
  #--------------------------------------------------------------------------
  def exist?
    #return (not @hidden and (@hp > 0 or @immortal))
    return (not @hidden and (@hp > 0 or (@ghost and @resolve > 0) or @immortal))
  end



but I haven't figured out how to prevent the resolve/willpower attacks from bringing the score into the negatives.

Code: [Select]

  #--------------------------------------------------------------------------
  # * Get Resolve
  #--------------------------------------------------------------------------
  def max_resolve
    willpower = x99(self.mdef, willpower_check)
     n = [[willpower, 1].max, 999999].min
    return n
  end
  #--------------------------------------------------------------------------
  # * Change Resolve
  #     resolve : new Resolve
  #--------------------------------------------------------------------------
  def resolve=(resolve)
    @resolve = [[resolve, max_resolve].min, 0].max
  end


there's actually no logical reason for the number to go below 0...IF hp doesn't go below 0, which I've never seen it do.

edit: not quite...

fixed some problems, temporarily using this,

Code: [Select]

        self.damage = [self.damage, self.resolve].min



but then i noticed I still had ghosts attacking when they were at 0 resolve and not visible on the screen. Which means i probably turned off their visibility some how, but not their existence in terms of attacking.

I think its this part that's screwing me over,

Code: [Select]

  #--------------------------------------------------------------------------
  # * Random Selection of Target Actor
  #     hp0 : limited to actors with 0 HP
  #--------------------------------------------------------------------------
  def random_target_actor(hp0 = false)
    # Initialize roulette
    roulette = []
    # Loop
    for actor in @actors
      # If it fits the conditions
      if (not hp0 and actor.exist?) or (hp0 and actor.hp0?)
        # Get actor class [position]
        position = $data_classes[actor.class_id].position
        # Front guard: n = 4; Mid guard: n = 3; Rear guard: n = 2
        n = 4 - position
        # Add actor to roulette n times
        n.times do
          roulette.push(actor)
        end
      end
    end
    # If roulette size is 0
    if roulette.size == 0
      return nil
    end
    # Spin the roulette, choose an actor
    return roulette[rand(roulette.size)]
  end
  #--------------------------------------------------------------------------
  # * Random Selection of Target Actor (HP 0)
  #--------------------------------------------------------------------------
  def random_target_actor_hp0
    return random_target_actor(true)
  end


but the syntax is unfamiliar and confusing to me. If i understood how statements like

Code: [Select]

def random_target_actor(hp0 = false)


(if something is in parenthesizes does "==" mean the same as "=")


and

Code: [Select]

  return random_target_actor(true)


(wait.. what's true?)

worked, and finally, this one...

Code: [Select]

      if (not hp0 and actor.exist?) or (hp0 and actor.hp0?)


which loses me completely because I thought hp0 WAS actor.hp0?,

then if i understood these things, I could probably add in the exceptions for ghost/resolve/willpower.

then again, I'm just guessing as to why I have to wait for my ghost actors to get hit before they can act. Whatever is triggered when they are hit is what I have to trigger when they become ghosts.

So i figured out the reason I was not able to act until after I was hit was some obscure rule about being released from a state after being hit to reset to 1 hp.  So I added the the actor.states.delete(1) to my loop on entering the ghost world as shown below:

Code: [Select]

  for i in 0...$game_party.actors.size
      actor = $game_party.actors[i]
      actor.states.delete(1)
      actor.ghost = true
      actor.resolve = actor.max_resolve #or 0 or 1...
    end


point is, it means I no longer have to wait until I get hit to move. Unfortunately, now I have to face two other problems that were not as obvious.

First, when my sprites 'die', i.e. their resolve hits 0, they are not really 'dead' because they keep fighting, but when all of them are 'dead' - i.e. at 0 will/resolve, then the game over is triggered normally. this is actually very similar to the immortal glitch where your immortal guys keep fighting when dead until all your guys die.

Second, there's the issue of doing 9999 or whatever Resolve damage and having it zero out, rather than putting your actors in the negatives. I have it zero out before the damage is displayed, which is weak. So you see a guy with 6 resolve take 6 damage from something like a doom god or whatever and you're like "wow that was weak." because you didn't actually get to see the awesome string of 9s you were expecting.

The first issue is more detrimental than the second, which is more cosmetic.

I just have to make sure the ghost world code is fully functional before implementing other aspects like spirit linked weapons, summoning, and so on.

but the syntax is unfamiliar and confusing to me. If i understood how statements like

Code: [Select]

def random_target_actor(hp0 = false)


(if something is in parenthesizes does "==" mean the same as "=")

What you have there is a default value in the event that particular argument isn't passed a variable when it the method is called. In that particular example, you can call random_target_actor as it is, or random_target_actor(variable). Obviously with that you want a true or false value passed in (so, random_target_actor(true) or random_target_actor(false)). It isn't a check to see if something equals it or not.

Basically, you can read it is:

The variable hp0 implicitly contains the object false unless I am explicitly told otherwise, in which case hp0 is of the passed in object.

The problem you get with these, though, is that Ruby doesn't assign the usual types to variables. There's not such thing as INT, BOOLEAN or CHAR variables. They are all objects. Even true or false are objects (of the TRUECLASS and FALSECLASS objects respectively). So you need to be careful. You could easily pass random_target_actor an integer or a string and it will be happy enough. It is a good idea to check that the argument taken is either a true or false value and flag up an issue if its neither of those.

and

Code: [Select]

  return random_target_actor(true)


(wait.. what's true?)

'true' is the object value (remember, true is an inbuilt object of the type TRUECLASS) so what you are doing is returning the result of the method random_target_actor where hp0 (in the method random_target_actor) is given the value of true. It's almost as if the method was random_target_actor(hp0 = true) instead of hp0 = false.

So, basically, what true is, is the given value of hp0 at the time that method is invoked.

worked, and finally, this one...

Code: [Select]

      if (not hp0 and actor.exist?) or (hp0 and actor.hp0?)


which loses me completely because I thought hp0 WAS actor.hp0?,

then if i understood these things, I could probably add in the exceptions for ghost/resolve/willpower.

I don't know what the method actor.hp0? returns so it's hard to really know whether they are the same or not. Usually, a method with the '?' at the end signals to the programmer that the value returned will be a true or false value. Because of the way that it is used I can assume this is the case here.

So, what we are asking in our condition is this:

Code: [Select]

if (not hp0 and actor.exist?) or (hp0 and actor.hp0?)


The first pair of parenthesis:

not hp0 : is another way of saying hp0 == false
actor.exist? : checks if our actor actually exists in the first place.

Together this is:

hp0 was given a false value and our actor exists.

The second pair:

hp0 : is another way to say hp0 == true
actor.hp0? : logic would assume it means does the actor have 0 HP left? (true or false)

so together that is:

hp0 was given the value true and the actor has 0HP left.

That statement as a whole, then:


IF

hp0 is false and the actor exists?

OR

hp0 is true and the actor's HP is 0

THEN do whatever...


I don't know how much that'll help, but that's what is going on there.

It sounds like you're having fun with this. It also seems like it might have benefited from a bit of planning out (I don't know how much you might have done, so I like to assume none).

I'm guessing that the problem is centred around the default system of "HP=0 means death and game over" business? If so, it might have been worth thinking of an alternative that left "HP=0 means death and game over" by implementing a second kind of HP that is used up first and leaving the default HP version for the ghost world (which I assume dying in there really is death and thus the rule "HP=0 means death and game over" remains true as opposed to what you have).

Perhaps if you write up a proper concept and goal thing, as well information on what the stats are and how they are used/depleted etc, I can maybe help work something out.

the problem I'm running into is a lack of available clarity in determining whether or not an actor is alive or dead. There's exist?, all_dead?, dead?, hp0?, zero_hp and finally actor.states[1], but there's also hidden? which I'm not too sure about and immortal, which is where I began with it.

My original objective:

Take the binaries immortal and dead? as true/false
and the hp variable as 0-99999+

make a variant ghost as true/false
and resolve variable as 0-99999+

Basically when ghost is true, hp damage has no meaning and resolve damage is all the matters. I must admit this stuff was originally envisioned for a single player, rather than party, in an MMO. So when it was planned the first time, the mechanic was very first person, and didn't take into consideration a whole party, or a single player with multiple actors under their control.

i don't understand how answering what my plan was solves my "dead people are still getting actions" issue.

You would think with this arrangement:

Code: [Select]

def dead?
    return (@hp == 0 and not ((@ghost and @resolve > 0) or @immortal))
  end
  #--------------------------------------------------------------------------
  # * Decide Existance: similar to having no hp
  #--------------------------------------------------------------------------
  def exist?
    return (not @hidden and (@hp > 0 or (@ghost and @resolve > 0) or @immortal))
  end
  #--------------------------------------------------------------------------
  # * Decide HP 0: if 0 get no actions - may wish to clone for @resolve
  #--------------------------------------------------------------------------
  def hp0?
      return (not @hidden and @hp == 0)
  end
  #--------------------------------------------------------------------------
  # * Decide if Command is Inputable
  #--------------------------------------------------------------------------
  def inputable?
    return (not @hidden and restriction <= 1)
  end
  #--------------------------------------------------------------------------
  # * Decide if Action is Possible
  #--------------------------------------------------------------------------
  def movable?
    return (not @hidden and restriction < 4)
  end


the only difference would be if their resolve hit 0 while a ghost, they would be dead.


Here's my ultimate question:

Where is the "actor gets skipped during command selection if hp is 0" script located?

ok, after some tampering, this is what I've concluded so far:

Code: [Select]

def dead?
    return (@hp == 0 and not ((@ghost and @resolve > 0) or @immortal))
  end


detects whether or not the enemy attack animations appear on your sprites, and whether you have actor sprites in battle for the attacks to appear on. Does not prevent actions from enemies or actors.

meanwhile

Code: [Select]

def exist?
    return (not @hidden and (@hp > 0 or (@ghost and @resolve > 0) or @immortal))
  end
 

is used by enemies to detect actors. if disabled, the enemies will not gain any actions but the actors can continue getting full actions against enemies.

this tells me that neither of these governs which actors get actions. That is clearly governed by something else, but I don't yet know what it is.

Looking at Scene_Battle, it appears that an actor can have a turn unless the actor being processed is not inputable? It basically loops over the actors until one of them is inputable?

So you need to make sure that inputable? contains something to do with Resolve being 0.

Because I'm not a fan of having too many logical statements together, I like to split them up; it's far easier to read.

Code: [Select]

def inputable?
  state = (not @hidden and restriction <= 1)
  if self.is_a?(RPG::Actor) and self.ghost
     state = (state and @resolve > 0)
  end
  return state
end


Thus, by default we want to set the outcome to the first condition (not being hidden and being able to move). Then, for Actors who are ghosts only, we want to make a change only if state was true (that we aren't hidden and we can move) and that our resolve is greater than 0. If we couldn't move as a ghost (due to paralysis etc), then it doesn't matter what our resolve is because we can't actually move anyway. If you prefer you could write it as:

Code: [Select]

def inputable?
  state = (not @hidden and restriction <= 1)
  if self.is_a?(RPG::Actor) and state
     state = (@ghost and @resolve > 0)
  end
  return state
end


It's no different but might be easier to see what is happening: don't go into the IF statement if the first line (not @hidden and restriction <= 1) is not true.

That should skip that actor's turn if they can't act or are in the ghost world and they have no resolve left. It is untested, so let me know how it goes.

For the record, I really hate RMXP. The original scripts in the editor are so confusing compared to VX to read.

Looking at Scene_Battle, it appears that an actor can have a turn unless the actor being processed is not inputable? It basically loops over the actors until one of them is inputable?

So you need to make sure that inputable? contains something to do with Resolve being 0.

Because I'm not a fan of having too many logical statements together, I like to split them up; it's far easier to read.

Code: [Select]

def inputable?
  state = (not @hidden and restriction <= 1)
  if self.is_a?(RPG::Actor) and self.ghost
     state = (state and @resolve > 0)
  end
  return state
end


Thus, by default we want to set the outcome to the first condition (not being hidden and being able to move). Then, for Actors who are ghosts only, we want to make a change only if state was true (that we aren't hidden and we can move) and that our resolve is greater than 0. If we couldn't move as a ghost (due to paralysis etc), then it doesn't matter what our resolve is because we can't actually move anyway. If you prefer you could write it as:

Code: [Select]

def inputable?
  state = (not @hidden and restriction <= 1)
  if self.is_a?(RPG::Actor) and state
     state = (@ghost and @resolve > 0)
  end
  return state
end


It's no different but might be easier to see what is happening: don't go into the IF statement if the first line (not @hidden and restriction <= 1) is not true.

That should skip that actor's turn if they can't act or are in the ghost world and they have no resolve left. It is untested, so let me know how it goes.

For the record, I really hate RMXP. The original scripts in the editor are so confusing compared to VX to read.

what you have here doesn't work at all, but it doesn't not crash either, it just acts normally. Based on it, I got a hint though, which brings us one step closer (but not fixed). I made this:

Code: [Select]

  def inputable?
    if @ghost == true
     return (not @hidden and @resolve > 0)
    else
     return (not @hidden and restriction <= 1)
    end
  end


which has the effect of allowing only living actors to get new commands, BUT existing commands already input before acting still fire off after resolve hits 0. So basically, whatever attack was programmed in before you got killed, still goes off. The animation for the attack appears even though your actor sprite is gone.

Yeah, I wasn't sure if it would work, but it's getting there. Like I said, I had XP simply because it has a different way of processing turn orders to VX.

So, it seems we need to remove the action from whatever handles those when someone's resolve is 0. I'll see what the code looks like, try to figure something out.

Edit: Scene_Battle 4 is the place to look into.

Edit again:

Code: [Select]

#--------------------------------------------------------------------------
  # * Frame Update (main phase step 1 : action preparation)
  #--------------------------------------------------------------------------
  def update_phase4_step1
    # Hide help window
    @help_window.visible = false
    # Determine win/loss
    if judge
      # If won, or if lost : end method
      return
    end
    # If an action forcing battler doesn't exist
    if $game_temp.forcing_battler == nil
      # Set up battle event
      setup_battle_event
      # If battle event is running
      if $game_system.battle_interpreter.running?
        return
      end
    end
    # If an action forcing battler exists
    if $game_temp.forcing_battler != nil
      # Add to head, or move
      @action_battlers.delete($game_temp.forcing_battler)
      @action_battlers.unshift($game_temp.forcing_battler)
    end
    # If no actionless battlers exist (all have performed an action)
    if @action_battlers.size == 0
      # Start party command phase
      start_phase2
      return
    end
    # Initialize animation ID and common event ID
    @animation1_id = 0
    @animation2_id = 0
    @common_event_id = 0
    # Shift from head of actionless battlers
    @active_battler = @action_battlers.shift
    # If already removed from battle
    if @active_battler.index == nil
      return
    end
    # Slip damage
    if @active_battler.hp > 0 and @active_battler.slip_damage?
      @active_battler.slip_damage_effect
      @active_battler.damage_pop = true
    end
    # Natural removal of states
    @active_battler.remove_states_auto
    # Refresh status window
    @status_window.refresh
    # Shift to step 2
    @phase4_step = 2
  end


Maybe you can put something in here to stop them from executing their set turn if their resolve is 0.

Also, there's a few cases where checks against HP > 0 are made for things like slip damage, that may need changing (if not already done so) to affect resolve when 'ghost' too.

I've been looking into Scene Battler 4 now and again, but I can't find the place where it says "if you have 0 hp after being hit, you lose your action". If I knew where and what that was, I could insert "oh yeah, and if ghost == true and resolve not > 0... then no actions" as well. But I only see an assumed action cycle like attacking, skills, item, and guard.

It's probably something that's called in Scene_Battle but is handled elsewhere. I couldn't see anything that stood out, but I didn't take a real close look into the code. Maybe something in Game_Battler handles it? I'll take a good look later.

It's probably something that's called in Scene_Battle but is handled elsewhere. I couldn't see anything that stood out, but I didn't take a real close look into the code. Maybe something in Game_Battler handles it? I'll take a good look later.

I believe the problem might have been solved. I tried this:

in scene battle 4:

Code: [Select]

  def update_phase4_step2
    # If not a forcing action
    unless @active_battler.current_action.forcing
     
     
      if @active_battler.ghost == true
        if @active_battler.resolve == 0
          $game_temp.forcing_battler = nil
          # Shift to step 1
          @phase4_step = 1
          return
        end
      end
#... [the rest of the code is normal after here]


it could probably be condensed into a single if statement, but I suck at condensing things I barely understand.

Edit: my next step is going to be making sure multiple attack forms do resolve damage including regular "attacks" of certain enemies. Once that's done, I can work on the Planescape effect of splitting up the adventuring party into different planes of existence depending on their karma/alignment.

I've been thinking of using a check on animations to see if they do resolve damage, but I'd like a more effective way of making monsters do resolve damage than just skills. It's kind of irritating that I have to wait for 2 minutes of physical attacks to get a couple of resolve attacks in with a skill during testing.