#==============================================================================
# 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= Comment beziehungsweise Comment 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)!
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 = 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
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.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 == 40 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:I / 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