Oniromancie: Scripts - System Battle FFTA


Comment ça marche?

Aëdemphia
Par Sylvanor

Fighting Robots Quest
Par Boulon

Forstale
Par Ødd Clock

Geex
Par roys

Inexistence
Par Falco

La Légende d'Ibabou
Par Zaitan

Lije
Par Gaetz

LoveMaster
Par Cuddlefox

Sarcia
Par Kaëlar

Super Mario RPG - Lost Souls
Par Omegabowser

News: Concours des Alex d'Or 2017-18: (...) / News: MegaMaker : créez votre propre (...) / News: Test de Tinker Quarry / Sorties: Leave the Room / Jeux: Leave the Room /

Chat  (49 connectés)

Bienvenue
visiteur !






publicité RPG Maker!

Statistiques

Liste des
membres


Contact

71 connectés actuellement

9178703 visiteurs
depuis l'ouverture

1317 visiteurs
aujourd'hui

Groupe Facebook

Barre de séparation

Partenaires




TOP
GAMEMAKING


Les 5 plus
visités

Lunae, le baz'arts d'Emz0

Le studio du chat vert

Pixelandgame

Tashiroworld

HeyMakeGames

Au hasard

Univers RPG Maker XP

Guelnika - E Magination

Le Comptoir du Clikeur

Les deux derniers

Lunae, le baz'arts d'Emz0

Le studio du chat vert

Nos autres partenaires

Devenir
partenaire


Barre de séparation

Un site du réseau
War Paradise

Annuaires référenceurs





System Battle FFTA
Script pour RPG Maker XP
Ecrit par davfinal

Alors tout d'abord il vous faut rpg maker xp version anglaise car sinon il ne voudra pas enregistré les scripts ( ne vous inquiétés pas votre partie pourra être charger).Commencons :

Creez 18 events au-dessus de main que vous nommerez ( de bas en haut ) :

-TBS_Help-

=begin
--------------------------------------------
*** Version data ***
--------------------------------------------
Tactical Battle System - Beta Build 13.5 - Version 0.88
Made in the Netherlands, Pie Bunker #0000, by Nick
Important changes since last beta:
-Redid the -Module-TBS-, to prevent lag (if any)
-Rerouted the battle settings to Game_System instead Game_Temp, so it will be saved
-Various bug fixes
-A new map to test the AI

--------------------------------------------
*** Setup ***
--------------------------------------------
Setup is very, very easy. Just place events on the map.
For actors it is just PLSL as event name
And for enemies it is ENSL + number, the number is the enemy ID in the troop. So ENSL1 for enemy
one. To setup the ranges, open -Module_TBS- and see the instructions there.

--------------------------------------------
*** Information ***
--------------------------------------------
- Calling can't get any easier, just the normal event calling!
- Enemy character sets are the name of their battler sets. To edit that, open -Game_Enemy-
and change line 19 (return @battler_name) to whatever you want.
- The downsets are the character sets + _down, defaults are set.
- You can simulate the battle by setting the "simulate_actor" in the -Module_TBS to true.
- By setting cinematics on true, you turn off the highlighting and damage popups.
- For more options, see the -Module_TBS-

--------------------------------------------
*** Event script commands (call script)***
--------------------------------------------
- You can turn on cinematics using "cinematics(true)" and use "cinematics(false)" to turn them off.
- You can use "presetup(actor_id, x, y)" to setup a actor on your side.
- You can switch to deathmatch (survival of the fittest) by "deathmatch(true)",
to turn it off again, use "deathmatch(false)"
- You can let a battle autostart if you use "autostart(true)" and have actors preset.
Turn it off by "autostart(false)"
- You can set the maximum numbers of actors by "max(number)", this is 4 by default (party size)
This maximum number includes the ones preset. 0 means no limit.
- To allow replacing preplaced actors use "replaceable(true)", use "replaceable(false)" to turn it off.

--------------------------------------------
*** Victory and failure commands ***
--------------------------------------------
- Victory and failure commands are call script commands, and are "victory(condition, value)"
for victory and "failure(condition, value)" for failure.
- Victory and failure only show on start of battle, if the option showinfo is on.
- Victory is defeat all enemies by standard. Everything you mistype will be interpreted
as defeat all enemies. Standard value is ""
- For hold out, for an X number of turns, use "holdout" for the condition and a number as turn
- For kill boss, use "killboss" for the condition and enemy id (in the troop) as value
- For reach, use "reach" as condition and [x,y] as value.
- Failure is "" by default, with "" value by default. You always lose when your entire party
is dead.
- For time limit, use "time" as condition and use a number of turns as value
- For may not die thing, use "dies" as condition and use a global actor id as value.

--------------------------------------------
*** Disclaimer ***
--------------------------------------------
- You must give me credit, I worked on this very hard, so credit is the least thing :P
- You may use this to learn scripting yourself.
- You may edit this for your own game. Actually, I build it to be easy to edit.
- You may not use this in a commercial game without my permission.
- You may not steal this. (Don't ask me how)
- You may not post this script somewhere else than on Creation Asylum without my permission.
- You may request new features, I'll script GOOD ideas.
- You may create your own addons for this script and put them somewhere.
- The using of this script in your game is at your own risk.
- I am not your slave. You can't demand from me I add a function or make it work.
- I can edit this script at any time I want.
- I remain to have the sole rights on this script unless someone buys it.
- This script is still in beta phase, I need you to report the bugs.

--------------------------------------------
*** Thanks to ***
--------------------------------------------
- Prebetatesters: Anaxim, DarkSyDaZ, Drake, Diegoale2000, Galliano, GoldenShadow and others I forgot
- Near_Fantastica for letting me use his pathfinding.
- Everyone in the TBS topic for reporting errors.
- Enterbrain for actually making this game maker.
- The ruby group for developing this great language.
- My loyal fans.
=end





-Module_TBS-

# Here will be all default settings for the TBS.
module TBS
#--------------------------------------------------------------------------
def self.options(name)
# Just modify the values
case name
# Simulate actor?
when "sim_actor" ; opt = false
# Simulate enemy?
when "sim_enemy" ; opt = true
# Use downsets (set true if you want proper revives)
when "downsets" ; opt = true
# Disables highlighting and damage popups. For fully simulated battles.
when "cinematic" ; opt = false
# Use the terrain tags as height values?
when "height" ; opt = false
# Set to false to gain exp per hit
when "exp_kill" ; opt = true
# Set to true to use the standard text at battle start. False means victory/failure conditions.
when "show_info" ; opt = false
else ; opt = false
end
return opt
end
#--------------------------------------------------------------------------
# The weapon range, instructions inside.
def self.range(id)
# To add an weapon with more than 1 range to the list, use when [id] ; r = [range]
# Where [id] is the actual item id and [range] is the actual range in tiles.
case id
when 5 ; r = 4
when 17 ; r = 3
when 21 ; r = 3
else ; r = 1
end
return r
end
#--------------------------------------------------------------------------
# The enemy range
def self.enemy_range(id)
# To add an enemy with more than 1 range to the list, use when [id] ; r = [range]
case id
when 3 ; r = 2
else ; r = 1
end
return r
end
#--------------------------------------------------------------------------
# The skill range
def self.skill_range(id)
list = []
# To add an skill with more than 1 range to the list, use when [id] ; r = [range]
case id
when 1 ; r = 3
when 7 ; r = 5
when 33 ; r = 2
when 61 ; r = 4
when 73 ; r = 3
when 77 ; r = 3
else ; r = 1
end
return r
end
#--------------------------------------------------------------------------
# The teleporting skills
def self.skill_teleport(id)
list = []
# To add an teleportation skill, use when [id] ; r = (true or false)
case id
when 0 ; r = false
else ; r = false
end
return r
end
#--------------------------------------------------------------------------
# The skill splash damage
def self.skill_splash(id)
list = []
# To add an skill with more than 1 range to the list,, use when [id] ; r = [splash]
case id
when 1 ; r = 2
when 7 ; r = 2
else ; r = 1
end
return r
end
#--------------------------------------------------------------------------
# The item range
def self.item_range(id)
list = []
# To add an item with more than 1 range to the list, use when itemid ; r = range
# Where itemid is the actual item id and range is the actual range in tiles.
case id
when 0 ; r = 1
else ; r = 1
end
return r
end
#--------------------------------------------------------------------------
# The move range
def self.move_range(id)
list = []
# Use when class_id ; r = range here.
case id
when 0 ; r = 4
else ; r = 4
end
return r
end
#--------------------------------------------------------------------------
# The enemy move range
def self.enemy_move_range(id)
list = []
# Use when enemy_id ; r = range here.
case id
when 0 ; r = 4
else ; r = 4
end
return r
end
#--------------------------------------------------------------------------
# The general downset. Will be changed though. It refers to the downset used when
# A battler is down.
def self.downset(type = "enemy", graphic = "")
if FileTest.exist?("Graphics/Characters/#{graphic}_down.png")
return "#{graphic}_down"
else
if type == "enemy" ; return "192-Down04"
elsif type == "actor"
# This little code gets the downset from the prefix.
pre = graphic.split("-")[0].to_i
if pre >= 1 and pre <= 16 ; return "189-Down01"
elsif pre >= 17 and pre <= 32 ; return "190-Down02"
elsif pre >= 33 and pre <= 48 ; return "191-Down03"
else ; return "189-Down01"
end
end
end
end
#--------------------------------------------------------------------------
def self.down_x(id, type = "enemy")
# The X of the downset here. To add enemy, add below "enemy", else add below "else"
case type
when "enemy"
case id
when 0 ; r = 0
else ; r = 0
end
else
case id
when 2 ; r = 1
when 4 ; r = 2
when 5 ; r = 1
when 6 ; r = 2
when 8 ; r = 1
else ; r = 0
end
end
return r
end
#--------------------------------------------------------------------------
def self.down_y(id, type = "enemy")
list = []
# The Y of the downset here. To add enemy, add below "enemy", else add below "else"
case type
when "enemy"
case id
when 0 ; r = 0
else ; r = 0
end
else
case id
when 2 ; r = 2
when 3 ; r = 3
when 5 ; r = 1
when 6 ; r = 1
when 7 ; r = 3
when 8 ; r = 1
else ; r = 0
end
end
return r
end
end



-Scene_Battle-

class Scene_Battle
#--------------------------------------------------------------------------
# The battle start :)
def main
# All the data
main_data
# The temp stuff
main_temp
# The windows
main_windows
# The standard transition
if $data_system.battle_transition == "" ; Graphics.transition(20)
else ; Graphics.transition(40, "Graphics/Transitions/" + $data_system.battle_transition)
end
# Start phase, and make the update loop
start_phase1
# Main loop
loop do
# Update game screen
Graphics.update
# Update input information
Input.update
# Frame update
update
# Abort loop if screen is changed
break if $scene != self
end
# Dispose of sprite set
@spriteset.dispose
# Prepare for transition
Graphics.freeze
# Refresh map
$game_map.refresh
# Dispose of windows
for wnd in @wnds.values
wnd.dispose
end
# Center the player
$game_player.center($game_player.x, $game_player.y)
# If switching to title screen
if $scene.is_a?(Scene_Title)
# Fade out screen
Graphics.transition
Graphics.freeze
end
# If switching from battle test to any screen other than game over screen
$scene = nil if $BTEST and not $scene.is_a?(Scene_Gameover)
end
#--------------------------------------------------------------------------
# This initializes all data for the initialize class
def main_data
# Make the location arrays, filled with Coords classes
@wlocs = []
@plocs = []
@alocs = []
@elocs = []
@flocs = []
@cursor = Coords.new
# Init spriteset
@spriteset = Spriteset_Battle.new
# Set some random variables
@cursor_active = true
@wait_count = 0
end
#--------------------------------------------------------------------------
# This initializes all temp stuff for the battle
def main_temp
# The game_temp stuff is set here
$game_temp.in_battle = true
$game_temp.battle_turn = 0
$game_temp.battle_event_flags.clear
$game_temp.battle_abort = false
$game_temp.battle_main_phase = false
$game_temp.battleback_name = $game_map.battleback_name
$game_temp.forcing_battler = nil
$game_system.battle_interpreter.setup(nil, 0)
# The teams go here
$game_system.battleteams["actors"] = Game_Team.new("actors")
$game_system.battleteams["enemies"] = Game_Team.new("enemies")
tbs_actors.diplo("enemies", "enemy")
tbs_enemies.diplo("actors", "enemy")
@troop_id = $game_temp.battle_troop_id
$game_troop.setup(@troop_id)
end
#--------------------------------------------------------------------------
# This initializes all windows.
def main_windows
@wnds = {}
@wnds["actor"] = Window_Command.new(160, ["Move", "Action", "Wait", "Status"])
@wnds["actor"].index = -1
@wnds["actor"].active = false
@wnds["actor"].visible = false
@wnds["actor2"] = Window_Command.new(160, ["Attack", "Skill", "Item"])
@wnds["actor2"].x = 160
@wnds["actor2"].y = 32
@wnds["actor2"].active = false
@wnds["actor2"].visible = false
@wnds["help"] = Window_Help.new
@wnds["confirm"] = Window_Confirm.new("Start battle?")
@wnds["confirm"].active = false
@wnds["confirm"].visible = false
@wnds["confirm"].center
@wnds["message"] = Window_Message.new
@wnds["status"] = Window_BattleStatus.new(640 - 160,64,160,160)
@wnds["status"].visible = false
@wnds["help"].visible = false
for wnd in @wnds.values
wnd.back_opacity = 160
end
end
#--------------------------------------------------------------------------
def update
# If battle event is running
if $game_system.battle_interpreter.running?
# Update interpreter
$game_system.battle_interpreter.update
# If a battler which is forcing actions doesn't exist
if $game_temp.forcing_battler == nil
# If battle event has finished running
setup_battle_event unless judge or $game_system.battle_interpreter.running?
end
end
# Update the visual things
$game_system.update
$game_screen.update
$game_map.update
@spriteset.update
update_loccalc
@spriteset.cursor.visible = @cursor_active
# If transition is processing
if $game_temp.transition_processing
# Clear transition processing flag
$game_temp.transition_processing = false
# Execute transition
if $game_temp.transition_name == "" ; Graphics.transition(20)
else ; Graphics.transition(40, "Graphics/Transitions/" + $game_temp.transition_name)
end
end
return if update_abort
# Update the battlers
for team in teams.values
team.update
end
# If there is a wait, let it wait
if @wait_count != 0
@wait_count -= 1
if @after_wait and @wait_count == 0
commands = @after_wait.dup
@after_wait = nil
for command in commands
eval(command)
end
end
return
end
update_windows
# Battle timer stuff
$game_temp.battle_abort = true if $game_system.timer_working and $game_system.timer == 0
# And of course, update phase here
case @phase
when 1 ; update_phase1 # Setup
when 2 ; update_phase2 # Main
when 3 ; update_phase3 # End
end
update_cursor
end
#--------------------------------------------------------------------------
# Update location calculation
def update_loccalc
# Shortcut for calculating locations
if @calc_locs == "normal"
@calc_locs = nil
@wlocs, @alocs = @active_battler.locs
# Single attack calculation
elsif @calc_locs == "attack"
@calc_locs = nil
@wlocs, @alocs = @active_battler.locs(true)
# Single friendly calculation
elsif @calc_locs == "friendly"
@calc_locs = nil
@alocs, @flocs = @active_battler.locs(true)
# All enemies calculation
elsif @calc_locs == "enemies"
@calc_locs = nil
for battler in act_enemies
@alocs.push(Coords.new(battler.x, battler.y)) unless battler.dead?
end
# All allies calculation
elsif @calc_locs == "allies"
@calc_locs = nil
for battler in act_allies
@flocs.push(Coords.new(battler.x, battler.y)) unless battler.dead?
end
# All allies with 0 HP calculation
elsif @calc_locs == "allies0"
@calc_locs = nil
for battler in act_allies
@flocs.push(Coords.new(battler.x, battler.y)) if battler.dead?
end
# Self
elsif @calc_locs == "self"
@calc_locs = nil
@flocs.push(Coords.new(@active_battler.x, @active_battler.y))
# Clear all locs.
elsif @calc_locs == "clear"
@calc_locs = nil
@wlocs, @alocs, @flocs = [],[],[]
end
hlt_update
end
#--------------------------------------------------------------------------
# Update the abortion
def update_abort
# If game over
if $game_temp.gameover
# Switch to game over screen
$scene = Scene_Gameover.new
return true
end
# If returning to title screen
if $game_temp.to_title
# Switch to title screen
$scene = Scene_Title.new
return true
end
# If battle is aborted
if $game_temp.battle_abort
# Return to BGM used before battle started
$game_system.bgm_play($game_temp.map_bgm)
# Battle ends
battle_end(1)
return true
end
return false
end
#--------------------------------------------------------------------------
# Update windows
def update_windows
# Update the windows
for wnd in @wnds.values
wnd.update
end
# Relocate the windows.
w = $game_map.width / 2
h = $game_map.height / 2
if @phase == 1
x = @cursor.x
y = @cursor.y
if y < h
@wnds["help"].y = 416
@wnds["status"].y = 256
elsif y > h
@wnds["help"].y = 0
@wnds["status"].y = 64
end
@wnds["status"].visible = true
@wnds["help"].visible = true
elsif @phase == 2 and @wnds["actor"].active
x = @active_battler.x
y = @active_battler.y
if x > w
@wnds["actor"].x = 0
@wnds["actor2"].x = 160
@act_loc = "left"
elsif x < w
@wnds["actor"].x = 480
@wnds["actor2"].x = 320
@act_loc = "right"
end
if y < h
@wnds["actor"].y = 320
@wnds["actor2"].y = 352
@wnds["status"].y = 320
elsif y > h
@wnds["actor"].y = 0
@wnds["actor2"].y = 32
@wnds["status"].y = 0
end
@wnds["actor"].visible = true
end
if x
if x > w ; @wnds["status"].x = 0
elsif x < w ; @wnds["status"].x = 480
end
end
# If message window is showing
return if $game_temp.message_window_showing
# Delete result window
if @wnds["result"]
@wnds["result"].dispose
@wnds.delete("result")
end
end
#--------------------------------------------------------------------------
# Update cursor stuff
def update_cursor
if Input.repeat?(Input::RIGHT) and @cursor_active and @cursor.x != $game_map.width - 1
@cursor.x += 1
$game_system.se_play($data_system.cursor_se)
elsif Input.repeat?(Input::LEFT) and @cursor_active and @cursor.x != 0
@cursor.x -= 1
$game_system.se_play($data_system.cursor_se)
elsif Input.repeat?(Input::DOWN) and @cursor_active and @cursor.y != $game_map.height - 1
@cursor.y += 1
$game_system.se_play($data_system.cursor_se)
elsif Input.repeat?(Input::UP) and @cursor_active and @cursor.y != 0
@cursor.y -= 1
$game_system.se_play($data_system.cursor_se)
end
@spriteset.cursor.x = @cursor.x * 32
@spriteset.cursor.y = @cursor.y * 32
$game_player.center(@cursor.x, @cursor.y)
end
#--------------------------------------------------------------------------
# Start the setup phase
def start_phase1
#Search enemy locations
@ennumbers = Array.new
elocs = Array.new
for i in 0..$game_map.events.size
testing = $game_map.event_name(i)
unless $game_map.event_name(i) == nil
if testing.include?("ENSL")
testing = (testing.delete "ENSL").to_i
enw = Coords.new($game_map.events.x,$game_map.events.y)
elocs.push(enw)
@ennumbers.push(testing)
end
end
end
# Enemy setup
$game_troop.setup($game_temp.battle_troop_id)
for enemy in $game_troop.enemies
for index in 0..999
if enemy.index + 1 == @ennumbers[index]
tbs_enemies.add(enemy)
enemy.place(elocs[index].x, elocs[index].y)
@elocs.push(Coords.new(elocs[index].x, elocs[index].y))
@spriteset.battler_sprites.push(Sprite_Battler.new(@spriteset.viewport1, enemy))
end
break if $game_troop.enemies.size == tbs_enemies.battlers.size
end
end
$game_party.clear_actions
# If there are preset locations
if !$game_system.battle_locations.empty?
for location in $game_system.battle_locations
actor = $game_actors[location[0]]
loc = location[1]
if $game_map.passable?(loc.x, loc.y, 10) and actor
tbs_actors.add(actor)
actor.place(loc.x, loc.y)
actor.turn_to(tbs_enemies.battlers[0])
@spriteset.battler_sprites.push(Sprite_Battler.new(@spriteset.viewport1, actor, true))
end
end
end
# Set the help text here.
if TBS.options("show_info")
string = "Switch with A/S. Cancel to start or replace."
else
string = ""
if $game_system.victory_condition == "holdout"
string += "Hold out for #{$game_system.victory_val.to_s} turns."
elsif $game_system.victory_condition == "killboss"
string += "Kill #{$game_troop.enemies[$game_system.victory_val].name}."
elsif $game_system.victory_condition == "reach"
string += "Reach (#{$game_system.victory_val[0]}, #{$game_system.victory_val[1]}."
else
string += "Kill all enemies."
end
if $game_system.failure_condition == "time"
string += "Time limit: #{$game_system.failure_val.to_s} turns"
elsif $game_system.failure_condition == "dies"
string += "#{$game_actors[$game_system.failure_val.to_i].name} must survive"
end
end
@wnds["help"].set_text(string)
#Search events for possible locations
for i in 0..$game_map.events.size
name = $game_map.event_name(i)
if name == "PLSL"
what = Coords.new($game_map.events.x,$game_map.events.y)
@plocs.push(what)
end
end
#Now pick cursor starting location
if @plocs.empty? ; @cursor = Coords.new(0, 0)
else ; @cursor = Coords.new(@plocs[0].x, @plocs[0].y)
end
for enemy in tbs_enemies.battlers
enemy.turn_to(@cursor)
end
# Phase and selection
if $game_system.autostart and !tbs_actors.battlers.empty?
$game_system.se_play($data_system.decision_se)
@wnds["confirm"].active = false
@wnds["confirm"].visible = false
@wnds["status"].visible = false
@wnds["help"].y = 0
@cursor_active = true
start_phase2
else
@phase = 1
@select = 0
end
end
#--------------------------------------------------------------------------
# The setup update, where characters are placed and stuff
def update_phase1
# Update the status window
@wnds["status"].battler = $game_party.actors[@select] if @wnds["status"].battler != $game_party.actors[@select]
# If X (or, in game default A) is pressed, go back with chara selection
if Input.trigger?(Input::X)
@select -= 1
@select = $game_party.actors.size - 1 if @select < 0
# If Y (or, in game default S) is pressed, go forward with chara selection
elsif Input.trigger?(Input::Y)
@select += 1
@select = 0 if @select > $game_party.actors.size - 1
# If confirm is pressed, place character
elsif Input.trigger?(Input::C) and !@wnds["confirm"].active
succes = false
actor = $game_party.actors[@select]
if (tbs_actors.battlers.size + 1 <= $game_system.max or $game_system.max == 0 or tbs_actors.battlers.include?(actor)) and (!$game_system.battle_locations[actor.id] or $game_system.replaceable) and !actor.dead?
for i in @plocs
if i.x == @cursor.x and i.y == @cursor.y and taken?(i.x, i.y) == false
$game_system.se_play($data_system.decision_se)
actor.place(@cursor.x,@cursor.y)
actor.turn_to(tbs_enemies.battlers[0])
tbs_actors.add(actor)
@spriteset.battler_sprites.push(Sprite_Battler.new(@spriteset.viewport1, actor, true))
succes = true
break
end
end
end
$game_system.se_play($data_system.buzzer_se) if !succes
# If confirm is pressed, do action based on selection
elsif Input.trigger?(Input::C) and @wnds["confirm"].active
# If on "No" get back to placement
if @wnds["confirm"].index == 1
@wnds["confirm"].index = 0
@wnds["confirm"].active = false
@wnds["confirm"].visible = false
tbs_actors.battlers.clear
# If there are preset locations
if !$game_system.battle_locations.empty?
for location in $game_system.battle_locations
actor = $game_actors[location[0]]
loc = location[1]
if $game_map.passable?(loc.x, loc.y, 10) and actor
tbs_actors.add(actor)
actor.place(loc.x, loc.y)
actor.turn_to(tbs_enemies.battlers[0])
@spriteset.battler_sprites.push(Sprite_Battler.new(@spriteset.viewport1, actor, true))
end
end
end
# Remove sprites.
@spriteset.create_sprites
@cursor_active = true
$game_system.se_play($data_system.cancel_se)
else
# If on "Yes" start the actual battle
if tbs_actors.battlers.empty? ; $game_system.se_play($data_system.buzzer_se)
else
$game_system.se_play($data_system.decision_se)
@wnds["confirm"].active = false
@wnds["confirm"].visible = false
@wnds["status"].visible = false
@wnds["help"].y = 0
@cursor_active = true
start_phase2
end
end
# If cancel is pressed, pop up the confirm window
elsif Input.trigger?(Input::B) and !@wnds["confirm"].active
@wnds["confirm"].active = true
@wnds["confirm"].visible = true
@cursor_active = false
# Or return back to the map if it was popped up
elsif Input.trigger?(Input::B) and @wnds["confirm"].active
@wnds["confirm"].active = false
@wnds["confirm"].visible = false
@cursor_active = true
$game_system.se_play($data_system.cancel_se)
end
end
#--------------------------------------------------------------------------
# Start phase 2
def start_phase2
$game_system.battle_locations = {}
# Just the setup
@elocs = @plocs = []
@phase = 2
@battler_index = -1
@active_battler = nil
@wnds["help"].visible = false
next_battler
end
#--------------------------------------------------------------------------
# Update phase 2
def update_phase2
# Determine win/loss
return if judge
# If an action forcing battler doesn't exist
if $game_temp.forcing_battler == nil
# Set up battle event
setup_battle_event
# If battle event is running
return if $game_system.battle_interpreter.running?
end
# Check if the battler must be simulated
if @active_battler.sim ; update_AI
else
# Update command
if @wnds["actor"].active or @wnds["actor2"].active
@cursor_active = false if @cursor_active == true
update_actor_command
end
# Update the update thing
if @skip ; @skip = false
else
if @update != @oldup ; @oldup = @update
else
case @update
when "move" ; update_movement unless @active_battler.moving?
when "attack" ; update_attack
when "skill" ; update_skill
when "item" ; update_item
when "status" ; update_status
end
end
end
# Grid
if @active_battler.moving?
@wl_done = false
@calc_locs = "clear" unless @wlocs.empty? and @alocs.empty?
elsif @active_battler.moving? == false and @wl_done == false
@wl_done = true
@calc_locs = "clear" unless @wlocs.empty? and @alocs.empty?
end
end
end
#--------------------------------------------------------------------------
# Behold, the actual AI
def update_AI
# Focus on the active character
move_cursor(@active_battler.x, @active_battler.y)
# Create a targets array
targets = []
# Show the grid.
unless @calced
@calced = true
@active_battler.trange = 1
@calc_locs = "normal"
if !$game_system.battle_cinematic
wait(1)
return
end
end
# If no action list made yet
if !@gen_list
# Generate an actions list
@ranged = []
@melee = []
for action in @active_battler.action_list
ran = 0
# If its a default attack
if action.kind == 0
if action.basic == 0 ; ran = @active_battler.range
else ; next
end
# Or a skill
elsif action.kind == 1
if $data_skills[action.skill_id].scope == 1 ; ran = TBS.skill_range(action.skill_id)
elsif $data_skills[action.skill_id].scope == 2 ; ran = -1
else ; next
end
end
# Split the list to melee and ranged
res = [ran, action]
if ran == 1 ; @melee.push(res)
elsif ran != 1 ; @ranged.push(res)
end
end
@gen_list = true
end
# If absolutely no targets and not calculated
unless @active_battler.moved
# Calculate who
@friendly = act_allies
@enemies = act_enemies
# Calculate if there is any enemy in range.
@reachable = []
for t in @enemies
@reachable.push(t) if in_range?(t.x, t.y) and !t.dead?
end
# If there are none in range, move to nearest.
if @reachable.empty?
# Search for the closest target
closest = [Coords.new, 9999, 9999]
for i in @enemies
next if i.dead?
dist = [i, @active_battler.x - i.x, @active_battler.y - i.y]
xdis = dist[1].abs - closest[1].abs
ydis = dist[2].abs - closest[2].abs
closest = dist if xdis + ydis < 0
end
# Make the closest one the actual target
@target = closest[0]
# Long range AI calc
lowest = [Coords.new, 9999, 9999]
# Calculate the lowest distance from walkable locs.
for i in @wlocs
dist = [i, i.x - @target.x, i.y - @target.y]
xdis = dist[1].abs - lowest[1].abs
ydis = dist[2].abs - lowest[2].abs
# Decide the tactic to use. Just stumbled across this one.
if @active_battler.tactic == "blind rush" ; lowest = dist if xdis + ydis < 0
elsif @active_battler.tactic == "retreat" ; lowest = dist if xdis - ydis > 0
end
end
@ptarget = lowest[0]
tx = @ptarget.x
ty = @ptarget.y
# Just short range AI
else
# Search weakest and move to it.
weakest = [99999999999999999999999, nil]
for t in @reachable
weak = t.hp * t.pdef * t.mdef
weakest = [weak, t] if weak < weakest[0]
end
@target = weakest[1]
tx = @target.x
ty = @target.y
# Calculate the quickest way.
lowest = [Coords.new, 9999, 9999]
for i in @wlocs
dist = [i, i.x - @target.x, i.y - @target.y]
xdis = dist[1].abs - lowest[1].abs
ydis = dist[2].abs - lowest[2].abs
lowest = dist if xdis + ydis < 0
end
@ptarget = lowest[0]
tx = @ptarget.x
ty = @ptarget.y
end
if in_range?(tx,ty,"move")
# Set the calculated flag
@active_battler.moved = true
# Move out.
@active_battler.find_path(tx,ty)
@tx, @ty = tx, ty
end
@calc_locs = "clear"
end
# Return if still moving
return unless @tx == @active_battler.x and @ty == @active_battler.y and !@active_battler.moving?
# Only when calculated, not acted and not long range.
if !@active_battler.acted and @active_battler.moved
# If actual long range, check if attacks can be used.
if @reachable.empty? or @melee.empty?
dist = @active_battler.distance(@target.x, @target.y, true)
pos = []
all = []
for i in @ranged
if i[1].kind == 1 ; splash = TBS.skill_splash(i[1].skill_id)
else ; splash = 0
end
next if splash >= dist
all.push([splash,i[1]]) if i[0] < 0
pos.push([splash,i[1]]) if i[0] + splash >= dist and dist != 0
end
# If possible actions, generate one.
list = nil
if !pos.empty? ; list = pos
elsif pos.empty? and !all.empty? ; list = all
end
if list
ratings_total = 0
rating_max = 0
for a in list
act = a[1]
rating_max = act.rating if act.rating > rating_max
ratings_total += act.rating - (rating_max - 3) if act.rating > rating_max - 3
end
# If ratings total isn't 0
if ratings_total > 0
# Create random numbers
value = rand(ratings_total)
# Set things that correspond to created random numbers as current action
for a in list
act = a[1]
if act.rating > rating_max - 3
if value < act.rating - (rating_max - 3)
action = act
break
else ; value -= act.rating - (rating_max - 3)
end
end
end
end
end
# Short range, use melee attacks.
else
pos = @melee
# If possible actions, generate one.
if !pos.empty?
ratings_total = 0
rating_max = 0
for ac in pos
act = ac[1]
rating_max = act.rating if act.rating > rating_max
ratings_total += act.rating - (rating_max - 3) if act.rating > rating_max - 3
end
# If ratings total isn't 0
if ratings_total > 0
# Create random numbers
value = rand(ratings_total)
# Set things that correspond to created random numbers as current action
for ac in pos
act = ac[1]
if act.rating > rating_max - 3
if value < act.rating - (rating_max - 3)
action = act
break
else ; value -= act.rating - (rating_max - 3)
end
end
end
end
end
end
# If it can attack and has a target, attack
if action and @target and !@active_battler.acted
# Set the action
@active_battler.current_action.kind = action.kind
@active_battler.current_action.basic = action.basic
@active_battler.current_action.skill_id = action.skill_id
# Check if its a skill with splash damage
if action.kind == 1 ; splash = TBS.skill_splash(action.skill_id)
else ; splash = 0
end
# Check location closest to target
lowest = [Coords.new, 9999, 9999]
@active_battler.trange = nil
disc, alocs = @active_battler.locs(true)
# Calculate the lowest distance from walkable locs.
for i in alocs
dist = [i, i.x - @target.x, i.y - @target.y]
xdis = dist[1].abs - lowest[1].abs
ydis = dist[2].abs - lowest[2].abs
lowest = dist if xdis + ydis < 0
end
map, locs = lowest[0].locs(splash)
@target = []
# Get the targets
for loc in locs
taken = taken?(loc.x, loc.y)
@target.push(taken) if taken
end
# Turn to actor
@active_battler.turn_to(@target[0])
# Set the acting stuff true
@active_battler.acted = true
if action.kind == 0 and action.basic == 0
# First set the animations.
@anim1 = @active_battler.animation1_id
@anim2 = @active_battler.animation2_id
# The actual attack damage!
for t in @target
t.attack_effect(@active_battler)
end
elsif action.kind == 1
# Search the actual skill
@skill = $data_skills[action.skill_id]
# Set the animations
@anim1 = @skill.animation1_id
@anim2 = @skill.animation2_id
# Use up SP
@active_battler.sp -= @skill.sp_cost
# Calculate the effect.
for t in @target
t.skill_effect(@active_battler, @skill)
end
end
# Animate this thingie
anim_source
return
end
end
# Unset stuff
@gen_list = nil
@melee = nil
@ranged = nil
@target = nil
@calced = false
@long = false
@calc_locs = "clear" unless @wlocs.empty? and @alocs.empty?
@active_battler.trange = nil
@active_battler.acted = false
@active_battler.moved = false
# Go to next battler
next_battler
end
#--------------------------------------------------------------------------
# Select next battler, based on agility
def next_battler
# First, make a nice list
make_action_orders
if @battler_index >= @action_battlers.size - 1
@battler_index = 0
$game_temp.battle_turn += 1
else ; @battler_index += 1
end
@active_battler.blink = false if @active_battler
obattler = @active_battler
@active_battler = @action_battlers[@battler_index]
next_battler if !@active_battler or @active_battler.dead? or @active_battler == obattler
@active_battler.blink = true
# If can't move or can't act, set flag.
for stat in @active_battler.states
state = $data_states[stat]
if state.restriction == 4
@active_battler.acted = true
@wnds["actor"].disable_item(1)
end
if state.cant_evade
@active_battler.moved = true
@wnds["actor"].disable_item(0)
end
end
# Do stuff if it can be controlled
if !@active_battler.sim
@wnds["actor"].active = true
move_cursor(@active_battler.x, @active_battler.y)
@wnds["actor"].enable_item(0) unless @active_battler.moved
@wnds["actor"].enable_item(1) unless @active_battler.acted
@wnds["actor"].index = 0
# Slip damage (from states etc)
if @active_battler.hp > 0 and @active_battler.slip_damage?
@active_battler.slip_damage_effect
@active_battler.damage_pop = true
end
# Natural removal of states
@active_battler.remove_states_auto
next_battler if @active_battler.dead?
else
@wnds["actor"].active = false
@wnds["actor"].visible = false
@wnds["actor2"].active = false
@wnds["actor2"].visible = false
end
@cursor_active = false
end
#--------------------------------------------------------------------------
# Yes, update the actor command window. Shocking fact.
def update_actor_command
# If confirm window is pressed:
if Input.trigger?(Input::C)
# If the main window.
if @wnds["actor"].active
# Start movement
if @wnds["actor"].index == 0 and !@active_battler.moved
@calc_locs = "normal"
@wnds["actor"].active = false
@wnds["actor"].visible = false
@cursor_active = true
@update = "move"
@prev_x = @active_battler.x
@prev_y = @active_battler.y
$game_system.se_play($data_system.decision_se)
return
# Start actions
elsif @wnds["actor"].index == 1 and !@active_battler.acted
@wnds["actor"].active = false
@wnds["actor2"].active = true
@wnds["actor2"].visible = true
$game_system.se_play($data_system.decision_se)
return
# End actor's turn
elsif @wnds["actor"].index == 2
@update = ""
unless @active_battler.acted
@active_battler.current_action.kind = 0
@active_battler.current_action.basic = 3
end
@active_battler.acted = false
@active_battler.moved = false
next_battler
$game_system.se_play($data_system.decision_se)
return
# Status window
elsif @wnds["actor"].index == 3
@select = @battler_index
#@ocursor = @cursor.clone
@wnds["actor"].active = false
@wnds["actor"].visible = false
@wnds["status"].battler = @active_battler
@wnds["status"].visible = true
@update = "status"
$game_system.se_play($data_system.decision_se)
return
else
$game_system.se_play($data_system.buzzer_se)
return
end
elsif @wnds["actor2"].active
# Start attacking
if @wnds["actor2"].index == 0 and !@active_battler.acted
@calc_locs = "attack"
@wnds["actor"].visible = false
@wnds["actor2"].active = false
@wnds["actor2"].visible = false
@cursor_active = true
@update = "attack"
@prev_ax = @active_battler.x
@prev_ay = @active_battler.y
$game_system.se_play($data_system.decision_se)
return
# Skills go here
elsif @wnds["actor2"].index == 1 and !@active_battler.acted
@wnds["skill"] = Window_Skill.new(@active_battler)
@wnds["skill"].help_window = @wnds["help"]
@wnds["actor"].visible = false
@wnds["actor2"].active = false
@wnds["actor2"].visible = false
@update = "skill"
$game_system.se_play($data_system.decision_se)
return
# Items go here
elsif @wnds["actor2"].index == 2 and !@active_battler.acted
@wnds["item"] = Window_Item.new
@wnds["item"].help_window = @wnds["help"]
@wnds["actor"].visible = false
@wnds["actor2"].active = false
@wnds["actor2"].visible = false
@update = "item"
$game_system.se_play($data_system.decision_se)
return
else
$game_system.se_play($data_system.buzzer_se)
return
end
end
# Some window switching here
elsif Input.trigger?(Input::RIGHT) ; flag = "right"
elsif Input.trigger?(Input::LEFT) ; flag = "left"
end
if @act_loc == "right"
if flag == "right" ; flag = "left"
elsif flag == "left" ; flag = "right"
end
end
if flag == "right" and @wnds["actor"].active and @wnds["actor"].index == 1
@wnds["actor"].active = false
@wnds["actor2"].active = true
@wnds["actor2"].visible = true
$game_system.se_play($data_system.decision_se)
elsif (Input.trigger?(Input::B) or flag == "left") and @wnds["actor2"].active
@wnds["actor"].active = true
@wnds["actor2"].active = false
@wnds["actor2"].visible = false
@wnds["actor2"].index = 0
$game_system.se_play($data_system.cancel_se)
@skip = true
end
end
#--------------------------------------------------------------------------
# Hard to guess, it updates movement
def update_movement
# When confirm button is pressed, move to that location unless it simply cant
if Input.trigger?(Input::C)
unless @active_battler.x == @cursor.x and @active_battler.y == @cursor.y
result = false
for i in @wlocs
result = true if i.x == @cursor.x and i.y == @cursor.y
end
unless result
$game_system.se_play($data_system.buzzer_se)
return
else
hlt_update
@active_battler.find_path(@cursor.x, @cursor.y) unless taken?(@cursor.x, @cursor.y)
@active_battler.moved = true
@wnds["actor"].disable_item(0)
@wnds["actor"].index = 1
@wnds["actor"].active = true
@wnds["actor"].visible = true
@cursor_active = false
$game_system.se_play($data_system.decision_se)
end
end
# When cancel is pressed and the active battler has moved, cancel movement
elsif Input.trigger?(Input::B) and @active_battler.moved and !@active_battler.acted and @wnds["actor"].active
@active_battler.place(@prev_x,@prev_y)
@calc_locs = "normal"
move_cursor(@prev_x, @prev_y)
@wnds["actor"].enable_item(0)
@active_battler.moved = false
@wnds["actor"].active = false
@wnds["actor"].visible = false
@wnds["actor"].index = 0
@cursor_active = true
@wl_done = false
$game_system.se_play($data_system.cancel_se)
# When cancel is pressed and the active battler hasn't moved, go back to actor command window
elsif Input.trigger?(Input::B) and !@active_battler.moved
@calc_locs = "clear"
move_cursor(@prev_x, @prev_y)
@wnds["actor"].active = true
@wnds["actor"].visible = true
@cursor_active = false
$game_system.se_play($data_system.cancel_se)
end
end
#--------------------------------------------------------------------------
# Update attack
def update_attack
return if @update != "attack" or @wnds["actor"].active or @wnds["actor2"].active
@target = taken?(@cursor.x, @cursor.y)
if @target and in_range?(@cursor.x, @cursor.y)
@wnds["status"].battler = @target
@wnds["status"].visible = true
else ; @wnds["status"].visible = false
end
# When confirm is pressed, attack
if Input.trigger?(Input::C)
if @cursor.x == @active_battler.x and @cursor.y == @active_battler.y
$game_system.se_play($data_system.buzzer_se)
return
end
# Only when in range
if !in_range?(@cursor.x, @cursor.y)
$game_system.se_play($data_system.buzzer_se)
return
end
# Get target and stuff.
if act_enemies.include?(@target) ; flag = true
else ; flag = false
end
if !@target
$game_system.se_play($data_system.buzzer_se)
return
end
if flag and !@target.dead?
# Face the target
@active_battler.turn_to(@target)
# Clear locations
@calc_locs = "clear"
# First set the animations.
@anim1 = @active_battler.animation1_id
@anim2 = @active_battler.animation2_id
# The actual attack damage!
@target.attack_effect(@active_battler)
# Set the action
@active_battler.current_action.kind = 0
@active_battler.current_action.basic = 0
# And set the actor stuff
move_cursor(@prev_ax, @prev_ay)
$game_system.se_play($data_system.decision_se)
@cursor_active = false
# Animate this thingie
anim_source
return
elsif @target.dead?
# Face the target
@active_battler.turn_to(@target)
# Knockback here
case @active_battler.direction
when 2 # down
kbdir = "down"
x, y = @target.x, @target.y + 1
when 4 # left
kbdir = "left"
x, y = @target.x - 1, @target.y
when 6 # right
kbdir = "right"
x, y = @target.x + 1, @target.y
when 8 # up
kbdir = "up"
x, y = @target.x, @target.y - 1
end
if @target.passable?(x, y)
# Clear locations
@calc_locs = "clear"
# First set the animations.
@anim1 = @active_battler.animation1_id
@anim2 = @active_battler.animation1_id
# Knockback
@target.walk_anime = false
@target.direction_fix = true
eval("@target.move_#{kbdir}")
# Set the action
@active_battler.current_action.kind = 0
@active_battler.current_action.basic = 0
# And set the actor stuff
move_cursor(@prev_ax, @prev_ay)
$game_system.se_play($data_system.decision_se)
@cursor_active = false
# Animate this thingie
anim_source
return
else ; $game_system.se_play($data_system.buzzer_se)
end
else
return if @cursor.x == @active_battler.x and @cursor.y == @active_battler.y
$game_system.se_play($data_system.buzzer_se)
end
# When cancel is pressed, go back to actor command window
elsif Input.trigger?(Input::B)
move_cursor(@prev_ax, @prev_ay)
@calc_locs = "clear"
@cursor_active = false
@wnds["actor2"].active = true
@wnds["actor2"].visible = true
@wnds["actor"].visible = true
@wnds["status"].visible = false
if @active_battler.moved ; @update = "move"
else ; @update = ""
end
$game_system.se_play($data_system.cancel_se)
end
end
#--------------------------------------------------------------------------
# Update skill
def update_skill
# If it needs to use the skill.
if @use
# Reset the cursor.
@spriteset.create_cursor
# Face the target
@active_battler.turn_to(@target[0])
# Clear the highlighting
@calc_locs = "clear"
# Check if it can be used.
unless @active_battler.skill_can_use?(@skill.id)
@wnds["skill"].visible = true
@wnds["skill"].active = true
@wnds["help"].visible = true
return
end
# Use up SP
@active_battler.sp -= @skill.sp_cost
# Display item name on help window
@wnds["help"].set_text(@skill.name, 1)
# First set the animations.
@anim1 = @skill.animation1_id
@anim2 = @skill.animation2_id
# Apply skill effect
for t in @target
if (@wnds["skill"].skill.scope == 5 or @wnds["skill"].skill.scope == 6) and t.dead? ; t.skill_effect(@active_battler, @skill)
elsif (@wnds["skill"].skill.scope != 5 or @wnds["skill"].skill.scope != 6) and !t.dead? ; t.skill_effect(@active_battler, @skill)
end
end
# Reset the flag.
@use = false
# Start Animation
anim_source
end
# If the confirm button is pressed
if Input.trigger?(Input::C)
# If the item window is active
if @wnds["skill"].active
# Use the actual item
@skill = $data_skills[@wnds["skill"].skill.id]
if @active_battler.skill_can_use?(@skill.id)
# Hide the window
@wnds["skill"].active = false
@wnds["skill"].visible = false
# Teleporting goes here
if TBS.skill_teleport(@skill.id)
@teleporting = true
@cursor_active = true
return
end
@target = []
# It needs to switch to the target selection here.
case @wnds["skill"].skill.scope
when 1 # single enemy
@spriteset.create_cursor(TBS.skill_splash(@skill.id))
@calc_locs = "attack"
@cursor_active = true
when 2 # all enemies
@calc_locs = "enemies"
for battler in act_enemies
@target.push(battler) if battler.exist?
end
when 3 # single ally
@calc_locs = "friendly"
@cursor_active = true
when 4 # all allies
@calc_locs = "allies"
for battler in act_allies
@target.push(battler) if battler.exist?
end
when 5 # single ally (HP 0)
@calc_locs = "friendly"
@cursor_active = true
when 6 # all allies (HP 0)
@calc_locs = "allies0"
for battler in act_allies
@target.push(battler) if battler.dead? and battler.exist?
end
when 7 # user
@calc_locs = "self"
@target.push(@active_battler)
end
@active_battler.current_action.skill_id = @wnds["skill"].skill.id
$game_system.se_play($data_system.decision_se)
else
$game_system.se_play($data_system.buzzer_se)
end
# If teleporting
elsif @teleporting
# If can be teleported to.
if @active_battler.passable?(@cursor.x, @cursor.y)
# Use up SP
@active_battler.sp -= @skill.sp_cost
# Play sound
$game_system.se_play($data_system.decision_se)
# Move
@active_battler.moveto(@cursor.x, @cursor.y)
# Flag and deflag
@teleporting = false
# First set the animations.
@anim1 = @skill.animation1_id
@anim2 = @skill.animation2_id
@target = []
# Then animate
anim_source
else ; $game_system.se_play($data_system.buzzer_se)
end
else
# If target array is not empty, set the flag.
if !@target.empty?
@use = true
$game_system.se_play($data_system.decision_se)
# Else, select.
else
# If actually in range.
if !in_range?(@cursor.x, @cursor.y)
$game_system.se_play($data_system.buzzer_se)
return
end
if @spriteset.cursor_range != 0
map, locs = @cursor.locs(@spriteset.cursor_range)
targ = []
flag = false
flag2 = false
for loc in locs
t = taken?(loc.x, loc.y)
next unless t
if @wnds["skill"].skill.scope == 1 ; flag = true if act_enemies.include?(t)
elsif @wnds["skill"].skill.scope == 3 or @wnds["skill"].skill.scope == 5 ; flag = true if act_allies.include?(t)
end
if flag
if (@wnds["skill"].skill.scope == 1 or @wnds["skill"].skill.scope == 3) and !t.dead?
flag2 = true
tf = true
elsif @wnds["skill"].skill.scope == 5 and t.dead?
flag2 = true
tf = true
else ; tf = false
end
end
targ.push(t) if tf
end
else
# Get a target.
targ = taken?(@cursor.x, @cursor.y)
# When its an enemy item
if @wnds["skill"].skill.scope == 1 ; flag = act_enemies.include?(targ)
# When its an ally item
elsif @wnds["skill"].skill.scope == 3 or @wnds["skill"].skill.scope == 5 ; flag = act_allies.include?(targ)
end
# Set the second flag.
flag2 = false
if flag
if @wnds["skill"].skill.scope == 1 or @wnds["skill"].skill.scope == 3 ; flag2 = (!targ.dead?)
elsif @wnds["skill"].skill.scope == 5 ; flag2 = (targ.dead?)
end
end
end
# If the flag is true and the target is not dead.
if flag and flag2
# Clear the highlighting
@calc_locs = "clear"
# Create the array.
if targ.is_a? Array ; @target = targ
else ; @target


letrsheur - posté le 12/08/2008 à 15:29:01. (11 messages postés)

Comment on fait pout réglé les hp d'un adversair


MagicTux - posté le 15/08/2008 à 19:31:11. (12 messages postés)

Ok, je viens de le télécharger, je vais essayer d'y ajouter quelques modifications.


Quelqu'un a déja réussi a le personnaliser ?

We could be together... walking on... walking on the moon.


lolmaxz - posté le 20/08/2008 à 06:54:05. (17 messages postés)

la vie est comme un fil... Tu coupe le fil, et tu meur !

peut tu fournir une démo???


Willy (visiteur non enregistré) - posté le 09/09/2008 à 03:09:53.

Woot!! J'ai modifier un peu ton démo et c'est super!!!
J'arrive même pas à savoir comment tu fais c'est genre d'affaires.
Peu importe! Tes Super!! Et sa marche en plus!

Merci...<3


natinusala (visiteur non enregistré) - posté le 22/11/2008 à 20:14:19.

ouaih c'est super je vais essayer de modifier le "actor turn" et le "enemy turn" :D autrement c'est vraiment génial !!!!!!!! :)


pele - posté le 28/02/2009 à 17:30:13. (53 messages postés)

Kalki

ce serait génial si on pouvait créer des Pnj qui se battent contre les
ennemis sans que vous les guidiez,au quel vous pourriez parler
pour qu' ils viennent dans l'équipe.

Apprendre le ruby RGSS1/2? http://Chalcie.overblog.com


look - posté le 04/06/2009 à 21:46:48. (2 messages postés)

C'est exactement comme fire emblem jutilise se script depui un baille si vs avez des question allez y


Zeddicuss - posté le 27/09/2009 à 16:41:41. (300 messages postés)

La mort c'est l'arret du coeur... L'amour c'est la raie du cul.

Citation:

Voila un screen: image.
Et puis la traduction est là !!
http://www.rpgcreative.net/Site/RPG%20Maker/image%20tutorial/scripts/TBS%20Fr.zip
Merci RPG Creative



Le lien est mort...:hum Il n'y a pas de démo SVP ?:'(:'(

Mon nouveau site !


Ebrayana - posté le 23/06/2010 à 11:47:27. (323 messages postés)

Mais enfaite je comprend que dal :help( en meme temp chuis débutante moi ) quelqu'un pourais m'expliqué !!!


Yoshiki - posté le 16/07/2010 à 11:41:10. (1 messages postés)

Bonjour à tous :), j'aimerais vous demander quelque chose car j'aurais besoin d'aide pour le script ^^. J'ai copier coller le script System Battle FFTA dans mon RPG Maker XP.Pour l'instant aucun problème. Ensuite je créer la map avec [T] à la fin, je place les héros actor1 actor2 et les ennemis enemy1 enemy2 etc...
Ensuite, quand j'envoie le jeu et que le combat commence il n'y a aucun problème.
Et c'est ici que le problème arrive, quand je termine le combat, il y a écrit "Game Over" et la partie se termine...:'(
J'aimerais juste savoir si il faut changer quelque chose dans les script ou autre chose.
Merci d'avance:banane


Naegeru - posté le 07/01/2012 à 18:21:05. (12 messages postés)

C'est cool le TBS je trouve. Ce script est très utile pour mon jeu!!!!

Suite à de nombreux abus, le post en invités a été désactivé. Veuillez vous inscrire si vous souhaitez participer à la conversation.

Haut de page

Merci de ne pas reproduire le contenu de ce site sans autorisation.
Contacter l'équipe

Plan du site:

Activité: Accueil | News | Forum | Flash-news | Chat | Commentaires | Galerie | Screen de la semaine | Sorties | Articles perso | Livre d'or | Recherche
Jeux: Index jeux séparés | Top Classiques | Top Originaux | Les autres | RPG Maker 95 | RPG Maker 2000 | RPG Maker 2003 | RPG Maker XP | RPG Maker VX | RPG Maker VX Ace | RPG Maker MV | Autres | Jeux complets | Proposer
Rubriques: Le Wiki | Collection Oniro | Tutoriaux | Scripts | Guides | Gaming-Live | Tests | Making-of | Interviews | Articles perso | OST | L'Annuaire | Divers | Palmarès
Hébergés: Aëdemphia | Fighting Robots Quest | Forstale | Geex | Inexistence | La Légende d'Ibabou | Lije | LoveMaster | Sarcia | Super Mario RPG - Lost Souls
Ressources: Jeux | Programmes | Packs de ressources | Midis | Eléments séparés | Sprites
RPG Maker 2000/2003: Chipsets | Charsets | Panoramas | Backdrops | Facesets | Battle anims | Battle charsets | Monstres | Systems | Templates
RPG Maker XP: Tilesets | Autotiles | Characters | Battlers | Window skins | Icônes | Transitions | Fogs | Templates
RPG Maker VX: Tilesets | Charsets | Facesets | Systèmes
RPG Maker MV: Tilesets | Characters | Faces | Systèmes | Title | Battlebacks | Animations | SV/Ennemis