File Coverage

blib/lib/Games/ABC_Path/Generator/RiddleObj.pm

Criterion	Covered	Total	%
statement	64	68	94.1
branch	20	22	90.9
condition			n/a
subroutine	15	16	93.7
pod	4	4	100.0
total	103	110	93.6

package Games::ABC_Path::Generator::RiddleObj;
$Games::ABC_Path::Generator::RiddleObj::VERSION = '0.4.2';
use 5.006;

use strict;
use warnings;

use Carp;

use integer;

use parent 'Games::ABC_Path::Solver::Base';

use Games::ABC_Path::Solver::Constants;


sub _solution
{
    my $self = shift;

    if (@_)
    {
        $self->{_solution} = shift;
    }

    return $self->{_solution};
}

sub _clues
{
    my $self = shift;

    if (@_)
    {
        $self->{_clues} = shift;
    }

    return $self->{_clues};
}

sub _A_pos
{
    my $self = shift;

    if (@_)
    {
        $self->{_A_pos} = shift;
    }

    return $self->{_A_pos};
}

sub _init
{
    my $self = shift;
    my $args = shift;

    $self->_solution( $args->{solution} );
    $self->_clues( $args->{clues} );
    $self->_A_pos( $args->{A_pos} );

    return;
}


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

    my $get_index = sub {
        my $i = $args->{index};

        if ( $i !~ m{\A[01234]\z} )
        {
            Carp::confess('index must be in the range 0-4');
        }

        return $i;
    };

    my $clue_idx;
    my $type = $args->{type};

    if ( $type eq 'col' )
    {
        $clue_idx = 2 + $LEN + $get_index->();
    }
    elsif ( $type eq 'row' )
    {
        $clue_idx = 2 + $get_index->();
    }
    elsif ( $type eq 'diag' )
    {
        $clue_idx = 0;
    }
    elsif ( $type eq 'antidiag' )
    {
        $clue_idx = 1;
    }
    else
    {
        Carp::confess("Unknown type $type.");
    }

    return [ map { $letters[ $_ - 1 ] } @{ $self->_clues->[$clue_idx] } ];
}


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

    my $s = ( ( ' ' x 7 ) . "\n" ) x 7;

    substr( $s, ( $self->_A_pos->y + 1 ) * 8 + $self->_A_pos->x + 1, 1 ) = 'A';

    my $clues = $self->_clues();
    foreach my $clue_idx ( 0 .. $NUM_CLUES - 1 )
    {
        my @pos =
              ( $clue_idx == 0 ) ? ( [ 0, 0 ], [ 6, 6 ] )
            : ( $clue_idx == 1 ) ? ( [ 0, 6 ], [ 6, 0 ] )
            : ( $clue_idx < ( 2 + 5 ) )
            ? ( [ 1 + $clue_idx - (2), 0 ], [ 1 + $clue_idx - (2), 6 ] )
            : (
            [ 0, 1 + $clue_idx - ( 2 + 5 ) ],
            [ 6, 1 + $clue_idx - ( 2 + 5 ) ]
            );

        foreach my $i ( 0 .. 1 )
        {
            substr( $s, $pos[$i][0] * 8 + $pos[$i][1], 1 ) =
                $letters[ $clues->[$clue_idx]->[$i] - 1 ];
        }
    }

    return $s;
}


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

    return $self->_solution;
}


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

    return $self->_solution->as_string($args);
}


1;    # End of Games::ABC_Path::Generator

__END__