Looking for a couple of scripts.

[BellGoRiiing]

This is officially my first post here, I just registered to this forum...Here are the scripts I'm looking for.

The Catapillar (sp?) Effect: I have tried all kind of scripts for this and all have failed so far...If you know of a script for this that never fails please tell me.

This Other Script: I don't know the name for this one, but I know how to describe it...The maximum characters for a party is 4, but I found out by using RGSS you can switch in and out party members. The only thing I want to change in this (to increase difficulty in my game) is to only be able to use it when you're on a certain map/area. If you know of a script that allows me to do this, please let me know.

This other script I'm not entirely sure if I'll be using it or not, but if I find out that I need it I'll post the details. Thanks people.

EDIT: I also want to add...Please let me know if I went against any of the forum rules, if I have then sorry.

EDIT 2: One other script that I was looking for...Chaos_Prime was looking for something quite similar but had no luck. You can find his thread on the second page of this board, its basically gives you information on the enemies/bosses you've defeated or fought. Think of it as a Logbook from Metroid Prime and Echoes, if you have a script for this let me know.

 

[A J]

This is the second

This script allow you to have more than 4 party members and the original was written by Fomar0153 and what I did is I made a special menu for changing the party members Just add ( $scene= Scene_Change.new ) in an event to call the Menu.
to change the max party size go to line 126

#==============================================================================
# ** Scene_Change
#------------------------------------------------------------------------------
#  This class performs Chaning Members Menu screen processing.
#==============================================================================
#Party Control By Fomar0153
#Changing Members Menu By A J aj_dark_soul@yahoo.co.uk
#This script allow you to have more than 4 party members
#and the original was written by Fomar0153 and what I did is I made a special
#menu for changing the party members Just add ( $scene= Scene_Change.new ) in
# an event to call the Menu.
# to change the max party size go to line 126
#==============================================================================
class Scene_Change
  #--------------------------------------------------------------------------
  #--------------------------------------------------------------------------
  def initialize(menu_index = 0)
    @menu_index = menu_index
  end
  #--------------------------------------------------------------------------
  # * Main Processing
  #--------------------------------------------------------------------------
  def main
    # Make command window
    s1 = "Change Members"
    s2 = "Done"
    @command_window = Window_Command.new(160, [s1, s2])
    @command_window.index = @menu_index
    # Make status window
    @status_window = Window_MenuStatus.new
    @status_window.x = 160
    @status_window.y = 0
    # Execute transition
    Graphics.transition
    # Main loop
    loop do
      # Update game screen
      Graphics.update
      # Update input information
      Input.update
      # Frame update
      update
      # Abort loop if screen is changed
      if $scene != self
        break
      end
    end
    # Prepare for transition
    Graphics.freeze
    # Dispose of windows
    @command_window.dispose
    @status_window.dispose
  end
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
    # Update windows
    @command_window.update
    @status_window.update
    # If command window is active: call update_command
    if @command_window.active
      update_command
      return
    end
    # If status window is active: call update_status
    if @status_window.active
      update_status
      return
    end
  end
  #--------------------------------------------------------------------------
  # * Frame Update (when command window is active)
  #--------------------------------------------------------------------------
  def update_command
    # If C button was pressed
    if Input.trigger?(Input::C)
      # If command other than save or end game, and party members = 0
      if $game_party.actors.size == 0 and @command_window.index < 4
        # Play buzzer SE
        $game_system.se_play($data_system.buzzer_se)
        return
      end
      # Branch by command window cursor position
      case @command_window.index
      when 0
      $game_system.se_play($data_system.cursor_se)
      @previous_index = @command_window.index
      @command_window.index = -1
      @command_window.active = false
      @status_window.active = true
      @status_window.index = @status_window.top_row
      return
     when 1  # save
        # Play decision SE
        $game_system.se_play($data_system.decision_se)
        # Switch to save screen
        $scene = Scene_Map.new
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Frame Update (when status window is active)
  #--------------------------------------------------------------------------
  def update_status
    # If B button was pressed
    if Input.trigger?(Input::B)
      # Play cancel SE
      $game_system.se_play($data_system.cancel_se)
      # Make command window active
      @command_window.active = true
      @status_window.active = false
      @status_window.index = -1
      return
    end
  end
end

#-------------------------------------------------------------------------------
# more than 4 max party members size
# By Fomar0153
#-------------------------------------------------------------------------------

class Game_Party

  Max_Party_Size = 8
  
  def max_party_size
    return Max_Party_Size
  end
  
  def add_actor(actor_id)
    actor = $game_actors[actor_id]
    if not @actors.include?(actor) and $game_party.actors.size < Max_Party_Size
      @actors.push(actor)
      $game_player.refresh
    end
  end
  
  def all_dead?
    if $game_party.actors.size == 0
      return false
    end
    for actor in @actors
      if actor.hp > 0
        return false
      end
      if actor.index >= 4
        return true
      end
    end
    return true
  end
end
##############
class Scene_Change
  
  alias party_swap_update_status update_status
  def update_status
    if Input.trigger?(Input::B)
      unless @swapee != nil
        $game_system.se_play($data_system.cancel_se)
        if @command_window.index == -1
          @command_window.index = @previous_index
        end
        @command_window.active = true
        @status_window.active = false
        @status_window.index = -1
        return
      end
      @swapee = nil
      return
    end
    if Input.trigger?(Input::C) and @command_window.index == -1
      unless @swapee != nil
        @swapee = @status_window.index
        $game_system.se_play($data_system.decision_se)
        return
      end
      if @swapee == @status_window.index
        $game_system.se_play($data_system.decision_se)
        @swapee = nil
        return
      end
      $game_system.se_play($data_system.decision_se)
      party_ids = []
      for actor in $game_party.actors
        party_ids.push(actor.id)
      end
      swapee2 = @status_window.index
      if @swapee < swapee2
        for i in @swapee...party_ids.size
          $game_party.remove_actor(party_ids[i])
        end
        $game_party.add_actor(party_ids[swapee2])
        for i in (@swapee + 1)...party_ids.size
          unless i == swapee2
            $game_party.add_actor(party_ids[i])
          else
            $game_party.add_actor(party_ids[@swapee])
          end
        end
      else
        for i in swapee2...party_ids.size
          $game_party.remove_actor(party_ids[i])
        end
        $game_party.add_actor(party_ids[@swapee])
        for i in (swapee2 + 1)...party_ids.size
          unless i == @swapee
            $game_party.add_actor(party_ids[i])
          else
            $game_party.add_actor(party_ids[swapee2])
          end
        end
      end
      @swapee = nil
      @status_window.refresh
      return
    end
    party_swap_update_status
  end
end

class Window_MenuStatus < Window_Selectable
  
  def initialize
    unless $game_party.actors.size > 4
      super(0, 0, 480, 480)
    else
      super(0, 0, 480, 160 * $game_party.actors.size)
    end
    self.contents = Bitmap.new(width - 32, height - 32)
    refresh
    self.active = false
    self.index = -1
  end
  
  alias large_refresh refresh
  def refresh
    large_refresh
    self.height = 480
  end
  
  def update_cursor_rect
    if @index < 0
      self.cursor_rect.empty
      return
    end
    row = @index / @column_max
    if row < self.top_row
      self.top_row = row
    end
    if row > self.top_row + (self.page_row_max - 1)
      self.top_row = row - (self.page_row_max - 1)
    end
    cursor_width = self.width / @column_max - 32
    x = @index % @column_max * (cursor_width + 32)
    y = @index / @column_max * 116 - self.oy
    self.cursor_rect.set(x, y, cursor_width, 96)
  end
  
  def top_row
    return self.oy / 116
  end
  
  def top_row=(row)
    if row < 0
      row = 0
    end
    if row > row_max - 1
      row = row_max - 1
    end
    self.oy = row * 116
  end
  
  def page_row_max
    return 4
  end
end

class Scene_Battle
  def phase3_next_actor
    begin
      if @active_battler != nil
        @active_battler.blink = false
      end
      if @actor_index == ([$game_party.actors.size, 4].min - 1)
        start_phase4
        return
      end
      @actor_index += 1
      @active_battler = $game_party.actors[@actor_index]
      @active_battler.blink = true
    end until @active_battler.inputable?
    phase3_setup_command_window
  end
  
end

class Game_Actor < Game_Battler
  def exist?
    return super == self.index < 4
  end
end

 

[BellGoRiiing]

Thanks, I'll try this out soon.

 

[A J]

and the first one

#==============================================================================
# â–  Train_Actor::Config
#------------------------------------------------------------------------------
# Caterpillar movement of actor is carried out on map
#==============================================================================

module Train_Actor

# ●Switch setup for transparent status
# When true, switch control is used
# TRANSPARENT_SWITCH = true
TRANSPARENT_SWITCH = false

# ●Switch number for transparent status
# When TRANSPARENT_SWITCH is true, transparency will be activated when the switch of this number is on
TRANSPARENT_SWITCHES_INDEX = 20

# ●Maximum number of actors
# There will be support for a large number of people in a party in the future...
TRAIN_ACTOR_SIZE_MAX = 4

# Constants
DOWN_LEFT  = 1
DOWN_RIGHT = 3
UP_LEFT    = 7
UP_RIGHT   = 9
JUMP       = 5

end

# rgss

# Spriteset_Map_Module.rb
#==============================================================================
# â–  Spriteset_Map_Module
#------------------------------------------------------------------------------
# Caterpillar movement of actor is carried out on map
#==============================================================================

module Train_Actor

module Spriteset_Map_Module
 def setup_actor_character_sprites?
   return @setup_actor_character_sprites_flag != nil
 end
 def setup_actor_character_sprites(characters)
   if !setup_actor_character_sprites?
     for character in characters.reverse
       @character_sprites.unshift(
         Sprite_Character.new(@viewport1, character)
       )
     end
     @setup_actor_character_sprites_flag = true
   end
 end
end

end

class Spriteset_Map
 include Train_Actor::Spriteset_Map_Module
end

# Scene_Map_Module.rb
#==============================================================================
# â–  Scene_Map_Module
#------------------------------------------------------------------------------
# Caterpillar movement of actor is carried out on map
#==============================================================================

module Train_Actor

module Scene_Map_Module
 def setup_actor_character_sprites(characters)
   @spriteset.setup_actor_character_sprites(characters)
 end
end

end

class Scene_Map
 include Train_Actor::Scene_Map_Module
end

# Game_Party_Module.rb
#==============================================================================
# â–  Game_Party_Module
#------------------------------------------------------------------------------
# Caterpillar movement of actor is carried out on map
#==============================================================================

module Train_Actor

module Game_Party_Module
 attr_reader :characters
 def actors_dead?
   for actor in actors
     if actor.dead?
       return true
     end
   end
   return false
 end
 def update_party_order
   if not actors_dead?
     return actors
   end
   alive_actors = []
   dead_actors = []
   for actor in actors
     if actor.dead?
       dead_actors.push actor
     else
       alive_actors.push actor
     end
   end
   return alive_actors + dead_actors
 end
 def setup_actor_character_sprites
   if @characters.nil?
     @characters = []
     for i in 1 ... TRAIN_ACTOR_SIZE_MAX
       @characters.push(Game_Party_Actor.new)
     end
   end
   setup_actors = update_party_order
   for i in 1 ... TRAIN_ACTOR_SIZE_MAX
     @characters[i - 1].setup(setup_actors[i])
   end
   if $scene.class.method_defined?('setup_actor_character_sprites')
     $scene.setup_actor_character_sprites(@characters)
   end
 end
 def update_party_actors
   update_party_order
   setup_actor_character_sprites
   transparent = $game_player.transparent
   if transparent == false
     if TRANSPARENT_SWITCH
       transparent = $game_switches[TRANSPARENT_SWITCHES_INDEX]
     end
   end
   for character in @characters
     character.transparent = transparent
     character.move_speed = $game_player.move_speed
     character.step_anime = $game_player.step_anime
     character.update
   end
 end
 def moveto_party_actors( x, y )
   setup_actor_character_sprites
   for character in @characters
     character.moveto( x, y )
   end
   if @move_list == nil
     @move_list = []
   end
   move_list_setup
 end
 def move_party_actors
   if @move_list == nil
     @move_list = []
     move_list_setup
   end
   @move_list.each_index do |i|
     if @characters[i] != nil
       case @move_list[i].type
         when Input::DOWN
           @characters[i].move_down(@move_list[i].args[0])
         when Input::LEFT
           @characters[i].move_left(@move_list[i].args[0])
         when Input::RIGHT
           @characters[i].move_right(@move_list[i].args[0])
         when Input::UP
           @characters[i].move_up(@move_list[i].args[0])
         when DOWN_LEFT
           @characters[i].move_lower_left
         when DOWN_RIGHT
           @characters[i].move_lower_right
         when UP_LEFT
           @characters[i].move_upper_left
         when UP_RIGHT
           @characters[i].move_upper_right
         when JUMP
           @characters[i].jump(@move_list[i].args[0],@move_list[i].args[1])
       end
     end
   end
 end
 class Move_List_Element
   def initialize(type,args)
     @type = type
     @args = args
   end
   def type() return @type end
   def args() return @args end
 end
 def move_list_setup
   for i in 0 .. TRAIN_ACTOR_SIZE_MAX
     @move_list[i] = nil
   end
 end
 def add_move_list(type,*args)
   @move_list.unshift(Move_List_Element.new(type,args)).pop
 end
 def move_down_party_actors(turn_enabled = true)
   move_party_actors
   add_move_list(Input::DOWN,turn_enabled)
 end
 def move_left_party_actors(turn_enabled = true)
   move_party_actors
   add_move_list(Input::LEFT,turn_enabled)
 end
 def move_right_party_actors(turn_enabled = true)
   move_party_actors
   add_move_list(Input::RIGHT,turn_enabled)
 end
 def move_up_party_actors(turn_enabled = true)
   move_party_actors
   add_move_list(Input::UP,turn_enabled)
 end
 def move_lower_left_party_actors
   move_party_actors
   add_move_list(DOWN_LEFT)
 end
 def move_lower_right_party_actors
   move_party_actors
   add_move_list(DOWN_RIGHT)
 end
 def move_upper_left_party_actors
   move_party_actors
   add_move_list(UP_LEFT)
 end
 def move_upper_right_party_actors
   move_party_actors
   add_move_list(UP_RIGHT)
 end
 def jump_party_actors(x_plus, y_plus)
   move_party_actors
   add_move_list(JUMP,x_plus, y_plus)
 end
end

end

class Game_Party
 include Train_Actor::Game_Party_Module
end

# Game_Player_Module.rb
#==============================================================================
# â–  Game_Player_Module
#------------------------------------------------------------------------------
# Caterpillar movement of actor is carried out on map
#==============================================================================

module Train_Actor

module Game_Player_Module
 attr_reader :move_speed
 attr_reader :step_anime

 def update_party_actors
   $game_party.update_party_actors
   $game_party.actors.each do |actor|
     if actor.dead?
       next
     end
     @character_name = actor.character_name
     @character_hue = actor.character_hue
     break
   end
 end
 def update
   update_party_actors
   super
 end
 def moveto( x, y )
   $game_party.moveto_party_actors( x, y )
   super( x, y )
 end
 def move_down(turn_enabled = true)
   if passable?(@x, @y, Input::DOWN)
     $game_party.move_down_party_actors(turn_enabled)
   end
   super(turn_enabled)
 end
 def move_left(turn_enabled = true)
   if passable?(@x, @y, Input::LEFT)
     $game_party.move_left_party_actors(turn_enabled)
   end
   super(turn_enabled)
 end
 def move_right(turn_enabled = true)
   if passable?(@x, @y, Input::RIGHT)
     $game_party.move_right_party_actors(turn_enabled)
   end
   super(turn_enabled)
 end
 def move_up(turn_enabled = true)
   if passable?(@x, @y, Input::UP)
     $game_party.move_up_party_actors(turn_enabled)
   end
   super(turn_enabled)
 end
 def move_lower_left
   # When possible to move from down→left or from left→down
   if (passable?(@x, @y, Input::DOWN) and passable?(@x, @y + 1, Input::LEFT)) or
      (passable?(@x, @y, Input::LEFT) and passable?(@x - 1, @y, Input::DOWN))
     $game_party.move_lower_left_party_actors
   end
   super
 end
 def move_lower_right
   # When possible to move from down→right or from right→down
   if (passable?(@x, @y, Input::DOWN) and passable?(@x, @y + 1, Input::RIGHT)) or
      (passable?(@x, @y, Input::RIGHT) and passable?(@x + 1, @y, Input::DOWN))
     $game_party.move_lower_right_party_actors
   end
   super
 end
 def move_upper_left
   # When possible to move from up→left or from left→up
   if (passable?(@x, @y, Input::UP) and passable?(@x, @y - 1, Input::LEFT)) or
      (passable?(@x, @y, Input::LEFT) and passable?(@x - 1, @y, Input::UP))
     $game_party.move_upper_left_party_actors
   end
   super
 end
 def move_upper_right
   # When possible to move from up→right or from right→up
   if (passable?(@x, @y, Input::UP) and passable?(@x, @y - 1, Input::RIGHT)) or
      (passable?(@x, @y, Input::RIGHT) and passable?(@x + 1, @y, Input::UP))
     $game_party.move_upper_right_party_actors
   end
   super
 end
 def jump(x_plus, y_plus)
   # New coordinates are calculated
   new_x = @x + x_plus
   new_y = @y + y_plus
   # When addition values are (0,0), it is possible to jump to the destination
   if (x_plus == 0 and y_plus == 0) or passable?(new_x, new_y, 0)
     $game_party.jump_party_actors(x_plus, y_plus)
   end
   super(x_plus, y_plus)
 end
end

end

class Game_Player
 include Train_Actor::Game_Player_Module
end

# Game_Event_Module.rb
#==============================================================================
# â–  Game_Event_Module
#------------------------------------------------------------------------------
# Caterpillar movement of actor is carried out on map
#==============================================================================

module Train_Actor

module Game_Event_Module
 #--------------------------------------------------------------------------
 # ● Judgement determined
 #     x  : X coordinates
 #     y  : Y coordinates
 #     d  : Direction (0,2,4,6,8)  ※ 0 = Checks if all directions are not able to be passed (for a jump)
 # return : Passing is impossible (false), possible (true)
 #--------------------------------------------------------------------------
 def passable?(x, y, d)
   result = super(x, y, d)
   if result
     # New coordinates are searched for
     new_x = x + (d == 6 ? 1 : d == 4 ? -1 : 0)
     new_y = y + (d == 2 ? 1 : d == 8 ? -1 : 0)
     # Loops for actor in train
     for actor in $game_party.characters
       # When displayed
       if not actor.character_name.empty?
         # When actor's coordinates correspond to the destination
         if actor.x == new_x and actor.y == new_y
           # When event
           if self != $game_player
             # Passing is impossible
             return false
           end
         end
       end
     end
   end
   return result
 end
end

end

class Game_Event
 include Train_Actor::Game_Event_Module
end
 
# Game_Party_Actor.rb
#==============================================================================
# â–  Game_Party_Actor
#------------------------------------------------------------------------------
# Caterpillar movement of actor is carried out on map
#==============================================================================

module Train_Actor

class Game_Party_Actor < Game_Character
 attr_writer :move_speed
 attr_writer :step_anime

 def initialize
   super()
   @through = true
 end
 def setup(actor)
   # The file name and hue of the character are set
   if actor != nil and (not actor.dead?) # When dead, it is erased for the time being...
     @character_name = actor.character_name
     @character_hue = actor.character_hue
   else
     @character_name = ""
     @character_hue = 0
   end
   # Opacity and blending method are initialized
   @opacity = 255
   @blend_type = 0
 end
 def screen_z(height = 0)
   if $game_player.x == @x and $game_player.y == @y
     return $game_player.screen_z(height) - 1
   end
   super(height)
 end
 #--------------------------------------------------------------------------
 # ● Move down
 #     turn_enabled : Flag that permits direction change on the spot
 #--------------------------------------------------------------------------
 def move_down(turn_enabled = true)
   # Face down
   if turn_enabled
     turn_down
   end
   # When possible to pass
   if passable?(@x, @y, Input::DOWN)
     # Face down
     turn_down
     # Update coordinates
     @y += 1
   end
 end
 #--------------------------------------------------------------------------
 # ● Move left
 #     turn_enabled : Flag that permits direction change on the spot
 #--------------------------------------------------------------------------
 def move_left(turn_enabled = true)
   # Face left
   if turn_enabled
     turn_left
   end
   # When possible to pass
   if passable?(@x, @y, Input::LEFT)
     # Face left
     turn_left
     # Update coordinates
     @x -= 1
   end
 end
 #--------------------------------------------------------------------------
 # ● Move right
 #     turn_enabled : Flag that permits direction change on the spot
 #--------------------------------------------------------------------------
 def move_right(turn_enabled = true)
   # Face right
   if turn_enabled
     turn_right
   end
   # When possible to pass
   if passable?(@x, @y, Input::RIGHT)
     # Face right
     turn_right
     # Update coordinates
     @x += 1
   end
 end
 #--------------------------------------------------------------------------
 # ● Move up
 #     turn_enabled : Flag that permits direction change on the spot
 #--------------------------------------------------------------------------
 def move_up(turn_enabled = true)
   # Face up
   if turn_enabled
     turn_up
   end
   # When possible to pass
   if passable?(@x, @y, Input::UP)
     # Face up
     turn_up
     # Update coordinates
     @y -= 1
   end
 end
 #--------------------------------------------------------------------------
 # ● Move lower left
 #--------------------------------------------------------------------------
 def move_lower_left
   # When no direction fixation
   unless @direction_fix
     # Turn left when facing right, turn down when facing up
     @direction = (@direction == Input::RIGHT ? Input::LEFT : @direction == Input::UP ? Input::DOWN : @direction)
   end
   # When possible to move from down→left or from left→down
   if (passable?(@x, @y, Input::DOWN) and passable?(@x, @y + 1, Input::LEFT)) or
      (passable?(@x, @y, Input::LEFT) and passable?(@x - 1, @y, Input::DOWN))
     # Update coordinates
     @x -= 1
     @y += 1
   end
 end
 #--------------------------------------------------------------------------
 # ● Move lower right
 #--------------------------------------------------------------------------
 def move_lower_right
   # When no direction fixation
   unless @direction_fix
     # Turn right when facing left, turn down when facing up
     @direction = (@direction == Input::LEFT ? Input::RIGHT : @direction == Input::UP ? Input::DOWN : @direction)
   end
   # When possible to move from down→right or from right→down
   if (passable?(@x, @y, Input::DOWN) and passable?(@x, @y + 1, Input::RIGHT)) or
      (passable?(@x, @y, Input::RIGHT) and passable?(@x + 1, @y, Input::DOWN))
     # Update coordinates
     @x += 1
     @y += 1
   end
 end
 #--------------------------------------------------------------------------
 # ● move upper left
 #--------------------------------------------------------------------------
 def move_upper_left
   # When no direction fixation
   unless @direction_fix
     # Turn left when facing right, turn up when facing down
     @direction = (@direction == Input::RIGHT ? Input::LEFT : @direction == Input::DOWN ? Input::UP : @direction)
   end
   # When possible to move from up→left or from left→up
   if (passable?(@x, @y, Input::UP) and passable?(@x, @y - 1, Input::LEFT)) or
      (passable?(@x, @y, Input::LEFT) and passable?(@x - 1, @y, Input::UP))
     # Update coordinates
     @x -= 1
     @y -= 1
   end
 end
 #--------------------------------------------------------------------------
 # ● move upper right
 #--------------------------------------------------------------------------
 def move_upper_right
   # When no direction fixation
   unless @direction_fix
     # Turn right when facing left, turn up when facing down
     @direction = (@direction == Input::LEFT ? Input::RIGHT : @direction == Input::DOWN ? Input::UP : @direction)
   end
   # When possible to move from up→right or from right→up
   if (passable?(@x, @y, Input::UP) and passable?(@x, @y - 1, Input::RIGHT)) or
      (passable?(@x, @y, Input::RIGHT) and passable?(@x + 1, @y, Input::UP))
     # Update coordinates
     @x += 1
     @y -= 1
   end
 end
end

end

tell me if it didn't work

 

[BellGoRiiing]

*bumpy*

Also thanks AJ, I'll let you know if they work properly.

As for anyone else, I have added about 1 or 2 other requests. Let me know if you can help me out there.

(...It has been 3 days...right? lol)

 

[MasterMind]

For the one where it's like Metroid Prime, check here.

It's the Bestiary you're looking for.
(I loved Metroid Prime...)

If you need help setting it up, lemme know.