Location: PHPKode > projects > Skrupel KI > skrupelki/ki_basis/schiffe_basis/schiffe_basis.php
<?php
/**
 * Autor: Wasserleiche (hide@address.com)
 * 
 * Abstrakte Oberklasse fuer Schiffe im allgemeinen.
 */
abstract class schiffe_basis {
	
	/**
	 * Setzt fuer das uebergebene Schiff den uebergebenen Aggressivitaets-Wert.
	 * arguments: $schiff_id - Die Datenbank-ID des Schiffs, dessen Aggressivitaet gesetzt wird.
	 * 			  $aggro - Die zu setzende Aggressivitaet (0-9).
	 */
	function setzeAggressivitaet($schiff_id, $aggro) {
		@mysql_query("UPDATE skrupel_schiffe SET aggro='$aggro' WHERE id='$schiff_id'");
	}
	
	/**
	 * Setzt fuer das uebergebene Schiff den uebergebenen Taktik-Wert. Der Wert wird natuerlich nur veraendert, 
	 * wenn das Taktik-Modul im Spiel aktiv ist.
	 * arguments: $schiff_id - Die Datenbank-ID des Schiffs, dessen Taktik gesetzt wird.
	 * 			  $taktik - Der zusetzende Taktik-Wert (0: Ueberlegt, 1: Aggressiv, 2: Defensiv).
	 */
	function setzeTaktik($schiff_id, $taktik) {
		if(ki_basis::ModulAktiv("taktik")) 
			@mysql_query("UPDATE skrupel_schiffe SET mission='$taktik' WHERE id='$schiff_id'");
	}
	
	/**
	 * Ueberprueft, ob es fuer das uebergebene Schiff im Moment Sinn macht, sich zu tarnen.
	 * arguments: $schiff_id - Die Datenbank-ID des Schiffes, dass sich tarnen soll.
	 */
	function aktiviereTarnung($schiff_id) {
		//Ist nicht genug Rennurbin auf dem Schiff, so wird keine Tarnung aktiviert.
		if($this->ermittleSchiffResource($schiff_id, "min2") < eigenschaften::$schiffe_infos->min_ren_tarnung) 
			return;
		foreach(eigenschaften::$gegner_ids as $gegner_id) {
			$sicht = "sicht_".$gegner_id;
			$sicht_beta = "sicht_".$gegner_id."_beta";
			$schiff_sicht = @mysql_query("SELECT $sicht, $sicht_beta FROM skrupel_schiffe 
				WHERE id='$schiff_id'");
			$schiff_sicht = @mysql_fetch_array($schiff_sicht);
			$sicht1 = $schiff_sicht[$sicht];
			$sicht2 = $schiff_sicht[$sicht_beta];
			if($sicht1 == 1 && $sicht2 == 0) {
				@mysql_query("UPDATE skrupel_schiffe SET spezialmission=8 WHERE id='$schiff_id'");
				return;
			}
		}
		@mysql_query("UPDATE skrupel_schiffe SET spezialmission=0 WHERE id='$schiff_id'");
	}
	
	/**
	 * Ermittelt das Waffensystem des Schiffes, das die groesste Anzahl hat und gibt diese Anzahl zurueck.
	 * arguments: $schiff_id - Die Datenbank-ID des Schiffes, dessen maximale Waffenanzahl ermittelt wird.
	 * returns: Die maximale Waffen-Anzahl des Schiffs.
	 */
	function ermittleMaxWaffenAnzahl($schiff_id) {
		$waffen = @mysql_query("SELECT energetik_anzahl, projektile_anzahl, hanger_anzahl FROM skrupel_schiffe 
				WHERE id='$schiff_id'");
		$waffen = @mysql_fetch_array($waffen);
		if($waffen['energetik_anzahl'] >= $waffen['projektile_anzahl'] 
		&& $waffen['energetik_anzahl'] >= $waffen['hanger_anzahl']) return $waffen['energetik_anzahl'];
		elseif($waffen['projektile_anzahl'] >= $waffen['energetik_anzahl'] 
		&& $waffen['projektile_anzahl'] >= $waffen['hanger_anzahl']) return $waffen['projektile_anzahl'];
		else return $waffen['hanger_anzahl'];
	}
	
	/**
	 * Ermittelt alle Planeten, die bekannt fuer ihre unerwuenschte Dominante Spezies sind, aber deren 
	 * Temperatur fuer die Rasse der KI noch in Ordnng ist und gibt deren Datenbank-IDs als Array zurueck.
	 * returns: Alle Datenbank-IDs als Array von Planeten mit unerwuenschter Spezies, aber akzeptabler 
	 * Temperatur.
	 */
	static function ermittlePlanetenFuerViraleInvasionSchiffe() {
		$comp_id = eigenschaften::$comp_id;
		$spiel_id = eigenschaften::$spiel_id;
		$schlechte_planeten = @mysql_query("SELECT p.id, p.temp FROM skrupel_ki_planeten k, 
				skrupel_planeten p WHERE (k.extra=1) AND (k.comp_id='$comp_id') AND 
				(k.planeten_id=p.id) AND (p.spiel='$spiel_id')");
		$planeten = array();
		$optimale_temp = ki_basis::ermittleOptimaleTemp();
		while($planeten_info = @mysql_fetch_array($schlechte_planeten)) {
			$temp = $planeten_info['temp'] - 35;
			if($optimale_temp == 0 || abs($temp - $optimale_temp) < 30) $planeten[] = $planeten_info['id'];
		}
		return $planeten;
	}
	
	/**
	 * Bestimmt, welche Erkundungs-Funktion benutzt wird. Diese Funktion ist nur eine Wrapper-Funktion!
	 * Hier wird die Funktion schiffe_basis::ermittleErkundungsZiel() verwendet.
	 * arguments: $schiff_id - Die Datenbank-ID des Schiffs, das erkunden soll.
	 * returns: Die Rueckgabe der verwendeten Erkundungs-Funktion.
	 */
	function erkunde($schiff_id) {
		return self::ermittleErkundungsZiel($schiff_id);
	}
	
	/**
	 * Diese Funktion ermittelt einen Planeten fuer ein Schiff, zu den er fliegen soll.
	 * arguments: $schiff_id - Die Datenbank-ID des Schiffs, der erkunden soll.
	 * returns: Ein Array aus X- und Y-Koordinate sowie der Datenbank-ID (falls es nicht nur Koordinaten sind) 
	 * 			des Ziels.
	 * 			null, falls kein Ziel-Planet gefunden wurde.
	 */
	static function ermittleErkundungsZiel($schiff_id) {
		//Zuerst wird versucht, ein sichtbares Wurmloch zu erkunden. Es wird nur erkundet, falls es noch 
		//unbekannt ist oder bekannt ist, dass es instabil ist.
		$spiel_id = eigenschaften::$spiel_id;
		$comp_id = eigenschaften::$comp_id;
		$schiff_koords = @mysql_query("SELECT kox, koy FROM skrupel_schiffe WHERE id='$schiff_id'");
		$schiff_koords = @mysql_fetch_array($schiff_koords);
		$x = $schiff_koords['kox'];
		$y = $schiff_koords['koy'];
		foreach(eigenschaften::$gesehene_wurmloecher_daten as $wurmloch_daten) {
			if(in_array($wurmloch_daten, eigenschaften::$bekannte_wurmloch_daten) 
			|| in_array($wurmloch_daten, eigenschaften::$bekannte_instabile_wurmloch_daten)) continue;
			//Falls das Wurmloch zu weit entfernt ist, wird es nicht angeflogen.
			$wurmloch_x = $wurmloch_daten['x'];
			$wurmloch_y = $wurmloch_daten['y'];
			$entfernung = floor(ki_basis::berechneStrecke($x, $y, $wurmloch_x, $wurmloch_y));
			if($entfernung > eigenschaften::$schiffe_infos->max_wurmloch_erkundungs_reichweite) continue;
			$schiffe_zum_wurmloch = @mysql_query("SELECT sum(id) FROM skrupel_schiffe 
				WHERE (besitzer='$comp_id') AND (spiel='$spiel_id') AND (zielx='$wurmloch_x') 
				AND (ziely='$wurmloch_y]')");
			$schiffe_zum_wurmloch = @mysql_fetch_array($schiffe_zum_wurmloch);
			if($schiffe_zum_wurmloch['sum(zielid)'] == null || $schiffe_zum_wurmloch['sum(zielid)'] == 0) 
				return array('x'=>$wurmloch_daten['x'], 'y'=>$wurmloch_daten['y'], 0);
		}
		//Ansonsten wird ein Ziel festgelegt, dass weiter weg ist.
		$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'];
		$sektor_anzahl = floor($spiel_umfang / eigenschaften::$schiffe_infos->sektor_erkundung_groesse);
		$sektor_anzahl = $sektor_anzahl * $sektor_anzahl;
		$koordinaten = array();
		$x = eigenschaften::$schiffe_infos->sektor_erkundung_groesse / 2;
		$y = $x;
		for($i=1; $i <= $sektor_anzahl; $i++) {
			if($x + eigenschaften::$schiffe_infos->sektor_erkundung_groesse >= $spiel_umfang) {
				$x = eigenschaften::$schiffe_infos->sektor_erkundung_groesse / 2;
				$y += eigenschaften::$schiffe_infos->sektor_erkundung_groesse;
			}
			if($y > $spiel_umfang) break;
			$sektor_koords = array('x'=>$x, 'y'=>$y);
			$koordinaten[] = $sektor_koords;
			$x += eigenschaften::$schiffe_infos->sektor_erkundung_groesse;
		}
		shuffle($koordinaten);
		$planeten_koords = @mysql_query("SELECT x_pos, y_pos FROM skrupel_planeten WHERE (spiel='$spiel_id') 
			AND (besitzer='$comp_id')");
		$eigene_planeten = array();
		while($koords = @mysql_fetch_array($planeten_koords)) {
			$eigene_planeten[] = array('x'=>$koords['x_pos'], 'y'=>$koords['y_pos']);
		}
		$wenigste_planeten = 9999;
		$bester_sektor = null;
		foreach($koordinaten as $koords) {
			$anzahl_eigener_planeten = 0;
			foreach($eigene_planeten as $planet) {
				$distanz = floor(ki_basis::berechneStrecke($koords['x'], $koords['y'], 
														   $planet['x'], $planet['y']));
				if($distanz <= eigenschaften::$schiffe_infos->sektor_erkundung_groesse * 2) 
					$anzahl_eigener_planeten++;
			}
			if($wenigste_planeten > $anzahl_eigener_planeten) {
				$wenigste_planeten = $anzahl_eigener_planeten;
				$bester_sektor = $koords;
			}
		}
		return array('x'=>$bester_sektor['x'], 'y'=>$bester_sektor['y'], 0);
	}
	
	/**
	 * Ermittelt die Menge der uebergebenen Resource an Bord des uebergebenen Schiffs.
	 * arguments: $schiff_id - Die Datenbank-ID des Schiffs.
	 * 			  $resource - Der (Datenbank-)Name des Resource.
	 * returns: Die Menge der Resource am Bord des Schiffs.
	 */
	function ermittleSchiffResource($schiff_id, $resource) {
		$resource = "fracht_".$resource;
		$res = @mysql_query("SELECT $resource FROM skrupel_schiffe WHERE id='$schiff_id'");
		$res = @mysql_fetch_array($res);
		return $res[$resource];
	}
	
	/**
	 * Belaedt das uebergebene Schiff mit der uebergebene Menge an Resourcen.
	 * arguments: $schiff_id - Die Datenbank-ID des Schiffes, das beladen werden soll.
	 * 			  $planeten_id - Die Datenbank-ID des Planeten, an dem das Schiff ist.
	 * 			  $resource - Die Resource, die geladen werden soll.
	 * 			  $menge - Die Menge der Resource, die gelanden werden soll.
	 */
	function ladeResourceAufSchiff($schiff_id, $planeten_id, $resource, $menge) {
		$schiff_daten = @mysql_query("SELECT frachtraum, fracht_leute, fracht_vorrat, fracht_min1, fracht_min2, 
			fracht_min3 FROM skrupel_schiffe WHERE id='$schiff_id'");
		$schiff_daten = @mysql_fetch_array($schiff_daten);
		$frachtraum = $schiff_daten['frachtraum'];
		$fracht_masse = ($schiff_daten['fracht_leute'] / 100) + $schiff_daten['fracht_vorrat'] 
			+ $schiff_daten['fracht_min1'] + $schiff_daten['fracht_min2'] + $schiff_daten['fracht_min3'];
		$frachtraum -= $fracht_masse;
		if($frachtraum == 0) return;
		$planet_res = "planet_".$resource;
		$planet_menge = @mysql_query("SELECT $planet_res FROM skrupel_planeten WHERE id='$planeten_id'");
		$planet_menge = @mysql_fetch_array($planet_menge);
		$planet_menge = $planet_menge[$planet_res];
		if($planet_menge == 0) return;
		$schiff_menge = $menge;
		if($schiff_menge > $frachtraum) $schiff_menge = $frachtraum;
		if($schiff_menge > $planet_menge) $schiff_menge = $planet_menge;
		$planet_menge = $planet_menge - $schiff_menge;
		$fracht_string = "fracht_".$resource;
		@mysql_query("UPDATE skrupel_schiffe SET $fracht_string='$schiff_menge' WHERE id='$schiff_id'");
		@mysql_query("UPDATE skrupel_planeten SET $planet_res='$planet_menge' WHERE id='$planeten_id'");
	}
	
	/**
	 * Ermittelt, ob das uebergebene Schiff die uebergebene Fertigkeit besitzt.
	 * arguments: $schiff_id - Die Datenbank-ID des Schiffs, das auf eine Spezialfaehigkeit hin 
	 * 						   ueberprueft wird.
	 * 			  $fertigkeit - Die Fertigkeit, die ueberprueft werden soll.
	 * returns: true, falls das Schiff die Fertigkeit hat.
	 * 			false, sonst.
	 */
	static function SchiffHatFertigkeit($schiff_id, $fertigkeit) {
		$schiff_fertigkeiten = @mysql_query("SELECT fertigkeiten FROM skrupel_schiffe WHERE id='$schiff_id'");
		$schiff_fertigkeiten = @mysql_fetch_array($schiff_fertigkeiten);
		$schiff_fertigkeiten = $schiff_fertigkeiten['fertigkeiten'];
		switch($fertigkeit) {
			case "srv" : return substr($schiff_fertigkeiten,23,1)+0 != 0;
			case "sensorenphalanx" : return substr($schiff_fertigkeiten,24,1)+0 == 1;
			case "labor" : return substr($schiff_fertigkeiten,24,1)+0 == 2;
			case "lloyd" : return substr($schiff_fertigkeiten,38,2)+0 != 0;
			case "cluster" : return substr($schiff_fertigkeiten,0,2)+0 != 0;
			case "quark" : return substr($schiff_fertigkeiten,7,1)+0 != 0;
			case "cyber" : return substr($schiff_fertigkeiten,48,2)+0 != 0;
			case "terrawarm" : return substr($schiff_fertigkeiten,5,1)+0 != 0;
			case "terrakalt" : return substr($schiff_fertigkeiten,6,1)+0 != 0;
			case "sprungtriebwerk" : return substr($schiff_fertigkeiten,11,3)+0 != 0;
			case "viraleinvasion" : return substr($schiff_fertigkeiten,43,3)+0 != 0;
			case "destabilisator" : return substr($schiff_fertigkeiten,50,2)+0 != 0;
			case "taster" : return substr($schiff_fertigkeiten,52,1)+0 != 0;
			case "tarnung" : return substr($schiff_fertigkeiten,22,1)+0 != 0;
		}
		return false;
	}
	
	/**
	 * Prueft, ob das uebergebene Schiff in der Datenbank als aktives Spezialschiff aufgefuehrt wird und 
	 * gibt dies zurueck.
	 * arguments: $schiff_id - Die Datenbank-ID des Schiffs, das ueberprueft werden soll.
	 * returns: true, falls das Schiff eine aktivierte Spezialmission hat.
	 * 			false, sonst.
	 */
	function istAktivesSpezialSchiff($schiff_id) {
		$ist_aktiv = @mysql_query("SELECT aktiv FROM skrupel_ki_spezialschiffe WHERE schiff_id='$schiff_id'");
		$ist_aktiv = @mysql_fetch_array($ist_aktiv);
		$ist_aktiv = $ist_aktiv['aktiv'];
		if($ist_aktiv == null) return false;
		return ($ist_aktiv == 1);
	}
	
	/**
	 * Ermittelt Information ueber die uebergebene Schiffs-Klasse.
	 * arguments: $klassen_id - Die Klassen-ID des Schiffs.
	 * 			  $info_index - Der Index im Schiffs-Array, der auf die gewuenschte Information zeigt.
	 * returns: Die Information an der Stelle im Array des Schiffes.
	 */
	static function ermittleSchiffInfo($klassen_id, $info_index) {
		foreach(eigenschaften::$schiff_arrays as $schiff_array) {
			if($klassen_id == $schiff_array[1]) return $schiff_array[$info_index];
		}
	}
	
	/**
	 * Prueft, ob das Schiff mit der uebergebenen Klassen-ID der uebergebenen Rasse ein Schiff mit viraler 
	 * Invasion ist.
	 * arguments: $klassen_id - Die Klassen-ID des zu ueberpruefenden Schiffs.
	 * 			  $rasse - Die Rasse des zu ueberpruefenden Schiffs.
	 * returns: true, falls das uebergebene Schiff virale Invasion hat.
	 * 			false, sonst.
	 */
	static function istViralesSchiff($klassen_id, $rasse) {
		$viral_array = self::ermittleViraleInvasionIDs();
		foreach($viral_array as $virale_infos) {
			if($virale_infos['id'] == $klassen_id && $virale_infos['rasse'] == $rasse) return true;
		}
		return false;
	}
	
	/**
	 * Ermittelt alle Datenbank-IDs der Schiffe des KI-Spielers. Alle IDs werden in eigenschaften::$schiff_ids 
	 * geschrieben und je nach Schiff-Typ werden sie in eigenschaften::$cluster_ids, 
	 * eigenschaften::$quark_ids, eigenschaften::$frachter_ids oder eigenschaften::$jaeger_ids 
	 * geschrieben.
	 */
	function ermittleSchiffIDs() {
		$comp_id = eigenschaften::$comp_id;
		$spiel_id = eigenschaften::$spiel_id;
		$schiffe = @mysql_query("SELECT id, frachtraum, energetik_anzahl, projektile_anzahl, hanger_anzahl, 
			klasseid, fertigkeiten, volk FROM skrupel_schiffe WHERE (besitzer='$comp_id') AND 
			(spiel='$spiel_id')");
		$cluster_schiff = $this->ermittleClusterSchiffID();
		$quark_schiff = $this->ermittleQuarkSchiffID(); 
		$cyber_schiff = $this->ermittleCyberSchiffID();
		$terra_warm = $this->ermittleTerraWarmID();
		$terra_kalt = $this->ermittleTerraKaltID();
		while($schiff = @mysql_fetch_array($schiffe)) {
			eigenschaften::$schiff_ids[] = $schiff['id'];
			$waffen = $schiff['energetik_anzahl'] + $schiff['projektile_anzahl'] + $schiff['hanger_anzahl'];
			if($this->istViralesSchiff($schiff['klasseid'], $schiff['volk'])) 
				eigenschaften::$virale_ids[] = $schiff['id'];
			elseif(substr($schiff['fertigkeiten'],52,1) != 0) eigenschaften::$taster_ids[] = $schiff['id'];
			if($schiff['klasseid'] == $cluster_schiff['id'] && $schiff['volk'] == $cluster_schiff['rasse']) 
				eigenschaften::$cluster_ids[] = $schiff['id'];
			elseif($schiff['klasseid'] == $quark_schiff['id'] && $schiff['volk'] == $quark_schiff['rasse']) 
				eigenschaften::$quark_ids[] = $schiff['id'];
			elseif($schiff['klasseid'] == $cyber_schiff['id'] && $schiff['volk'] == $cyber_schiff['rasse']) 
				eigenschaften::$cyber_ids[] = $schiff['id'];
			elseif($schiff['klasseid'] == $terra_warm['id'] && $schiff['volk'] == $terra_warm['rasse']) 
				eigenschaften::$terra_warm_ids[] = $schiff['id'];
			elseif($schiff['klasseid'] == $terra_kalt['id'] && $schiff['volk'] == $terra_kalt['rasse']) 
				eigenschaften::$terra_kalt_ids[] = $schiff['id'];
			elseif($schiff['frachtraum'] >= eigenschaften::$frachter_infos->min_frachtraum_frachter 
			&& $waffen <= eigenschaften::$frachter_infos->max_frachter_waffen) 
				eigenschaften::$frachter_ids[] = $schiff['id'];
			elseif($waffen >= eigenschaften::$scouts_infos->min_scout_waffen 
			&& $waffen <= eigenschaften::$scouts_infos->max_scout_waffen) 
				eigenschaften::$scout_ids[] = $schiff['id'];
			elseif($waffen >= eigenschaften::$jaeger_infos->min_jaeger_waffen) 
				eigenschaften::$jaeger_ids[] = $schiff['id'];
		}
	}
	
	/**
	 * Ermittelt die Klassen-ID und die Rasse des Schiffs, welches die Spezialfaehigkeit
	 * SubpartikelCluster hat.
	 * returns: Die Klassen-ID und die Rasse des gesuchten Schiffs.
	 * 			null, falls es kein Subpartikelcluster-Schiff gibt.
	 */
	static function ermittleClusterSchiffID() {
		$cluster_schiff_id = null;
		$rasse = null;
		foreach(eigenschaften::$schiff_arrays as $schiff_array) {
			$spezial_string = $schiff_array[17];
			$substring = substr($spezial_string, 0, 2);
			if($substring != 0) {
				$cluster_schiff_id = $schiff_array[1];
				$rasse_index = count($schiff_array) - 1;
				$rasse = $schiff_array[$rasse_index];
				break;
			}
		}
		if($cluster_schiff_id == null) return null;
		return array('id'=>$cluster_schiff_id, 'rasse'=>$rasse);
	}
	
	/**
	 * Ermittelt die Klassen-ID und die Rasse des Schiffs, welches die Spezialfaehigkeit
	 * Quarksreorganisator hat.
	 * returns: Die Klassen-ID und die Rasse des gesuchten Schiffs.
	 * 			null, falls es kein Quarksreorganisator-Schiff gibt.
	 */
	static function ermittleQuarkSchiffID() {
		$quark_schiff_id = null;
		$rasse = null;
		foreach(eigenschaften::$schiff_arrays as $schiff_array) {
			$spezial_string = $schiff_array[17];
			$sub_1 = substr($spezial_string, 7, 1);
			if($sub_1 != 0) {
				$quark_schiff_id = $schiff_array[1];
				$rasse_index = count($schiff_array) - 1;
				$rasse = $schiff_array[$rasse_index];
				break;
			}
		}
		if($quark_schiff_id == null) return null;
		return array('id'=>$quark_schiff_id, 'rasse'=>$rasse);
	}
	
	/**
	 * Ermittelt die Klassen-ID und die Rasse des Schiffs, welches die Spezialfaehigkeit 
	 * Cybernrittnikk hat.
	 * returns: Die Klassen-ID und die Rasse des gesuchten Schiffs.
	 * 			null, falls es kein Cyber-Schiff gibt.
	 */
	static function ermittleCyberSchiffID() {
		$cyber_schiff_id = null;
		$rasse = null;
		foreach(eigenschaften::$schiff_arrays as $schiff_array) {
			$spezial_string = $schiff_array[17];
			$sub_1 = substr($spezial_string, 48, 2);
			if($sub_1 != 0) {
				$cyber_schiff_id = $schiff_array[1];
				$rasse_index = count($schiff_array) - 1;
				$rasse = $schiff_array[$rasse_index];
				break;
			}
		}
		if($cyber_schiff_id) return null;
		return array('id'=>$cyber_schiff_id, 'rasse'=>$rasse);
	}
	
	/**
	 * Ermittelt die Klassen-ID und die Rasse eines Schiffes mit Terraformer (Temperatur-Erhoehend).
	 * returns: Die Klassen-ID und die Rasse eines Schiffes mit warmen Terraformer.
	 * 			null, falls es kein Schiff mit warmen Terraformer gibt.
	 */
	static function ermittleTerraWarmID() {
		$terra_warm_schiff_id = null;
		$rasse = null;
		foreach(eigenschaften::$schiff_arrays as $schiff_array) {
			$spezial_string = $schiff_array[17];
			$sub_string = substr($spezial_string, 5, 1)+0;
			if($sub_string != 0) {
				$terra_warm_schiff_id = $schiff_array[1];
				$rasse_index = count($schiff_array) - 1;
				$rasse = $schiff_array[$rasse_index];
				break;
			}
		}
		if($terra_warm_schiff_id == null) return null;
		return array('id'=>$terra_warm_schiff_id, 'rasse'=>$rasse);;
	}
	
	/**
	 * Ermittelt die Klassen-ID und die Rasse eines Schiffes mit Terraformer (Temperatur-Senkend).
	 * returns: Die Klassen-ID und die Rasse eines Schiffes mit kalten Terraformer.
	 * 			null, falls es kein Schiff mit warmen Terraformer gibt.
	 */
	static function ermittleTerraKaltID() {
		$terra_kalt_schiff_id = null;
		foreach(eigenschaften::$schiff_arrays as $schiff_array) {
			$spezial_string = $schiff_array[17];
			$sub_string = substr($spezial_string, 6, 1)+0;
			if($sub_string != 0) {
				$terra_kalt_schiff_id = $schiff_array[1];
				$rasse_index = count($schiff_array) - 1;
				$rasse = $schiff_array[$rasse_index];
				break;
			}
		}
		if($terra_kalt_schiff_id == null) return null;
		return array('id'=>$terra_kalt_schiff_id, 'rasse'=>$rasse);
	}
	
	/**
	 * Ermittelt alle Klassen-IDs von Schiffen mit viraler Invasion und gibt diese als 
	 * Array zurueck.
	 * returns: Alle Klassen-IDs und Rassen von viraler Invasion-Schiffen als Array.
	 */
	static function ermittleViraleInvasionIDs() {
		$virale_ids = array();
		foreach(eigenschaften::$schiff_arrays as $schiff_array) {
			$spezial_string = $schiff_array[17];
			$sub_string = substr($spezial_string, 43, 3);
			if($sub_string+0 != 0) {
				$rasse_index = count($schiff_array) - 1;
				$rasse = $schiff_array[$rasse_index];
				$viral_array = array('id'=>$schiff_array[1], 'rasse'=>$rasse);
				$virale_ids[] = $viral_array;
			}
		}
		return $virale_ids;
	}
	
	/**
	 * Aktiviert oder deaktiviert ein Schiff in dder Tabelle skrupel_ki_spezialschiffe.
	 * arguments: $schiff_id - Die Datenbank-ID des Schiffes, dessen Aktivierung geaendert werden soll.
	 * 			  $aktiv - 0, falls es deaktiviert werden soll.
	 * 					   1, sonst.
	 */
	static function deaktiviereSpezialschiff($schiff_id, $aktiv) {
		@mysql_query("UPDATE skrupel_ki_spezialschiffe SET aktiv='$aktiv' WHERE schiff_id='$schiff_id'");
	}
	
	/**
	 * Ermittelt den freien Frachtraum des uebergebenen Schiffs.
	 * arguments: $schiff_id - Die Datenbank-ID des Schiffs, dessen verfuegbarer Frachtraum ermittelt wird.
	 * returns: Den freien Frachtraum des Schiffs.
	 */
	function ermittleFreienFrachtraum($schiff_id) {
		$schiff_infos = @mysql_query("SELECT fracht_vorrat, fracht_min1, fracht_min2, fracht_min3, 
			fracht_leute, frachtraum FROM skrupel_schiffe WHERE id='$schiff_id'");
		$schiff_infos = @mysql_fetch_array($schiff_infos);
		$frachtraum = $schiff_infos['frachtraum'];
		if($frachtraum == 0) return 0;
		$schiffvorrat = $schiff_infos['fracht_vorrat'];
		$schiffmin1 = $schiff_infos['fracht_min1'];
		$schiffmin2 = $schiff_infos['fracht_min2'];
		$schiffmin3 = $schiff_infos['fracht_min3'];
		$schiffleute = $schiff_infos['fracht_leute'];
		return $frachtraum - ($schiffvorrat + $schiffmin1 + $schiffmin2 + $schiffmin3 + $schiffleute / 100);
	}
	
	/**
	 * Ermittelt die maximale Warp-Geschwindigkeit eines Schiffs.
	 * arguments: $schiff_id - Die Datenbank-ID des relevanten Schiffs.
	 * returns: Die maximale Warp-Geschwindigkeit des Schiffs.
	 */
	static function ermittleMaximumWarp($schiff_id) {
		$antrieb_stufe = @mysql_query("SELECT antrieb FROM skrupel_schiffe WHERE id='$schiff_id'");
		$antrieb_stufe = @mysql_fetch_array($antrieb_stufe);
		$antrieb_stufe = $antrieb_stufe['antrieb'];
		if($antrieb_stufe > 8) $antrieb_stufe--;
		return $antrieb_stufe;
	}
	
	/**
	 * Ermittelt die Scanner-Reichweite des uebergebenen Schiffes.
	 * arguments: $schiff_id - Die Datenbank-ID des Schiffs, dessen Scanner-Reichweite gesucht wird.
	 * returns: Die Scanner-Reichweite des Schiffs.
	 */
	function ermittleSchiffScanweite($schiff_id) {
		$sensor = @mysql_query("SELECT scanner FROM skrupel_schiffe WHERE id='$schiff_id'");
		$sensor = @mysql_fetch_array($sensor);
		$sensor = $sensor['scanner'];
		if($sensor == 0) return 47;
		if($sensor == 1) return 83;
		else return 116;
	}
	
	/**
	 * Prueft, ob das uebergebene Schiff zu weit vom uebergebenen Minenfeld entfernt, um es zu raeumen und 
	 * setzt gegebenenfalls einen Kurs, damit das Schiff das Minenfeld raeumen kann.
	 * Es wird nicht ueberprueft, ob sich das Schiff innerhalb das Minenfeldes befindet!
	 * arguments: $schiff_id - Die Datenbank-ID des Schiffs, das ein Minenfeld raeumen soll.
	 * 			  $minen_feld_id - Die Datenbank-ID des zu raeumenden Minenfeldes.
	 * returns: true, falls ein Kurs gesetzt wurde.
	 * 			false, sonst.
	 */
	function fliegeZuMinenfeldRand($schiff_id, $minen_feld_id) {
		$schiff_koords = @mysql_query("SELECT kox, koy FROM skrupel_schiffe WHERE id='$schiff_id'");
		$schiff_koords = @mysql_fetch_array($schiff_koords);
		$schiff_x = $schiff_koords['kox'];
		$schiff_y = $schiff_koords['koy'];
		$minenfeld_koords = @mysql_query("SELECT x_pos, y_pos FROM skrupel_anomalien 
			WHERE id='$minen_feld_id'");
		$minenfeld_koords = @mysql_fetch_array($minenfeld_koords);
		$minenfeld_x = $minenfeld_koords['x_pos'];
		$minenfeld_y = $minenfeld_koords['y_pos'];
		if($minenfeld_x == null || $minenfeld_y == null || ($minenfeld_x == 0 && $minenfeld_y == 0)) 
			return false;
		$entfernung = ki_basis::berechneStrecke($schiff_x, $schiff_y, $minenfeld_x, $minenfeld_y);
		if($entfernung > 95) {
			$vektor_x = $minenfeld_x - $schiff_x;
			$vektor_y = $minenfeld_y - $schiff_y;
			$vektor_normal = ki_basis::normiereVektor($vektor_x, $vektor_y);
			$ziel_entfernung = $entfernung - 95;
			$vektor_x = $vektor_normal['vektor_x'] * $ziel_entfernung;
			$vektor_y = $vektor_normal['vektor_y'] * $ziel_entfernung;
			$ziel_x = $vektor_x + $schiff_x;
			$ziel_y = $vektor_y + $schiff_y;
			$spiel_id = eigenschaften::$spiel_id;
			$planeten_id = @mysql_query("SELECT id FROM skrupel_planeten WHERE (spiel='$spiel_id') 
				AND (x_pos='$ziel_x') AND (y_pos='$ziel_y')");
			$planeten_id = @mysql_fetch_array($planeten_id);
			if($planeten_id != null && $planeten_id['id'] != null && $planeten_id != 0) {
				$ziel_x += 2;
				$ziel_y += 2;
			}
			$warp = $this->ermittleMaximumWarp($schiff_id);
			$this->fliegeSchiff($schiff_id, $ziel_x, $ziel_y, $warp, null);
			return true;
		}
		return false;
	}
	
	/**
	 * Ermittelt den Planeten, an dem das angegebene Schiff als letztes war, wenn das Schiff eine Ernte-Route
	 * abfliegt.
	 * arguments: $schiff_id - Die Datenbank-ID des Schiffs, dessen letzter Routen-Planet gesucht wird.
	 * returns: Die Datenbank-ID des Planeten, bei dem das angegebene Schiff als letztes innerhalb der Route war.
	 * 			null, falls kein solcher Planet vorhanden ist.
	 */
	function ermittleLetztenRoutenPlaneten($schiff_id) {
		$logbuch = @mysql_query("SELECT logbuch FROM skrupel_schiffe WHERE id='$schiff_id'");
		$logbuch = @mysql_fetch_array($logbuch);
		return $logbuch['logbuch'];
	}
	
	/**
	 * Ermittelt den naechsten Planeten des uebergebenen Schiffs, den es in seiner Route ausgehend vom 
	 * uebergebenen Planeten als naechstens anfliegen soll.
	 * arguments: $schiff_id - Die Datenbank-ID des Schiffs, dessen naechster Routen-Planet ermittelt wird.
	 * 			  $planeten_id - Die Datenbank-ID des Planeten, der als letztes vom Schiff innerhalb der Route
	 * 							 angeflogen wurde.
	 * returns: Ein Array aus X- und Y-Koordinate und der Datenbank-ID des Ziel-Planeten.
	 * 			null, falls das Schiff keine Route hat.
	 */
	function ermittleNaechstenRoutenPlaneten($schiff_id, $planeten_id) {
		$routen_planeten_ids = @mysql_query("SELECT routing_id FROM skrupel_schiffe WHERE id='$schiff_id'");
		$routen_planeten_ids = @mysql_fetch_array($routen_planeten_ids);
		$routen_planeten_ids = explode(':', $routen_planeten_ids['routing_id']);
		$routen_laenge = count($routen_planeten_ids);
		if($routen_laenge == null || $routen_laenge == 0) return null;
		$neue_zielid = null;
		for($k=0; $k < $routen_laenge-1; $k++) {
			if($routen_planeten_ids[$k] == $planeten_id) {
				if($routen_planeten_ids[$k+1] != null) $neue_zielid = $routen_planeten_ids[$k+1];
				else $neue_zielid = $routen_planeten_ids[0];
				break;
			}
		}
		if($neue_zielid == null) return null;
		$planet_koords = @mysql_query("SELECT x_pos, y_pos FROM skrupel_planeten WHERE id='$neue_zielid'");
		$planet_koords = @mysql_fetch_array($planet_koords);
		$planet_koords = array('x'=>$planet_koords['x_pos'], 'y'=>$planet_koords['y_pos'], 'id'=>$neue_zielid);
		return $planet_koords;
	}
	
	/**
	 * Prueft, ob das uebergebene Schiff zu einem Wurmloch fliegt.
	 * arguments: $schiff_id - Die Datenbank-ID des Schiffs, dessen Ziel ueberprueft werden soll.
	 * returns: true, falls das Schiff zu einem Wurmloch fliegt.
	 * 			false, sonst.
	 */
	function fliegtZuWurmloch($schiff_id) {
		$schiff_infos = @mysql_query("SELECT zielx, ziely, zielid FROM skrupel_schiffe WHERE id='$schiff_id'");
		$schiff_infos = @mysql_fetch_array($schiff_infos);
		$ziel_x = $schiff_infos['zielx'];
		$ziel_y = $schiff_infos['ziely'];
		$ziel_id = $schiff_infos['zielid'];
		if(($ziel_x == 0 && $ziel_y == 0) || $ziel_id != 0) return false;
		foreach(eigenschaften::$gesehene_wurmloecher_daten as $wurmloch) {
			if($ziel_x == $wurmloch['x'] && $ziel_y == $wurmloch['y']) return true;
		}
		return false;
	}
	
	/**
	 * Ermittlet die Menge an Lemin, die das uebergebene Schiff zum Beginn seiner Reise tanken sollte.
	 * arguments: $schiff_id - Die Datenbank-ID des Schiffs, dessen initiale Tankefuellung ermittelt wird.
	 * returns: Die initiale Tankfuellung fuer das Schiff.
	 */
	function ermittleStreckenVerbrauch($schiff_id) {
		$schiff_infos = @mysql_query("SELECT masse, kox, koy, zielx, ziely, zielid, lemin, leminmax, flug, 
			routing_status, routing_id FROM skrupel_schiffe WHERE id='$schiff_id'");
		$schiff_infos = @mysql_fetch_array($schiff_infos);
		$schiff_masse = $schiff_infos['masse'];
		$x_pos = $schiff_infos['kox'];
		$y_pos = $schiff_infos['koy'];
		$ziel_x = $schiff_infos['zielx'];
		$ziel_y = $schiff_infos['ziely'];
		$ziel_id = $schiff_infos['zielid'];
		$lemin_schiff = $schiff_infos['lemin'];
		$lemin_max = $schiff_infos['leminmax'];
		$schiff_flug = $schiff_infos['flug'];
		$routing_status = $schiff_infos['routing_status'];
		$routing_planeten = $schiff_infos['routing_id'];
		$warp = $this->ermittleMaximumWarp($schiff_id);
		$verbrauch_prozent = 100;
		switch($warp) {
			case 2: $verbrauch_prozent = 107.5;
			case 3: $verbrauch_prozent = 107.78;
			case 4: $verbrauch_prozent = 106.25;
			case 5: $verbrauch_prozent = 104;
			case 6: $verbrauch_prozent = 103.69;
			case 7: $verbrauch_prozent = 108.16;
			case 8: $verbrauch_prozent = 109.38;
		}
		if($routing_status == 2) {
			$alter_planet = $this->ermittleLetztenRoutenPlaneten($schiff_id);
			$planeten_id = $this->ermittleNaechstenRoutenPlaneten($schiff_id, $alter_planet);
			$planeten_id = $planeten_id['id'];
			$planeten_koords = @mysql_query("SELECT x_pos, y_pos FROM skrupel_planeten WHERE id='$planeten_id'");
			$planeten_koords = @mysql_fetch_array($planeten_koords);
			$ziel_x = $planeten_koords['x_pos'];
			$ziel_y = $planeten_koords['y_pos'];
		}
		$flug_strecke = ki_basis::berechneStrecke($x_pos, $y_pos, $ziel_x, $ziel_y);
		$lemin = ceil($verbrauch_prozent * $schiff_masse / 100000 * $flug_strecke);
		if(($routing_status == 2 && $lemin_schiff == 0) || $schiff_flug == 3 
		|| $this->fliegtZuWurmloch($schiff_id)) $lemin = $lemin * 3;
		if($lemin_max < $lemin) $lemin = $lemin_max;
		if(in_array($schiff_id, eigenschaften::$jaeger_ids) 
		&& $lemin < eigenschaften::$jaeger_infos->min_lemin_jaeger_tank_start) 
			$lemin = eigenschaften::$jaeger_infos->min_lemin_jaeger_tank_start;
		return $lemin;
	}
	
	/**
	 * Tankt das Lemin vom uebergebenen Planeten auf das gegebene Schiff, sodass eine bestimmte Obergrenze
	 * nicht ueberschritten wird. Es findet keine Pruefung statt, ob das Schiff auch bei diesem Planeten ist!
	 * arguments: $schiff_id - Die Datenbank-ID des Schiffs, das aufgetankt werden soll.
	 * 			  $planeten_id - Die Datenbank-ID des Planeten, von dem Lemin abgetankt werden soll.
	 */
	function tankeLeminStart($schiff_id, $planeten_id) {
		$schiff_daten = @mysql_query("SELECT lemin, leminmax FROM skrupel_schiffe WHERE id='$schiff_id'");
		$schiff_daten = @mysql_fetch_array($schiff_daten);
		$planeten_res = @mysql_query("SELECT lemin FROM skrupel_planeten WHERE id='$planeten_id'");
		$planeten_res = @mysql_fetch_array($planeten_res);
		$lemin_schiff = $schiff_daten['lemin'];
		$lemin_max_schiff = $schiff_daten['leminmax'];
		$lemin_planet = $planeten_res['lemin'];
		$lemin_planet_abzug = 0;
		$obergrenze = $this->ermittleStreckenVerbrauch($schiff_id);
		if($this->SchiffHatFertigkeit($schiff_id, "sprungtriebwerk")) {
			$fertigkeiten = @mysql_query("SELECT fertigkeiten FROM skrupel_schiffe WHERE id='$schiff_id'");
			$fertigkeiten = @mysql_fetch_array($fertigkeiten);
			$sprung_lemin = substr($fertigkeiten['fertigkeiten'], 11, 3)+0;
			$obergrenze += $sprung_lemin;
		}
		if($obergrenze > $lemin_max_schiff) $obergrenze = $lemin_max_schiff;
		if($lemin_schiff + $lemin_planet > $obergrenze) {
			$lemin_planet_abzug = $obergrenze - $lemin_schiff;
			$lemin_schiff = $obergrenze;
		} else { 
			$lemin_schiff += $lemin_planet;
			$lemin_planet_abzug = $lemin_planet;
		}
		ki_basis::zieheResourcenAb("lemin", $lemin_planet_abzug, $planeten_id);
		@mysql_query("UPDATE skrupel_schiffe SET lemin='$lemin_schiff' WHERE id='$schiff_id'");
	}
	
	/**
	 * Tankt das Lemin vom uebergebenen Planeten auf das gegebene Schiff. Es findet keine Pruefung 
	 * statt, ob das Schiff auch bei diesem Planeten ist!
	 * arguments: $schiff_id - Die Datenbank-ID des Schiffs, das aufgetankt werden soll.
	 * 			  $planeten_id - Die Datenbank-ID des Planeten, von dem Lemin abgetankt werden soll.
	 */
	function tankeLemin($schiff_id, $planeten_id) {
		$schiff_fracht = @mysql_query("SELECT lemin, leminmax FROM skrupel_schiffe WHERE id='$schiff_id'");
		$schiff_fracht = @mysql_fetch_array($schiff_fracht);
		$planeten_res = @mysql_query("SELECT lemin FROM skrupel_planeten WHERE id='$planeten_id'");
		$planeten_res = @mysql_fetch_array($planeten_res);
		$lemin_schiff = $schiff_fracht['lemin'];
		$lemin_schiff_max = $schiff_fracht['leminmax'];
		$lemin_planet = $planeten_res['lemin'];
		$lemin_planet_abzug = 0;
		if($lemin_schiff + $lemin_planet > $lemin_schiff_max) {
			$lemin_planet_abzug = $lemin_schiff_max - $lemin_schiff;
			$lemin_schiff = $lemin_schiff_max;
		}
		else { 
			$lemin_schiff += $lemin_planet;
			$lemin_planet_abzug = $lemin_planet;
		}
		ki_basis::zieheResourcenAb("lemin", $lemin_planet_abzug, $planeten_id);
		@mysql_query("UPDATE skrupel_schiffe SET lemin='$lemin_schiff' WHERE id='$schiff_id'");
	}
	
	/**
	 * Leert den Frachtraum des uebegebenen Schiffs auf den uebegebenen Planeten. Es wird nicht geprueft, 
	 * ob das Schiff wirklich beim Planeten ist!
	 * arguments: $schiff_id - Die Datenbank-ID des Schiffs, des Frachtraum geleert werden soll.
	 * 			  $planeten_id - Die Datenbank-ID des Planeten, auf das die Fracht geladen werden soll.
	 */
	static function leereFrachtRaum($schiff_id, $planeten_id) {
		$schiff_fracht = @mysql_query("SELECT fracht_cantox, fracht_vorrat, fracht_min1, 
			fracht_min2, fracht_min3, lemin, fracht_leute FROM skrupel_schiffe WHERE id='$schiff_id'");
		$schiff_fracht = @mysql_fetch_array($schiff_fracht);
		$planeten_res = @mysql_query("SELECT cantox, vorrat, min1, min2, min3, lemin, kolonisten 
			FROM skrupel_planeten WHERE id='$planeten_id'");
		$planeten_res = @mysql_fetch_array($planeten_res);
		$planet_cantox = $planeten_res['cantox'] + $schiff_fracht['fracht_cantox'];
		$planet_vorrat = $planeten_res['vorrat'] + $schiff_fracht['fracht_vorrat'];
		$planet_min1 = $planeten_res['min1'] + $schiff_fracht['fracht_min1'];
		$planet_min2 = $planeten_res['min2'] + $schiff_fracht['fracht_min2'];
		$planet_min3 = $planeten_res['min3'] + $schiff_fracht['fracht_min3'];
		$planet_lemin = $planeten_res['lemin'] + $schiff_fracht['lemin'];
		$planet_leute = $planeten_res['kolonisten'] + $schiff_fracht['fracht_leute'];
		if($planet_cantox < 0) $planet_cantox = 0;
		if($planet_vorrat < 0) $planet_vorrat = 0;
		if($planet_min1 < 0) $planet_min1 = 0;
		if($planet_min2 < 0) $planet_min2 = 0;
		if($planet_min3 < 0) $planet_min3 = 0;
		if($planet_lemin < 0) $planet_lemin = 0;
		if($planet_leute < 0) $planet_leute = 0;
		@mysql_query("UPDATE skrupel_planeten SET cantox='$planet_cantox', vorrat='$planet_vorrat', 
			min1='$planet_min1', min2='$planet_min2', min3='$planet_min3', lemin='$planet_lemin', 
			kolonisten='$planet_leute' WHERE id='$planeten_id'");
		@mysql_query("UPDATE skrupel_schiffe SET fracht_cantox=0, fracht_vorrat=0, fracht_min1=0, 
			fracht_min2=0, fracht_min3=0, lemin=0, fracht_leute=0 WHERE id='$schiff_id'");
	}
	
	/**
	 * Baut alle Projektile fuer die Projektil-Waffen des uebergebenen Schiffs, sofern die Resourcen des 
	 * Planeten ausreichen.
	 * arguments: $schiff_id - Die Datenbank-ID des Schiffs, bei dem Projektile gebaut werden sollen.
	 */
	function baueProjektile($schiff_id) {
		$schiff_infos = @mysql_query("SELECT kox, koy, projektile_anzahl, projektile 
			FROM skrupel_schiffe WHERE id='$schiff_id'");
		$schiff_infos = @mysql_fetch_array($schiff_infos);
		$x_pos = $schiff_infos['kox'];
		$y_pos = $schiff_infos['koy'];
		$max_projektile = $schiff_infos['projektile_anzahl'] * 5;
		$vorhandene_projektile = $schiff_infos['projektile'];
		if($max_projektile == 0) return;
		$spiel_id = eigenschaften::$spiel_id;
		$planeten_res =  @mysql_query("SELECT cantox, min1, min2 FROM skrupel_planeten 
			WHERE (x_pos='$x_pos') AND (y_pos='$y_pos') AND (spiel='$spiel_id')");
		$planeten_res = @mysql_fetch_array($planeten_res);
		$planet_cantox = $planeten_res['cantox'];
		$planet_min1 = $planeten_res['min1'];
		$planet_min2 = $planeten_res['min2'];
		if($planet_cantox < 35 || $planet_min1 < 2 || $planet_min2 < 1) return;
		$mehr_projektile = true;
		while($planet_cantox >= 35 && $planet_min1 >= 2 && $planet_min2 >= 1 
		&& $vorhandene_projektile < $max_projektile) {
			$vorhandene_projektile++;
			$planet_cantox -= 35;
			$planet_min1 -= 2;
			$planet_min2 -= 1;
		}
		@mysql_query("UPDATE skrupel_schiffe SET projektile='$vorhandene_projektile', projektile_auto=1 
				WHERE id='$schiff_id'");
		@mysql_query("UPDATE skrupel_planeten SET cantox='$planet_cantox', min1='$planet_min1', 
			min2='$planet_min2' WHERE (x_pos='$x_pos') AND (y_pos='$y_pos') AND (spiel='$spiel_id')");
	}
	
	/**
	 * Fliegt das uebegebene Schiff zu den uebergebenen Ziel-Koordinaten mit der uebegebenen Ziel-ID und 
	 * der uebergebenen Warp-Geschwindigkeit. Hat das Schiff ein Sprungtriebwerk, ist die Entfernung 
	 * groesser als die maximale Sprung-Reichweite und bleibt nach dem Sprung noch genuegend Lemin uebrig, 
	 * so wird das Sprungtriebwerk aktiviert.
	 * arguments: $schiff_id - Die Datenbank-ID des zu fliegenden Schiffs.
	 * 			  $ziel_x - Die X-Koordinaten des Ziels.
	 * 			  $ziel_y - Die Y-Koordinaten des Ziels.
	 * 			  $warp - Die Warp-Geschwindigkeit, mit der geflogen wird.
	 * 			  $ziel_id - Die Datenbank-ID des Ziels, falls das Ziel ein Schiff oder ein Planet ist.
	 */
	function fliegeSchiff($schiff_id, $ziel_x, $ziel_y, $warp, $ziel_id) {
		if($ziel_x == 0 && $ziel_y == 0) return;
		if($ziel_id != null && $ziel_id != 0) {
			$spiel_id = eigenschaften::$spiel_id;
			$comp_id = eigenschaften::$comp_id;
			$feind_schiff_id = @mysql_query("SELECT id FROM skrupel_schiffe WHERE (NOT (besitzer='$comp_id')) 
				AND (kox='$ziel_x') AND (koy='$ziel_y') AND (id='$ziel_id') AND (spiel='$spiel_id')");
			$feind_schiff_id = @mysql_fetch_array($feind_schiff_id);
			$flug = 2;
			if($feind_schiff_id['id'] != null && $feind_schiff_id['id'] == $ziel_id) $flug = 3;
			@mysql_query("UPDATE skrupel_schiffe SET zielx='$ziel_x', ziely='$ziel_y', 
				warp='$warp', flug='$flug', zielid='$ziel_id' WHERE id='$schiff_id'");
		}
		else @mysql_query("UPDATE skrupel_schiffe SET zielx='$ziel_x', ziely='$ziel_y', zielid=0, 
			warp='$warp', flug=1 WHERE id='$schiff_id'");
		if(!schiffe_basis::SchiffHatFertigkeit($schiff_id, "sprungtriebwerk")) return;
		$schiff_infos = @mysql_query("SELECT fertigkeiten, lemin, kox, koy FROM skrupel_schiffe 
			WHERE id='$schiff_id'");
		$schiff_infos = @mysql_fetch_array($schiff_infos);
		$fertigkeiten = $schiff_infos['fertigkeiten'];
		$lemin_schiff = $schiff_infos['lemin'];
		$x_pos = $schiff_infos['kox'];
		$y_pos = $schiff_infos['koy'];
		$sprung_lemin = substr($fertigkeiten, 11, 3)+0;
		if(($lemin_schiff - $sprung_lemin) < eigenschaften::$schiffe_infos->min_restlemin_sprung) return;
		$sprung_min_strecke = substr($fertigkeiten, 14, 4)+0;
		$sprung_max_strecke = substr($fertigkeiten, 18, 4)+0;
		//Falls es moeglich ist, dass das Schiff durch das Sprungtriebwerk ausserhalb der Karte landet, 
		//wird das Sprungtriebwerk nicht aktiviert.
		$weitester_zielpunkt = ki_basis::berechneWegPunkt($sprung_max_strecke, $x_pos, $y_pos, 
							   $ziel_x, $ziel_y);
		if(ki_basis::PunktAusserhalb($weitester_zielpunkt[0], $weitester_zielpunkt[1])) return;
		$min_strecke = ($sprung_min_strecke + $sprung_max_strecke) / 2;
		$ziel_entfernung = floor(ki_basis::berechneStrecke($x_pos, $y_pos, $ziel_x, $ziel_y));
		if($ziel_entfernung != 0 && $min_strecke != 0 && $ziel_entfernung >= $min_strecke) 
			@mysql_query("UPDATE skrupel_schiffe SET spezialmission=7 WHERE id='$schiff_id'");
	}
	
	/**
	 * Fliegt das uebergebene Schiff zum naechsten wichtigen Planeten.
	 * arguments: $schiff_id - Die Datenbank-ID des Schiffs, das geflogen werden soll.
	 */
	function zuWichtigenPlaneten($schiff_id) {
		$schiff_daten = @mysql_query("SELECT kox, koy FROM skrupel_schiffe WHERE id='$schiff_id'");
		$schiff_daten = @mysql_fetch_array($schiff_daten);
		$x_start = $schiff_daten['kox']; 
		$y_start = $schiff_daten['koy'];
		$antrieb_stufe = $this->ermittleMaximumWarp($schiff_id);
		$wichtige_koords = array();
		foreach(eigenschaften::$wichtige_planeten_ids as $id) {
			$planet = @mysql_query("SELECT x_pos, y_pos FROM skrupel_planeten WHERE id='$id'");
			$planet = @mysql_fetch_array($planet);
			$wichtige_koords[] = array('x'=>$planet['x_pos'], 'y'=>$planet['y_pos'], 'id'=>$id);
		}
		$naher_planet = ki_basis::ermittleNahesZiel($schiff_id, $wichtige_koords, 
													eigenschaften::$bekannte_wurmloch_daten);
		$x_ziel = $naher_planet['x'];
		$y_ziel = $naher_planet['y'];
		$id_ziel = $naher_planet['id'];
		$this->fliegeSchiff($schiff_id, $x_ziel, $y_ziel, $antrieb_stufe, $id_ziel);
	}
	
	/**
	 * Setzt einen Kurs fuer das gegebene Schiff, sodass um ein gegebenes Objekt (zb. Wurmloch oder Minenfeld)
	 * herumgeflogen wird.
	 * arguments: $schiff_x - Die X-Koordinaten des Schiffs, dass gegebenenfalls ein Objekt umfliegen soll.
	 * 			  $schiff_y - Die Y-Koordinaten des Schiffs, dass gegebenenfalls ein Objekt umfliegen soll.
	 * 			  $schiff_id - Die Datenbank-ID des Schiffs, dass gegebenenfalls ein Objekt umfliegen soll.
	 * 			  $objekt_x - Die X-Koordinaten des Objekts, dass umflogen werden soll.
	 * 			  $objekt_y - Die Y-Koordinaten des Objekts, dass umflogen werden soll.
	 * 			  $schiff_ziel_x - Die X-Koordinaten des Ziels, zu dem das Schiff eigentlich hin soll.
	 * 			  $schiff_ziel_y - Die Y-Koordinaten des Ziels, zu dem das Schiff eigentlich hin soll.
	 * 			  $schiff_ziel_id - Die Datenbank-ID des Ziels, zu dem das Schiff eigentlich hin soll.
	 * 			  $mindestabstand - Der Abstand (in Lj), der zum Objekt, das umflogen werden soll, genommen 
	 * 								werden soll.
	 * returns: true - Falls das Objekt umflogen werden muss und dabei gleich der Kurs gesetzt wurde.
	 * 			false - Sonst. Dabei wurde kein Kurs gesetzt.
	 */
	function umfliegeObjekt($schiff_x, $schiff_y, $schiff_id, $objekt_x, $objekt_y, 
							$schiff_ziel_x, $schiff_ziel_y, $schiff_ziel_id , $mindestabstand) {
		//Zielvektor fuer die direkte Flugrichtung:
		$zielvek_x = $schiff_ziel_x - $schiff_x;
		$zielvek_y = $schiff_ziel_y - $schiff_y;
		//Vektor zum objekt:
		$wurmvek_x = $objekt_x - $schiff_x;
		$wurmvek_y = $objekt_y - $schiff_y;
		
		//Der Zielvektor wird normiert:
		$zielvek_betrag = sqrt($zielvek_x * $zielvek_x + $zielvek_y * $zielvek_y);
		if($zielvek_betrag == 0) return false;
		$zielnvek_x = $zielvek_x / $zielvek_betrag;
		$zielnvek_y = $zielvek_y / $zielvek_betrag;
		
		//Projektion des Vektors zum objekt auf Zielstrecke:
		$proj = $wurmvek_x * $zielnvek_x + $wurmvek_y * $zielnvek_y;
		//Falls der eingeschlossene Winkel der Vektoren groesser als 90 Grad ist, so ist $proj negativ 
		//und ein Ausweichen unnoetig.
		if($proj >= 0) {
			//Der Fusspunkt ist der Punkt der direkten Flugstrecke, der dem objekt am naechsten kommt.
			$fuss_x = $schiff_x + $proj * $zielnvek_x;
			$fuss_y = $schiff_y + $proj * $zielnvek_y;
			
			//Senkrecht zur direkten Flugstrecke stehender Vektor mit Laenge des min. Abstands zum objekt
			$wurmabstandvek_x = $fuss_x - $objekt_x;
			$wurmabstandvek_y = $fuss_y - $objekt_y;
			//Falls das objekt (fast) genau auf Zielstrecke ist:
      		if((abs($wurmabstandvek_x) < 1) && (abs($wurmabstandvek_y) < 1)) {
				//Hier wird der senkrecht zur Flugstrecke stehende (normierte) Ausweichvektor generiert:	
      			$wurmabstandvek_x = $zielnvek_y;
				$wurmabstandvek_y = -$zielnvek_x;
      		}
      		$wurmabstandvek_betrag = sqrt($wurmabstandvek_x * $wurmabstandvek_x + 
      									  $wurmabstandvek_y * $wurmabstandvek_y);
      		//Falls ein ausreichender objektabstand beim Direktflug doch gegeben ist:
      		if($wurmabstandvek_betrag >= $mindestabstand) return false;
			$faktor = $mindestabstand / $wurmabstandvek_betrag;
			
			//Umgehungswegpunkt zur objektmeidung
			$zwischen_x = round($objekt_x + $faktor * $wurmabstandvek_x);
			$zwischen_y = round($objekt_y + $faktor * $wurmabstandvek_y);
			
			//Nun wird der Kurs zum Ausweich-Punkt gesetzt. Ausserdem werden die relevanten Daten in die 
			//Datenbank geschrieben.
			$warp = $this->ermittleMaximumWarp($schiff_id);
			$this->fliegeSchiff($schiff_id, $zwischen_x, $zwischen_y, $warp, null);
			$umflug_daten = "".$zwischen_x.":".$zwischen_y.":".$schiff_ziel_x.":".$schiff_ziel_y.
							":".$schiff_ziel_id;
			@mysql_query("UPDATE skrupel_schiffe SET routing_schritt=1, routing_koord='$umflug_daten' 
				WHERE id='$schiff_id'");
			return true;
		}
		return false;
	}
	
	/** 
	 * Prueft, ob das gegebene Schiff ein nahes Objekt umfliegen muss. Falls ja, wird ein entsprechender 
	 * Kurs gesetzt.
	 * arguments: $schiff_id - Die Datenbank-ID des Schiffs, dass gegebenenfalls ein Objekt umfliegen soll.
	 * returns: true, falls ein Objekt umflogen werden muss. Dabei wurde ein Kurs gesetzt.
	 * 			false, sonst. Dan wurde kein Kurs gesetzt.
	 * Mitwirkende Autoren: Jonu.
	 */
	function mussObjektUmfliegen($schiff_id) {
		$schiff_daten = @mysql_query("SELECT kox, koy, zielx, ziely, zielid FROM skrupel_schiffe 
			WHERE id='$schiff_id'");
		$schiff_daten = @mysql_fetch_array($schiff_daten);
		$schiff_x = $schiff_daten['kox'];
		$schiff_y = $schiff_daten['koy'];
		$schiff_ziel_x = $schiff_daten['zielx'];
		$schiff_ziel_y = $schiff_daten['ziely'];
		$schiff_ziel_id = $schiff_daten['zielid'];
		foreach(eigenschaften::$gesehene_wurmloecher_daten as $wurmloch) {
			if($wurmloch['x'] == $schiff_ziel_x && $wurmloch['y'] == $schiff_ziel_y) return false;
		}
		$anomalien_koords = array();
		$spiel_id = eigenschaften::$spiel_id;
		$comp_id = eigenschaften::$comp_id;
		$anomalien = @mysql_query("SELECT x_pos, y_pos, id, art FROM skrupel_anomalien 
			WHERE (spiel='$spiel_id') AND (sicht_".$comp_id."=1) AND ((art=1) OR (art=2) OR (art=5))");
		while($anomalie = @mysql_fetch_array($anomalien)) {
			if($anomalie['art'] == 5) {
				$besitzer = ki_basis::ermittleMinenfeldBesitzer($anomalie['id']);
				if($besitzer == eigenschaften::$comp_id) continue;
			}
			$anomalien_koords[] = array('x'=>$anomalie['x_pos'], 'y'=>$anomalie['y_pos'], 'id'=>$anomalie['id']);
		}
		//Erstmal wird die naechste Anomoalie gesucht, die ein Wurmloch, ein Sprungtor oder ein Minenfeld ist.
		$nahe_anomalie = ki_basis::ermittleNahesZiel($schiff_id, $anomalien_koords, null);
		//Wurde keine solche Anomalie gefunden, so wird auch keine umflogen.
		if($nahe_anomalie == null || $nahe_anomalie['id'] == 0) return false;
		$anomalie_x = $nahe_anomalie['x'];
		$anomalie_y = $nahe_anomalie['y'];
		$anomalie_art = @mysql_query("SELECT art FROM skrupel_anomalien WHERE (x_pos='$anomalie_x') AND 
			(y_pos='$anomalie_y') AND (spiel='$spiel_id')");
		$anomalie_art = @mysql_fetch_array($anomalie_art);
		$anomalie_art = $anomalie_art['art'];
		$abstand = 100;
		//Je nach Art des Objekts wird ein anderer Sicherheits-Abstand gewaehlt. Plasma-Stuerme werden 
		//nicht umflogen.
		if($anomalie_art == 5) $abstand = eigenschaften::$schiffe_infos->mindest_minenfeld_abstand;
		elseif($anomalie_art == 1 || $anomalie_art == 2) 
			$abstand = eigenschaften::$schiffe_infos->mindest_wurmloch_abstand;
		else return false;
		return $this->umfliegeObjekt($schiff_x, $schiff_y, $schiff_id, $nahe_anomalie['x'], $nahe_anomalie['y'], 
									 $schiff_ziel_x, $schiff_ziel_y, $schiff_ziel_id , $abstand);
	}
	
	/**
	 * Prueft, ob das uebergebene Schiff von einem gegnerischen Schiff angegriffen wird und laesst das Schiff
	 * gegebenenfalls fluechten. Dabei wird zu einem Planeten gefluechtet, der in die entgegengesetzte Richtung
	 * des Angreifers liegt.
	 * arguments: $schiff_id - Die Datenbank-ID des Schiffs, das vieleicht fluechten soll.
	 * returns: true - Falls das Schiff angegriffen wird und fluechtet.
	 * 			false - Sonst.
	 */
	function flieheVorSchiff($schiff_id) {
		$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'];
		$kleine_entfernung = eigenschaften::$frachter_infos->max_gegner_frachter_naehe;
		$naher_gegner_id = 0;
		$naher_gegner_x = 0;
		$naher_gegner_y = 0;
		foreach(eigenschaften::$sichtbare_gegner_schiffe as $gegner_schiff) {
			$gegner_x = $gegner_schiff['x'];
			$gegner_y = $gegner_schiff['y'];
			$entfernung = floor(ki_basis::berechneStrecke($schiff_x, $schiff_y, $gegner_x, $gegner_y));
			if($entfernung < $kleine_entfernung) {
				$kleine_entfernung = $entfernung;
				$naher_gegner_x = $gegner_x;
				$naher_gegner_y = $gegner_y;
			}
		}
		if($naher_gegner_x != 0 || $naher_gegner_y != 0) {
			$flucht_koords = ki_basis::ermittleFluchtKoordinaten($schiff_id, $naher_gegner_x, $naher_gegner_y);
			$warp = $this->ermittleMaximumWarp($schiff_id);
			$this->fliegeSchiff($schiff_id, $flucht_koords['x'], $flucht_koords['y'], $warp, null);
			return true;
		}
		return false;
	}
	
	/**
	 * Ermittelt den naechst-gelegenen Planeten und fliegt dort hin. Es wird dabei nicht geprueft, ob der 
	 * naechste Planet feindlich ist oder nicht.
	 * arguments: $schiff_id - Die Datenbank-ID des Schiffs, das tanken fliegen soll.
	 */
	function fliegeTanken($schiff_id) {
		$schiff_pos = @mysql_query("SELECT kox, koy FROM skrupel_schiffe WHERE id='$schiff_id'");
		$schiff_pos = @mysql_fetch_array($schiff_pos);
		$x_pos = $schiff_pos['kox'];
		$y_pos = $schiff_pos['koy'];
		$warp = $this->ermittleMaximumWarp($schiff_id);
		$ziel_planet = ki_basis::ermittleNahenPlaneten($x_pos, $y_pos, null, false, true);
		$this->fliegeSchiff($schiff_id, $ziel_planet['x'], $ziel_planet['y'], $warp, $ziel_planet['id']);
	}
	
	/**
	 * Scannt die Umgebung nach Planeten, um Planeten ins Logbuch des Schiffs zu speichern, die sich nicht fuer 
	 * die Kolonisierung lohnen. Ist das Schiff ein Frachter mit Kolonisten, so wird das Schiff sofort wo 
	 * anders hin geflogen. In dieser Implementierung wird hoechstens ein Planet erfasst!
	 * arguments: $schiff_id - Die Datenbank-ID des Schiffs, das seine Umgebung nach Planeten scant.
	 * returns: true - Falls das Schiff ein Frachter mit Kolonisten ist und dieser umgeleitet wurde.
	 * 			false - Falls keine Flug-Aenderung vorgenommen wurde bzw. das Schiff keine Kolonisten an 
	 * 					Bord hat.
	 */
	function scanneUmgebung($schiff_id) {
		$schiff_daten = @mysql_query("SELECT kox, koy, fracht_leute, status, lemin FROM skrupel_schiffe 
				WHERE id='$schiff_id'");
		$schiff_daten = @mysql_fetch_array($schiff_daten);
		$x_pos = $schiff_daten['kox'];
		$y_pos = $schiff_daten['koy'];
		$fracht_leute = $schiff_daten['fracht_leute'];
		$schiff_status = $schiff_daten['status'];
		$schiff_lemin = $schiff_daten['lemin'];
		//Kolonien der KI werden nicht beruecksichtigt.
		$naher_planet = ki_basis::ermittleNahenPlaneten($x_pos, $y_pos, eigenschaften::$kolonien_ids, 
						false, true);
		if($naher_planet != null && $naher_planet['id'] != null && $naher_planet['id'] != 0) {
			$entfernung = floor(ki_basis::berechneStrecke($x_pos, $y_pos, $naher_planet['x'], 
														  $naher_planet['y']));
			if($entfernung <= $this->ermittleSchiffScanweite($schiff_id)) {
				if(!(ki_basis::PlanetLohntSich($naher_planet['id']))) {
					if($fracht_leute >= eigenschaften::$frachter_kolo_infos->kolo_leute) {
						frachter_basis::fliegeKolonieSchiff($schiff_id);
						if($schiff_status == 2) $this->tankeLemin($schiff_id, $naher_planet['id']);
						elseif($this->ermittleStreckenVerbrauch($schiff_id) > $schiff_lemin) {
							$warp = $this->ermittleMaximumWarp($schiff_id);
							$this->fliegeSchiff($schiff_id, $naher_planet['x'], $naher_planet['y'], 
												$warp, $naher_planet['id']);
						}
						return true;
					}
				}
			}
		}
		return false;
	}
	
	/**
	 * Ueberprueft, ob das gegebene Schiff gerade durch ein stabiles Wurmloch geflogen ist.
	 * arguments: $schiff_id - Die Datenbank-ID des Schiffs, bei dem geprueft werden soll, ob es durch ein 
	 * 						   Wurmloch geflogen ist.
	 * returns: Die Datenbank-ID sowie die X- und Y-Koordinate des Wurmlochs, durch das das Schiff gekommen 
	 * 			ist, falls das Schiff durch ein Wurmloch flog.
	 * 			null, sonst.
	 */
	function durchWurmlochGeflogen($schiff_id) {
		$schiff_daten = @mysql_query("SELECT kox, koy, zielx, ziely, zielid, status, flug FROM skrupel_schiffe 
			WHERE id='$schiff_id'");
		$schiff_daten = @mysql_fetch_array($schiff_daten);
		$x_pos = $schiff_daten['kox'];
		$y_pos = $schiff_daten['koy'];
		$ziel_x = $schiff_daten['zielx'];
		$ziel_y = $schiff_daten['ziely'];
		$ziel_id = $schiff_daten['zielid'];
		if($ziel_id != 0 || $ziel_x != 0 || $ziel_y != 0) return null;
		foreach(eigenschaften::$gesehene_wurmloecher_daten as $wurmloch_daten) {
			$wurmloch_x = $wurmloch_daten['x'];
			$wurmloch_y = $wurmloch_daten['y'];
			$wurmloch_id = $wurmloch_daten['id'];
			if($wurmloch_id == null || $wurmloch_id == 0) continue;
			$wurmloch_entfernung = floor(ki_basis::berechneStrecke($x_pos, $y_pos, $wurmloch_x, $wurmloch_y));
			if($wurmloch_entfernung > 20) continue;
			$spiel_id = eigenschaften::$spiel_id;
			$extra = @mysql_query("SELECT extra FROM skrupel_anomalien WHERE id='$wurmloch_id'");
			$extra = @mysql_fetch_array($extra);
			$extra = $extra['extra'];
			//Hat das Wurmloch keine Ziel-Informationen, so ist es instabil.
			if($extra == null || $extra == "" || $extra == '') {
				wurmloecher_basis::updateInstabileWurmloecher($wurmloch_id);
				return null;
			}
			wurmloecher_basis::updateBekannteWurmloecher($wurmloch_id);
			return wurmloecher_basis::ermittleWurmlochZiel($wurmloch_id);
		}
		return null;
	}
	
	/**
	 * Verwaltet das Verhalten von Schiffen mit Wurmloechern. Ist das Schiff durch ein Wurmloch geflogen, so 
	 * wird ein Kurs gesetzt und das Wurmloch gegebenenfalls durchflogen.
	 * arguments: $schiff_id - Die Datenbank-ID des Schiffs, dessen Wurmloch-Verhalten bestimmt wird.
	 * returns: true, falls das Schiff mit einem Wurmloch interagiert.
	 * 			false, sonst.
	 */
	function reagiereAufWurmloch($schiff_id) {
		$schiff_daten = @mysql_query("SELECT status, flug, kox, koy, fracht_leute, routing_schritt, 
			routing_koord FROM skrupel_schiffe WHERE id='$schiff_id'");
		$schiff_daten = @mysql_fetch_array($schiff_daten);
		if($schiff_daten['status'] == 2 && $schiff_daten['flug'] == 0) return false;
		$warp = $this->ermittleMaximumWarp($schiff_id);
		$x_pos = $schiff_daten['kox'];
		$y_pos = $schiff_daten['koy'];
		$schiff_flug = $schiff_daten['flug'];
		$schiff_status = $schiff_daten['status'];
		$fracht_leute = $schiff_daten['fracht_leute'];
		$wurmloch_flug_status = $schiff_daten['routing_schritt'];
		$wurmloch_flug_daten = $schiff_daten['routing_koord'];
		//Ist das Schiff im freien Raum und steht still, so wird ueberprueft, ob es gerade durch ein Wurmloch
		//geflogen ist. Falls ja, wird gegebenenfalls das Wurmloch umflogen.
		if($schiff_status == 1 && $schiff_flug == 0) {
			$wl_daten = $this->durchWurmlochGeflogen($schiff_id);
			if($wl_daten != null && $wl_daten['id'] != null && $wl_daten['id'] != 0) {
				if($this instanceof frachter_basis) {
					if($fracht_leute < eigenschaften::$frachter_kolo_infos->kolo_leute) 
						$this->zuWichtigenPlaneten($schiff_id);
					else $this->fliegeKolonieSchiff($schiff_id);
				} elseif($this instanceof jaeger_basis) $this->fliegeJaeger($schiff_id);
				elseif($this instanceof scouts_basis) $this->fliegeScout($schiff_id);
				elseif($this instanceof spezialschiffe_leicht) $this->fliegeTasterSchiff($schiff_id);
				$ziel_daten = @mysql_query("SELECT zielx, ziely, zielid FROM skrupel_schiffe 
					WHERE id='$schiff_id'");
				$ziel_daten = @mysql_fetch_array($ziel_daten);
				if($this->umfliegeObjekt($x_pos, $y_pos, $schiff_id, $wl_daten['x'], $wl_daten['y'], 
										 $ziel_daten['zielx'], $ziel_daten['ziely'], $ziel_daten['zielid'], 
										 eigenschaften::$schiffe_infos->mindest_wurmloch_abstand))
					return true;
			}
			if($schiff_flug == 0) {
				if($this instanceof frachter_basis) {
					if($fracht_leute < eigenschaften::$frachter_kolo_infos->kolo_leute) 
						$this->zuWichtigenPlaneten($schiff_id);
					else $this->fliegeKolonieSchiff($schiff_id);
				} elseif($this instanceof jaeger_basis) $this->fliegeJaeger($schiff_id);
				elseif($this instanceof scouts_basis) $this->fliegeScout($schiff_id);
				elseif($this instanceof spezialschiffe_leicht) $this->fliegeTasterSchiff($schiff_id);
				return true;
			}
		}
		//Ist das Schiff gerade dabei, ein Wurmloch zu umfliegen, das er gerade passiert hatte, so wird 
		//geprueft, ob es es schon weit genug umflogen hat, sodass er nun direkt zum urspruenglichen Ziel
		//fliegen kann.
		if($wurmloch_flug_status == 1) {
			$wurmloch_flug_daten = explode(':', $wurmloch_flug_daten);
			$ziel_x = $wurmloch_flug_daten[0];
			$ziel_y = $wurmloch_flug_daten[1];
			if($ziel_x == $x_pos && $ziel_y == $y_pos) {
				@mysql_query("UPDATE skrupel_schiffe SET routing_schritt=0, routing_koord='' 
						WHERE id='$schiff_id'");
				$this->fliegeSchiff($schiff_id, $wurmloch_flug_daten[2], $wurmloch_flug_daten[3], 
									$warp, $wurmloch_flug_daten[4]);
			}
			return true;
		}
		//Hier wird ueberprueft, ob das Schiff auf dem Weg zu einem bekannten Wurmloch ist. Falls es schon 
		//durch das Wurmloch geflogen ist, so wird das Ausgangs-Wurmloch gegebenenfalls umflogen.
		if($wurmloch_flug_status == 2) {
			$wurmloch_flug_daten = explode(':', $wurmloch_flug_daten);
			$wurmloch_x = $wurmloch_flug_daten[0];
			$wurmloch_y = $wurmloch_flug_daten[1];
			$wurmloch_id = $wurmloch_flug_daten[2];
			$wurmloch_ziel_id = wurmloecher_basis::ermittleWurmlochZiel($wurmloch_id);
			if($wurmloch_ziel_id != null && $wurmloch_ziel_id['id'] != null && $wurmloch_ziel_id['id'] != 0) {
				$wurmloch_ziel_id = $wurmloch_ziel_id['id'];
				$wurmloch_ziel_daten2 = $this->durchWurmlochGeflogen($schiff_id);
				$wurmloch_ziel_id2 = $wurmloch_ziel_daten2['id'];
				//Falls das Schiff schon durch das Wurmloch geflogen ist, wird gecheckt, ob das Wurmloch 
				//umflogen werden muss.
				if($wurmloch_ziel_id == $wurmloch_ziel_id2 && 
				$wurmloch_ziel_id != null && $wurmloch_ziel_id != 0 && 
				$wurmloch_ziel_id2 != null && $wurmloch_ziel_id2 != 0) {
					$umflug_x = $wurmloch_ziel_daten2['x'];
					$umflug_y = $wurmloch_ziel_daten2['y'];
					$zielx = $wurmloch_flug_daten[3];
					$ziely = $wurmloch_flug_daten[4];
					$zielid = $wurmloch_flug_daten[5];
					if(!($this->umfliegeObjekt($x_pos, $y_pos, $schiff_id, $umflug_x, $umflug_y, $zielx, 
					$ziely, $zielid, eigenschaften::$schiffe_infos->mindest_wurmloch_abstand))) {
						@mysql_query("UPDATE skrupel_schiffe SET routing_schritt=0, routing_koord='' 
								WHERE id='$schiff_id'");
						$this->fliegeSchiff($schiff_id, $zielx, $ziely, $warp, $zielid);
						return true;
					}
				}
				$this->fliegeSchiff($schiff_id, $wurmloch_x, $wurmloch_y, $warp, 0);
				return true;
			}
		}
		return false;
	}
	
	/**
	 * Ueberprueft, ob beim uebergebenen Planeten ein Schiff mit der uebergebenen Klassen-Id ist.
	 * arguments: $planeten_id - Die Datenbank-ID des zu ueberpruefenden Planeten.
	 * 			  $klassen_id - Die Klassen-ID des gesuchten Schiffs.
	 * returns: true, falls ein solches Schiff am Planeten ist.
	 * 			false, sonst.
	 */
	static function ermittleSchiffanPlaneten($planeten_id, $klassen_id) {
		$spiel_id = eigenschaften::$spiel_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_pos = $planeten_daten['x_pos'];
		$y_pos = $planeten_daten['y_pos'];
		$schiff_daten = @mysql_query("SELECT klasseid FROM skrupel_schiffe WHERE (kox='$x_pos') 
			AND (koy='$y_pos') AND (spiel='$spiel_id')");
		while($schiff_klasse = @mysql_fetch_array($schiff_daten)) {
			if($schiff_klasse['klasseid'] == $klassen_id) return true;
		}
		return false;
	}
}
?>
Return current item: Skrupel KI