Mouvements supplémentaires.v2

-Introduction

Parfois j'ai besoin de petites fonctions simples, qui ne méritent pas de script à part entière, alors je les regourpent toutes là-dedans. Il y a des mouvements supplementaires, des accesseurs, des choses assez simples. Ce script se décompose en differents modules correspondants à des classes comme l'interpreteur ou character. Il y a ausi un module mixte. Cette organisation me permet de simplifier les inclusions.

-Installation

Ce script n'échappe pas à la régle du "copiez en dessous de material".
Il n'a pas de nécéssité particulière.


-script:

Code:

#===============================================================================
#
#
#                            Mouvements supplémentaires .v2
#
#
#===============================================================================
#
#By Vincentmhd
#http://vincentmhdmaker.canalblog.com/
#2/10/2009
#v1 ->  v2  ajout des diagonales à go_to(x,y) et approach_to(x,y)
#=>Mouvements plus logiques
#=====================================NOTE======================================
#
#Ce script  ajoute de petites  fonctions. Elle se décompose en plusieurs modules
#chacun  spécifiques à une  classe sauf  pour  MIXTE qui  contient des  méthodes
#communes.
#
#Je ne peux pas m'amuser à toutes les expliquer car c'est une sorte de fourre
#tout personnel.
#
#-------------------------------------------------------------------------------


module MIXTE 
#------------------------------------------------------------------------------#
#Wait at random between min and max                                            #
#------------------------------------------------------------------------------#
  def wait_between(min,max)
    middle = min + rand(max - min)
    @wait_count = middle
  end
#------------------------------------------------------------------------------#
#Wait at random between 0 and max                                              #
#------------------------------------------------------------------------------#
  def wait_between_M(max)
    middle = rand(max)
    @wait_count = middle
  end
#------------------------------------------------------------------------------#
# * Erase Event
#------------------------------------------------------------------------------#
  def erase_event(id)
    $game_map.events[id].erase
  end
#------------------------------------------------------------------------------#
# * Start Event
#------------------------------------------------------------------------------#
  def start_event(id)
    $game_map.events[id].start
  end

#------------------------------------------------------------------------------#
# * Tint Screen
#------------------------------------------------------------------------------#
  def Tint_Screen(r, g, b, a, t, bool = false)
    tone = Tone.new(r,g,b,a)
    $game_map.screen.start_tone_change(tone, t)
    @wait_count = t if bool
  end
#------------------------------------------------------------------------------#
# * Tint Screen Relative
#------------------------------------------------------------------------------#
  def Tint_Screen_R(r, g, b, a, t, bool = false)
    red    = $game_map.screen.tone_target.red + r
    green  = $game_map.screen.tone_target.green + g
    blue  = $game_map.screen.tone_target.blue + b
    alpha  = $game_map.screen.tone_target.gray + a
   
    tone  = Tone.new(red, green, blue, alpha)
    $game_map.screen.start_tone_change(tone, t)
    @wait_count = t if bool
  end
#------------------------------------------------------------------------------#
# * Screen Flash
#------------------------------------------------------------------------------#
  def Flash_Screen(r, g, b, a, t, bool = false)
    tone = Color.new(r,g,b,a)
    $game_map.screen.start_flash(tone, t)
    @wait_count = t if bool
  end
#------------------------------------------------------------------------------#
# * Screen Flash Relative
#------------------------------------------------------------------------------#
  def Flash_Screen_R( r, g, b, a, t, bool = false)
    if $game_map.screen.flash_duration != 0
      red    = $game_map.screen.flash_color.red + r
      green  = $game_map.screen.flash_color.green + g
      blue  = $game_map.screen.flash_color.blue + b
      alpha  = $game_map.screen.flash_color.alpha + a
    else
      red    = $game_map.screen.tone_target.red + r
      green  = $game_map.screen.tone_target.green + g
      blue  = $game_map.screen.tone_target.blue + b
      alpha  = $game_map.screen.tone_target.gray + a
    end
    tone  = Color.new(red, green, blue, alpha)
    $game_map.screen.start_flash(tone, t)
    @wait_count = t if bool
  end

#==============================================================================#
end                                                          #module MIXTE end#
#==============================================================================#


module EVENT
#------------------------------------------------------------------------------#
#Change event trigger:                                                        #
#                                                                              #
#0: Input Touch                                                                #
#1: Contact Heros                                                              #
#2: Contact Event                                                              #
#3: Automatic                                                                  #
#4: Parallel Process                                                          #
#5+: None                                                                      #
#                                                                              #
#------------------------------------------------------------------------------#
  attr_accessor  :trigger
  def change_trigger( t )
    @trigger = t
  end

 
#==============================================================================#
end                                                          #module EVENT end#
#==============================================================================#

module INTERPRETER
  def change_trigger(t, id = @event_id)
    $game_map.events[id].trigger = t
  end
#==============================================================================#
end                                                    #module INTERPRETER end#
#==============================================================================#

module CHARACTER
#------------------------------------------------------------------------------#
#Change event priority                                                        #
#------------------------------------------------------------------------------#
  attr_accessor  :priority_type
  def change_priority(p)
    @priority_type = p
  end
#------------------------------------------------------------------------------#
#Selfswitches for move        id = ' '                                        #
#------------------------------------------------------------------------------#
  def self_switches(id, value)
    key = [$game_map.map_id, @id, id]
    $game_self_switches[key] = (value)
    $game_map.need_refresh = true
  end
#------------------------------------------------------------------------------#
#Manual start event if(player is on the event)                                #
#------------------------------------------------------------------------------#
  def start_if_on
    if $game_player.x == @x && $game_player.y== @y
      start
    end
  end
#------------------------------------------------------------------------------#
#Ramdom moveTo                  (x et y are arrays)                            #
#------------------------------------------------------------------------------#
  def moveto_R_between(x,y)
    index = rand(x.size)
    moveto(x[index],y[index])
  end
#------------------------------------------------------------------------------#
#Order moveTo                  (x et y are arrays)                            #
#------------------------------------------------------------------------------#
  attr_accessor  :order
  def moveto_O(x,y)
    if (@order == nil) || (@order == (x.size - 1))
      @order = 0
    else
      @order +=1
    end
    moveto(x[@order],y[@order])
  end
#------------------------------------------------------------------------------#
#Random moveTo in a rect                                                      #
#------------------------------------------------------------------------------#
  def moveto_R_in(x_min, x_max, y_min, y_max)
    x = x_min + rand(x_max - x_min + 1)
    y = y_min + rand(y_max - y_min + 1)
    moveto(x.to_i,y.to_i)
  end
#------------------------------------------------------------------------------#
#moveto_P si passable                                                          #
#------------------------------------------------------------------------------#
  def moveto_P(x, y)
    if passable?(x,y)
      moveto(x.to_i,y.to_i)
    end
  end
#------------------------------------------------------------------------------#
#Random moveto_P in a rect                                                    #
#------------------------------------------------------------------------------#
  def moveto_P_in(x_min, x_max, y_min, y_max)
    x = x_min + rand(x_max - x_min + 1)
    y = y_min + rand(y_max - y_min + 1)
    while passable?(x,y)
      moveto_P(x.to_i,y.to_i)
      x = x_min + rand(x_max - x_min + 1)
      y = y_min + rand(y_max - y_min + 1)
    end
  end
#-------------------------------------------------------------------------------
# * Jump if place is passable
#    x_plus : x-coordinate plus value
#    y_plus : y-coordinate plus value
#-------------------------------------------------------------------------------
  def jump_P(x_plus, y_plus)
    if passable? (@x + x_plus, @y + y_plus)
      if x_plus.abs > y_plus.abs            # Horizontal distance is longer
        x_plus < 0 ? turn_left : turn_right
      elsif x_plus.abs > y_plus.abs        # Vertical distance is longer
        y_plus < 0 ? turn_up : turn_down
      end
      @x += x_plus
      @y += y_plus
      distance = Math.sqrt(x_plus * x_plus + y_plus * y_plus).round
      @jump_peak = 10 + distance - @move_speed
      @jump_count = @jump_peak * 2
      @stop_count = 0
      straighten
    end
  end
#-------------------------------------------------------------------------------
# * Jump if place is passable in Star
#    x_plus : x-coordinate plus value
#    y_plus : y-coordinate plus value
#-------------------------------------------------------------------------------
  def jump_C(star)
    dir = rand(8)
    ok = false
    a = 0
    while ok == false
      case dir
      when 0 #down
        ok = passable?(@x,@y-star)
      when 1 #left
        ok = passable?(@x-star,@y)
      when 2 #right
        ok = passable?(@x+star,@y)
      when 3 #up
        ok = passable?(@x,@y+star)
      when 4 #down left
        ok = passable?(@x-star,@y-star)
      when 5 #down rigth
        ok = passable?(@x+star,@y-star)
      when 6 #up left
        ok = passable?(@x-star,@y+star)
      when 7 #up right
        ok = passable?(@x+star,@y+star)
      end
      if (ok==false)
        dir = rand(8)
      end
    end
    if ok == true
      case dir
      when 0 #down
        jump(0,-star)
      when 1 #left
        jump(-star,0)
      when 2 #right
        jump(star,0)
      when 3 #up
        jump(0,star)
      when 4 #down left
        jump(-star,-star)
      when 5 #down rigth
        jump(star,-star)
      when 6 #up left
        jump(-star,star)
      when 7 #up right
        jump(star,star)
      end
    end
  end
#-------------------------------------------------------------------------------
# Approach to (x, y)    !!Passability is not considered
#-------------------------------------------------------------------------------
  attr_accessor  :target_x, :target_y
  def approach_to(x,y)
    @target_x = x
    @target_y = y
    sx = @x - @target_x
    sy = @y - @target_y
   
    if ((sx.abs > 0)&&(sy.abs > 0))
      if (sx > 0)
        if (sy > 0)
          move_upper_left
        else
          move_lower_left
        end
      else
        if (sy > 0)
          move_upper_right
        else
          move_lower_right
        end       
      end
      
    else
      
      if ((sx.abs > 0)||(sy.abs > 0))
        if (sx.abs > sy.abs)                    # Horizontal distance is longer
          if (sx > 0)
            move_left()
          else
            move_right()
          end
        else                                  # Vertical distance is longer
          if (sy > 0)
            move_up()
          else
            move_down()
          end
        end
      end
    end
  end
 
#-------------------------------------------------------------------------------
# Go to (x, y)  absolue          !!Passability is not considered
#-------------------------------------------------------------------------------
  def go_to(x,y)
    @target_x = x
    @target_y = y
    @custom_index = 1
  end
#-------------------------------------------------------------------------------
# Go to (x, y)  relative          !!Passability is not considered
#-------------------------------------------------------------------------------
  def go_to_R(x,y)
    @target_x = @x + x
    @target_y = @y + y
    @custom_index = 1
  end

#-------------------------------------------------------------------------------
# Go to (x_min, x_max, y_min, y_max)            !!Passability is not considered
#-------------------------------------------------------------------------------
  def go_to_in(x_min, x_max, y_min, y_max) 
    @target_x = x_min + rand(x_max - x_min + 1)
    @target_y  = y_min + rand(y_max - y_min + 1)
    @custom_index = 1
  end
 
#-------------------------------------------------------------------------------
# Go to (x_min, x_max, y_min, y_max) if P          !!Passability is not considered
#-------------------------------------------------------------------------------
  def go_to_in_P(x_min, x_max, y_min, y_max)
    @target_x = x_min + rand(x_max - x_min + 1)
    @target_y  = y_min + rand(y_max - y_min + 1)
    while !(passable?(@target_x,@target_y))
      @target_x = x_min + rand(x_max - x_min + 1)
      @target_y  = y_min + rand(y_max - y_min + 1)
    end
    @custom_index = 1
  end


#-------------------------------------------------------------------------------
# Show balloon
#------------------------------------------------------------------------------- 
  def show_balloon(id)
    @balloon_id = id
  end
 
#==============================================================================#
end                                                      #module CHARACTER end#
#==============================================================================#


#------------------------------------------------------------------------------#
#Inclusion des modules  + appoint                                              #
#------------------------------------------------------------------------------#
class Game_Interpreter
  include MIXTE
  include INTERPRETER
end

class Game_Character
  include MIXTE
  include CHARACTER
#-------------------------------------------------------------------------------
# Go to (x y)
#-------------------------------------------------------------------------------
  alias go_to_move_type_custom move_type_custom
  def move_type_custom
    if stopping?
      case @custom_index
      when 1
        if ((@x == @target_x)&&(@y==@target_y))
          @custom_index = nil
        end
        approach_to(@target_x, @target_y)
      else
        #nothing
      end
    end
    go_to_move_type_custom
  end
 
end

class Game_Event
  include MIXTE
  include EVENT
end
#------------------------------------------------------------------------------#
#Appoints divers                                                              #
#------------------------------------------------------------------------------#

class Game_Screen
  attr_reader :tone_target, :flash_duration, :flash_color
end






Modification du déclenchement
Cette méthode modifie le trigger de l'event en question, cette méthode peut être très puissante...
Appel Déplacement:

Spoiler:

Appel Interpreter:
Spoiler:



Modification de la priorité d'un event (de la couche)
Cette méthode modifie la couche de l'event: dessus, desous, même que le héro, elle va de paire avec le changement de trigger, cette méthode peut être aussi très puissante si bien exploitée...
Appel Déplacement:
Spoiler:



Modification Selfswitches pendant un déplacement
Cette fonction me manquait car je me demande pourquoi ils ont mis une fonction pour modifier les game_switches mais pas les variables et les selfswitches?! id correspond à "A", "B" ... value true or false
Appel Déplacement:
Spoiler:



Start event if on
C'est un besoin particulier. L'event commence manuellement si le player est sur la même case.
Appel Déplacement:
Spoiler:



Montre une émoticone
Appel Déplacement:
Spoiler:



Les déplacements

Téléportation aléatoire dans une liste de positions
x est y sont des arrays de taille identique.
Appel Déplacement:
Spoiler:


Téléportation ordonnée dans une liste de positions
x est y sont des arrays de taille identique.
Appel Déplacement:
Spoiler:


Téléportation aleatoire dans une zone rectangulaire
Appel Déplacement:
Spoiler:


Téléportation si la case est passable
Appel Déplacement:
Spoiler:


Téléportation aleatoire dans une zone rectangulaire et si la case est passable
Appel Déplacement:
Spoiler:


Saut si la case est passable
Appel Déplacement:
Spoiler:


Saut sur une des case autour au rayon spécifié et si la case est passable
Appel Déplacement:
Spoiler:


S'approcher d'une position
Attention ce déplacement ne tient pas compte de la passabilité et peut bloquer l'event.
Appel Déplacement:
Spoiler:


Aller à
Attention ce déplacement ne tient pas compte de la passabilité et peut bloquer l'event. Comme d'habitude il y a deux types de coordonnées: absolues et relatives. Ce déplacement se fait tant que le personnage n'a pas atteint les coordonées (blocage possible).
Appel Déplacement:
Spoiler:


-Démo:

voir les résultats du concours de Sept 2009: Lien
Les meilleures applications sont dans les events des cellules mirroirs.


-Crédit: Vincentmhd
_________________