Location: PHPKode > projects > Skrupel KI > skrupelki/ki_basis/ki_basis.php
<?php
/**
 * Autor: Wasserleiche (hide@address.com)
 */
include_once("eigenschaften/eigenschaften.php");
include_once("eigenschaften/planeten_infos.php");
include_once("eigenschaften/schiffe/schiffe_infos.php");
include_once("eigenschaften/schiffe/geleitschutz_infos.php");
include_once("eigenschaften/schiffe/jaeger_infos.php");
include_once("eigenschaften/schiffe/scouts_infos.php");
include_once("eigenschaften/schiffe/frachter/frachter_infos.php");
include_once("eigenschaften/schiffe/frachter/frachter_kolo_infos.php");
include_once("eigenschaften/schiffe/frachter/frachter_route_infos.php");
include_once("eigenschaften/schiffe/spezialschiffe_infos.php");
include_once("eigenschaften/sternenbasen/basen_ausbau_infos.php");
include_once("eigenschaften/sternenbasen/basen_neu_infos.php");
include_once("eigenschaften/sternenbasen/basen_schiffbau_infos.php");
include_once("eigenschaften/sternenbasen/raumfalten_infos.php");

include_once("planeten_basis/planeten_basis.php");
include_once("politik_basis/politik_basis.php");
include_once("schiffe_basis/schiffe_basis.php");
include_once("schiffe_basis/frachter_basis.php");
include_once("schiffe_basis/jaeger_basis.php");
include_once("schiffe_basis/scouts_basis.php");
include_once("schiffe_basis/geleitschutz_basis.php");
include_once("schiffe_basis/wurmloecher_basis.php");
include_once("sternenbasen_basis/sternenbasen_basis.php");
include_once("sternenbasen_basis/basen_schiffbau_basis.php");

/**
 * Diese abstrakte Klasse beinhaltet die meisten nuetzlichen Funktionen und Datenfelder.
 * Sie sollte nicht veraendert werden, ohne sich im klaren zu sein, was sie fuer die erbenden
 * Klassen die Konsquenzen sein werden.
 */
abstract class ki_basis {
	var $planeten;
	var $politik;
	var $frachter;
	var $jaeger;
	var $scouts;
	var $spezialschiffe;
	var $sternenbasen;
	var $geleitschutz;
	
	/**
	 * Dies ist die wichtigste Funktion einer KI-Klasse. Sie wird in /inhalt/zugende.php aufgerufen, nachdem 
	 * das KI-Objekt erstellt wurde. Erbende KI-Klassen muessen diese Funktion implementieren.
	 */
	abstract function berechneZug();
	
	/**
	 * Konstructor fuer ki_basis. Es wird einfach ein eigenschaften-Objekt erstellt.
	 */
	function __construct($sid, $id, $nick, $schiffe_infos, $jaeger_infos, $scouts_infos, $frachter_infos, 
						$frachter_kolo_infos, $frachter_route_infos, $spezialschiffe_infos, $basen_neu_infos, 
						$basen_ausbau_infos, $basen_schiffbau_infos, $raumfalten_infos, $planeten_infos, 
						$geleitschutz_infos) {
		$spiel_id = $this->ermittleSpielID($sid);
		$comp_id = $this->ermittleCompID($id, $sid);
		$tick = $this->ermittleTick($spiel_id);
		$rasse = $this->ermittleRasse($comp_id, $sid);
		eigenschaften::init($tick, $comp_id, $rasse, $nick, $sid, $spiel_id, 
						$schiffe_infos, $jaeger_infos, $scouts_infos, $frachter_infos, $frachter_kolo_infos, 
						$frachter_route_infos, $spezialschiffe_infos, $basen_neu_infos, $basen_ausbau_infos, 
						$basen_schiffbau_infos, $raumfalten_infos, $planeten_infos, $geleitschutz_infos);
		wurmloecher_basis::ermittleSichtbareWurmloecher();
		wurmloecher_basis::ermittleGeseheneWurmloecher();
		wurmloecher_basis::ermittleBekannteWurmloecher();
		wurmloecher_basis::ermittleInstabileWurmloecher();
	}
	
	/**
	 * Ermittelt die Datenbank-ID des aktuellen Spieles und gibt diese zurueck.
	 * arguments: $sid - Die temporaere Datenbank-ID des aktuellen Spieles.
	 * returns: die Datenbank-ID des aktuellen Spieles.
	 */
	function ermittleSpielID($sid) {
		$id = @mysql_query("SELECT id FROM skrupel_spiele WHERE sid='$sid'");
		$id = @mysql_fetch_array($id);
		return $id['id'];
	}
	
	/**
	 * Ermittelt die Spieler-Nummer des KI-Spieler im aktuellen Spiel und gibt diese zurueck.
	 * arguments: $id - Die Spieler-ID der KI.
	 * 			  $sid - Die temporaere Datenbank-ID des aktuellen Spieles.
	 * returns: Die Spieler-Nummer des KI-Spieler im aktuellen Spiel.
	 */
	static function ermittleCompID($id, $sid) {
		$k = 1;
		for(; $k <= 10; $k++) {
			$comp_spieler_id = @mysql_query("SELECT spieler_{$k} FROM skrupel_spiele WHERE sid='$sid'");
			$comp_spieler_id = @mysql_fetch_array($comp_spieler_id);
			$comp_spieler_id = $comp_spieler_id['spieler_'.$k];
			if($comp_spieler_id == $id) break;
		}
		return $k;
	}
	
	/**
	 * Ermittelt die aktuelle Runde des aktuellen Spiels und gibt diese zurueck.
	 * arguments: $spiel_id - Die Datenbank-ID des aktuellen Spieles.
	 * returns: Die aktuelle Runde im aktuellen Spiel.
	 */
	function ermittleTick($spiel_id) {
		$tick = @mysql_query("SELECT runde FROM skrupel_spiele WHERE id='$spiel_id'");
		$tick = @mysql_fetch_array($tick);
		return $tick['runde'];
	}
	
	/**
	 * Ermittelt die Rasse des KI-Spielers und gibt diese zurueck.
	 * arguments: $comp_id - Die Spieler-Nummer im aktuellen Spiel.
	 * 			  $sid - Die temporaere Datenbank-ID des aktuellen Spieles.
	 * returns: Die Rasse deas KI-Spielers.
	 */
	function ermittleRasse($comp_id, $sid) {
		$rasse = @mysql_query("SELECT spieler_{$comp_id}_rasse FROM skrupel_spiele WHERE sid='$sid'");
		$rasse = @mysql_fetch_array($rasse);
		return $rasse['spieler_'.$comp_id.'_rasse'];
	}
	
	/**
	 * Ermittelt die Optimale Temperatur der Rasse des KI-Spielers
	 * returns: Die Optimale Temperatur in Grad Celsius.
	 * 			0, falls die Rasse keine Optimale Temperatur hat.
	 */
	static function ermittleOptimaleTemp() {
		$rassen_daten_pfad = "./../daten/".eigenschaften::$rasse."/daten.txt";
		$rassen_daten = file($rassen_daten_pfad);
		$rassen_attribute = explode(':', $rassen_daten[2]);
		if ($rassen_attribute[0] == 0) return 0;
		return $rassen_attribute[0] - 35;
	}
	
	/**
	 * Zieht eine bestimmte Menge einer Resource auf einem Planeten ab.
	 * arguments: $resource - Die Resource, von der etwas abgezogen werden soll.
	 * 			  $menge - Die Menge, die abgezogen werden soll.
	 * 			  $planeten_id - Die Datenbank-ID des Planeten, auf dem Resourcen abgezogen werden.
	 */
	static function zieheResourcenAb($resource, $menge, $planeten_id) {
		$aktuelle_menge = @mysql_query("SELECT $resource FROM skrupel_planeten WHERE id='$planeten_id'");
		$aktuelle_menge = @mysql_fetch_array($aktuelle_menge);
		$neue_menge = $aktuelle_menge[$resource] - $menge;
		@mysql_query("UPDATE skrupel_planeten SET $resource='$neue_menge' WHERE id='$planeten_id'");
	}

	/**
	 * Ermittelt die naechst-groessere freie ID der uebergebenen Tabelle.
	 * arguments: $tabelle - Der Name der Tabelle.
	 * returns: die naechst-groessere freie ID der Tabelle.
	 */
	static function ermittleNaechsteID($tabelle) {
		$groesste_id = @mysql_query("SELECT max(id) FROM $tabelle");
		$groesste_id = @mysql_fetch_array($groesste_id);
		return $groesste_id['max(id)'] + 1;
	}
	
	/**
	 * Prueft, ob in der Tabelle skrupel_ki_spezialschiffe Schiffe eingetragen sind, die eigentlich nicht mehr 
	 * existieren. Diese Eintraege werden geloescht.
	 */	
	static function pruefeSpezialSchiffe() {
		$spiel_id = eigenschaften::$spiel_id;
		$geloeschte_schiffe = @mysql_query("SELECT k.id FROM skrupel_ki_spezialschiffe k WHERE (NOT EXISTS 
			(SELECT * FROM skrupel_schiffe s WHERE (s.id=k.schiff_id) AND (s.spiel='$spiel_id')))");
		while($schiff = @mysql_fetch_array($geloeschte_schiffe)) {
			$spezialschiff_id = $schiff['id'];
			@mysql_query("DELETE FROM skrupel_ki_spezialschiffe WHERE id='$spezialschiff_id'");
		}
	}
	
	/**
	 * Ermittelt alle Informationen zu Schiffen, die durch die Rasse gebaut werden koennen und speichert diese 
	 * in eigenschaften::$schiff_arrays. Es werden auch jene Schiffe erfasst, die durch Strukturtaster kopiert 
	 * wurden. An jedes Array wird die zum Schiff gehoeriges Rasse angehaengt.
	 */
	function ermittleSchiffArrays() {
		$schiff_datei_pfad = "./../daten/".eigenschaften::$rasse."/schiffe.txt";
		$schiffe = file($schiff_datei_pfad);
		$schiff_arrays = array();
		foreach($schiffe as $schiff_zeile) {
			$array = explode(':', $schiff_zeile);
			$array[] = eigenschaften::$rasse;
			$schiff_arrays[] = $array;
		}
		$spiel_id = eigenschaften::$spiel_id;
		$comp_id = eigenschaften::$comp_id;
		$alle_daten = @mysql_query("SELECT klasse, klasse_id, techlevel, sonstiges, rasse 
				FROM skrupel_konplaene WHERE (spiel='$spiel_id') AND (besitzer='$comp_id')");
		while($daten = @mysql_fetch_array($alle_daten)) {
			$relevante_daten = array();
			$relevante_daten[] = $daten['klasse'];
			$relevante_daten[] = $daten['klasse_id'];
			$relevante_daten[] = $daten['techlevel'];
			$sonstiges_array = explode(':', $daten['sonstiges']);
			foreach($sonstiges_array as $info) {
				$relevante_daten[] = $info;
			}
			$relevante_daten[] = $daten['rasse'];
			$schiff_arrays[] = $relevante_daten;
		}
		eigenschaften::$schiff_arrays = $schiff_arrays;
	}
	
	/**
	 * Ermittelt alle Angriffe eines Gegners auf einen von der KI bewohnten Planeten bzw. Schiffe. Ein Schiff 
	 * zaehlt als Angreifer, falls es Kurs auf einen Planeten oder Schiff der KI gelegt hat und es vom 
	 * KI-Spieler gesehen wird.
	 */
	function ermittleGegnerAngriffe() {
		eigenschaften::$gegner_angriffe = array();
		$spiel_id = eigenschaften::$spiel_id;
		$comp_id = eigenschaften::$comp_id;
		
		foreach(eigenschaften::$sichtbare_gegner_schiffe as $gegner_schiff_daten) {
			$id = $gegner_schiff_daten['id'];
			$schiff_daten = @mysql_query("SELECT zielid, status, kox, koy FROM skrupel_schiffe WHERE id='$id'");
			$schiff_daten = @mysql_fetch_array($schiff_daten);
			$ziel_id = $schiff_daten['zielid'];
			
			if($ziel_id == 0) {
				$status = $schiff_daten['status'];
				if($status == 2) {
					$x_pos = $schiff_daten['kox'];
					$y_pos = $schiff_daten['koy'];
					$planeten_daten = @mysql_query("SELECT id FROM skrupel_planeten 
							WHERE x_pos='$x_pos' AND y_pos='$y_pos' AND spiel='$spiel_id' AND besitzer='$comp_id'");
					$planeten_daten = @mysql_fetch_array($planeten_daten);
					if($planeten_daten == null || $planeten_daten['id'] == 0) continue;
					$ziel_id = $planeten_daten['id'];
				}
			}
			if(in_array($ziel_id, eigenschaften::$kolonien_ids) || in_array($ziel_id, eigenschaften::$schiff_ids)) 
				eigenschaften::$gegner_angriffe[] = $gegner_schiff_daten;
			
		}
	}
	
	/**
	 * Ermittelt die Koordinaten und die Datenbank-ID aller sichtbaren gegnerischen Planeten und 
	 * schreibt diese Infos in eigenschaften::$gegner_planeten_daten und in die Tabelle skrupel_ki_planeten.
	 */
	function ermittleSichtbareGegnerPlaneten() {
		$sicht = "sicht_".eigenschaften::$comp_id;
		$comp_id = eigenschaften::$comp_id;
		$spiel_id = eigenschaften::$spiel_id;
		$gegner_planeten = @mysql_query("SELECT x_pos, y_pos, id FROM skrupel_planeten WHERE ($sicht=1) 
					AND (NOT ((besitzer='$comp_id') OR (besitzer=0))) AND (spiel='$spiel_id') AND NOT EXISTS 
					(SELECT * FROM skrupel_politik WHERE (spiel='$spiel_id') AND 
					((partei_a='$comp_id') || (partei_b='$comp_id')))");
		while($planeten_infos = @mysql_fetch_array($gegner_planeten)) {
			if($planeten_infos == null || $planeten_infos['id'] == 0) continue;
			eigenschaften::$gegner_planeten_daten[] = array('x'=>$planeten_infos['x_pos'], 
													  'y'=>$planeten_infos['y_pos'], 'id'=>$planeten_infos['id']);
			self::updateSchlechtePlaneten($planeten_infos['id'], 2);
		}
	}
	
	/**
	 * Ermittelt die Koordinaten und Datenbank-IDs der sichtbaren gegnerischen Schiff und schreibt diese Infos 
	 * in eigenschaften::$sichtbare_gegner_schiffe.
	 */
	function ermittleGegnerSchiffe() {
		$sicht = "sicht_".eigenschaften::$comp_id;
		$comp_id = eigenschaften::$comp_id;
		$spiel_id = eigenschaften::$spiel_id;
		$gegner_schiffe = @mysql_query("SELECT kox, koy, id FROM skrupel_schiffe WHERE ($sicht=1) 
					AND (NOT (besitzer='$comp_id')) AND (spiel='$spiel_id') AND (NOT EXISTS 
					(SELECT * FROM skrupel_politik WHERE (spiel='$spiel_id') AND 
					((partei_a='$comp_id') || (partei_b='$comp_id'))))");
		while($schiff_id =  mysql_fetch_array($gegner_schiffe)) {
			eigenschaften::$sichtbare_gegner_schiffe[] = array ('x'=>$schiff_id['kox'], 'y'=>$schiff_id['koy'], 
																'id'=>$schiff_id['id']);
		}
	}
	
	/**
	 * Ermittelt den genauen Platz, den der uebergebene Spieler in einer bestimmten Disziplin im 
	 * uebergebenen Spiel hat.
	 * arguments: $comp_id - Die spielinterne Spieler-ID des Spielers, dessen Rang ermittelt wird.
	 * 			  $rang_art - Die Art des Ranges, die ermittelt werden soll.
	 * 			  $spiel_id - Die Datenbank-ID des Spieles.
	 * returns: Den Platz, den der Spieler in der uebergebenen Disziplin belegt.
	 */
	static function ermittleRangVonSpieler($comp_id, $rang_art) {
		$rang_string = "spieler_".$comp_id."_".$rang_art;
		$spiel_id = eigenschaften::$spiel_id;
		$rang = @mysql_query("SELECT $rang_string FROM skrupel_spiele WHERE spiel='$spiel_id'");
		$rang = @mysql_fetch_array($rang);
		return $rang[$rang_string];
	}
	
	/**
	 * Ermittelt alle Spieler-Nummern von gegnerischen Spielern im aktuellen Spiel und 
	 * schreibt diese in eigenschaften::$gegner_ids.
	 */
	function ermittleGegner() {
		eigenschaften::$gegner_ids = array();
		$spiel_id = eigenschaften::$spiel_id;
		$comp_id = eigenschaften::$comp_id;
		for($k = 1; $k <= 10; $k++) {
			if($k == eigenschaften::$comp_id) continue;
			$spieler_id = @mysql_query("SELECT spieler_{$k} FROM skrupel_spiele WHERE (id='$spiel_id') 
				AND NOT EXISTS (SELECT * FROM skrupel_politik WHERE (spiel='$spiel_id') AND 
				((partei_a='$comp_id') || (partei_b='$comp_id')))");
			$spieler_id = @mysql_fetch_array($spieler_id);
			if($spieler_id['spieler_'.$k] != 0) eigenschaften::$gegner_ids[] = $k;
		}
	}
	
	/**
	 * Ermittelt alle Kolonien des KI-Spielers und schreibt diese in eigenschaften::$kolonien_ids. Falls genug 
	 * Kolonien vorhanden sind, wird die Menge an Kolonisten, die pro Planet zur Kolonisieren mit genommen wird, 
	 * erhoeht.
	 */
	function ermittleKolonien() {
		$comp_id = eigenschaften::$comp_id;
		$spiel_id = eigenschaften::$spiel_id;
		$kolonien = @mysql_query("SELECT id FROM skrupel_planeten 
						WHERE (besitzer='$comp_id') AND (spiel='$spiel_id')");
		while($planeten_id = @mysql_fetch_array($kolonien)) {
			eigenschaften::$kolonien_ids[] = $planeten_id['id'];
		}
		if(count(eigenschaften::$kolonien_ids) <= eigenschaften::$frachter_kolo_infos->max_kolonien_wenig_leute) 
		eigenschaften::$frachter_kolo_infos->kolo_leute = eigenschaften::$frachter_kolo_infos->kolo_leute_anfangs;
	}
	
	/**
	 * Aktualisiert die Tabelle skrupel_ki_neuebasen. Ist $aktion=0, so wird der uebergebene Planet von 
	 * der Tabelle geloescht, ist $aktion=1 wird der Planet hinzugefuegt.
	 * arguments: $planeten_id - Die Datenbank-ID des Planeten, der hinzugefuegt oder geloescht werden soll.
	 * 			  $aktion - Der Planet wird bei 0 aus der Tabelle geloescht und bei 1 hinzugefuegt.
	 */
	static function updateNeueBasenPlaneten($planeten_id, $aktion) {
		switch($aktion) {
			case 0: {
				@mysql_query("DELETE FROM skrupel_ki_neuebasen WHERE planeten_id='$planeten_id'");
				break;
			}
			case 1: {
				$planet = @mysql_query("SELECT id FROM skrupel_ki_neuebasen WHERE planeten_id='$planeten_id'");
				$planet = @mysql_fetch_array($planet);
				if($planet != null && $planet['id'] != null && $planet['id'] != 0) return;
				$neue_id = ki_basis::ermittleNaechsteID("skrupel_ki_neuebasen");
				@mysql_query("INSERT INTO skrupel_ki_neuebasen (id, planeten_id) 
						VALUES ('$neue_id', '$planeten_id')");
				break;
			}
		}
	}
	
	/**
	 * Ermittelt alle Planeten, wo eine Sternenbasis gebaut werden soll und schreibt diese 
	 * in eigenschaften::$neue_basis_planeten.
	 */
	function ermittleNeueBasenPlaneten() {
		$spiel_id = eigenschaften::$spiel_id;
		$comp_id = eigenschaften::$comp_id;
		$neue_basen_planeten = @mysql_query("SELECT n.planeten_id, n.id FROM skrupel_ki_neuebasen n, 
				skrupel_planeten p WHERE (p.id=n.planeten_id) AND (p.spiel='$spiel_id') 
				AND (p.besitzer='$comp_id')");
		eigenschaften::$neue_basis_planeten = array();
		while($id = @mysql_fetch_array($neue_basen_planeten)) {
			$planeten_id = $id['planeten_id'];
			$n_id = $id['id'];
			if(self::planetWirdAngegriffen($planeten_id)) 
				@mysql_query("DELETE FROM skrupel_ki_neuebasen WHERE id='$n_id'");
			else {
				eigenschaften::$neue_basis_planeten[] = $planeten_id;
				eigenschaften::$wichtige_planeten_ids[] = $planeten_id;
			}
		}
	}
	
	function planetWirdAngegriffen($planeten_id) {
		$planeten_daten = @mysql_query("SELECT x_pos, y_pos FROM skrupel_planeten WHERE id='$planeten_id'");
		$planeten_daten = @mysql_fetch_array($planeten_daten);
		$x_planet = $planeten_daten['x_pos'];
		$y_planet = $planeten_daten['y_pos'];
		
		foreach(eigenschaften::$gegner_angriffe as $schiff_daten) {
			$id = $schiff_daten['id'];
			$schiff_daten = @mysql_query("SELECT zielid, status, kox, koy FROM skrupel_schiffe WHERE id='$id'");
			$schiff_daten = @mysql_fetch_array($schiff_daten);
			$ziel_id = $schiff_daten['zielid'];
			
			if($planeten_id == $ziel_id) return true;
			
			if($ziel_id == 0) {
				$status = $schiff_daten['status'];
				if($status == 2) {
					$x_schiff = $schiff_daten['kox'];
					$y_schiff = $schiff_daten['koy'];
					if($x_planet == $x_schiff && $y_planet == $y_schiff) return true;
				}
			}
		}
		return false;
	}
	
	/**
	 * Ermittelt alle bekannten, sich fuer die Kolonisierung nicht lohnenden Planeten-IDs.
	 * returns: Ein Array mit den Datenbank-IDs der "schlechten" Planeten.
	 */
	static function ermittleSchlechtePlaneten() {
		$spiel_id = eigenschaften::$spiel_id;
		$comp_id = eigenschaften::$comp_id;
		$schlechte_planeten = @mysql_query("SELECT p.id FROM skrupel_ki_planeten k, skrupel_planeten p 
						WHERE (p.id=k.planeten_id) AND (p.spiel='$spiel_id') AND (k.comp_id='$comp_id')");
		$planeten = array();
		while($planet = @mysql_fetch_array($schlechte_planeten)) {
			$planeten[] = $planet['id'];
		}
		return $planeten;
	}
	
	/**
	 * Aktualisiert die Tabelle skrupel_ki_planeten mit den uebergebenen Werten.
	 * arguments: $planeten_id - Die Datenbank-ID des Planeten, der sich fuer die Kolonisierung nicht lohnt.
	 * 			  $extra - Der Grund, warum der Planet sich nicht lohnt.
	 */
	static function updateSchlechtePlaneten($planeten_id, $extra) {
		$planeten_ids = self::ermittleSchlechtePlaneten();
		if(in_array($planeten_id, $planeten_ids)) return;
		$id = self::ermittleNaechsteID("skrupel_ki_planeten");
		$comp_id = eigenschaften::$comp_id;
		@mysql_query("INSERT INTO skrupel_ki_planeten (id, planeten_id, comp_id, extra) 
						VALUES('$id', '$planeten_id', '$comp_id', '$extra')");
	}
	
	/**
	 * Ermittelt die ID und die Anzahl der dominanten Spezies des uebergebenen Planeten und gibt diese 
	 * Informationen zurueck.
	 * arguments: $planeten_id - Die Datenbank-ID des Planeten, dessen dominante Spezies ermittelt werden soll.
	 * returns: Ein Array aus der ID und der Anzahl der dominanten Spezies.
	 * 			null, falls es keine dominante Spezies auf dem Planeten gibt.
	 */
	static function ermittleDomSpezies($planeten_id) {
		$planeten_daten = @mysql_query("SELECT native_id, native_kol FROM skrupel_planeten 
			WHERE id='$planeten_id'");
		$planeten_daten = @mysql_fetch_array($planeten_daten);
		$planeten_einwohner = $planeten_daten['native_id'];
		$planeten_einwohner_anzahl = $planeten_daten['native_kol'];
		if($planeten_einwohner_anzahl == 0) return null;
		return array('id'=> $planeten_einwohner, 'anzahl'=>$planeten_einwohner_anzahl);
	}
	
	/**
	 * Checkt, ob sich der angegebene Planet zur kolonisierung lohnt. Es wird ueberprueft, ob die Temperatur 
	 * des Planeten um mehr als 30 C von der optimalen Temperatur der Rasse abweicht oder eine aggressive oder 
	 * eine diebische dominante Spezies auf dem Planeten ist. Falls das der Fall ist, wird dieser Planet in 
	 * die skrupel_ki_planeten-Tabelle hinzugefuegt.
	 * arguments: $planeten_id - Die Datenbank-ID des zu ueberpruefenden Planeten.
	 * returns: true - Falls der Planet kolonisiert werden sollte.
	 * 			false - Sonst.
	 */
	static function PlanetLohntSich($planeten_id) {
		$schlechte_planeten = self::ermittleSchlechtePlaneten();
		if(in_array($planeten_id, $schlechte_planeten)) return false;
		$optimale_temp = self::ermittleOptimaleTemp();
		$planeten_daten = @mysql_query("SELECT temp, native_id, native_kol FROM skrupel_planeten 
			WHERE id='$planeten_id'");
		$planeten_daten = @mysql_fetch_array($planeten_daten);
		$planeten_temp = $planeten_daten['temp'] - 35;
		$planeten_einwohner = $planeten_daten['native_id'];
		$planeten_einwohner_anzahl = $planeten_daten['native_kol'];
		if($optimale_temp != 0 && abs($planeten_temp - $optimale_temp) >= 30) {
			self::updateSchlechtePlaneten($planeten_id, 0);
			return false;
		}
		if(($planeten_einwohner == 8 || $planeten_einwohner == 15 
		|| $planeten_einwohner == 31 || $planeten_einwohner == 36) 
		&& $planeten_einwohner_anzahl >= eigenschaften::$spezialschiffe_infos->min_native_invasion) {
			self::updateSchlechtePlaneten($planeten_id, 1);
			return false;
		}
		return true;
	}
	
	/**
	 * Ermittelt alle bekannten gegnerischen Planeten und speichert deren Daten in 
	 * eigenschaften::$gegner_planeten_daten
	 */
	static function ermittleGegnerPlaneten() {
		$comp_id = eigenschaften::$comp_id;
		$spiel_id = eigenschaften::$spiel_id;
		$planeten_infos = @mysql_query("SELECT p.id, p.x_pos, p.y_pos FROM skrupel_planeten p, 
						skrupel_ki_planeten k WHERE (p.id=k.planeten_id) 
						AND (p.spiel='$spiel_id') AND (k.comp_id='$comp_id') AND (k.extra=2)");
		eigenschaften::$gegner_planeten_daten = array();
		while($planet = @mysql_fetch_array($planeten_infos)) {
			eigenschaften::$gegner_planeten_daten[] = array('x'=>$planet['x_pos'], 'y'=>$planet['y_pos'], 
															'id'=>$planet['id']);
		}
	}
	
	/**
	 * Ermittelt alle fuer die KI sichtbaren feindlichen Minenfelder und gibt diese zurueck.
	 * returns: Ein Array aus allen Datenbank-IDs und Koordinaten von sichtbaren feindlichen Minenfelder.
	 */
	static function ermittleFeindlicheMinenfelder() {
		if(!(self::ModulAktiv("minenfelder"))) return array();
		$spiel_id = eigenschaften::$spiel_id;
		$comp_id = eigenschaften::$comp_id;
		$minenfelder = @mysql_query("SELECT id, x_pos, y_pos, extra FROM skrupel_anomalien 
			WHERE (spiel='$spiel_id') AND (art=5) AND (sicht_".$comp_id."=1)");
		$minenfeld_array = array();
		while($minenfeld = @mysql_fetch_array($minenfelder)) {
			$extra_array = explode(':', $minenfeld['extra']);
			$besitzer = $extra_array[0];
			if(!in_array($besitzer, eigenschaften::$gegner_ids)) continue;
			$minenfeld_eintrag = array('x'=>$minenfeld['x_pos'], 'y'=>$minenfeld['y_pos'], 
									   'id'=>$minenfeld['id']);
			$minenfeld_array[] = $minenfeld_eintrag;
		}
		return $minenfeld_array;
	}
	
	/**
	 * Ermittelt den Besitzer des uebergebenen Minenfeldes.
	 * arguments: $anomalie_id - Die Datenbank-ID des Minenfeldes, dessen Besitzer gefragt wird.
	 * returns: Die Spieler-ID im aktuellen Spiel des Besitzers des Minenfeldes.
	 */
	static function ermittleMinenfeldBesitzer($anomalie_id) {
		$besitzer = @mysql_query("SELECT extra FROM skrupel_anomalien WHERE id='$anomalie_id'");
		$besitzer = @mysql_fetch_array($besitzer);
		$besitzer = explode(':', $besitzer['extra']);
		return $besitzer[0];
	}
	
	/**
	 * Ermittelt die Menge der uebergebene Resource auf dem uebergebenen Planeten.
	 * arguments: $planeten_id - Die Datenbank-ID des Planeten, von dem eine Resource abgefragt wird.
	 * 			  $resource - Die Resource, dessen Menge abgefragt wird.
	 * returns: Die Menge der gefragten Resource des Planeten.
	 */
	static function ermittleResource($planeten_id, $resource) {
		$res = @mysql_query("SELECT $resource FROM skrupel_planeten WHERE id='$planeten_id'");
		$res = @mysql_fetch_array($res);
		return $res[$resource];
	}
	
	/**
	 * Ueberprueft, ob das aktuelle Spiel das uebergebene Modul aktiviert hat.
	 * arguments: $modul_string - Das zu ueberpruefende Modul.
	 * returns: true, falls das Spiel das Modul aktiviert hat.
	 * 			false, sonst.
	 */
	static function ModulAktiv($modul_string) {
		$spiel_id = eigenschaften::$spiel_id;
		$module = @mysql_query("SELECT module FROM skrupel_spiele WHERE id='$spiel_id'");
		$module = @mysql_fetch_array($module);
		$modul_array = explode(':', $module['module']);
		switch($modul_string) {
			case "minenfelder": return $modul_array[2]+0 != 0;
			case "taktik": return $modul_array[3]+0 != 0;
		}
		return false;
	}
	
	/**
	 * Ermittelt alle Ordner innerhalb des ki-Ordners, in denen installierte KIs sind und gibt diese zurueck.
	 * returns: Ein Array aus allen Ordner-Namen der installierten KIs.
	 */
	static function ermittleKIOrdner() {
		$root_path = "../extend/ki/";
		$directories = openDir($root_path);
		$dir_array = array();
		$ausnahmen = array("dokumentation", "ki_basis", ".", "..");
		while($dir = readdir($directories)){
			if(in_array($dir, $ausnahmen)) continue;
			$dir_array[] = $dir;
		}
		closeDir($directories);
		return $dir_array;
	}
	
	/**
	 * Ermittelt alle Ordner und deren Computer-Namen aller installierten KIs und gibt diese als Array zurueck.
	 * returns: Ein Array aus allen Daten der installierten KIs.
	 */
	static function ermittleKIDaten() {
		$ki_ordner = ki_basis::ermittleKIOrdner();
		$ki_daten = array();
		foreach($ki_ordner as $ki) {
			include("../extend/ki/".$ki."/holeDaten.php");
		}
		return $ki_daten;
	}
	
	/**
	 * Ermittlet alle Nicknames von KI-Spieler vom uebergebenen Spiel und gibt diese als Array zurueck.
	 * arguments: $sid - Die temporaere Datenbank-ID des Spiels, dessen KI-Spieler gesucht werden.
	 * returns: Die Nicknames der KI-Spieler des Spiels.
	 * Mitwirkende Autoren: myrbel
	 */	
	static function ermittleComputerSpieler($sid) {
		$computer_spieler = array();
		for($k=1; $k<=10; $k++) {
	        $spieler = @mysql_query("SELECT spieler_{$k}, spieler_{$k}_raus FROM skrupel_spiele 
	        	WHERE sid='$sid'");
	        $spieler = @mysql_fetch_array($spieler);
	        $spieler_id = $spieler['spieler_'.$k];
	        $spieler_raus = $spieler['spieler_'.$k.'_raus'];
	        if($spieler_id != 0 && $spieler_raus == 0) {
                $spieler_nick = @mysql_query("SELECT nick FROM skrupel_user WHERE id='$spieler_id'");
                $spieler_nick = @mysql_fetch_array($spieler_nick);
                $spieler_nick = $spieler_nick['nick'];
                if($spieler_nick != null) {
                    foreach(ki_basis::ermittleKIDaten() as $daten) {
                    	$nick = substr($spieler_nick, 0, strlen($daten['nick']));
                    	if($daten['nick'] == $nick) $computer_spieler[] = $spieler_id;
                    }
                }
	        }
		}
		return $computer_spieler;
	}
	
	/**
	 * Prueft, ob alle menschlichen Spieler im Spiel aufgegeben haben oder zerstoert wurden.
	 * returns: true, falls alle Menschen aufgegeben haben oder zerstoert wurden.
	 * 			false, sonst.
	 */
	static function alleMenschenRaus($sid) {
		$spieler_anzahl = @mysql_query("SELECT spieleranzahl FROM skrupel_spiele WHERE sid='$sid'");
		$spieler_anzahl = @mysql_fetch_array($spieler_anzahl);
		return ($spieler_anzahl['spieleranzahl'] == count(self::ermittleComputerSpieler($sid)));
	}
	
	/**
	 * Ueberprueft, ob alle Spieler, die nicht KI-Spieler sind, ihren Zug beendet haben.
	 * arguments: $sid - Die temporaere Datenbank-ID des Spiels.
	 * returns: true, falls alle menschlichen Spieler ihren Zug beendet haben.
	 * 			false, sonst.
	 */
	static function alleMenschenGezogen($sid) {
		$menschen_spieler_fertig = 0;
		for($k=1; $k<=10; $k++) {
			$spieler_k_zug = "spieler_".$k."_zug";
			$spieler_infos = @mysql_query("SELECT $spieler_k_zug, spieler_{$k} FROM skrupel_spiele 
				WHERE sid='$sid'");
			$spieler_infos = @mysql_fetch_array($spieler_infos);
			$spieler_gezogen = $spieler_infos[$spieler_k_zug];
			$spieler_id = $spieler_infos[1];
			if($spieler_id != 0) {
				$spieler_nick = @mysql_query("SELECT nick FROM skrupel_user WHERE id='$spieler_id'");
				$spieler_nick = @mysql_fetch_array($spieler_nick);
				if($spieler_nick != null && $spieler_nick['nick'] != null) {
					$spieler_nick = $spieler_nick['nick'];
					foreach(ki_basis::ermittleKIDaten() as $daten) {
						if($daten['nick'] != $spieler_nick) $menschen_spieler_fertig++;
					}
				}
			}
		}
		$spieler_anzahl = @mysql_query("SELECT spieleranzahl FROM skrupel_spiele WHERE sid='$sid'");
		$spieler_anzahl = @mysql_fetch_array($spieler_anzahl);
		$spieler_anzahl = $spieler_anzahl['spieleranzahl'];
		$menschen_spieler_anzahl = $spieler_anzahl - self::ermittleComputerSpieler($sid);
		return ($menschen_spieler_anzahl == $menschen_spieler_fertig);
	}
	
	/**
	 * Ermittelt den Winkel zwischen 3 Punkten.
	 * arguments: $a_x, $a_y - Die Koordinaten des ersten Punktes.
	 * 			  $mitte_x, $mitte_y - Die Koordinaten des mittleren Punktes.
	 * 			  $b_x, $b_y - Die Koordinaten des dritten Punktes.
	 * returns: Den Winkel zwischen den 3 Punkten in Grad.
	 */
	static function ermittleWinkel($a_x, $a_y, $mitte_x, $mitte_y, $b_x, $b_y) {
		$mitte_a_x = $a_x - $mitte_x;
		$mitte_a_y = $a_y - $mitte_y;
		$mitte_b_x = $b_x - $mitte_x;
		$mitte_b_y = $b_y - $mitte_y;
		$zaehler = ($mitte_a_x * $mitte_b_x) + ($mitte_a_y * $mitte_b_y);
		$nenner_1 = sqrt(($mitte_a_x * $mitte_a_x) + ($mitte_a_y * $mitte_a_y));
		$nenner_2 = sqrt(($mitte_b_x * $mitte_b_x) + ($mitte_b_y * $mitte_b_y));
		if($nenner_1 == 0 || $nenner_2 == 0) return null;
		$cos_a_mitte_b = $zaehler / ($nenner_1 * $nenner_2);
		return rad2deg(acos($cos_a_mitte_b));
	}
	
	/**
	 * Berechnet die Strecke zwischen den Start- und Ziel-Koordinaten.
	 * arguments: $x_start - Die X-Koordinate des Start-Punkts.
	 * 			  $y_start - Die Y-Koordinate des Start-Punkts.
	 * 			  $x_ziel - Die X-Koordinate des Ziel-Punkts.
	 * 			  $y_ziel - Die Y-Koordinate des Ziel-Punkts.
	 * returns: Die Strecke (in Lichtjahren) zwischen Start- und Ziel-Punkt
	 */
	static function berechneStrecke($x_start, $y_start, $x_ziel, $y_ziel) {
		$x_laenge = $x_ziel - $x_start;
		$y_laenge = $y_ziel - $y_start;
		return sqrt(($x_laenge * $x_laenge) + ($y_laenge * $y_laenge));
	}
	
	/**
	 * Berechnet den normalisierten Vektor fuer den uebergebenen Vektor und gibt diesen zurueck.
	 * arguments: $vektor_x - Die X-Komponente des Vektors.
	 * 			  $vektor_y - Die Y-Komponente des Vektors.
	 * returns: Ein Array aus den normalisierten Vektor-Komponenten.
	 */
	static function normiereVektor($vektor_x, $vektor_y) {
		if($vektor_x == 0 && $vektor_y == 0) return array('vektor_x'=>0, 'vektor_y'=>0);
		$vektor_faktor = 1 / sqrt(($vektor_x * $vektor_x) + ($vektor_y * $vektor_y));
		$vektor_x = $vektor_x * $vektor_faktor;
		$vektor_y = $vektor_y * $vektor_faktor;
		return array('vektor_x'=>$vektor_x, 'vektor_y'=>$vektor_y);
	}
	
	/**
	 * Berechnet den Punkt, den man erreicht, wenn man den uebegebenen Vektor um die 
	 * uebergebene Strecke verlaengert und gibt diesen als Array zurueck.
	 * arguments: $strecke - Die Strecke vom Start-Punkt zum Punkt, der berechnet werden soll.
	 * 			  $x_start - Die X-Koordinate des Start-Punkts.
	 * 			  $y_start - Die y-Koordinate des Start-Punkts.
	 * 			  $x_ziel - Die X-Koordinate des Punkts, in dessen Richtung der Vektor verlaeuft.
	 * 			  $y_ziel - Die Y-Koordinate des Punkts, in dessen Richtung der Vektor verlaeuft.
	 * returns: Den resultierenden Punkt als Array aus X- und Y-Koordinate.
	 */
	static function berechneWegPunkt($strecke, $x_start, $y_start, $x_ziel, $y_ziel) {
		$vektor_x = $x_ziel - $x_start;
		$vektor_y = $y_ziel - $y_start;
		$vektor_normal = ki_basis::normiereVektor($vektor_x, $vektor_y);
		$vektor_x = $vektor_normal['vektor_x'] * $strecke;
		$vektor_y = $vektor_normal['vektor_y'] * $strecke;
		return array($vektor_x + $x_start, $vektor_y + $y_start);
	}
	
	/**
	 * Prueft, ob die uebergebenen Koordinaten ausserhalb der Karte liegen.
	 * arguments: $x - Die X-Koordinate.
	 * 			  $y - Die Y-Koordinate.
	 * returns: true, falls der Punkt ausserhalb liegt.
	 * 			false, sonst.
	 */
	static function PunktAusserhalb($x, $y) {
		if($x < 0 || $y < 0) return true;
		$spiel_id = eigenschaften::$spiel_id;
		$umfang = @mysql_query("SELECT umfang FROM skrupel_spiele WHERE id='$spiel_id'");
		$umfang = @mysql_fetch_array($umfang);
		$umfang = $umfang['umfang'];
		return ($x > $umfang || $y > $umfang);
	}
	
	/**
	 * Ermittelt den naechst-gelegenen, wichtigen Planeten ausgehend von den Start-Koordinaten und
	 * den uebergebenen wichtigen Planeten.
	 * arguments: $x_start - Die X-Koordinate des Start-Punkts.
	 * 			  $y_start - Die Y-Koordinate des Start-Punkts.
	 * 			  $wichtige_planeten_ids - Die Datenbank-IDs der moeglichen Ziel-Planeten als Array.
	 * returns: Die X- und Y-Koordinaten sowie die Datenbank-ID des naechsten wichtigen Planeten als Array, 
	 * 			falls ein solcher Planet gefunden wurde.
	 * 			null, sonst.
	 */
	static function ermittleNahenWichtigenPlaneten($x_start, $y_start, $wichtige_planeten_ids) {
		$planeten_koords = array();
		foreach($wichtige_planeten_ids as $id) {
			$planeten_pos = @mysql_query("SELECT x_pos, y_pos FROM skrupel_planeten WHERE id='$id'");
			$planeten_pos = @mysql_fetch_array($planeten_pos);
			$planeten_koords[] = array('x'=>$planeten_pos['x_pos'], 'y'=>$planeten_pos['y_pos']);
		}
		$planeten_anzahl = count($wichtige_planeten_ids);
		$kurze_strecke = 9999;
		$x_nahe = 0; $y_nahe = 0;
		foreach($planeten_koords as $koords) {
			if($koords == null) continue;
			$x = $koords['x'];
			$y = $koords['y'];
			if($x == null || $y == null) continue;
			$strecke = ki_basis::berechneStrecke($x_start, $y_start, $x, $y);
			if($kurze_strecke > $strecke) {
				$kurze_strecke = $strecke;
				$x_nahe = $x;
				$y_nahe = $y;
			}
		}
		if($x_nahe == 0 && $y_nahe == 0) return null;
		$spiel_id = eigenschaften::$spiel_id;
		$planeten_id = @mysql_query("SELECT id FROM skrupel_planeten WHERE (spiel='$spiel_id') 
			AND (x_pos='$x_nahe') AND (y_pos='$y_nahe')");
		$planeten_id = @mysql_fetch_array($planeten_id);
		$planeten_id = $planeten_id['id'];
		if($planeten_id == null || $planeten_id == 0) return null;
		return array('x'=>$x_nahe, 'y'=>$y_nahe, 'id'=>$planeten_id);
	}
	
	/**
	 * Ermittelt den naechst-gelegenen Planeten ausgehend von den Start-Koordinaten.
	 * arguments: $x_start - Die X-Koordinate des Start-Punkts.
	 * 			  $y_start - Die Y-Koordinate des Start-Punkts.
	 * 			  $comp_id - Die Spieler-Nummer des KI-Spielers (1-10).
	 * 			  $ausnahmen - Die Datenbank-IDs der Planeten, die ignoriert werden sollen, als Array.
	 * 			  			   null, falls keine Ausnahmen gemacht werden sollen.
	 * 			  $spiel_id - Die Datenbank-ID des zugehoerigen Spiels.
	 * 			  $muss_bewohnt_sein - true, falls der naechste Planet vom uebergebenen Spieler besitzt 
	 * 								   werden soll.
	 * 								   false, sonst.
	 * 			  $sichtbar - true, falls der naechste Planet fuer den uebergebenen Spieler sichtbar sein soll.
	 * 						  false, sonst.
	 * returns: Die X- und Y-Koordinaten sowie die Datebank-ID des Ziels als Array, falls eine Ziel 
	 * 			gefunden wurde.
	 * 			null, falls kein Ziel gefunden wurde.
	 */
	static function ermittleNahenPlaneten($x_start, $y_start, $ausnahmen, $muss_bewohnt_sein, $sichtbar) {
		$ausnahmen_string = "";
		$besitzer = 0;
		$spiel_id = eigenschaften::$spiel_id;
		$comp_id = eigenschaften::$comp_id;
		if($muss_bewohnt_sein) $besitzer = $comp_id;
		if($ausnahmen != null) {
			foreach($ausnahmen as $ausnahme) {
				$ausnahmen_string = $ausnahmen_string."(NOT (id='$ausnahme')) AND";
			}
		}
		$sicht_string = "";
		if($sichtbar) $sicht_string = "(sicht_".$comp_id."_beta=1) AND ";
		$temp_string = "SELECT x_pos, y_pos, id FROM skrupel_planeten WHERE ".$sicht_string.$ausnahmen_string." 
			(besitzer='$besitzer') AND (spiel='$spiel_id')";
		$nahe_planeten = @mysql_query($temp_string);
		$nahe_planeten_daten = array();
		while($planet = @mysql_fetch_array($nahe_planeten)) {
			$nahe_planeten_daten[] = array('x'=>$planet['x_pos'], 'y'=>$planet['y_pos'], 'id'=>$planet['id']);
		}
		$kurze_strecke = 9999;
		$naher_planet = null;
		foreach($nahe_planeten_daten as $daten) {
			if($daten == null) continue;
			if($daten['x'] == null || $daten['y'] == null) continue;
			$strecke = ki_basis::berechneStrecke($x_start, $y_start, $daten['x'], $daten['y']);
			if($kurze_strecke > $strecke) {
				$kurze_strecke = $strecke;
				$naher_planet = $daten;
			}
		}
		return $naher_planet;
	}
	
	/**
	 * Ermittelt das naechst-gelegene Ziel (Planet oder Schiff) ausgehend von den Start-Koordinaten.
	 * arguments: $schiff_id - Die Datenbank-ID des Schiffs, dessen naechstes Ziel bestimmt werden soll.
	 * 			  $ziele_daten - Die Datenbank-IDs sowie die X- und Y-Koordinaten von moeglichen Zielen.
	 * 			  $spiel_id - Die Datenbank-ID des zugehoerigen Spiels.
	 * returns: Die X- und Y-Koordinaten und die Datenbank-ID des Ziels als Array.
	 * 			null, sonst.
	 */
	static function ermittleNahesZiel($schiff_id, $ziele_daten, $wurmloch_daten) {
		if($ziele_daten == null) return null;
		$schiff_koords = @mysql_query("SELECT kox, koy FROM skrupel_schiffe WHERE id='$schiff_id'");
		$schiff_koords = @mysql_fetch_array($schiff_koords);
		$x_start = $schiff_koords['kox'];
		$y_start = $schiff_koords['koy'];
		$kurze_strecke = 99999;
		$nahes_ziel = null;
		$x_wurmloch = 0; 
		$y_wurmloch = 0; 
		$id_wurmloch = 0;
		$spiel_id = eigenschaften::$spiel_id;
		$comp_id = eigenschaften::$comp_id;
		foreach($ziele_daten as $ziel) {
			if($ziel == null) continue;
			$x = $ziel['x'];
			$y = $ziel['y'];
			$id = $ziel['id'];
			if($x == null || $y == null) continue;
			$direkte_strecke = ki_basis::berechneStrecke($x_start, $y_start, $x, $y);
			$wurmloch_strecke = 99999;
			//Hier werden die uebergebenen Wurmloecher-Koordinaten benutzt:
			if($wurmloch_daten != null) {
				foreach($wurmloch_daten as $wurmloch) {
					if($wurmloch == null) continue;
					$wurmloch_x = $wurmloch['x'];
					$wurmloch_y = $wurmloch['y'];
					$wurmloch_id = $wurmloch['id'];
					$wurmloch_ziel = wurmloecher_basis::ermittleWurmlochZiel($wurmloch_id);
					if($wurmloch_ziel == null || $wurmloch_ziel['id'] == null) continue;
					$wurmloch_ziel_x = $wurmloch_ziel['x'];
					$wurmloch_ziel_y = $wurmloch_ziel['y'];
					if($wurmloch_ziel_x == null || $wurmloch_ziel_y == null) continue;
					$strecke_wurmloch1 = ki_basis::berechneStrecke($x_start, $y_start, 
																   $wurmloch_x, $wurmloch_y);
					$strecke_wurmloch2 = ki_basis::berechneStrecke($wurmloch_ziel_x, 
																   $wurmloch_ziel_y, $x, $y);
					$wurmloch_strecke_temp = $strecke_wurmloch1 + $strecke_wurmloch2;
					if($strecke_wurmloch1 == 0 || $strecke_wurmloch2 == 0) continue;
					if($wurmloch_strecke_temp < $wurmloch_strecke) {
						$wurmloch_strecke = $wurmloch_strecke_temp;
						$x_wurmloch = $wurmloch_x;
						$y_wurmloch = $wurmloch_y;
						$id_wurmloch = $wurmloch_id;
					}
				}
			}
			//Nun wird entschieden, ob ein kuerzerer weg gefunden wurde:
			if($kurze_strecke > $direkte_strecke && $wurmloch_strecke > $direkte_strecke) {
				$kurze_strecke = $direkte_strecke;
				$nahes_ziel = array('x'=>$x, 'y'=>$y, 'id'=>$id);
				$x_wurmloch = 0; $y_wurmloch = 0; $id_wurmloch = 0;
			}
			elseif($kurze_strecke > $wurmloch_strecke && $direkte_strecke > $wurmloch_strecke) {
				$kurze_strecke = $wurmloch_strecke;
				$nahes_ziel = array('x'=>$x, 'y'=>$y, 'id'=>$id);
			} else { $x_wurmloch = 0; $y_wurmloch = 0; $id_wurmloch = 0; }
		}
		//Wurde kein Ziel gefunden, wird null zurueckgegeben.
		if($nahes_ziel == null || $nahes_ziel['id'] == null || $nahes_ziel['id'] == 0 
		|| ($nahes_ziel['x'] == 0 && $nahes_ziel['y'] == 0)) return null;
		//Soll ein Wurmloch benutzt werden, so wird dies in der Datenbank vermerkt.
		if($id_wurmloch != 0) {
			$routing_koord = "".$x_wurmloch.":".$y_wurmloch.":".$id_wurmloch.":"
							 .$nahes_ziel['x'].":".$nahes_ziel['y'].":".$nahes_ziel['id']."";
			@mysql_query("UPDATE skrupel_schiffe SET routing_schritt=2, routing_koord='$routing_koord' 
				WHERE id='$schiff_id'");
			$nahes_ziel = array('x'=>$x_wurmloch, 'y'=>$y_wurmloch, 0);
		}
		else @mysql_query("UPDATE skrupel_schiffe SET routing_schritt=0, routing_koord='' WHERE id='$schiff_id'");
		return $nahes_ziel;
	}
	
	/**
	 * Ermittelt die Koordinaten fuer die Flucht des uebergebenen Schiffes von den uebergebenen 
	 * Flucht-Koordinaten.
	 * arguments: $schiff_id - Die Datenbank-ID des Schiffs, das fluechtet.
	 * 			  $flucht_x - Die X-Koodinaten des Punktes, von dem gefluechtet wird.
	 * 			  $flucht_y - Die Y-Koodinaten des Punktes, von dem gefluechtet wird.
	 * returns: Die Ziel-Koordinaten als Array, zu denen gefluechtet wird.
	 * Mitwirkende Autoren: Jonu.
	 */
	static function ermittleFluchtKoordinaten($schiff_id, $flucht_x, $flucht_y) {
		$schiff_daten = @mysql_query("SELECT kox, koy FROM skrupel_schiffe WHERE id='$schiff_id'");
		$schiff_daten = @mysql_fetch_array($schiff_daten);
		$schiff_x = $schiff_daten['kox'];
		$schiff_y = $schiff_daten['koy'];
		$spiel_id = eigenschaften::$spiel_id;
		$spiel_umfang = @mysql_query("SELECT umfang FROM skrupel_spiele WHERE id='$spiel_id'");
		$spiel_umfang = @mysql_fetch_array($spiel_umfang);
		$spiel_umfang = $spiel_umfang['umfang'];
		$abstand_x = abs($flucht_x - $schiff_x);
		$abstand_y = abs($flucht_y - $schiff_y);
		$faktor = ceil(100 / sqrt($abstand_x * $abstand_x + $abstand_y * $abstand_y));
		if($schiff_x < $flucht_x) $flucht_ziel_x = $schiff_x - $faktor * $abstand_x;
		else $flucht_ziel_x = $schiff_x + $faktor * $abstand_x;
		if($schiff_y < $flucht_y) $flucht_ziel_y = $schiff_y - $faktor * $abstand_y;
		else $flucht_ziel_y = $schiff_y + $faktor * $abstand_y;
		if($flucht_ziel_x < 0) $flucht_ziel_x = 0;
		elseif($flucht_ziel_x > $spiel_umfang) $flucht_ziel_x = $spiel_umfang;
		if($flucht_ziel_y < 0) $flucht_ziel_y = 0;
		elseif($flucht_ziel_y > $spiel_umfang) $flucht_ziel_y = $spiel_umfang;
		return array('x'=>$flucht_ziel_x, 'y'=>$flucht_ziel_y);
	}
}
?>
Return current item: Skrupel KI