Envision, Create, Share

Welcome to HBGames, a leading amateur game development forum and Discord server. All are welcome, and amongst our ranks you will find experts in their field from all aspects of video game design and development.
Register

Skill Orb Script Help

Latest Post

Joe parz

Member

137
Hello everyone, i just have an issue with this script, i think its an easy fix as its just a cursor issue.

Code: 
# Orb Based Skill System *

#***************************************************

# Author: El Conducter *

# Date: August/02/07 *

# Version: 2.0 *

#***************************************************

 

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

# What it Does:

# This script allows characters to learn new skills by equipping magic Orbs.

# Equipping Orbs uses MP, which has been added for the characters. As

# the characters levels increase, so does their MP.

# Update in Version 2.0

# I have now added a shop to buy and sell Orbs. The orbs are also now

# arranged in alphabetical order rather than by ID.

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

 

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

# How it Works: This script is organized into 4 parts. New part in Version 2.0

#

# Part 1 defines Orbs and sets up the Orb database. The main points in Part 1 are:

#

# class Orb defines a new object (the Orb)

# - id: As its name implies it is the Orb's ID Number

# - name: The Name of the Orb

# - mp_cost: The amount of MP required to equip the Orb

# - price: How much the Orb costs

# - skills: An array of learnable skills from Orb

# - info: A discription of what the Orb does

#

# class Orbs_Data is the database where all the games Orbs

# are defined. The orbs are set up in an array and assigned to a Constant.

# - Define your Orbs within the array like so: Orb.new(id, name, mp_cost, skills, info)

#

# Part 2 consists of all the window classes and scene that deals with equipping Orbs.

# The classes that make up Part 2 are:

#

# - Scene_Equip_Orb

# - Window_EquipOrb

# - Window_RemoveOrb

# - Window_Orb_Right

# - Window_MP

# - Window_Command2

# - Window_Command3

# - Window_Help2

#

# Part 3 contains all the altered original code. classes that had to altered are: 

#

# - Game_Actor

# - Game_Party

# - Window_Base

# - Scene_Menu

# - Scene_Title

# - Game_Temp New in 2.0

#

# Part 4 has all the classes that handle the buying and selling Orbs:

#

# - Scene_Orb_Shop

# - Window_Orb_Buy

# - Window_Orb_Sell

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

 

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

# How to Use This Script:

# Just copy it and paste it above Main.

#

# To add Orbs to your party's inventory while playing the game, use

# events Call Script function like this:

# - $game_party.gain_orb($data_orbs[X])

# Where X stands, put the id of the orb you want to add.

# Orb ID's in the Orb database start with 0 and up.

#

# To use the Shop function of this script, use events Call Script function 

# like this:

# - $game_temp.shop_orbs = [$data_orbs[X], $data_orbs[X]]

# - $scene = Scene_Orb_Shop.new

# Where X stands, put the id of the orb you want to add. Just

# keep adding to the array how many orbs you want to be able

# to buy. The second line actually calls the shop itself; using the

# orbs you specified to buy.

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

 

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

# Modifications:

# The Orb script is fully customizable to fit the users needs. Much can be

# done with it. Possible modifications include:

# - Orbs that can effect characters attributes and elemental & status

# attack and defense.

# - Orbs that level up and gain new skills

# - Orb synthesis shop

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

 

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

# Comments:

# I hope my script is easy for you to use and modify. Use this script to

# learn RGSS better and become a better scriptor yourself. 

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

 

 

#******************************************************************************

# I Part One

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

# This part deals with the construction of Orbs and sets up the Orb Database.

#******************************************************************************

 

 

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

# ** Orb

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

# This class defines the Orb object.

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

 

module RPG

 

class Orb

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

# * Public Instance Variables

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

attr_reader :id

attr_accessor :name

attr_accessor :mp_cost

attr_accessor :price # New in 2.0

attr_accessor :skills 

attr_reader :info

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

# * Object Initialization

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

def initialize(id, name, mp_cost, price, skills = [], info = nil)

# Set parameters

@id = id

@name = name

@mp_cost = mp_cost

@price = price # New in 2.0

@skills = skills

@info = info

end

end

 

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

# ** Orb_Data

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

# Stores all the games Orb data.

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

 

class Orbs_Data

 

# This is the Orb database

# Define new Orbs like so; Orb.new(id, name, mp_cost, price, skills, info) 

# Put the skill ID's you want to learn in the skills array

 

Orb_Database = [ 

 

Orb.new(0, 'Heal', 3, 100, [1, 4], 'Bestows Heal and Remedy on user.'), 

Orb.new(1, 'Hi Heal', 5, 500, [1, 2, 4, 5], 'Bestows Heal 1 & 2 & Remedy 1 & 2 and on user.'),

Orb.new(2, 'X Heal', 8, 1000, [1, 2, 3, 4, 5, 6], 'Bestows Heal 1 & 2 & Remedy 1 & 2 and Revive on user.'),

Orb.new(3, 'Fire', 2, 100, [7], 'Bestows Fire on user.'), 

Orb.new(4, 'Hi Fire', 4, 500, [7, 8], 'Bestows Fire 1 & 2 on user.'),

Orb.new(5, 'X Fire', 6, 1000, [7, 8, 9], 'Bestows Fire 1, 2 , & 3 on user.'),

Orb.new(6, 'Ice', 2, 100, [10], 'Bestows Ice on user.'),

Orb.new(7, 'Hi Ice', 4, 500, [10, 11], 'Bestows Ice 1 & 2 on user.'),

Orb.new(8, 'X Ice', 6, 1000, [10, 11, 12], 'Bestows Ice 1, 2 , & 3 on user.'),

Orb.new(9, 'Light', 6, 600, [25], 'Bestows Light on user.'),

Orb.new(10, 'Dark', 6, 600, [28], 'Bestows Darkness on user.'),

Orb.new(11, 'Flare', 7, 800, [31], 'Bestows Burst on user.'),

Orb.new(12, 'Ultima', 9, 1200, [32], 'Bestows Ultima on user.'),

Orb.new(13, 'Sword', 2, 500, [57, 58], 'Bestows Sword Skills on user.'),

Orb.new(14, 'Hi Sword', 5, 1000, [57, 58, 59, 60], 'Bestows Advanced Sword Skills on user.'),

Orb.new(15, 'White', 16, 2000, [1, 2, 3, 4, 5, 6, 25, 26, 27, 54, 55], 'Bestows effects of X Heal, Hi Light, Resist Barrier on user.')

 

]

end

end

 

 

#******************************************************************************

# II Part Two

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

# This part deals with the windows and scene for equipping Orbs.

#******************************************************************************

 

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

# ** Scene_Equip_Orb

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

# This class handles equipping & unequipping Orbs.

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

 

class Scene_Equip_Orb

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

# * Object Initialization

# actor_index : actor index

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

def initialize(actor_index = 0)

@actor_index = actor_index

end

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

# * Main Processing

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

def main

# Get actor

@actor = $game_party.actors[@actor_index]

# Command window

s1 = 'Equip'

s2 = 'Remove'

s3 = 'Discard'

@window_choice = Window_Command3.new([s1, s2, s3])

@window_choice.active = true

# Character attributes window

@orb_right_window = Window_Orb_Right.new(@actor)

@orb_right_window.x = 368

@orb_right_window.y = 64

# Orb equip window

@window_equip_orb = Window_EquipOrb.new(@actor)

@window_equip_orb.x = 0

@window_equip_orb.y = 272

# Orb unequip window

@window_remove_orb = Window_RemoveOrb.new(@actor)

@window_remove_orb.x = 0

@window_remove_orb.y = 64

# MP cost window

@mp_window = Window_MP.new

@mp_window.x = 368

@mp_window.y = 416

# Help Window

@help_window = Window_Help2.new

@help_window.x = 0

@help_window.y = 0

@help_window.visible = false

refresh

# Execute transition

Graphics.transition

# Main loop

loop do

# Update game screen

Graphics.update

# Update input information

Input.update

# Frame update

update

# Abort loop if screen is changed

if $scene != self

break

end

end

# Prepare for transition

Graphics.freeze

# Dispose of windows

@mp_window.dispose

@window_equip_orb.dispose

@window_remove_orb.dispose

@window_choice.dispose

@orb_right_window.dispose

@help_window.dispose

end

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

# * Refresh Methods

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

# Refresh equip window

def refresh

# Get Orb to equip

@gem = @window_equip_orb.gem

# If no Orbs are in stock to select, update MP cost window to nothing

if @gem == nil

# Update MP cost window to nothing

@mp_window.set_new_parameters(nil)

# Set help window text to nothing

@help_window.set_text("") 

elsif @gem != nil

# Set help window text to current Orb's info

@help_window.set_text(@gem.info) 

if @window_equip_orb.active 

# Get currently selected Orbs MP cost

mp_need = @gem.mp_cost

# Update MP cost window

@mp_window.set_new_parameters(mp_need)

end

end

end

# Refresh unequip window

def refresh2 

# Get Orb to unequip

@gem2 = @window_remove_orb.gem

# If character has no Orbs to unequip, update MP cost window to nothing

if @gem2 == nil

# Update MP cost window to nothing

@mp_window.set_new_parameters(nil)

# Set help window text to nothing

@help_window.set_text("")

elsif @gem2 != nil

# Set help window text to current Orb's info

@help_window.set_text(@gem2.info)

if @window_remove_orb.active

# Get currently selected Orbs MP cost

mp_need = @gem2.mp_cost

# Update MP cost window

@mp_window.set_new_parameters(-mp_need)

end

end 

end

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

# * Equip, Unequip, & Drop Methods

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

# Equip Orb

def equip_orb(orb)

# Get Orb position data

index = @window_equip_orb.index

# Equip actor with Orb

@actor.get_orb(orb)

# Actor learn skill(s) from Orb

@actor.learn_orbskill(orb)

# Subtract Orb MP cost from character MP

@actor.mp -= orb.mp_cost

# Clear inventory of equiped Orb at Orb's location

$game_party.orbs.delete_at(index)

# Remake Orb equip, unequip, and attribute window contents

@orb_right_window.refresh

@window_remove_orb.refresh

@window_equip_orb.refresh

end

# Unequip Orb

def unequip_orb(orb)

# Get Orb position data

index = @window_remove_orb.index

# Add Orb back to inventory

$game_party.gain_orb(orb)

# Return actors MP

@actor.mp += orb.mp_cost

# Character will forget unequiped Orb's skill(s)

@actor.drop_orbskill(orb)

# Clear actors inventory at Orb's position

@actor.orbs_equiped.delete_at(index)

# Remake Orb equip, unequip, and attribute window contents

@orb_right_window.refresh

@window_remove_orb.refresh

@window_equip_orb.refresh

end

# Drop Orb

def trash_orb(orb)

# Get Orb position data

index = @window_equip_orb.index

# Clear inventory of equiped Orb at Orb's location

$game_party.orbs.delete_at(index)

# Remake Orb equip, unequip, and attribute window contents

@orb_right_window.refresh

@window_remove_orb.refresh

@window_equip_orb.refresh

end

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

# * Frame Update

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

def update

# Update windows

@mp_window.update

@window_remove_orb.update

@window_equip_orb.update

@window_choice.update

@orb_right_window.update

refresh

# If command window is active: call update_choice

if @window_choice.active

update_choice

return

end

# If the unequip Orb window is active: call update_remove_orb

if @window_remove_orb.active

update_remove_orb

return

end

# If the equip Orb window is active: call update_orb

if @window_equip_orb.active

update_orb

return

end

end

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

# * Frame Update (when command window is active)

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

def update_choice

# If B button was pressed

if Input.trigger?(Input::B)

# Play cancel SE

$game_system.se_play($data_system.cancel_se)

# Switch to menu screen

@window_choice.active = false

@window_choice.index = -1

$scene = Scene_Menu.new(4)

return

end

# If C button was pressed

if Input.trigger?(Input::C)

# Play decision SE

$game_system.se_play($data_system.decision_se)

# What actions to take when user selects Equip or Unequip

case @window_choice.index

when 0

# Activate equip Orb window

@window_choice.active = false

@window_choice.visible = false

@window_equip_orb.active = true

@window_equip_orb.index = 0

@help_window.visible = true

when 1

# Activate unequip Orb window

@window_choice.active = false

@window_choice.visible = false

@window_remove_orb.active = true

@window_remove_orb.index = 0 

@help_window.visible = true

when 2

# Activate equip window to dump Orb

@window_choice.active = false

@window_equip_orb.active = true

@window_equip_orb.index = 0

return

end

end

# If R button was pressed

if Input.trigger?(Input::R)

# Play cursor SE

$game_system.se_play($data_system.cursor_se)

# To next actor

@actor_index += 1

@actor_index %= $game_party.actors.size

# Switch to different equipment screen

$scene = Scene_Equip_Orb.new(@actor_index)

return

end

# If L button was pressed

if Input.trigger?(Input::L)

# Play cursor SE

$game_system.se_play($data_system.cursor_se)

# To previous actor

@actor_index += $game_party.actors.size - 1

@actor_index %= $game_party.actors.size

# Switch to different equipment screen

$scene = Scene_Equip_Orb.new(@actor_index)

return

end

end

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

# * Frame Update (when Orb unequip window is active)

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

def update_remove_orb

refresh2

# If B button was pressed

if Input.trigger?(Input::B)

# Play cancel SE

$game_system.se_play($data_system.cancel_se)

# Active command window

@window_choice.active = true

@window_choice.visible = true

@window_remove_orb.active = false

@help_window.visible = false

@window_choice.index = 0

for i in 0...@actor.orbs_equiped.size

@actor.learn_orbskill(@actor.orbs_equiped[i])

end

return

end

# If C button was pressed

if Input.trigger?(Input::C)

# Get currently selected orb data on the unequip Orb window

@gem2 = @window_remove_orb.gem

# If character has no Orbs to unequip, play cancel SE

if @gem2 == nil

$game_system.se_play($data_system.cancel_se)

else

# Play equip SE 

$game_system.se_play($data_system.equip_se)

# Change equipment

unequip_orb(@gem2)

return

end

end

end

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

# * Frame Update (when Orb equip window is active)

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

def update_orb

# If B button was pressed

if Input.trigger?(Input::B)

# Play cancel SE

$game_system.se_play($data_system.cancel_se)

# Activate command window

@window_choice.active = true

@window_choice.visible = true

@window_equip_orb.active = false

@help_window.visible = false

@window_choice.index = 0 

return

end

# If C button was pressed

if Input.trigger?(Input::C)

# Get currently selected orb data on the equip Orb window

@gem = @window_equip_orb.gem

# if the are no equipable orbs in stock, play cancel SE

if @gem == nil

# Play cancel SE

$game_system.se_play($data_system.cancel_se)

else

# If Discard Orb was selected

if @window_choice.index == 2

# Play equip SE 

$game_system.se_play($data_system.equip_se)

trash_orb(@gem)

else # Else if Equip Orb was selected

# Character can't equip Orb without enough MP

# Check if currently selected Orb's MP cost is higher than actor's MP

if @gem.mp_cost > @actor.mp

# Play cancel SE

$game_system.se_play($data_system.cancel_se)

else

# Play equip SE 

$game_system.se_play($data_system.equip_se)

# Change equipment

equip_orb(@gem)

return

end

end

end

end

end

end

 

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

# ** Window_EquipOrb

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

# This window displays Orbs in the party's inventory

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

 

class Window_EquipOrb < Window_Selectable

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

# * Object Initialization

# actor : actor

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

def initialize(actor)

super(0, 0, 368, 208)

@actor = actor

@column_max = 1

self.active = false

refresh

self.index = 0

end

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

# * Orb Acquisition

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

def gem

return @data[self.index]

end

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

# * Refresh

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

def refresh

if self.contents != nil

self.contents.dispose

self.contents = nil

end

@data = []

# For every Orb in party's inventory, they are sent to @data array

for i in 0...$game_party.orbs.size

@data.push($game_party.orbs[i])

end

# If item count is not 0, make a bitmap and draw all items

@item_max = @data.size

if @item_max > 0

self.contents = Bitmap.new(width - 32, row_max * 32)

for i in 0...@item_max

draw_item(i)

end

end

end

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

# * Draw Item

# index : item number

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

def draw_item(index)

orb = @data[index]

# if actor doesn't have enough MP to equip Orb, darken its color

if orb.mp_cost > @actor.mp

self.contents.font.color = disabled_color

else

self.contents.font.color = normal_color

end

x = 4 

y = index * 30

rect = Rect.new(x, y, self.width / @column_max - 32, 32)

self.contents.fill_rect(rect, Color.new(0, 0, 0, 0))

bitmap = RPG::Cache.icon('036-Item05')

opacity = self.contents.font.color == normal_color ? 255 : 128

self.contents.blt(x, y + 4, bitmap, Rect.new(0, 0, 24, 24), opacity) 

self.contents.draw_text(x + 28, y, 204, 32, orb.name, 0)

end

end

 

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

# ** Window_RemoveOrb

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

# This window displays the Orbs an actor has currently equiped

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

 

class Window_RemoveOrb < Window_Selectable

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

# * Object Initialization

# actor : actor

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

def initialize(actor)

super(0, 0, 368, 208)

@actor = actor

@column_max = 1

self.active = false

@data = []

refresh

self.index = 0

end

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

# * Orb Acquisition

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

def gem

return @data[self.index]

end

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

# * Refresh

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

def refresh

if self.contents != nil

self.contents.dispose

self.contents = nil

end

@data = []

# For every Orb the actor has equipped, they are sent to @data array

for i in 0...@actor.orbs_equiped.size

@data.push(@actor.orbs_equiped[i])

end

# If item count is not 0, make a bit map and draw all items

@item_max = @data.size

if @item_max > 0

self.contents = Bitmap.new(width - 32, row_max * 32)

for i in 0...@item_max

draw_item(i)

end

end

end

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

# * Draw Item

# index : item number

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

def draw_item(index)

orb = @data[index]

x = 4 

y = index * 30

rect = Rect.new(x, y, self.width / @column_max - 32, 32)

self.contents.fill_rect(rect, Color.new(0, 0, 0, 0))

bitmap = RPG::Cache.icon('036-Item05')

opacity = self.contents.font.color == normal_color ? 255 : 128

self.contents.blt(x, y + 4, bitmap, Rect.new(0, 0, 24, 24), opacity)

self.contents.draw_text(x + 28, y, 204, 32, orb.name, 0)

end

end

 

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

# ** Window_Orb_Right

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

# Shows characters attributes.

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

 

class Window_Orb_Right < Window_Base

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

# * Object Initialization

# actor : actor

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

def initialize(actor)

super(0, 0, 272, 352)

self.contents = Bitmap.new(width - 32, height - 32)

@actor = actor

refresh

end

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

# * Draws actors attributes

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

def draw_stats

draw_actor_graphic(@actor, 136, 200)

draw_actor_name(@actor, 4, 152)

draw_actor_level(@actor, 4, 184)

draw_actor_hp(@actor, 4, 216, 172)

draw_actor_sp(@actor, 4, 248, 172)

draw_actor_mp(@actor, 4, 280)

end

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

# * Refresh

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

def refresh

self.contents.clear

draw_stats

end

end

 

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

# ** Window_MP

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

# This window displays amount of MP a character has.

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

 

class Window_MP < Window_Base

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

# * Object Initialization

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

def initialize

super(0, 0, 272, 64)

self.contents = Bitmap.new(width - 32, height - 32)

refresh

end

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

# Refresh

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

def refresh

self.contents.clear

cx = contents.text_size($data_system.words.gold).width

self.contents.font.color = system_color

self.contents.draw_text(4, 0, 120, 32, "MP Required", 0)

if @mp_need != nil

self.contents.font.color = normal_color

self.contents.draw_text(124, 0, 32, 32, @mp_need.to_s, 2)

end

end

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

# * Set parameters for Orb's MP cost

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

def set_new_parameters(mp_need)

if @mp_need != mp_need 

@mp_need = mp_need

refresh

end

end

end

 

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

# ** Window_Command2

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

# This version of command window is a set size with scrolling commands.

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

 

class Window_Command2 < Window_Selectable

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

# * Object Initialization

# width : window width

# commands : command text string array

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

def initialize(width, commands)

super(0, 0, width, 224)

@item_max = commands.size

@commands = commands

self.contents = Bitmap.new(width - 32, @item_max * 32)

refresh

self.index = 0

end

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

# * Refresh

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

def refresh

self.contents.clear

for i in 0...@item_max

draw_item(i, normal_color)

end

end

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

# * Draw Item

# index : item number

# color : text color

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

def draw_item(index, color)

self.contents.font.color = color

rect = Rect.new(4, 32 * index, self.contents.width - 8, 32)

self.contents.fill_rect(rect, Color.new(0, 0, 0, 0))

self.contents.draw_text(rect, @commands[index])

end

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

# * Disable Item

# index : item number

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

def disable_item(index)

draw_item(index, disabled_color)

end

end

 

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

# ** Window_Command3

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

# This is a horizontal version of the Command Window.

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

 

class Window_Command3 < Window_Selectable

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

# * Object Initialization

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

def initialize(commands)

super(0, 0, 640, 64)

self.contents = Bitmap.new(width - 32, height - 32)

@item_max = commands.size

@commands = commands

@column_max = @item_max

refresh

self.index = 0

end

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

# * Refresh

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

def refresh

self.contents.clear

for i in 0...@item_max

draw_item(i, normal_color)

end

end

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

# * Draw Item

# index : item number

# color : text character color

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

def draw_item(index, color)

self.contents.font.color = color

x = self.width / @item_max * index

x2 = self.width / @column_max - 32

rect = Rect.new(x, 0, x2, 32)

self.contents.draw_text(rect, @commands[index], 1)

end

end

 

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

# ** Window_Help2

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

# This window shows Orb explanations.

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

 

class Window_Help2 < Window_Base

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

# * Object Initialization

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

def initialize

super(0, 0, 640, 64)

self.contents = Bitmap.new(width - 32, height - 32)

end

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

# * Set Text

# text : text string displayed in window

# align : alignment (0..flush left, 1..center, 2..flush right)

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

def set_text(text, align = 1)

# If at least one part of text and alignment differ from last time

if text != @text or align != @align

# Redraw text

self.contents.clear

self.contents.font.color = normal_color

self.contents.draw_text(4, 0, self.width - 40, 32, text, align)

@text = text

@align = align

@actor = nil

end

end

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

# * Set Actor

# actor : status displaying actor

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

def set_actor(actor)

if actor != @actor

self.contents.clear

draw_actor_name(actor, 4, 0)

draw_actor_state(actor, 140, 0)

draw_actor_hp(actor, 284, 0)

draw_actor_sp(actor, 460, 0)

@actor = actor

@text = nil

self.visible = true

end

end

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

# * Set Enemy

# enemy : name and status displaying enemy

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

def set_enemy(enemy)

text = enemy.name

state_text = make_battler_state_text(enemy, 112, false)

if state_text != ""

text += " " + state_text

end

set_text(text, 1)

end

end

 

#******************************************************************************

# III Part Three

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

# This part contains all the changes to the original script.

#******************************************************************************

 

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

# ** Game_Actor

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

 

class Game_Actor < Game_Battler

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

# * Public Instance Variables

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

# Added variables

attr_accessor :orbs_equiped

attr_reader :max_mp

attr_reader :mp

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

# * Alias Methods

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

alias orb_game_actor_setup setup

alias orb_game_actor_init initialize

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

# * Object Initialization

# actor_id : actor ID

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

def initialize(actor_id)

orb_game_actor_init(actor_id)

end

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

# * Setup

# information for Orbs

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

def setup(actor_id)

# Added info for Orb system

@orbs_equiped = []

@mp = 10

@max_mp = 10

# Original setup method

orb_game_actor_setup(actor_id)

end

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

# * Create Maximum MP

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

def max_mp=(max_mp)

@max_mp = max_mp

end

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

# * Create MP

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

def mp=(mp)

@mp = mp

end

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

# * Change EXP

# exp : new EXP

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

def exp=(exp)

@exp = [[exp, 9999999].min, 0].max

# Level up

while @exp >= @exp_list[@level+1] and @exp_list[@level+1] > 0

@level += 1

# Max MP and current MP also rise with level

# Max MP will equal actor's level

@mp += 1

@max_mp += 1

# Learn skill

for j in $data_classes[@class_id].learnings

if j.level == @level

learn_skill(j.skill_id)

end

end

end

# Level down

while @exp < @exp_list[@level]

@level -= 1

# Max MP and current MP also decrease with level

# Max MP will equal actor's level

@mp -= 1

@max_mp -= 1

end

# Correction if exceeding current max HP and max SP

@hp = [@hp, self.maxhp].min

@sp = [@sp, self.maxsp].min

end

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

# * Returns actors orbs_equipped array

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

def orbs_equip

return @actor.orbs_equiped

end

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

# * Equip orb method

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

def get_orb(orb_id)

@orbs_equiped.push(orb_id).dup

end 

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

# * Unequip orb method

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

def getrid_orb(orb_id)

@orbs_equiped.delete_at(orb_id.index)

end

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

# * Learn Skill from orb

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

def learn_orbskill(orb_id)

@orb = orb_id

# For every skill the current orb contains, the actor will learn them

# when equipping it

for i in 0...@orb.skills.size

skill_id = @orb.skills[i]

# Learn Skill

if not skill_learn?(skill_id)

@skills.push(skill_id)

end

end

end

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

# * Forget Skill from orb

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

def drop_orbskill(orb_id)

@orbf = orb_id

# For every skill the current orb contains, the actor will forget them

# when unequipping it

for i in 0...@orbf.skills.size

skill_id = @orbf.skills[i]

# Forget Skill

@skills.delete(skill_id)

end

end 

end

 

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

# ** Game_Party

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

 

class Game_Party

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

# * Public Instance Variables

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

# Added variable

attr_accessor :orbs

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

# * Alias Method

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

alias orb_game_party_init initialize

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

# * Object Initialization

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

def initialize

# Original initialize method

orb_game_party_init

# Added Orbs array

# This array stores all the Orbs in the party's inventory

@orbs = []

end

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

# Clear inventory of an Orb

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

def lose_orb(orb_id)

# Delete Orb at correct location

@orbs.delete_at(orb_id.index)

# Sort Orbs in alphabetical order by name

@orbs.sort! {|a, z| a.id <=> z.id}

end

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

# Add an Orb to the Party's inventory

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

def gain_orb(orb_id)

# Duplicate Orbs of the same type that are sent to array

@orbs.push(orb_id).dup

# Sort Orbs in alphabetical order by name

@orbs.sort! {|a, z| a.id <=> z.id}

end

end 

 

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

# ** Window_Base

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

 

class Window_Base < Window

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

# * Draws actors battler picture

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

def draw_actor_battler(actor, x, y)

bitmap = RPG::Cache.battler(actor.battler_name, actor.battler_hue)

x2 = bitmap.width 

y2 = bitmap.height

x3 = 240 - bitmap.width 

y3 = 320 - bitmap.height

src_rect = Rect.new(0, 0, x2, y2)

if x3 <= y3

new_rect = Rect.new(0, 0, x2 + x3, y2 + x3)

else

new_rect = Rect.new(0, 0, x2 + y3, y2 + y3)

end

self.contents.stretch_blt(new_rect, bitmap, src_rect, 100)

end

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

# * Draws actors MP

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

def draw_actor_mp(actor, x, y)

self.contents.font.color = system_color

self.contents.draw_text(x, y, 32, 32, "MP")

self.contents.font.color = normal_color

self.contents.draw_text(x + 24, y, 84, 32, actor.mp.to_s, 2)

self.contents.draw_text(x + 112, y, 12, 32, "/ ", 1)

self.contents.draw_text(x + 120, y, 84, 32, actor.max_mp.to_s)

end

end

 

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

# ** Scene_Menu

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

 

class Scene_Menu

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

# * Main Processing

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

def main

# Make command window

s1 = $data_system.words.item

s2 = $data_system.words.skill

s3 = $data_system.words.equip

s4 = "Orbs"

s5 = "Status"

s6 = "Save"

s7 = "End Game"

@command_window = Window_Command2.new(160, [s1, s2, s3, s4, s5, s6, s7])

@command_window.index = @menu_index

# If number of party members is 0

if $game_party.actors.size == 0

# Disable items, skills, equipment, orbs, and status

@command_window.disable_item(0)

@command_window.disable_item(1)

@command_window.disable_item(2)

@command_window.disable_item(3)

@command_window.disable_item(4)

end

# If save is forbidden

if $game_system.save_disabled

# Disable save

@command_window.disable_item(5)

end

# Make play time window

@playtime_window = Window_PlayTime.new

@playtime_window.x = 0

@playtime_window.y = 224

# Make steps window

@steps_window = Window_Steps.new

@steps_window.x = 0

@steps_window.y = 320

# Make gold window

@gold_window = Window_Gold.new

@gold_window.x = 0

@gold_window.y = 416

# Make status window

@status_window = Window_MenuStatus.new

@status_window.x = 160

@status_window.y = 0

# Execute transition

Graphics.transition

# Main loop

loop do

# Update game screen

Graphics.update

# Update input information

Input.update

# Frame update

update

# Abort loop if screen is changed

if $scene != self

break

end

end

# Prepare for transition

Graphics.freeze

# Dispose of windows

@command_window.dispose

@playtime_window.dispose

@steps_window.dispose

@gold_window.dispose

@status_window.dispose

end

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

# * Frame Update (when command window is active)

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

def update_command

# If B button was pressed

if Input.trigger?(Input::B)

# Play cancel SE

$game_system.se_play($data_system.cancel_se)

# Switch to map screen

$scene = Scene_Map.new

return

end

# If C button was pressed

if Input.trigger?(Input::C)

# If command other than save or end game, and party members = 0

if $game_party.actors.size == 0 and @command_window.index < 4

# Play buzzer SE

$game_system.se_play($data_system.buzzer_se)

return

end

# Branch by command window cursor position

case @command_window.index

when 0 # item

# Play decision SE

$game_system.se_play($data_system.decision_se)

# Switch to item screen

$scene = Scene_Item.new

when 1 # skill

# Play decision SE

$game_system.se_play($data_system.decision_se)

# Make status window active

@command_window.active = false

@status_window.active = true

@status_window.index = 0

when 2 # equipment

# Play decision SE

$game_system.se_play($data_system.decision_se)

# Make status window active

@command_window.active = false

@status_window.active = true

@status_window.index = 0

when 3 # Orbs

# Play decision SE

$game_system.se_play($data_system.decision_se)

# Make status window active

@command_window.active = false

@status_window.active = true

@status_window.index = 0

when 4 # status

# Play decision SE

$game_system.se_play($data_system.decision_se)

# Make status window active

@command_window.active = false

@status_window.active = true

@status_window.index = 0

when 5 # save

# If saving is forbidden

if $game_system.save_disabled

# Play buzzer SE

$game_system.se_play($data_system.buzzer_se)

return

end

# Play decision SE

$game_system.se_play($data_system.decision_se)

# Switch to save screen

$scene = Scene_Save.new

when 6 # end game

# Play decision SE

$game_system.se_play($data_system.decision_se)

# Switch to end game screen

$scene = Scene_End.new

end

return

end

end

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

# * Frame Update (when status window is active)

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

def update_status

# If B button was pressed

if Input.trigger?(Input::B)

# Play cancel SE

$game_system.se_play($data_system.cancel_se)

# Make command window active

@command_window.active = true

@status_window.active = false

@status_window.index = -1

return

end

# If C button was pressed

if Input.trigger?(Input::C)

# Branch by command window cursor position

case @command_window.index

when 1 # skill

# If this actor's action limit is 2 or more

if $game_party.actors[@status_window.index].restriction >= 2

# Play buzzer SE

$game_system.se_play($data_system.buzzer_se)

return

end

# Play decision SE

$game_system.se_play($data_system.decision_se)

# Switch to skill screen

$scene = Scene_Skill.new(@status_window.index)

when 2 # equipment

# Play decision SE

$game_system.se_play($data_system.decision_se)

# Switch to equipment screen

$scene = Scene_Equip.new(@status_window.index)

when 3 # Orbs

# Play decision SE

$game_system.se_play($data_system.decision_se)

# Switch to Orbs Screen

$scene = Scene_Equip_Orb.new(@status_window.index)

when 4 # status

# Play decision SE

$game_system.se_play($data_system.decision_se)

# Switch to status screen

$scene = Scene_Status.new(@status_window.index)

end

return

end

end

end

 

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

# ** Scene_Title

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

 

class Scene_Title

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

# Alias Methods

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

alias orb_scene_title_main main

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

# * Main Processing

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

def main

# Load Orb database

$data_orbs = RPG::Orbs_Data::Orb_Database

# Original script

orb_scene_title_main

end

end

 

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

# ** Game_Temp

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

 

class Game_Temp

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

# * Public Instance Variables

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

# Added variable

attr_accessor :shop_orbs

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

# * Alias Method

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

alias orb_game_temp_init initialize

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

# * Object Initialization

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

def initialize

# Original method

orb_game_temp_init

# Added array for Orbs that the shop will sell

@shop_orbs = []

end

end

 

 

#******************************************************************************

# IV Part Four

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

# This part is contains the windows and scene that enable buying and selling Orbs.

#******************************************************************************

 

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

# ** Scene_Orb_Shop

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

# This class handles buying and selling Orbs.

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

 

class Scene_Orb_Shop

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

# * Main Processing

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

def main

# Get orbs for sale from $game_temp array

@orbs_for_sale = $game_temp.shop_orbs

# Make help window

@help_window = Window_Help.new

# Make command window

@command_window = Window_ShopCommand.new

# Make gold window

@gold_window = Window_Gold.new

@gold_window.x = 480

@gold_window.y = 64

# Make blank window

@blank_window = Window_Base.new(0, 128, 640, 352)

# Make buy window

@orb_buy_window = Window_Orb_Buy.new(@orbs_for_sale)

@orb_buy_window.active = false

@orb_buy_window.visible = false

@orb_buy_window.help_window = @help_window

# Make sell window

@orb_sell_window = Window_Orb_Sell.new

@orb_sell_window.active = false

@orb_sell_window.visible = false

@orb_sell_window.help_window = @help_window

# Execute transition

Graphics.transition

# Main loop

loop do

# Update game screen

Graphics.update

# Update input information

Input.update

# Frame update

update

# Abort loop if screen is changed

if $scene != self

break

end

end

# Prepare for transition

Graphics.freeze

# Dispose of windows

@help_window.dispose

@command_window.dispose

@gold_window.dispose

@blank_window.dispose

@orb_buy_window.dispose

@orb_sell_window.dispose

end

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

# * Frame Update

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

def update

# Update windows

@help_window.update

@command_window.update

@gold_window.update

@blank_window.update

@orb_buy_window.update

@orb_sell_window.update

# If command window is active: call update_command

if @command_window.active

update_command

return

end

# If buy window is active: call update_orb_buy

if @orb_buy_window.active

update_orb_buy

return

end

# If sell window is active: call update_orb_sell

if @orb_sell_window.active

update_orb_sell

return

end

end

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

# * Frame Update (when command window is active)

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

def update_command

# If B button was pressed

if Input.trigger?(Input::B)

# Play cancel SE

$game_system.se_play($data_system.cancel_se)

# Switch to map screen

$scene = Scene_Map.new

return

end

# If C button was pressed

if Input.trigger?(Input::C)

# Branch by command window cursor position

case @command_window.index

when 0 # buy

# Play decision SE

$game_system.se_play($data_system.decision_se)

# Change windows to buy mode

@command_window.active = false

@blank_window.visible = false

@orb_buy_window.active = true

@orb_buy_window.visible = true

@orb_buy_window.refresh

when 1 # sell

# Play decision SE

$game_system.se_play($data_system.decision_se)

# Change windows to sell mode

@command_window.active = false

@blank_window.visible = false

@orb_sell_window.active = true

@orb_sell_window.visible = true

@orb_sell_window.refresh

when 2 # quit

# Play decision SE

$game_system.se_play($data_system.decision_se)

# Switch to map screen

$scene = Scene_Map.new

end

return

end

end

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

# * Frame Update (when buy window is active)

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

def update_orb_buy

# If B button was pressed

if Input.trigger?(Input::B)

# Play cancel SE

$game_system.se_play($data_system.cancel_se)

# Go back to command window

@command_window.active = true

@blank_window.visible = true

@orb_buy_window.active = false

@orb_buy_window.visible = false

# Set help text to nothing

@help_window.set_text("")

return

end

# If C button was pressed

if Input.trigger?(Input::C)

# Get orb to buy

@orb = @orb_buy_window.orb

# If orb is nothing, or the if it costs more money than the player has

if @orb == nil or @orb.price > $game_party.gold

# Play buzzer SE

$game_system.se_play($data_system.buzzer_se)

return

end

# Play shop SE

$game_system.se_play($data_system.shop_se)

# Add orb to players inventory

$game_party.gain_orb(@orb)

# Subtract money for purchase

$game_party.lose_gold(@orb.price)

# Remake gold and sell window contents

@gold_window.refresh

@orb_buy_window.refresh

end

end

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

# * Frame Update (when sell window is active)

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

def update_orb_sell

# If B button was pressed

if Input.trigger?(Input::B)

# Play cancel SE

$game_system.se_play($data_system.cancel_se)

# Go back to command window

@command_window.active = true

@blank_window.visible = true

@orb_sell_window.active = false

@orb_sell_window.visible = false

# Set help text to nothing

@help_window.set_text("")

return

end

# If C button was pressed

if Input.trigger?(Input::C)

# Get orb to sell

@orb = @orb_sell_window.orb

@index = @orb_sell_window.index

# If item is invalid, or item price is 0 (unable to sell)

if @orb == nil or @orb.price == 0

# Play buzzer SE

$game_system.se_play($data_system.buzzer_se)

return

end

# Play shop SE

$game_system.se_play($data_system.shop_se)

# Add money from orb sale

$game_party.gain_gold(@orb.price / 2)

# Get rid of orb from players inventory

$game_party.orbs.delete_at(@index)

# Remake gold and sell window contents

@gold_window.refresh

@orb_sell_window.refresh

end

end

end

 

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

# ** Window_Orb_Buy

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

# This window displays buyable Orbs on the shop screen.

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

 

class Window_Orb_Buy < Window_Selectable

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

# * Object Initialization

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

def initialize(orbs_for_sale)

super(0, 128, 368, 352)

@orbs_for_sale = orbs_for_sale

refresh

self.index = 0

end

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

# * Orb Acquisition

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

def orb

return @data[self.index]

end

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

# * Refresh

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

def refresh

if self.contents != nil

self.contents.dispose

self.contents = nil

end

@data = []

# For every orb in @orbs_for_sale array send them to window array

for i in 0..@orbs_for_sale.size

orb = @orbs_for_sale[i]

if orb != nil

@data.push(orb)

end

end

# Sort Orbs in alphabetical order by name

@data.sort! {|a, z| a.id <=> z.id}

# If item count is not 0, make a bit map and draw all items

@item_max = @data.size

if @item_max > 0

self.contents = Bitmap.new(width - 32, row_max * 32)

for i in 0...@item_max

draw_item(i)

end

end

end

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

# * Draw Item

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

def draw_item(index)

orb = @data[index]

# If price is less than money in possession, 

if orb.price <= $game_party.gold

self.contents.font.color = normal_color

else

self.contents.font.color = disabled_color

end

x = 4

y = index * 32

rect = Rect.new(x, y, self.width - 32, 32)

self.contents.fill_rect(rect, Color.new(0, 0, 0, 0))

bitmap = RPG::Cache.icon('036-Item05')

opacity = self.contents.font.color == normal_color ? 255 : 128

self.contents.blt(x, y + 4, bitmap, Rect.new(0, 0, 24, 24), opacity)

self.contents.draw_text(x + 28, y, 212, 32, orb.name, 0)

self.contents.draw_text(x + 240, y, 88, 32, orb.price.to_s, 2)

end

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

# * Help Text Update

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

def update_help

@help_window.set_text(self.orb == nil ? "" : self.orb.info)

end

end

 

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

# ** Window_Orb_Sell

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

# This window displays sellable Orbs on the shop screen.

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

 

class Window_Orb_Sell < Window_Selectable

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

# * Object Initialization

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

def initialize

super(272, 128, 368, 352)

refresh

self.index = 0

end

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

# * Orb Acquisition

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

def orb

return @data[self.index]

end

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

# * Refresh

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

def refresh

if self.contents != nil

self.contents.dispose

self.contents = nil

end

@data = []

# For every Orb in party's inventory, they are sent to @data array

for i in 0...$game_party.orbs.size

@data.push($game_party.orbs[i])

end

# If item count is not 0, make a bitmap and draw all items

@item_max = @data.size

if @item_max > 0

self.contents = Bitmap.new(width - 32, row_max * 32)

for i in 0...@item_max

draw_item(i)

end

end

end

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

# * Draw Item

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

def draw_item(index)

orb = @data[index]

x = 4 

y = index * 32

rect = Rect.new(x, y, self.width - 32, 32)

self.contents.fill_rect(rect, Color.new(0, 0, 0, 0))

bitmap = RPG::Cache.icon('036-Item05')

opacity = self.contents.font.color == normal_color ? 255 : 128

self.contents.blt(x, y + 4, bitmap, Rect.new(0, 0, 24, 24), opacity)

self.contents.draw_text(x + 28, y, 212, 32, orb.name, 0)

sell_price = orb.price / 2

self.contents.draw_text(x + 240, y, 88, 32, sell_price.to_s, 2)

end

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

# * Help Text Update

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

def update_help

@help_window.set_text(self.orb == nil ? "" : self.orb.info)

end

end

i want to know how to fix the orb window, its like cut off for some reason.


Uploaded with ImageShack.us
 
Sort by date Sort by votes

regi

Sponsor

15,156
I'm not entirely sure what the problem is. Should there be text, a graphic, or what in the blank upper left screen?

(Just fyi, using the
Code: 
 tags will make reading scripts much easier.)
 
Upvote 0 Downvote

Joe parz

Member

137
o im sorry, do you see how the heal materia is like cut off on the bottom left window. it shows like 5 1/2 options instead of just 5. Theres 5 heals that you can see, and you can only see half of the 6th one. is there anyway to just be able to see 5 at a time and not 5 1/2 like its showing? I hope im explaining this okay
 
Upvote 0 Downvote

regi

Sponsor

15,156
Ah, that makes a lot more sense.
My guess is to change line 536 to something like super(0, 0, 368, 192)
(Modifying the last number changes the window height, which should make only the top 5 lines visible.) You'll have to play around with that value to get the right height. I'm not entirely sure if that's the right window, though, so tell me if it works.
 
Upvote 0 Downvote

MicKo

Member

35
You could increase the space between each line, or, as regi said, resize the window.
Try this:
[ruby]# Orb Based Skill System *
#***************************************************
# Author: El Conducter *
# Date: August/02/07 *
# Version: 2.0 *
#***************************************************
 
#----------------------------------------------------------------------------
# What it Does:
# This script allows characters to learn new skills by equipping magic Orbs.
# Equipping Orbs uses MP, which has been added for the characters. As
# the characters levels increase, so does their MP.
# Update in Version 2.0
# I have now added a shop to buy and sell Orbs. The orbs are also now
# arranged in alphabetical order rather than by ID.
#----------------------------------------------------------------------------
 
#----------------------------------------------------------------------------
# How it Works: This script is organized into 4 parts. New part in Version 2.0
#
# Part 1 defines Orbs and sets up the Orb database. The main points in Part 1 are:
#
# class Orb defines a new object (the Orb)
# - id: As its name implies it is the Orb's ID Number
# - name: The Name of the Orb
# - mp_cost: The amount of MP required to equip the Orb
# - price: How much the Orb costs
# - skills: An array of learnable skills from Orb
# - info: A discription of what the Orb does
#
# class Orbs_Data is the database where all the games Orbs
# are defined. The orbs are set up in an array and assigned to a Constant.
# - Define your Orbs within the array like so: Orb.new(id, name, mp_cost, skills, info)
#
# Part 2 consists of all the window classes and scene that deals with equipping Orbs.
# The classes that make up Part 2 are:
#
# - Scene_Equip_Orb
# - Window_EquipOrb
# - Window_RemoveOrb
# - Window_Orb_Right
# - Window_MP
# - Window_Command2
# - Window_Command3
# - Window_Help2
#
# Part 3 contains all the altered original code. classes that had to altered are:
#
# - Game_Actor
# - Game_Party
# - Window_Base
# - Scene_Menu
# - Scene_Title
# - Game_Temp New in 2.0
#
# Part 4 has all the classes that handle the buying and selling Orbs:
#
# - Scene_Orb_Shop
# - Window_Orb_Buy
# - Window_Orb_Sell
#----------------------------------------------------------------------------
 
#----------------------------------------------------------------------------
# How to Use This Script&#058;
# Just copy it and paste it above Main.
#
# To add Orbs to your party's inventory while playing the game, use
# events Call Script function like this:
# - $game_party.gain_orb($data_orbs 
 
Upvote 0 Downvote
You must log in or register to reply here.

Share this page

Thank you for viewing

HBGames is a leading amateur video game development forum and Discord server open to all ability levels. Feel free to have a nosey around!

Discord

Join our growing and active Discord server to discuss all aspects of game making in a relaxed environment. Join Us

RPG Maker

  • Support & Help
    •
  • Tutorials
    •
  • Plugins - MZ, MV
    •
  • Scripts - Ace, VX, XP
    •
  • Resources
    •

    Content

  • Our Games
    •
  • Games in Development
    •  Emoji by Twemoji.
    Top