[RMVX ACE] HOW DO I GET CHARACTERS TO SHOW THE ARE DEAD WITH SIDE SCROLL BATTLE?

Posts

Pages: 1
Hazelsoft
237
01/10/2017 03:55 PM
Hello everyone I put in the Yanfly Engine Ace - Visual Battlers v1.01 scripting for RMVX ACE but when the characters HP depletes to 0 the character is still standing how do I fix this?
This is the Yanfly script I am using:

#==============================================================================
#
# Бе Yanfly Engine Ace - Visual Battlers v1.01
# -- Last Updated: 2012.07.24
# -- Level: Easy
# -- Requires: n/a
#
# Бе Modified by:
# -- Yami
# -- Kread-Ex
# -- Archeia_Nessiah
#==============================================================================

$imported = {} if $imported.nil?
$imported = true

#==============================================================================
# Бе Updates
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
# 2012.12.18 - Added preset views and able to change direction in-game.
# 2012.07.24 - Finished Script.
# 2012.01.05 - Started Script.
#
#==============================================================================
# Бе Introduction
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
# This script provides a visual for all actors by default charsets. The actions
# and movements are alike Final Fantasy 1, only move forward and backward when
# start and finish actions.
#
#==============================================================================
# Бе Instructions
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
# To change the player direction in-game, use the snippet below in a script
# call:
#
# $game_system.party_direction = n
#
# To install this script, open up your script editor and copy/paste this script
# to an open slot below Бе Materials but above Бе Main. Remember to save.
#
#==============================================================================
# Бе Compatibility
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
# This script is made strictly for RPG Maker VX Ace. It is highly unlikely that
# it will run with RPG Maker VX without adjusting.
#
#==============================================================================

module YEA
module VISUAL_BATTLERS

#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
# - Party Location Setting -
#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
# These settings are adjusted for Party Location. Each Actor will have
# coordinates calculated by below formula. There are two samples coordinates
# below, change PARTY_DIRECTION to the base index you want to use.
#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
PARTY_DIRECTION = 6 # This direction is opposite from actual direction.

PARTY_LOCATION_BASE_COORDINATES ={
# Index => ,
2 => , #UP
4 => , #LEFT
3 => , #RIGHT
6 => , #DEFAULT RIGHT
8 => , #DOWN
} # Do not remove this.

PARTY_LOCATION_FORMULA_X = "base_x + index * mod_x"
PARTY_LOCATION_FORMULA_Y = "base_y + index * mod_y"

end # VISUAL_BATTLERS
end # YEA

#==============================================================================
# Бе Editting anything past this point may potentially result in causing
# computer damage, incontinence, explosion of user's head, coma, death, and/or
# halitosis so edit at your own risk.
#==============================================================================

#==============================================================================
# ? Бе Direction
#==============================================================================

module Direction

#--------------------------------------------------------------------------
# self.correct
#--------------------------------------------------------------------------
def self.correct(direction)
case direction
when 1; return 4
when 3; return 6
when 7; return 4
when 9; return 6
else; return direction
end
end

#--------------------------------------------------------------------------
# self.opposite
#--------------------------------------------------------------------------
def self.opposite(direction)
case direction
when 1; return 6
when 2; return 8
when 3; return 4
when 4; return 6
when 6; return 4
when 7; return 6
when 8; return 2
when 9; return 4
else; return direction
end
end

end # Direction

#==============================================================================
# ? Бе Game_System
#==============================================================================

class Game_System; attr_accessor :party_direction; end

#==============================================================================
# ? Бе Game_BattleCharacter
#==============================================================================

class Game_BattleCharacter < Game_Character

#--------------------------------------------------------------------------
# initialize
#--------------------------------------------------------------------------
def initialize(actor)
super()
setup_actor(actor)
@move_x_rate = 0
@move_y_rate = 0
end

#--------------------------------------------------------------------------
# setup_actor
#--------------------------------------------------------------------------
def setup_actor(actor)
@actor = actor
@step_anime = true
set_graphic(@actor.character_name, @actor.character_index)
setup_coordinates
dr = $game_system.party_direction || YEA::VISUAL_BATTLERS::PARTY_DIRECTION
direction = Direction.opposite(dr)
set_direction(Direction.correct(direction))
end

#--------------------------------------------------------------------------
# sprite=
#--------------------------------------------------------------------------
def sprite=(sprite)
@sprite = sprite
end

#--------------------------------------------------------------------------
# setup_coordinates
#--------------------------------------------------------------------------
def setup_coordinates
location = ($game_system.party_direction ||
YEA::VISUAL_BATTLERS::PARTY_DIRECTION)
base_x = YEA::VISUAL_BATTLERS::PARTY_LOCATION_BASE_COORDINATES
base_y = YEA::VISUAL_BATTLERS::PARTY_LOCATION_BASE_COORDINATES
mod_x = YEA::VISUAL_BATTLERS::PARTY_LOCATION_BASE_COORDINATES
mod_y = YEA::VISUAL_BATTLERS::PARTY_LOCATION_BASE_COORDINATES
@actor.screen_x = eval(YEA::VISUAL_BATTLERS::PARTY_LOCATION_FORMULA_X)
@actor.screen_y = eval(YEA::VISUAL_BATTLERS::PARTY_LOCATION_FORMULA_Y)
@actor.origin_x = @actor.screen_x
@actor.origin_y = @actor.screen_y
@actor.create_move_to(screen_x, screen_y, 1)
end

#--------------------------------------------------------------------------
# index
#--------------------------------------------------------------------------
def index
return @actor.index
end

#--------------------------------------------------------------------------
# screen_x
#--------------------------------------------------------------------------
def screen_x
return @actor.screen_x
end

#--------------------------------------------------------------------------
# screen_y
#--------------------------------------------------------------------------
def screen_y
return @actor.screen_y
end

#--------------------------------------------------------------------------
# screen_z
#--------------------------------------------------------------------------
def screen_z
return @actor.screen_z
end

end # Game_BattleCharacter

#==============================================================================
# ? Бе Game_Battler
#==============================================================================

class Game_Battler < Game_BattlerBase

#--------------------------------------------------------------------------
# public instance variables
#--------------------------------------------------------------------------
attr_accessor :moved_back
attr_accessor :origin_x
attr_accessor :origin_y
attr_accessor :screen_x
attr_accessor :screen_y
attr_accessor :started_turn

#--------------------------------------------------------------------------
# alias method: execute_damage
#--------------------------------------------------------------------------
alias game_battler_execute_damage_vb execute_damage
def execute_damage(user)
game_battler_execute_damage_vb(user)
if @result.hp_damage > 0
move_backward(24, 6) unless @moved_back
@moved_back = true
end
end

#--------------------------------------------------------------------------
# face_opposing_party
#--------------------------------------------------------------------------
def face_opposing_party
direction = ($game_system.party_direction ||
YEA::VISUAL_BATTLERS::PARTY_DIRECTION)
character.set_direction(Direction.correct(direction)) rescue 0
end

#--------------------------------------------------------------------------
# new method: face_coordinate
#--------------------------------------------------------------------------
def face_coordinate(destination_x, destination_y)
x1 = Integer(@screen_x)
x2 = Integer(destination_x)
y1 = Graphics.height - Integer(@screen_y)
y2 = Graphics.height - Integer(destination_y)
return if x1 == x2 and y1 == y2
#---
angle = Integer(Math.atan2((y2-y1),(x2-x1)) * 1800 / Math::PI)
if (0..225) === angle or (-225..0) === angle
direction = 6
elsif (226..675) === angle
direction = 9
elsif (676..1125) === angle
direction = 8
elsif (1126..1575) === angle
direction = 7
elsif (1576..1800) === angle or (-1800..-1576) === angle
direction = 4
elsif (-1575..-1126) === angle
direction = 1
elsif (-1125..-676) === angle
direction = 2
elsif (-675..-226) === angle
direction = 3
end
#---
character.set_direction(Direction.correct(direction)) rescue 0
end

#--------------------------------------------------------------------------
# create_move_to
#--------------------------------------------------------------------------
def create_move_to(destination_x, destination_y, frames = 12)
@destination_x = destination_x
@destination_y = destination_y
frames = .max
@move_x_rate = .max
@move_y_rate = .max
end

#--------------------------------------------------------------------------
# update_move_to
#--------------------------------------------------------------------------
def update_move_to
@move_x_rate = 0 if @screen_x == @destination_x || @move_x_rate.nil?
@move_y_rate = 0 if @screen_y == @destination_y || @move_y_rate.nil?
value = .min
@screen_x += (@destination_x > @screen_x) ? value : -value
value = .min
@screen_y += (@destination_y > @screen_y) ? value : -value
end

#--------------------------------------------------------------------------
# move_forward
#--------------------------------------------------------------------------
def move_forward(distance = 24, frames = 12)
direction = forward_direction
move_direction(direction, distance, frames)
end

#--------------------------------------------------------------------------
# move_backward
#--------------------------------------------------------------------------
def move_backward(distance = 24, frames = 12)
direction = Direction.opposite(forward_direction)
move_direction(direction, distance, frames)
end

#--------------------------------------------------------------------------
# move_direction
#--------------------------------------------------------------------------
def move_direction(direction, distance = 24, frames = 12)
case direction
when 1; move_x = distance / -2; move_y = distance / 2
when 2; move_x = distance * 0; move_y = distance * 1
when 3; move_x = distance / -2; move_y = distance / 2
when 4; move_x = distance * -1; move_y = distance * 0
when 6; move_x = distance * 1; move_y = distance * 0
when 7; move_x = distance / -2; move_y = distance / -2
when 8; move_x = distance * 0; move_y = distance * -1
when 9; move_x = distance / 2; move_y = distance / -2
else; return
end
destination_x = @screen_x + move_x
destination_y = @screen_y + move_y
create_move_to(destination_x, destination_y, frames)
end

#--------------------------------------------------------------------------
# forward_direction
#--------------------------------------------------------------------------
def forward_direction
return ($game_system.party_direction ||
YEA::VISUAL_BATTLERS::PARTY_DIRECTION)
end

#--------------------------------------------------------------------------
# move_origin
#--------------------------------------------------------------------------
def move_origin
create_move_to(@origin_x, @origin_y)
face_coordinate(@origin_x, @origin_y)
@moved_back = false
end

#--------------------------------------------------------------------------
# moving?
#--------------------------------------------------------------------------
def moving?
return false if dead? || !exist?
return @move_x_rate != 0 || @move_y_rate != 0
end

end # Game_Battler

#==============================================================================
# ? Бе Game_Actor
#==============================================================================

class Game_Actor < Game_Battler

#--------------------------------------------------------------------------
# overwrite method: use_sprite?
#--------------------------------------------------------------------------
def use_sprite?
return true
end

#--------------------------------------------------------------------------
# new method: screen_x
#--------------------------------------------------------------------------
def screen_x
return @screen_x rescue 0
end

#--------------------------------------------------------------------------
# new method: screen_y
#--------------------------------------------------------------------------
def screen_y
return @screen_y rescue 0
end

#--------------------------------------------------------------------------
# new method: screen_z
#--------------------------------------------------------------------------
def screen_z
return 100
end

#--------------------------------------------------------------------------
# new method: sprite
#--------------------------------------------------------------------------
def sprite
index = $game_party.battle_members.index(self)
return SceneManager.scene.spriteset.actor_sprites
end

#--------------------------------------------------------------------------
# new method: character
#--------------------------------------------------------------------------
def character
return sprite.character_base
end

#--------------------------------------------------------------------------
# face_opposing_party
#--------------------------------------------------------------------------
def face_opposing_party
dr = $game_system.party_direction || YEA::VISUAL_BATTLERS::PARTY_DIRECTION
direction = Direction.opposite(dr)
character.set_direction(Direction.correct(direction)) rescue 0
end

#--------------------------------------------------------------------------
# forward_direction
#--------------------------------------------------------------------------
def forward_direction
return Direction.opposite(($game_system.party_direction ||
YEA::VISUAL_BATTLERS::PARTY_DIRECTION))
end

end # Game_Actor

#==============================================================================
# ? Бе Game_Enemy
#==============================================================================

class Game_Enemy < Game_Battler

#--------------------------------------------------------------------------
# new method: sprite
#--------------------------------------------------------------------------
def sprite
return SceneManager.scene.spriteset.enemy_sprites.reverse
end

#--------------------------------------------------------------------------
# new method: character
#--------------------------------------------------------------------------
def character
return sprite
end

end # Game_Enemy

#==============================================================================
# ? Бе Game_Troop
#==============================================================================

class Game_Troop < Game_Unit

#--------------------------------------------------------------------------
# alias method: setup
#--------------------------------------------------------------------------
alias game_troop_setup_vb setup
def setup(troop_id)
game_troop_setup_vb(troop_id)
set_coordinates
end

#--------------------------------------------------------------------------
# new method: set_coordinates
#--------------------------------------------------------------------------
def set_coordinates
for member in members
member.origin_x = member.screen_x
member.origin_y = member.screen_y
member.create_move_to(member.screen_x, member.screen_y, 1)
end
end

end # Game_Troop

#==============================================================================
# ? Бе Sprite_Battler
#==============================================================================

class Sprite_Battler < Sprite_Base

#--------------------------------------------------------------------------
# public instance_variable
#--------------------------------------------------------------------------
attr_accessor :character_base
attr_accessor :character_sprite

#--------------------------------------------------------------------------
# alias method: dispose
#--------------------------------------------------------------------------
alias sprite_battler_dispose_vb dispose
def dispose
dispose_character_sprite
sprite_battler_dispose_vb
end

#--------------------------------------------------------------------------
# new method: dispose_character_sprite
#--------------------------------------------------------------------------
def dispose_character_sprite
@character_sprite.dispose unless @character_sprite.nil?
end

#--------------------------------------------------------------------------
# alias method: update
#--------------------------------------------------------------------------
alias sprite_battler_update_vb update
def update
sprite_battler_update_vb
return if @battler.nil?
update_move_to
update_character_base
update_character_sprite
end

#--------------------------------------------------------------------------
# new method: update_character_base
#--------------------------------------------------------------------------
def update_character_base
return if @character_base.nil?
@character_base.update
end

#--------------------------------------------------------------------------
# new method: update_character_sprite
#--------------------------------------------------------------------------
def update_character_sprite
return if @character_sprite.nil?
@character_sprite.update
end

#--------------------------------------------------------------------------
# new method: update_move_to
#--------------------------------------------------------------------------
def update_move_to
@battler.update_move_to
end

#--------------------------------------------------------------------------
# new method: moving?
#--------------------------------------------------------------------------
def moving?
return false if @battler.nil?
return @battler.moving?
end

end # Sprite_Battler

#==============================================================================
# ? Бе Sprite_BattleCharacter
#==============================================================================

class Sprite_BattleCharacter < Sprite_Character

#--------------------------------------------------------------------------
# initialize
#--------------------------------------------------------------------------
def initialize(viewport, character = nil)
super(viewport, character)
character.sprite = self
end

end # Sprite_BattleCharacter

#==============================================================================
# ? Бе Spriteset_Battle
#==============================================================================

class Spriteset_Battle

#--------------------------------------------------------------------------
# public instance_variable
#--------------------------------------------------------------------------
attr_accessor :actor_sprites
attr_accessor :enemy_sprites

#--------------------------------------------------------------------------
# overwrite method: create_actors
#--------------------------------------------------------------------------
def create_actors
total = $game_party.max_battle_members
@current_party = $game_party.battle_members.clone
@actor_sprites = Array.new(total) { Sprite_Battler.new(@viewport1) }
for actor in $game_party.battle_members
@actor_sprites.battler = actor
create_actor_sprite(actor)
end
end

#--------------------------------------------------------------------------
# new method: create_actor_sprite
#--------------------------------------------------------------------------
def create_actor_sprite(actor)
character = Game_BattleCharacter.new(actor)
character_sprite = Sprite_BattleCharacter.new(@viewport1, character)
@actor_sprites.character_base = character
@actor_sprites.character_sprite = character_sprite
actor.face_opposing_party
end

#--------------------------------------------------------------------------
# alias method: update_actors
#--------------------------------------------------------------------------
alias spriteset_battle_update_actors_vb update_actors
def update_actors
if @current_party != $game_party.battle_members
dispose_actors
create_actors
end
spriteset_battle_update_actors_vb
end

#--------------------------------------------------------------------------
# new method: moving?
#--------------------------------------------------------------------------
def moving?
return battler_sprites.any? {|sprite| sprite.moving? }
end

end # Spriteset_Battle

#==============================================================================
# ? Бе Scene_Battle
#==============================================================================

class Scene_Battle < Scene_Base

#--------------------------------------------------------------------------
# public instance variables
#--------------------------------------------------------------------------
attr_accessor :spriteset

#--------------------------------------------------------------------------
# alias method: process_action_end
#--------------------------------------------------------------------------
alias scene_battle_process_action_end_vb process_action_end
def process_action_end
start_battler_move_origin
scene_battle_process_action_end_vb
end

#--------------------------------------------------------------------------
# alias method: execute_action
#--------------------------------------------------------------------------
alias scene_battle_execute_action_vb execute_action
def execute_action
start_battler_move_forward
scene_battle_execute_action_vb
end

#--------------------------------------------------------------------------
# new method: start_battler_move_forward
#--------------------------------------------------------------------------
def start_battler_move_forward
return if @subject.started_turn
@subject.started_turn = true
@subject.move_forward
wait_for_moving
end

#--------------------------------------------------------------------------
# new method: start_battler_move_origin
#--------------------------------------------------------------------------
def start_battler_move_origin
@subject.started_turn = nil
move_battlers_origin
wait_for_moving
@subject.face_opposing_party rescue 0
end

#--------------------------------------------------------------------------
# new method: move_battlers_origin
#--------------------------------------------------------------------------
def move_battlers_origin
for member in all_battle_members
next if member.dead?
next unless member.exist?
member.move_origin
end
end

#--------------------------------------------------------------------------
# new method: wait_for_moving
#--------------------------------------------------------------------------
def wait_for_moving
update_for_wait
update_for_wait while @spriteset.moving?
end

end # Scene_Battle

#==============================================================================
#
# Бе End of File
#
#==============================================================================
BlackWolf1992
234
01/11/2017 04:05 AM
I actually am using this script as well. However, I cannot really help as scripting falls outside my knowledge of expertise. Honestly, I have no real problem with as I mean you cannot make every game perfect so yeah some things may be off and not right (like the whole not having a death state animation.)

The only thing I would be able to say is you could always use another sidebattle script like Galv's Animated Battlers or Theo's sidebattle script however you would need the sprite graphics and I take in since you are using YF's you are like me and not great at sprite art which makes sense (or you just wanted that whole classic Final Fantasy 1 look.) Either way, I am actually interested to see if there is a solution to this as well. If not then well, guess I should learn to create sprites. Ha-ha.
karins_soulkeeper
will ████ for ███
3090
01/11/2017 09:42 AM
It's hard to check thins thoroughly, since I'm on my phone, but the key method to look at should be this one:

#--------------------------------------------------------------------------
# new method: create_actor_sprite
#--------------------------------------------------------------------------
def create_actor_sprite(actor)
character = Game_BattleCharacter.new(actor)
character_sprite = Sprite_BattleCharacter.new(@viewport1, character)
@actor_sprites.character_base = character
@actor_sprites.character_sprite = character_sprite #specifically, this one here
actor.face_opposing_party
end

Edit: Or maybe editing this one would be better?
#--------------------------------------------------------------------------
# setup_actor
#--------------------------------------------------------------------------
def setup_actor(actor)
@actor = actor
@step_anime = true
set_graphic(@actor.character_name, @actor.character_index) #this line here
setup_coordinates
dr = $game_system.party_direction || YEA::VISUAL_BATTLERS::PARTY_DIRECTION
direction = Direction.opposite(dr)
set_direction(Direction.correct(direction))
end

Edit2: Change that line to this here:
if actor.hp == 0
  set_graphic(charset_name_for_dead_actor, charset_index_for_dead_actor)
else
  set_graphic(@actor.character_name, @actor.character_index)
end

Hazelsoft
237
01/11/2017 06:03 PM
karin's its not working for it
karins_soulkeeper
will ████ for ███
3090
01/12/2017 03:27 AM
Huh. Unsurprisingly.

I'd have to do some extensive testing for this. I'll be back in a while. Though if anyone else has a solution at the ready, feel free to pop it in.
BlackWolf1992
234
01/12/2017 03:34 AM
Odd, I kind of figured that would work. It looks like it would. Then again my ability to understand scripting is weak but logically it looks like it would with the:

if actor.hp == 0
  set_graphic(charset_name_for_dead_actor, charset_index_for_dead_actor)
else
  set_graphic(@actor.character_name, @actor.character_index)
end
karins_soulkeeper
will ████ for ███
3090
01/13/2017 01:08 PM
I've had no luck so far, sorry. I'd keep trying, but I suggest you look for someone else to solve this. I might take a while.

Maybe a better scripter, or the actual writer of this script can help you?
BlackWolf1992
234
01/13/2017 09:41 PM
At least you tried Karin :)

Hmm. Why not try another script and just get someone to do the graphic sprites for you?
Hazelsoft
237
01/13/2017 11:14 PM


I will try that thank you BlackWolf!
BlackWolf1992
234
01/13/2017 11:47 PM
Good luck. If you want something a bit simple, Galv's script is probably best. Theo's, while is a script, can be very confusing at times. I believe there is another script out there by Fomar0153 which is like Yanfly's script here but I have yet to use the script so no idea.

There is also Kread-EX Animated Battlers v1.08 which lets you use animations as battlers which is pretty cool. Unity's Luxaren Allure uses it.

I also believe Victor Saint may have a sideview battle script but I do remember I will have to check again when I have time.
Hazelsoft
237
01/14/2017 02:39 AM
oh ok ty BlackWolf
Jeroen_Sol
Nothing reveals Humanity so well as the games it plays. A game of betrayal, where the most suspicious person is brutally murdered? How savage.
3885
01/15/2017 01:09 AM
I'm not too savvy at this, but shouldn't the actor.hp in the if statement be @actor.hp ?

Edit: Though I suppose that doesn't make much of a difference since they are set to be equal a few lines above it.
Pages: 1