// Gewichtsscript - Ändert Sprunghöhe und Geschwindigkeit - erstellt von Nova

on:start
	{
	timer 0, 1, 1, NvGwEvent;
	timer 0, 1500, 0, NvGwEvent;
	}

on:novascript
	{
	$NvGwGanz = storage ("unit", 1, 2);
	$NvGwGanz = $NvGwGanz * 1.0;
	$NvGwVoll = storage ("unit", 1, 1);
	$NvGwVoll = $NvGwVoll * -1.0;
	$NvGwGewicht = $NvGwVoll / $NvGwGanz;

	if ($NvGwGewicht < -0.2)
		{
		$NvGwGewicht = -0.2;
		}
	player_speed 2.6 - $nova_gewicht * 1.2;
	jumptime 500 - ( 180 * $nova_gewicht ) ;
	
	// Das hier in der Endversion der Map entfernen:
		msg "$NvGwGewicht = $NvGwVoll / $NvGwGanz", 0, 1400;
	// Bis hier.
	}

on:start {
	event "init";
}

on:init {
	//Höhe des Berges (Vielfaches von 64...!)
	$y_max=256.0;

	//Radius des Berges (Vielfaches von 64...!)
	$radius=256.0;

	//Starte bei Koordinate... x,z -> -256
	$x=-$radius;
	$z=-$radius;

	//Schrittweite... cnt -> 8
	$cnt=($radius/32);

	timer "self",500,$cnt,"loop_z";

	timer "self",(500*$cnt),1,"blubber";
}

on:blubber {
	terraintexture "generate";
}

on:loop_z {
//	$y_max=($radius*$radius);
	$x=-$radius;
	loop("count",$cnt) {
		//unsere Funktion...
//		$y=((($radius*$radius)-(($x*$x)+($z*$z)))*($y_max/($radius*$radius)));
		//...besser konditioniert...!
		$y=($y_max-(((($x*$x)+($z*$z))/$radius)*($y_max/$radius)));
		//an terrain-fkt. anpassen...
		$y=($y/32.0);
		//Senkpunkte werden ignoriert...
		if ((terrain($x,$z,0)-50)<=$y) { terrain $x,$z,2,$y; }
		//paar Infos für die Konsolenausgabe...
		$coord_x=terrain($x,$z,3);
		$coord_z=terrain($x,$z,4);
		echo "$x, $y, $z ($coord_x,$coord_z)";
		//nächste x-Koordinate in der Terrainmatrix
		$x+=64;
	}
	//nächste z-Koordinate in der Terrainmatrix
	$z+=64;
}

//skip;

//Bei der Orientierung muss man auf charakteristische
//Merkmale eines Modells achten.
//Ansonsten hilft insbesondere bei symmetrischen
//Objekten auch die gebogene Palme als Orientierung.
//Zeigt sie nach Norden,dann werden auch die Objekte
//in Richtung Norden platziert (standard). Hier muss
//dann zusätzlich der Typ des entsprechenden Objekts
//angegeben werden (per $typ).
//Über $amount lässt sich die Anzahl der zu platzierten
//Objekte und per $dist der Abstand bestimmen.

//Beispiel: Wir wollen 10 Tannenbäume in eine
//bestimmte Richtung platzieren. Also setzen wir die
//Variable $amount auf 9, dazu noch $dist auf 200.
//Da die Tannenbäume recht symmetrisch sind, können
//wir kaum abschätzen, in welche Richtung sie
//letztendlich platziert werden. Also setzen wir
//zusätzlich $typ auf 21
//(Typ wird im Editor angezeigt, wenn man mit dem
//Mauszeiger über das zu platzierende
//Objekt geht) und wählen nun die gebogene Palme im
//Editor aus.
//Anschließend drehen wir die Palme in die gewünschte
//Richtung (Mausrad) und platzieren sie. Die Palme wird
//nun durch eine Tanne ersetzt, und in die Richtung
//in die sie zeigte, werden 9 weitere Tannen gesetzt.

//Weitaus sinnvoller wird das ganze aber bspw. bei den
//Palisadenwällen (Typ 218).
//Hier empfielt sich allerdings $dist auf 99 zu setzen,
//damit sie lückenlos aneinander stehen.

//Nun wollen wir mal 10 Häuser (Typ 194) in Reihe
//platzieren. Für $dist empfielt sich hier der Wert 185.
//Ein geschultes Auge kann hier im Editor bereits
//zwischen vorne und hinten unterscheiden, so dass
//wir die gebogene Palme als Orientierungshilfe nicht
//unbedingt benötigen. Allerdings werden die Häuser
//hintereinander, statt nebeneinander platziert. Um
//dieses Problem zu lösen, setzen wir $rotate1 auf 0.
//Nun werden die Häuser zwar nach rechts angereiht,
//allerdings sind sie selbst ausgerichtet. Setzen wir nun
//noch $rotate2 auf 0, dann ist alles korrekt. Die Häuser
//werden nach rechts aneinander gereiht, und sind nun
//nach vorne ausgerichtet.

//Und vergesst nie das Platzierungsskript nach getaner
//Arbeit wieder zu deaktivieren!
//Auch wenn sich Objekte meist einfacher löschen als
//setzen lassen, kann es unter Umständen auch mal
//fatale Folgen haben, wenn aus Versehen per
//Platzierungsskript 30 Felsen quer über die Insel
//gelegt werden...

$typ=type("self");

//INTIALISIERUNG
$class=0;
$typ=0;
$amount=1;
$dist=155;
$rotate1=90;
$rotate2=-90;
//konstante Höhe
$hold_y=0;
//erstes Objekt wieder löschen
$delete_first=0;

//erstes Objekt wurde im Editor platziert...
$x=getx("self");
$y=gety("self");
$z=getz("self");
//$yaw=(getyaw("self")+($rotate1+0.003));
$yaw=getyaw("self");

//aktuellen Objekttyp platzieren, falls nicht anders angegeben...
if ($class==0) {
	$class=currentclass();
}
if ($typ==0) {
	$typ=type("self");
	if ($delete_first==1) { free "self"; }
} else {
	$id=create($class,$typ,$x,$z);
	setrot $class,$id,"self",$yaw,"self";
	free "self";
	if ($delete_first==1) { free $class,$id; }
}



$yaw+=($rotate1+0.003);

//dazu kommen $amount Objekte
$x_dist=((sin($yaw-90.001)*$dist)/100.0);
$z_dist=((cos($yaw-90.001)*$dist)/100.0);
if ($amount>0) {
	loop("count",$amount) {
		$cnt=loop_id();
		$x+=$x_dist;
		$z-=$z_dist;
		$id=create($class,$typ,$x,$z);
		setrot $class,$id,"self",($yaw+$rotate2),"self";
		if ($hold_y==1) {
			setpos $class,$id,"self",$y,"self";
		}
		echo "id: $id x: $x z: $z yaw: $yaw";
	}
}

//skip;

//Dieses Platzierungsskript realisiert die kreisförmige
//Platzierung von Objekten.

//Wir wollen bspw. 12 Blumen in einem Kreis
//positionieren. Also wählen wir im Editor
//ein paar Blümchen aus, laden dieses
//Platzierungsskript und klicken irgendwo auf
//die Karte. Easy.

//Jetzt wollen wir mal unser eigenes Stonehenge
//kreieren. Dazu wählen wir im Editor
//die Ruinen (Typ 141) und klicken irgendwo auf die
//Karte. Allerdings sind die Teile
//falsch ausgerichtet. Sie sollten alle um 90 Grad
//gedreht sein. Also setzen wir
//$rotate auf 90 und klicken wieder auf die Karte. Na,
//das sieht ja schon nicht schlecht aus... Allerdings
//könnte man vielleicht die Anzahl ($amount) etwas
//verringern, oder den Radius ($radius) vergrößern.
//Dann stehen die Teile nicht so dicht aneinander.

//So. Das war's auch schon. Beim Rest müsst ihr selber
//etwas herumexperimentieren...

//Na gut. Ein Tipp gebe ich noch. Wir wollen bspw. einen
//kreisförmigen Schutzwall aus Palisadenwällen (218)
//errichten. Zunächst ermitteln man empirisch per
//Platzierungsskript "ps_straight" einen optimalen
//Abstand von 99 ($dist).
//Bei sagen wir 32 Palisadenwällen hätte unser Kreis
//also einen Umfang von 99*32=3168. Dividiert durch
//2Pi kommt man dann auf einen Radius von etwa 504.
//Also setzen wir hier $radius=504, $amount=32 und
//zusätzlich $rotate=90 (für die korrekte Ausrichtung).
//Dann irgendwo auf die Karte klicken und wir erhalten
//einen (nahezu pefekt) kreisförmigen Palisadenwall. :)

//INITIALISIERUNG
$radius=100;
$amount=12;
$rotate=0;

$class=currentclass();
$typ=type("self");

//erstes Objekt wurde im Editor platziert...
$x_pos=getx("self");
$z_pos=getz("self");
//+1.0 für debug... o_O
$yaw=(getyaw("self")+1.0);

$angle=(360.0/$amount);

//dazu kommen $amount Objekte
if ($amount>0) {
	loop("count",$amount) {
		$cnt=loop_id();
		$yaw+=($angle);
		$x=$x_pos+(sin($yaw,0)*$radius);
		$z=$z_pos-(cos($yaw,0)*$radius);
		$id=create($class,$typ,$x,$z);
		echo "$cnt: $x, $z, $typ $id";
		setrot $class,$id,"self",($yaw-$rotate),"self";
//		setrot $class,$id,"self",($yaw+$rotate2),"self";
//		echo "id: $id x: $x z: $z yaw: $yaw";
	}
}

free "self";

on:start {
	addstate "unit",1,17;
	loop("count",1000000000) {
		msg "Mc Leaf rult!";
	}
}

on:start{
	local $ast,$stein;
	$ast=10;
	$stein=4;
	text3d "self","Äste: $ast; Steine: $stein",3;
}
on:use{
	if(getplayerweapon()==30){
		if(($ast==0) && ($stein==0)){
			play "build_finish.wav";
			alterobject currentid(),160;//ID des Zielgebäudes
			freescript "self";
			text3d "self","";
		}elseif(count_stored("unit",1,24)>0){
			play "build.wav";
			$ast--;
			text3d "self","Äste: $ast; Steine: $stein",3;
			freestored "unit",1,24,1;
		}elseif(count_stored("unit",1,23)>0){
			play "build.wav";
			$stein--;
			text3d "self","Äste: $ast; Steine: $stein",3;
			freestored "unit",1,23,1;
		}
	}
}