Déplacement en 1/4 de case + 8 directions

• Script de Pipo.
• Aucune démo n'est disponible pour ce script.

Je suppose que vous connaissez tous le fameux scripts de déplacement en 1/4 de case qui tient en 10 lignes, bourré de bug, ne gérant pas les collisions avec les objets, avec les évènements, etc, etc...

J'ai donc créé une nouvelle version, gérant les collisions avec les objets et les évènements ainsi que les intéractions, et permettant le déplacement diagonal, également en quart de case.

Du coup, le script est beaucoup plus long, certes, mais il marche ;)

###################################################################
# Déplacement en 1/4 de case amélioré + mouvement en 8 directions.
# Ce script permet un déplacement libre, sans les contraintes habituelles
# des cases de la grille. Le déplacement diagonal est géré dans le script.
# Gère les collisions ainsi que les contacts avec les évènements.
# Pour faciliter la création d'une cinématique, par exemple, ce script peut être désactivé
# par un interrupteur. Le réalignement sur la grille est alors automatique.
#
#Sur ce, bon making!
###################################################################

class Game_Player < Game_Character

def update #on redéfinit l'update
if $game_switches[10] == true #remplacez 10 par le n° de l'interrupteur désactivant ce script.
@case_par_case = true
else
@case_par_case = false
end
# ?????????????????
last_moving = moving?
# ?????????????????????
# ???????????????????????
unless moving? or $game_system.map_interpreter.running? or
@move_route_forcing or $game_temp.message_window_showing
# ???????????????????????????
case Input.dir8 #j'ai juste modifié cette partie et les when x pour permettre les 8 directions
when 1
move_lower_left
when 2
move_down
when 3
move_lower_right
when 4
move_left
when 6
move_right
when 7
move_upper_left
when 8
move_up
when 9
move_upper_right
end
end
# ????????????
last_real_x = @real_x
last_real_y = @real_y
super
# ??????????????????????????????
if @real_y > last_real_y and @real_y - $game_map.display_y > CENTER_Y
# ???????????
$game_map.scroll_down(@real_y - last_real_y)
end
# ??????????????????????????????
if @real_x < last_real_x and @real_x - $game_map.display_x < CENTER_X
# ???????????
$game_map.scroll_left(last_real_x - @real_x)
end
# ??????????????????????????????
if @real_x > last_real_x and @real_x - $game_map.display_x > CENTER_X
# ???????????
$game_map.scroll_right(@real_x - last_real_x)
end
# ??????????????????????????????
if @real_y < last_real_y and @real_y - $game_map.display_y < CENTER_Y
# ???????????
$game_map.scroll_up(last_real_y - @real_y)
end
# ?????????
unless moving?
# ????????????????
if last_moving
# ???????????????????????
result = check_event_trigger_here([1,2])
# ?????????????
if result == false
# ???????? ON ?? CTRL ??????????????
unless $DEBUG and Input.press?(Input::CTRL)
# ?????? ???????
if @encounter_count > 0
@encounter_count -= 1
end
end
end
end
# C ??????????
if Input.trigger?(Input::C)
# ?????????????????
check_event_trigger_here([0])
check_event_trigger_there([0,1,2])
end
end
end
#--------------------------------------------------------------------------
# Redéfinition du déplacement vers le bas.
#--------------------------------------------------------------------------
def move_down(turn_enabled = true)#la partie entre parenthèse signifie que la rotation est
#activée par défaut.

if turn_enabled# si le héros n'est pas en direction fixe.
turn_down#il regarde en bas.
end#fin du if.

if @case_par_case == true #si l'interrupteur case par case est activé.
@x = @x.to_i #réalignement en x sur la case si ce n'est pas déjà fait.
@y = @y.to_i #réalignement en y sur la case si ce n'est pas déjà fait.
if passable?(@x, @y, 2) #définition normale, tirée du script originale.
# ????
# ?????
@y += 1 #un pas vers le bas. En effet, l'origine se trouve en haut à gauche!
# ????
increase_steps
# ????????
else
# ???????????
check_event_trigger_touch(@x, @y+1)
end #fin de la définition normale

else #sinon, si désactivé, on utilise la définition 1/4 de case.

# Pour savoir si le mouvement est possible, deux tests sont utilisés, avec un "centrage" différent
# pour englober toute la largeur de la case. Il en sera de même pour toutes les directions:
if passable?((@x+0.75).to_i, @y.to_i, 2) and passable?(@x.to_i, @y.to_i, 2)#Si le mouvement est possible.
@stop = true
@y += 0.25 # Pas en bas, 1/4 d'un pas normal
increase_steps # Augmentation des étapes du charset.
else #Si le déplacement n'est pas possible (= cogne sur un mur/sur un événement).
@y = @y.to_i #sécurité: au cas où il y aurait un bug, le héros se réalignera
#sur le centre de la case, et ne sera pas bloqué..
check_event_trigger_touch((@x+0.5).to_i, @y+1) #vérifie s'il y a un événement de contact à déclencher.
end
end
end#fin de la définition
#--------------------------------------------------------------------------
# Redéfinition du déplacement vers la gauche.
#--------------------------------------------------------------------------
#C'est exactement la même chose que pour le déplacement vers le bas.
#Pour plus de clarté, ce passage ne sera pas commenté. Essayez de comprendre chaque
#partie du script, et, le cas échéant, vous pouvez vous référer aux commentaires
#du déplacement vers le bas.
def move_left(turn_enabled = true)
if turn_enabled
turn_left
end

if @case_par_case == true
@x = @x.to_i
@y = @y.to_i

if passable?(@x, @y, 4)
@stop = true
@x -= 1

increase_steps

else

check_event_trigger_touch(@x-1, @y)
end

else

if passable?((@x+0.75).to_i, (@y+0.75).to_i, 4) and passable?(@x.to_i, @y.to_i, 4)
@stop = true
@x -= 0.25

increase_steps
else
@x = @x.to_i
check_event_trigger_touch(@x-1, (@y+0.5).to_i)
end
end
end#fin de définition
#--------------------------------------------------------------------------
# Redéfinition du déplacement vers la droite.
#--------------------------------------------------------------------------
def move_right(turn_enabled = true)

if turn_enabled
turn_right
end

if @case_par_case == true
@x = @x.to_i
@y = @y.to_i
if passable?(@x, @y, 6)
@x += 1
increase_steps
else
# ???????????
check_event_trigger_touch(@x+1, @y)
end

else

if passable?(@x.to_i, (@y+0.75).to_i, 6) and passable?(@x.to_i, @y.to_i, 6)
@stop = true
@x += 0.25

increase_steps
else
@x = @x.to_i
check_event_trigger_touch(@x+1, (@y+0.5).to_i)
end
end
end
#--------------------------------------------------------------------------
# Redéfinition du déplacement vers le haut.
#--------------------------------------------------------------------------
def move_up(turn_enabled = true)
# mouvement haut
if turn_enabled
turn_up
end
if @case_par_case == true #si le maker souhaite que le héros se déplace case par case.
#Remplacer 10 par le numéro de l'interrupteur
@x = @x.to_i #réalignement sur la case si ce n'est pas déjà fait
@y = @y.to_i #idem
if passable?(@x, @y, 8)
# ????
# ?????
@y -= 1
# ????
increase_steps
# ????????
else
# ???????????
check_event_trigger_touch(@x, @y-1)
end
else #sinon, si désactivé, on repasse en mode 1/4 de case.
# mouvement possible ?
if passable?((@x+0.75).to_i, (@y+0.75).to_i, 8) and passable?(@x.to_i, (@y+0.75).to_i, 8)
@stop = true
@y -= 0.25# pas en haut
increase_steps# augmenter les étapes du pas
else
@y = @y.to_i
check_event_trigger_touch((@x+0.5).to_i, @y-1)
end
end
end
#--------------------------------------------------------------------------
#Redéfinition du mouvement en bas à droite.
#--------------------------------------------------------------------------
def move_lower_right

unless @direction_fix #si la direction n'est pas fixe,
@direction = (@direction == 4 ? 6 : @direction == 8 ? 2 : @direction)
#si le héros regarde en bas ou à droite, rien ne se passe. Sinon, il se tourne
end

if @case_par_case == true # si case par case, on remet la définition normale
if (passable?(@x, @y, 2) and passable?(@x, @y + 1, 6)) or
(passable?(@x, @y, 6) and passable?(@x + 1, @y, 2))

@x += 1#ici, il faut modifier les deux coordonnées!
@y += 1
# ????
increase_steps
end
else #sinon, défintion de déplacement quart de case
#attention passage compliqué...
if (passable?((@x+0.75).to_i, @y.to_i, 2) and passable?(@x.to_i, @y.to_i, 2) and
#si il peut aller en bas et...
passable?(@x.to_i, (@y+1).to_i, 6) and passable?(@x.to_i, (@y+0.25).to_i, 6)) or
#s'étant déplacé en bas (y+0.25), il peut aussi aller à droite, c'est bon. Ou bien, si...
(passable?(@x.to_i, (@y+0.75).to_i, 6) and passable?(@x.to_i, @y.to_i, 6) and
#si il peut aller à droite et...
passable?((@x+1).to_i, @y.to_i, 2) and passable?((@x+0.25).to_i, @y.to_i, 2))
#s'étant déplacé à droite (y+0.25), il peut aussi aller en bas, c'est bon.
#En fait, @x+1 = @x+0.75(formule de base)+0.25(déplacement antérieur).
@x += 0.25#si c'est bon, on se déplace.
@y += 0.25
increase_steps
else #si le déplacement diagonal est impossible.
@stop = false#on réinitialise l'interrupteur stop
move_right#on essaie de se déplacer à droite. Si ça marche, stop est activé.
if @stop == false#s'il n'est pas activé, on essaie alors d'aller en bas.
move_down
end
end
end
end #fin de définition
#--------------------------------------------------------------------------
# Mouvement en bas à gauche !!!!!!!!!!!!!!
#--------------------------------------------------------------------------
def move_lower_left
# ?????????
unless @direction_fix
# ?????????????????????????
@direction = (@direction == 6 ? 4 : @direction == 8 ? 2 : @direction)
end

if @case_par_case == true # si case par case, on remet la définition normale
if (passable?(@x, @y, 2) and passable?(@x, @y + 1, 4)) or
(passable?(@x, @y, 4) and passable?(@x - 1, @y, 2))
# ?????
@x -= 1
@y += 1
# ????
increase_steps
end
else #sinon, défintion de déplacement quart de case
@test = @x
@testb = @y
if (passable?((@x+0.75).to_i, @y.to_i, 2) and passable?(@x.to_i, @y.to_i, 2) and
passable?((@x+0.75).to_i, (@y+1).to_i, 4) and passable?(@x.to_i, (@y+0.25).to_i, 4)) or
(passable?((@x+0.75).to_i, (@y+0.75).to_i, 4) and passable?(@x.to_i, @y.to_i, 4) and
passable?((@x+0.5).to_i, @y.to_i, 2) and passable?((@x-0.25).to_i, @y.to_i, 2))
# ?????
@x -= 0.25
@y += 0.25
# ????
increase_steps

else
@stop = false
move_left
if @stop == false
move_down
end

end
end
end #fin de définition
#--------------------------------------------------------------------------
# Mouvement en haut à gauche !!!!!!!!!!!!!!
#--------------------------------------------------------------------------
def move_upper_left
# ?????????
unless @direction_fix
# ?????????????????????????
@direction = (@direction == 6 ? 4 : @direction == 2 ? 8 : @direction)
end

if @case_par_case == true # si case par case, on remet la définition normale
# ??????? ?????????????????
if (passable?(@x, @y, 8) and passable?(@x, @y - 1, 4)) or
(passable?(@x, @y, 4) and passable?(@x - 1, @y, 8))
# ?????
@x -= 1
@y -= 1
# ????
increase_steps
end
else #sinon, défintion de déplacement quart de case
if (passable?((@x+0.75).to_i, (@y+0.75).to_i, 8) and passable?(@x.to_i, (@y+0.75).to_i, 8) and
passable?((@x+0.75).to_i, (@y+0.5).to_i, 4) and passable?(@x.to_i, (@y - 0.25).to_i, 4)) or
(passable?((@x+0.75).to_i, (@y+0.75).to_i, 4) and passable?(@x.to_i, @y.to_i, 4) and
passable?((@x+0.5).to_i, (@y+0.75), 8) and passable?((@x - 0.25).to_i, (@y+0.75).to_i, 8))
# ?????
@x -= 0.25
@y -= 0.25
# ????
increase_steps

else
@stop = false
move_left
if @stop == false
move_up
end

end
end
end #fin de définition
#--------------------------------------------------------------------------
# Mouvement en haut à droite !!!!!!!!!!!!!!
#--------------------------------------------------------------------------
def move_upper_right
# ?????????
unless @direction_fix
# ?????????????????????????
@direction = (@direction == 4 ? 6 : @direction == 2 ? 8 : @direction)
end

if @case_par_case == true # si case par case, on remet la définition normale
# ??????? ?????????????????
if (passable?(@x, @y, 8) and passable?(@x, @y - 1, 6)) or
(passable?(@x, @y, 6) and passable?(@x + 1, @y, 8))
# ?????
@x += 1
@y -= 1
# ????
increase_steps
end
else #sinon, définition de déplacement quart de case
@test = @x
@testb = @y
if (passable?((@x+0.75).to_i, (@y+0.75), 8) and passable?(@x.to_i, (@y+0.75).to_i, 8) and
passable?(@x.to_i, (@y+0.5).to_i, 6) and passable?(@x.to_i, (@y-0.25).to_i, 6)) or
(passable?(@x.to_i, (@y+0.75).to_i, 6) and passable?(@x.to_i, @y.to_i, 6) and
passable?((@x+1).to_i, (@y+0.75), 8) and passable?((@x+0.25).to_i, (@y+0.75).to_i, 8))
# ?????
@x += 0.25
@y -= 0.25
# ????
increase_steps
else
@stop = false
move_right
if @stop == false
move_up
end
end
end
end #fin de définition

#--------------------------------------------------------------------------
# Redéfinition des intéractions avec les événements.
#--------------------------------------------------------------------------
def check_event_trigger_here(triggers)
result = false
# ??????????
if $game_system.map_interpreter.running?
return result
end
# ?????????
for event in $game_map.events.values
# ???????????????????
@test_event_x = @x+0.25
@test_event_y = @y+0.25
if event.x == @test_event_x.to_i and event.y == @test_event_y.to_i and triggers.include?(event.trigger)
# ????????????????????????
if not event.jumping? and event.over_trigger?
event.start
result = true
end
end
end
return result
end
#--------------------------------------------------------------------------
# ? ???????????
#--------------------------------------------------------------------------
def check_event_trigger_there(triggers)
result = false
# ??????????
if $game_system.map_interpreter.running?
return result
end
# ????????
@test_event = @x+0.25
new_x = @test_event.to_i + (@direction == 6 ? 1 : @direction == 4 ? -1 : 0)
@test_event = @y+0.25
new_y = @test_event.to_i + (@direction == 2 ? 1 : @direction == 8 ? -1 : 0)
# ?????????
for event in $game_map.events.values
# ???????????????????
if event.x == new_x and event.y == new_y and
triggers.include?(event.trigger)
# ???????????????????????
if not event.jumping? and not event.over_trigger?
event.start
result = true
end
end
end
# ???????????????????
if result == false
# ??????????????
if $game_map.counter?(new_x, new_y)
# 1 ??????????
new_x += (@direction == 6 ? 1 : @direction == 4 ? -1 : 0)
new_y += (@direction == 2 ? 1 : @direction == 8 ? -1 : 0)
# ?????????
for event in $game_map.events.values
# ???????????????????
if event.x == new_x and event.y == new_y and
triggers.include?(event.trigger)
# ???????????????????????
if not event.jumping? and not event.over_trigger?
event.start
result = true
end
end
end
end
end
return result
end
end