view release on metacpan or  search on metacpan

lib/AI/Pathfinding/OptimizeMultiple/App/CmdLine.pm  view on Meta::CPAN

    my $simulate_to          = undef;
    my $_add_horne_prune     = 0;
    my $input_obj_class = 'AI::Pathfinding::OptimizeMultiple::DataInputObj';
    my %stats_factors;

    my $help = 0;
    my $man  = 0;
    GetOptionsFromArray(
        $self->argv(),
        'help|h'          => \$help,
        man               => \$man,
        "o|output=s"      => \$output_filename,
        "num-boards=i"    => \$num_boards,
        "trace"           => \$should_trace_be_done,
        "rle!"            => \$should_rle_be_done,
        "start-board=i"   => \$_start_board,
        "quotas-expr=s"   => \$_quotas_expr,
        "quotas-are-cb"   => \$quotas_are_cb,
        "offset-quotas"   => \$offset_quotas,
        "opt-for=s"       => \$optimize_for,
        "simulate-to=s"   => \$simulate_to,
        "sprtf"           => \$_add_horne_prune,
        "input-class=s"   => \$input_obj_class,
        "stats-factors=f" => \%stats_factors,
    ) or die "Extracting options from ARGV array failed - $!";

    if ($help)
    {
        $self->_should_exit_immediately(1);
        print <<"EOF";
$0 - optimize a game AI multi-tasking configuration

--help | -h - displays this help screen
--output=[filename] | -o [filename] - output to this file instead of STDOUT.
EOF
        return;
    }

    $self->_start_board($_start_board);
    $self->_num_boards($num_boards);
    $self->_output_filename($output_filename);
    $self->_should_trace_be_done($should_trace_be_done);
    $self->_should_rle_be_done($should_rle_be_done);
    $self->_quotas_expr($_quotas_expr);
    $self->_quotas_are_cb($quotas_are_cb);
    $self->_optimize_for($optimize_for);
    $self->_offset_quotas($offset_quotas);
    $self->_simulate_to($simulate_to);
    $self->_add_horne_prune($_add_horne_prune);
    $self->_stats_factors( \%stats_factors );
    $self->input_obj_class($input_obj_class);

    {
        my $class = $self->input_obj_class();
        if ( $class !~ m{\A$_module_re\z} )
        {
            Carp::confess(
                "Input object class does not seem like a good class:"
                    . $self->input_obj_class() );
        }
        eval "require $class;";
        if ($@)
        {
            die "Could not load '$class' - <<$@>>";
        }

        # TODO : Restore later.
        $self->_input_obj(
            $class->new(
                {
                    start_board => $self->_start_board(),
                    num_boards  => $self->_num_boards(),
                }
            )
        );
    }

    $self->_post_processor(
        AI::Pathfinding::OptimizeMultiple::PostProcessor->new(
            {
                do_rle        => $self->_should_rle_be_done(),
                offset_quotas => $self->_offset_quotas(),
            }
        )
    );

    return;
}

sub _selected_scans
{
    my $self = shift;

    return $self->_input_obj->selected_scans();
}

sub _map_all_but_last
{
    my $self = shift;

    my ( $cb, $arr_ref ) = (@_);

    return [
        ( map { $cb->($_) } @$arr_ref[ 0 .. $#$arr_ref - 1 ] ),
        $arr_ref->[-1]
    ];
}

sub _get_quotas
{
    my $self = shift;
    if ( $self->_quotas_are_cb() )
    {
        return scalar( eval( $self->_quotas_expr() ) );
    }
    elsif ( defined( $self->_quotas_expr() ) )
    {
        return [ eval $self->_quotas_expr() ];
    }
    else
    {
        return $self->_get_default_quotas();
    }
}

sub _get_default_quotas
{
    return [ (350) x 5000 ];
}

sub _get_script_fh
{
    my $self = shift;
    return IO::File->new(
        ( $self->_output_filename() eq "-" )
        ? ">&STDOUT"
        : ( $self->_output_filename(), "w" )
    );
}

sub _get_script_terminator
{
    return "\n\n\n";
}

sub _out_script
{
    my $self            = shift;
    my $cmd_line_string = shift;

    $self->_get_script_fh()
        ->print( $cmd_line_string,
        $self->_get_script_terminator($cmd_line_string) );
}

sub _get_line_of_command
{
    my $self = shift;

    my $args_string = join( " ",
        $self->_start_board(),
        $self->_start_board() + $self->_num_boards() - 1, 1 );
    return "freecell-solver-range-parallel-solve $args_string";
}

sub _line_ends_mapping
{
    my $self = shift;
    return $self->_map_all_but_last( sub { "$_[0] \\\n" }, shift );
}

sub _get_used_scans
{
    my $self = shift;
    return [ grep { $_->is_used() } @{ $self->_selected_scans() } ];
}

sub _get_scan_line