Killer Van

August 18, 2018

Credevo che funzionasse tutto bene, invece ho visto che andando ad equipaggiare sempre più cose il gioco in battaglia comincia a laggare, e non poco (13 fps)

Secondo te qual è il problema?

Consigli per il post precedente?

August 9, 2018

1. Ho capito, ma credo che si potrebbe fare, anche se più lungo e forse meno corretto, in questo modo:

al posto di actor.equips.each (per ogni equipaggiamento), andare a controllare uno alla volta gli equipaggiamenti:

if !equip[0].nil?
base_bitmap.blt(0,0,Cache.battler....))
end
if !equip[2].nil?
base_bitmap.blt(0,0,Cache.battler....))

(i numeri li ho messi a caso).

2. Credo di aver capito, ma non ho idea di come farlo, intendi che ad ogni equipaggiamento non sarebbe più assegnato solo un nome ma anche più nomi (solo la spada ne avrebbe 2)

3. Peccato.

4. Ho provato a scrivere questo, ma non funziona, è come se ignorasse la condizione:

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
    }
    if equip[2].nil?
      base_bitmap.blt(0, 0, Cache.battler("Capelli" + actor.id, 0), rect) 
      end
  base_bitmap # restituisco la bitmap elaborata
end

Forse ("Capelli" + actor.id , 0) non vuol dire niente?

E poi facendo così lo metterebbe sopra tutto e non dove andrebbe appunto l'elmo.

Consigli?

August 8, 2018

Funziona, ma ci sono dei problemi,

1 come posso assegnare una diversa priorità agli equipaggiamenti, in modo che le sovrapposizioni creino la giusta bitmap? (spada, corpo, armatura...)

2 per la spada mi servirebbero 2 immagini da caricare per creare la bitmap, quella che sta dietro al personaggio e quella che sta davanti al personaggio

3 ho disegnato una spada che ha dei pixel semitrasparenti, ma in battaglia tutti i pixel ottengono opacità massima (255). credo sia un problema dell' hue, ho provato a smanettare con il codice ma il problema resta.

4 poi per l'equipaggiamento del copricapo servirebbe creare una cosa del genere:

se è equipaggiato un copricapo, carica il suo file immagine,

se non è equipaggiato nientecarica il file immagine dei capelli.

Come posso fare?

August 7, 2018

Mi da questo errore:

Script 'battaglia' line 712 IndexError occurred.

index 1 out of string

riguarda l'assegnazione del file alle armature

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

August 6, 2018

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ì?

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:

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?

August 6, 2018

Allora, da quello che ho capito dovrei scrivere

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?

August 2, 2018

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?

August 2, 2018

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).

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 :

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ì

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

???

August 2, 2018

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:

##------------------------------------------------------------------------------#
#  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 !@states.empty?
      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 || !@subject.current_action || !@subject.current_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 !@battler.bactivated
    @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

August 2, 2018

Come?

August 2, 2018

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?

August 2, 2018

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

August 1, 2018

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?

August 1, 2018

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

August 1, 2018

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

August 1, 2018

L'errore me lo da su equips, mentre base_bitmap non so come definirlo.

August 1, 2018

No non ho capito, poi ho provato ad assegnare a base_bitmap, che appunto mi dava errore, un file ma mi dava comunque errore su equips di:

Cache.battler(actor.base_bitmap, 0)

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

August 1, 2018

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

Io per ogni attore ho grafiche nude diverse ed equipaggiamenti diversi

es:

nudo gigi è diverso da nudo gigia.

spada di fuoco di gigi è diversa da spada di fuoco di gigia ecco perchè all'inizio le avevo divise in cartelle diverse.

July 31, 2018

Battler, infatti, ho notato che nelle scorse tue risposte avevi frainteso,

lo so che definire un metodo per ogni eroe e arma non è pratico, infatti devo cambiarlo.

Ho provato a dargli questo attributo nelle note ma non sono riuscito, adesso provo ancora e stasera ti faccio sapere

Sera: non sono riuscito, perchè io dovrei scrivere una cosa come:

def nome_eroe

end
def copricapo_equipaggiato

end
def busto_equipaggiato

end
def pantaloni_equipaggiati

end
def scarpe_equipaggiate

end
def spada_equipaggiata
end
body = Cache.Corpi(nome_eroe,0) 
copricapo = Cache.Corpicapi(copricapo_equipaggiato,0) 
busto = Cache.Busti(busto_equipaggiato,0) 
pantaloni = Cache.Pantaloni(pantaloni_equipaggiati,0) 
scarpe = Cache.Scarpe(scarpe_equipaggiate,0) 
spada = Cache.Spade(spada_equipaggiata,0) 
#poi devo fare tutti e le sovrapposizioni

Questo dovrebbe valere per tutti gli eroi

come posso fare tutte le definizioni?

July 30, 2018

Ho un' altro problema, sempre legato al fatto che non riesco a dire allo script di unire determinate immagini, in base all'equipaggiamento ed al nome del personaggio.

Lo script che ho scritto è questo

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 Cache ho definito sia .zeck che .zeck_copricapo.

il problema è che così facendo tutti i battler sullo schermo hanno questo sprite, mentre io vorrei far si che a seconda del loro nome ed equipaggiamento avessero sprite diversi.

Come posso fare?

July 25, 2018

Grazie mille Holy87.

Con il tuo aiuto e altre ricerche su internet, sono riuscito a mettere l'armatura al mio battler; e la mia immagine di profilo ne è la prova.

Ma per fare questo ho detto io allo script quali file utilizzare.

Vorrei creare un'altra parte di script che ottiene le informazioni riguardanti l'equipaggiamento dei personaggi e prenda da solo le immagini.

Ho cercato tanti comandi e ho trovato il comando equips nella guida di rpg maker ma da quello che ho capito serve per impostare l'equipaggiamento iniziale del personaggio e non per farti restituire il suo equipaggiamento attuale.

Come posso fare?

Grazie in anticipo

July 19, 2018

Ok scusa leggerò tutta la guida

July 19, 2018

Quindi, ovunque nel progetto cercherei di ottenere l'oggetto sprite dell'eroe, facendo

$game_map.character_sprites[0].aggiorna_sprite # 0 è l'eroe

ovunque in che senso?

ho letto la parte riguardante le bitmap della tua guida e mi sembra di aver capito, il problema e che non riesco a scrivere lo script.

July 19, 2018

ok ma per assegnare lo sprite al personaggio devo dirgli il nome dello sprite, ho provato a scrivere corpo, e corpo.blt, ma corpo.blt non lo trova; e se scrivo corpo assegna al personaggio lo sprite che avevo all'inizio.

da quello che ho capito devo assegnarli la bitmap, ma come faccio?

July 18, 2018

Ho cercato di informarmi meglio e tirato giù questo script

corpo = Bitmap.new("./Graphics/Battlers/corpo.png") 
copricapo_capelli = Bitmap.new("./Graphics/Battlers/copricapo_capelli.png")
 def blt(x, y, src_corpo, src_copricapo_capelli, opacity = 255)
end

Il problema è che non crea un file di immagine o se lo crea io non riesco a trovarlo da nessuna parte.

A me servirebbe proprio un file.

Sign In

Killer Van

Posts

Joined

Last visited

Content Type

Profiles

Forums

Calendar

Posts posted by Killer Van

Sportello aiuti veloci VX-Ace

Sportello aiuti veloci VX-Ace

Sportello aiuti veloci VX-Ace

Sportello aiuti veloci VX-Ace

Sportello aiuti veloci VX-Ace

Sportello aiuti veloci VX-Ace

Sportello aiuti veloci VX-Ace

Sportello aiuti veloci VX-Ace

Sportello aiuti veloci VX-Ace

Sportello aiuti veloci VX-Ace

Sportello aiuti veloci VX-Ace

Sportello aiuti veloci VX-Ace

Sportello aiuti veloci VX-Ace

Sportello aiuti veloci VX-Ace

Sportello aiuti veloci VX-Ace

Sportello aiuti veloci VX-Ace

Sportello aiuti veloci VX-Ace

Sportello aiuti veloci VX-Ace

Sportello aiuti veloci VX-Ace

Sportello aiuti veloci VX-Ace

Sportello aiuti veloci VX-Ace

Sportello aiuti veloci VX-Ace

Sportello aiuti veloci VX-Ace

Sportello aiuti veloci VX-Ace

Sportello aiuti veloci VX-Ace

Browse

Activity