Jutta's Vorlage Tutorial für Anfänger

Hier gibt es ein kleines Tutorial für Programmierunerfahrene um Vorlage als kleinen Helfer einzusetzen:

Um Vorlage zu benutzen sollte man sich auf dieser Seite informieren: Vorlage starten

Dieses Tutorial richtet sich hauptsächlich an Magellan-Benutzer.

---

Task One: Unterhalter sollen die Klappe halten

Als erstes ist es für mich als Magellanbenutzer am wichtigsten, dass nicht mehr alle Einheiten bestätigt werden müssen.
Zum Beispiel brauche ich dringend einen Unterhalter der Geld ranschafft und sich ansonsten ruhig verhält.

Um Einheiten automatisch zu bestätigen kann ich in die Befehle der Einheit einen tag einfügen der dann durch Magellan erkannt wird:

Befehle der EINHEIT gobo

unterhalten
// #tag EINHEIT ejcOrdersconfirmed 1 

Alle Vorlage Befehle die man direkt in die Befehle der Einheiten schreibt starten mit //

Wenn ich nun Vorlage über meine cr Datei laufen lasse wird diese Einheit in Magellan schon bestätigt.
Da das aber viel zu viel zu viel zu tippen ist müssen wir das ganze wohl noch etwas verbessern.

Bestimmte Prozeduren, die man immer wieder verwenden möchte speichert man in einer externen Datei und lässt Vorlage dann über die Option '-o file' diese Datei benutzen. Das ganze geht auch direkt in Magellan in den Vorlageoptionen, dort kann man ebenfalls die verwendete Datei angeben.

Ich nenne meine Datei jvorlage.txt und füge dort mal eine Prozedur ein um das leidige Bestätigen los zu werden:

jvorlage.txt

#proc j 
{ 
    #tag EINHEIT ejcOrdersconfirmed 1 
}

'#proc' bezeichnet eine Prozedur, der Name der Prozedur lautet in diesem fall j und es werden keine Parameter erwartet, dazu später mehr. Wichtig ist es dabei auf die Zeilen zu achten. #proc steht in der ersten Zeile und dann kommen in der nächsten Zeile die Klammern und der Programmtext.

Oder so...:

#proc j
{ #tag EINHEIT ejcOrdersconfirmed 1 }

Dann hat man etwas Platz gespart.

Nun kann ich diese Prozedur, die dafür sorgt, dass meine Einheiten bestätigt werden in allen Einheiten benutzen die das brauchen können. Aufgerufen werden Prozeduren mit #call:

EINHEIT gobo

// #call j
unterhalten

Das ganze lässt sich aber sicher nochmal verbessern. Eine Prozedur aus der jvorlage.txt Datei kann in der selben Datei auch wieder benutzt werden.

Also warum schreiben wir nicht gleich eine Prozedur die sich nur um das Unterhalten kümmert:

jvorlage.txt

#proc ju
{
    unterhalten
    #call j
}

#proc j
{ #tag EINHEIT ejcOrdersconfirmed 1 }

und verwenden die in unseren Befehlen

EINHEIT gobo

#call ju
lernen unterhaltung

Diese Einheit lernt jetzt einmal Unterhaltung und wird dann immer bestätigt und unterhält. Na sauber. Endlich Ruhe vor diesen nervigen Unterhaltern.

Nur was machen, wenn diese Einheit so viel Silber anhäuft, dass sie versucht ist nach Vegas abzuhauen. Da muss man was machen...

jvorlage.txt

#proc jug $gibsmir
{
    #call ju
    gib $gibsmir alles silber
}

#proc j
{ #tag EINHEIT ejcOrdersconfirmed 1 }

oder jvorlage.txt

#proc jug $gibsmir
{
    unterhalten
    #call j
    gib $gibsmir alles silber
}

Ich lasse das #proc j ab jetzt mal weg... oki!

Hier benutzen wir das erste mal einen Parameter. Die Parameter sind durch das Dollarzeichen gekennzeichnet. Passt hier ja sehr gut, geht ja um Knete. Beim Aufruf in den Befehlen gebe ich als Parameter dann die gewünschte Einheit an. In der Prozedur jug rufe ich ju wieder auf, ju sorgt für das Unterhalten und das Bestätigen

EINHEIT gobo

#call jug gob1
unterhalten

Die Einheit wird nun Bestätigt, Unterhält und gibt alles Silber an gob1 ab. Sehr löblich das Ganze.

Was passiert aber nun wenn gob1 gerade woanders ist? Ich glaube wir ändern das nochmal...

jvorlage.txt

#proc jug $gibsmir
{
    #ifunit $gibsmir { gib $gibsmir alles silber }
    #call ju
}

Jetzt wird mit dem Befehle #ifunit überprüft ob die gewünschte Einheit überhaupt da ist... (oder genauer ob sie gesehen wird...) erst dann wird der Teil in der Klammer ausgeführt. Der Aufruf ist natürlich gleich geblieben... Gut ne... muss ich in den Befehlen gar nix ändern.

Machen wir das nochmal besser. Ich will auch noch angeben wieviel Silber die Einheit behält. Die muss ja auch leben...

jvorlage.txt

#proc jugb $gibsmir $behalten
{
    ;wir rechnen mal aus was die Einheit so über hat
    $silberueber=unit.silber-$behalten
    #ifunit $gibsmir { #if $silberueber>0 { gib $gibsmir $silberueber } }
    #call ju
}

Zuerst habe ich mal einen Kommentar eingefügt damit ich in 2 Jahren noch weiss was ich da gemacht habe...
Das Silber was ich über habe ist genau das Silber was ich habe (unit.silber) minus den Teil den ich behalten möchte.
Wenn das ganze negativ sein sollte habe ich wohl nix zu verschenken.
Dieses mal verwende ich zwei if-Bedingungen. Einmal wird getestet ob die Einheit gibsmir da ist und zweitens ob die Einheit die jugb aufruft selber 'silberueber' hat ;)
Mit dem Aufruf von UNIT kann ich ziemlich viele Dinge über eine Einheit rausfinden. Die Silbermenge rauszufinden war nur eine kleine Sache.

EINHEIT gobo

#call jugb gob1 100
unterhalten

gobo wird Bestätigt, Unterhält und gibt alles Silber über 100 an gob1 (wenn gob1 gesehen wird)

Ich hoffe das war hilfreich... Jutta

EINHEIT

Task Two: Endlich nicht mehr ums lernen kümmern

Dauernd muss man den Jungs sagen was sie lernen sollen. Das nervt auf die Dauer gewaltig. Da wünscht man sich doch, dass man einmal klarstellt was gelernt werden soll und dann ('für immer') sein Ruhe hat.

Ein Aufruf in der Form,

// #call jlernen wahrnehmung 5 taktik 10 ausdauer 11 stangenwaffen 17 tarnung 14

ist genau das, was man sich wünscht... Und dann hat man ca. 394 Runden seine Ruhe (supi!)

Und so wirds gemacht:

#proc jlernen 
{
	$ichlerne=''
	$i=1
	$gefunden=0
	;nochmal neu
	#message '--Juttas-Autolerner-------------------------------------------------------------------'
	#message 'Was soll ich nun lernen?'
	#message 'Anzahl möglicher Talente :'+(ARG.size/2)
	#while (($i<40)&&($gefunden==0))
	{
		$a=0
		#while ($a<ARG.SIZE)
		{
			;#message 'Durchlauf: '+$i+'.'
			$talent=ARG[$a]
			$stufe=ARG[$a+1]
			;#message $talent+' auf '+$stufe+' ?'

			#if ((unit.$talent.stufe<$stufe)&&(unit.$talent.stufe<$i)) { $gefunden=1 : $ichlerne=$talent : #break }			
			$a=$a+2;
		} 		
	$i=$i+1
	}

	#if ($gefunden==1) { #message 'Ich lerne am besten '+$ichlerne : lernen $ichlerne : #call j } #else { #message 'Ich habe fertig!' }
	#message '--Juttas--Autolerner-------------------------------------------------------------------'
}

Task Drei: Buchführung

Da hat man sich gerade an die statischen Lerntage gewöhnt und schon schafft die Spielleitung die wieder ab. Auf einmal ist es Zufall, ob eine Einheit aufsteigt, oder nicht... So geht das natürlich nicht. Ich will doch zu jedem Zeitpunkt wissen wie lange das noch dauert ("wie lange dauert das noch?"). Ohne Micromanagement macht es aber einfach nicht so viel Spass... Also wie bekomme ich eine gescheite Lernkontrolle hin um auch die richtigen langsamer denkenden Untergebenen entsprechend zu foltern?

#proc jltrace &$cnt $talent &$stufe $max
{
#if $stufe>unit.$talent.stufe { $cnt=$cnt+1 : #message 'Lerne '+$talent+' auf T'+$stufe+' | '+$cnt+' Lernversuche | TMax: '+$max : #call j }
#if $stufe==unit.$talent.stufe { $cnt=$cnt+1 : '\47\47 '+$cnt+' Lernversuche um '+$talent+' auf T'+$stufe+' zu lernen' : #message 'Die Einheit ist aufgestiegen!' : $cnt=0 : #if $stufe<$max { $stufe=$stufe+1 : #call j } }
#call jlb $talent $stufe
}

#proc jlb $talent $bis
{
	#if UNIT.$talent.Stufe<$bis { lernen $talent : #call j } #else { #message 'Talentziel erreicht!' : lernen $talent }
}

Der schlanke Aufruf von:

#call jltrace 0 tarnung 1 20 

loggt dann für einen die benötigten Lernwochen für jede Talentstufe von 1 bis 20. Dabei entsteht natürlich eine Menge Datenmüll...

#call jltrace 0 tarnung 20 20

loggt dann nur wie lange von 0 auf 20 gebraucht wurde... ;)

Task 4: 17 Runden Ruhe *sigh*

Manchmal will man eine Einheit einfach einige Runden nicht mehr sehen und die machen lassen.

#proc bis &$bis
{
#message ''
#message '-Juttamatik-Runde_'+report.runde+'---------------------------------'
$i=1
$cmd=''
#while ($i<ARG.SIZE) { $cmd=$cmd+ARG[$i]+' ' : $i=$i+1 } 
#if ($bis>0&&$bis<1000) { #if (report.runde-$bis<0) { #call j : #message '--!bestätige_Einheit!--' } 
#else { $plus=17+(random()%23) : #message '--Zielrunde_erreicht--' : $bis=report.runde+$plus : #message '--bestätige_neu_bis_'+$bis+'-(zufällig)--' } }
#else { #message '  --FEHLER--' : #message '--DER ERSTE PARAMETER MUSS EINE ZAHL SEIN!--' : #message '  --FEHLER--' : $cmd=ARG[0]+' '+$cmd }
$cmd
#message '-Juttamatik-läuft_bis_'+$bis+'---------------------------------'
#message ''
}

Mit dieser schlanken Prozedur kann man einer Einheit jeglichen Befehl geben und die führt das dann bis zur Zielrunde aus.

// #call bis 999 lernen tarnung

Und schon hat man seine Ruhe vor seinen Minions...

Task Five: Wo bin ich???

Transporter laufen häufig immer den gleichen Weg. Auch für Transportschiffe wäre es wünschenswert festzulegen was sie wo machen sollen... Also machen wir das...

Aufruf

// #call jkoordy -2 -7 nach n n n und gib xyz 10 adamantium und benennen einheit schlumpf

Blöd natürlich wenn die Unit die Nummer 'und' hat. Dann läuft das Skript nicht ;)

#proc jkoordy $x $y
{

#if (region.x==($x)&&region.y==($y)) 
	{
	#message '------------------------------------------------------------------------------' 
	#message 'Region '+region.name+' ['+region.x+'|'+region.y+'] - Regionale Aufträge:'
	$i=3
	$a=0
	$cmd=[]
	$cmd[0]=ARG[2]
	#while ($i<ARG.SIZE)
		{	
			#if (ARG[$i]=='und') { $a=$a+1 : $i=$i+1 : #if ($i<ARG.SIZE) { $cmd[$a]=ARG[$i] : $i=$i+1 } } #else { $cmd[$a]=$cmd[$a]+' '+ARG[$i] : $i=$i+1 }
			
		}
	
	$i=0
	
	#while ($i<$cmd.SIZE)
		{

			$cmd[$i]+' ;['+($i+1)+']'
			$i=$i+1
		}
	#message '-------------------------------------------------------------------------------'	
	#call j
	}

}