File Coverage

blib/lib/Games/Solitaire/Verify/Card.pm

Criterion	Covered	Total	%
statement	78	78	100.0
branch	20	20	100.0
condition			n/a
subroutine	21	21	100.0
pod	12	12	100.0
total	131	131	100.0

package Games::Solitaire::Verify::Card;
$Games::Solitaire::Verify::Card::VERSION = '0.2601';
use warnings;
use strict;


use parent 'Games::Solitaire::Verify::Base';

use Games::Solitaire::Verify::Exception ();

__PACKAGE__->mk_acc_ref(
    [
        qw(
            _flipped
            _s
            data
            id
            rank
            suit
            _game
        )
    ]
);


sub _recalc
{
    my ($self) = @_;

    $self->_s( $self->to_string() );

    return;
}

sub _card_num_normalize
{
    my $arg = shift;

    if ( ref($arg) eq "" )
    {
        return +{ map { $_ => $arg } (qw(t non_t)) };
    }
    else
    {
        return $arg;
    }
}

my @card_nums = (
    map { _card_num_normalize($_) } (
        "A",
        ( 2 .. 9 ),
        {
            't'     => "T",
            'non_t' => "10",
        },

        "J", "Q",
        "K"
    )
);

my %ranks_map =
    ( map { $card_nums[$_]->{t} => ( $_ + 1 ) } ( 0 .. $#card_nums ) );

my @suits_map_proto = (
    [ "H" => { name => "hearts",   color => "red", }, ],
    [ "C" => { name => "clubs",    color => "black", }, ],
    [ "D" => { name => "diamonds", color => "red", }, ],
    [ "S" => { name => "spades",   color => "black", }, ],
);

my %suits_map = ( map { @$_ } @suits_map_proto );


sub get_suits_seq
{
    my $class = shift;

    return [ map { $_->[0] } @suits_map_proto ];
}


sub calc_rank
{
    my ( $self, $s ) = @_;

    return $ranks_map{$s};
}


sub calc_rank_with_0
{
    my ( $self, $str ) = @_;

    if ( $str eq "0" )
    {
        return 0;
    }
    else
    {
        return $self->calc_rank($str);
    }
}

sub _from_string
{
    my ( $self, $str ) = @_;

    my $is_flipped = 0;

    if ( $str =~ s{\A<(.*)>\z}{$1}ms )
    {
        $is_flipped = 1;
    }

    if ( length($str) != 2 )
    {
        Games::Solitaire::Verify::Exception::Parse::Card->throw(
            error => "string length is too long", );
    }

    my ( $rank, $suit ) = split( //, $str );

    if ( !defined( $self->rank( $self->calc_rank($rank) ) ) )
    {
        Games::Solitaire::Verify::Exception::Parse::Card::UnknownRank->throw(
            error => "unknown rank", );
    }

    if ( exists( $suits_map{$suit} ) )
    {
        $self->suit($suit);
    }
    else
    {
        Games::Solitaire::Verify::Exception::Parse::Card::UnknownSuit->throw(
            error => "unknown suit", );
    }

    $self->set_flipped($is_flipped);

    return;
}

sub _init
{
    my ( $self, $args ) = @_;

    if ( exists( $args->{string} ) )
    {
        $self->_from_string( $args->{string} );
        $self->_recalc();
    }

    if ( exists( $args->{id} ) )
    {
        $self->id( $args->{id} );
    }

    if ( exists( $args->{data} ) )
    {
        $self->data( $args->{data} );
    }

    return;
}


sub color
{
    my ($self) = @_;

    return $self->color_for_suit( $self->suit() );
}


sub color_for_suit
{
    my ( $self, $suit ) = @_;

    return $suits_map{$suit}->{'color'};
}


sub clone
{
    my $self = shift;

    my $new_card = Games::Solitaire::Verify::Card->new();

    $new_card->data( $self->data() );
    $new_card->id( $self->id() );
    $new_card->suit( $self->suit() );
    $new_card->rank( $self->rank() );

    $new_card->_recalc();

    return $new_card;
}


sub _to_string_without_flipped
{
    my $self = shift;

    return $self->rank_to_string( $self->rank() ) . $self->suit();
}

sub to_string
{
    my $self = shift;

    my $s = $self->_to_string_without_flipped();

    return ( $self->is_flipped ? "<$s>" : $s );
}


sub fast_s
{
    return shift->_s;
}


{
    my @_t_nums = ( '0', ( map { $_->{t} } @card_nums ) );

    sub get_ranks_strings
    {
        return \@_t_nums;
    }

    sub rank_to_string
    {
        my ( $class, $rank ) = @_;

        return $_t_nums[$rank];
    }

}


sub is_flipped
{
    return shift->_flipped();
}


sub set_flipped
{
    my ( $self, $v ) = @_;

    $self->_flipped($v);

    $self->_recalc();

    return;
}

1;    # End of Games::Solitaire::Verify::Card

__END__