oneCardLight.pl

/* -*- Mode:Prolog -*- */

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Gameserver-Spielengine fuer ONECARDLIGHT %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

:- module(oneCardLight,[initMatch_oneCardLight/8,play_oneCardLight/9,joinMatch_oneCardLight/7]).

:- use_module(library(file_systems)).
:- use_module(library(lists)).
:- ensure_loaded(simutils).
:- use_module(remoteaiwrapper).

% JavaEinstieg: nachträgliches Beitreten nicht möglich
joinMatch_oneCardLight(_MatchID,_PlayerDetails,_Oldworld,_Newworld,_Views,_Round,_Phase).

/*------------------- JavaEinstieg: INITMATCH ---------------------------------------------------------*/
% erstellt Spiel
initMatch_oneCardLight(_MatchID,_MatchOptions,PlayerList,PlayerDetails,Worldout,Views,Round,Phase) :-
        PlayerList = [Player1,Player2],                                         % Player1=player1, Player2=player2
        PlayerDetails = [player(Detail1,_N1,_Role1),player(Detail2,_N2,_Role2)],% D1=human, N1=de, Role1=north, D2=localai(oneCardPlayer), N2=@oneCardPlayer, Role2=south
        PlayerDetailDict = [Player1-Detail1, Player2-Detail2],                  % P1-D1=player1-human, P2-D2=player2-localai(oneCardPlayer)

        InitialPlayer1Hand = [7],
        InitialPlayer2Hand = [4],
        InitialTalon = [8,3],

        World = [player1-InitialPlayer1Hand,player2-InitialPlayer2Hand,talon-InitialTalon,
                 status-beforeTrick,lead-Player1,winner-nil,
                 playHistory-[],
                 playerDetailDict-PlayerDetailDict,
                 player1KB-[],player2KB-[]],

        playersworld(Player1,World,Player1world),                               % erstellt Spielerwelt
        playersworld(Player2,World,Player2world),
        playersviewWithoutActions(Player1world,Player1view1),                   % erstellt Spielerview ohne Aktionen
        playersviewWithoutActions(Player2world,Player2view1),
        playersviewWithAllowedActions(Player1world,Player1view1,Player1view2),  % erweitert Spielerview um Aktionen
        playersviewWithAllowedActions(Player2world,Player2view1,Player2view2),

        Worldout = World,
        Views = [Player1view2,Player2view2],
        Round = '1',
        Phase = 'default',
        true.


% beschreibt die Welt eines bestimmten Spielers
playersworld(Player,World,PlayersWorld) :-
        worldget(Player,World,PlayersHand),
        worldget(talon,World,Talon),
        length(Talon,TalonCount),
        worldget(status,World,Status),
        worldget(lead,World,Lead),
        worldget(winner,World,Winner),
        worldget(playHistory,World,PlayHistory),

        PlayersWorld = [playersName-Player,
                        playersHand-PlayersHand,talonCount-TalonCount,
                        status-Status,lead-Lead, winner-Winner,
                        playHistory-PlayHistory],
        true.

% wandelt die Welt eines Spielers in Views um
playersviewWithoutActions(PlayersWorld,PlayersView) :-
        worldget(playersName,PlayersWorld,Player),
        worldget(lead,PlayersWorld,Lead),
        worldget(playersHand,PlayersWorld,OwnHand),
        worldget(talonCount,PlayersWorld,TalonCount),
        worldget(playHistory,PlayersWorld,PlayHistory),
        worldget(status,PlayersWorld,Status),

        length(OwnHand,OwnHandCount),                           % # eigene Handkarten
        (Status = inTrick ->    % eine Karte wurde gespielt     % # gegnerische Handkarten
         (Lead = Player ->      % ich bin dran
          OpponentHandCount is 2 - TalonCount
         ;                      % ich bin nicht dran
          OpponentHandCount = 1
         )
        ;
         (Status = beforeTrick -> % keine Karte wurde gespielt
          OpponentHandCount = 1
         ;
          (Status = end ->
           OpponentHandCount is 2 - TalonCount - OwnHandCount
          ;
           throw(unknownStatus-Status)
          )
         )
        ),

        (Status = inTrick ->                                    % bestimmt Karten für die Stichpositionen
         PlayHistory = [FirstTrickCard|_],
         CurrentTrick = [FirstTrickCard]
        ;
         (PlayHistory = [SecondTrickCard,FirstTrickCard|_] ->
          CurrentTrick = [FirstTrickCard,SecondTrickCard]
         ;
          CurrentTrick = []
         )
        ),

        ViewCards0 = [],
        putVisibleCards(OwnHand,ViewCards0,ViewCards1,1),               % eigene Handkarten auf den View
        putHiddenCards(TalonCount,ViewCards1,ViewCards2,3),             % Stapel auf den View
        putHiddenCards(OpponentHandCount,ViewCards2,ViewCards3,2),      % gegnerische Handkarten auf den View
        putVisibleCards(CurrentTrick,ViewCards3,ViewCards4,5),          % aktuellen Stich auf den View
        putMissingCards(ViewCards4,ViewCards),                         % alle übrigen Positionen werden mit "none-0" belegt

        (Status = end ->
         worldget(winner,PlayersWorld,Winner),
         atom_concat('Winner: ',Winner,WinnerText),
         Message = WinnerText
        ;
         Message = 'inGame'
        ),

        Form = [form(1,[text(Message)])],

        PlayersView = view(Player,ViewCards,[],[],Form,[],undo(0,[]),[]),
        true.

% Legt für den Spieler sichtbare Karten auf den View.
putVisibleCards([],View,View,_Position).
putVisibleCards([Card|RestCards],ViewIn,ViewOut,Position) :-
        number_card(Card,CardName),
        NextPosition is Position + 1,
        NextView = [Position-card(CardName)|ViewIn],
        putVisibleCards(RestCards,NextView,ViewOut,NextPosition).

% Legt für den Spieler verdeckte Karten auf den View.
putHiddenCards(0,View,View,_Position).
putHiddenCards(Count,ViewIn,ViewOut,Position) :-
        Count > 0,
        NextCount is Count - 1,
        NextPosition is Position + 1,
        NextView = [Position-card(hiddenCard)|ViewIn],
        putHiddenCards(NextCount,NextView,ViewOut,NextPosition).

% Fuegt an allen Positionen fuer die keine Karte bekannt ist explizit "none-0" ein.
putMissingCards(ViewIn,ViewOut) :-
        range(1,6,AllPositions), % AllPositions=[1,2,...,6]
        putMissingCards(ViewIn,ViewOut,AllPositions).
putMissingCards(View,View,[]).
putMissingCards(ViewIn,ViewOut,[Position|RestPositions]) :-
        member(Position-_,ViewIn),
        !,
        putMissingCards(ViewIn,ViewOut,RestPositions).
putMissingCards(ViewIn,ViewOut,[Position|RestPositions]) :-
        NextView = [Position-card(none-0)|ViewIn],
        putMissingCards(NextView,ViewOut,RestPositions).

% Zuordnung von Zehnerkarten zu frz. Kartenspiel
number_card(0,h-a):-!.
number_card(1,h-2):-!.
number_card(2,h-3):-!.
number_card(3,h-4):-!.
number_card(4,h-5):-!.
number_card(5,h-6):-!.
number_card(6,h-7):-!.
number_card(7,h-8):-!.
number_card(8,h-9):-!.
number_card(9,h-t):-!.
number_card(talon,hiddenCard):-!.
number_card(N,C) :- throw(numbercard_conversion_error(N,C)).

% erweitert die PlayerView um Aktionen
playersviewWithAllowedActions(PlayersWorld,PlayersViewIn,PlayersViewOut) :-
        PlayersViewIn = view(Player,ViewCards,PlayerAnimations,_,Form,Magic,Undo,Chat),
        worldget(lead,PlayersWorld,Lead),

        (dif(Player,Lead) ->    % Spieler nicht dran
         PlayerAllowedActions = []
        ;                       % Spieler dran
         PlayerAllowedActions1 = [1-[click]],                           % Handkarte
         worldget(talonCount,PlayersWorld,TalonCount),
         worldget(TalonCount,[1-3,2-4],Position),
         PlayerAllowedActions = [Position-[click]|PlayerAllowedActions1]% Stapelkarte
        ),

        PlayersViewOut = view(Player,ViewCards,PlayerAnimations,PlayerAllowedActions,Form,Magic,Undo,Chat),
        true.

/*------------------- JavaEinstieg: PLAY ---------------------------------------------------------*/
% führt Spielzug aus
play_oneCardLight(Player,GuiactionIn,_MatchNumber,WorldIn,WorldOut,Views,Matchstate,Round,Phase) :-
        (isGuiPlayer(WorldIn,Player) -> % prüft ob Mensch oder AI
         guiActionHandler(WorldIn,GuiactionIn,Gameaction), % GUI-Action verarbeiten
         Guiaction = GuiactionIn,
         PlayerKB = []
        ;
         aiActionHandler(WorldIn,GuiactionAi,Gameaction,PlayerKB), % AI-Action holen
         Guiaction = GuiactionAi
        ),

        % KnowledgeBase in der Welt aktualisieren (für KI-Spieler)
        atom_concat(Player,'KB',PlayerKBkey),
        worldput(PlayerKBkey,WorldIn,PlayerKB,World0),

        % Gameaction in der Welt ausführen
        actionToWorld(Gameaction,World0,World),

        % Matchstate definieren
        worldget(status,World,Status),
        (Status = end ->
         worldget(winner,World,Winner),
         (Winner = player1 ->
          Loser = player2
         ;
          Loser = player1
         ),
         debprintln('GAME OVER',3),
         Matchstate0 = matchstate(finished,[player(Winner,won,1),player(Loser,lost,0)])
        ;
         Matchstate0 = matchstate(running(0),[])
        ),

        % Dynamischen Views der Spieler erstellen
        dynamicview(player1,Gameaction,Guiaction,WorldIn,World,View1),
        dynamicview(player2,Gameaction,Guiaction,WorldIn,World,View2),

        % Dynamischen Views die erlaubten Aktionen hinzufügen
        playersworld(player1,World,Player1World),
        playersworld(player2,World,Player2World),
        playersviewWithAllowedActions(Player1World,View1,View12),
        playersviewWithAllowedActions(Player2World,View2,View22),

        % Output:
        WorldOut = World,
        Views = [View12,View22],
        Matchstate = Matchstate0,
        Round = '1',
        Phase = 'default',
        true.

% true wenn menschlicher Spieler
isGuiPlayer(World,Player) :-
        worldget(playerDetailDict,World,PlayerDetailDict),
        worldget(Player,PlayerDetailDict,Type),
        Type = human.

% behandelt alle GUI-Ereignisse
guiActionHandler(World,Guiaction,Gameaction) :-
        worldget(lead,World,Player),
        playersworld(Player,World,Playersworld),
        playersviewWithoutActions(Playersworld,view(_,ViewCards,_,_,_,_,_,_)),
        guiactionToGameaction(Guiaction,ViewCards,Gameaction),
        true.

% Wandelt eine GUI-Action in eine Game-Action um.
guiactionToGameaction(click(Position),ViewCards,play(Number)) :-
        worldget(Position,ViewCards,card(CardName)),
        number_card(Number,CardName),
        true.

% Behandelt analog zum Guiactionhandler KI-Aktionen.
aiActionHandler(World,Guiaction,Gameaction,NewKB) :-
        worldget(lead,World,Player),
        playersworld(Player,World,Playersworld),
        playersviewWithoutActions(Playersworld,view(_,ViewCards,_,_,_,_,_,_)),

        worldget(playerDetailDict,World,PlayerDetailDict),
        worldget(Player,PlayerDetailDict,PlayerDetails),
        atom_concat(Player,'KB',PlayerKBkey),
        worldget(PlayerKBkey,World,OldKB),

        (PlayerDetails = localai(AiName) ->
         aifolder(Aifolder), % Ordner, in dem die AI-Spieler liegen (atom, incl. Slash am Ende)
         atom_concat('z_modulename_',AiName,AiModule),
         atoms_concat([Aifolder,AiName,'/z_modulename_',AiName],AiModulePath),
         atoms_concat([Aifolder,AiName,'/'],AiPath),
         current_directory(Serverpath,AiPath), % aktuellen Working Dir merken, aber auf AiPath setzen
         use_module(AiModulePath),
         atom_concat('z_',AiName,AiPredicate),
         AiGoal =.. [AiPredicate,_Version,Playersworld,OldKB,Gameaction,NewKB],
         (AiModule:AiGoal ->
          current_directory(_,Serverpath), % zurueck zum Server-Verzeichnis
          true
         ;
          current_directory(_,Serverpath),% zurueck zum Server-Verzeichnis
          throw(gameException('LocalAiFailed'))
         ),
         true
        ;
         (PlayerDetails = remoteai(Host,Port) ->
          (Port = 3142 ->
           Protocol = socket
          ;
           Protocol = webservice
          )
         ;
          PlayerDetails = remoteai(Host,Port,Protocol)
         ),
         remoteAiHost_port_protocol_playersWorld_oldkb_newkb_action(Host,Port,Protocol,Playersworld,OldKB,NewKB,Gameaction)
        ),
        !,

        (Gameaction = play(_) ->
         gameactionToGuiaction(Gameaction,ViewCards,Guiaction) % Was waere die Guiaction hierzu?
        ;
         (Gameaction = timeoutError ->
          throw(gameException('{AITimeOut}'))
         ;
          throw(gameException('{UnImplementedAIAction}'-Gameaction))
         )
        ),
        true.

% wandelt eine Game-Action in eine GUI-Action um
gameactionToGuiaction(play(Card),ViewCards,click(Position)) :-
        (dif(Card,talon) ->     % spielt Handkarte
         number_card(Card,CardName),
         worldget(Position,ViewCards,card(CardName))
        ;                       % spielt Stapel
         worldget(4,ViewCards,Talon),
         (Talon = card(hiddenCard) ->
          Position = 4
         ;
          Position = 3
         )
        ),
        true.

% führe Gameaction aus
actionToWorld(play(Card),WorldIn,WorldOut) :- % Handkarte wird gespielt
        (dif(Card,talon) ->     % spielt Handkarte
         worldget(lead,WorldIn,Player),
         worldget(Player,WorldIn,Hand),
         select(Card,Hand,RestCards),
         worldput(Player,WorldIn,RestCards,World0),     % gespielte Karte aus Hand entfernen
         PlayCard = Card
        ;                       % spielt Stapelkarte
         worldget(talon,WorldIn,[TalonCard|Talon]),
         worldput(talon,WorldIn,Talon,World0),          % gespielte Karte vom Stapel entfernen
         PlayCard = TalonCard
        ),
        worldget(playHistory,World0,PlayHistory),
        worldput(playHistory,World0,[PlayCard|PlayHistory],World1), % in play history eintragen

        trickHandling(World1,WorldOut),
        true.

% wertet den Stich aus
trickHandling(WorldIn,WorldOut) :-
        worldget(lead,WorldIn,Player),
        (Player = player1 ->
         Opponent = player2
        ;
         Opponent = player1
        ),
        worldget(status,WorldIn,Status),

        (Status = beforeTrick ->        % erste Karte wird ausgespielt
         worldput(lead,WorldIn,Opponent,World1),
         worldput(status,World1,inTrick,World2)
        ;                               % zweite Karte wird ausgespielt
         worldget(playHistory,WorldIn,[Card1,Card2|_]), % Opponent spielte Card2, Player spielt Card1
         (Card1 > Card2 ->
          Winner = Player
         ;
          Winner = Opponent
         ),
         worldput(winner,WorldIn,Winner,World0),
         worldput(lead,World0,nil,World1),
         worldput(status,World1,end,World2)
        ),

        WorldOut = World2,
        true.

% berechnet alle Animationen, die für den Zug gemacht werden müssen
dynamicview(Player,Gameaction,Guiaction,OldWorld,NewWorld,Dynamicview) :-
        playersworld(Player,OldWorld,OldPlayerWorld),
        playersviewWithoutActions(OldPlayerWorld,view(_,OldPlayerViewCards,_,_,_,_,_,_)),

        playersworld(Player,NewWorld,NewPlayerWorld),
        playersviewWithoutActions(NewPlayerWorld,view(_,NewPlayerViewCards,_,_,PlayerForm,Magic,Undo,Chat)),

        worldget(lead,OldWorld,Lead),
        moveAnimation(Lead,Player,OldPlayerViewCards,Gameaction,Guiaction,PlayerMoveAnimations),     % animiere den Flug der Karte
        animations(OldPlayerViewCards,NewPlayerViewCards,PlayerAnimations),
        append(PlayerMoveAnimations,PlayerAnimations,AllPlayerAnimations),

        DynamicPlayerView = view(Player,OldPlayerViewCards,AllPlayerAnimations,_,PlayerForm,Magic,Undo,Chat), % Dynamic-Views sind Old-Views plus Animation (im Gegensatz zu den theoretischen STATISCHEN NewViews)

        Dynamicview = DynamicPlayerView,
        true.

% Berechnet die Animation der "fliegenden" Karte.
moveAnimation(Actor,Player,ViewCards,Gameaction,Guiaction,[move(FromPosition,ToPosition,HiddenCard,card(VisibleAs))]) :-
        Guiaction = click(ActorsFromPosition),
        ((Actor = Player;Gameaction = play(talon)) ->
         FromPosition = ActorsFromPosition
        ;
         FromPosition = 2
        ),
        worldget(FromPosition,ViewCards,OldCard), % was wurde an der Stelle, an der die Animation beginnt, zuvor dargestellt?
        (OldCard = card(hiddenCard) ->
         HiddenCard = card(hiddenCard)
        ;
         HiddenCard = card(none-0), % anschliessend rueckt eh die Karte rechts davon nach
         true
        ),
        Gameaction = play(Number),
        number_card(Number,VisibleAs),

        (member(5-card(none-0),ViewCards) -> % naechste freie Position fuer Trick-Karte
         ToPosition = 5
        ;
         ToPosition = 6
        ),
        true.

% Berechne aus dem Unterschied der ViewCards die darzustellenden Animationen.
animations(_OldViewCards,[],[]).
animations(OldViewCards,[FirstNew|RestNewViewCards],Animations) :-
        member(FirstNew,OldViewCards), % Feld war vorher genauso belegt -> nicht zu animieren
        animations(OldViewCards,RestNewViewCards,Animations).
animations(OldViewCards,[FirstNew|RestNewViewCards],[update(Position,Card)|Animations]) :-
        FirstNew = Position-Card,
        animations(OldViewCards,RestNewViewCards,Animations).