shogun3 wrote:I noticed that some of you guys seem pretty skilled when it comes to scripting and eventing, so I hope you don't mind if I ask you a question regarding a feature I would like to implement in the tactical battle system I'm using (Gubid) which allows for the placement of extra party members and troops on the battlefield.
While these extra troop members are able to move/attack/die like their counterparts, I can't use conditional switches to call events when they are hit, have a state inflicted, etc. because the drop down menu only lists 8 enemies. Example: If enemy#8 has state "Hit" inflicted==>show picture 3.

Do you guys think it's impossible to do so through events?

shogun3 wrote:yeah but the sized event script actually gives u the chance to interact with more than one tile of a sprite whereas the body square thingy is just hit detection for the tools...
maybe someone can make it compatible with the newer version of xas...

Code:


#===============================================================================
# Bigger Event Interaction
#===============================================================================
# By: Mr_Wiggles
# Version: 1.0
# 2/5/13
#-------------------------------------------------------------------------------
# Events always grow to the LEFT!, odd tiled events are centered after moving
# left.
#
# Create an event with a comment in an event in the TOP 10 LINES!
#    BIGEVENT <size x> <size y>
#
#   i.e. "BIGEVENT 2 2" will make an event 2 tiles by 2 tiles large.
#===============================================================================

module BigEvent

 # INCREMENT
 Increment = 1

 def self.front_pos_large_event?(event)

  # Calculate player new position
  d = $game_player.direction
  new_x = $game_player.x + (d == 6 ? Increment : d == 4 ? -Increment : 0)
  new_y = $game_player.y + (d == 2 ? Increment : d == 8 ? -Increment : 0)

  # Calculate event offset (ie size delta)
 event_new_size = event.check_event_size
  if (event_new_size==false)
  ex, ey = 0,0
 else
ex ,ey = event_new_size
  end
  
  # Calculate event min and max coordinates
  p1, p2 = event.x - ex, event.y - ey
  p3, p4 = event.x, event.y
  plx, ply = new_x, new_y

  # Verify if player new position is inside event min and max coordinates
  if (plx >= p1 and plx <= p3) and (ply >= p2 and ply <= p4)
    return true
  else
    return false
  end
end

end


class Game_Event < Game_Character

 attr_accessor :hasBeenLift

 alias :bigev_init :initialize
 def initialize(*args)
   bigev_init(*args)
   check_event_size # run first to make sprites aligned correctly
   @hasBeenLift=false
  #File.open("debug.txt", 'a') {|f| f.write(self.inspect) } if (@newsize != false)
 end
 
def check_event_size
   return @newsize unless @newsize.nil?
   list  = @event.pages[0].list
   for i in 0..9 # check top 10 lines
     line = list[i]
     next if line.nil?
     command = line.parameters[0]
     break unless command.is_a?(String)
     next if command.nil?
     command = command.split
     if command.include?("BIGEVENT")
       sizex = command[1].to_i - 1
       sizey = command[2].to_i - 1
       #DEBUG.write("sizex="+sizex.to_s+",sizey="+sizey.to_s)        
     end
   end
   if sizex.nil? or sizey.nil?
     @newsize = false
   else
     @newsize = [sizex, sizey]
   end
   return @newsize
 end
 
def screen_x
   if @newsize.is_a?(Array)
     extra = (@newsize[0] % 2 == 0) ? -16 : 0 # even odd offset
     return (@real_x - $game_map.display_x + 3) / 4 + extra
   end
   return (@real_x - $game_map.display_x + 3) / 4 + 16
 end
end


class Game_Player < Game_Character

 alias :bigev_passable? :passable?
 def passable?(x, y, d)    
   for event in $game_map.events.values
     event_new_size = event.check_event_size
     #DEBUG.write("PASSABLE="+ (!(event.hasBeenLift == true && event.throw_active == false && event_new_size  && check_large_event(event, event_new_size, d))).to_s)
     return false if event.hasBeenLift == false && event.throw_active == false &&  event_new_size  && check_large_event(event, event_new_size, d)
   end

   #DEBUG.write("COND3="+bigev_passable?(x, y, d).to_s)
   return bigev_passable?(x, y, d)
 end

 def check_large_event(event, size, dir = nil)
   #DEBUG.write("Size:#{size} Colision with: #{event.id} and this: #{self.id}")
   ex, ey = size
   p1, p2 = event.x - ex, event.y - ey
   p3, p4 = event.x, event.y
   plx, ply = (self.x), (self.y)
   if dir != nil
     plx = plx + (dir == 6 ? 1 : dir == 4 ? -1 : 0)
     ply = ply + (dir == 2 ? 1 : dir == 8 ? -1 : 0)
   end
   #DEBUG.write("EVENT original=["+p3.to_s+","+p4.to_s+"] corrected=["+p1.to_s+","+p2.to_s+"], PLAYER origin=["+(self.x).to_s+","+self.y.to_s+"], PLAYER cible=["+plx.to_s+","+ply.to_s+"]")
   if (plx >= p1 and plx <= p3) and (ply >= p2 and ply <= p4)
    #DEBUG.write("Passable=false")
     return true
   end
   #DEBUG.write("Passable=true")
   return false # passable
end

 #--------------------------------------------------------------------------
 # ? Can Pickup?
 #--------------------------------------------------------------------------  
 def pickup_event    
   return if @pickup_lock
   return if @pickup_lock_time > 0    
  return if $game_system.map_interpreter.running?
   return if $game_switches[XASTHROW_ACTIVE_SWITCH_ID] == false
   #return if $game_switches[76] = true
return if jumping?
  return if @swimming
   return if $game_temp.cast_time > 0

    $game_map.events.each_value do |event|
       front_pos = BigEvent::front_pos_large_event?(event)        
       #DEBUG.write("pickup_event[" + event.id.to_s + "] front_pos=" + front_pos.to_s)
       if front_pos
          next if event.throw == 0
         next if event.erased
          next if event.collapsing?
          next if event.through
          next if event.throw_weight > @throw_weight_max.to_i
          if event.battler != nil and not event.battler.e_item
             next if event.battler.dead?
             $game_temp.carry_time = Graphics.frame_rate * XAS::ENEMY_CARRY_TIME
             event.blow(0,0)
          end
         @pickup_lock_time = 15
          event.throw_active = true
          #LEPAS33
          event.hasBeenLift=true
 $throw_active=true
          @pickup_lock = true
          @need_refresh_pose = true
           #Baf Edit : Added lift SE
          $game_system.se_play(XAS::LIFT_SE)
          event.jump(0,0)
          event.x = @x
          event.y = @y
          event.pre_move_speed = event.move_speed
          event.move_speed = 7
       end
   end  
 end
end


Code:


#===============================================================================
# Bigger Event Interaction
#===============================================================================
# By: Mr_Wiggles
# Version: 1.0
# 2/5/13
#-------------------------------------------------------------------------------
# Events always grow to the LEFT!, odd tiled events are centered after moving
# left.
#
# Create an event with a comment in an event in the TOP 10 LINES!
#    BIGEVENT <size x> <size y>
#
#   i.e. "BIGEVENT 2 2" will make an event 2 tiles by 2 tiles large.
#===============================================================================
class Game_Event < Game_Character
  alias :bigev_init :initialize
  def initialize(*args)
    bigev_init(*args)
    check_event_size # run first to make sprites aligned correctly
  end
  
  def check_event_size
    return @newsize unless @newsize.nil?
    list  = @event.pages[0].list
    for i in 0..9 # check top 10 lines
      line = list[i]
      next if line.nil?
      command = line.parameters[0]
      break unless command.is_a?(String)
      next if command.nil?
      command = command.split
      if command.include?("BIGEVENT")
        sizex = command[1].to_i - 1
        sizey = command[2].to_i - 1
      end
    end
    if sizex.nil? or sizey.nil?
      @newsize = false
    else
      @newsize = [sizex, sizey]
    end
    return @newsize
  end
  
  def screen_x
    if @newsize.is_a?(Array)
      extra = (@newsize[0] % 2 == 0) ? -16 : 0 # even odd offset
      return (@real_x - $game_map.display_x + 3) / 4 + extra
    end
    return (@real_x - $game_map.display_x + 3) / 4 + 16
  end
end

#===============================================================================
class Game_Map
  def passable?(x, y, d, self_event = nil)
    # If coordinates given are outside of the map
    unless valid?(x, y)
      # impassable
      return false
    end
    # Change direction (0,2,4,6,8,10) to obstacle bit (0,1,2,4,8,0)
    bit = (1 << (d / 2 - 1)) & 0x0f
    # Loop in all events
    for event in events.values
      #-------------------------------------
      # New method
      # If tiles other than self are consistent with coordinates
      if event.tile_id >= 0 and event != self_event and !event.through
        temp = false
        use_new = event.check_event_size
        if !self_event.nil? and use_new
          temp = self_event.check_large_event(event, use_new, d)
          #print("Map: #{temp}")
        else
          temp = (event.x == x and event.y == y)
        end
        if temp
          # If obstacle bit is set
          if @passages[event.tile_id] & bit != 0
            # impassable
            return false
          # If obstacle bit is set in all directions
          elsif @passages[event.tile_id] & 0x0f == 0x0f
            # impassable
            return false
          # If priorities other than that are 0
          elsif @priorities[event.tile_id] == 0
            # passable
            return true
          end
        end
      end
      #-------------------------------------
    end
    # Loop searches in order from top of layer
    for i in [2, 1, 0]
      # Get tile ID
      tile_id = data[x, y, i]
      # Tile ID acquistion failure
      if tile_id == nil
        # impassable
        return false
      # If obstacle bit is set
      elsif @passages[tile_id] & bit != 0
        # impassable
        return false
      # If obstacle bit is set in all directions
      elsif @passages[tile_id] & 0x0f == 0x0f
        # impassable
        return false
      # If priorities other than that are 0
      elsif @priorities[tile_id] == 0
        # passable
        return true
      end
    end
    # passable
    return true
  end
end

#===============================================================================
class Game_Character
  def passable?(x, y, d)
    # Get new coordinates
    new_x = x + (d == 6 ? 1 : d == 4 ? -1 : 0)
    new_y = y + (d == 2 ? 1 : d == 8 ? -1 : 0)
    # If coordinates are outside of map
    return false if !$game_map.valid?(new_x, new_y)
    # If through is ON
    return true if @through
    # If unable to leave first move tile in designated direction
    return false if !$game_map.passable?(x, y, d, self)
    # If unable to enter move tile in designated direction
    return false unless $game_map.passable?(new_x, new_y, 10 - d)
    # Loop all events
    #-------------------------------------
    # new method
    for event in $game_map.events.values
      temp = false
      use_new = event.check_event_size
      if use_new
        temp = check_large_event(event, use_new, d)
        #print("Character: #{temp}")
      else
        temp = (event.x == new_x and event.y == new_y)
      end
      if temp
       return false if event.character_name != ""
        return false if (self != $game_player and !event.through)
      end
    end
    #-------------------------------------
    if $game_player.x == new_x and $game_player.y == new_y
      return false if (@character_name != "" and !$game_player.through)
    end
    # passable
    return true
  end
  #--------------------------------------------------------------------------
  # New Definition
  def check_large_event(event, size, dir = nil)
    #print("Size:#{size} Colision with: #{event.id} and this: #{self}")
    ex, ey = size
    p1, p2 = event.x - ex, event.y - ey
    p3, p4 = event.x, event.y
    plx, ply = self.x, self.y
    if dir != nil
      plx = plx + (dir == 6 ? 1 : dir == 4 ? -1 : 0)
      ply = ply + (dir == 2 ? 1 : dir == 8 ? -1 : 0)
    end
    if (plx >= p1 and plx <= p3) and (ply >= p2 and ply <= p4)
      #print("SizeX: #{p1},#{plx},#{p3} SizeY: #{p2},#{ply},#{p4} ")
      return true
    end
    return false # passable
 end
end

#===============================================================================
class Game_Player < Game_Character
  #--------------------------------------------------------------------------
  def check_event_trigger_here(triggers)
    result = false
    # If event is running
   return result if $game_system.map_interpreter.running?
    # All event loops
    for event in $game_map.events.values
    #-------------------------------------
    # new method
      # If event coordinates and triggers are consistent
      if triggers.include?(event.trigger)
        temp = false
        use_new = event.check_event_size
        if use_new
          temp = check_large_event(event, use_new)
          #print("Player Here: #{temp}")
        else
          temp = (event.x == @x and event.y == @y)
        end
        if temp and !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 event is running
    return result if $game_system.map_interpreter.running?
    # Calculate front event coordinates
    new_x = @x + (@direction == 6 ? 1 : @direction == 4 ? -1 : 0)
    new_y = @y + (@direction == 2 ? 1 : @direction == 8 ? -1 : 0)
    # All event loops
    for event in $game_map.events.values
    #-------------------------------------
    # new method
      temp = false
      if triggers.include?(event.trigger)
        use_new = event.check_event_size
        if use_new
          temp = check_large_event(event, use_new, @direction)
        else
          temp = (event.x == new_x and event.y == new_y)
        end
        # If starting determinant is front event
        if temp and !event.jumping? and !event.over_trigger?
          event.start
          result = true
        end
      end
    #-------------------------------------
    end
    # If fitting event is not found
    if result == false
      # If front tile is a counter
      if $game_map.counter?(new_x, new_y)
        # Calculate 1 tile inside coordinates
        new_x += (@direction == 6 ? 1 : @direction == 4 ? -1 : 0)
        new_y += (@direction == 2 ? 1 : @direction == 8 ? -1 : 0)
        # All event loops
        for event in $game_map.events.values
        #-------------------------------------
        # new method
          temp = false
          if triggers.include?(event.trigger)
            use_new = event.check_event_size
            if use_new
              temp = check_large_event(event, use_new, @direction)
            else
              temp = (event.x == new_x and event.y == new_y)
            end
            # If starting determinant is front event (other than jumping)
            if temp and !event.jumping? and !event.over_trigger?
              event.start
              result = true
            end
          end
        #-------------------------------------
        end
      end
    end
    return result
  end
  #--------------------------------------------------------------------------
  def check_event_trigger_touch(x, y)
    result = false
    # If event is running
    return result if $game_system.map_interpreter.running?
    # All event loops
    for event in $game_map.events.values
    #-------------------------------------
    # new method
      temp = false
      if [1,2].include?(event.trigger)
        use_new = event.check_event_size
        if use_new
          temp = check_large_event(event, use_new)
        else
          temp = (event.x == x and event.y == y)
        end
        # If starting determinant is front event (other than jumping)
        if temp and !event.jumping? and !event.over_trigger?
          event.start
          result = true
        end
      end
    #-------------------------------------
    end
    return result
  end
end