% FILE: test_games.pl
% LINE: Defines all variants of games tested
% DATE: February 20, 2021

% takes the most basic turn for a player
% draws from the deck,  
% possibly add variable for player for writing purposes


% SETS vs RUNS+
%-------------------------------------------------------------------------------------------------------------------------------------------------------------------

play_rummy_sets_vs_runs_ss :- 
    deck(Deck), 
    player((player1, Hand1, Melds1, Score1)),
    player((player2, Hand2, Melds2, Score2)),
    init_rummy(Deck, (_, Hand1, _, _), (_, Hand2, _, _), DiscardPile, NewDeck, (_, NewHand1, _, _), (_, NewHand2, _, _)),
    play_rummy_round_sets_vs_runs_ss(NewDeck, (player1, NewHand1, Melds1, Score1), (player2, NewHand2, Melds2, Score2), DiscardPile, _, _, Runs),
    write(Runs), nl.


% Plays an entire round of rummy. The round ends when either the deck, or one of the players'
% hands is empty
play_rummy_round_sets_vs_runs_ss([], (_, Hand1, Melds1, Score1), (_, Hand2, Melds2, Score2), _, UpdateScore1, UpdateScore2, Runs) :- 
    calculate_score((_, Hand1, Melds1, Score1), (_, Hand2, Melds2, Score2), UpdateScore1, UpdateScore2),
    write("Player 1 Score: "), write(UpdateScore1), nl,
    write("Player 2 Score: "), write(UpdateScore2), nl,
    human_readable_melds(Runs, HRRuns),
    write("RUNS: "), write(HRRuns), nl.

play_rummy_round_sets_vs_runs_ss(_, (_, [], Melds1, Score1), (_, Hand2, Melds2, Score2), _, UpdateScore1, UpdateScore2, Runs) :- 
    calculate_score((_, [], Melds1, Score1), (_, Hand2, Melds2, Score2), UpdateScore1, UpdateScore2),
    write("Player 1 Score: "), write(UpdateScore1), nl,
    write("Player 2 Score: "), write(UpdateScore2), nl,
    human_readable_melds(Runs, HRRuns),
    write("RUNS: "), write(HRRuns), nl.

play_rummy_round_sets_vs_runs_ss(_, (_, Hand1, Melds1, Score1), (_, [], Melds2, Score2), _, UpdateScore1, UpdateScore2, Runs) :- 
    calculate_score((_, Hand1, Melds1, Score1), (_, [], Melds2, Score2), UpdateScore1, UpdateScore2),
    write("Player 1 Score: "), write(UpdateScore1), nl,
    write("Player 2 Score: "), write(UpdateScore2), nl,
    human_readable_melds(Runs, HRRuns),
    write("RUNS: "), write(HRRuns), nl, nl.

play_rummy_round_sets_vs_runs_ss(Deck, (Player1, Hand1, Melds1, Score1), (Player2, Hand2, Melds2, Score2), DiscardPile, UpdateScore1, UpdateScore2, Runs) :-
    human_readable(Deck, HRDeck),
    write("Deck: "), write(HRDeck), nl,
    human_readable(DiscardPile, HRDiscardPile),
    write("Discard Pile: "), write(HRDiscardPile), nl,
    human_readable_melds(Runs, HRRuns), write("Runs: "), write(HRRuns), nl, nl,

    write("Player 1 turn!"), nl,
    print_info(Hand1, Melds1, "HAND BEFORE TURN: ", "MELDS BEFORE TURN: "), nl,
    take_turn_sets((Player1, Hand1, Melds1, Score1), Deck, DiscardPile, (_, NewHand1, NewMeld1, _), NewDeck1, NewDiscard1), nl,
    print_info(NewHand1, NewMeld1, "HAND AFTER TURN: ", "MELDS AFTER TURN: "), nl, nl,

    write("Player 2 turn!"), nl,
    print_info(Hand2, Melds2, "HAND BEFORE TURN: ", "MELDS BEFORE TURN: "), nl,
    take_turn_runs2((Player2, Hand2, Melds2, Score2), NewDeck1, NewDiscard1, (_, NewHand2, NewMeld2, _), NewDeck2, NewDiscard2, Runs, NewRuns), nl,
    print_info(NewHand2, NewMeld2, "HAND AFTER TURN: ", "MELDS AFTER TURN: "), nl, nl, nl,

    play_rummy_round_sets_vs_runs_ss(NewDeck2, (Player1, NewHand1, NewMeld1, Score1), (Player2, NewHand2, NewMeld2, Score2), NewDiscard2, UpdateScore1, UpdateScore2, NewRuns).



% SETS vs SETS+
%-------------------------------------------------------------------------------------------------------------------------------------------------------------------

take_turn_sets_vs_sets_ss((_, Hand, Melds, _), Deck, DiscardPile, (_, NewHand3, NewMelds, _), NewDeck1, NewDiscardPile, Sets, NewSets) :- 
    draw_from_deck(Deck, NewDeck1, Hand, NewHand1),
    write("LOOKING FOR SETS..."), nl,
    find_set_all_melds(NewHand1, NewHand1, Melds, NewMelds, NewHand2, Sets, NewSets),
    random_discard(NewHand2, DiscardPile, NewHand3, NewDiscardPile).


play_rummy_sets_vs_sets_ss :- 
    sets(Sets),
    deck(Deck), 
    player((player1, Hand1, Melds1, Score1)),
    player((player2, Hand2, Melds2, Score2)),
    init_rummy(Deck, (_, Hand1, _, _), (_, Hand2, _, _), DiscardPile, NewDeck, (_, NewHand1, _, _), (_, NewHand2, _, _)),
    play_rummy_round_sets_vs_sets_ss(NewDeck, (player1, NewHand1, Melds1, Score1), (player2, NewHand2, Melds2, Score2), DiscardPile, _, _, Sets),
    write(Sets).


% plays an entire round of Rummy 500: sets vs sets+
play_rummy_round_sets_vs_sets_ss([], (_, Hand1, Melds1, Score1), (_, Hand2, Melds2, Score2), _, UpdateScore1, UpdateScore2, Sets) :- 
    calculate_score((_, Hand1, Melds1, Score1), (_, Hand2, Melds2, Score2), UpdateScore1, UpdateScore2),
    write("Player 1 Score: "), write(UpdateScore1), nl,
    write("Player 2 Score: "), write(UpdateScore2), nl,
    human_readable_melds(Sets, HRSets),
    write("SETS: "), write(HRSets), nl.

play_rummy_round_sets_vs_sets_ss(_, (_, [], Melds1, Score1), (_, Hand2, Melds2, Score2), _, UpdateScore1, UpdateScore2, Sets) :- 
    calculate_score((_, [], Melds1, Score1), (_, Hand2, Melds2, Score2), UpdateScore1, UpdateScore2),
    write("Player 1 Score: "), write(UpdateScore1), nl,
    write("Player 2 Score: "), write(UpdateScore2), nl,
    write("SETS: "), write(Sets), nl.

play_rummy_round_sets_vs_sets_ss(_, (_, Hand1, Melds1, Score1), (_, [], Melds2, Score2), _, UpdateScore1, UpdateScore2, Sets) :- 
    calculate_score((_, Hand1, Melds1, Score1), (_, [], Melds2, Score2), UpdateScore1, UpdateScore2),
    write("Player 1 Score: "), write(UpdateScore1), nl,
    write("Player 2 Score: "), write(UpdateScore2), nl,
    write("SETS: "), write(Sets), nl.

play_rummy_round_sets_vs_sets_ss(Deck, (Player1, Hand1, Melds1, Score1), (Player2, Hand2, Melds2, Score2), DiscardPile, UpdateScore1, UpdateScore2, Sets) :-
    human_readable(Deck, HRDeck),
    write("Deck: "), write(HRDeck), nl,
    human_readable(DiscardPile, HRDiscardPile),
    write("Discard Pile: "), write(HRDiscardPile), nl, nl,

    write("Player 1 turn!"), nl,
    print_info(Hand1, Melds1, "HAND BEFORE TURN: ", "MELDS BEFORE TURN: "), nl,
    take_turn_sets_vs_sets_ss((Player1, Hand1, Melds1, Score1), Deck, DiscardPile, (_, NewHand1, NewMeld1, _), NewDeck1, NewDiscard1, Sets, NewSets), nl,
    print_info(NewHand1, NewMeld1, "HAND AFTER TURN: ", "MELDS AFTER TURN: "), nl, nl,

    write("Player 2 turn!"), nl,
    print_info(Hand2, Melds2, "HAND BEFORE TURN: ", "MELDS BEFORE TURN: "), nl,
    take_turn_sets2((Player2, Hand2, Melds2, Score2), NewDeck1, NewDiscard1, (_, NewHand2, NewMeld2, _), NewDeck2, NewDiscard2, NewSets, FinalSets), nl,
    print_info(NewHand2, NewMeld2, "HAND AFTER TURN: ", "MELDS AFTER TURN: "), nl, nl, nl,

    play_rummy_round_sets_vs_sets_ss(NewDeck2, (Player1, NewHand1, NewMeld1, Score1), (Player2, NewHand2, NewMeld2, Score2), NewDiscard2, UpdateScore1, UpdateScore2, FinalSets).


% SETS AND RUNS vs SETS
%-------------------------------------------------------------------------------------------------------------------------------------------------------------------

% initializes the game and plays an entire round of rummy
play_rummy_sets_and_runs_vs_sets :- 
    deck(Deck), 
    player((player1, Hand1, Melds1, Score1)),
    player((player2, Hand2, Melds2, Score2)),
    init_rummy(Deck, (_, Hand1, _, _), (_, Hand2, _, _), DiscardPile, NewDeck, (_, NewHand1, _, _), (_, NewHand2, _, _)),
    play_rummy_round_sets_and_runs_vs_sets(NewDeck, (player1, NewHand1, Melds1, Score1), (player2, NewHand2, Melds2, Score2), DiscardPile, _, _).


play_rummy_round_sets_and_runs_vs_sets([], (_, Hand1, Melds1, Score1), (_, Hand2, Melds2, Score2), _, UpdateScore1, UpdateScore2) :- 
    calculate_score((_, Hand1, Melds1, Score1), (_, Hand2, Melds2, Score2), UpdateScore1, UpdateScore2),
    write("Player 1 Score: "), write(UpdateScore1), nl,
    write("Player 2 Score: "), write(UpdateScore2), nl.

play_rummy_round_sets_and_runs_vs_sets(_, (_, [], Melds1, Score1), (_, Hand2, Melds2, Score2), _, UpdateScore1, UpdateScore2) :- 
    calculate_score((_, [], Melds1, Score1), (_, Hand2, Melds2, Score2), UpdateScore1, UpdateScore2),
    write("Player 1 Score: "), write(UpdateScore1), nl,
    write("Player 2 Score: "), write(UpdateScore2), nl.

play_rummy_round_sets_and_runs_vs_sets(_, (_, Hand1, Melds1, Score1), (_, [], Melds2, Score2), _, UpdateScore1, UpdateScore2) :- 
    calculate_score((_, Hand1, Melds1, Score1), (_, [], Melds2, Score2), UpdateScore1, UpdateScore2),
    write("Player 1 Score: "), write(UpdateScore1), nl,
    write("Player 2 Score: "), write(UpdateScore2), nl.

play_rummy_round_sets_and_runs_vs_sets(Deck, (Player1, Hand1, Melds1, Score1), (Player2, Hand2, Melds2, Score2), DiscardPile, UpdateScore1, UpdateScore2) :-
    human_readable(Deck, HRDeck),
    write("Deck: "), write(HRDeck), nl,

    human_readable(DiscardPile, HRDiscardPile),
    write("Discard Pile: "), write(HRDiscardPile), nl, nl,

    write("Player 1 turn!"), nl,
    print_info(Hand1, Melds1, "HAND BEFORE TURN: ", "MELDS BEFORE TURN: "), nl,
    take_turn_both((Player1, Hand1, Melds1, Score1), Deck, DiscardPile, (_, NewHand1, NewMeld1, _), NewDeck1, NewDiscard1), nl,
    print_info(NewHand1, NewMeld1, "HAND AFTER TURN: ", "MELDS AFTER TURN: "), nl, nl,

    write("Player 2 turn!"), nl,
    print_info(Hand2, Melds2, "HAND BEFORE TURN: ", "MELDS BEFORE TURN: "), nl,
    take_turn_sets((Player2, Hand2, Melds2, Score2), NewDeck1, NewDiscard1, (_, NewHand2, NewMeld2, _), FinalDeck, FinalDiscard), nl,
    print_info(NewHand2, NewMeld2, "HAND AFTER TURN: ", "MELDS AFTER TURN: "), nl, nl, nl,

    play_rummy_round_sets_and_runs_vs_sets(FinalDeck, (Player1, NewHand1, NewMeld1, Score1), (Player2, NewHand2, NewMeld2, Score2), FinalDiscard, UpdateScore1, UpdateScore2).


% SETS AND RUNS vs RUNS
%-------------------------------------------------------------------------------------------------------------------------------------------------------------------

play_rummy_sets_and_runs_vs_runs :- 
    deck(Deck), 
    player((player1, Hand1, Melds1, Score1)),
    player((player2, Hand2, Melds2, Score2)),
    init_rummy(Deck, (_, Hand1, _, _), (_, Hand2, _, _), DiscardPile, NewDeck, (_, NewHand1, _, _), (_, NewHand2, _, _)),
    play_rummy_round_sets_and_runs_vs_runs(NewDeck, (player1, NewHand1, Melds1, Score1), (player2, NewHand2, Melds2, Score2), DiscardPile, _, _).


play_rummy_round_sets_and_runs_vs_runs([], (_, Hand1, Melds1, Score1), (_, Hand2, Melds2, Score2), _, UpdateScore1, UpdateScore2) :- 
    calculate_score((_, Hand1, Melds1, Score1), (_, Hand2, Melds2, Score2), UpdateScore1, UpdateScore2),
    write("Player 1 Score: "), write(UpdateScore1), nl,
    write("Player 2 Score: "), write(UpdateScore2), nl.

play_rummy_round_sets_and_runs_vs_runs(_, (_, [], Melds1, Score1), (_, Hand2, Melds2, Score2), _, UpdateScore1, UpdateScore2) :- 
    calculate_score((_, [], Melds1, Score1), (_, Hand2, Melds2, Score2), UpdateScore1, UpdateScore2),
    write("Player 1 Score: "), write(UpdateScore1), nl,
    write("Player 2 Score: "), write(UpdateScore2), nl.

play_rummy_round_sets_and_runs_vs_runs(_, (_, Hand1, Melds1, Score1), (_, [], Melds2, Score2), _, UpdateScore1, UpdateScore2) :- 
    calculate_score((_, Hand1, Melds1, Score1), (_, [], Melds2, Score2), UpdateScore1, UpdateScore2),
    write("Player 1 Score: "), write(UpdateScore1), nl,
    write("Player 2 Score: "), write(UpdateScore2), nl.

play_rummy_round_sets_and_runs_vs_runs(Deck, (Player1, Hand1, Melds1, Score1), (Player2, Hand2, Melds2, Score2), DiscardPile, UpdateScore1, UpdateScore2) :-
    human_readable(Deck, HRDeck),
    write("Deck: "), write(HRDeck), nl,

    human_readable(DiscardPile, HRDiscardPile),
    write("Discard Pile: "), write(HRDiscardPile), nl, nl,

    write("Player 1 turn!"), nl,
    print_info(Hand1, Melds1, "HAND BEFORE TURN: ", "MELDS BEFORE TURN: "), nl,
    take_turn_both((Player1, Hand1, Melds1, Score1), Deck, DiscardPile, (_, NewHand1, NewMeld1, _), NewDeck1, NewDiscard1), nl,
    print_info(NewHand1, NewMeld1, "HAND AFTER TURN: ", "MELDS AFTER TURN: "), nl, nl,

    write("Player 2 turn!"), nl,
    print_info(Hand2, Melds2, "HAND BEFORE TURN: ", "MELDS BEFORE TURN: "), nl,
    take_turn_runs((Player2, Hand2, Melds2, Score2), NewDeck1, NewDiscard1, (_, NewHand2, NewMeld2, _), FinalDeck, FinalDiscard), nl,
    print_info(NewHand2, NewMeld2, "HAND AFTER TURN: ", "MELDS AFTER TURN: "), nl, nl, nl,

    play_rummy_round_sets_and_runs_vs_runs(FinalDeck, (Player1, NewHand1, NewMeld1, Score1), (Player2, NewHand2, NewMeld2, Score2), FinalDiscard, UpdateScore1, UpdateScore2).



% SETS AND RUNS vs SETS+
%-------------------------------------------------------------------------------------------------------------------------------------------------------------------

% starts a round of rummy where sets and runs play sets+
play_rummy_sets_and_runs_vs_sets_ss :- 
    sets(Sets),
    deck(Deck), 
    player((player1, Hand1, Melds1, Score1)),
    player((player2, Hand2, Melds2, Score2)),
    init_rummy(Deck, (_, Hand1, _, _), (_, Hand2, _, _), DiscardPile, NewDeck, (_, NewHand1, _, _), (_, NewHand2, _, _)),
    play_rummy_round_sets_and_runs_vs_sets_ss(NewDeck, (player1, NewHand1, Melds1, Score1), (player2, NewHand2, Melds2, Score2), DiscardPile, _, _, Sets),
    write(Sets).


%takes turn for sets and runs opponent. Adds any sets found to list for sets+ opponent to play off of
take_turn_both_special((_, Hand, Melds, _), Deck, DiscardPile, (_, FinalHand, NewestMelds, _), NewDeck1, NewDiscardPile, Sets, NewSets) :- 
    draw_from_deck(Deck, NewDeck1, Hand, NewHand1),
    write("LOOKING FOR SETS..."), nl,
    find_set_all_melds(NewHand1, NewHand1, Melds, NewMelds, NewHand2, Sets, NewSets),
    merge_sort(NewHand2, SortedHand),
    write("LOOKING FOR RUNS..."), nl,
    find_run(SortedHand, NewHand3, [diamonds, clubs, hearts, spades], NewMelds, NewestMelds),
    random_discard(NewHand3, DiscardPile, FinalHand, NewDiscardPile).


% plays an entire round of sets and runs vs sets+
play_rummy_round_sets_and_runs_vs_sets_ss([], (_, Hand1, Melds1, Score1), (_, Hand2, Melds2, Score2), _, UpdateScore1, UpdateScore2, Sets) :- 
    calculate_score((_, Hand1, Melds1, Score1), (_, Hand2, Melds2, Score2), UpdateScore1, UpdateScore2),
    write("Player 1 Score: "), write(UpdateScore1), nl,
    write("Player 2 Score: "), write(UpdateScore2), nl,
    human_readable_melds(Sets, HRSets),
    write("SETS: "), write(HRSets), nl.

play_rummy_round_sets_and_runs_vs_sets_ss(_, (_, [], Melds1, Score1), (_, Hand2, Melds2, Score2), _, UpdateScore1, UpdateScore2, Sets) :- 
    calculate_score((_, [], Melds1, Score1), (_, Hand2, Melds2, Score2), UpdateScore1, UpdateScore2),
    write("Player 1 Score: "), write(UpdateScore1), nl,
    write("Player 2 Score: "), write(UpdateScore2), nl,
    write("SETS: "), write(Sets), nl.

play_rummy_round_sets_and_runs_vs_sets_ss(_, (_, Hand1, Melds1, Score1), (_, [], Melds2, Score2), _, UpdateScore1, UpdateScore2, Sets) :- 
    calculate_score((_, Hand1, Melds1, Score1), (_, [], Melds2, Score2), UpdateScore1, UpdateScore2),
    write("Player 1 Score: "), write(UpdateScore1), nl,
    write("Player 2 Score: "), write(UpdateScore2), nl,
    write("SETS: "), write(Sets), nl.

play_rummy_round_sets_and_runs_vs_sets_ss(Deck, (Player1, Hand1, Melds1, Score1), (Player2, Hand2, Melds2, Score2), DiscardPile, UpdateScore1, UpdateScore2, Sets) :-
    human_readable(Deck, HRDeck),
    write("Deck: "), write(HRDeck), nl,
    human_readable(DiscardPile, HRDiscardPile),
    write("Discard Pile: "), write(HRDiscardPile), nl, nl,

    write("Player 1 turn!"), nl,
    print_info(Hand1, Melds1, "HAND BEFORE TURN: ", "MELDS BEFORE TURN: "), nl,
    take_turn_both_special((Player1, Hand1, Melds1, Score1), Deck, DiscardPile, (_, NewHand1, NewMeld1, _), NewDeck1, NewDiscard1, Sets, NewSets), nl,
    print_info(NewHand1, NewMeld1, "HAND AFTER TURN: ", "MELDS AFTER TURN: "), nl, nl,

    write("Player 2 turn!"), nl,
    print_info(Hand2, Melds2, "HAND BEFORE TURN: ", "MELDS BEFORE TURN: "), nl,
    take_turn_sets2((Player2, Hand2, Melds2, Score2), NewDeck1, NewDiscard1, (_, NewHand2, NewMeld2, _), NewDeck2, NewDiscard2, NewSets, FinalSets), nl,
    print_info(NewHand2, NewMeld2, "HAND AFTER TURN: ", "MELDS AFTER TURN: "), nl, nl, nl,

    play_rummy_round_sets_and_runs_vs_sets_ss(NewDeck2, (Player1, NewHand1, NewMeld1, Score1), (Player2, NewHand2, NewMeld2, Score2), NewDiscard2, UpdateScore1, UpdateScore2, FinalSets).


% SETS AND RUNS vs RUNS+
%-------------------------------------------------------------------------------------------------------------------------------------------------------------------

% starts a round of rummy where sets and runs play sets+
play_rummy_sets_and_runs_vs_runs_ss :- 
    runs(Runs),
    deck(Deck), 
    player((player1, Hand1, Melds1, Score1)),
    player((player2, Hand2, Melds2, Score2)),
    init_rummy(Deck, (_, Hand1, _, _), (_, Hand2, _, _), DiscardPile, NewDeck, (_, NewHand1, _, _), (_, NewHand2, _, _)),
    play_rummy_round_sets_and_runs_vs_runs_ss(NewDeck, (player1, NewHand1, Melds1, Score1), (player2, NewHand2, Melds2, Score2), DiscardPile, _, _, Runs),
    write(Runs).


%takes turn for sets and runs opponent. Adds any sets found to list for sets+ opponent to play off of
take_turn_both_special2((_, Hand, Melds, _), Deck, DiscardPile, (_, FinalHand, NewestMelds, _), NewDeck1, NewDiscardPile, Runs, NewRuns) :- 
    draw_from_deck(Deck, NewDeck1, Hand, NewHand1),
    write("LOOKING FOR SETS..."), nl,
    find_set(NewHand1, NewHand1, Melds, NewMelds, NewHand2),
    merge_sort(NewHand2, SortedHand),
    write("LOOKING FOR RUNS..."), nl,
    find_run_melds(SortedHand, NewHand3, [diamonds, clubs, hearts, spades], NewMelds, NewestMelds, Runs, NewRuns),
    random_discard(NewHand3, DiscardPile, FinalHand, NewDiscardPile).


% plays an entire round of sets and runs vs sets+
play_rummy_round_sets_and_runs_vs_runs_ss([], (_, Hand1, Melds1, Score1), (_, Hand2, Melds2, Score2), _, UpdateScore1, UpdateScore2, Runs) :- 
    calculate_score((_, Hand1, Melds1, Score1), (_, Hand2, Melds2, Score2), UpdateScore1, UpdateScore2),
    write("Player 1 Score: "), write(UpdateScore1), nl,
    write("Player 2 Score: "), write(UpdateScore2), nl,
    human_readable_melds(Runs, HRRuns),
    write("RUNS: "), write(HRRuns), nl.

play_rummy_round_sets_and_runs_vs_runs_ss(_, (_, [], Melds1, Score1), (_, Hand2, Melds2, Score2), _, UpdateScore1, UpdateScore2, Runs) :- 
    calculate_score((_, [], Melds1, Score1), (_, Hand2, Melds2, Score2), UpdateScore1, UpdateScore2),
    write("Player 1 Score: "), write(UpdateScore1), nl,
    write("Player 2 Score: "), write(UpdateScore2), nl,
    human_readable_melds(Runs, HRRuns),
    write("RUNS: "), write(HRRuns), nl.

play_rummy_round_sets_and_runs_vs_runs_ss(_, (_, Hand1, Melds1, Score1), (_, [], Melds2, Score2), _, UpdateScore1, UpdateScore2, Runs) :- 
    calculate_score((_, Hand1, Melds1, Score1), (_, [], Melds2, Score2), UpdateScore1, UpdateScore2),
    write("Player 1 Score: "), write(UpdateScore1), nl,
    write("Player 2 Score: "), write(UpdateScore2), nl,
    human_readable_melds(Runs, HRRuns),
    write("RUNS: "), write(HRRuns), nl.

play_rummy_round_sets_and_runs_vs_runs_ss(Deck, (Player1, Hand1, Melds1, Score1), (Player2, Hand2, Melds2, Score2), DiscardPile, UpdateScore1, UpdateScore2, Runs) :-
    human_readable(Deck, HRDeck),
    write("Deck: "), write(HRDeck), nl,
    human_readable(DiscardPile, HRDiscardPile),
    write("Discard Pile: "), write(HRDiscardPile), nl, nl,

    write("Player 1 turn!"), nl,
    print_info(Hand1, Melds1, "HAND BEFORE TURN: ", "MELDS BEFORE TURN: "), nl,
    take_turn_both_special2((Player1, Hand1, Melds1, Score1), Deck, DiscardPile, (_, NewHand1, NewMeld1, _), NewDeck1, NewDiscard1, Runs, NewRuns), nl,
    print_info(NewHand1, NewMeld1, "HAND AFTER TURN: ", "MELDS AFTER TURN: "), nl, nl,

    write("Player 2 turn!"), nl,
    print_info(Hand2, Melds2, "HAND BEFORE TURN: ", "MELDS BEFORE TURN: "), nl,
    take_turn_runs2((Player2, Hand2, Melds2, Score2), NewDeck1, NewDiscard1, (_, NewHand2, NewMeld2, _), NewDeck2, NewDiscard2, NewRuns, FinalRuns), nl,
    print_info(NewHand2, NewMeld2, "HAND AFTER TURN: ", "MELDS AFTER TURN: "), nl, nl, nl,

    play_rummy_round_sets_and_runs_vs_runs_ss(NewDeck2, (Player1, NewHand1, NewMeld1, Score1), (Player2, NewHand2, NewMeld2, Score2), NewDiscard2, UpdateScore1, UpdateScore2, FinalRuns).



% SETS+ AND RUNS+ vs SETS
%-------------------------------------------------------------------------------------------------------------------------------------------------------------------

% initializes the game and plays an entire round of rummy
play_rummy_sr_vs_sets :- 
    deck(Deck), 
    sets(Sets),
    runs(Runs),
    player((player1, Hand1, Melds1, Score1)),
    player((player2, Hand2, Melds2, Score2)),
    init_rummy(Deck, (_, Hand1, _, _), (_, Hand2, _, _), DiscardPile, NewDeck, (_, NewHand1, _, _), (_, NewHand2, _, _)),
    play_rummy_round_sr_vs_sets(NewDeck, (player1, NewHand1, Melds1, Score1), (player2, NewHand2, Melds2, Score2), DiscardPile, _, _, Sets, Runs),
    write(Runs), nl,
    write(Sets), nl.

% plays an entire round of rummy where sets+ and runs+ goes against sets
play_rummy_round_sr_vs_sets([], (_, Hand1, Melds1, Score1), (_, Hand2, Melds2, Score2), _, UpdateScore1, UpdateScore2, Sets, Runs) :- 
    calculate_score((_, Hand1, Melds1, Score1), (_, Hand2, Melds2, Score2), UpdateScore1, UpdateScore2),
    write("Player 1 Score: "), write(UpdateScore1), nl,
    write("Player 2 Score: "), write(UpdateScore2), nl,
    human_readable_melds(Runs, HRRuns),
    write("RUNS: "), write(HRRuns), nl,
    human_readable_melds(Sets, HRSets),
    write("SETS: "), write(HRSets), nl, nl.

play_rummy_round_sr_vs_sets(_, (_, [], Melds1, Score1), (_, Hand2, Melds2, Score2), _, UpdateScore1, UpdateScore2, Sets, Runs) :- 
    calculate_score((_, [], Melds1, Score1), (_, Hand2, Melds2, Score2), UpdateScore1, UpdateScore2),
    write("Player 1 Score: "), write(UpdateScore1), nl,
    write("Player 2 Score: "), write(UpdateScore2), nl,
    human_readable_melds(Runs, HRRuns),
    write("RUNS: "), write(HRRuns), nl,
    human_readable_melds(Sets, HRSets),
    write("SETS: "), write(HRSets), nl, nl.

play_rummy_round_sr_vs_sets(_, (_, Hand1, Melds1, Score1), (_, [], Melds2, Score2), _, UpdateScore1, UpdateScore2, Sets, Runs) :- 
    calculate_score((_, Hand1, Melds1, Score1), (_, [], Melds2, Score2), UpdateScore1, UpdateScore2),
    write("Player 1 Score: "), write(UpdateScore1), nl,
    write("Player 2 Score: "), write(UpdateScore2), nl,
    human_readable_melds(Runs, HRRuns),
    write("RUNS: "), write(HRRuns), nl,
    human_readable_melds(Sets, HRSets),
    write("SETS: "), write(HRSets), nl, nl.

play_rummy_round_sr_vs_sets(Deck, (Player1, Hand1, Melds1, Score1), (Player2, Hand2, Melds2, Score2), DiscardPile, UpdateScore1, UpdateScore2, Sets, Runs) :-
    human_readable(Deck, HRDeck),
    write("Deck: "), write(HRDeck), nl,
    human_readable(DiscardPile, HRDiscardPile),
    write("Discard Pile: "), write(HRDiscardPile), nl,
    human_readable_melds(Runs, HRRuns), write("Runs: "), write(HRRuns), nl,
    human_readable_melds(Sets, HRSets), write("Sets: "), write(HRSets), nl, nl,

    write("Player 1 turn!"), nl,
    print_info(Hand1, Melds1, "HAND BEFORE TURN: ", "MELDS BEFORE TURN: "), nl,
    take_turn_everything((Player1, Hand1, Melds1, Score1), Deck, DiscardPile, (_, NewHand1, NewMeld1, _), NewDeck1, NewDiscard1, Runs, NewRuns, Sets, NewSets), nl,
    print_info(NewHand1, NewMeld1, "HAND AFTER TURN: ", "MELDS AFTER TURN: "), nl, nl,

    write("Player 2 turn!"), nl,
    print_info(Hand2, Melds2, "HAND BEFORE TURN: ", "MELDS BEFORE TURN: "), nl,
    take_turn_sets_vs_sets_ss((Player2, Hand2, Melds2, Score2), NewDeck1, NewDiscard1, (_, NewHand2, NewMeld2, _), NewDeck2, NewDiscard2, NewSets, FinalSets), nl,
    print_info(NewHand2, NewMeld2, "HAND AFTER TURN: ", "MELDS AFTER TURN: "), nl, nl, nl,

    play_rummy_round_sr_vs_sets(NewDeck2, (Player1, NewHand1, NewMeld1, Score1), (Player2, NewHand2, NewMeld2, Score2), NewDiscard2, UpdateScore1, UpdateScore2, FinalSets, NewRuns).



% SETS+ AND RUNS+ vs RUNS
%-------------------------------------------------------------------------------------------------------------------------------------------------------------------

take_turn_sr_vs_runs((_, Hand, Melds, _), Deck, DiscardPile, (_, FinalHand, NewestMelds, _), NewDeck1, NewDiscardPile, Runs, NewRuns) :- 
    draw_from_deck(Deck, NewDeck1, Hand, NewHand1),
    merge_sort(NewHand1, NewHand2),
    write("LOOKING FOR RUNS..."), nl,
    find_run_melds(NewHand2, NewHand3, [diamonds, clubs, hearts, spades], Melds, NewestMelds, Runs, NewRuns),
    random_discard(NewHand3, DiscardPile, FinalHand, NewDiscardPile).


% initializes the game and plays an entire round of rummy
play_rummy_sr_vs_runs :- 
    deck(Deck), 
    sets(Sets),
    runs(Runs),
    player((player1, Hand1, Melds1, Score1)),
    player((player2, Hand2, Melds2, Score2)),
    init_rummy(Deck, (_, Hand1, _, _), (_, Hand2, _, _), DiscardPile, NewDeck, (_, NewHand1, _, _), (_, NewHand2, _, _)),
    play_rummy_round_sr_vs_runs(NewDeck, (player1, NewHand1, Melds1, Score1), (player2, NewHand2, Melds2, Score2), DiscardPile, _, _, Sets, Runs),
    write(Runs), nl,
    write(Sets), nl.


% plays an entire round of rummy where sets+ and runs+ play just runs
play_rummy_round_sr_vs_runs([], (_, Hand1, Melds1, Score1), (_, Hand2, Melds2, Score2), _, UpdateScore1, UpdateScore2, Sets, Runs) :- 
    calculate_score((_, Hand1, Melds1, Score1), (_, Hand2, Melds2, Score2), UpdateScore1, UpdateScore2),
    write("Player 1 Score: "), write(UpdateScore1), nl,
    write("Player 2 Score: "), write(UpdateScore2), nl,
    human_readable_melds(Runs, HRRuns),
    write("RUNS: "), write(HRRuns), nl,
    human_readable_melds(Sets, HRSets),
    write("SETS: "), write(HRSets), nl, nl.

play_rummy_round_sr_vs_runs(_, (_, [], Melds1, Score1), (_, Hand2, Melds2, Score2), _, UpdateScore1, UpdateScore2, Sets, Runs) :- 
    calculate_score((_, [], Melds1, Score1), (_, Hand2, Melds2, Score2), UpdateScore1, UpdateScore2),
    write("Player 1 Score: "), write(UpdateScore1), nl,
    write("Player 2 Score: "), write(UpdateScore2), nl,
    human_readable_melds(Runs, HRRuns),
    write("RUNS: "), write(HRRuns), nl,
    human_readable_melds(Sets, HRSets),
    write("SETS: "), write(HRSets), nl, nl.

play_rummy_round_sr_vs_runs(_, (_, Hand1, Melds1, Score1), (_, [], Melds2, Score2), _, UpdateScore1, UpdateScore2, Sets, Runs) :- 
    calculate_score((_, Hand1, Melds1, Score1), (_, [], Melds2, Score2), UpdateScore1, UpdateScore2),
    write("Player 1 Score: "), write(UpdateScore1), nl,
    write("Player 2 Score: "), write(UpdateScore2), nl,
    human_readable_melds(Runs, HRRuns),
    write("RUNS: "), write(HRRuns), nl,
    human_readable_melds(Sets, HRSets),
    write("SETS: "), write(HRSets), nl, nl.

play_rummy_round_sr_vs_runs(Deck, (Player1, Hand1, Melds1, Score1), (Player2, Hand2, Melds2, Score2), DiscardPile, UpdateScore1, UpdateScore2, Sets, Runs) :-
    human_readable(Deck, HRDeck),
    write("Deck: "), write(HRDeck), nl,
    human_readable(DiscardPile, HRDiscardPile),
    write("Discard Pile: "), write(HRDiscardPile), nl,
    human_readable_melds(Runs, HRRuns), write("Runs: "), write(HRRuns), nl,
    human_readable_melds(Sets, HRSets), write("Sets: "), write(HRSets), nl, nl,

    write("Player 1 turn!"), nl,
    print_info(Hand1, Melds1, "HAND BEFORE TURN: ", "MELDS BEFORE TURN: "), nl,
    take_turn_everything((Player1, Hand1, Melds1, Score1), Deck, DiscardPile, (_, NewHand1, NewMeld1, _), NewDeck1, NewDiscard1, Runs, NewRuns, Sets, NewSets), nl,
    print_info(NewHand1, NewMeld1, "HAND AFTER TURN: ", "MELDS AFTER TURN: "), nl, nl,

    write("Player 2 turn!"), nl,
    print_info(Hand2, Melds2, "HAND BEFORE TURN: ", "MELDS BEFORE TURN: "), nl,
    take_turn_sr_vs_runs((Player2, Hand2, Melds2, Score2), NewDeck1, NewDiscard1, (_, NewHand2, NewMeld2, _), NewDeck2, NewDiscard2, NewRuns, FinalRuns), nl,
    print_info(NewHand2, NewMeld2, "HAND AFTER TURN: ", "MELDS AFTER TURN: "), nl, nl, nl,

    play_rummy_round_sr_vs_runs(NewDeck2, (Player1, NewHand1, NewMeld1, Score1), (Player2, NewHand2, NewMeld2, Score2), NewDiscard2, UpdateScore1, UpdateScore2, NewSets, FinalRuns).




% SETS+ AND RUNS+ vs SETS+
%-------------------------------------------------------------------------------------------------------------------------------------------------------------------

% initializes the game and plays an entire round of rummy
play_rummy_sr_vs_sets_ss :- 
    deck(Deck), 
    sets(Sets),
    runs(Runs),
    player((player1, Hand1, Melds1, Score1)),
    player((player2, Hand2, Melds2, Score2)),
    init_rummy(Deck, (_, Hand1, _, _), (_, Hand2, _, _), DiscardPile, NewDeck, (_, NewHand1, _, _), (_, NewHand2, _, _)),
    play_rummy_round_sr_vs_sets_ss(NewDeck, (player1, NewHand1, Melds1, Score1), (player2, NewHand2, Melds2, Score2), DiscardPile, _, _, Sets, Runs),
    write(Runs), nl,
    write(Sets), nl.


% plays an entire round of rummy where sets+ and runs+ play just runs
play_rummy_round_sr_vs_sets_ss([], (_, Hand1, Melds1, Score1), (_, Hand2, Melds2, Score2), _, UpdateScore1, UpdateScore2, Sets, Runs) :- 
    calculate_score((_, Hand1, Melds1, Score1), (_, Hand2, Melds2, Score2), UpdateScore1, UpdateScore2),
    write("Player 1 Score: "), write(UpdateScore1), nl,
    write("Player 2 Score: "), write(UpdateScore2), nl,
    human_readable_melds(Runs, HRRuns),
    write("RUNS: "), write(HRRuns), nl,
    human_readable_melds(Sets, HRSets),
    write("SETS: "), write(HRSets), nl, nl.

play_rummy_round_sr_vs_sets_ss(_, (_, [], Melds1, Score1), (_, Hand2, Melds2, Score2), _, UpdateScore1, UpdateScore2, Sets, Runs) :- 
    calculate_score((_, [], Melds1, Score1), (_, Hand2, Melds2, Score2), UpdateScore1, UpdateScore2),
    write("Player 1 Score: "), write(UpdateScore1), nl,
    write("Player 2 Score: "), write(UpdateScore2), nl,
    human_readable_melds(Runs, HRRuns),
    write("RUNS: "), write(HRRuns), nl,
    human_readable_melds(Sets, HRSets),
    write("SETS: "), write(HRSets), nl, nl.

play_rummy_round_sr_vs_sets_ss(_, (_, Hand1, Melds1, Score1), (_, [], Melds2, Score2), _, UpdateScore1, UpdateScore2, Sets, Runs) :- 
    calculate_score((_, Hand1, Melds1, Score1), (_, [], Melds2, Score2), UpdateScore1, UpdateScore2),
    write("Player 1 Score: "), write(UpdateScore1), nl,
    write("Player 2 Score: "), write(UpdateScore2), nl,
    human_readable_melds(Runs, HRRuns),
    write("RUNS: "), write(HRRuns), nl,
    human_readable_melds(Sets, HRSets),
    write("SETS: "), write(HRSets), nl, nl.

play_rummy_round_sr_vs_sets_ss(Deck, (Player1, Hand1, Melds1, Score1), (Player2, Hand2, Melds2, Score2), DiscardPile, UpdateScore1, UpdateScore2, Sets, Runs) :-
    human_readable(Deck, HRDeck),
    write("Deck: "), write(HRDeck), nl,
    human_readable(DiscardPile, HRDiscardPile),
    write("Discard Pile: "), write(HRDiscardPile), nl,
    human_readable_melds(Runs, HRRuns), write("Runs: "), write(HRRuns), nl,
    human_readable_melds(Sets, HRSets), write("Sets: "), write(HRSets), nl, nl,

    write("Player 1 turn!"), nl,
    print_info(Hand1, Melds1, "HAND BEFORE TURN: ", "MELDS BEFORE TURN: "), nl,
    take_turn_everything((Player1, Hand1, Melds1, Score1), Deck, DiscardPile, (_, NewHand1, NewMeld1, _), NewDeck1, NewDiscard1, Runs, NewRuns, Sets, NewSets), nl,
    print_info(NewHand1, NewMeld1, "HAND AFTER TURN: ", "MELDS AFTER TURN: "), nl, nl,

    write("Player 2 turn!"), nl,
    print_info(Hand2, Melds2, "HAND BEFORE TURN: ", "MELDS BEFORE TURN: "), nl,
    take_turn_sets2((Player2, Hand2, Melds2, Score2), NewDeck1, NewDiscard1, (_, NewHand2, NewMeld2, _), NewDeck2, NewDiscard2, NewSets, FinalSets), nl,
    print_info(NewHand2, NewMeld2, "HAND AFTER TURN: ", "MELDS AFTER TURN: "), nl, nl, nl,

    play_rummy_round_sr_vs_sets_ss(NewDeck2, (Player1, NewHand1, NewMeld1, Score1), (Player2, NewHand2, NewMeld2, Score2), NewDiscard2, UpdateScore1, UpdateScore2, FinalSets, NewRuns).



% SETS+ AND RUNS+ vs RUNS+
%-------------------------------------------------------------------------------------------------------------------------------------------------------------------

% initializes the game and plays an entire round of rummy
play_rummy_sr_vs_runs_ss :- 
    deck(Deck), 
    sets(Sets),
    runs(Runs),
    player((player1, Hand1, Melds1, Score1)),
    player((player2, Hand2, Melds2, Score2)),
    init_rummy(Deck, (_, Hand1, _, _), (_, Hand2, _, _), DiscardPile, NewDeck, (_, NewHand1, _, _), (_, NewHand2, _, _)),
    play_rummy_round_sr_vs_runs_ss(NewDeck, (player1, NewHand1, Melds1, Score1), (player2, NewHand2, Melds2, Score2), DiscardPile, _, _, Sets, Runs),
    write(Runs), nl,
    write(Sets), nl.


% plays an entire round of rummy where sets+ and runs+ play just runs
play_rummy_round_sr_vs_runs_ss([], (_, Hand1, Melds1, Score1), (_, Hand2, Melds2, Score2), _, UpdateScore1, UpdateScore2, Sets, Runs) :- 
    calculate_score((_, Hand1, Melds1, Score1), (_, Hand2, Melds2, Score2), UpdateScore1, UpdateScore2),
    write("Player 1 Score: "), write(UpdateScore1), nl,
    write("Player 2 Score: "), write(UpdateScore2), nl,
    human_readable_melds(Runs, HRRuns),
    write("RUNS: "), write(HRRuns), nl,
    human_readable_melds(Sets, HRSets),
    write("SETS: "), write(HRSets), nl, nl.

play_rummy_round_sr_vs_runs_ss(_, (_, [], Melds1, Score1), (_, Hand2, Melds2, Score2), _, UpdateScore1, UpdateScore2, Sets, Runs) :- 
    calculate_score((_, [], Melds1, Score1), (_, Hand2, Melds2, Score2), UpdateScore1, UpdateScore2),
    write("Player 1 Score: "), write(UpdateScore1), nl,
    write("Player 2 Score: "), write(UpdateScore2), nl,
    human_readable_melds(Runs, HRRuns),
    write("RUNS: "), write(HRRuns), nl,
    human_readable_melds(Sets, HRSets),
    write("SETS: "), write(HRSets), nl, nl.

play_rummy_round_sr_vs_runs_ss(_, (_, Hand1, Melds1, Score1), (_, [], Melds2, Score2), _, UpdateScore1, UpdateScore2, Sets, Runs) :- 
    calculate_score((_, Hand1, Melds1, Score1), (_, [], Melds2, Score2), UpdateScore1, UpdateScore2),
    write("Player 1 Score: "), write(UpdateScore1), nl,
    write("Player 2 Score: "), write(UpdateScore2), nl,
    human_readable_melds(Runs, HRRuns),
    write("RUNS: "), write(HRRuns), nl,
    human_readable_melds(Sets, HRSets),
    write("SETS: "), write(HRSets), nl, nl.

play_rummy_round_sr_vs_runs_ss(Deck, (Player1, Hand1, Melds1, Score1), (Player2, Hand2, Melds2, Score2), DiscardPile, UpdateScore1, UpdateScore2, Sets, Runs) :-
    human_readable(Deck, HRDeck),
    write("Deck: "), write(HRDeck), nl,
    human_readable(DiscardPile, HRDiscardPile),
    write("Discard Pile: "), write(HRDiscardPile), nl,
    human_readable_melds(Runs, HRRuns), write("Runs: "), write(HRRuns), nl,
    human_readable_melds(Sets, HRSets), write("Sets: "), write(HRSets), nl, nl,

    write("Player 1 turn!"), nl,
    print_info(Hand1, Melds1, "HAND BEFORE TURN: ", "MELDS BEFORE TURN: "), nl,
    take_turn_everything((Player1, Hand1, Melds1, Score1), Deck, DiscardPile, (_, NewHand1, NewMeld1, _), NewDeck1, NewDiscard1, Runs, NewRuns, Sets, NewSets), nl,
    print_info(NewHand1, NewMeld1, "HAND AFTER TURN: ", "MELDS AFTER TURN: "), nl, nl,

    write("Player 2 turn!"), nl,
    print_info(Hand2, Melds2, "HAND BEFORE TURN: ", "MELDS BEFORE TURN: "), nl,
    take_turn_runs2((Player2, Hand2, Melds2, Score2), NewDeck1, NewDiscard1, (_, NewHand2, NewMeld2, _), NewDeck2, NewDiscard2, NewRuns, FinalRuns), nl,
    print_info(NewHand2, NewMeld2, "HAND AFTER TURN: ", "MELDS AFTER TURN: "), nl, nl, nl,

    play_rummy_round_sr_vs_runs_ss(NewDeck2, (Player1, NewHand1, NewMeld1, Score1), (Player2, NewHand2, NewMeld2, Score2), NewDiscard2, UpdateScore1, UpdateScore2, NewSets, FinalRuns).



% SETS+ AND RUNS+ vs SETS AND RUNS
%-------------------------------------------------------------------------------------------------------------------------------------------------------------------

% initializes the game and plays an entire round of rummy
play_rummy_srss_vs_sr :- 
    deck(Deck), 
    sets(Sets),
    runs(Runs),
    player((player1, Hand1, Melds1, Score1)),
    player((player2, Hand2, Melds2, Score2)),
    init_rummy(Deck, (_, Hand1, _, _), (_, Hand2, _, _), DiscardPile, NewDeck, (_, NewHand1, _, _), (_, NewHand2, _, _)),
    play_rummy_round_srss_vs_sr(NewDeck, (player1, NewHand1, Melds1, Score1), (player2, NewHand2, Melds2, Score2), DiscardPile, _, _, Sets, Runs),
    write(Runs), nl,
    write(Sets), nl.


%takes turn for sets and runs opponent. Adds any sets found to list for sets+ opponent to play off of
take_turn_both_special3((_, Hand, Melds, _), Deck, DiscardPile, (_, FinalHand, NewestMelds, _), NewDeck1, NewDiscardPile, Sets, NewSets, Runs, NewRuns) :- 
    draw_from_deck(Deck, NewDeck1, Hand, NewHand1),
    write("LOOKING FOR SETS..."), nl,
    find_set_all_melds(NewHand1, NewHand1, Melds, NewMelds, NewHand2, Sets, NewSets),
    merge_sort(NewHand2, SortedHand),
    write("LOOKING FOR RUNS..."), nl,
    find_run_melds(SortedHand, NewHand3, [diamonds, clubs, hearts, spades], NewMelds, NewestMelds, Runs, NewRuns),
    random_discard(NewHand3, DiscardPile, FinalHand, NewDiscardPile).


% plays an entire round of rummy where sets+ and runs+ play just runs
play_rummy_round_srss_vs_sr([], (_, Hand1, Melds1, Score1), (_, Hand2, Melds2, Score2), _, UpdateScore1, UpdateScore2, Sets, Runs) :- 
    calculate_score((_, Hand1, Melds1, Score1), (_, Hand2, Melds2, Score2), UpdateScore1, UpdateScore2),
    write("Player 1 Score: "), write(UpdateScore1), nl,
    write("Player 2 Score: "), write(UpdateScore2), nl,
    human_readable_melds(Runs, HRRuns),
    write("RUNS: "), write(HRRuns), nl,
    human_readable_melds(Sets, HRSets),
    write("SETS: "), write(HRSets), nl, nl.

play_rummy_round_srss_vs_sr(_, (_, [], Melds1, Score1), (_, Hand2, Melds2, Score2), _, UpdateScore1, UpdateScore2, Sets, Runs) :- 
    calculate_score((_, [], Melds1, Score1), (_, Hand2, Melds2, Score2), UpdateScore1, UpdateScore2),
    write("Player 1 Score: "), write(UpdateScore1), nl,
    write("Player 2 Score: "), write(UpdateScore2), nl,
    human_readable_melds(Runs, HRRuns),
    write("RUNS: "), write(HRRuns), nl,
    human_readable_melds(Sets, HRSets),
    write("SETS: "), write(HRSets), nl, nl.

play_rummy_round_srss_vs_sr(_, (_, Hand1, Melds1, Score1), (_, [], Melds2, Score2), _, UpdateScore1, UpdateScore2, Sets, Runs) :- 
    calculate_score((_, Hand1, Melds1, Score1), (_, [], Melds2, Score2), UpdateScore1, UpdateScore2),
    write("Player 1 Score: "), write(UpdateScore1), nl,
    write("Player 2 Score: "), write(UpdateScore2), nl,
    human_readable_melds(Runs, HRRuns),
    write("RUNS: "), write(HRRuns), nl,
    human_readable_melds(Sets, HRSets),
    write("SETS: "), write(HRSets), nl, nl.

play_rummy_round_srss_vs_sr(Deck, (Player1, Hand1, Melds1, Score1), (Player2, Hand2, Melds2, Score2), DiscardPile, UpdateScore1, UpdateScore2, Sets, Runs) :-
    human_readable(Deck, HRDeck),
    write("Deck: "), write(HRDeck), nl,
    human_readable(DiscardPile, HRDiscardPile),
    write("Discard Pile: "), write(HRDiscardPile), nl,
    human_readable_melds(Runs, HRRuns), write("Runs: "), write(HRRuns), nl,
    human_readable_melds(Sets, HRSets), write("Sets: "), write(HRSets), nl, nl,

    write("Player 1 turn!"), nl,
    print_info(Hand1, Melds1, "HAND BEFORE TURN: ", "MELDS BEFORE TURN: "), nl,
    take_turn_everything((Player1, Hand1, Melds1, Score1), Deck, DiscardPile, (_, NewHand1, NewMeld1, _), NewDeck1, NewDiscard1, Runs, NewRuns, Sets, NewSets), nl,
    print_info(NewHand1, NewMeld1, "HAND AFTER TURN: ", "MELDS AFTER TURN: "), nl, nl,

    write("Player 2 turn!"), nl,
    print_info(Hand2, Melds2, "HAND BEFORE TURN: ", "MELDS BEFORE TURN: "), nl,
    take_turn_both_special3((Player2, Hand2, Melds2, Score2), NewDeck1, NewDiscard1, (_, NewHand2, NewMeld2, _), NewDeck2, NewDiscard2, NewSets, FinalSets, NewRuns, FinalRuns), nl,
    print_info(NewHand2, NewMeld2, "HAND AFTER TURN: ", "MELDS AFTER TURN: "), nl, nl, nl,

    play_rummy_round_srss_vs_sr(NewDeck2, (Player1, NewHand1, NewMeld1, Score1), (Player2, NewHand2, NewMeld2, Score2), NewDiscard2, UpdateScore1, UpdateScore2, FinalSets, FinalRuns).