Ruby Quellcode

#==============================================================================
# Sichtweite plus Sichtblockevents Script
# "Hide and Seek" - Script
#------------------------------------------------------------------------------
# By Hüpfende Kokosnuss || Jumping Coconut 
# 8. June 2009,  Version 2.1
#==============================================================================
=begin
 
                            Deutsche Erkärung
                            =================
 
Dieses Skript sorgt dafür, dass ihr eine Art Versteckspiel
ganz einfach basteln könnt. Wie z.B. bei Zelda Ocarina of Time oder in 
etlichen anderen Spielen. Das Prinzip hierbei ist immer:
Der Spieler darf von den Events nicht gesehen werden, kann sich aber
hinter gewissen Gegenständen verstecken.
Es gibt hier 2 Arten von Events, die neuerdings sogar Kombiniert werden
können:
 
Seek-Events ("Suchende Events"): Diese Events "suchen" den Spieler.
                                 Wenn sie den Spieler sehen, starten sie sich.
                                 Man kann bei Seekern viele Dinge einstellen, 
                                 zum Beispiel die Sichtweite.
Hide-Events ("Versteck-Events"): Steht ein Hide-Event zwischen dem Spieler 
                                 und einem Seek-Event, so wird das Seek-Event
                                 den Spieler nicht "sehen" und kann sich somit
                                 nicht starten.
 
Außerem kann man Terrain-Tags einstellen, welche die selben Fähigkeiten wie
ein Hide-Event haben (etwa ein Baum).
 
 
Allgemeines zur Definition von Hide- und Seek-Events
----------------------------------------------------
 
Hide- und Seek-Events definiert man durch den Eventnamen (gilt dann für alle
Eventseiten) oder durch Kommentare auf einer Eventseite (gilt dann nur für 
die entsprechende Eventseite). Hier nimmt man auch alle Einstellungen, wie
zum Beispiel Sichtweite und Sichtwinkel, vor.
Der Eventname muss immer angepasst werden. Entweder man nimmt die Einstellungen
direkt im Eventnamen vor, oder der Eventname muss ein Schlüsselwort für 
Kommentare enthalten. Nur Events, deren Namen dieses Kommentar-Schlüsselwort
enthält, werden auf ihre Kommentare hin untersucht.
Beispiele von Eventnamen für Hide- and Seekevents:
 
 
Eventname:  Hide Seek 5 90 7
             |     |   \ | /
             |     |  Reaktionszeit 5 Sek., Sichtwinkel 90°, Sichtweite 7 Tiles
             |   Event ist ein Seeker (löst sich aus, wenn es den Spieler sieht)
            Event ist undurchsichtig für andere Seeker
 
 
Eventname:  Bla bla Event bla Comment:5 bla bla
                   |             |
             Sinnloser Kram      |
                      Hide- and Seekanweisungen befinden sich in Kommentaren
                      auf den jeweiligen Eventseiten, die 2 gibt an, dass der
                      jeweilige Kommentar sich innerhalb der ersten 5 
                      Eventbefehle befindet
 
 
Die selben Befehle wie für Eventnamen können auch für Kommentare verwendet 
werden. Zu beachten hierbei ist, dass bei Kommentaren alle Befehle in EINER
Kommentarzeile stehen müssen!
Die Reihenfolge ist egal, außer bei Reaktionszeit, Sichtwinkel und Sichtweite.
Diese müssen, wenn sie überhaupt angegeben werden, IMMER die letzten 3 Werte
bilden. Zuerst wird die Reaktionszeit angegeben (ist 0 wenn sie fehlt), dann
der Sichtwinkel, dann die Sichtweite. Siehe hierzu auch das erste Beispiel.
Folgende Schlüsselworte können angegeben werden:
  - Hide     = Event ist ein Hide-Event, also blockiert es die Sicht der Seeker.
  - Seek     = Event ist ein Seeker, löst also aus, wenn Spieler in Sichtweite.
  - Circle   = Event sieht in Sichtkreisen (nicht in Sichtdreiecken). Besonders
               nützlich wenn dabei ein Sichtwinkel von 0 angegeben wurde, 
               das ermöglicht dem Seeker nämlich, Kreisförmig in alle Richtungen
               zu schauen (gut für Sensoren, Fallen, etc).
  - Reverse  = Wenn das Seekerevent eigentlich auslösen sollte, löst es nicht
               aus, und wenn es nicht auslösen sollte, löst es aus. Gut für 
               Events, nur agieren sollen, wenn Spieler außer Sichtweite ist.
  - Comment:X= Comment beziehungsweise Comment:X gibt an, dass neben den
               Befehlen im Eventnamen auch die ersten X Befehle des Events
               nach Kommentaren gescannt werden sollen, die Hide-and Seek
               Befehle beeinhalten. Die Angabe von X ist optional, aber
               gut für die Performance!
 
Folgende Werte bilden den Schluss des Eventnamens:
  - Drittletzte Stelle = Reaktionszeit in Sekunden, Seeker-Event löst erst
                         aus, nach dem der Spieler sich bereits X Sekunden
                         im Sichtfeld befindet.
  - Zweitletzte Stelle = Sichtwinkel in Grad. Gültige Werte sind 1-179 Grad.
  - Letzte Stelle      = Sichtweite in Tiles.
 
Alle Schlüsselworte und die Positionen der Werte können unter 
"Hide and Seek SETTINGS" verändert werden.
 
 
Erstellen von "Verstecken" für den Spieler
------------------------------------------
 
Verstecke sind leicht einzurichten. Hide-Events fungieren als Sichtblocker 
(wie diese eingerichtet werden ist ja oben beschrieben).
Um Events zu sparen kann man allerdings auch bestimmte Terrain-Tags vergeben,
welche dann automatisch wie Hide-Events gehandhabt werden.
Man kann sowohl eins als auch mehrere Terrains angeben.
Einstellbar bei den SETTINGS unter: $has_hideterrain
 
 
Neue Eventbefehle (Callscripts)
-------------------------------
 
Für TRUE/FALSE Abfrage in Conditional Branch:
  has_seek(Sichtweite, Sichtwinkel, Circle, Reaktionszeit, Event-ID)
   Manuelle Seek-Abfrage für spezielles Event. Die Bedingung ist dann 
   entweder wahr, wenn der das Event den Spieler unter den entsprechenden
   Bedingungen sieht, oder falsch, wenn dies nicht der Fall ist.
   Reaktionszeit und Event-ID müssen nicht immer angegeben werden, 
   sind dann standardmäßig 0 und die ID des aktuellen Events. Beispiel hierfür:
  has_seek(5, 90, false) 
   => Sichtweite 5, Sichtwinkel 90, gilt für aktuelles Event.
 
  has_seconds_player_seen(Event-ID)
   Gibt als Zahl zurück, wie viele Sekunden der Spieler schon im Sichtfeld des
   entsprechenden Seek-Events ist. Wird die Event-ID nicht angegeben, so 
   wird das aktuelle Event genommen. Beispiel:
  has_seconds_player_seen == 10
   => Conditional Branch ist wahr, wenn der Spieler GENAU 10 Sekunden im 
      Sichtfeld des aktuellen Events ist. Ansonsten kommt der ELSE-Zweig zum 
      tragen. Funtkioniert nur bei Seekern, ist der Spieler nicht im Sichtfeld,
      wird 0 zurückgegeben.
 
Normale Eventbefehle:
  has_set_seconds_player_seen(Sekunden, Event-ID) 
   Setzt die Sekunden, die das Event mit der entsprechenden ID den Spieler schon
   gesehen hat, auf übergebenen Wert.
   Wird nichts übergeben, so setzt es die Sekunden des aktuellen Events auf 0.
  has_set_seconds_player_seen(5, 10)
   => Event mit der ID 10 sieht den Spieler jetzt seit 5 Sekunden. Kann dann
      Beispielsweise mit "has_seconds_player_seen" abgefragt werden.
 
 
Performance
-----------
 
Das Skript verbraucht nicht viel Performance, für das was es leistet. 
Generel gilt, dass Events, die über Eventnamen deklariert sind, weniger
Performance fressen.
Sind Kommentare doch unausweichlich, so sollte auf jedenfall die Funktion 
genutzt werden, den Bereich, in dem Sich der Kommentar befindet, anzugeben
(also mit Comment:X)!
Des weiteren kann man das Skript über Mapnamen an- und ausstellen.
Dann ist das Skript nur auf den Maps aktiv, die das entsprechende
Schlüsselwort beeinhalten (oder nur auf denen, die das Schlüsselwort NICHT
beeinhalten, ist Einstellbar ;D).
Hierfür muss bei den SETTINGS $has_mpkey und $has_mpcon angepasst werden.
Soll das Skript auf allen Maps aktiv sein, empfielt sich, bei $has_mpkey
einfach "" einzutragen und $has_mpcon auf true zu stellen.
 
 
Zur Kompatibilität
------------------
 
Eigentlich funktioniert dieses Skript sogar mit Pixelmovement.
Ich habe es mit f0tz!baerchens Pixelmovement 1.5 getestet, wichtig ist nur,
dass Hide and Seek unter das Pixelmovement- und über das Main- Skript 
gestellt wird.
Es ist sogar zu fast allen vorherigen Hide- and Seek Versionen 
abwärtskompatibel, so dass man alte Hide- and Seek Events nicht noch mal 
umbennen braucht. Es empfiehlt sich aber, die alten Maps trotzdem noch 
zu testen, wenn man von einer alten Hide- and Seek Version auf die aktuelle
umspringt.
 
 
Sonstiges
---------
 
Wenn ein Seek-Event weder einen Kreis noch ein Sichtdreieck bekommt (weil man
einen Winkel größer als 179 oder kleiner als 1 gewählt hat), löst es nur aus,
sobald der Spieler auf das Event drauftritt. Das würde nämlich sogar ein Blinder
merken ^_~
 
Umgekehrt: Wenn der Spieler auf einem Hide-Event steht ist er für
die Seek-Events unsichtbar. Das ist gut für "geschützte Bereiche".
 
Bei allen Schlüsselwörtern wird Groß- und Kleinschreibung nicht beachtet.
 
 
Das ganze System hört sich vielleicht kompliziert an, aber in der Demo gibts 
genug Beispiele, und wenn man sich die Erklärungen hier mal 5 Minuten
durchliest, versteht mans auch! Es ist alles sehr logisch aufgebaut.
Ich wünsche euch allen viel Spaß mit euren jeweiligen Projekten ^^
 
=end
#==============================================================================
# Erwähnt bitte "Hüpfende Kokosnuss" in den Credits.
# Please remember "Jumping Coconut || Hüpfende Kokosnuss" for your credits!
#==============================================================================
 
# ------ Hide and Seek SETTINGS ------
 
 
# - Keywords for Events -
 
# Keyword for Hide-Events
  $has_hdkey = "Hide"
# Keyword for Seek-Events
  $has_skkey = "Seek"
# Keyword for Seighting-Circle (Seek-Event only)
  $has_sckey = "Circle"
# Keyword for Revers-Function (Seek-Event only)
  $has_rvkey = "Reverse"  
# Keyword if event contains Hide-and-Seek specific comments
  $has_cmkey = "Comment"
 
# - Values for Events - 
 
# Follwoing Settings should only be changed if you're sure what you're doing.
# Position where Range is declared (1 for last, 2 for forelast, 3 for ...)
  $has_swpos = 1 
# Position where Angle is declared (1 for last, 2 for forelast, 3 for ...)
  $has_sapos = 2
# Position where Reaction Time is declared (1 for last, 2 for forelast, 3 for ...)
  $has_rtpos = 3
 
# - Other -
 
# Keyword for map ("" for no Keyword)
  $has_mpkey = ""
# TRUE if Keyword has to appear in Map-Name for making Hide and Seek active,
# FALSE if Keyword has to appear in Map-Name for turning Hide and Seek off
  $has_mpcon = true
 
# Hideterrains (these terrains will act like a Hide-Event)
# for example you can write $has_hideterrain = 1 or $has_hideterrain = [4,6,7]
  $has_hideterrain = 
 
# ------ Hide and Seek SETTINGS ------
 
 
#==============================================================================
# ** Game_Map
#------------------------------------------------------------------------------
#  Reading Event-Names for Hide and Seek - Declaration, Checking Seekers
#==============================================================================
class Game_Map
  #--------------------------------------------------------------------------
  # * Adding Public instance Variable, aliasing setup and update method
  #--------------------------------------------------------------------------
  attr_accessor :map
  alias_method(:hk_has_setup , :setup)
  alias_method(:hk_has_update, :update)
  #--------------------------------------------------------------------------
  # * After Setup, checking Event Names
  #--------------------------------------------------------------------------
  def setup(*args)
    hk_has_setup(*args)
    $hide_and_seek = nil
    if map_name.downcase.include?($has_mpkey.downcase) == $has_mpcon
      $hide_and_seek = Hide_and_Seek.new
    end
    unless $hide_and_seek == nil
      @events.each {|id, event|
        unless @map.events[id].name.downcase.include?($has_cmkey.downcase)    
          # Die Namen überprüfen, wenn keine Kommentare geprüft werden sollen
          name = @map.events[id].name.downcase
          seeker = name.include?($has_skkey.downcase)
          hideev = name.include?($has_hdkey.downcase)
          $hide_and_seek.change_unit(id, seeker, hideev)
        end
      }
      # Undurchsichtige Terrains überprüfen
      $hide_and_seek.get_terrains
      # Die Events müssen refreshed werden damit die Kommentare gelesen werden
      for event in @events.values
        event.refresh
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Map_Name  This method returns the map's name
  #--------------------------------------------------------------------------
  def map_name
    return load_data("Data/MapInfos.rxdata")[@map_id].name if @map_id != nil
  end
  #--------------------------------------------------------------------------
  # * Check Seekers each update
  #--------------------------------------------------------------------------
  def update(*args)
    hk_has_update(*args)
    if $hide_and_seek != nil
      $hide_and_seek.check_seekers 
    end
  end
end
 
#==============================================================================
# ** Game_Event
#------------------------------------------------------------------------------
#  Reading Comments for Hide and Seek - Declaration
#==============================================================================
class Game_Event
  #--------------------------------------------------------------------------
  # * Adding Public instance Variable, aliasing refresh and initialize method
  #--------------------------------------------------------------------------
  attr_accessor :hk_has_seen_player_since
  alias_method(:hk_has_refresh, :refresh)
  alias_method(:hk_has_initialize, :initialize)
  #--------------------------------------------------------------------------
  # * Object Initialization
  #     hk_has_seen_player_since : Framecount, starting at the moment when 
  #                                event could see the player          
  #--------------------------------------------------------------------------
  def initialize(*args)
    @hk_has_seen_player_since = 0
    hk_has_initialize(*args)
  end
  #--------------------------------------------------------------------------
  # * If Event hasn't got a Hide and Seek - declared Name, check if it has
  #     a Hide and Seek - declared comment (each new Page)
  #--------------------------------------------------------------------------
  def refresh
    hk_has_refresh
    if $hide_and_seek != nil
      # Gelöschte Events aus den Listen entfernen
      $hide_and_seek.change_unit(@id, false, false) if @erased
      # Kommentare prüfen wenn gewünscht
      if event_name.downcase.include?($has_cmkey.downcase) and list != nil
        # checklistsize aus dem Eventnamen lesen (Schlüsselwort:checklistsize)
        checklistsize = 0
        event_name.split.each do |namepart|
          checklistsize = namepart.split(":")[1].to_i if namepart.include?($has_cmkey)
        end
        # Im Zweifelsfall listsize als checklistsize nehmen nehmen
        if checklistsize <= 0 or (list.size-1) < checklistsize
          checklistsize = (list.size-1)
        end
        seeker = false
        hideev = false
        for i in 0..checklistsize
          if list[i].code == 108 || list[i].code == 408
            unless seeker
              seeker = list[i].parameters[0].downcase.include?($has_skkey.downcase)
            end
            unless hideev
              hideev = list[i].parameters[0].downcase.include?($has_hdkey.downcase)
            end
          end
        $hide_and_seek.change_unit(@id, seeker, hideev)
        end
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Event_Name  This method returns the events's name
  #--------------------------------------------------------------------------
  def event_name
    if $game_map != nil
      return $game_map.map.events[@id].name if @id != nil
    end
  end
end
 
#==============================================================================
# ** Hide_and_Seek
#------------------------------------------------------------------------------
#  This Class handles interaction between User and pure Mathematics
#==============================================================================
class Hide_and_Seek
  #--------------------------------------------------------------------------
  # * Object Initialization
  #     seekers : Array of EventIDs from Seeker-Events
  #     hideevs : Array of EventIDs from Hide-Events
  #     Starting HaS_Geometrie
  #--------------------------------------------------------------------------
  def initialize
    @seekers = []
    @hideevs = []
    $has_geometrie = HaS_Geometrie.new
  end
  #--------------------------------------------------------------------------
  # * Change Unit  Adds or Removes Hide- and Seekevent-IDs
  #     id   : Eventid
  #     seek : True for adding a Seeker, False for removing a Seeker
  #     hide : True for adding a Hideevent, False for removing a Hideevent
  #--------------------------------------------------------------------------
  def change_unit(id, seek, hide)
    @seekers.delete(id) unless seek == nil
    @hideevs.delete(id) unless hide == nil
    @seekers << id if seek
    @hideevs << id if hide
  end
  #--------------------------------------------------------------------------
  # *  Get Terrains  Scanning Map for Hideterrains
  #--------------------------------------------------------------------------
  def get_terrains
    @terrains = []
    terraintags = $has_hideterrain.to_a
    for x in 0..$game_map.map.width
      for y in 0..$game_map.map.height
        if terraintags.include?($game_map.terrain_tag(x,y))
          @terrains << {"x" => x, "y" => y}
        end
      end
    end
  end
  #--------------------------------------------------------------------------
  # *  Check Seekers  Reading Seek-Events over ID, filtering their 
  #                   Hide and Seek - Parameters (like seighting-distance)
  #--------------------------------------------------------------------------
  def check_seekers
    if @seekers != nil
      @seekers.each do |i|
        if $game_map.events[i] != nil
          # Je nach Sclüsselwort Eventname oder Kommentare prüfen
          unless $game_map.events[i].event_name.downcase.include?($has_cmkey.downcase)
            seekerstring = $game_map.events[i].event_name.downcase
          else
            # Herausbekommen, wie weit in die Commandlist reingeschaut werden muss
            checklistsize = $game_map.events[i].list.size-1
            $game_map.events[i].event_name.downcase.split.each do |namepart|
              checklistsize = namepart.split(":")[1].to_i if namepart.include?($has_cmkey)
            end
            # Die Commandlist durchgehen und nach entsprechendem Kommentar suchen
            for j in 0..checklistsize
              code = $game_map.events[i].list[j].code
              comment = $game_map.events[i].list[j].parameters[0]
              if (code == 108 || code == 408) and comment.downcase.include?($has_skkey.downcase)
                seekerstring = comment.downcase
                break
              end
            end
          end
          # Jetzt relevante Informationen aus Seekerstring filtern
          # Seek Befehl umkehren?
          reverse = seekerstring.include?($has_rvkey.downcase)
          # Kreisförmige Sicht aktivieren?
          circle = seekerstring.include?($has_sckey.downcase)
          seekerstring = seekerstring.split
          # Range auslesen (positionsbedingt)
          ra = seekerstring[seekerstring.size-$has_swpos].to_i
          # Sichtwinkel auslesen (positionsbedingt)
          sw = seekerstring[seekerstring.size-$has_sapos].to_i
          # Reaction Time auslesen (positionsbedingt)
          rt = seekerstring[seekerstring.size-$has_rtpos].to_i
          # Reaction Time ist in Sekunden, in Frames umrechnen
          rt *= Graphics.frame_rate
          # Abwärtskompatibilitiät v1.2 : nur über Eventnamen
          if comment == nil
            if ra == 0
              # Wert wurde von Kennzeichen mit ":" getrennt
              ra = seekerstring[seekerstring.size-$has_swpos].split(":")[1].to_i
            end
            if sw == 0
              # Sichtwinkel gabs nicht, Seeker sahen nur geradeaus (SW 1 Grad)
              sw = 1
            end
          end
          # Seek-Befehl absetzen und ins Gegenteil verkehren wenn Reverse-Schlüsselwort
          if seek2(ra, sw, i, circle) != reverse
            # Wenn in Sichtweite, den Framecount setzen falls noch nicht geschehen
            if $game_map.events[i].hk_has_seen_player_since == 0
              $game_map.events[i].hk_has_seen_player_since = Graphics.frame_count
            end
          else
             # Wenn nicht in Sichtweite, den Framecount auf 0 setzen
             $game_map.events[i].hk_has_seen_player_since = 0
          end
          # Wenn Player schon lang genug in Sichtweite ist
          if ( ( ( $game_map.events[i].hk_has_seen_player_since + rt ) <
            Graphics.frame_count ) and $game_map.events[i].hk_has_seen_player_since != 0 )
            # Starten nur wenn Event nicht läuft und nicht gelöscht ist
            unless $game_system.map_interpreter.running? or 
                   $game_map.events[i].list == nil or
                   $game_map.events[i].moving?
              $game_map.events[i].start
            end
          end
        end
      end
    end
  return true
  end
  #--------------------------------------------------------------------------
  # *  Seek2  New Seek-Method since v2.0, acts with HaS_Geometrie
  #     range  : How far the Seeker can look (Tiles)
  #     siwi   : Seighting-Triangle-Angle
  #              1-179 degrees, other values will skip Triangle-Check
  #     seeker : Seeker's Event-ID
  #     circle : Seighting-Circle with Radius range around Seeker?
  #              If Triangle and Circle are aktive, Player has to be in both
  #--------------------------------------------------------------------------
  def seek2(range, siwi, seeker, circle)
    ax = $game_map.events[seeker].real_x
    ay = $game_map.events[seeker].real_y
    px = $game_player.real_x
    py = $game_player.real_y
    blx = 0.0
    bly = 0.0
    alpha = siwi
    strecke_h = range * 128
    richtung = $game_map.events[seeker].direction
    sichtkreis = circle
    if $has_geometrie.variablen_uebergeben(ax, ay, px, py, blx, bly, alpha, strecke_h, richtung, sichtkreis)
      if $has_geometrie.spieler_in_sichtfeld #spieler ist in sichtfeld
        @hideevs.each do |id| #überprüfe ob hide event auf strecke
          blx = $game_map.events[id].real_x
          bly = $game_map.events[id].real_y
          $has_geometrie.blockpunkte_aendern(blx, bly)
          return false if $has_geometrie.hide_auf_strecke
        end
        @terrains.each do |terrain| #überprüfe ob terrain event auf strecke
          blx = terrain["x"] * 128
          bly = terrain["y"] * 128
          $has_geometrie.blockpunkte_aendern(blx, bly)
          return false if $has_geometrie.hide_auf_strecke
        end
        return true
      end
    end
    return false
  end
end
 
#==============================================================================
# ** Interpreter
#------------------------------------------------------------------------------
#  For direct Commands to Hide and Seek and old methods (compatibility)
#==============================================================================
class Interpreter
  #--------------------------------------------------------------------------
  # *  HaS Seek  Manual seek for Conditional Branch. 
  #     siwi   : Angle
  #     sw     : Seighting-Distance      
  #     circle : Circle on or off
  #     rt     : Reaction Time
  #     seek_id: Id of the seeking Event                            
  #--------------------------------------------------------------------------
  def has_seek(siwi, sw, circle = false, rt = 0, seek_id = @event_id )
    if $hide_and_seek != nil
      if $hide_and_seek.seek2(sw,siwi,seek_id,circle)
        if $game_map.events[@event_id].hk_has_seen_player_since == 0
          $game_map.events[@event_id].hk_has_seen_player_since = Graphics.frame_count
        end
        if ( ( ( $game_map.events[@event_id].hk_has_seen_player_since + rt ) <
          Graphics.frame_count ) and $game_map.events[@event_id].hk_has_seen_player_since != 0 )
          return true
        end
      else
        $game_map.events[@event_id].hk_has_seen_player_since = 0
      end
    end
    return false
  end
  #--------------------------------------------------------------------------
  # *  HaS Seconds Player Seen  Returns how many seconds the Player is seen
  #                             by the Event with the ID.
  #     eventid: ID of the Seeker (optional)
  #--------------------------------------------------------------------------
  def has_seconds_player_seen(eventid = @event_id)
    if $game_map.events[eventid].hk_has_seen_player_since == 0
      spt = 0
    else
      spt = Graphics.frame_count - $game_map.events[eventid].hk_has_seen_player_since
      spt = (spt / Graphics.frame_rate).round
    end
    return spt
  end
  #--------------------------------------------------------------------------
  # *  HaS Set Seconds Player Seen  Sets the Player-Seen-Seconds to a value.
  #     seconds: Seconds (optional)
  #     eventid: ID of the Seeker (optional)
  #--------------------------------------------------------------------------
  def has_set_seconds_player_seen(seconds = 0, eventid = @event_id)
    $game_map.events[eventid].hk_has_seen_player_since = seconds * Graphics.frame_rate
    return true
  end
  #--------------------------------------------------------------------------
  # *  Set Hide and Seek Event  Name of old Method (v1.3), 
  # *                           use is not recommed.
  #--------------------------------------------------------------------------
  def set_hideandseek_event(eventid, seek, hide)
    if $hide_and_seek != nil 
      $hide_and_seek.change_unit(eventid, seek, hide)
    end
    return true
  end
  #--------------------------------------------------------------------------
  # *  Seek  Name of the old Seek-Method which was declared at Interpreter Class
  #     sw      : Range
  #     sb      : no use anymore (was event id of the first hideevent)
  #     ab      : no use anymore (was event id of the last hideevent)
  #     seek_id : Seeker's Event-ID
  #--------------------------------------------------------------------------
  def seek(sw, sb = 0, ab = 0, seek_id = @event_id)
    if $hide_and_seek != nil
      return $hide_and_seek.seek2(sw, 1, seek_id, false)
    end
    return false
  end
end
 
#==============================================================================
# ** HaS_Geometrie
#------------------------------------------------------------------------------
#  This Class does the geometrics for Hide and Seek
#  If you extract anything from this class (even if you just get
#  "inspiration"), I want to be credited! Sorry but this was pretty much work.
#==============================================================================
class HaS_Geometrie
  #--------------------------------------------------------------------------
  # * Variablen Übergeben  Setting instance Variables for the calculations
  #     ax, ay     : Event X and Event Y Coordinates
  #     px, py     : Player X and Player Y Coordinates
  #     blx, bly   : Hideevent X and Hideevent Y Coordinates
  #     alpha      : Seighting-Triangle Angle
  #     sichtweite : Seighting-Distance
  #     kreis      : True if a Seighting-Circle shout be calculated
  #--------------------------------------------------------------------------
  def variablen_uebergeben(ax, ay, px, py, blx, bly, alpha, sichtweite, richtung, kreis)
    @punkt_a = { "x" => ax, "y" => ay}
    @punkt_b = { "x" => 0.0, "y" => 0.0}
    @punkt_c = { "x" => 0.0, "y" => 0.0}
    @punkt_p = { "x" => px, "y" => py}
    @punkt_bl = { "x" => blx, "y" => bly}
    @richtung = richtung
    @sichtweite = sichtweite
    @sichtwinkel = alpha
    @circle = kreis
    return true if eckpunkte_bestimmen
  end
  #--------------------------------------------------------------------------
  # * Blockpunkte Ändern  Method to change Hideevent-Coordinates
  #     blx, bly   : Hideevent X and Hideevent Y Coordinates
  #--------------------------------------------------------------------------
  def blockpunkte_aendern(blx, bly)
    @punkt_bl = { "x" => blx, "y" => bly}
  end
  #--------------------------------------------------------------------------
  # * Bogenmass  Thanks to =Kai= and Monsta from rpg-studio for this Method
  #     n : Angle
  #--------------------------------------------------------------------------
  def bogenmass(n)
     n * 2.0 * Math::PI / 360.0
  end
  #--------------------------------------------------------------------------
  # * Eckpunkte Bestimmen  Figures out Verticles of the Seighting-Triangle
  #     Thanks to =Kai= for eliminating some syntax errors with Math.sin
  #--------------------------------------------------------------------------
  def eckpunkte_bestimmen
    alpha = @sichtwinkel
    strecke_h = @sichtweite
    gamma = (180.0 - alpha) / 2.0
    gamma_b = bogenmass(gamma)
    alpha_b = bogenmass(alpha)
    a = ((strecke_h/Math.sin(gamma_b)) * (Math.sin(alpha_b/2.0))) * 2.0
    case @richtung
    when 2
      @punkt_b["y"] = @punkt_a["y"]+strecke_h
      @punkt_c["y"] = @punkt_a["y"]+strecke_h
      @punkt_b["x"] = @punkt_a["x"]+(a/2.0)
      @punkt_c["x"] = @punkt_a["x"]-(a/2.0)  
    when 4
      @punkt_b["x"] = @punkt_a["x"]-strecke_h
      @punkt_c["x"] = @punkt_a["x"]-strecke_h
      @punkt_b["y"] = @punkt_a["y"]-(a/2.0)
      @punkt_c["y"] = @punkt_a["y"]+(a/2.0)
    when 6
      @punkt_b["x"] = @punkt_a["x"]+strecke_h
      @punkt_c["x"] = @punkt_a["x"]+strecke_h
      @punkt_b["y"] = @punkt_a["y"]+(a/2.0)
      @punkt_c["y"] = @punkt_a["y"]-(a/2.0)
    when 8
      @punkt_b["y"] = @punkt_a["y"]-strecke_h
      @punkt_c["y"] = @punkt_a["y"]-strecke_h
      @punkt_b["x"] = @punkt_a["x"]-(a/2.0)
      @punkt_c["x"] = @punkt_a["x"]+(a/2.0)  
    end
    return true
  end
  #--------------------------------------------------------------------------
  # * Spieler in Sichtfeld  Returns True if Player is within 
  #     Seighting-Triangle (if it is activated) and Seighting-Circle 
  #     (if it is activated), or if Player is on Seek-Event
  #--------------------------------------------------------------------------
  def spieler_in_sichtfeld
 
    # Punkte zur Berechnung setzen (P ist Spieler, A Seeker)
    px = @punkt_p["x"]
    py = @punkt_p["y"]
    ax = @punkt_a["x"]
    ay = @punkt_a["y"]
    bx = @punkt_b["x"]
    by = @punkt_b["y"]
    cx = @punkt_c["x"]
    cy = @punkt_c["y"]
 
    # Wenn Spieler auf selber Position wie Seeker steht: True
    return true if px == ax && py == ay
 
    # Wenn weder Sichtkreis noch Sichtdreieck aktiviert sind, hier abbrechen
    if not @circle and not @sichtwinkel.between?(1,179)
      return false
    end
 
    # Sichtkreis:
    # Prüfung ob Spieler innerhalb eines Kreises mit Radius Sichtweite ist
    if @circle
      # Muss nur geprüft werden wenn es eingestellt wurde
      return false if (((px - ax).abs + (py - ay).abs) > @sichtweite )
    end
 
    # Sichtdreieck:
    # Prüfung ob Spieler außerhalb der Sichtweite oder hinter dem Seeker ist
    unless @sichtwinkel.between?(1,179)
      # Wenn ein Sichtwinkel von 0 oder 360 eingestellt wurde: Prüfung überspringen
      # Dann wird nur die Auswertung vom Sichtkreis genommen
      return true
    end
    case @richtung
    when 2
      return false if py > by || py < ay  # by == cy
    when 4
      return false if px > ax || px < bx  # bx == cx
    when 6
      return false if px < ax || px > bx  # bx == cx
    when 8
      return false if py < by || py > ay  # by == cy
    end
    ab_m = 1.0
    ab_b = 1.0
    ac_m = 1.0
    ac_b = 1.0
    #gerade AB
    ab_m = (by - ay) / (bx - ax)
    ab_b = ay - (ab_m * ax)
    #gerade AC
    ac_m = (cy - ay) / (cx - ax)
    ac_b = ay - (ac_m * ax)
    #aufgelöst nach x und y :
    #py == (m*px) + b
    #px == (py - b) / m
    #Eingesetzte für X-Wert der Strecke AB, 
    ab_x = (py - ab_b) / ab_m
    ab_y = (ab_m*px) + ab_b
    ac_x = (py - ac_b) / ac_m
    ac_y = (ac_m*px) + ac_b
    case @richtung
    when 2
      return false if px <= ac_x || px >= ab_x
    when 4
      return false if py >= ac_y || py <= ab_y
    when 6
      return false if py <= ac_y || py >= ab_y
    when 8
      return false if px >= ac_x || px <= ab_x
    end
 
    return true
  end
  #--------------------------------------------------------------------------
  # * Hide auf Strecke  Returns True if Hideevent is between Player and Seeker
  #     Thanks to uni-protokolle.de for some inspiration, they could not
  #     explain what I wanted to know, but somehow I figuerd it out by myself
  #--------------------------------------------------------------------------
  def hide_auf_strecke
 
    # Punkte zur Berechnung übernehmen (P ist Spieler, A Seeker und BL Hide)
    px = @punkt_p["x"]
    py = @punkt_p["y"]
    ax = @punkt_a["x"]
    ay = @punkt_a["y"]
    blx = @punkt_bl["x"]
    bly = @punkt_bl["y"]
 
    # Wenn Seeker selbst Hideevent, nicht prüfen  
    return false if @punkt_bl == @punkt_a 
 
    case @richtung # ist Hide-Event irgendwo zwischen Spieler und Seeker
    when 2
      return false if bly > py || bly < ay
    when 4
      return false if blx > ax || blx < px
    when 6
      return false if blx < ax || blx > px
    when 8
      return false if bly < py || bly > ay
    end
    # Temporäre Variablen deklarieren, vorhandene zu Dezimalzahlen umwandeln
    px *= 1.0
    py *= 1.0
    ax *= 1.0
    ay *= 1.0
    blx *= 1.0
    bly *= 1.0
    m = -1.0
    b = -1.0
    tempx = -1.0
    tempy = -1.0
    qx = []
    qy = []
    # Das Blockevent wird zu einem Quadrat gemacht; die 4 Punkte berechnen:
    qx[1] = blx - 64.0
    qy[1] = bly - 64.0
    qx[2] = blx + 64.0
    qy[2] = bly - 64.0
    qx[3] = blx - 64.0
    qy[3] = bly + 64.0
    qx[4] = blx + 64.0
    qy[4] = bly + 64.0
    # Funktionsgleichung für eine Gerade zwischen Seeker und Spieler aufstellen
    # Steigung M berechnen
    if ((px - ax) == 0) # Steigung endlos
      m = 9999999.99
    else
      m = (py - ay) / (px - ax)
    end 
    # Y-Achsenabschnittszahl B berechnen
    b = ay - (m * ax)
    # Jetzt nur noch prüfen, ob die Gerade eine der Kanten des Quadrates schneidet
    tempx = funktionsgleichung_auswerten(qy[1], 0, m, b)
    return true if tempx >= qx[1] && tempx <= qx[2]
    tempx = funktionsgleichung_auswerten(qy[3], 0, m, b)
    return true if tempx >= qx[3] && tempx <= qx[4]
    tempy = funktionsgleichung_auswerten(0, qx[1], m, b)
    return true if tempy >= qy[1] && tempy <= qy[3]  
    tempy = funktionsgleichung_auswerten(0, qx[2], m, b)
    return true if tempy >= qy[2] && tempy <= qy[4]   
    # Wenn Gerade nicht das Quadrat schneitet, false
    return false
  end
  #--------------------------------------------------------------------------
  # * Funktionsgleichung Auswerten  Returns X or Y ( y = m * x + b )
  #--------------------------------------------------------------------------
  def funktionsgleichung_auswerten(y, x, m, b)
    if y == 0
      # nach y auflösen
      return (m * x + b)
    elsif x == 0
      # nach x auflösen
      return ((y -  b) / m)
    else
      return 0
    end
  end
end