Games::Pandemic::Player - pandemic game player

    use Games::Pandemic::Player;
    my $role = 'Games::Pandemic::Role::Medic';
    my $player = Games::Pandemic::Player->new_with_traits(traits=>[$role]);

  The GNU General Public License, Version 2, June 1991

#
# This file is part of Games-Pandemic
#
# This software is Copyright (c) 2009 by Jerome Quelin.
#
# This is free software, licensed under:
#
#   The GNU General Public License, Version 2, June 1991
#
use 5.010;
use strict;
use warnings;

package Games::Pandemic::Player;
BEGIN {
  $Games::Pandemic::Player::VERSION = '1.111030';
}
# ABSTRACT: pandemic game player

use File::Spec::Functions qw{ catfile };
use List::MoreUtils       qw{ any };
use Moose                 0.92;
use MooseX::SemiAffordanceAccessor;
use UNIVERSAL::require;

with 'MooseX::Traits';

use Games::Pandemic::Utils;


# -- default builders / finishers

sub DEMOLISH {
    my $self = shift;
    debug( "~player: " . $self->role . "\n" );
}

# -- accessors

has _cards => (
    traits     => ['Hash'],
    is         => 'ro',
    isa        => 'HashRef[Games::Pandemic::Card]',
    default    => sub { {} },
    auto_deref => 1,
    handles    => {
        nb_cards   => 'count',     # my $nb = $player->nb_cards;
        _all_cards => 'values',    # my @c = $player->all_cards;
        drop_card  => 'delete',    # $player->drop_card( $card );
        _add_card  => 'set',       # $player->_add_card( $card, $card );
        owns_card  => 'exists',    # my $bool = $player->owns_card($card);
    }
);

has actions_left => (
    traits  => ['Counter'],
    is      => 'rw',
    default => 0,   # just to clear moose warning
    isa     => 'Int',
    handles => { action_done => 'dec' },
);

has location => ( is=>'rw', isa=>'Games::Pandemic::City', lazy_build => 1 );


# -- default builders

sub _build_location {
    return Games::Pandemic->instance->map->start_city;
}


# -- methods given by the games::pandemic::role::*


#
# my $name = $player->_role;
#
# return the internal, non-localized name of the role, used to name the
# various images associated to the role.
#


# -- public methods

#- default role attributes, superseded by the various roles


sub auto_clean_on_cure { 0 }
sub can_build_anywhere { 0 }
sub can_join_others    { 0 }
sub can_move_others    { 0 }
sub can_share_anywhere { 0 }
sub cards_needed       { 5 }
sub treat_all          { 0 }
sub max_cards          { 7 }


#- misc methods


sub image {
    my ($self, $what, $size) = @_;
    return catfile(
        $SHAREDIR, 'roles',
        join('-', $self->_role, $what, $size) . '.png'
    );
}



sub all_cards {
    my $self = shift;

    # fetch cards
    my @cards = $self->_all_cards;
    my @cities =
        sort { $a->city->disease->name cmp $b->city->disease->name
            || $a->label cmp $b->label }
        grep { $_->isa('Games::Pandemic::Card::City') }
        @cards;
    my @specials =
        sort { $a->label cmp $b->label }
        grep { ! $_->isa('Games::Pandemic::Card::City') }
        @cards;
    return @specials, @cities;
}



sub owns_city_card {
    my ($self, $city) = @_;
    my ($card) =
        grep { $_->can('city') && $_->city eq $city }
        $self->all_cards;
    return $card;
}



sub gain_card {
    my ($self, $card) = @_;
    $self->_add_card( $card, $card );
}


#- methods to check what actions are currently possible *now*


sub is_move_possible { 1 }



sub is_flight_possible {
    my $self = shift;
    my @cards =
        grep { $_->city ne $self->location }
        $self->all_cards;
    return scalar @cards;
}


sub is_charter_possible {}


sub is_shuttle_possible {}


sub is_join_possible {}



sub is_build_possible {
    my $self = shift;
    my $city = $self->location;

    return 0 if $city->has_station;
    return 1 if $self->can_build_anywhere;
    return $self->owns_city_card( $city );
}



sub is_discover_possible {
    my $self = shift;

    return unless $self->location->has_station;

    # get list of city cards
    my @cards =
        grep { $_->isa('Games::Pandemic::Card::City') }
        $self->all_cards;

    # check if we have enough cards
    my %seen;
    foreach my $card ( @cards ) {
        my $disease = $card->city->disease;
        my $name = $disease->name;
        $seen{$name}++;
        return $disease if $seen{$name} == $self->cards_needed && ! $disease->has_cure;
    }

    return 0;
}



sub is_treat_possible {
    my $self = shift;
    my $city = $self->location;
    my $game = Games::Pandemic->instance;
    my $map  = $game->map;

    foreach my $disease ( $map->all_diseases ) {
        return 1 if $city->get_infection($disease);
    }
    return 0;
}



sub is_share_possible {
    my $self = shift;
    my $city = $self->location;
    my $game = Games::Pandemic->instance;

    return 0 unless grep { $_ ne $self && $_->location eq $city } $game->all_players;
    return 1 if $self->can_share_anywhere;
    return $self->owns_city_card( $city );
}



sub is_pass_possible { 1 }



sub is_drop_possible {
    my $self = shift;
    return $self->nb_cards;
}


#- methods to control whether an action (with all params) is valid


sub can_travel_to {
    my ($self, $city) = @_;
    return any { $_ eq $city } $self->location->neighbours;
}



sub can_shuttle_to {
    my ($self, $city) = @_;
    my $location = $self->location;
    return $city ne $location && $location->has_station && $city->has_station;
}



sub can_join_to {}




no Moose;
__PACKAGE__->meta->make_immutable;

1;

__END__