#-------------------------------------------------------------------------------
#
#                          Stealth Detection System v 1.0
#                    code by cmpsr2000 @ rpgrevolution.com/forums
#                              Released June 11, 2008
#
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
#
# SDS is an advanced stealth detection system for use in RPG Maker VX games.
# To use the system, you need to build an event that begins with a script call:
#
#  $game_stealth.detector(eventID, detectRange, detectAction,
#                          tunnelVision, trueSight)
#
#  eventID:        l'ID de l'event. mettez @event_id pour eviter de configurer a chaque fois.
#  detectRange:    Distance à laquelle le garde peut voir

#  detectAction:  le mode de detection des gardes
#                  PAR DEFAUT : Mode 1 (GameOver)
#                  0: Téléportation
#                  1: Game Over
#                  2: Executer evenement commun
#                  3: MGS Mode
#  tunnelVision:  Le champ de vision se fait en ligne droite
#                  PAR DEFAUT = false
#  trueSight:    Le garde voit a travers les murs
#                  PAR DEFAUT = false
#
#
#                      EXPLICATION DU MGS MODE:
#
#      Lorsque vous utilisez le mode 3 (MGS Mode) , le garde sera "alerté"
#      par n'importe quel mouvement suspect. Le garde courra donc vers votre derniere position.
#      Le garde regardera autour de lui, et, si il vous trouve, l'action défini dans "Capture_Action" s'execute.
#
#-------------------------------------------------------------------------------
class Game_Stealth
 
  attr_accessor :common_event_id
 
  def initialize
    @checkedTiles  = []
    @fovPassability = {}
    @detectingEvent = nil
    @tempInterpreter = nil
    @alertedGuards = []
   
    #---------------------------------------------------------------------------
    # Si vous utilisez le tunnel vision, vous pouvez définir ici la largeur
    # du couloir. ATTENTION, le nombre doit etre un nombre IMPAIR !
    #
    #---------------------------------------------------------------------------
    @tunnelWidth = 3
   
    #---------------------------------------------------------------------------
    # Si vous utilisez le mode 2 (Evenement commun) Entrez l'ID de l'event ici.
    #---------------------------------------------------------------------------
    @common_event_id = 1
   
    #---------------------------------------------------------------------------
    # Vitesse et fréquence des gardes dans le
    # MGS mode.
    #  Vitesse:      1: Tres lent,
    #              2: Lent
    #              3: Modéré
    #              4: Normal
    #              5: Rapide
    #              6: Très rapide
    #
    #  frequency:  1: La plus basse
    #              2: Basse
    #              3: Normale
    #              4: Grande
    #              5: Maximum
    #---------------------------------------------------------------------------
    @guardInterceptSpeed = 4
    @guardInterceptFrequency = 5
   
    #---------------------------------------------------------------------------
    # Definissez ici l'action a effectuer lorsque le garde
    # Repere le héros.
    #  captureAction:  0: Téléportation
    #                  1: Game Over
    #                  2: Evenement commun
    #---------------------------------------------------------------------------
    @captureAction = 1
   
    #---------------------------------------------------------------------------
    # Intervalle de temps entre chaque mouvement lorsque
    # le garde cherche le heros dans le MGS mode.
    #---------------------------------------------------------------------------
    @waitTime = 60
   
    #---------------------------------------------------------------------------
    # Mettez le en "false" et la vision derriere le garde sera désactivé
    # Cela signifie que vous pouvez marcher derriere le garde sans qu'il
    # s'en apercoive.
    #---------------------------------------------------------------------------
    @allowDetectRadius= true

    @tunnelWidth += 1 if (@tunnelWidth % 2) == 1
  end
 
  #-----------------------------------------------------------------------------
  # LA CONFIGURATION S'ARRETE ICI
  #-----------------------------------------------------------------------------
  def update
    if $game_player.detected and not $game_player.moving?
      doDetectAction
    end
    for guard in @alertedGuards
      case guard.detectState
      when nil, 0 #alerted
        guard.lock
        guard.returnX          = guard.x
        guard.returnY          = guard.y
        guard.returnRoute      = guard.move_route
        guard.returnRouteIndex  = guard.move_route_index
        guard.returnSpeed      = guard.move_speed
        guard.returnFrequency  = guard.move_frequency
        guard.move_speed        = @guardInterceptSpeed
        guard.move_frequency    = @guardInterceptFrequency
        guard.isAware = false
        guard.detectState = guard.goto($game_player.x, $game_player.y) ? 1 : 3
        guard.unlock
      when 1 #intercepting
        if (guard.move_route_index == guard.move_route.list.length - 1 and
          guard.stopping?) or guard.move_failed
          guard.lock
          guard.isAware = true
          guard.spinInPlace(@waitTime)
          guard.detectState = 2
          guard.unlock
        end
      when 2 #checking
        if guard.move_route_index == guard.move_route.list.length - 1 and
          guard.stopping?
          guard.lock
          guard.isAware = false
          go = guard.goto(guard.returnX, guard.returnY)
          guard.detectState = 3
          guard.unlock
        end
      when 3 #returning
        if guard.move_route_index == guard.move_route.list.length - 1 and not
          guard.moving?
          guard.lock
          guard.isAware = true
          guard.move_route        = guard.returnRoute
          guard.move_route_index  = guard.returnRouteIndex
          guard.move_speed        = guard.returnSpeed
          guard.move_frequency    = guard.returnFrequency
          guard.detectState      = 0
          @captured = false
          @alertedGuards.delete(guard)
          guard.unlock
        end
      end
    end
    observe
  end
  #-----------------------------------------------------------------------------
  # Runs through the aware events(guards) on the map and tells them to check
  # for the player.
  #-----------------------------------------------------------------------------
  def observe
    for event in $game_map.events.values #events is a hash!
      if event.isAware
        if event.moved? or event.turned? or $game_player.moved?
          if checkForDetection(event)
            $game_player.detected = true
            @detectingEvent = event
            return
          end
        end
      end
      @checkedTiles  = []
      @fovPassability = {}
    end
  end
  #-----------------------------------------------------------------------------
  # Runs through each tile in the event(guard)'s field of view and checks
  # it for the player. RETURNS: Boolean
  #  event:    The guard that is currently checking for the player.
  #-----------------------------------------------------------------------------
  def checkForDetection(event)
    return true if playerInDetectionRadius(event)
    return false if playerOutOfRange(event)
    fieldOfView = event.tunnelVision ? @tunnelWidth : 1
    for distance in 1..event.detectRange
      for width in 1..fieldOfView
        return true if checkTile(event, width, distance)
      end
      fieldOfView += 2 unless event.tunnelVision
    end
    return false
  end

  #-----------------------------------------------------------------------------
  # Checks a tile for the player. RETURNS: Boolean
  #  event:    The guard that is currently checking for the player.
  #  width:    The width-index of the tile being checked
  #  distance: The depth-index of the tile being checked
  #-----------------------------------------------------------------------------
  def checkTile(event, width, distance)
    if event.tunnelVision
      if @tunnelWidth > 1
        width = width - ((@tunnelWidth - 1)/2)
      else
        width = 0
      end
    else
      width -= distance
    end
    x = event.x
    y = event.y
    direction = event.direction
    case direction
    when 2
      y += distance
      x += width
    when 4
      y += width
      x -= distance
    when 6
      y += width
      x += distance
    when 8
      y -= distance
      x += width
    end
    return false if @checkedTiles.index([x,y]) != nil
    return false if tileHidden?(event, x, y)
    return true if $game_player.x == x and $game_player.y == y
    return false
  end
  #-----------------------------------------------------------------------------
  # Determines the visibility of a tile to a guard. RETURNS: Boolean
  #  event:    The guard that is currently checking for the player.
  #  x:        The x coordinate of the tile to be checked
  #  y:        The y coordinate of the tile to be checked
  #-----------------------------------------------------------------------------
  def tileHidden?(event, x, y)
    return false if event.trueSight
    #check the current tile first
    @checkedTiles.push([x,y])
    originalX = x
    originalY = y
    if not $game_map.passable?(x, y)
      @fovPassability[[x,y]] = false
      return true
    end
   
    #now check all adjacent tiles one step closer to the detector
    direction = event.direction
    case direction
    when 2 #down
      y -= 1
      for i in (x-1)..(x+1)
        #if we've checked the tile, then it exists in the FoV
        if @checkedTiles.index([i,y]) != nil
          if not @fovPassability[[i,y]]
            @fovPassability[[originalX,originalY]] = false
            return true
          end
        end
      end
    when 4 #left
      x += 1
      for i in (y-1)..(y+1)
        #if we've checked the tile, then it exists in the FoV
        if @checkedTiles.index([x,i]) != nil
          if not @fovPassability[[x,i]]
            @fovPassability[[originalX,originalY]] = false
            return true
          end
        end
      end
    when 6 #right
      x -= 1
      for i in (y-1)..(y+1)
        #if we've checked the tile, then it exists in the FoV
        if @checkedTiles.index([x,i]) != nil
          if not @fovPassability[[x,i]]
            @fovPassability[[originalX,originalY]] = false
            return true
          end
        end
      end
    when 8 #up
      y += 1
      for i in (x-1)..(x+1)
        #if we've checked the tile, then it exists in the FoV
        if @checkedTiles.index([i,y]) != nil
          if not @fovPassability[[i,y]]
            @fovPassability[[originalX,originalY]] = false
            return true
          end
        end
      end
    end
   
    #this tile and the blocking tiles must be passable
    @fovPassability[[originalX,originalY]] = true
    return false
  end
  #-----------------------------------------------------------------------------
  # Guards and other "detector" events have an awareness of their immediate
  # surroundings. If the player is adjacent to the event, they will be
  # discovered if @allowDetectRadius is true. RETURNS: Boolean
  #  event:    The guard that is currently checking for the player.
  #-----------------------------------------------------------------------------
  def playerInDetectionRadius(event)
    return false unless @allowDetectRadius
    adjacentTiles = [ [event.x, event.y - 1],
                      [event.x + 1, event.y - 1],
                      [event.x + 1, event.y],
                      [event.x + 1, event.y + 1],
                      [event.x, event.y + 1],
                      [event.x - 1, event.y + 1],
                      [event.x - 1, event.y],
                      [event.x - 1, event.y - 1] ]
    for tile in adjacentTiles
      if $game_player.x == tile[0] and $game_player.y == tile[1]
        return true
      end
    end
    return false
  end
 
  def playerOutOfRange(event)
    direction = event.direction
    case direction
    when 2 #down
      yDifference = event.y - $game_player.y
      xDifference = event.x - $game_player.x
      coneWidth = event.tunnelVision ? (@tunnelWidth / 2).floor : event.detectRange - 1
      if yDifference > event.detectRange or $game_player.y < event.y - 1 or
        (xDifference.abs > coneWidth)
        return true
      end
    when 4 #left
      yDifference = event.y - $game_player.y
      xDifference = event.x - $game_player.x
      coneWidth = event.tunnelVision ? (@tunnelWidth / 2).floor : event.detectRange - 1
      if xDifference > event.detectRange or $game_player.x > event.x + 1 or
        (yDifference.abs > coneWidth)
        return true
      end
    when 6 #right
      yDifference = $game_player.y - event.y
      xDifference = $game_player.x - event.x
      coneWidth = event.tunnelVision ? (@tunnelWidth / 2).floor : event.detectRange - 1
      if xDifference > event.detectRange or $game_player.x < event.x - 1 or
        (yDifference.abs > coneWidth)
        return true
      end
    when 8 #up
      yDifference = event.y - $game_player.y
      xDifference = event.x - $game_player.x
      coneWidth = event.tunnelVision ? (@tunnelWidth / 2).floor : event.detectRange - 1
      if yDifference > event.detectRange or $game_player.y > event.y + 1 or
        (xDifference.abs > coneWidth)
        return true
      end
    end
    return false
  end
  #-----------------------------------------------------------------------------
  # Called in an event to enable detection for the event (guard).
  #  eventID:      The id of the event. use @event_id in your event call!
  #  detectRange:  How far away the guard can see
  #  detectAction: What happens when caught. defaults to game_over
  #  tunnelVision: Whether the guard has field of view or tunnel vision
  #  trueSight:    Whether the guard can see through objects
  #-----------------------------------------------------------------------------
  def detector(eventID, detectRange, detectAction = 1,
              tunnelVision = false, trueSight = false)
    event              = $game_map.events[eventID]
    event.isAware      = true
    event.detectAction  = detectAction
    event.detectRange  = detectRange
    event.tunnelVision  = tunnelVision
    event.trueSight    = trueSight
    event.setPosition
  end
  #-----------------------------------------------------------------------------
  # Called in an event to set the location tile of the "jail"
  #  eventID:  The ID of the event that is at the jail location.
  #              Again, use @event_id
  #-----------------------------------------------------------------------------
  def jail(eventID)
    event = $game_map.events[eventID]
    @jailX      = event.x
    @jailY      = event.y
  end
  #-----------------------------------------------------------------------------
  # Executes the desired action upon detecting the player
  #-----------------------------------------------------------------------------
  def doDetectAction
    case @detectingEvent.detectAction
    when 0 # goto jail
      sendToJail
    when 1 # game over
      $scene = Scene_Gameover.new
    when 2 # execute common event
      doCommonEvent
    when 3 # MGS - enemy moves towards player position
      if @detectingEvent.detectState == 2
        if not @captured
          case @captureAction
          when 0
            sendToJail
          when 1, 3
            gameOver
          when 2
            doCommonEvent
          end
          @captured = true
        end
      else
        Sound.play_found
        @detectingEvent.balloon_id = 1
        unless @alertedGuards.include?(@detectingEvent)
          @alertedGuards.push(@detectingEvent)
        end
      end
    end
    $game_player.detected = false
    @detectingEvent = nil
  end
  #-----------------------------------------------------------------------------
  # MODE 0: Send player to the "jail" tile
  #-----------------------------------------------------------------------------
  def sendToJail
      $game_player.reserve_transfer($game_map.map_id, @jailX, @jailY,
                                    @detectingEvent.direction)
  end
  #-----------------------------------------------------------------------------
  # MODE 1: Game Over
  #-----------------------------------------------------------------------------
  def gameOver
    $scene = Scene_Gameover.new
  end
  #-----------------------------------------------------------------------------
  # MODE 2: Execute Common Event
  #-----------------------------------------------------------------------------
  def doCommonEvent
      $game_temp.common_event_id = @common_event_id
  end
end

#-------------------------------------------------------------------------------
# Son joué lorsque le héros est repéré
#-------------------------------------------------------------------------------
module Sound
  def self.play_found
    Audio.se_play("Audio/SE/found.wav", 100, 150)
  end
end
#-------------------------------------------------------------------------------
# This contains command for object movement and can be reused and included in
# any game_character or it's descendants.
#-------------------------------------------------------------------------------
module Movement
  #-----------------------------------------------------------------------------
  # Checks to see whether this object has moved since the last check.
  # RETURNS: Boolean
  #-----------------------------------------------------------------------------
  def moved?
    if self.x != @oldX or self.y != @oldY
      setPosition
      return true
    else
      return false
    end
  end
  #-----------------------------------------------------------------------------
  # Checks to see whether this object has turned.
  # RETURNS: Boolean
  #-----------------------------------------------------------------------------
  def turned?
    if self.direction != @oldDirection
      setDirection
      return true
    else
      return false
    end
  end
  #-----------------------------------------------------------------------------
  # Saves the current direction so that it can be checked against after a turn
  #-----------------------------------------------------------------------------
  def setDirection
    @oldDirection = self.direction
  end
  #-----------------------------------------------------------------------------
  # Saves the current position so that it can be checked against after a move
  #-----------------------------------------------------------------------------
  def setPosition
    @oldX = self.x
    @oldY = self.y
  end
  #-----------------------------------------------------------------------------
  # Changes the object's route to perform an in-place spin while waiting after
  # each turn. It is recommended to call object.lock before using this, and
  # call object.unlock when it has complete.
  #-----------------------------------------------------------------------------
  def spinInPlace(waitTime)
    spinRoute = RPG::MoveRoute.new
    spinRoute.repeat = false
    spinRoute.wait = true
    for x in 0..3
      spinRoute.list.push(RPG::MoveCommand.new(15, [waitTime]))
      spinRoute.list.push(RPG::MoveCommand.new(16 + x))
    end
    spinRoute.list.push(RPG::MoveCommand.new(15, [waitTime]))
    spinRoute.list.push(RPG::MoveCommand.new(0))
    spinRoute.list.delete_at(0) #weird RGSS Anomoly, must delete empty position
   
    self.move_route = spinRoute
    self.move_route_index = 0
  end
  #-----------------------------------------------------------------------------
  # This is an advanced pathfinding algorithm that returns a boolean indicating
  # whether or not it was able to find a path from the start point (the object's
  # current location) to the endpoint, then changes the object's move values
  # to initiate movement. RETURNS: Boolean
  #  finalX:  x coordinate of the destination
  #  finalY:  y coordinate of the destination
  #-----------------------------------------------------------------------------
  def goto(finalX, finalY)
    return true if self.x == finalX and self.y == finalY
    startX = self.x
    startY = self.y
   
    #figure out the route: A* algorithm
    @activeList = []
    @activeParents = []
    @activeScores = []
    @closedList = []
    @closedParents = []
    @closedScores = []
    @activeList.push([startX, startY])
    @activeParents.push([startX, startY])
    @activeScores.push([0,0,0])
    noPath = false
    finalNode = [finalX, finalY]
   
    #main logic
    while @closedList.index(finalNode) == nil
      nodeToCheck = @activeList[0]  #lowest F is always in position 0!
      if nodeToCheck == nil
        noPath = true
        break
      end
      moveToClosed(nodeToCheck)
      for node in adjacentNodes(nodeToCheck) #a "node" is an array: [x, y] !!!
        if ($game_map.passable?(node[0], node[1]) and
          @closedList.index(node) == nil) or node == finalNode
          index = @activeList.index(node)
          if index == nil
            scores = calcScores(node, nodeToCheck, finalNode)
            insertionPoint = findInsertionPoint(scores[0])
            @activeList.insert(insertionPoint, node)
            @activeParents.insert(insertionPoint, nodeToCheck)
            @activeScores.insert(insertionPoint, scores)
          else
            g = calcG(nodeToCheck)
            if g < @activeScores[index][1]
              @activeParents[index] = nodeToCheck
              h = @activeScores[index][2]
              f = g + h
              @activeScores[index] = [f, g, h]
              insertionPoint = findInsertionPoint(@activeScores[index][0])
             
              #we don't need to reinsert if we already exist in the right place
              if insertionPoint != index
                tempNode  = @activeList[index]
                tempParent = @activeParents[index]
                tempScores = @activeScores[index]
               
                #delete existing
                @activeList.delete(tempNode)
                @activeParents.delete(tempParent)
                @activeScores.delete(tempScores)
               
                #reinsert
                @activeList.insert(insertionPoint, tempNode)
                @activeParents.insert(insertionPoint, tempParent)
                @activeScores.insert(insertionPoint, tempScores)
              end
            end
          end
        end
      end
    end
   
    #return if there is no path, otherwise build the path
    return false if noPath
    path = [finalNode]
    parent = @closedParents[@closedList.index(finalNode)]
    while parent != [startX, startY]
      path.push(parent)
      parent = @closedParents[@closedList.index(parent)]
    end
    path.reverse! #put the path in order of execution
   
    #make a new route object that doesn't repeat (one time use only!)
    gotoRoute = RPG::MoveRoute.new
    gotoRoute.repeat = false
   
    #itterate through the path and add the appropriate commands to the route
    #we can't move diagonal, so only one x or one y should change between steps
    lastNode = [startX, startY]
    for node in path
      if node[0] > lastNode[0]
        commandCode = 3 # move right
      elsif node[0] < lastNode[0]
        commandCode = 2 # move left
      else
        if node[1] > lastNode[1]
          commandCode = 1 # move down
        elsif node[1] < lastNode[1]
          commandCode = 4 # move up
        end
      end
      lastNode = node
      gotoRoute.list.push(RPG::MoveCommand.new(commandCode))
    end
    gotoRoute.list.push(RPG::MoveCommand.new(0))
    gotoRoute.list.delete_at(0) #weird RGSS Anomoly, must delete empty position
   
    #set the object's route and return!
    self.move_route = gotoRoute
    self.move_route_index = 0
    return true
  end
  #-----------------------------------------------------------------------------
  # moves the active node to the closed list so it's not checked twice!
  #-----------------------------------------------------------------------------
  def moveToClosed(activeNode)
    index = @activeList.index(activeNode)
   
    #add to closed
    @closedList.push(@activeList[index])
    @closedParents.push(@activeParents[index])
    @closedScores.push(@activeScores[index])
   
    #delete from active
    @activeList.delete_at(index)
    @activeParents.delete_at(index)
    @activeScores.delete_at(index)
  end
  #-----------------------------------------------------------------------------
  # finds the array insertion point based on the f score
  #-----------------------------------------------------------------------------
  def findInsertionPoint(f)
    insertionPoint = 0
    if @activeList.length != 0
      while insertionPoint < @activeList.length
        if f <= @activeScores[insertionPoint][0]
          break
        else
          insertionPoint += 1
        end
      end 
    end
   
    return insertionPoint
  end
  #-----------------------------------------------------------------------------
  # calculates all the scores for a node
  #-----------------------------------------------------------------------------
  def calcScores(node, parentNode, finalNode)
    h = calcH(node, finalNode)
    g = calcG(parentNode)
    f = g + h
   
    return [f, g, h]
  end
  #-----------------------------------------------------------------------------
  # calculates the G value (route distance)
  #-----------------------------------------------------------------------------
  def calcG(parentNode)
    #can't move diagonly: just add 1 to parent score
    index = @closedList.index(parentNode)
    score = @closedScores[index][1] + 1
    return score
  end
  #-----------------------------------------------------------------------------
  # claculates the H value (distance from start to finish)
  #-----------------------------------------------------------------------------
  def calcH(node, finalNode)
    #Manhattan method is admissible in this context
    score = (node[0] - finalNode[0]).abs + (node[1] - finalNode[1]).abs
   
    return score
  end
  #-----------------------------------------------------------------------------
  # Finds the adjacent nodes of the active node
  #-----------------------------------------------------------------------------
  def adjacentNodes(sourceNode)
    node1 = [sourceNode[0] + 1, sourceNode[1]]
    node2 = [sourceNode[0], sourceNode[1] + 1]
    node3 = [sourceNode[0] - 1, sourceNode[1]]
    node4 = [sourceNode[0], sourceNode[1] - 1]
    return [node1, node2, node3, node4]
  end
end
#-------------------------------------------------------------------------------
# the instance of $game_stealth needs to be created
#-------------------------------------------------------------------------------
class Scene_Title < Scene_Base
  alias oldCreateGameObjectsStealth create_game_objects 
  def create_game_objects
    oldCreateGameObjectsStealth
    $game_stealth = Game_Stealth.new
  end
end
#-------------------------------------------------------------------------------
# The stealth system needs to be updated every frame along with the map scene
#-------------------------------------------------------------------------------
class Scene_Map < Scene_Base
  alias oldUpdateStealth update
  def update
    oldUpdateStealth
    unless $game_message.visible      # Unless displaying a message
      $game_stealth.update
    end
  end
end

class Game_Player < Game_Character
  include Movement
  attr_accessor :detected
end
#-------------------------------------------------------------------------------
# Events have tons of new attributes with the stealth system. Plus, we need to
# include the movement module and initialize awareness to false.
#-------------------------------------------------------------------------------
class Game_Event < Game_Character
  include Movement
 
  #for all stealth
  attr_accessor :isAware
  attr_accessor :detectRange
  attr_accessor :tunnelVision
  attr_accessor :trueSight
  attr_accessor :detectAction
  attr_accessor :originalAction
 
  #For MGS-style stealth
  attr_accessor :move_speed
  attr_accessor :move_frequency
  attr_accessor :detectState
  attr_accessor :move_route_index
  attr_accessor :move_route
  attr_accessor :returnX
  attr_accessor :returnY
  attr_accessor :returnRoute
  attr_accessor :returnRouteIndex
  attr_accessor :returnSpeed
  attr_accessor :returnFrequency
  attr_reader  :move_failed
 
  alias oldInitStealth initialize
  def initialize(map_id, event)
    oldInitStealth(map_id, event)
    @isAware = false
  end
end