File Coverage

blib/lib/Games/Solitaire/BlackHole/Solver/Golf/App.pm

Criterion	Covered	Total	%
statement	49	56	87.5
branch	11	18	61.1
condition	1	3	33.3
subroutine	4	4	100.0
pod	1	1	100.0
total	66	82	80.4

package Games::Solitaire::BlackHole::Solver::Golf::App;
$Games::Solitaire::BlackHole::Solver::Golf::App::VERSION = '0.18.0';
use 5.014;
use Moo;

extends('Games::Solitaire::BlackHole::Solver::App::Base');
use Games::Solitaire::BlackHole::Solver::App::Base qw/ $card_re /;


sub run
{
    my $self      = shift;
    my $RANK_KING = $self->_RANK_KING;

    # A boolean
    my $place_queens_on_kings = '';

    # A boolean
    my $wrap_ranks = '';
    $self->_process_cmd_line(
        {
            extra_flags => {
                "queens-on-kings!" => \$place_queens_on_kings,
                "wrap-ranks!"      => \$wrap_ranks,
            }
        }
    );
    if ($wrap_ranks)
    {
        $place_queens_on_kings = 1;
    }
    $self->_calc_lines( shift(@ARGV), );

    my $talon_line = shift( @{ $self->_board_lines } );
    my @talon_values;
    my $talon_ptr = 0;
    if ( my ($cards) = $talon_line =~ m{\ATalon:((?: $card_re){16})\z} )
    {
        @talon_values = map { $self->_get_rank($_) }
            @{ $self->_talon_cards( [ $cards =~ /($card_re)/g ] ) };
    }
    else
    {
        die "Could not match first talon line!";
    }

    $self->_set_up_solver( $talon_ptr,
        [ 1, ( $wrap_ranks ? ($RANK_KING) : () ) ] );

    my $positions    = $self->_positions;
    my $board_values = $self->_board_values;

    my $verdict = 0;

    $self->_next_task;

QUEUE_LOOP:
    while ( my $state = $self->_get_next_state_wrapper )
    {
        # The foundation
        my $fnd      = vec( $state, 0, 8 );
        my $no_cards = 1;
        my $tln      = vec( $state, 1, 8 );
        my @sub_queue;

        my @_pending;

        if ( $place_queens_on_kings || ( $fnd != $RANK_KING ) )
        {
            $self->_find_moves( \@sub_queue, $state, \$no_cards );
        }
        else
        {
        COL:
            foreach my $col_idx ( keys @$board_values )
            {
                my $pos = vec( $state, 4 + $col_idx, 4 );

                if ($pos)
                {
                    $no_cards = 0;
                    last COL;
                }
            }
        }

        if ($no_cards)
        {
            $self->_trace_solution( $state, );
            $verdict = 1;
            last QUEUE_LOOP;
        }

        if ( $tln < @talon_values )
        {
            my $next_s = $state;
            vec( $next_s, 0, 8 ) = $talon_values[$tln];
            ++vec( $next_s, 1, 8 );
            if ( !exists( $positions->{$next_s} ) )
            {
                $positions->{$next_s} =
                    [ $state, scalar(@$board_values), 1, 0 ];
                push @_pending, [ $next_s, 0 ];
            }
        }

        # Give preference to non-talon moves
        push @_pending, @sub_queue;
        last QUEUE_LOOP
            if not $self->_process_pending_items( \@_pending, $state );
    }

    return $self->_my_exit( $verdict, );
}


1;

__END__