Scripts Errors

DemoniacWind · May 4, 2014

The first script is:

#:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=
# ▼ Animated Battlers

# Author: Kread-EX

# Version 1.08

# Release date: 28/11/2012

#:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=

#------------------------------------------------------------------------------

# ▼ UPDATES

#------------------------------------------------------------------------------

# # 07/04/2013. Added option for linking animations during skill use.

# # 04/04/2013. Fixed a bug with guarding.

# # 18/02/2013. Fixed another bug with Dual Wielding.

# # 16/02/2013. Fixed a bug with Dual Wielding.

# # 15/02/2013. Compatibility with Symphony.

# # 15/02/2013. Added state animations and a few other options.

# # 15/02/2013. Compatibility with modern algebra's Flash Enemy.

# # 05/01/2013. Compatibility with Banish Skills.

#------------------------------------------------------------------------------

# ▼ INTRODUCTION

#------------------------------------------------------------------------------

# # This script will allow you to use battle animations as animation battlers.

# # It sounds simple enough but please read the instructions.

# #

# # DON'T ASK ME FOR A DEMO. PLEASE.

#------------------------------------------------------------------------------

# ▼ INSTRUCTIONS

#------------------------------------------------------------------------------

# # I direct you to this page: http://wp.me/P22oyp-ca

#------------------------------------------------------------------------------

# ▼ TERMS OF USAGE

#------------------------------------------------------------------------------

# # You are free to adapt this work to suit your needs.

# # You can use this work for commercial purposes if you like it.

# # Credit is appreciated.

# #

# # For support:

# # grimoirecastle.wordpress.com

# # rpgmakerweb.com

#------------------------------------------------------------------------------

# ▼ COMPATIBILITY

#------------------------------------------------------------------------------

# # Works with the DBS and Ace Battle Engine.

# # List of aliases and overwrites:

# #

# # DataManager

# # load_database (alias)

# # load_aniB_notetags (new method)

# #

# # BattleManager

# # process_victory (alias)

# #

# # RPG::Actor, RPG::Class, RPG::Enemy

# # load_aniB_notetags (new method)

# # animation_data (new method)

# #

# # RPG::UsableItem

# # load_aniB_notetags (new method)

# # battler_anim_id (new attr method)

# # move_to_target (new attr method)

# #

# # Game_Battler

# # skill_pose_active (new attr method)

# # item_pose_active (new attr method)

# # x_destination (new attr method)

# # y_destination (new attr method)

# # movement_type (new attr method)

# # animation_data (new method)

# # skill_battler_anim (new method)

# # item_battler_anim (new method)

# # on_action_end (alias)

# # is_moving? (new method)

# #

# # Game_Actor

# # victory_pose (new attr method)

# # perform_collapse_effect (alias)

# # screen_x (overwrite)

# # screen_y (overwrite)

# # screen_z (overwrite)

# # use_sprite? (overwrite)

# #

# # Sprite_Battler

# # screen_x (new attr method)

# # screen_y (new attr method)

# # initialize (alias)

# # update (alias)

# # update_bitmap (overwrite)

# # update_position (overwrite)

# # update_movement (new method)

# # update_battler_poses (new method)

# # animation? (overwrite)

# # battler_animation? (new method)

# # start_battler_animation (new method)

# # load_battler_animation_bitmap (new method)

# # make_battler_animation_sprites (new method)

# # set_battler_animation_origin (new method)

# # move_battler_animation (new method)

# # dispose_battler_animation (new method)

# # update_battler_animation (new method)

# # battler_animation_set_sprites (new method)

# # battler_animation_process_timing (new method)

# # get_current_pose (new method)

# # update_collapse (alias)

# # update_boss_collapse (overwrite)

# #

# # Window_BattleActor

# # update (alias)

# #

# # Scene_Battle

# # execute_action (alias)

# # move_to_target (new method)

# # move_back_to_pos (new method)

#------------------------------------------------------------------------------

($imported ||= {})['KRX-AnimatedBattlers'] = true

#puts 'Load: Animated Battlers v1.08 by Kread-EX'

module KRX

#===========================================================================

# ■ CONFIGURATION

#===========================================================================

ACTOR_POSITIONS = [[400, 300], [460, 320], [520, 340], [580, 360]]

VICTORY_DELAY = 30

MAX_SPRITES = 16

MOVEMENT_Y_OFFSET = 64

# Set this to true to make the attack anim play twice for dual wielders.

DUAL_WIELDING = false

#===========================================================================

# ■ CONFIGURATION ENDS HERE

#===========================================================================

module REGEXP

ANIM_TAG_START = //i

ANIM_TAG_END = /<\/animation_block>/i

ANIM_STANDING = /standing:[ ]*(\d+)/i

ANIM_DANGER = /danger:[ ]*(\d+)/i

ANIM_HIT = /hit:[ ]*(\d+)/i

ANIM_DEAD = /dead:[ ]*(\d+)/i

ANIM_VICTORY = /victory:[ ]*(\d+)/i

ANIM_ITEM_DEFAULT = /item_default:[ ]*(\d+)/i

ANIM_SKILL_DEFAULT = /skill_default:[ ]*(\d+)/i

ANIM_ITEM = /item:[ ]*(\d+(?:\s*,\s*\d+*)*)/i

ANIM_SKILL = /skill:[ ]*(\d+(?:\s*,\s*\d+*)*)/i

ANIM_STATE = /state:[ ]*(\d+(?:\s*,\s*\d+*)*)/i

ANIM_MOV_F = /move_f:[ ]*(\d+)/

ANIM_MOV_B = /move_b:[ ]*(\d+)/

ANIM_MIRROR = /mirror/i

ANIM_GUARD = /guard:[ ]*(\d+)/i

ANIM_ON_ITEM = //i

ANIM_TO_TARGET = //i

end

end

#===========================================================================

# ■ DataManager

#===========================================================================

module DataManager

#--------------------------------------------------------------------------

# ● Loads the database

#--------------------------------------------------------------------------

class << self; alias_method

krx_aniB_dm_ld, :load_database); end

def self.load_database

krx_aniB_dm_ld

load_aniB_notetags

end

#--------------------------------------------------------------------------

# ● Loads the note tags

#--------------------------------------------------------------------------

def self.load_aniB_notetags

groups = [$data_skills, $data_items, $data_actors, $data_classes,

$data_enemies]

for group in groups

for obj in group

next if obj.nil?

obj.load_aniB_notetags

end

end

#puts "Read: Animated Battlers Notetags"

end

end

#===========================================================================

# ■ BattleManager

#===========================================================================

module BattleManager

#--------------------------------------------------------------------------

# ● Process the battle victory

#--------------------------------------------------------------------------

class << self; alias_method

krx_aniB_bm_pv,

rocess_victory); end

def self.process_victory

$game_party.members.each {|m| m.victory_pose = true}

KRX::VICTORY_DELAY.times {SceneManager.scene.update_basic}

krx_aniB_bm_pv

$game_party.members.each {|m| m.victory_pose = false}

end

end

#===========================================================================

# ■ RPG::Actor, RPG::Class, RPG::Enemy

#===========================================================================

module KRX

module ANIMATED_BATTLERS

#--------------------------------------------------------------------------

# ● Loads the note tags

#--------------------------------------------------------------------------

def load_aniB_notetags

@animation_data = {}

@note.split(/[\r\n]+/).each do |line|

case line

when KRX::REGEXP::ANIM_TAG_START

@enable_aniB_tags = true

when KRX::REGEXP::ANIM_TAG_END

@enable_aniB_tags = false

when KRX::REGEXP::ANIM_STANDING

@animation_data[:stand] = $1.to_i if @enable_aniB_tags

when KRX::REGEXP::ANIM_DANGER

@animation_data[:danger] = $1.to_i if @enable_aniB_tags

when KRX::REGEXP::ANIM_HIT

@animation_data[:hit] = $1.to_i if @enable_aniB_tags

when KRX::REGEXP::ANIM_DEAD

@animation_data[:dead] = $1.to_i if @enable_aniB_tags

when KRX::REGEXP::ANIM_VICTORY

@animation_data[:victory] = $1.to_i if @enable_aniB_tags

when KRX::REGEXP::ANIM_ITEM_DEFAULT

@animation_data[:dflt_item] = $1.to_i if @enable_aniB_tags

when KRX::REGEXP::ANIM_SKILL_DEFAULT

@animation_data[:dflt_skill] = $1.to_i if @enable_aniB_tags

when KRX::REGEXP::ANIM_MIRROR

@animation_data[:mirror] = true if @enable_aniB_tags

when KRX::REGEXP::ANIM_GUARD

@animation_data[:guard] = $1.to_i if @enable_aniB_tags

when KRX::REGEXP::ANIM_MOV_F

@animation_data[:move_f] = $1.to_i if @enable_aniB_tags

when KRX::REGEXP::ANIM_MOV_B

@animation_data[:move_b] = $1.to_i if @enable_aniB_tags

when KRX::REGEXP::ANIM_ITEM

if @enable_aniB_tags

@animation_data[:item] ||= []

$1.scan(/\d+/).each {|i| @animation_data[:item].push(i.to_i)}

end

when KRX::REGEXP::ANIM_SKILL

if @enable_aniB_tags

@animation_data[:skill] ||= []

$1.scan(/\d+/).each {|i| @animation_data[:skill].push(i.to_i)}

end

when KRX::REGEXP::ANIM_STATE

if @enable_aniB_tags

@animation_data[:states] ||= []

$1.scan(/\d+/).each {|i| @animation_data[:states].push(i.to_i)}

end

end

end

end

#--------------------------------------------------------------------------

# ● Returns the animation settings

#--------------------------------------------------------------------------

def animation_data(key)

@animation_data[key]

end

end

end

class RPG::Actor < RPG::BaseItem

include KRX::ANIMATED_BATTLERS

end

class RPG::Class < RPG::BaseItem

include KRX::ANIMATED_BATTLERS

end

class RPG::Enemy < RPG::BaseItem

include KRX::ANIMATED_BATTLERS

end

#===========================================================================

# ■ RPG::UsableItem

#===========================================================================

class RPG::UsableItem < RPG::BaseItem

#--------------------------------------------------------------------------

# ● Public instance variables

#--------------------------------------------------------------------------

attr_reader :battler_anim_id

attr_reader :move_to_target

attr_reader :move_direction

#--------------------------------------------------------------------------

# ● Loads the note tags

#--------------------------------------------------------------------------

def load_aniB_notetags

@note.split(/[\r\n]+/).each do |line|

case line

when KRX::REGEXP::ANIM_ON_ITEM

@battler_anim_id = $1.to_i

when KRX::REGEXP::ANIM_TO_TARGET

@move_to_target = true

@move_direction = $1.to_i

@move_direction ||= 0

end

end

end

end

#===========================================================================

# ■ Game_Battler

#===========================================================================

class Game_Battler < Game_BattlerBase

#--------------------------------------------------------------------------

# ● Public instance variables

#--------------------------------------------------------------------------

attr_accessor :skill_pose_active

attr_accessor :item_pose_active

attr_accessor :x_destination

attr_accessor :y_destination

attr_accessor :movement_type

#--------------------------------------------------------------------------

# ● Returns the battler animation data

#--------------------------------------------------------------------------

def animation_data(key)

if actor?

if actor.animation_data(key).nil?

self.class.animation_data(key)

else

actor.animation_data(key)

end

else

enemy.animation_data(key)

end

end

#--------------------------------------------------------------------------

# ● Returns the battler animation ID for a specific skill

#--------------------------------------------------------------------------

def skill_battler_anim(id)

data = animation_data

skill) || []

data.each_index do |i|

next if i % 2 != 0

return data[i+1] if data == id

end

$data_skills[id].battler_anim_id ? $data_skills[id].battler_anim_id :

animation_datadflt_skill)

end

#--------------------------------------------------------------------------

# ● Returns the battler animation ID for a specific item

#--------------------------------------------------------------------------

def item_battler_anim(id)

data = animation_dataitem) || []

data.each_index do |i|

next if i % 2 != 0

return data[i+1] if data == id

end

$data_items[id].battler_anim_id ? $data_items[id].battler_anim_id :

animation_datadflt_item)

end

#--------------------------------------------------------------------------

# ● Returns the battler animation ID for a specific state

#--------------------------------------------------------------------------

def state_battler_anim(id)

data = animation_datastates) || []

data.each_index do |i|

next if i % 2 != 0

return data[i+1] if data == id

end

nil

end

#--------------------------------------------------------------------------

# ● Clears the action data

#--------------------------------------------------------------------------

alias_methodkrx_aniB_gb_oae, n_action_end)

def on_action_end

krx_aniB_gb_oae

@skill_pose_active = false

@item_pose_active = false

end

#--------------------------------------------------------------------------

# ● Determine if the battler is moving on the battle screen

#--------------------------------------------------------------------------

unless $imported["YES-BattleSymphony"]

def is_moving?

((@x_destination || 0) > 0) || ((@y_destination || 0) > 0)

end

end

#--------------------------------------------------------------------------

# ● Update movement (Symphony)

#--------------------------------------------------------------------------

if $imported["YES-BattleSymphony"]

def update_movement

return unless self.is_moving?

@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 = [(@screen_x - @destination_x).abs, @move_x_rate].min

ofx = (@destination_x > @screen_x) ? value : -value

@screen_x += (@destination_x > @screen_x) ? value : -value

value = [(@screen_y - @destination_y).abs, @move_y_rate].min

ofy = (@destination_y > @screen_y) ? value : -value

@screen_y += (@destination_y > @screen_y) ? value : -value

sprite.move_battler_animation(ofx, ofy)

end

#--------------------------------------------------------------------------

# ● Update jump (Symphony)

#--------------------------------------------------------------------------

def update_jump

return unless self.is_moving?

#---

value = [(@screen_x - @destination_x).abs, @move_x_rate].min

@screen_x += (@destination_x > @screen_x) ? value : -value

ofx = (@destination_x > @screen_x) ? value : -value

@parabola[:x] += value

@screen_y -= @arc_y

#---

if @destination_x == @screen_x

@screen_y = @destination_y

@arc_y = 0

@arc = 0

else

a = (2.0*(@parabola[:y0]+@parabola[:y1])-4*@parabola[:h])/(@parabola[

]**2)

b = (@parabola[:y1]-@parabola[:y0]-a*(@parabola[

]**2))/@parabola[

]

@arc_y = a * @parabola[:x] * @parabola[:x] + b * @parabola[:x] + @parabola[:y0]

end

#---

@screen_y += @arc_y

@move_x_rate = 0 if @screen_x == @destination_x

@move_y_rate = 0 if @screen_y == @destination_y

sprite.move_battler_animation(ofx, @arc_y)

end

end

end

#===========================================================================

# ■ Game_Actor

#===========================================================================

class Game_Actor < Game_Battler

#--------------------------------------------------------------------------

# ● Public instance variables

#--------------------------------------------------------------------------

attr_accessor :victory_pose

#--------------------------------------------------------------------------

# ● Perform the collapse effect if dead

#--------------------------------------------------------------------------

alias_methodkrx_aniB_ga_pce, erform_collapse_effect)

def perform_collapse_effect

return if animation_datadead) != nil

krx_aniB_ga_pce

end

#--------------------------------------------------------------------------

# ● Return x coordinates on battle screen

#--------------------------------------------------------------------------

unless $imported["YES-BattleSymphony"]

def screen_x

KRX::ACTOR_POSITIONS[index][0]

end

#--------------------------------------------------------------------------

# ● Return y coordinates on battle screen

#--------------------------------------------------------------------------

def screen_y

KRX::ACTOR_POSITIONS[index][1]

end

end

#--------------------------------------------------------------------------

# ● Return z coordinates on battle screen

#--------------------------------------------------------------------------

def screen_z

return 100

end

#--------------------------------------------------------------------------

# ● The actors will use a sprite

#--------------------------------------------------------------------------

def use_sprite?

return true

end

end

#==============================================================================

# ■ Sprite_Battler

#==============================================================================

class Sprite_Battler < Sprite_Base

#--------------------------------------------------------------------------

# ● Public instance variables

#--------------------------------------------------------------------------

attr_reader :screen_x

attr_reader :screen_y

#--------------------------------------------------------------------------

# ● Object Initialize

#--------------------------------------------------------------------------

alias_methodkrx_aniB_sb_init, :initialize)

def initialize(viewport, battler = nil)

krx_aniB_sb_init(viewport, battler)

@battler_ani_duration = 0

@blank_bitmap = Bitmap.new(48, 48)

end

#--------------------------------------------------------------------------

# ● Frame Update

#--------------------------------------------------------------------------

alias_methodkrx_abiB_sb_update, :update)

def update

dispose_battler_animation unless @battler || !battler_animation?

krx_abiB_sb_update

update_movement

@charset_shadow.visible = false if $imported["YES-BattleSymphony"]

end

#--------------------------------------------------------------------------

# ● Updates the initial bitmap

#--------------------------------------------------------------------------

def update_bitmap

self.bitmap = @blank_bitmap if self.bitmap != @blank_bitmap

update_battler_poses

update_flash_and_whiten

end

#--------------------------------------------------------------------------

# ● Updates the coordinates

#--------------------------------------------------------------------------

unless $imported["YES-BattleSymphony"]

def update_position

self.x = @screen_x || @battler.screen_x

self.y = @screen_y || @battler.screen_y

self.z = @battler.screen_z

end

end

#--------------------------------------------------------------------------

# ● Updates the movement positions

#--------------------------------------------------------------------------

def update_movement

return unless @battler

return if $imported["YES-BattleSymphony"]

@battler.x_destination ||= 0

@battler.y_destination ||= 0

@screen_x ||= @battler.screen_x

@screen_y ||= @battler.screen_y

if @battler.x_destination != 0

sx, dx = @screen_x, @battler.x_destination

@screen_x = sx > dx ? [sx-16, dx].max : [sx+16, dx].min

mx = @screen_x - sx

move_battler_animation(mx, 0)

if @screen_x == dx

@battler.x_destination = 0

update_position

end

end

if @battler.y_destination != 0

sy, dy = @screen_y, @battler.y_destination

@screen_y = sy > dy ? [sy-8, dy].max : [sy+8, dy].min

my = @screen_y - sy

move_battler_animation(0, my)

if @screen_y == dy

@battler.y_destination = 0

update_position

end

end

end

#--------------------------------------------------------------------------

# ● Updates the battler poses

#--------------------------------------------------------------------------

def update_battler_poses

update_battler_animation

return if @battler.nil? || !@battler_visible

battler_anim_id = get_current_pose

return if battler_animation? || @no_loop

return if battler_anim_id.nil?

animation = $data_animations[battler_anim_id]

mirror = @battler.animation_datamirror)

if @battler.dual_wield? && @start_dual_wielding

@dual_wielding_done = true

@start_dual_wielding = false

end

start_battler_animation(animation, mirror)

end

#--------------------------------------------------------------------------

# ● Updates the flash and whiten effects

#--------------------------------------------------------------------------

def update_flash_and_whiten

unless @battler_ani_sprites.nil?

if @flash_color && @flash_duration > 0

d = @flash_duration

r, g, b = @flash_color.red, @flash_color.green, @flash_color.blue

@flash_color.alpha = @flash_color.alpha * (d - 1) / d

end

@battler_ani_sprites.each do |sprite|

if @flash_color && @flash_duration > 0

sprite.color.set(r, g, b, @flash_color.alpha)

end

if @effect_type == :whiten

sprite.color.set(255, 255, 255, 0)

sprite.color.alpha = 128 - (16 - @effect_duration) * 10

end

end

@flash_duration -= 1 if @flash_duration

end

end

#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

# * Update Flash (modern algebra Flash Selected Enemy)

#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

def update_fse_flash

unless @battler_ani_sprites.nil?

@battler_ani_sprites.each do |sprite|

sprite.color.set(*FSE_FLASH_COLOUR)

if @effect_duration > (FSE_FLASH_DURATION / 2)

sprite.color.alpha =

(FSE_FLASH_DURATION - @effect_duration) * @fse_flash_mod

else

sprite.color.alpha = @effect_duration * @fse_flash_mod

end

end

end

end

#--------------------------------------------------------------------------

# ● Determine if an anim is playing

#--------------------------------------------------------------------------

def animation?

@animation != nil || @banim_wait

end

#--------------------------------------------------------------------------

# ● Determine if a battler anim is playing

#--------------------------------------------------------------------------

def battler_animation?

@battler_animation != nil

end

#--------------------------------------------------------------------------

# ● Start the battler animation

#--------------------------------------------------------------------------

def start_battler_animation(animation, mirror)

dispose_battler_animation

@battler_animation = animation

@battler_mirror = mirror

if @battler_animation

set_animation_rate

@battler_ani_duration = @battler_animation.frame_max * @ani_rate + 1

load_battler_animation_bitmap

make_battler_animation_sprites

set_battler_animation_origin

update_battler_animation

end

end

#--------------------------------------------------------------------------

# ● Construct the animation bitmaps

#--------------------------------------------------------------------------

def load_battler_animation_bitmap

animation1_name = @battler_animation.animation1_name

animation1_hue = @battler_animation.animation1_hue

animation2_name = @battler_animation.animation2_name

animation2_hue = @battler_animation.animation2_hue

@battler_ani_bitmap1 = Cache.animation(animation1_name, animation1_hue)

@battler_ani_bitmap2 = Cache.animation(animation2_name, animation2_hue)

if @@_reference_count.include?(@battler_ani_bitmap1)

@@_reference_count[@battler_ani_bitmap1] += 1

else

@@_reference_count[@battler_ani_bitmap1] = 1

end

if @@_reference_count.include?(@battler_ani_bitmap2)

@@_reference_count[@battler_ani_bitmap2] += 1

else

@@_reference_count[@battler_ani_bitmap2] = 1

end

Graphics.frame_reset

end

#--------------------------------------------------------------------------

# ● Construct the animation sprites to hold the bitmaps

#--------------------------------------------------------------------------

def make_battler_animation_sprites

@battler_ani_sprites = []

if @use_sprite && !@@ani_spr_checker.include?(@battler_animation)

KRX::MAX_SPRITES.times do

sprite = ::Sprite.new(viewport)

sprite.visible = false

@battler_ani_sprites.push(sprite)

end

end

@battler_ani_duplicated = @@ani_checker.include?(@battler_animation)

end

#--------------------------------------------------------------------------

# ● Pinpoint the animation origin values

#--------------------------------------------------------------------------

def set_battler_animation_origin

@battler_ani_ox = x - ox + width / 2

@battler_ani_oy = y - oy + height / 2

if @battler_animation.position == 0

@battler_ani_oy -= height / 2

elsif @battler_animation.position == 2 || @battler_animation.position == 3

@battler_ani_oy += height / 2

end

end

#--------------------------------------------------------------------------

# ● Move the animation

#--------------------------------------------------------------------------

def move_battler_animation(dx, dy)

if @battler_ani_sprites

@battler_ani_ox += dx

@battler_ani_oy += dy

@battler_ani_sprites.each do |sprite|

sprite.x += dx

sprite.y += dy

end

end

end

#--------------------------------------------------------------------------

# ● Free the animation

#--------------------------------------------------------------------------

def dispose_battler_animation

if @battler_ani_bitmap1

@@_reference_count[@battler_ani_bitmap1] -= 1

if @@_reference_count[@battler_ani_bitmap1] == 0

@battler_ani_bitmap1.dispose

end

end

if @battler_ani_bitmap2

@@_reference_count[@battler_ani_bitmap2] -= 1

if @@_reference_count[@battler_ani_bitmap2] == 0

@battler_ani_bitmap2.dispose

end

end

if @battler_ani_sprites

@battler_ani_sprites.each {|sprite| sprite.dispose }

@battler_ani_sprites = nil

@battler_animation = nil

end

@battler_ani_bitmap1 = nil

@battler_ani_bitmap2 = nil

@flash_color = @flash_duration = nil

end

#--------------------------------------------------------------------------

# ● Update the animation

#--------------------------------------------------------------------------

def update_battler_animation

return unless battler_animation?

@battler_ani_duration -= 1

if @battler_ani_duration % @ani_rate == 0

if @battler_ani_duration > 0

frame_index = @battler_animation.frame_max

frame_index -= (@battler_ani_duration + @ani_rate - 1) / @ani_rate

@last_frame = frame_index

battler_animation_set_sprites(@battler_animation.frames[frame_index])

@battler_animation.timings.each do |timing|

battler_animation_process_timing(timing) if timing.frame == frame_index

end

else

@battler_animation = nil

end

end

end

#--------------------------------------------------------------------------

# ● Set the animation sprites' coordinates

#--------------------------------------------------------------------------

def battler_animation_set_sprites(frame)

cell_data = frame.cell_data

@battler_ani_sprites.each_with_index do |sprite, i|

next unless sprite

pattern = cell_data[i, 0]

if !pattern || pattern < 0

sprite.visible = false

next

end

sprite.bitmap = pattern < 100 ? @battler_ani_bitmap1 :

@battler_ani_bitmap2

sprite.visible = true

sprite.src_rect.set(pattern % 5 * 192,

pattern % 100 / 5 * 192, 192, 192)

if @battler_mirror

sprite.x = @battler_ani_ox - cell_data[i, 1]

sprite.y = @battler_ani_oy + cell_data[i, 2]

sprite.angle = (360 - cell_data[i, 4])

sprite.mirror = (cell_data[i, 5] == 0)

else

sprite.x = @battler_ani_ox + cell_data[i, 1]

sprite.y = @battler_ani_oy + cell_data[i, 2]

sprite.angle = cell_data[i, 4]

sprite.mirror = (cell_data[i, 5] == 1)

end

sprite.z = @battler.is_moving? ? self.z + 60 : self.z + i

sprite.ox = 96

sprite.oy = 96

sprite.zoom_x = cell_data[i, 3] / 100.0

sprite.zoom_y = cell_data[i, 3] / 100.0

sprite.opacity = cell_data[i, 6] * self.opacity / 255.0

sprite.blend_type = cell_data[i, 7]

end

end

#--------------------------------------------------------------------------

# ● Plays sounds and flash effects

#--------------------------------------------------------------------------

def battler_animation_process_timing(timing)

timing.se.play unless @battler_ani_duplicated

case timing.flash_scope

when 1

self.flash(timing.flash_color, timing.flash_duration * @ani_rate)

when 2

if viewport && !@battler_ani_duplicated

viewport.flash(timing.flash_color, timing.flash_duration * @ani_rate)

end

when 3

self.flash(nil, timing.flash_duration * @ani_rate)

end

end

#--------------------------------------------------------------------------

# ● Determine which pose should be used right now

#--------------------------------------------------------------------------

def get_current_pose

return unless @battler

# Standing

new_pose = @battler.animation_datastand)

# Dead

if @battler.dead?

new_pose = @battler.animation_datadead)

# Victory

elsif @battler.is_a?(Game_Actor) && @battler.victory_pose

new_pose = @battler.animation_datavictory)

# Moving toward target

elsif @battler.is_moving? && @battler.movement_type == 0

new_pose = @battler.animation_datamove_f)

# Moving back to initial position

elsif @battler.is_moving? && @battler.movement_type == 1

new_pose = @battler.animation_datamove_

# Guarding

elsif @battler.guard?

new_pose = @battler.animation_dataguard)

# Skill

elsif @battler.skill_pose_active

new_pose = @battler.skill_battler_anim(@battler.current_action.item.id)

# Item

elsif @battler.item_pose_active

new_pose = @battler.item_battler_anim(@battler.current_action.item.id)

# Being hit

elsif @battler.result.hp_damage > 0 && @battler.result.added_states.size == 0

new_pose = @battler.animation_datahit)

elsif @battler.states.size > 0 || @battler.result.added_states.size > 0

new_pose = @battler.animation_datastand)

@battler.sort_states.each do |state|

if @battler.state_battler_anim(state)

new_pose = @battler.state_battler_anim(state)

break

end

end

elsif @battler.hp_rate < 0.5

new_pose = @battler.animation_datadanger)

end

# Saved pose

@next_pose = nil unless @battler.skill_pose_active

new_pose = @next_pose if @next_pose

# Failsafe: use hit animation if no other one is found

new_pose = @battler.animation_datahit) if new_pose.nil?

# Failsafe: and in last resort, use standing anim

new_pose = @battler.animation_datastand) if new_pose.nil?

# Animation loops unless specified otherwise

if @last_pose == new_pose

@no_loop = !($data_animations[new_pose].name =~ /no[_|\s]loop/i).nil?

end

# Forces 1 loop for dual wielding animation

if KRX:UAL_WIELDING

if @battler.dual_wield? && @battler.weapons.size == 2

if @battler.current_action && @battler.current_action.item

if @battler.current_action.item.id == @battler.attack_skill_id

@start_dual_wielding = true unless @dual_wielding_done

@no_loop = false unless @dual_wielding_done

end

end

end; end

# Manage wait flag

fmax = $data_animations[new_pose].frame_max

@banim_wait = !($data_animations[new_pose].name =~ /wait/i).nil?

@banim_wait = false if @last_frame == fmax - 1 if @banim_wait

if @last_frame == fmax - 1

switch_to = $data_animations[new_pose].name.match(/To(\d+)/i)

id = switch_to[1] if switch_to

@next_pose = id.to_i if id

end

# Update animation

if new_pose != @last_pose

@last_pose = new_pose

@battler_animation = nil

@no_loop = false

@start_dual_wielding = false

@dual_wielding_done = false

end

new_pose

end

#--------------------------------------------------------------------------

# ● Performs the collapse effect

#--------------------------------------------------------------------------

alias_methodkrx_aniB_sb_uc, :update_collapse)

def update_collapse

krx_aniB_sb_uc

@battler_ani_sprites.each do |spr|

spr.blend_type = 1

spr.color.set(255, 128, 128, 128)

spr.opacity = 256 - (48 - @effect_duration) * 6

end

end

#--------------------------------------------------------------------------

# ● Performs the boss collapse effect

#--------------------------------------------------------------------------

def update_boss_collapse

@effect_duration = @battler_ani_duration

end

#--------------------------------------------------------------------------

# ● Mimics the flash effect

#--------------------------------------------------------------------------

def flash(color, duration)

@flash_color = color.dup

@flash_duration = duration

end

end

# Ignore in YEA Battle Engine

unless $imported["YEA-BattleEngine"]

#==============================================================================

# ■ Window_BattleEnemy

#==============================================================================

class Window_BattleEnemy < Window_Selectable

#--------------------------------------------------------------------------

# ● Frame Update

#--------------------------------------------------------------------------

alias_methodkrx_aniB_wbe_update, :update)

def update

enemy.sprite_effect_type = :whiten if active

krx_aniB_wbe_update

end

end

end

# End of YEA Battle Engine check

# Flash Selected Enemy compat.

if $imported[:"FlashSelectedEnemy 1.0.0"]

#==============================================================================

# ■ Window_BattleEnemy

#==============================================================================

class Window_BattleEnemy < Window_Selectable

#--------------------------------------------------------------------------

# ● Frame Update

#--------------------------------------------------------------------------

def update

super

end

end

end

# End of Flash Selected Enemy check

#==============================================================================

# ■ Window_BattleActor

#==============================================================================

class Window_BattleActor < Window_BattleStatus

#--------------------------------------------------------------------------

# ● Frame Update

#--------------------------------------------------------------------------

alias_methodkrx_aniB_wba_update, :update)

def update

$game_party.battle_members[index].sprite_effect_type = :whiten if active

krx_aniB_wba_update

end

end

#==============================================================================

# ■ Scene_Battle

#==============================================================================

class Scene_Battle < Scene_Base

#--------------------------------------------------------------------------

# ● Execute the action previously selected

#--------------------------------------------------------------------------

alias_methodkrx_aniB_sb_ea, :execute_action)

def execute_action

move_to_target

if @subject.current_action.item.is_a?(RPG::Skill)

@subject.skill_pose_active = true

wait_for_animation

elsif @subject.current_action.item.is_a?(RPG::Item)

@subject.item_pose_active = true

end

krx_aniB_sb_ea

move_back_to_pos

end

#--------------------------------------------------------------------------

# ● Moves the battler towards the target

#--------------------------------------------------------------------------

def move_to_target

@subject.movement_type = 2

return unless @subject.current_action.item.move_to_target

target = @subject.current_action.make_targets.compact[0]

ctx = @subject.screen_x > target.screen_x ? 96 : -96

cty = KRX::MOVEMENT_Y_OFFSET * @subject.current_action.item.move_direction

@subject.x_destination = target.screen_x + ctx

@subject.y_destination = target.screen_y + cty

@subject.movement_type = 0

update_basic while @subject.is_moving?

end

#--------------------------------------------------------------------------

# ● Moves the battler back to where they started

#--------------------------------------------------------------------------

def move_back_to_pos

return unless @subject.movement_type == 0

@subject.x_destination = @subject.screen_x

@subject.y_destination = @subject.screen_y

@subject.movement_type = 1

update_basic while @subject.is_moving?

end

#--------------------------------------------------------------------------

# ● Use a Banish skill

#--------------------------------------------------------------------------

if $imported['KRX-BanishSkills']

def use_banish_skill(target, orig_item, skill_id)

@log_window.display_use_item(@subject, orig_item)

@subject.use_item(orig_item)

@log_window.display_banish(orig_item, target)

item = $data_skills[skill_id]

@log_window.display_use_item(target, item)

target.actions << Game_Action.new(self)

target.current_action.set_skill(item.id)

target.skill_pose_active = true

wait_for_animation

target.use_item(item)

target.remove_banish_state

refresh_status

show_animation([@subject], item.animation_id)

item.repeats.times do

@subject.item_apply(target, item)

refresh_status

@log_window.display_action_results(@subject, item)

end

target.skill_pose_active = false

target.actions.clear

end; end

end

if $imported["YES-BattleSymphony"]

#===========================================================================

# ■ Spriteset_Battle

#===========================================================================

class Spriteset_Battle

#--------------------------------------------------------------------------

def update_actors

@actor_sprites.each_with_index do |sprite, i|

party_member = $game_party.battle_members

if party_member != sprite.battler

sprite.battler = $game_party.battle_members

#---

if party_member

party_member.reset_position

party_member.correct_origin_position

party_member.break_pose if party_member.dead?

end

end

sprite.update

end

end

end

#===========================================================================

# ■ Game_Actor

#===========================================================================

class Game_Actor

#--------------------------------------------------------------------------

def use_charset?

return false

end

end

end

And the error is:

"Script 'Animated Battlers' line 851: TypeError occurred. no implicit conversion from nil to integer".

And I found it HERE

The second script is:

##----------------------------------------------------------------------------##
## Composite Character v2.1

## Created by Neon Black

##

## Only for non-commercial use. See full terms of use and contact info at:

## http://cphouseset.wordpress.com/liscense-and-terms-of-use/

##----------------------------------------------------------------------------##

##

##----------------------------------------------------------------------------##

## Revision Info:

## V2.1 - 2.12.2013

## Added new script calls

## V2.0 - 1.24.2013

## Rewrote entire script from scratch

## V1.0 - 10.17.2012

## Wrote and debugged main script

##----------------------------------------------------------------------------##

##

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

$imported["COMPOSITE"] = 2.1 ##

##

##----------------------------------------------------------------------------##

## Instructions:

## Place this script in the "Materials" section of the scripts above "Main".

## To use this script you must have additional composite graphics in a folder

## for characters and a folder for faces. Charactersets will use composites

## based on their names in the NAMES setting. Some layers of the composite

## may also change based on the equipped items on the actor associated with

## file name. There are several tags that work with both actors and equips.

##

## Tags:

## tag init[Handler, hue]

## - Can only be tagged in actors. Changes composite layer :tag to handler

## "Handler" with the defined hue. Do not use colons for layer names or

## quotes for file handler names.

## gender[male]

## - Sets the character's initial gender to "male" or "female" depending on

## which you place in the brackets. This can only tag actors.

## alt name[Christopher]

## - Sets the character's name for the opposite gender. If the player changes

## the gender in the GUI and has not changed the name, the new name will be

## displayed. The name "Christopher" here can be any name you desire.

## tag image[Handler, hue]

## - Changes the default images for layer :tag to file handler "Handler".

##

## Script Calls:

## The character creation screen can be called with either of these two script

## calls from an event. Other script calls also exist.

##

## creation(id) -or- creation(id, array)

## - The value "id" can be either the actor's ID or the name of the character

## set to modify. The "array" value does not need to be used ever. This is

## the array of handlers from "GUI_LISTS" to use. If no array is defined,

## "BASE_GUI" is used instead.

## composite_custom(id, handler, name, hue)

## - Changes composite "id"'s layer "handler" into file "name" with a hue of

## "hue". This occurs on the same priority level as the character creation

## screen, so it is covered by armour and can be modified by the player.

## "id" must be a value from NAMES, "handler" a layer from COMPOSITE, "name"

## a file from FILE_HANDLERS, and "hue" a number from 0 to 255.

## composite_force(id, handler, name, hue)

## - Similar to the command above, but this takes the highest priority when

## being drawn and cannot be changed by the player.

## composite_reset(id)

## - Removes all layers added using the "composite_force" script call.

##

## Special Layers:

## In order to allow a slight bit more customization, there are 3 types of

## special layers that link directly to other layers. These layers end with

## "Back", "Hueless", and "All".

##

## Back Layers

## - These layers do not actually need to be behind the normal layer. They

## are simply a second layer with all the same properties of the parent

## layer. An example would be :hairRear which would be a rear layer of

## :hair.

## Hueless Layers

## - These layers ignore the changed hue values. The main use of these would

## be objects with skin tone or perhaps objects that you only want to change

## part of the colour on. The only object that uses this in the example

## is :eyesHueless which is a hueless layer of :eyes.

## All Layers

## - These are special layers on the character. They are a layer that appears

## on the character no matter what the player does. The file that appears

## is still linked to the file part it is attatched to for the sake of hue.

## The file that appears for one of these layers is defined in the hash

## GUI_OPTIONS.

##----------------------------------------------------------------------------##

##

module CP # Do not touch ##

module COMPOSITE # these lines. ##

##

##----------------------------------------------------------------------------##

## Config:

## The config options are below. You can set these depending on the flavour of

## your game. Each option is explained in a bit more detail above it.

##

##------

# The folders containing the composite parts for characters and for facesets.

CHAR_FOLDER = "Graphics/Composite/Charas/"

FACE_FOLDER = "Graphics/Composite/Faces/"

# Determines if the creation screen uses face sets are not. Set to false if

# you do not want a faceset displayed.

USE_FACESETS = true

# The width and height of the character window in the creation screen. The

# character in the screen is zoomed in to 200%.

WINDOW_WIDTH = 90

WINDOW_HEIGHT = 112

# The text options for the character selection GUI. EMPTY_TEXT refers to an

# option which is blank for some reason.

GUI_CLOSE = "Finish Editing"

EMPTY_TEXT = "None"

# The number of allowed character spaces for names when input from the editor.

CHARACTERS = 6

# Names for the male and female genders.

GENDER_NAMES = ["Male", "Female"]

# Determines if male undefined characters start out as male characters.

MALE_DEFAULT = true

##------

# Determine the files that are recognized as composite images and the actor

# they are linked to, for the sake of armour, storage, etc.

NAMES ={

"$Hero1" => 11,

"$Hero2" => 12,

}

# The switches related to characters. A switch is turned ON when the character

# is male and OFF when the character is female.

SWITCHES ={

11 => 72,

12 => 73,

}

# The order for composite layers. The first layer is the lowest layer.

COMPOSITE =[

:hairRear,

:cape,

:armorRear,

:headAll,

:head,

:eyes,

:eyesAll,

:eyesHueless,

:armor,

:hair,

:glasses,

:helmet,

]

# These are the handlers for all files in the composite folders. Actor and

# equip tags as well as GUI options point to a handler and the handler

# determines the male and female files to look up. Make sure every handler

# has a different name.

FILE_HANDLERS ={

# "Handler" => ["Male_File", "Female_File"],

"Shaggy" => ["Hair1M", nil],

"Slick" => ["Hair2M", nil],

"Spiked" => ["Hair3M", nil],

"Fancy" => ["Hair4M", nil],

"Stylish" => [nil, "Hair1F"],

"Waist Length" => [nil, "Hair2F"],

"Curled" => [nil, "Hair3F"],

"Pigtails" => [nil, "Hair4F"],

"Short" => ["Hair1U", "Hair1U"],

"Long" => ["Hair2U", "Hair2U"],

"Observant" => ["Eye1M", "Eye1F"],

"Closed" => ["Eye2M", "Eye2F"],

"Intent" => ["Eye3M", "Eye3F"],

"HeadBase" => ["HeadAll", "HeadAll"],

"FaceBase" => ["FaceM", "FaceF"],

"BodyBase" => ["BaseM", "BaseF"],

"Clothes" => ["ClothesM", "ClothesF"],

"Cloth" => ["ClothM", "ClothF"],

"Armor" => ["ArmourM", "ArmourF"],

"Glasses" => ["Glasses", "Glasses"],

"Sunglasses" => ["Sunglasses", "Sunglasses"],

"Goggles" => ["Goggles", "Goggles"],

}

# Standard handlers. These are default handlers of certain layers.

STANDARD ={

:headAll => "HeadBase",

:head => "FaceBase",

:armor => "BodyBase",

}

# The GUI options that may be called from an array. If the "Name" field is set

# to a :symbol like the :barber example, it will point back to another option

# and use that option's name and layer. The point is simply to link different

# handlers to it as well as giving it different colour options. The colorize?

# option can be set to a value of 0, 1, or 2 depending on the style of hue bar

# you would like displayed. If it is set to 0, no bar will be displayed.

GUI_OPTIONS ={

# :handler => ["Name", colorize?, "AllFile"],

:Name => ["Name", 0, nil],

:Gender => ["Gender", 0, nil],

:hair => ["Hair", 1, nil],

:eyes => ["Eyes", 1, "EyeAll"],

:barber => [:hair, true, nil],

}

# These are the basic options to use in the GUI if no array is defined.

BASE_GUI = [:Name, :Gender, :hair, :eyes]

# These are the lists that refer to the options. Male and Female only options

# are automatically filtered depending on the character's gender.

GUI_LISTS ={

:hair => ["Shaggy", "Slick", "Spiked", "Fancy", "Stylish", "Waist Length",

"Curled", "Pigtails"],

:eyes => ["Observant", "Intent", "Closed"],

:barber => ["Shaggy", "Slick", "Spiked", "Fancy", "Stylish", "Waist Length",

"Curled", "Pigtails", "Short", "Long"],

}

##----------------------------------------------------------------------------##

##

##

##----------------------------------------------------------------------------##

## The following lines are the actual core code of the script. While you are

## certainly invited to look, modifying it may result in undesirable results.

## Modify at your own risk!

###----------------------------------------------------------------------------

end

nd

odule Cache

class << self ## Alias for the used methods in this module.

alias cp_cm_character character

alias cp_cm_face face

alias cp_cm_clear clear

end

def self.character(*args) ## Checks if the file is a composite.

return cp_cm_character(*args) unless Composites.include?(args[0])

create_composite(args[0], "Graphics/Characters/")

hue = args[1] ? args[1] : 0

load_bitmap("Graphics/Characters/", args[0], hue)

end

def self.face(*args) ## Checks if the face is a composite.

return cp_cm_face(*args) unless Composites.include?(args[0])

create_composite(args[0], "Graphics/Faces/")

hue = args[1] ? args[1] : 0

load_bitmap("Graphics/Faces/", args[0], hue)

end

def self.need_comp_ref?(file, path) ## Checks refresh status.

return true if Composites.refresh?(file)

return true if @cache[path].nil? || @cache[path].disposed?

return false

end

def self.create_composite(file, folder) ## Find and create the composite.

path = "#{folder}#{file}"

return unless need_comp_ref?(file, path)

foldrs = ["Graphics/Characters/", "Graphics/Faces/"]

Composites.constants.each_with_index do |fld, i|

paths = "#{foldrs}#{file}"

array = Composites.images(file)

Composites.layers do |i|

image = array

unless @temp

@temp = Bitmap.new("#{fld}#{image}") rescue next

@temp.hue_change(Composites.hues(file)) unless Composites.hues(file).nil?

else

t = Bitmap.new("#{fld}#{image}") rescue next

t.hue_change(Composites.hues(file)) unless Composites.hues(file).nil?

@temp.blt(0, 0, t, t.rect)

t.dispose; t = nil

end

end

@temp = Bitmap.new unless @temp

Composites.refreshed(file)

@cache[paths] = Bitmap.new(@temp.width, @temp.height)

@cache[paths].blt(0, 0, @temp, @temp.rect)

@temp.dispose; @temp = nil

end

Composites.remove_temp_layers(file)

end

def self.clear ## Reset the composite cache.

cp_cm_clear

Composites.clear

end

nd

odule Composites

def self.include?(file) ## Checks if a file is a composite.

return CP::COMPOSITE::NAMES.include?(file)

end

def self.options ## Easy access of the options hash.

return CP::COMPOSITE::GUI_OPTIONS

end

def self.lists ## Easy access of the gui lists hash.

return CP::COMPOSITE::GUI_LISTS

end

def self.list_by_block(handler, block) ## Returns a list based on gender.

return [] unless [0, 1].include?(block) && lists.include?(handler)

return lists[handler].select {|a| !files[a][block].nil?}

end

def self.layers ## Gets each layer key one at a time.

CP::COMPOSITE::COMPOSITE.each do |key|

yield key

end

end

def self.constants ## Gets the folder constants.

if CP::COMPOSITE::USE_FACESETS

return [CP::COMPOSITE::CHAR_FOLDER, CP::COMPOSITE::FACE_FOLDER]

else

return [CP::COMPOSITE::CHAR_FOLDER]

end

end

def self.files ## Gets the file handler hash.

return CP::COMPOSITE::FILE_HANDLERS

end

def self.include_block?(block, handler) ## Checks gender blocks to handlers.

return false unless files.include?(handler)

return !files[handler][block].nil?

end

def self.standard ## Gets the standard GUI display.

return CP::COMPOSITE::STANDARD

end

def self.get_first_handler(block, key) ## Gets the init files based on block.

return nil if ![0, 1].include?(block) || !lists.include?(key)

lists[key].each do |handler|

next unless files.include?(handler)

return handler unless files[handler][block].nil?

end

return nil

end

def self.n(file) ## Returns a number from a file.

return CP::COMPOSITE::NAMES[file]

end

def self.refreshed(file) ## Resets a file's refresh status.

return unless n(file)

actor(file).composite_refresh = false

end

def self.images(file) ## Get all images of a file.

return @temp_images[file] if @temp_images && @temp_images[file]

return actor(file).composite_images

end

def self.hues(file) ## Get all hues of a file.

return @temp_hues[file] if @temp_hues && @temp_hues[file]

return actor(file).composite_hues

end

def self.remove_temp_layers(file) ## Removes temporary (save) layers.

@temp_images.delete(file) if @temp_images

@temp_hues.delete(file) if @temp_hues

end

def self.make_temp_file(file, handlers) ## Create a new temp of a file.

@temp_images = {} if @temp_images.nil?; @temp_hues = {} if @temp_hues.nil?

@temp_images[file] = {}; @temp_hues[file] = {}

handlers.each do |key, array|

@temp_images[file][key] = array[0]

@temp_hues[file][key] = array[1]

end

end

def self.refresh?(file) ## Check if a file needs refreshing.

return false unless n(file) ## Includes temp file checking.

return true if @temp_images && @temp_images.include?(file)

return actor(file).composite_refresh

end

def self.actor(file) ## Gets a game actor from a file name.

return $game_actors[n(file)]

end

def self.clear ## Allows forced reset of each file.

CP::COMPOSITE::NAMES.keys.each do |file|

actor(file).composite_refresh = true

end

end

nd

lass Game_Actor < Game_Battler

attr_accessor :composite_refresh

alias cp_cmpst_init initialize

def initialize(*args) ## Sets the initial values for composites.

cp_cmpst_init(*args)

@composite_refresh = true

@editor_changes = {}

@editor_hues = {}

@forced_composites = {}

end

def composite_images ## Returns the composite images for an actor.

make_composite_lists if @composite_refresh

return @composite_images

end

def composite_hues ## Returns the composite hues.

make_composite_lists if @composite_refresh

return @composite_hues

end

def edd_additions(hueless, rear) ## Make a new filename based on layers.

a = ""

b = hueless ? "#{a}Hueless" : a

c = rear ? "#{b}Rear" : b

return c

end

def get_composite_lists ## Gets a composite list for save files.

return {} unless Composites.include?(character_name)

make_composite_lists

r = {}

@composite_images.each {|k, v| r[k] = [v, @composite_hues[k]]}

return r

end

def make_composite_lists ## Makes the list of composites and hues.

@composite_images = {}

@composite_hues = {}

@composite_male = get_base_gender ## Sets gender.

if CP::COMPOSITE::SWITCHES.include?(@actor_id) ## Sets a gender switch.

$game_switches[CP::COMPOSITE::SWITCHES[@actor_id]] = @composite_male

end

block = @composite_male ? 0 : 1

make_equip_hashes(block) ## Ensures equips are set up.

Composites.layers do |key| ## Check each layer.

@composite_hues[key] = 0 ## Gets init values for variables.

name = nil

string = key.to_s

hueless = string.include?("Hueless")

rear = string.include?("Rear")

all = string.include?("All")

string.gsub!(/(Hueless|All|Rear)/, '')

edd = edd_additions(hueless, rear)

line = CP::COMPOSITE::GUI_OPTIONS[string.to_sym]

handler = get_composite_handler(key)

parent = get_composite_handler(string.to_sym)

hues = get_composite_hue(key)

if all && !line.nil? ## Determines the needed value.

name = line[2]

elsif handler && Composites.files.include?(handler) &&

Composites.files[handler][block]

name = "#{Composites.files[handler][block]}#{edd}"

elsif parent && Composites.files.include?(parent) &&

Composites.files[parent][block] && (rear || hueless)

name = "#{Composites.files[parent][block]}#{edd}"

elsif Composites.standard.include?(key)

name = Composites.files[Composites.standard[key]][block]

end

next unless name ## Skips if there is no name.

@composite_images[key] = name ## Creates the hashes.

@composite_hues[key] = hueless ? 0 : hues

end

end

def get_base_gender ## Gets the gender.

return @editor_changes[:Gender] if @editor_changes.include?Gender)

return actor.gender_base

end

def get_composite_handler(key) ## Complex method to find the file handler.

block = @composite_male ? 0 : 1

if @forced_composites.include?(key) && Composites.include_block?(block,

@forced_composites[key][0])

hues = @forced_composites[key][0]

elsif @equip_hashes.include?(key) && Composites.include_block?(block,

@equip_hashes[key][0])

handler = @equip_hashes[key][0]

elsif @editor_changes.include?(key) && Composites.include_block?(block,

@editor_changes[key])

handler = @editor_changes[key]

elsif actor.composite_init.include?(key) && Composites.include_block?(block,

actor.composite_init[key][0])

handler = actor.composite_init[key][0]

elsif Composites.get_first_handler(block, key)

handler = Composites.get_first_handler(block, key)

else

handler = nil

end

return handler

end

def get_composite_hue(key) ## Same as above but for hues.

block = @composite_male ? 0 : 1

if @forced_composites.include?(key) && Composites.include_block?(block,

@forced_composites[key][0])

hues = @forced_composites[key][1]

elsif @equip_hashes.include?(key) && Composites.include_block?(block,

@equip_hashes[key][0])

hues = @equip_hashes[key][1]

elsif @editor_changes.include?(key) && Composites.include_block?(block,

@editor_changes[key])

hues = @editor_hues[key]

elsif actor.composite_init.include?(key) && Composites.include_block?(block,

actor.composite_init[key][0])

hues = actor.composite_init[key][1]

else

hues = 0

end

return hues

end

def make_equip_hashes(block) ## Makes the handler hash for equips.

@equip_hashes = {}

equips.each do |eq|

next unless eq

eq.composite_hash.each do |key, array|

next if Composites.files[array[0]][male? ? 0 : 1].nil?

@equip_hashes[key] = array

end

end

end

alias cp_composite_change_eq change_equip

def change_equip(*args) ## Ensures refreshing on equip change.

cp_composite_change_eq(*args)

@composite_refresh = true

end

def change_composite(hand, value = nil, hue = nil)

array = ["#{hand}".to_sym, "#{hand}Rear".to_sym, "#{hand}Hueless".to_sym,

"#{hand}All".to_sym]

array.each do |handler| ## Changes values for a layer and sublayers.

unless value.nil?

@editor_changes[handler] = value

@editor_hues[handler] = hue if hue

else

@editor_changes.delete(handler)

@editor_hues.delete(handler)

end

end

@composite_refresh = true

end

def force_composite(hand, value = nil, hue = nil)

array = ["#{hand}".to_sym, "#{hand}Rear".to_sym, "#{hand}Hueless".to_sym,

"#{hand}All".to_sym]

array.each do |handler| ## Changes values for a layer and sublayers.

unless value.nil?

@forced_composites[handler] = []

@forced_composites[handler][0] = value

@forced_composites[handler][1] = hue if hue

else

@forced_composites.delete(handler)

end

end

@composite_refresh = true

end

def reset_composite

@forced_composites = {}

@composite_refresh = true

end

def reset_name ## Changes the name to a default name.

return if actor.alt_name.empty?

@composite_male = get_base_gender

if @composite_male == actor.gender_base

@name = actor.name if @name == actor.alt_name

else

@name = actor.alt_name if @name == actor.name

end

end

def male? ## Check if the actor is male.

return @composite_male

end

nd

lass Window_SaveFile < Window_Base

def draw_party_characters(x, y) ## Creates a temp array for the save file.

header = DataManager.load_header(@file_index)

return unless header

header[:characters].each_with_index do |data, i|

Composites.make_temp_file(data[0], data[2])

draw_character(data[0], data[1], x + i * 48, y)

end

end

nd

lass Game_Party < Game_Unit

def characters_for_savefile ## Adds the composite arrays to a save file.

battle_members.collect do |actor|

[actor.character_name, actor.character_index, actor.get_composite_lists]

end

end

nd

lass Scene_Load < Scene_File ## Clears the composites on a load.

alias cp_comp_load_succ on_load_success

def on_load_success

Composites.clear

cp_comp_load_succ

end

nd

lass Scene_Save < Scene_File ## Clears the composites on save.

alias cp_comp_save_ok on_savefile_ok

def on_savefile_ok

Composites.clear

cp_comp_save_ok

end

nd

lass Bitmap

def draw_rainbow(*args) ## Draws a rainbow rectangle.

case args.size

when 1

rect = args[0].clone

when 4

rect = Rect.new(args[0], args[1], args[2], args[3])

end

ca = rainbow_colours

6.times do |i|

wv = rect.width / (6 - i)

n = i == 5 ? 0 : 1

r2 = Rect.new(rect.x, rect.y, wv + n, rect.height)

self.gradient_fill_rect(r2, ca, ca[(i + 1) % 6])

rect.width -= wv

rect.x += wv

end

end

def rainbow_colours ## Colours for the rectangle.

c1 = Color.new(255, 0, 0); c2 = Color.new(255, 255, 0)

c3 = Color.new( 0, 255, 0); c4 = Color.new( 0, 255, 255)

c5 = Color.new( 0, 0, 255); c6 = Color.new(255, 0, 255)

return [c1, c2, c3, c4, c5, c6]

end

@@wheel = Bitmap.new(360, 1)

@@wheel.draw_rainbow(0, 0, 360, 1)

def self.hue_colour_wheel(hue) ## Show the new hue colour.

if @@wheel.disposed?

@@wheel = Bitmap.new(360, 1)

@@wheel.draw_rainbow(0, 0, 360, 1)

end

return @@wheel.get_pixel(hue % 360, 0)

end

nd

# The core bits of the script scene are below.

lass Window_CCFace < Window_Base

def initialize(actor, input)

super(0, 0, 120, 120)

self.visible = CP::COMPOSITE::USE_FACESETS

@input_window = input

self.y = @input_window.y

self.x = @input_window.x - (self.width + 8)

@actor = $data_actors[actor]

refresh

end

def refresh

contents.clear

draw_face(@actor.face_name, @actor.face_index, 0, 0)

end

nd

lass Window_CCCharacter < Window_Base

def initialize(actor, input)

super(0, 0, CP::COMPOSITE::WINDOW_WIDTH, CP::COMPOSITE::WINDOW_HEIGHT)

@input_window = input

self.y = @input_window.y

self.x = @input_window.x + @input_window.width + 8

@actor = $data_actors[actor]

@ticker = 10

@last_frame = 1

@frame = 1

refresh

end

def update

@ticker += 1

@frame = (@ticker % 40) / 10; @frame = 1 if @frame == 3

return if @frame == @last_frame

@last_frame = @frame

refresh

end

def refresh

contents.clear

x = contents.width / 2

y = contents.height - 6

draw_character(@actor.character_name, @actor.character_index, x, y, @frame)

end

def draw_character(character_name, character_index, x, y, frame = 1)

return unless character_name

bitmap = Cache.character(character_name)

sign = character_name[/^[\!\$]./]

if sign && sign.include?('$')

cw = bitmap.width / 3

ch = bitmap.height / 4

else

cw = bitmap.width / 12

ch = bitmap.height / 8

end

n = character_index

src_rect = Rect.new((n%4*3+frame)*cw, (n/4*4)*ch, cw, ch)

ret_rect = Rect.new(x - cw, y - cw * 2, cw * 2, ch * 2)

contents.stretch_blt(ret_rect, bitmap, src_rect)

end

nd

lass Window_CCGui < Window_Selectable

def initialize(file, list)

@list = list

extra_width = CP::COMPOSITE::WINDOW_WIDTH + 8

extra_width += 128 if CP::COMPOSITE::USE_FACESETS

x = (Graphics.width - (180 + extra_width)) / 2

x += 128 if CP::COMPOSITE::USE_FACESETS

y = (Graphics.height - window_height) / 2

h = window_height

super(x, y, 180, h)

@file = file

refresh

end

def window_height

[fitting_height(item_max * 2), Graphics.height].min

end

def item_max

@list.size + 1

end

def contents_height

(item_max * 2) * line_height

end

def item_height

line_height * 2

end

def refresh

contents.clear

draw_all_items

end

def data

@list[@index]

end

def adj_data

if Composites.options[data][0].is_a?(Symbol)

return Composites.options[data][0]

else

return data

end

end

def draw_item(index)

rect = item_rect(index)

lh = line_height

if index == @list.size

text = CP::COMPOSITE::GUI_CLOSE

change_color(normal_color)

draw_text(rect.x + 2, rect.y + lh / 2, rect.width - 4, lh, text, 1)

else

block = Composites.options[@list[index]]

if block[0].is_a?(Symbol)

title = Composites.options[block[0]][0]

else

title = block[0]

end

value = (CP::COMPOSITE::COMPOSITE.include?(@list[index]) ||

@list[index] == :Gender || @list[index] == :Name)

sym = value ? @list[index] : block[0]

change_color(system_color)

draw_text(rect.x + 2, rect.y, rect.width - 4, lh, title)

case sym

when :Gender

na = CP::COMPOSITE::GENDER_NAMES

name = Composites.actor(@file).male? ? na[0] : na[1]

when :Name

name = Composites.actor(@file).name

else

name = Composites.actor(@file).get_composite_handler(sym)

name = CP::COMPOSITE::EMPTY_TEXT if name.nil?

hue = Composites.actor(@file).get_composite_hue(sym)

if block[1]

c1 = Bitmap.hue_colour_wheel(hue)

c2 = Color.new(c1.red, c1.green, c1.blue, 0)

r2 = contents.text_size(name).width

hr = Rect.new(contents.width - (r2 + 6), rect.y + lh + 3, r2 + 1, lh - 6)

contents.gradient_fill_rect(hr, c2, c1)

end

end

change_color(normal_color)

draw_text(rect.x + 2, rect.y + lh, rect.width - 6, lh, name, 2)

end

end

nd

lass Window_CCSelect < Window_Selectable

attr_reader :hue

def initialize(file, input)

super(0, 0, 160, 0)

@input_window = input

@file = file

@data = nil

@hue = 0

end

def item_max

return 1 if @data.nil? || @data.empty?

return @data.size

end

def refresh

contents.clear

draw_all_items

draw_hue_wheel

end

def draw_item(index)

rect = item_rect(index); rect.x += 2; rect.width -= 4

change_color(normal_color)

draw_text(rect, @data[index])

end

def draw_hue_wheel

rect = item_rect(item_max); contents.clear_rect(rect)

rect.y += 4; rect.height -= 8; rect.x += 8; rect.width -= 16

ind = Composites.options[@input_window.data]

return if !ind || ind[1] == 0

if ind[1] == 2

value = @hue >= 180 ? @hue - 360 : @hue

rect.height /= 2; rect.height -= 1; rect.x -= 60

contents.draw_rainbow(rect)

rect.y += (rect.height + 1); rect.x -= value / 3

contents.draw_rainbow(rect)

rect.x += 119

contents.draw_rainbow(rect)

rect.y -= (rect.height + 1); rect.x += value / 3

contents.draw_rainbow(rect)

bitmap2 = Bitmap.new(10, 19)

bitmap2.fill_rect(0, 0, 10, 19, Color.new(255, 255, 255))

c1 = Bitmap.hue_colour_wheel(0)

c2 = Bitmap.hue_colour_wheel(@hue)

bitmap2.gradient_fill_rect(1, 1, 8, 17, c1, c2, true)

rect = item_rect(item_max)

contents.blt((rect.width - 10) / 2, rect.y + 2, bitmap2, bitmap2.rect)

rect.width = 10

contents.clear_rect(rect)

rect.x = contents.width - rect.width

contents.clear_rect(rect)

elsif ind[1] == 1

contents.draw_rainbow(rect)

bitmap2 = Bitmap.new(7, 20)

bitmap2.fill_rect(0, 0, 7, 20, Color.new(255, 255, 255))

bitmap2.fill_rect(1, 2, 5, 16, Bitmap.hue_colour_wheel(@hue))

off = @hue / 3

contents.blt(rect.x - 3 + off, rect.y - 2, bitmap2, bitmap2.rect)

end

end

def show

val = @input_window.adj_data

ind = @input_window.data

actor = Composites.actor(@file)

block = Composites.actor(@file).male? ? 0 : 1

@name = Composites.list_by_block(ind, block).index(actor.get_composite_handler(val))

@index = val != :Gender ? @name : Composites.actor(@file).male? ? 0 : 1

@index = 0 if @index.nil?

@hue = actor.get_composite_hue(val) unless val == :Gender

cont = Composites.options[ind]

if val == :Gender

@data = CP::COMPOSITE::GENDER_NAMES

else

@data = Composites.list_by_block(ind, block)

end

add = Composites.options[ind][1] ? 1 : 0

add = 0 if val == :Gender

self.height = fitting_height(@data.size + add)

create_contents

refresh

self.x = @input_window.x + 16

iw = @input_window

self.y = iw.y + iw.standard_padding + (iw.index * (iw.line_height * 2)) - iw.oy + 28

self.y = Graphics.height - self.height if y + height > Graphics.height

super

activate

end

def cursor_right(wrap)

return if Composites.options.include?(@input_window.data) &&

!Composites.options[@input_window.data][1]

@hue /= 12; @hue *= 12

@hue += 12; @hue -= 360 if @hue >= 360

draw_hue_wheel

end

def cursor_left(wrap)

return if Composites.options.include?(@input_window.data) &&

!Composites.options[@input_window.data][1]

@hue /= 12; @hue *= 12

@hue -= 12; @hue += 360 if @hue < 0

draw_hue_wheel

end

nd

lass Game_Interpreter

def creation(char, list = nil) ## Allows for easy calling of the scene.

return if $game_party.in_battle

if char.is_a?(Integer)

return unless CP::COMPOSITE::NAMES.has_value?(char)

char = CP::COMPOSITE::NAMES.index(char)

else

return unless Composites.include?(char)

end

list = CP::COMPOSITE::BASE_GUI if list.nil?

return unless list.is_a?(Array)

SceneManager.call(Scene_CharacterCreation)

SceneManager.scene.prepare(char, list)

Fiber.yield

end

def composite_force(char, handler, name, hue = 0)

if char.is_a?(Integer)

return unless CP::COMPOSITE::NAMES.has_value?(char)

else

return unless Composites.include?(char)

char = CP::COMPOSITE::NAMES[char]

end

$game_actors[char].force_composite(handler, name, hue)

end

def composite_custom(char, handler, name, hue = 0)

if char.is_a?(Integer)

return unless CP::COMPOSITE::NAMES.has_value?(char)

else

return unless Composites.include?(char)

char = CP::COMPOSITE::NAMES[char]

end

$game_actors[char].change_composite(handler, name, hue)

end

def composite_reset(char)

if char.is_a?(Integer)

return unless CP::COMPOSITE::NAMES.has_value?(char)

else

return unless Composites.include?(char)

char = CP::COMPOSITE::NAMES[char]

end

$game_actors[char].reset_composite

end

nd

lass Scene_CharacterCreation < Scene_MenuBase

def prepare(file, list)

@file = file

@list = list

end

def start

super

@actor = Composites.actor(@file)

create_windows

end

def create_windows

@input_window = Window_CCGui.new(@file, @list)

@input_window.set_handlerok, methodgui_ok))

@input_window.set_handlercancel, methodgui_cancel))

@select_window = Window_CCSelect.new(@file, @input_window)

@select_window.set_handlerok, methodselect_ok))

@select_window.set_handlercancel, methodselect_cancel))

@chara_window = Window_CCCharacter.new(@actor.id, @input_window)

@face_window = Window_CCFace.new(@actor.id, @input_window)

@input_window.activate.select(0)

@select_window.hide

end

def gui_ok

val = @input_window.data

if val == :Name

SceneManager.call(Scene_Name)

SceneManager.scene.prepare(Composites.actor(@file).id, CP::COMPOSITE::CHARACTERS)

@input_window.refresh

elsif val == nil

return_scene

else

@select_window.show

end

end

def gui_cancel

@input_window.activate.select(@input_window.item_max - 1)

end

def select_ok

val = @input_window.data

adj = @input_window.adj_data

id = @select_window.index

if adj == :Gender

if id == 0

Composites.actor(@file).change_compositeGender, true)

Composites.actor(@file).reset_name

elsif id == 1

Composites.actor(@file).change_compositeGender, false)

Composites.actor(@file).reset_name

end

else

block = Composites.actor(@file).male? ? 0 : 1

handler = Composites.list_by_block(val, block)[@select_window.index]

hue = @select_window.hue

Composites.actor(@file).change_composite(adj, handler, hue)

end

@select_window.hide

@chara_window.refresh

@face_window.refresh

@input_window.activate.refresh

end

def select_cancel

@select_window.hide

@input_window.activate

end

nd

lass RPG::BaseItem

def composite_hash

add_composite_data if @composite_hash.nil?

return @composite_hash

end

def composite_init

add_composite_data if @composite_init.nil?

return @composite_init

end

def gender_base

add_composite_data if @gender_base.nil?

return @gender_base

end

def alt_name

add_composite_data if @alt_name.nil?

return @alt_name

end

INITI_RE = /(.+) init\[(.+)[,]\s*(\d+)\]/i

IMAGE_RE = /(.+) image\[(.+)[,]\s*(\d+)\]/i

GENDER_RE = /gender\[(male|female)\]/i

ALT_NAME = /alt name\[(.+)\]/i

def add_composite_data

@gender_base = CP::COMPOSITE::MALE_DEFAULT

@composite_hash = {}; @composite_init = {}; @alt_name = ""

self.note.split(/[\r\n]+/).each do |line|

case line

when INITI_RE

@composite_init[$1.to_sym] = [$2.to_s, $3.to_i]

@composite_init["#{$1.to_s}Rear".to_sym] = [$2.to_s, $3.to_i]

@composite_init["#{$1.to_s}Hueless".to_sym] = [$2.to_s, 0]

@composite_init["#{$1.to_s}All".to_sym] = [$2.to_s, $3.to_i]

when IMAGE_RE

@composite_hash[$1.to_sym] = [$2.to_s, $3.to_i]

@composite_hash["#{$1.to_s}Rear".to_sym] = [$2.to_s, $3.to_i]

@composite_hash["#{$1.to_s}Hueless".to_sym] = [$2.to_s, 0]

@composite_hash["#{$1.to_s}All".to_sym] = [$2.to_s, $3.to_i]

when GENDER_RE

@gender_base = true if $1.to_s.downcase == "male"

@gender_base = false if $1.to_s.downcase == "female"

when ALT_NAME

@alt_name = $1.to_s

end

end

end

nd

##--------------------------------------------------------------------------###

End of script. #

##--------------------------------------------------------------------------###

And the error is:

"Script 'In Game Character Creation' line 1091: SyntaxError occurred. unexpected $end"

I've "downloaded" this script HERE
The last script is:

#==============================================================================#
# **SheolShade Minimap** #

#------------------------------------------------------------------------------#

# ** Autor: SheolShade #

# ** Versão: 1.0b #

# ** Data: 24/12/2012 #

#------------------------------------------------------------------------------#

# - Descrição: #

# Este script adiciona um mini mapa circular no jogo. #

# - Utilização: #

# Cole este script na seção "Scripts Adicionais". #

#==============================================================================#

#==============================================================================#

# ** Configuração #

#------------------------------------------------------------------------------#

# TileSize -> linha: 99

# Define o tamanho do tile utilizado no minimapa.

#

# MapOffset -> linha: 100

# Dependendo do tamanho do tile utilizado será necessário ajustar a

# posição do minimapa.

#

# PlayerColor -> linha: 101

# Define a cor do jogador mostrada no mapa.

#

# ObjectColor -> linha: 102

# Permite definir uma cor pra cada tipo de objeto no mapa, como

# NPCS, teletranportes, baús e etc, usando comenta´rios nos eventos.

# Use a seguinte sintaxe dentro do {}, separado por vírgulas:

#

# "comentário" => Color.new(R, G,

.invert

# R = valor RGB para vermelho;

# G = valor RGB para verde;

# B = valor RGB para azul;

#

# BorderColor -> linha: 104

# Define a cor do contorno dos eventos e jogador.

#

# ObjectLayerOpacity -> linha: 105

# Define a transparencia da camada de eventos.

#

# MiniMapCorner -> linha: 106

# Define a posção do mini mapa.

# 1 = Canto superior esquerdo;

# 2 = Canto superior direito;

# 3 = Canto inferior esquerdo;

# 4 = Canto inferior direito;

#

# MapColor -> linha: 107

# Define a cor da parte não passável do mapa.

#

# MapBorderColor -> linha: 108

# Define a cor do contorno das areas não passávies.

#

# BorderName -> linha: 109

# Nome do arquivo de imagem para a borda do mini mapa. Na pasta System.

#

# BackTextureName -> linha: 110

# Nome do arquivo de imagem para a textura de fundo. Na pasta System.

#

# ClearOutsideArea -> linha: 111

# Permite preeencher com uma cor as area fora do mapa ao invez de usar

# a textura. true ou false

#

# ClearOutsideColor -> linha: 112

# Se ClearoutsideArea for true, utilizará a cor definida aqui para

# preencher a area externa.

#

# OutlineMapArea -> linha: 113

# Permite definir um contorno demarcando o limite do mapa. true ou false

#

# OutlineMapColor -> linha: 114

# Se OutlineMapArea for true, utilizará a cor definida aqui para

# o contorno.

#

# EnableSwitchID

# Define a id do switch usado para ligar ou desligar o mini mapa.

#==============================================================================#

#==============================================================================#

# ** Classe Color

#==============================================================================#

class Color

#-----------------------------------------------------------------------------

# * Inverte o valor das cores

#-----------------------------------------------------------------------------

def invert

r = 255 - self.red

g = 255 - self.green

b = 255 - self.blue

a = self.alpha

self.set(r, g, b, a)

end

end

#==============================================================================#

# ** Modulo SheolShade

#==============================================================================#

module SheolShade

module MiniMap

#Inicio da configuração#

TileSize = 8

MapOffset = -4

PlayerColor = Color.new(255,0,0).invert

ObjectColor = {"npc" => Color.new(0,255,0).invert,

"door" => Color.new(0,0,255).invert,

"chest" => Color.new(100,100,100).invert}

BorderColor = Color.new(0,0,0).invert

ObjectLayerOpacity = 255

MiniMapCorner = 2

MapColor = Color.new(200,150,150).invert

MapBorderColor = Color.new(50,50,50).invert

BorderName = "Border"

BackTextureName = "OldPaper"

ClearOutsideArea = false

ClearOutsideColor = Color.new(0,0,0).invert

OutlineMapArea = true

OutlineMapColor = Color.new(0,0,0).invert

EnableSwitchId = 1

#Fim da configuração#

MiniMapCoords = {1 => [0,0,112,112],

2 => [Graphics.width - 112,0,112,112],

3 => [0,Graphics.height - 112,112,112],

4 => [Graphics.width - 112,Graphics.height - 112,112,112]}

end

end

#==============================================================================#

# ** Classe Mini Map

#==============================================================================#

class MiniMap

include SheolShade::MiniMap

def initialize(viewport)

@viewport = viewport

refresh

end

def refresh

@backmask = Sprite.new(@viewport)

@backmask.bitmap = Cache::system("Back_96")

@backmask.x = @backmask.y = 8

@backtile = Sprite.new(@viewport)

@backtile.blend_type = 2

@backtile.z = 1

@backtile.x = @backtile.y = -100

@map = Sprite.new(@viewport)

@map.z = 2

@map.blend_type = 2

@object_layer = Sprite.new(@viewport)

@object_layer.z = 3

@object_layer.blend_type = 2

@object_layer.bitmap = Bitmap.new($game_map.width*TileSize + 112,

$game_map.height*TileSize + 112)

@object_layer.opacity = ObjectLayerOpacity

@border = Sprite.new(@viewport)

@border.bitmap = Cache::system(BorderName)

@border.z = 4

@border.opacity = 255

@mask = Cache::system("Mask")

draw_back

draw_map

end

def visible

$game_switches[EnableSwitchId]

end

def draw_map

front = make_map_bitmap(MapColor)

border = make_map_bitmap(MapBorderColor)

result = Bitmap.new($game_map.width*TileSize + 112,

$game_map.height*TileSize+ 112)

result.blt(-1, 0, border, border.rect)

result.blt(1, 0, border, border.rect)

result.blt(0, -1, border, border.rect)

result.blt(0, 1, border, border.rect)

result.blt(0, 0, front, front.rect)

@mapbitmap = result

end

def draw_back

bitmap = Bitmap.new($game_map.width*TileSize+112,

$game_map.height*TileSize+112)

bit = Cache::system(BackTextureName)

bitmap.stretch_blt(bitmap.rect, bit, bit.rect)

if ClearOutsideArea

bitmap.fill_rect(0,0,bitmap.width, 56, ClearOutsideColor)

bitmap.fill_rect(0,0,56, bitmap.height, ClearOutsideColor)

bitmap.fill_rect(0,bitmap.height-56,bitmap.width, 56, ClearOutsideColor)

bitmap.fill_rect(bitmap.width-56,0,56, bitmap.height, ClearOutsideColor)

elsif OutlineMapArea

bitmap.fill_rect(56,55,bitmap.width-112,1,OutlineMapColor)

bitmap.fill_rect(55,56,1,bitmap.height-112,OutlineMapColor)

bitmap.fill_rect(bitmap.width-56,55,1,bitmap.height-112,OutlineMapColor)

bitmap.fill_rect(56,bitmap.height-56,bitmap.width-112,1,OutlineMapColor)

end

@backtilebitmap = bitmap

end

def draw_object_layer

for event in $game_map.events.keys

if $game_map.events[event].list.size >= 0

for item in $game_map.events[event].list

if item.code == 108 or item.code == 408

if ObjectColor.has_key?(item.parameters[0])

draw_object($game_map.events[event].real_x*TileSize+56,

$game_map.events[event].real_y*TileSize+56,

ObjectColor[item.parameters[0]])

end

end

end

end

end

draw_object($game_player.real_x*TileSize+56, $game_player.real_y*TileSize+56, PlayerColor)

end

def draw_object(x, y, color)

@object_layer.bitmap.fill_rect(x, y, TileSize, TileSize, BorderColor)

@object_layer.bitmap.fill_rect(x+1, y+1, TileSize-2, TileSize-2, color)

@object_layer.bitmap.clear_rect(x,y,1,1)

@object_layer.bitmap.clear_rect(x,y+TileSize-1,1,1)

@object_layer.bitmap.clear_rect(x+TileSize-1,y,1,1)

@object_layer.bitmap.clear_rect(x+TileSize-1,y+TileSize-1,1,1)

end

def make_map_bitmap(color)

bitmap = Bitmap.new($game_map.width*TileSize + 112,

$game_map.height*TileSize + 112)

for x in 0..$game_map.width - 1

for y in 0..$game_map.height - 1

if $game_map.airship_land_ok?(x, y)

next

end

bitmap.fill_rect(x*TileSize+56, y*TileSize+56, TileSize, TileSize, color)

end

end

bitmap

end

def update_object_layer

@object_layer.bitmap.clear

draw_object_layer

end

def dispose

@backmask.dispose

@backtile.dispose

@map.dispose

@object_layer.dispose

@border.dispose

end

def update

@backmask.visible = visible

@backtile.visible = visible

@map.visible = visible

@object_layer.visible = visible

@border.visible = visible

if visible

@map.bitmap = @mapbitmap.dup

@backtile.bitmap = @backtilebitmap.dup

sx = $game_player.real_x * (TileSize * -1) + MapOffset

sy = $game_player.real_y * (TileSize * -1) + MapOffset

update_object_layer

@map.x = @backtile.x = @object_layer.x = sx

@map.y = @backtile.y = @object_layer.y = sy

@backtile.bitmap.blt(sx*-1, sy*-1,@mask,@mask.rect)

@map.bitmap.blt(sx*-1, sy*-1,@mask,@mask.rect)

@object_layer.bitmap.blt(sx*-1, sy*-1,@mask,@mask.rect)

end

end

end

#==============================================================================#

# ** Classe Spriteset_Map

#==============================================================================#

class Spriteset_Map

alias old_init initialize

alias old_updt update

alias old_disp dispose

include SheolShade::MiniMap

def initialize

viewport = Viewport.new(Graphics.width - 112,0,112,112)

viewport.rect.set(MiniMapCoords[MiniMapCorner][0],

MiniMapCoords[MiniMapCorner][1],

MiniMapCoords[MiniMapCorner][2],

MiniMapCoords[MiniMapCorner][3])

viewport.z = 500

@minimapa = MiniMap.new(viewport)

old_init

end

def dispose

old_disp

@minimapa.dispose

end

def update

old_updt

@minimapa.update

end

end

#==============================================================================#

# ** Fim do Script

#==============================================================================#

And the error is: "Unable to find file: Graphic/System/Back_96"

I've "downloaded" it HERE

Can someone help me? (I added the scripts in "Script editor-->Materials")

And teach me how to add scripts and how to create scripts?

Thanks to all!

Andar · May 4, 2014

the last error is the easiest - that script requires a picture with the filename "Back_96", and you haven't added that picture to your project. Most probably you'll find it in the demo-download from the link you gave.

How to create scripts: that is programming i Ruby, just search the internet for tutorials on how to program in Ruby. If you can already program in any other language, that might take a month to learn - if you never programmed something, it'll probably be half a year learning before you can create your first script.

As for the second error - syntax errors either are bugs in the original script (rarely unless they're new) or you made a mistake in copy&paste and are missing part of the script.

And the first error - either this is an mistake in a scriptcall or notetag you made wrong, or you didn't start a new game after installing the script (loading a savegame often disrupts a script that was not yet installed when the savegame was created)

DemoniacWind · May 5, 2014

For the third error when I click on "Download Demo" it redirects me to mediafire, and the file that I can download is a ".exe", so is a game created using that script, there isn't any file named "Back_96".

The second error, I copied it from a post in a section named "RpgMaker VX & VX-Ace → RGSS3 (VX-Ace) → Scripts RGSS3 (VX-Ace)". I think this is a new script, only created for RMVX Ace.

For the first error, I select "New Game" and I can see the error when a battle starts.

<b>I can see the first error when a battle starts;

I can see the second error when I start the game;

I can see the third error when I start the game.</b>

I hope that these more information can make the difference.

Thanks to all!

Andar · May 5, 2014

DemoniacWind said:
For the third error when I click on "Download Demo" it redirects me to mediafire, and the file that I can download is a ".exe", so is a game created using that script, there isn't any file named "Back_96".

Of course, I never said anything else - it's obvious that a demo is a complete game.
Download it, install it, open it in the editor, export the picture and reimport it to your game.

second script: I gave it only a short view, but it's missing an e at the end - shortly before the last line there is a line nd, and that makes no sense - change that line to end and test again.

And if you started a new game with the first, then there is a problem in your configuration - either a notetag wrong, a scriptcall wrong, or you have configured the wrong variables - check the script description to see if you did everything as you were told to do.

DemoniacWind · May 5, 2014

For the first, I'll take a look at the script's description.

For the second, I tried to add an "e" where there was "nd", but there is an error (the same as the first time)

EDIT

For the third, a positive thing is that there aren't errors, but the negative is that there isn't any minimap.

Scripts Errors

DemoniacWind

Warper

Andar

Veteran

DemoniacWind

Warper

Andar

Veteran

DemoniacWind

Warper

Users Who Are Viewing This Thread (Users: 0, Guests: 1)

Latest Threads

Latest Posts

Latest Profile Posts

Newest members

Forum statistics