current_player, change_player, einheit_delete, *einheit_attack hinzugefügt

daten.pl

@@ -14,6 +14,7 @@ einheit(tank, 5, 5, 3, 3).
 
 % Startpositionen der Spieler mit jeweils -1 auf die coords
 % Damit ist die init_player universell
+% playerStart(Player, X, Y)
 playerStart(1, -1, -1).
 playerStart(2, 3, 3).
 
@@ -73,16 +74,19 @@ init_player(Player, Type1, Type2, Type3) :-
 	Yp1 is Y + 1,
 	Yp2 is Y + 2,
 
-	% einheit_active(Player, Einheit Type, feldX, feldY)
-	assert( einheit_active(Player,Type1,Xp1,Yp1) ),
-	assert( einheit_active(Player,Type2,Xp2,Yp1) ),
-	assert( einheit_active(Player,Type3,Xp1,Yp2) ),
-
 	% Berechnet die zustehenden Tokens pro Runde für den Spieler
-	einheit(Type1, _,_,_, Cost1),
+	einheit(Type1, _, Defense_Points1, _, Cost1),
-	einheit(Type2, _,_,_, Cost2),
+	einheit(Type2, _, Defense_Points2, _, Cost2),
-	einheit(Type3, _,_,_, Cost3),
+	einheit(Type3, _, Defense_Points3, _, Cost3),
 	player_tokens(Tokens),
 	Cost is Tokens - (Cost1 + Cost2 + Cost3),
 
-	assert( player_tokens(Player, Cost) ).
+	assert( player_tokens(Player, Cost) ),
+
+	% Definiert die aktiven einheiten der Spieler
+	% einheit_active(Player, Einheit Type, feldX, feldY)
+	assert( einheit_active(Player,Type1,Xp1,Yp1,Defense_Points1) ),
+	assert( einheit_active(Player,Type2,Xp2,Yp1,Defense_Points2) ),
+	assert( einheit_active(Player,Type3,Xp1,Yp2,Defense_Points3) ).
+
+	

logik.pl

@@ -1,11 +1,35 @@
 % hier kommt der ganze logik bums hin
 
-% globalen Turncounter
+% Der aktuelle Spieler wird hiermit gesetzt damit das später
+% nicht bei jedem Aufruf angegeben werden muss
+:- assert( current_player(1) ). % das muss so weil sonst err
 
+% Aktualisieren des aktuellen Spielers geht hiermit
+change_player_to(Player) :-
+	retract( current_player(_X) ),
+	assert( current_player(Player) ).
+
+% Ein Spieler ist entweder current_player oder inactive_player
+% je nach dem ob dieser gerade am Zug ist oder nicht
+inactive_player(Player) :-
+	current_player(Player1),
+	playerStart(Player1,_,_),
+	playerStart(Player,_,_),
+	Player1 \= Player.
+
+% Das hier muss an jedem Rundenende ausgeführt werden um den
+% aktuellen Spieler zu wechseln
+change_player :-
+	inactive_player(Player),
+	change_player_to(Player),
+	!.
+
+
+% globalen Turncounter
 player_turn(Player) :-
 
     % calculate action points
-    calc_action_points(Player, Turncounter),
+    calc_action_points(Player, _Turncounter),
 
 
     % further logic
@@ -17,17 +41,56 @@ player_turn(Player) :-
     save_action_points(Player).
 
 
-% Bewegt die Einheit des Spielers an position Xold, Yold 
+% Bewegt die Einheit des aktuellen Spielers an position Xold, Yold 
-% um Xmove, Ymove in die jeweilige Richtung
+% auf position Xnew, Ynew
-einheit_move(Player, Xold, Yold, Xnew, Ynew) :-
+einheit_move(Xold, Yold, Xnew, Ynew) :-
-	% Die Einheit entfernen
+	% Den aktuellen Spieler abfragen
-	retract( einheit_active(Player, Type, Xold, Yold) ),
+	current_player(Player),
+
+	% Die Einheitv on der alten Position nehmen
+	retract( einheit_active(Player, Type, Xold, Yold, Defense) ),
 
 	% Die Einheit an die neue Position setzen
-	assert( einheit_active(Player, Type, Xnew, Ynew) ),
+	assert( einheit_active(Player, Type, Xnew, Ynew, Defense) ),
 
 	% Errechnen der verbleibenden Tokens
 	retract( player_tokens(Player, Tokens) ),
 	% die berechnung muss noch mal angeschaut werden
 	TokensNew is Tokens - (Xold - Xnew) - (Xold - Ynew),
-	assert( player_tokens(Player, TokensNew) ).
+	assert( player_tokens(Player, TokensNew) ).
+
+
+% Lässt zwei Einheiten gegeneinander Kämpfen
+% Die Einheit des aktuellen Spielers auf Xattack, Yattack
+% greift die Einheit des anderen auf Xdefend, Ydefend an
+einheit_attack(Xattack, Yattack, Xdefend, Ydefend) :-
+	current_player(Player),
+	einheit_active(Player, TypeAttack, Xattack, Yattack, _),
+	einheit_active(PlayerDefend, TypeDefend, Xdefend, Ydefend, HP),
+	einheit(TypeAttack, AP, _,_,_),
+	(
+		(% Entweder die Einheit überlebt
+			einheit_alive(AP, HP, HPnew),
+			retract( einheit_active(PlayerDefend, TypeDefend, 
+										Xdefend, Ydefend, HP) ),
+			assert( einheit_active(PlayerDefend, TypeDefend, 
+										Xdefend, Ydefend, HPnew) )
+		)
+		;
+		(% Oder halt nicht
+			einheit_delete(Xdefend, Ydefend)
+		)
+	),
+	!.
+
+
+% Prüft ob eine Einheit den Angriff überlebt und gibt die neue
+% Defense/HP aus falls dem so ist
+einheit_alive(AP, HP, HPnew) :-
+	HPnew is HP - AP,
+	HPnew > 0.
+
+
+% Entfernt eine Einheit vom Spielfeld an Position X, Y
+einheit_delete(X, Y) :-
+	retract( einheit_active(_, _, X, Y, _) ).

main.pl

@@ -1,3 +1,3 @@
 % hier startet das game
 % alle anderen dateien werden dann hier geladen und gesteuert
-:- load_files([daten, logik, gui]).
+:- load_files([daten, logik, gui]).