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 = "Hide and Seek"
# 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 = 5
 
# ------ 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(*args)
	hk_has_refresh(*args)
	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