Games::Solitaire::Verify::Freecells - a class for representing the

Games-Solitaire-Verify documentation

Contained in the Games-Solitaire-Verify distribution.

Index

NAME
VERSION
SYNOPSIS
FUNCTIONS
AUTHOR
BUGS
SUPPORT
ACKNOWLEDGEMENTS
COPYRIGHT & LICENSE

Code Index:

package Games::Solitaire::Verify::Freecells
- _input_from_string
- _init
- _parse_freecell_card
- count
- cell
- assign
- to_string
- cell_clone
- clear
- clone
- num_empty
EOF

NAME

Games::Solitaire::Verify::Freecells - a class for representing the Freecells in games such as Freecell, Baker's Game, or Seahaven Towers

VERSION

Version 0.01

SYNOPSIS

    use Games::Solitaire::Verify::Freecells;

    # For internal use.

FUNCTIONS

$self->count()

Returns the number of cells.

$self->cell($index)

Returns the card in the freecell with the index $index .

$self->assign($index, $card)

Sets the card in the freecell with the index $index to $card, which should be a Games::Solitaire::Verify::Card object.

$self->to_string()

Stringifies the freecells into the Freecell Solver solution display notation.

$self->cell_clone($pos)

Returns a clone of the card in the position $pos .

$self->clear($pos)

Clears/empties the freecell at position $pos .

$board->clone()

Returns a clone of the freecells, with all of their cards duplicated.

$self->num_empty()

Returns the number of empty freecells.

AUTHOR

Shlomi Fish, <shlomif at iglu.org.il>

BUGS

Please report any bugs or feature requests to bug-games-solitaire-verifysolution-move at rt.cpan.org, or through the web interface at http://rt.cpan.org/NoAuth/ReportBug.html?Queue=Games-Solitaire-Verify. I will be notified, and then you'll automatically be notified of progress on your bug as I make changes.

SUPPORT

You can find documentation for this module with the perldoc command.

    perldoc Games::Solitaire::Verify::Column

You can also look for information at:

* RT: CPAN's request tracker: http://rt.cpan.org/NoAuth/Bugs.html?Dist=Games-Solitaire-Verify
* AnnoCPAN: Annotated CPAN documentation: http://annocpan.org/dist/Games-Solitaire-Verify
* CPAN Ratings: http://cpanratings.perl.org/d/Games-Solitaire-Verify
* Search CPAN: http://search.cpan.org/dist/Games-Solitaire-Verify

ACKNOWLEDGEMENTS

COPYRIGHT & LICENSE

Copyright 2008 Shlomi Fish.

This program is released under the following license: MIT/X11 ( http://www.opensource.org/licenses/mit-license.php ).

Games-Solitaire-Verify documentation

Contained in the Games-Solitaire-Verify distribution.

package Games::Solitaire::Verify::Freecells;

use warnings;
use strict;

our $VERSION = '0.0901';

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

use Games::Solitaire::Verify::Exception;
use Games::Solitaire::Verify::Card;

use List::Util qw(first);

__PACKAGE__->mk_acc_ref([qw(
    _count
    _cells
    )]);

sub _input_from_string
{
    my $self = shift;
    my $str = shift;

    if ($str !~ m{\AFreecells:}gms)
    {
        Games::Solitaire::Verify::Exception::Parse::State::Freecells->throw(
            error => "Wrong Freecell String",
        );
    }

    for my $pos (0 .. ($self->count()-1))
    {
        if ($str =~ m{\G  (..)}gms)
        {
            my $card_s = $1;
            $self->assign($pos, $self->_parse_freecell_card($card_s))
        }
        else
        {
            Games::Solitaire::Verify::Exception::Parse::State::Freecells->throw(
                error => "Wrong Freecell String",
            );
        }
    }
}

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

    if (! exists($args->{count}))
    {
        die "The count was not specified for the freecells";
    }

    $self->_count($args->{count});

    $self->_cells([(undef) x $self->_count()]);

    if (exists($args->{string}))
    {
        return $self->_input_from_string($args->{string});
    }

    return;
}

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

    return
    (
        ($s eq q{  })
            ? undef()
            : Games::Solitaire::Verify::Card->new(
                {
                    string => $s,
                }
            )
    );
}

sub count
{
    my $self = shift;

    return $self->_count();
}

sub cell
{
    my ($self, $idx) = @_;

    return $self->_cells()->[$idx];
}

sub assign
{
    my ($self, $idx, $card) = @_;

    $self->_cells()->[$idx] = $card;

    return;
}

sub to_string
{
    my $self = shift;

    return "Freecells:" . (($self->count() == 0) ? " " :
    join("",
        map { "  " . (defined($_) ? $_->to_string() : "  ") }
        map { $self->cell($_) } 
        (0 .. ($self->count()-1))
    ));
}

sub cell_clone
{
    my ($self, $pos) = @_;

    my $card = $self->cell($pos);

    return defined($card) ? $card->clone() : undef();
}

sub clear
{
    my ($self, $pos) = @_;

    undef($self->_cells()->[$pos]);

    return;
}


sub clone
{
    my $self = shift;

    my $copy = 
        __PACKAGE__->new(
            {
                count => $self->count(),
            }
        );

    foreach my $pos (0 .. ($self->count()-1))
    {
        $copy->assign($pos, $self->cell_clone($pos));
    }

    return $copy;
}

sub num_empty
{
    my $self = shift;

    my $count = 0;

    foreach my $fc_idx (0 .. ($self->count()-1) )
    {
        if (!defined($self->cell($fc_idx)))
        {
            $count++;
        }
    }
    return $count;
}

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