ClueFinal.pl

:- dynamic active_player/1.
:- dynamic current_player/1.
:- dynamic controlling_player/1.
:- dynamic room/1.
:- dynamic weapon/1.

:- dynamic last_play_id/1.

:- dynamic card_in_possession/2.
:- dynamic recorded_suggestion/3.
:- dynamic recorded_to_player_response/3.
:- dynamic recorded_to_opponent_response/2.

/*
    Game Setup
*/

init_clue(Type, Players, ControllingPlayer) :-
	% Wipe everything first
	wipe,
	init_weapons(Type),
	init_rooms(Type),
	init_players(Players),
	init_first_player,
	assert(controlling_player(ControllingPlayer)),
	assert(last_play_id(0)).

init_players([]).
init_players([Name|Names]) :-
    assert(active_player(Name)),
    init_players(Names).

% If mrsPeacock is playing, then she's first
init_first_player :-
	active_player(mrsPeacock),
	assert(current_player(mrsPeacock)).
% Else, find whoever is to the left
init_first_player :-
	assert(current_player(mrsPeacock)),
	next_turn(TrueFirst),
	set_current_player(TrueFirst).
% wipe game databases
wipe :-
	retractall(weapon(_)),
	retractall(room(_)),
	retractall(active_player(_)),
	retractall(current_player(_)),
	retractall(controlling_player(_)),
	retractall(recorded_suggestion(_,_,_)),
	retractall(recorded_to_player_response(_,_,_)),
	retractall(recorded_to_opponent_response(_,_)),
	retractall(card_in_possession(_,_)).

/*
Deduction
*/
check_accusation :-
	get_remaining_chars(C),
	get_remaining_weapons(W),
	get_remaining_rooms(R),
	length(C,1),
	length(W,1),
	length(R,1),
	write('Accusation found: \n'),
	write(C),
	write(' killed Mr. Boddy with '),
	write(W),
	write(' in the '),
	write(R),
	write('.').
	
get_remaining_chars(Chars) :-
	get_all_chars(C),
	get_eliminated_chars(EC),
	subtract(C,EC, Chars).
get_remaining_weapons(Weapons) :-
	get_all_weapons(W),
	get_eliminated_weapons(EW),
	subtract(W,EW, Weapons).
get_remaining_rooms(Rooms) :-
	get_all_rooms(R),
	get_eliminated_rooms(ER),
	subtract(R,ER,Rooms).

get_eliminated_cards(All) :-
	findall(X, card_in_possession(_,X), All).

get_all_chars(Chars) :-
	setof(X, character(X), Chars).
get_all_weapons(Weapons) :-
	setof(X, weapon(X), Weapons).
get_all_rooms(Rooms) :-
	setof(X, room(X), Rooms).

get_eliminated_chars(Chars) :-
	setof(X, (card_in_possession(_,X),character(X)), Chars).
get_eliminated_weapons(Weapons) :-
	setof(X, (card_in_possession(_,X),weapon(X)), Weapons).
get_eliminated_rooms(Rooms) :-
	setof(X, (card_in_possession(_,X),room(X)), Rooms).

/*
Game Cycles
*/

set_current_player(Player) :-
	retractall(current_player(_)),
	assert(current_player(Player)).
next_turn(NextPlayer) :-
	current_player(Current),
	relatively_left(Current, NextPlayer),
	% That's active
    active_player(NextPlayer),
    % No more
    !.
    
/*
    Main Gameplay
*/

new_suggestion(Id, Player, suggestion(Location, Suspect, Weapon)) :-
    % Get a new ID for the suggestion
    new_play_id(Id),
    % Record it
    assert(recorded_suggestion(Id, Player, suggestion(Location, Suspect, Weapon))).
    
% This happens when someone responds to a move the controlling player makes
player_suggestion_response(SuggestionId, Opponent, DebunkingCard) :-
    % We know that the opponent posesses this card
    assert(card_in_possession(Opponent, DebunkingCard)),
    % Record this response
    assert(recorded_to_player_response(SuggestionId, Opponent, DebunkingCard)).
    
% This happens when someone responds to a move an oppponent makes
opponent_suggestion_response(SuggestionId, Debunker) :-
    % TODO: Mark all cards this his suggestion as possibly in the hand of someone
    assert(recorded_to_opponent_response(SuggestionId, Debunker)).
    
new_play_id(X) :-
    last_play_id(LastId),
    X is LastId + 1,
    retractall(last_play_id(_)),
    assert(last_play_id(X)).

save_own_cards([]).
save_own_cards([Card|Cards]) :-
	controlling_player(CPlayer),
	assert(card_in_possession(CPlayer, Card)),
	save_own_cards(Cards).
/*
    User Interface
*/

main :-
    write('Clue Assistant 1.0\n'),
    ask_school(School),
    ask_players(Players),
    ask_controller(ControllingPlayer),
	ask_own_cards(Cards),
    init_clue(School, Players, ControllingPlayer),
	save_own_cards(Cards),
    write('Game Initialized.\n\n'),
    main_menu(0).
    
ask_school(School) :-
    write('School of Thought [oldSchool, newSchool]: '),
    read(School).
    
ask_players(Players) :-
    write('Type the participating players in the following format\n'),
    write(' [player0, player1, etc..]: '),
    read(Players).
    
ask_controller(ControllingPlayer) :-
    write('Who are you playing as?: '),
    read(ControllingPlayer).

ask_own_cards(Cards) :-
	write('What cards do you have\n'),
	write('[card0, card1, ...].: '),
	read(Cards).
    
% Main Menu
    
main_menu(0) :-
    print_main_menu,
    read(Option),
    main_menu(Option).
    
% Record a new suggestion
main_menu(1) :-
    new_move(0),
    main_menu(0).

% Show suggestion history
main_menu(2) :-
    fact_history_menu,
    main_menu(0).
    
% Show card facts
main_menu(3) :-
    card_fact_menu,
    main_menu(0).

main_menu(4) :-
	check_accusation,
	main_menu(0).

main_menu(5).
    
% Repeat the menu
main_menu(_) :- main_menu(0).

print_main_menu :-
    write('[1] Record a new suggestion\n'),
    write('[2] Show suggestion history\n'),
    write('[3] Show card facts\n'),
	write('[4] Check for accusation\n'),
	write('[5] Leave\n').
    
/*
    UI: Recording moves
*/

new_move(0) :-
    print_new_move,
    read(Option),
    suggestion_menu(Option).
   
    
print_new_move :-
    write('[1] Record a suggestion you made\n'),
    write('[2] Record a suggestion an opponent made\n').
   
% A player suggestion
suggestion_menu(1) :-
    controlling_player(ControllingPlayer),
    generic_suggestion_menu(SuggestionId, ControllingPlayer),
    % Check for a response
    write('Did anyone show you a card? [yes, no]: '),
    read(Response),
    player_suggestion_response_menu(Response, SuggestionId).
    
% An opponent suggestion
suggestion_menu(2) :-
    write('Who made this suggestion?: '),
    read(Opponent),
    generic_suggestion_menu(SuggestionId, Opponent),
    write('Did anyone respond to this suggestion? [yes, no]: '),
    read(Response),
    opponent_suggestion_response_menu(Response, SuggestionId).

generic_suggestion_menu(SuggestionId, Player) :-
    write('(Suggestion) Who: '),
    read(Character),
    write('(Suggestion) Where: '),
    read(Where),
    write('(Suggestion) With What: '),
    read(Weapon),
    % Record this suggestion
    new_suggestion(SuggestionId, Player, suggestion(Where, Character, Weapon)).
    
% When someone responds to a suggestion a player made
player_suggestion_response_menu(no, _).
player_suggestion_response_menu(yes, SuggestionId) :-
    write('Who responded?: '),
    read(Debunker),
    write('Which card was shown?: '),
    read(Card),
    player_suggestion_response(SuggestionId, Debunker, Card).
    
% When someone responds to a suggestion an opponent made
opponent_suggestion_response_menu(no, _).
opponent_suggestion_response_menu(yes, SuggestionId) :-
    write('Who responded?: '),
    read(Debunker),
    opponent_suggestion_response(SuggestionId, Debunker).
    
/*
    UI: Move history
*/

fact_history_menu :-
    % For each suggestion,
    findall(Id,recorded_suggestion(Id,_,_),L),
    print_facts(L).
    
print_facts([]).
print_facts([SuggestionId|Ids]) :-
    print_suggestion(SuggestionId),
    print_suggestion_response(SuggestionId),
    write('\n'),
    print_facts(Ids).
      
print_suggestion(SuggestionId) :-
    recorded_suggestion(SuggestionId, Player, suggestion(Location, Suspect, Weapon)),
    write(Player),
    write(' suggested ('),
    write(Suspect),
    write(','),
    write(Weapon),
    write(','),
    write(Location),
    write('). ').
    
print_suggestion_response(SuggestionId) :-
    % Is this a player suggestion?
    recorded_to_player_response(SuggestionId, Opponent, DebunkingCard),
    % It can't be anything else
	!,
	write(Opponent),
	write(' showed '),
	write(DebunkingCard).
print_suggestion_response(SuggestionId) :-
	% Is this an opponent suggestion?
	recorded_to_opponent_response(SuggestionId, Debunker),
	!,
	write(Debunker),
	write(' showed a card.').

print_suggestion_response(_) :-
	% Previous goals could not be proven
	write('No one responded.').

/*
UI: Cards
*/

card_fact_menu :-
	findall(X, card_in_possession(_, X), L),
	print_card_facts(L).

print_card_facts([]).
print_card_facts([Card|Cards]) :-
	card_in_possession(Owner, Card),
	write(Card),
	write(' is owned by '),
	write(Owner),
	write('\n'),
    print_card_facts(Cards).


/*
    Game Elements and Rules
*/

character(missScarlet).
character(colonelMustard).
character(mrsWhite).
character(mrGreen).
character(mrsPeacock).
character(professorPlum).

% Player Spatial Ordering
left_of(missScarlet, colonelMustard).
left_of(colonelMustard, mrsWhite).
left_of(mrsWhite, mrGreen).
left_of(mrGreen, mrsPeacock).
left_of(mrsPeacock, professorPlum).
left_of(professorPlum, missScarlet).

relatively_left(LeftPlayer, RightPlayer) :- left_of(LeftPlayer, RightPlayer).
relatively_left(LeftPlayer, RightPlayer) :-
    left_of(LeftPlayer, DirectlyLeft),
    relatively_left(DirectlyLeft, RightPlayer).

init_weapons(oldSchool) :-
    assert(weapon(knife)),
    assert(weapon(candlestick)),
    assert(weapon(revolver)),
    assert(weapon(rope)),
    assert(weapon(pipe)),
    assert(weapon(wrench)).
    
init_weapons(newSchool) :-
    assert(weapon(knife)),
    assert(weapon(candlestick)),
    assert(weapon(pistol)),
    assert(weapon(rope)),
    assert(weapon(bat)),
    assert(weapon(ax)).
    
init_rooms(oldSchool) :-
    assert(room(kitchen)),
    assert(room(ballroom)),
    assert(room(conservatory)),
    assert(room(billiard)),
    assert(room(library)),
    assert(room(study)),
    assert(room(hall)),
    assert(room(lounge)),
    assert(room(dining_room)).
    
init_rooms(newSchool) :-
    assert(room(kitchen)),
    assert(room(patio)),
    assert(room(spa)),
    assert(room(theatre)),
    assert(room(living)),
    assert(room(observatory)),
    assert(room(hall)),
    assert(room(guest)),
    assert(room(dining)).