Sportello aiuti veloci VX-Ace 31

[Holy87]

Scusa ma non lo trovo, la tua guida o quella integrata nel gioco?

La mia guida, ma ho ricontrollato ed è un po' diverso…
Allora, seguendo lo stesso esempio degli equipaggiamenti, devi aggiungere l'attributo base_bitmap (o in qualsiasi modo tu lo voglia chiamare) in RPG::Actor.
Per quanto riguarda gli eroi, questi sono l'istanza di Game_Actor (perché non sono statici come gli equipaggiamenti, ma salgono di livello, cambiano HP ecc...)
quindi ci vuole un metodo in Game_Actor che richiami la propria controparte dell'attributo di RPG::Actor

class Game_Actor < Game_Battler
  def base_bitmap
    actor.base_bitmap
  end
end

Spero che ti sia chiaro.

[Killer Van]

No non ho capito, basta scrivere questo codice nello script degli animated battler e in game actor aggiungere un attributo tipo così:
@base_bitmap =' '
?
Non credo

Modificato da Killer Van, 01 August 2018 - 23:53 PM.

[Holy87]

No non ho capito, basta scrivere questo codice nello script degli animated battler e in game actor aggiungere un attributo tipo così:
@base_bitmap =' '
?
Non credo

Che usi uno script degli animated battlers lo hai detto ora. A questo punto, non puoi usare al posto di base_bitmap la grafica che imposti direttamente come battler? Cerca l'attributo nello script.

[Killer Van]

Ho trovato questo codice:

def setup_animated_battler @pose = 0    @move_speed = 0    char = actor? ? actor : enemy    @animated_battler = $1 if char.note =~ /<battler:[ ](.*)>/i  end

@animated_battler è quello che mi serve giusto?
Però come lo definisco?
Ho visto che lui lo utilizza così

new_bitmap=Cache.battler(@battler.animated_battler, 0)

Io dovrei scrivere la stessa cosa, ma con base_bitmap, al posto di new_bitmap?

Modificato da Killer Van, 02 August 2018 - 00:24 AM.

[Holy87]

Ho trovato questo codice:

def setup_animated_battler @pose = 0    @move_speed = 0    char = actor? ? actor : enemy    @animated_battler = $1 if char.note =~ /<battler:[ ](.*)>/i  end

@animated_battler è quello che mi serve giusto?
Però come lo definisco?
Ho visto che lui lo utilizza così

new_bitmap=Cache.battler(@battler.animated_battler, 0)

Io dovrei scrivere la stessa cosa, ma con base_bitmap, al posto di new_bitmap?

No, non devi reinventare la ruota. È già definito...
Basta che fai actor.animated_battler

[Killer Van]

Mi da questo errore :   undefined method 'animated_battler' for 1:Fixnum
Credo che il problema sia la classe giusto?

Io ho usato la funzione Trova negli script e non ho trovato nessun 

def animated_battler

Modificato da Killer Van, 02 August 2018 - 09:02 AM.

[Holy87]

Mi da questo errore :   undefined method 'animated_battler' for 1:Fixnum
Credo che il problema sia la classe giusto?
Io ho usato la funzione Trova negli script e non ho trovato nessun 

def animated_battler

Non dev'essere per forza un metodo, ma anche un attributo pubblico.
Devi rendere la variabile @animated_battler pubblica inserendo
attr_reader :animated_battler
All'interno della classe Game_Actor

[Killer Van]

Ho provato ma mi da lo stesso errore.
Ma forse sto sbagliando io ad utilizzare generate _animated_battler
Nelle parentesi va scritto l'id o il nome del personaggio, l'id giusto?

Modificato da Killer Van, 02 August 2018 - 09:34 AM.

[Holy87]

Ho provato ma mi da lo stesso errore.
Ma forse sto sbagliando io ad utilizzare generate _animated_battler
Nelle parentesi va scritto l'id o il nome del personaggio, l'id giusto?

Né uno né l'altro. Devi passargli l'oggetto.

[Killer Van]

Come?

[Holy87]

Mi dici dove stai chiamando quel metodo?
È mi dici, per cortesia, il messaggio di errore completo (o fai uno screen)?
Leggere il messaggio di errore è la prima cosa che si deve fare per capire dove sia il problema.

[Killer Van]

Errore: Script 'Galv's animated battler' line 726 NoMethodError occurred

undefined method 'animated_battler' for 1:Fixnum

 

animated_battler, ho visto che nello script viene utilizzato più volte, ho usato la funzione cerca per vedere dove lo definiva, ma non ho trovato niente.

Ti posto lo script:

Spoiler

##------------------------------------------------------------------------------#
#  Galv's Animated Battlers
#------------------------------------------------------------------------------#
#  For: RPGMAKER VX ACE
#  Version 1.2
#------------------------------------------------------------------------------#
#  2014-01-17 - Version 1.2 - compatibility fix when using with Actor Duel Game
#  2013-05-06 - Version 1.1 - added move speed for melee attacks
#  2013-05-04 - Version 1.0 - release
#------------------------------------------------------------------------------#
#  Holder's animated battler spritesheets can be found here:
#  http://animatedbattlers.wordpress.com/
#------------------------------------------------------------------------------#
#  This is just another animated battler script that uses holder-style animated
#  battler sheets. There are better ones out there, this one is just my basic
#  implementation in an attempt to continue improving my scripting.
#
#  This script works in the default battle system but is optimised for use with
#  Yanfly's battle script. Not tested with other battle scripts. Put this script
#  below any battle scripts you try it with.
#------------------------------------------------------------------------------#
 
#------------------------------------------------------------------------------#
#  Note tag for ENEMIES and ACTORS
#------------------------------------------------------------------------------#
#
#  <battler: filename>    # filename is the animated spritesheet located in
#                         # /Graphics/Battlers/
#                         # Required for actors, optional for enemies.
#
#  <stationary_sub>       # will not re-position themselves in front of an ally
#                         # they are covering/substituting for.
#
#------------------------------------------------------------------------------#
 
#------------------------------------------------------------------------------#
#  Note tags for SKILLS, ITEMS and STATES
#------------------------------------------------------------------------------#
#
#  <pose: x>    # The skill, item or state will use x pose row.
#               # If a skill does not have this tag, it will use row 6.
#               # If an item does not have this tag, it will use row 5.
#               # If a state does not have this tag, it will use row 2. If a
#               # battler has multiple states, it uses the highest priority.
#
#------------------------------------------------------------------------------#
 
#------------------------------------------------------------------------------#
#  Note tag for SKILLS, ITEMS and ACTORS
#------------------------------------------------------------------------------#
#
#  <melee: x>  # Normal attacks for Actors, items being used or skills being
#              # used that have this tag will make the actor dash into close
#              # range before doing the action. x is the dash speed.
#              # 0 = instant.  1 is slow, higher numbers is faster
#
#------------------------------------------------------------------------------#
 
#------------------------------------------------------------------------------#
#  SCRIPT CALLS
#------------------------------------------------------------------------------#
#
#
#------------------------------------------------------------------------------#
#------------------------------------------------------------------------------#
   
  
    
 
 #------------------------------------------------------------------------------#
 
($imported ||= {})["Galv_Animated_Battlers"] = true
module GALV_BAT
  
#-------------------------------------------------------------------------------
#
#  * SETTINGS
#
#-------------------------------------------------------------------------------
  
  COLS = 4             # How many columns your animated spritesheet uses
  ROWS = 14            # How many rows your animated spritesheet uses
  
  ENEMY_FLIP = true    # true = flip enemy battler image horizontally
  ACTOR_FLIP = false   # true = flip actor battler image horizonatally
  
  HP_CRISIS = 0.25     # Remaining hp before poor status pose (0.25 = 25%)
  
  ONE_ANIM = [3,4,5,6,7,11,12]  # Poses that will NOT keep repeating their frames
 
 
  XOFFSET = 80    # horizonatal distance from opponent when using <melee: x>
  YOFFSET = 0     # vertical distance from opponent when using <melee: x>
  
  SXOFFSET = 40   # horizontal distance from ally when substituting
  SYOFFSET = 0    # vertical distance from ally when substituting
  
#------------------------------------------------------------------------------#
  ACTOR_POSITIONS = [ # don't touch
#------------------------------------------------------------------------------#
#  Set x,y locations of your actors on the battle screen
#------------------------------------------------------------------------------#
 
    [400,280],   # Party member 1 [x,y]
    [425,260],   # Party member 2 [x,y]
    [450,290],   # Party member 3 [x,y]
    [475,265],   # Party member 4 [x,y]
   
#------------------------------------------------------------------------------#
  ] #don't touch
#------------------------------------------------------------------------------#
 
#-------------------------------------------------------------------------------
#  POSES USED FOR SPECIAL ACTIONS:
#-------------------------------------------------------------------------------
 
   COUNTER_ATTACK = 4       # Pose when counter attacking
   MAGIC_REFLECT  = 7       # Pose when reflecting magic 
   EVASION        = [9,8]   # Move back then move forward poses to evade.
 
#-------------------------------------------------------------------------------
#  POSE INFORMATION:
#------------------------------------------------------------------------------#
#  DEFAULT SPRITESHEET POSES (HOLDER SETUP)
#------------------------------------------------------------------------------#
#  ROW     POSE              
#
#   0      Idle
#   1      Guard
#   2      Poor Status
#   3      Get hit
#   4      Normal Attack
#   5      Use Item
#   6      Use Skill
#   7      Use Magic
#   8      Move toward
#   9      Move back
#   10     Victory
#   11     Battle Start
#   12     Dead
#   13     Spritesheet Info
#------------------------------------------------------------------------------#
 
#-------------------------------------------------------------------------------
#
#  * END SETTINGS
#
#-------------------------------------------------------------------------------
 
end
 
 
#------------------------------------------------------------------------------#
#  OVERWRITTEN METHODS
#------------------------------------------------------------------------------#
#  class Spriteset_Battle
#    - create_enemies
#    - create_actors
#    - update_actors
#------------------------------------------------------------------------------#
 
 
    #----------------------#
#---|   GAME_INTERPRETER   |----------------------------------------------------
    #----------------------#
 
class Game_Interpreter
  def change_battler(id,name )
    $game_actors[id].animated_battler = name
  end
end # Game_Interpreter
 
 
    #-------------------#
#---|   RPG::BASEITEM   |-------------------------------------------------------
    #-------------------#
 
class RPG::BaseItem
  def pose
    if @pose.nil?
      if @note =~ /<pose: (.*)>/i
        @pose = $1.to_i
      else
        @pose = nil
      end
    end
    @pose
  end
end # RPG::BaseItem
 
 
    #----------------------#
#---|   GAME_BATTLERBASE   |----------------------------------------------------
    #----------------------#
 
class Game_BattlerBase
  alias galv_animb_gbb_appear appear
  def appear
    return if SceneManager.scene_is?(Scene_Map)
    galv_animb_gbb_appear
  end
end # Game_BattlerBase
 
 
    #------------------#
#---|   GAME_BATTLER   |--------------------------------------------------------
    #------------------#
 
class Game_Battler < Game_BattlerBase
  attr_accessor :animated_battler
  attr_accessor :pose
  attr_accessor :freeze_pose
  attr_accessor :bactivated
  attr_accessor :move_target
  attr_accessor :orx
  attr_accessor :ory
  attr_accessor :reset_pose
  attr_accessor :move_speed
  
  def setup_animated_battler
    @pose = 0
    @move_speed = 0
    char = actor? ? actor : enemy
    @animated_battler = $1 if char.note =~ /<battler:[ ](.*)>/i
  end
  
  def do_pose(col)
    @reset_pose = true
    @pose = col
    @freeze_pose = true if GALV_BAT::ONE_ANIM.include?(@pose)
  end
  
  alias galv_animb_gbgbb_on_turn_end on_turn_end
  def on_turn_end
    galv_animb_gbgbb_on_turn_end
    set_idle_pose
  end
  
  alias galv_animb_gbgbb_on_action_end on_action_end
  def on_action_end
    galv_animb_gbgbb_on_action_end
    set_idle_pose
  end
  
  def set_idle_pose
    return if !@bactivated
    if death_state?
      do_pose(12)
    elsif guard?
      do_pose(1)
    elsif [email protected]?
      do_pose(state_pose)
    elsif low_life?
      do_pose(2)
    else
      do_pose(0)
    end
    @freeze_pose = false unless GALV_BAT::ONE_ANIM.include?(@pose)
  end
  
  def low_life?
    @hp < (mhp * GALV_BAT::HP_CRISIS)
  end
  
  def state_pose
    prio = 0
    prio_state = 0
    @states.each { |sid|
      if $data_states[sid].priority > prio
        prio_state = sid
        prio = $data_states[sid].priority
      end
    }
    if prio_state <= 0 || !$data_states[prio_state].pose
      return 2
    else
      $data_states[prio_state].pose
    end
  end
 
  alias galv_animb_gbgbb_add_state add_state
  def add_state(state_id)
    galv_animb_gbgbb_add_state(state_id)
    set_idle_pose
  end
  
  alias galv_animb_gbgbb_remove_state remove_state
  def remove_state(state_id)
    dead = dead?
    galv_animb_gbgbb_remove_state(state_id)
    set_idle_pose if state_id != 1 && !dead? || dead
  end
  
  alias galv_animb_gbgbb_execute_damage execute_damage
  def execute_damage(user)
    perform_get_hit if @result.hp_damage > 0
    galv_animb_gbgbb_execute_damage(user)
    if !$imported["YEA-BattleEngine"]
      SceneManager.scene.wait(15)
      set_idle_pose
    end
  end
  
  def perform_get_hit
    if !dead? && !guard? && $game_party.in_battle && @animated_battler
      do_pose(3)
      @sprite_effect_type = :get_hit
    end
  end
  
  def perform_counter_attack
    if !dead? && $game_party.in_battle && @animated_battler
      do_pose(GALV_BAT::COUNTER_ATTACK)
      @sprite_effect_type = :counter_attack
    end
  end
  
  def perform_magic_reflect
    if !dead? && $game_party.in_battle && @animated_battler
      do_pose(GALV_BAT::MAGIC_REFLECT)
      @sprite_effect_type = :counter_attack
    end
  end
 
  def perform_victory
    if !dead? && @animated_battler
      do_pose(10)
    end
  end
 
  def perform_enter_battle
    @bactivated = true
    if !dead? && @animated_battler
      @pose = 11
      @sprite_effect_type = :enter_battle
    end
  end
  
  def perform_dash(dash_type,target)
    if !dead? && @animated_battler
      @move_target = target
      pose = dash_type == :dash_forward ? 8 : 9
      do_pose(pose)
      @sprite_effect_type = dash_type
    end
  end
  
  def perform_travel(dash_type,target,speed)
    @move_target = target
    @move_speed = speed
    do_pose(8)
    @sprite_effect_type = dash_type
  end
  
  def moving?
    @move_speed > 0
  end
  
  def perform_dodge
    if !dead? && @animated_battler
      do_pose(GALV_BAT::EVASION[0])
      @sprite_effect_type = :dodge
    end
  end
 
  alias galv_animb_gbgbb_on_battle_start on_battle_start
  def on_battle_start
    perform_enter_battle
    galv_animb_gbgbb_on_battle_start
  end
 
  def init_animated_battler(i)
    @sprite_effect_type = :appear
    @bactivated = false
    @pose = alive? ? 11 : 12
    if actor?
      @screen_x = GALV_BAT::ACTOR_POSITIONS[i][0]
      @orx = GALV_BAT::ACTOR_POSITIONS[i][0]
      @screen_y = GALV_BAT::ACTOR_POSITIONS[i][1]
      @ory = GALV_BAT::ACTOR_POSITIONS[i][1]
    else
      @orx = @screen_x
      @ory = @screen_y
    end
  end
  
  def reinit_battler(i)
    if actor?
      @screen_x = GALV_BAT::ACTOR_POSITIONS[i][0]
      @orx = GALV_BAT::ACTOR_POSITIONS[i][0]
      @screen_y = GALV_BAT::ACTOR_POSITIONS[i][1]
      @ory = GALV_BAT::ACTOR_POSITIONS[i][1]
    else
      @orx = @screen_x
      @ory = @screen_y
    end
    @bactivated = true
  end
  
  alias galv_animb_gbgbb_item_apply item_apply
  def item_apply(user, item)
    galv_animb_gbgbb_item_apply(user, item)
    if @result.evaded
      perform_dodge
    end
  end
end # Game_Battler < Game_BattlerBase
 
 
    #----------------#
#---|   GAME_ACTOR   |----------------------------------------------------------
    #----------------#
 
class Game_Actor < Game_Battler
  attr_accessor :screen_x
  attr_accessor :screen_y
  
  def screen_x; screen_x = @screen_x; end
  def screen_y; screen_y = @screen_y; end
  def screen_z; 100; end
  
  alias galv_animb_gagb_initialize initialize
  def initialize(actor_id)
    galv_animb_gagb_initialize(actor_id)
    setup_animated_battler
    @screen_x = 0
    @screen_y = 0
  end
  
  def sub_pose(target)
    if !dead? && @animated_battler
      return if $data_actors[@actor_id].note =~ /<stationary_sub>/i
      @screen_x = target.screen_x - GALV_BAT::SXOFFSET
      @screen_y = target.screen_y - GALV_BAT::SYOFFSET
      @sprite_effect_type = :substitute
    end
  end
  
  def return_to_position
    if !dead? && @animated_battler
      @screen_x = @orx
      @screen_y = @ory
    end
  end
end # Game_Actor < Game_Battler
 
 
    #----------------#
#---|   GAME_ENEMY   |----------------------------------------------------------
    #----------------#
 
class Game_Enemy < Game_Battler
  alias galv_animb_gegb_initialize initialize
  def initialize(index, enemy_id)
    galv_animb_gegb_initialize(index, enemy_id)
    setup_animated_battler
  end
  
  def sub_pose(target)
    if !dead? && @animated_battler
      return if $data_enemies[@enemy_id].note =~ /<stationary_sub>/i
      @screen_x = target.screen_x + GALV_BAT::SXOFFSET
      @screen_y = target.screen_y + GALV_BAT::SYOFFSET
      @sprite_effect_type = :substitute
    end
  end
  
  def return_to_position
    if !dead? && @animated_battler
      @screen_x = @orx
      @screen_y = @ory
    end
  end
end # Game_Enemy < Game_Battler
 
 
    #-------------------#
#---|   BATTLEMANAGER   |-------------------------------------------------------
    #-------------------#
 
module BattleManager
  class << self
    alias galv_animb_bm_process_victory process_victory
  end
  
  def self.process_victory
    $game_party.battle_members.each { |actor| actor.perform_victory }
    galv_animb_bm_process_victory
  end
end # BattleManager
 
 
    #------------------#
#---|   SCENE_BATTLE   |--------------------------------------------------------
    #------------------#
 
class Scene_Battle < Scene_Base
  alias galv_animb_sbsb_start start
  def start
    position_battlers
    galv_animb_sbsb_start
  end
 
  def position_actors
    $game_party.battle_members.each_with_index { |battler,i|
      battler.reinit_battler(i)
    }
    @spriteset.refresh_actors
  end
  
  def position_battlers
    galv_all_battle_members.each_with_index { |battler,i|
      battler.init_animated_battler(i)
    }
  end
  
  def galv_all_battle_members
    $game_party.battle_members + $game_troop.members
  end
  
  alias galv_animb_sbsb_show_animation show_animation
  def show_animation(targets, animation_id)
    @move_target = targets[0]
    check_dash
    set_pose
    galv_animb_sbsb_show_animation(targets, animation_id)
  end
  
  def check_dash
    move = move_to_target
    if move > 0
      @subject.perform_travel(:move_forward,@move_target,move)
      update_for_wait while @subject.moving?
    elsif move == 0
      @subject.perform_dash(:dash_forward,@move_target)
      wait(30)
    end
  end
  
  def move_to_target
    return -1 if no_action && !@moveitem
    @moveitem ||= @subject.current_action.item
    return $1.to_i if @moveitem.note =~ /<melee: (.*)>/i
    if @moveitem.is_a?(RPG::Skill) && @moveitem.id == 1
      char = @subject.actor? ? $data_actors[@subject.id] : 
        $data_enemies[@subject.enemy_id]
      return $1.to_i if char.note =~ /<melee: (.*)>/i
    end
    return -1
  end
  
  def no_action
    !@subject || [email protected]_action || [email protected]_action.item
  end
  
  alias galv_animb_sbsb_process_action_end process_action_end
  def process_action_end
    if @subject.screen_x != @subject.orx
      @subject.perform_dash(:dash_back,@subject)
      wait(25)
    end
    galv_animb_sbsb_process_action_end
    @moveitem = nil
  end
  
  alias galv_animb_sbsb_invoke_counter_attack invoke_counter_attack
  def invoke_counter_attack(target,item)
    target.perform_counter_attack
    galv_animb_sbsb_invoke_counter_attack(target,item)
  end
  
  alias galv_animb_sbsb_invoke_magic_reflection invoke_magic_reflection
  def invoke_magic_reflection(target, item)
    target.perform_magic_reflect
    galv_animb_sbsb_invoke_magic_reflection(target, item)
  end
    
  def set_pose
    return if no_action
    item = @subject.current_action.item
    if item.is_a?(RPG::Skill)
      case item.id
      when 2  # guard
        @subject.do_pose(1)
      when 1  # attack
        @subject.do_pose(4)
        wait(20) if $imported["YEA-BattleEngine"]
      else
        unique = item.pose ? item.pose : 6
        @subject.do_pose(unique)
      end
    elsif item.is_a?(RPG::Item)
      unique = item.pose ? item.pose : 5
      @subject.do_pose(unique)
      wait(30) if $imported["YEA-BattleEngine"]
    end
  end
end # Scene_Battle < Scene_Base
 
 
    #----------------------#
#---|   WINDOW_BATTLELOG   |----------------------------------------------------
    #----------------------#
 
class Window_BattleLog < Window_Selectable
  alias galv_animb_wblws_display_substitute display_substitute
  def display_substitute(substitute, target)
    substitute.sub_pose(target)
    galv_animb_wblws_display_substitute(substitute, target)
  end
end
 
 
    #----------------------#
#---|   SPRITESET_BATTLE   |----------------------------------------------------
    #----------------------#
 
class Spriteset_Battle
  #OVERWRITE
  def create_enemies
    @enemy_sprites = $game_troop.members.reverse.collect do |enemy|
      if enemy.animated_battler
        Sprite_AnimBattler.new(@viewport1, enemy)
      else
        Sprite_Battler.new(@viewport1, enemy)
      end
    end
  end
  
  # OVERWRITE
  def create_actors
    @actor_sprites = $game_party.battle_members.reverse.collect do |actor|
      Sprite_ActorBattler.new(@viewport1, actor)
    end
  end
  
  # OVERWRITE
  def update_actors
    need_update = false
    @actor_sprites.each_with_index do |sprite, i|
      sprite.battler = $game_party.battle_members[i]
      if sprite.battler
        sprite.update
      else
        need_update = true
      end
    end
    need_update = true if @actor_sprites.count < $game_party.battle_members.count
    if need_update
      SceneManager.scene.position_actors
    end
  end
  
  def refresh_actors
    dispose_actors
    create_actors
  end
end # Spriteset_Battle
 
 
    #--------------------#
#---|   SPRITE_BATTLER   |------------------------------------------------------
    #--------------------#
 
class Sprite_Battler < Sprite_Base
  alias galv_animb_spritebsb_update update
  def update
    if @battler && @battler.animated_battler && @galv_animb
      super
    else
      galv_animb_spritebsb_update
    end
  end
end # Sprite_Battler < Sprite_Base
 
 
    #------------------------#
#---|   SPRITE_ANIMBATTLER   |--------------------------------------------------
    #------------------------#
 
class Sprite_AnimBattler < Sprite_Battler
  def initialize(viewport, battler = nil)
    init_variables
    super(viewport,battler)
  end
 
  def init_variables
    @pattern = 0
    @speed_timer = 0
    @pose = 0
    @galv_animb = true
  end
 
  def update
    if @battler && @battler.animated_battler
      update_bitmap
      update_pose
      update_src_rect
      update_anim
      update_position
      setup_new_effect
      setup_new_animation
      update_effect
    end
    super
  end
  
 class RPG::EquipItem # vedi la guida di RPG Maker
  # restituisce la grafica di battaglia
  def battler_graphic(actor_id)
    @battler_graphic ||= get_battler_graphic
    @battler_graphic[actor_id] ||= ''
  end
 
  # ottiene il nome della grafica dalle note
  def get_battler_graphic
    @battler_graphic = {}
    self.note.split(/[\r\n]+/).each {|line|
      @battler_graphic[$1.to_i] = $2 if line =~ /<grafica eroe (\d+):[ ]*(.+)>/
    }
    '' # restituisce una stringa vuota se non c'è
  end
end
 
def generate_battler_bitmap(actor)
  base_bitmap = Cache.battler(actor.animated_battler, 0) # è un esempio, base_bitmap dovrebbe avere la grafica dell'eroe nudo
  base_bitmap = base_bitmap.clone # ne faccio un clone per non sporcare la bitmap nella cache
  rect = Rect.new(0, 0, base_bitmap.width, base_bitmap.height)
  actor.equips.each {|equip| # per ogni equipaggiamento
    next if equip.nil? # passo al prossimo se l'equip non esiste
      if !equip.battler_graphic(actor.id).empty? # se la stringa non è vuota
        base_bitmap.blt(0, 0, Cache.battler(equip.battler_graphic(actor.id), 0), rect)
      end
    }
  base_bitmap # restituisco la bitmap elaborata
end
  
  def update_bitmap
    generate_battler_bitmap(1)
    #new_bitmap = Cache.battler(@battler.animated_battler,
     # @battler.battler_hue)
    if bitmap != base_bitmap
      self.bitmap = base_bitmap
      spritesheet_normal
      init_visibility
    end
  end
 
  def spritesheet_normal
    @cw = 384 / GALV_BAT::COLS
    @ch = 1344 / GALV_BAT::ROWS
    self.ox = @cw / 2
    self.oy = @ch
    set_mirror
  end
 
  def set_mirror
    self.mirror = GALV_BAT::ENEMY_FLIP
  end
 
  def update_pose
    if @pose != @battler.pose
      @pattern = 0
      @pose = @battler.pose
    end
    if @battler.reset_pose
      @pose = 0
      @battler.reset_pose = false
    end
  end
 
  def update_src_rect
    if @pattern >= GALV_BAT::COLS
      @pattern = 0 unless freeze_pose?
    end
    sx = @pattern * @cw
    sy = @battler.pose * @ch
    self.src_rect.set(sx, sy, @cw, @ch)
  end
 
  def freeze_pose?
    @battler.freeze_pose && @pattern == GALV_BAT::COLS - 1
  end
 
  def update_anim
    return if [email protected]
    @speed_timer += 1
    if @speed_timer > 8
      @pattern += 1 unless freeze_pose?
      @speed_timer = 0
    end
  end
 
  def update_position
    self.x = @battler.screen_x
    self.y = @battler.screen_y
    self.z = @battler.screen_z
  end
 
  def start_effect(effect_type)
    @effect_type = effect_type
    case @effect_type
    when :counter_attack,:magic_reflect,:get_hit
      @effect_duration = 40
      @battler_visible = true
    when :enter_battle
      @effect_duration = 35
      @battler_visible = true
    when :dash_forward,:dash_back
      @effect_duration = 15
      @battler_visible = true
    when :move_forward
      @effect_duration = 500
      @move_duration = @effect_duration
      @battler_visible = true
    when :dodge
      @effect_duration = 20
      @battler_visible = true
    when :substitute
      @effect_duration = 20
      @battler_visible = true
    end
    super
  end
 
  def update_effect
    if @effect_duration > 0
      case @effect_type
      when :get_hit, :substitute
        update_generic_pose
      when :counter_attack,:magic_reflect
        update_counter
      when :enter_battle
        update_enter_battle
      when :dash_forward
        update_dash_forward
      when :move_forward
        update_move_forward
      when :dash_back
        update_dash_back
      when :dodge
        update_dodge
      end
    end
    super
  end
 
  def revert_to_normal
    return if do_revert?
    super
    spritesheet_normal
  end
  
  def do_revert?
    @effect_type == :whiten || @battler.dead?
  end
 
  def update_generic_pose
    if @effect_duration == 1
      @battler.return_to_position
      @battler.set_idle_pose
    end
  end
  
  def xoff; @battler.actor? ? GALV_BAT::XOFFSET : -GALV_BAT::XOFFSET; end
  def yoff; @battler.actor? ? GALV_BAT::YOFFSET : -GALV_BAT::YOFFSET; end
 
  def update_dash_forward
    if @battler.actor? && @battler.screen_x > Graphics.width / 2
      @battler.screen_x -= 3
    elsif @battler.enemy? && @battler.screen_x < Graphics.width / 2
      @battler.screen_x += 3
    end
    update_disappear
    if @effect_duration == 1
      @battler.screen_x = @battler.move_target.screen_x + xoff
      @battler.screen_y = @battler.move_target.screen_y + yoff
      start_effect(:appear)
    end
  end
  
  def update_dash_back
    if @battler.actor? && @battler.screen_x < Graphics.width / 2
      @battler.screen_x += 3
    elsif @battler.enemy? && @battler.screen_x > Graphics.width / 2
      @battler.screen_x -= 3
    end
    update_disappear
    if @effect_duration == 1
      @battler.screen_x = @battler.move_target.orx
      @battler.screen_y = @battler.move_target.ory
      start_effect(:appear)
    end
  end
  
  def update_move_forward
    if @battler.actor?
      @battler.screen_x -= x_difference(@battler,@battler.move_target)
    elsif @battler.enemy?
      @battler.screen_x += x_difference(@battler,@battler.move_target)
    end
    @battler.screen_y += y_difference(@battler,@battler.move_target)
  end
 
  def y_difference(bat,tar)
    yof = bat.actor? ? yoff : -yoff
    y_diff = bat.ory - (tar.screen_y + yof)
    x_diff = bat.orx - (tar.screen_x + xoff)
    y_move = y_diff.to_f / (x_diff.to_f / [@battler.move_speed,1].max).to_f
    return bat.actor? ? -y_move : y_move
  end
  
  def x_difference(bat,tar)
    if bat.actor? && bat.screen_x <= (tar.screen_x + xoff) ||
        bat.enemy? && bat.screen_x >= (tar.screen_x + xoff)
      @battler.move_speed = 0
      @effect_duration = 1
      return 0
    end
    return @battler.move_speed
  end
  
  def update_dodge
    if @effect_duration == 1
      @battler.screen_x = @battler.orx
      @battler.screen_y = @battler.ory
      @battler.set_idle_pose
    elsif @effect_duration >= 10
      @battler.actor? ? @battler.screen_x += 3 : @battler.screen_x -= 3
    else
      @battler.pose = GALV_BAT::EVASION[1]
      @battler.actor? ? @battler.screen_x -= 3 : @battler.screen_x += 3
    end
  end
 
  def update_enter_battle
    if @effect_duration == 1
      @battler.bactivated = true
      @battler.set_idle_pose
    end
  end
 
  def update_counter
    self.color.set(255, 255, 255, 0)
    self.color.alpha = 128 - (26 - @effect_duration) * 10
    @battler.set_idle_pose if @effect_duration == 1
  end
 
  def update_collapse; end
end # Sprite_AnimBattler < Sprite_Base
 
 
    #-------------------------#
#---|   SPRITE_ACTORBATTLER   |-------------------------------------------------
    #-------------------------#
 
class Sprite_ActorBattler < Sprite_AnimBattler
  def initialize(viewport, battler = nil)
    super(viewport,battler)
  end
  
  def dispose; super; end
  def update; super; end
 
  def set_mirror
    self.mirror = GALV_BAT::ACTOR_FLIP
  end
 
  def update_position
    self.x = @battler.screen_x
    self.y = @battler.screen_y
    self.z = @battler.screen_z
  end
  
  def init_visibility
    self.opacity = 255
  end
end # Sprite_ActorBattler < Sprite_AnimBattler
 
 
    #------------------------#
#---|   WINDOW_BATTLEENEMY   |--------------------------------------------------
    #------------------------#
 
class Window_BattleEnemy < Window_Selectable
  if $imported["YEA-BattleEngine"]
    def create_flags
      set_select_flag(:any)
      select(-1)
      return if $game_temp.battle_aid.nil?
      if $game_temp.battle_aid.need_selection?
        select(-1)
      elsif $game_temp.battle_aid.for_all?
        select(-1)
        set_select_flag(:all)
      elsif $game_temp.battle_aid.for_random?
        select(-1)
        set_select_flag(:random)
      end
    end
  end
end # Window_BattleEnemy < Window_Selectable 

Modificato da Killer Van, 02 August 2018 - 10:49 AM.

[Holy87]

undefined method 'animated_battler' for 1:Fixnum

ti sta dicendo che non esiste il metodo 'animated_battler' di un semplice numero. E mi pare anche giusto, perché da un numero dovrebbe ricavare l'eroe?
Primo problema: gli passi un numero e non l'eroe.
Secondo problema: hai messo la generazione della bitmap nell'update. Il metodo blt è time-consuming, cioè influisce nelle prestazioni. Farlo n volte per ogni frame rallenterà non poco il gioco.
La bitmap deve essere elaborata SOLO all'inizio, non ad ogni frame.
Vedo che all'inizio della classe, viene inizializzata anche con il parametro battler. Questo sarà sicuramente un Game_Battler, quindi un eroe o un nemico.
Il secondo problema quindi è che non fa differenza sul se sia un eroe o un mostro, e quindi quando cercherà di trovare le armi equipaggiate di un nemico ti andrà in crash.

Sempre per battler, è probabile che l'oggetto che cerchi è @battler. È questo che devi passargli, ricordandoti che la bitmap la devi generare solo se è un eroe (if @battler.actor?)

[Killer Van]

1 - Quindi nelle parentesi dovrei scrivere qualcosa come ($data_actors[1])  ?

2 - Lo so, infatti nello script che avevo scritto all'inizio avevo messo body.blt fuori dall'update, mentre i materiali per fare la sovrapposizione dentro l'update; e, a dir la verità, non so neanche perchè tutto funzionava (il gioco non laggava e lo sprite dell'battler era quello giusto).

Spoiler

body = Cache.zeck('corpo',0)
copricapo_capelli = Cache.zeck_copricapo('copricapo_capelli', 0)
body.blt(0, 0,  copricapo_capelli, Rect.new(0, 0, 384, 1344))

def update_bitmap
     body = Cache.zeck('corpo',0)
     copricapo_capelli = Cache.zeck_copricapo('copricapo_capelli', 0)
    if bitmap != body
      self.bitmap = body
      spritesheet_normal
      init_visibility
    end
  end

In questo caso come posso fare?

Perchè da quello che ho capito lui non genera una bitmap e la utilizza, ma continua a caricarla dal file

script di Galv :

Spoiler

def update_bitmap

    new_bitmap = Cache.battler(@battler.animated_battler,
      @battler.battler_hue)
    if bitmap != base_bitmap
      self.bitmap = base_bitmap
      spritesheet_normal
      init_visibility
    end
  end 

3 - Quindi lo script finale dovrebbe essere così

Spoiler

def generate_battler_bitmap(actor)
  if @battler.actor?
  base_bitmap = Cache.battler(actor.animated_battler, 0) # è un esempio, base_bitmap dovrebbe avere la grafica dell'eroe nudo
  base_bitmap = base_bitmap.clone # ne faccio un clone per non sporcare la bitmap nella cache
  rect = Rect.new(0, 0, base_bitmap.width, base_bitmap.height)
  actor.equips.each {|equip| # per ogni equipaggiamento
    next if equip.nil? # passo al prossimo se l'equip non esiste
      if !equip.battler_graphic(actor.id).empty? # se la stringa non è vuota
        base_bitmap.blt(0, 0, Cache.battler(equip.battler_graphic(actor.id), 0), rect)
      end
      end
    }
  base_bitmap # restituisco la bitmap elaborata
end

???

Modificato da Killer Van, 02 August 2018 - 18:56 PM.

[Holy87]

Ma diamine, ma se scrivi $data_actors[1] non significa che gli darai SOLO il primo eroe?
Vuoi che tutti i mostri e gli eroi abbiano la stessa grafica?

if @battler.actor?

e dov'è l'end?
Te lo devo fare tutto io lo script, oppure vuoi imparare e quindi solo qualche aiuto? Non ho capito.
A questo punto dovresti capire come fare una condizione, ti ho anche dato una guida
La condizione deve stare all'esterno: se è un eroe, usa questo metodo. Altrimenti no.
Dovevi chiamare il metodo con generate_battler_bitmap(@battler.base_bitmap)

[Killer Van]

Voglio capire come funziona, non voglio che tu mi scriva lo script, ho scritto $data_actors[1] riferendomi a quando utilizzo il comando (ovviamente riferendomi a quello che ho scritto nel messaggio precedente)
L'end l'ho messo, nello script che avevi scritto tu, c'erano 2 end, adesso ce ne sono 3.

 
 poi, per ottenere la bitmap(non so dove tu voglia metterla)

• def generate_battler_bitmap(actor)
• base_bitmap = Cache.battler(actor.base_bitmap, 0) # è un esempio, base_bitmap dovrebbe avere la grafica dell'eroe nudo
• base_bitmap = base_bitmap.clone # ne faccio un clone per non sporcare la bitmap nella cache
• rect = Rect.new(0, 0, base_bitmap.width, base_bitmap.height)
• actor.equips.each {|equip| # per ogni equipaggiamento
• next if equip.nil? # passo al prossimo se l'equip non esiste
• if !equip.battler_graphic.empty? # se la stringa non è vuota
• base_bitmap.blt(0, 0, Cache.battler(equip.battler_graphic, 0), rect)
• end
• }
• base_bitmap # restituisco la bitmap elaborata
• end

Comunque
ho provato a mettere l'if fuori e mi dice che actor? non è definito in Nil Class

Consigli?

Modificato da Killer Van, 03 August 2018 - 14:13 PM.

[Killer Van]

Allora, da quello che ho capito dovrei scrivere

Spoiler

def generate_battler_bitmap(@battler.base_bitmap)

  base_bitmap = Cache.battler(actor.base_bitmap, 0) # è un esempio, base_bitmap dovrebbe avere la grafica dell'eroe nudo

  base_bitmap = base_bitmap.clone # ne faccio un clone per non sporcare la bitmap nella cache

  rect = Rect.new(0, 0, base_bitmap.width, base_bitmap.height)

  actor.equips.each {|equip| # per ogni equipaggiamento

    next if equip.nil? # passo al prossimo se l'equip non esiste

      if !equip.battler_graphic(actor.id).empty? # se la stringa non è vuota

        base_bitmap.blt(0, 0, Cache.battler(equip.battler_graphic(actor.id), 0), rect)

      end

    }

  base_bitmap # restituisco la bitmap elaborata

end

poi quando utilizzo questo metodo devo mettere l'if prima e l'end dopo

Ma nelle parentesi quando utilizzo il metodo cosa devo scrivere, o meglio come posso definire base_bitmap in Game Battler?

e poi dove devo generare la bitmap? Forse in Scene Battle?

[Holy87]

Ok, ok, ricominciamo dalle basi, perché sono quelle che mancano.
Prima di tutto, devi capire il concetto di programmazione orientata ad oggetti, delle classi e delle istanze.
Invece di spiegarlo per l'ennesima volta qui, ti consiglio di leggere la mia guida dalla pagina 33.

Letto? Bene.

Ora, sono andato a scaricare il codice originale dello script, ed ho trovato subito questo

Come vedi, c'è già un attributo pubblico che è animated_battler.
Dove viene usato? Cerchiamo nel codice…

Più o meno avevi azzeccato, ma fatto sta che caricare l'immagine dalla Cache è una cosa, riprodurla ad ogni frame è un'altra.
Devi fare in modo che se l'immagine dell'eroe è già elaborata, la salvi nella Cache, altrimenti la elabori. Così solo la prima volta verrà elaborata, mentre le altre volte sarà semplicemente caricata.
A questo punto, è la Cache che dovrebbe creare l'immagine (e salvarla), del come spero che ci arriverai da solo.
Ovviamente, dovrai fare anche in modo che al cambiamento dell'equipaggiamento, quell'immagine venga reimpostata.

[Killer Van]

Da quello che ho capito per crearla bisogna utilizzare generate_battler_bitmap, mentre per caricarla dalla Cache ad ogni frame bisogna scrivere una cosa così?

Spoiler

def update_bitmap
    new_bitmap = Cache.battler(base_bitmap, 0)
    if bitmap != new_bitmap
      self.bitmap = new_bitmap
      spritesheet_normal
      init_visibility
    end
  end 

 

 

dove base_bitmap appunto è la grafica con armatura dell'eroe.

Ma non ho ancora capito come creare questa bitmap, non so come utilizzare o meglio adattare al mio progetto questa parte di script che mi hai dato:

Spoiler

def generate_battler_bitmap(actor)
  base_bitmap = Cache.battler(actor.base_bitmap, 0) # è un esempio, base_bitmap dovrebbe avere la grafica dell'eroe nudo
  base_bitmap = base_bitmap.clone # ne faccio un clone per non sporcare la bitmap nella cache
  rect = Rect.new(0, 0, base_bitmap.width, base_bitmap.height)
  actor.equips.each {|equip| # per ogni equipaggiamento
    next if equip.nil? # passo al prossimo se l'equip non esiste
      if !equip.battler_graphic(actor.id).empty? # se la stringa non è vuota
        base_bitmap.blt(0, 0, Cache.battler(equip.battler_graphic(actor.id), 0), rect)
      end
    }
  base_bitmap # restituisco la bitmap elaborata
end 

Consigli?

[Holy87]

E dalle… Dimentica base_bitmap, non esiste, è un esempio (come descritto appunto nel commento), non è che dando nomi a caso funziona!
Ti ho appena fatto uno Screenshot dell'attributo da utilizzare, quello è il nome dell'immagine del battler dell'eroe, bastava cercare l'attributo vero come avevo detto!
Ti ho anche detto che il metodo per generare la bitmap è meglio piazzarlo nella Cache!
Sembra che il mio ultimo post non sia proprio stato letto!
Allora, quello che dovevi fare era

module Cache
  def self.actor_battler(filename, actor)
    if include?('battler_' + filename)
      load_bitmap('battler_', filename)
    else
      generate_battler_bitmap(filename, actor)
    end
  end

  def self.generate_battler_bitmap(filename, actor)
    base_bitmap = Cache.battler(filename, 0) # è un esempio, base_bitmap dovrebbe avere la grafica dell'eroe nudo
    base_bitmap = base_bitmap.clone # ne faccio un clone per non sporcare la bitmap nella cache
    rect = Rect.new(0, 0, base_bitmap.width, base_bitmap.height)
    actor.equips.each {|equip| # per ogni equipaggiamento
      next if equip.nil? # passo al prossimo se l'equip non esiste
      if !equip.battler_graphic(actor.id).empty? # se la stringa non è vuota
        base_bitmap.blt(0, 0, Cache.battler(equip.battler_graphic(actor.id), 0), rect)
      end
    }
    base_bitmap # restituisco la bitmap elaborata
  end

  # cancella l'immagine dell'eroe dalla cache
  def self.reset_actor_bitmap(filename)
    if include?('battler_' + filename)
      @cache['battler_' + filename] = nil
    end
  end
end

questo è ciò che dovrebbe essere aggiunto in Cache.

Per quanto riguarda lo script di Galv, questo era il metodo da modificare

class Sprite_AnimBattler < Sprite_AnimBattler
  def update_bitmap
    if @battler.actor?
      new_bitmap = Cache.actor_battler(@battler.animated_battler,
                                       @battler)
    else
      new_bitmap = Cache.battler(@battler.animated_battler,
                                 @battler.battler_hue)
    end
    if bitmap != new_bitmap
      self.bitmap = new_bitmap
      spritesheet_normal
      init_visibility
    end
  end
end

come vedi basta una condizione che se è l'eroe, carica il battler creato con l'equipaggiamento

infine, la cancellazione della bitmap nella Cache quando l'eroe cambia equipaggiamento, così da aggiornare l'immagine al prossimo caricamento

class Game_Actor < Game_Battler
  alias equip_change_graphic refresh unless $@ # alias del metodo refresh

  # viene chiamato quando si cambia equip
  def refresh
    equip_change_graphic # richiamo il metodo copiato
    Cache.reset_actor_bitmap(self.animated_battler)
  end
end

per la spiegazione sugli alias, come sempre leggi la guida.