Considering Rm2k3 UNLESS this script exist.....which i don't know if it does.

[gameo]

I'm wondering, if there is, not a CBS like Final fantasy 4+, but like Final Fantasy I & Final Fantasy II.


It's turn based, and it's side view. No timers, no special conditions, just like Final Fantasy I & II.


Screenshots:

http://www.gamespot.com/psp/rpg/finalfantasyiianniversaryedition/images.html

[gameo]

Hmm.....i think i was being very specific, showing a lot of screenshots, and didn't even make it as a request.


Though it could be, but for now i'm just asking if there is a script like that.

[gameo]

Am i just not being specific?

I think it's well explained, showed, and politely asked.

[Joaocarlos]

http://www.creationasylum.net/index.php?showtopic=13724

simple you can get

is this it?

[gameo]

2 sec i'll have a look.



No, it's not that. Have tried it, a guy said he would remake it in FF style, but it never happened.

[poser7]

I know it's side view but is it just turn based? If so I think this will work, it's a script so you'll have to use rmxp

[spoiler]

Code Select Expand

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

class Sprite_Battler < RPG::Sprite
#--------------------------------------------------------------------------
# * Initialize
#--------------------------------------------------------------------------
alias cbs_initialize initialize
def initialize(viewport, battler = nil)

# Configuration
@speed = 7 # Framerate speed of the battlers
@frames = 4 # Number of frames in each pose
@poses = 11 # Number of poses (stances) in the template
@mirror_enemies = true # Enemy battlers use reversed image
@stationary_enemies = false # If the enemies don't move while attacking
@stationary_actors = false # If the actors don't move while attacking
@calculate_speed = true # System calculates a mean/average speed
@phasing = true # Characters fade in/out while attacking
@default_collapse = false # Restores the old 'red fade' effect to enemies
# Array that holds the id # of weapons that forces the hero to be stationary
@stationary_weapons = [17,18,19,20,21,22,23,24] # (examples are bows & guns)

# DO NOT EDIT BELOW THIS LINE UNLESS YOU KNOW WHAT YOU'RE DOING
@frame, @pose = 0, 0
@last_time = 0
@last_move_time = 0
cbs_initialize(viewport, battler)
self.mirror = !!battler and @mirror_enemies
viewport.z = 99
end
#--------------------------------------------------------------------------
# * Update
#--------------------------------------------------------------------------
alias cbs_update update
def update
return unless @battler

# Regular Update
cbs_update

# Start Routine
unless @started
@pose = state
@width = @width / @frames
@height = @height / @poses
@display_x = @battler.screen_x
@display_y = @battler.screen_y
@destination_x = @display_x
@destination_y = @display_y
@started = true
end

# Cut Out Frame
self.src_rect.set(@width * @frame, @height * @pose, @width, @height)

# Position Sprite
self.x = @display_x
self.y = @display_y
self.z = @display_y
self.ox = @width / 2
self.oy = @height

# Setup Animation
time = Graphics.frame_count / (Graphics.frame_rate / @speed)
if @last_time < time
@frame = (@frame + 1) % @frames
if @frame == 0
if @freeze
@frame = @frames - 1
return
end
@pose = state
end
end
@last_time = time

# Move It
move if moving
end
#--------------------------------------------------------------------------
# * Current State
#--------------------------------------------------------------------------
def state
# Damage State
if [nil,{}].include?(@battler.damage)
# Battler Fine
@state = 0
# Battler Wounded
@state = 2 if @battler.hp < @battler.maxhp / 4

if @default_collapse
# Battler Dead (Red-Out Collapse)
if @battler.dead? and @battler.is_a?(Game_Actor)
@state = 10
# Fix Opacity
self.opacity = 255
end
else
# Battler Dead (Pose-Type Collapse)
if @battler.dead?
@state = 10
# Fix Opacity
self.opacity = 255
end
end
end
# Guarding State
@state = 3 if @battler.guarding?
# Moving State
if moving
# If enemy battler moving
if @battler.is_a?(Game_Enemy)
# Battler Moving Left
@state = 5 if moving.eql?(0)
# Battler Moving Right
@state = 4 if moving.eql?(1)
# Else actor battler moving
else
# Battler Moving Left
@state = 4 if moving.eql?(0)
# Battler Moving Right
@state = 5 if moving.eql?(1)
end
end
# Return State
return @state
end
#--------------------------------------------------------------------------
# * Move
#--------------------------------------------------------------------------
def move
time = Graphics.frame_count / (Graphics.frame_rate.to_f / (@speed * 5))
if @last_move_time < time

# Pause for Animation
return if @pose != state

# Phasing
if @phasing
d1 = (@display_x - @original_x).abs
d2 = (@display_y - @original_y).abs
d3 = (@display_x - @destination_x).abs
d4 = (@display_y - @destination_y).abs
self.opacity = [255 - ([d1 + d2, d3 + d4].min * 1.75).to_i, 0].max
end

# Calculate Difference
difference_x = (@display_x - @destination_x).abs
difference_y = (@display_y - @destination_y).abs

# Done? Reset, Stop
if [difference_x, difference_y].max.between?(0, 8)
@display_x = @destination_x
@display_y = @destination_y
@pose = state
return
end

# Calculate Movement Increments
increment_x = increment_y = 1
if difference_x < difference_y
increment_x = 1.0 / (difference_y.to_f / difference_x)
elsif difference_y < difference_x
increment_y = 1.0 / (difference_x.to_f / difference_y)
end

# Calculate Movement Speed
if @calculate_speed
total = 0; $game_party.actors.each{ |actor| total += actor.agi }
speed = @battler.agi.to_f / (total / $game_party.actors.size)
increment_x *= speed
increment_y *= speed
end

# Multiply and Move
multiplier_x = (@destination_x - @display_x > 0 ? 8 : -8)
multiplier_y = (@destination_y - @display_y > 0 ? 8 : -8)
@display_x += (increment_x * multiplier_x).to_i
@display_y += (increment_y * multiplier_y).to_i
end
@last_move_time = time
end
#--------------------------------------------------------------------------
# * Set Movement
#--------------------------------------------------------------------------
def setmove(destination_x, destination_y)
unless (@battler.is_a?(Game_Enemy) and @stationary_enemies) or
(@battler.is_a?(Game_Actor) and @stationary_actors)
unless @stationary_weapons.include?(@battler.weapon_id)
@original_x = @display_x
@original_y = @display_y
@destination_x = destination_x
@destination_y = destination_y
end
end
end
#--------------------------------------------------------------------------
# * Movement Check
#--------------------------------------------------------------------------
def moving
if (@display_x != @destination_x and @display_y != @destination_y and !@battler.dead?)
return (@display_x > @destination_x ? 0 : 1)
end
end
#--------------------------------------------------------------------------
# * Set Pose
#--------------------------------------------------------------------------
def pose=(pose)
@pose = pose
@frame = 0
end
#--------------------------------------------------------------------------
# * Freeze
#--------------------------------------------------------------------------
def freeze
@freeze = true
end
#--------------------------------------------------------------------------
# * Fallen Pose
#--------------------------------------------------------------------------
alias cbs_collapse collapse
def collapse
if @default_collapse
cbs_collapse if @battler.is_a?(Game_Enemy)
end
end
end

#==============================================================================
# ** Game_Actor
#==============================================================================

class Game_Actor
#--------------------------------------------------------------------------
# * Actor X Coordinate
#--------------------------------------------------------------------------
def screen_x
if self.index != nil
return self.index * 45 + 450
else
return 0
end
end
#--------------------------------------------------------------------------
# * Actor Y Coordinate
#--------------------------------------------------------------------------
def screen_y
return self.index * 35 + 200
end
#--------------------------------------------------------------------------
# * Actor Z Coordinate
#--------------------------------------------------------------------------
def screen_z
return screen_y
end
end

#==============================================================================
# ** Scene_Battle
#==============================================================================

class Scene_Battle
#--------------------------------------------------------------------------
# * Action Animation, Movement
#--------------------------------------------------------------------------
alias cbs_update_phase4_step3 update_phase4_step3
def update_phase4_step3(battler = @active_battler)
@rtab = !@target_battlers
target = (@rtab ? battler.target : @target_battlers)[0]
@moved = {} unless @moved
return if @spriteset.battler(battler).moving
case battler.current_action.kind
when 0 # Attack
if not (@moved[battler] or battler.guarding?)
offset = (battler.is_a?(Game_Actor) ? 40 : -40)
@spriteset.battler(battler).setmove(target.screen_x + offset, target.screen_y)
@moved[battler] = true
return
elsif not battler.guarding?
@spriteset.battler(battler).pose = 6 + rand(2)
@spriteset.battler(battler).setmove(battler.screen_x, battler.screen_y)
end
when 1 # Skill
@spriteset.battler(battler).pose = 8
when 2 # Item
@spriteset.battler(battler).pose = 8
end
@moved[battler] = false
@rtab ? cbs_update_phase4_step3(battler) : cbs_update_phase4_step3
end
#--------------------------------------------------------------------------
# * Hit Animation
#--------------------------------------------------------------------------
alias cbs_update_phase4_step4 update_phase4_step4
def update_phase4_step4(battler = @active_battler)
for target in (@rtab ? battler.target : @target_battlers)
damage = (@rtab ? target.damage[battler] : target.damage)
if damage.is_a?(Numeric) and damage > 0
@spriteset.battler(target).pose = 1
end
end
@rtab ? cbs_update_phase4_step4(battler) : cbs_update_phase4_step4
end
#--------------------------------------------------------------------------
# * Victory Animation
#--------------------------------------------------------------------------
alias cbs_start_phase5 start_phase5
def start_phase5
for actor in $game_party.actors
return if @spriteset.battler(actor).moving
end
for actor in $game_party.actors
unless actor.dead?
@spriteset.battler(actor).pose = 9
@spriteset.battler(actor).freeze
end
end
cbs_start_phase5
end
#--------------------------------------------------------------------------
# * Change Arrow Viewport
#--------------------------------------------------------------------------
alias cbs_start_enemy_select start_enemy_select
def start_enemy_select
cbs_start_enemy_select
@enemy_arrow.dispose
@enemy_arrow = Arrow_Enemy.new(@spriteset.viewport2)
@enemy_arrow.help_window = @help_window
end
end

#==============================================================================
# ** Spriteset_Battle
#==============================================================================

class Spriteset_Battle
#--------------------------------------------------------------------------
# * Change Enemy Viewport
#--------------------------------------------------------------------------
alias cbs_initialize initialize
def initialize
cbs_initialize
@enemy_sprites = []
for enemy in $game_troop.enemies.reverse
@enemy_sprites.push(Sprite_Battler.new(@viewport2, enemy))
end
end
#--------------------------------------------------------------------------
# * Find Sprite From Battler Handle
#--------------------------------------------------------------------------
def battler(handle)
for sprite in @actor_sprites + @enemy_sprites
return sprite if sprite.battler == handle
end
end
end

#==============================================================================
# ** Arrow_Base
#==============================================================================

class Arrow_Base < Sprite
#--------------------------------------------------------------------------
# * Reposition Arrows
#--------------------------------------------------------------------------
alias cbs_initialize initialize
def initialize(viewport)
cbs_initialize(viewport)
self.ox = 14
self.oy = 10
end
end
[/spoiler]

Hp bars are nice too, here they are [spoiler]

Code Select Expand

# HP/SP/EXP?????????? Ver 1.00
# ????????URL
# http://members.jcom.home.ne.jp/cogwheel/

#==============================================================================
# ? Game_Actor
#------------------------------------------------------------------------------
# ???????????????????? Game_Actors ??? ($game_actors)
# ?????????Game_Party ??? ($game_party) ??????????
#==============================================================================

class Game_Actor < Game_Battler
def now_exp
return @exp - @exp_list[@level]
end
def next_exp
return @exp_list[@level+1] > 0 ? @exp_list[@level+1] - @exp_list[@level] : 0
end
end

#==============================================================================
# ? Window_Base
#------------------------------------------------------------------------------
# ??????????????????????????
#==============================================================================

class Window_Base < Window
#--------------------------------------------------------------------------
# ? HP ??????
#--------------------------------------------------------------------------
# ??????HP??? draw_actor_hp_hpsp ?????
alias :draw_actor_hp_hpsp :draw_actor_hp
def draw_actor_hp(actor, x, y, width = 144)
# ??rate? ???HP/MHP???
if actor.maxhp != 0
rate = actor.hp.to_f / actor.maxhp
else
rate = 0
end
# plus_x:X??????? rate_x:X???????(%) plus_y:Y???????
# plus_width:???? rate_width:????(%) height:??
# align1:?????1 0:??? 1:???? 2:???
# align2:?????2 0:??? 1:???? 2:???
# align3:?????? 0:??? 1:???
plus_x = 0
rate_x = 0
plus_y = 25
plus_width = 0
rate_width = 100
height = 10
align1 = 1
align2 = 2
align3 = 0
# ????????? grade1:???? grade2:????
# (0:????????? 1:????????? 2:??????????(??)?
grade1 = 1
grade2 = 0
# ????color1:???color2:??
# color3:???????????color4:??????????
# color5:???????????color6:??????????
color1 = Color.new(0, 0, 0, 192)
color2 = Color.new(255, 255, 192, 192)
color3 = Color.new(0, 0, 0, 192)
color4 = Color.new(64, 0, 0, 192)
color5 = Color.new(80 - 24 * rate, 80 * rate, 14 * rate, 192)
color6 = Color.new(240 - 72 * rate, 240 * rate, 62 * rate, 192)
# ??sp?????????????
if actor.maxhp != 0
hp = (width + plus_width) * actor.hp * rate_width / 100 / actor.maxhp
else
hp = 0
end
# ??????
gauge_rect(x + plus_x + width * rate_x / 100, y + plus_y,
width, plus_width + width * rate_width / 100,
height, hp, align1, align2, align3,
color1, color2, color3, color4, color5, color6, grade1, grade2)
# ??????HP?????????
draw_actor_hp_hpsp(actor, x, y, width)
end
#--------------------------------------------------------------------------
# ? SP ??????
#--------------------------------------------------------------------------
# ??????SP??? draw_actor_sp_hpsp ?????
alias :draw_actor_sp_hpsp :draw_actor_sp
def draw_actor_sp(actor, x, y, width = 144)
# ??rate? ???SP/MSP???
if actor.maxsp != 0
rate = actor.sp.to_f / actor.maxsp
else
rate = 1
end
# plus_x:X??????? rate_x:X???????(%) plus_y:Y???????
# plus_width:???? rate_width:????(%) height:??
# align1:?????1 0:??? 1:???? 2:???
# align2:?????2 0:??? 1:???? 2:???
# align3:?????? 0:??? 1:???
plus_x = 0
rate_x = 0
plus_y = 25
plus_width = 0
rate_width = 100
height = 10
align1 = 1
align2 = 2
align3 = 0
# ????????? grade1:???? grade2:????
# (0:????????? 1:????????? 2:??????????(??)?
grade1 = 1
grade2 = 0
# ????color1:???color2:??
# color3:???????????color4:??????????
# color5:???????????color6:??????????
color1 = Color.new(0, 0, 0, 192)
color2 = Color.new(255, 255, 192, 192)
color3 = Color.new(0, 0, 0, 192)
color4 = Color.new(0, 64, 0, 192)
color5 = Color.new(14 * rate, 80 - 24 * rate, 80 * rate, 192)
color6 = Color.new(62 * rate, 240 - 72 * rate, 240 * rate, 192)
# ??sp?????????????
if actor.maxsp != 0
sp = (width + plus_width) * actor.sp * rate_width / 100 / actor.maxsp
else
sp = (width + plus_width) * rate_width / 100
end
# ??????
gauge_rect(x + plus_x + width * rate_x / 100, y + plus_y,
width, plus_width + width * rate_width / 100,
height, sp, align1, align2, align3,
color1, color2, color3, color4, color5, color6, grade1, grade2)
# ??????SP?????????
draw_actor_sp_hpsp(actor, x, y, width)
end
#--------------------------------------------------------------------------
# ? EXP ??????
#--------------------------------------------------------------------------
# ??????EXP??? draw_actor_sp_hpsp ?????
alias :draw_actor_exp_hpsp :draw_actor_exp
def draw_actor_exp(actor, x, y, width = 204)
# ??rate? ???exp/nextexp???
if actor.next_exp != 0
rate = actor.now_exp.to_f / actor.next_exp
else
rate = 1
end
# plus_x:X??????? rate_x:X???????(%) plus_y:Y???????
# plus_width:???? rate_width:????(%) height:??
# align1:?????1 0:??? 1:???? 2:???
# align2:?????2 0:??? 1:???? 2:???
# align3:?????? 0:??? 1:???
plus_x = 0
rate_x = 0
plus_y = 25
plus_width = 0
rate_width = 100
height = 10
align1 = 1
align2 = 2
align3 = 0
# ????????? grade1:???? grade2:????
# (0:????????? 1:????????? 2:??????????(??)?
grade1 = 1
grade2 = 0
# ????color1:???color2:??
# color3:???????????color4:??????????
# color5:???????????color6:??????????
color1 = Color.new(0, 0, 0, 192)
color2 = Color.new(255, 255, 192, 192)
color3 = Color.new(0, 0, 0, 192)
color4 = Color.new(64, 0, 0, 192)
color5 = Color.new(80 * rate, 80 - 80 * rate ** 2, 80 - 80 * rate, 192)
color6 = Color.new(240 * rate, 240 - 240 * rate ** 2, 240 - 240 * rate, 192)
# ??exp?????????????
if actor.next_exp != 0
exp = (width + plus_width) * actor.now_exp * rate_width /
100 / actor.next_exp
else
exp = (width + plus_width) * rate_width / 100
end
# ??????
gauge_rect(x + plus_x + width * rate_x / 100, y + plus_y,
width, plus_width + width * rate_width / 100,
height, exp, align1, align2, align3,
color1, color2, color3, color4, color5, color6, grade1, grade2)
# ??????EXP?????????
draw_actor_exp_hpsp(actor, x, y)
end
#--------------------------------------------------------------------------
# ? ??????
#--------------------------------------------------------------------------
def gauge_rect(x, y, rect_width, width, height, gauge, align1, align2, align3,
color1, color2, color3, color4, color5, color6, grade1, grade2)
case align1
when 1
x += (rect_width - width) / 2
when 2
x += rect_width - width
end
case align2
when 1
y -= height / 2
when 2
y -= height
end
# ???
self.contents.fill_rect(x, y, width, height, color1)
self.contents.fill_rect(x + 1, y + 1, width - 2, height - 2, color2)
if align3 == 0
if grade1 == 2
grade1 = 3
end
if grade2 == 2
grade2 = 3
end
end
if (align3 == 1 and grade1 == 0) or grade1 > 0
color = color3
color3 = color4
color4 = color
end
if (align3 == 1 and grade2 == 0) or grade2 > 0
color = color5
color5 = color6
color6 = color
end
# ???????
self.contents.gradation_rect(x + 2, y + 2, width - 4, height - 4,
color3, color4, grade1)
if align3 == 1
x += width - gauge
end
# ???????
self.contents.gradation_rect(x + 2, y + 2, gauge - 4, height - 4,
color5, color6, grade2)
end
end

#------------------------------------------------------------------------------
# ?Bitmap????????????????
#==============================================================================

class Bitmap
#--------------------------------------------------------------------------
# ? ????????????
# color1 : ???????
# color2 : ??????
# align : 0:?????????
# 1:?????????
# 2:???????????????????
#--------------------------------------------------------------------------
def gradation_rect(x, y, width, height, color1, color2, align = 0)
if align == 0
for i in x...x + width
red = color1.red + (color2.red - color1.red) * (i - x) / (width - 1)
green = color1.green +
(color2.green - color1.green) * (i - x) / (width - 1)
blue = color1.blue +
(color2.blue - color1.blue) * (i - x) / (width - 1)
alpha = color1.alpha +
(color2.alpha - color1.alpha) * (i - x) / (width - 1)
color = Color.new(red, green, blue, alpha)
fill_rect(i, y, 1, height, color)
end
elsif align == 1
for i in y...y + height
red = color1.red +
(color2.red - color1.red) * (i - y) / (height - 1)
green = color1.green +
(color2.green - color1.green) * (i - y) / (height - 1)
blue = color1.blue +
(color2.blue - color1.blue) * (i - y) / (height - 1)
alpha = color1.alpha +
(color2.alpha - color1.alpha) * (i - y) / (height - 1)
color = Color.new(red, green, blue, alpha)
fill_rect(x, i, width, 1, color)
end
elsif align == 2
for i in x...x + width
for j in y...y + height
red = color1.red + (color2.red - color1.red) *
((i - x) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
green = color1.green + (color2.green - color1.green) *
((i - x) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
blue = color1.blue + (color2.blue - color1.blue) *
((i - x) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
alpha = color1.alpha + (color2.alpha - color1.alpha) *
((i - x) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
color = Color.new(red, green, blue, alpha)
set_pixel(i, j, color)
end
end
elsif align == 3
for i in x...x + width
for j in y...y + height
red = color1.red + (color2.red - color1.red) *
((x + width - i) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
green = color1.green + (color2.green - color1.green) *
((x + width - i) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
blue = color1.blue + (color2.blue - color1.blue) *
((x + width - i) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
alpha = color1.alpha + (color2.alpha - color1.alpha) *
((x + width - i) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
color = Color.new(red, green, blue, alpha)
set_pixel(i, j, color)
end
end
end
end
end


[/spoiler]

( If you don't know, just insert these scripts above main)

and your battlers (enemy and ally) will have to be set up like this