File Coverage

blib/lib/Games/SMTNocturne/Demons/Demon.pm

Criterion	Covered	Total	%
statement	46	50	92.0
branch	18	22	81.8
condition			n/a
subroutine	14	15	93.3
pod	5	10	50.0
total	83	97	85.5

package Games::SMTNocturne::Demons::Demon;
BEGIN {
  $Games::SMTNocturne::Demons::Demon::AUTHORITY = 'cpan:DOY';
}
$Games::SMTNocturne::Demons::Demon::VERSION = '0.02';
use strict;
use warnings;
use overload '""' => 'to_string', fallback => 1;
# ABSTRACT: an individual demon

use JSON::PP;


my %DEMONS_BY_NAME = %{ decode_json(do { local $/;  }) };
for my $name (keys %DEMONS_BY_NAME) {
    $DEMONS_BY_NAME{$name}{name} = $name;
    $DEMONS_BY_NAME{$name} = bless $DEMONS_BY_NAME{$name}, __PACKAGE__;
}
my @DEMONS = sort {
    $a->level <=> $b->level || $a->name cmp $b->name
} values %DEMONS_BY_NAME;

my %DEMONS_BY_TYPE;
for my $name (keys %DEMONS_BY_NAME) {
    my $demon = $DEMONS_BY_NAME{$name};
    push @{ $DEMONS_BY_TYPE{$demon->type} ||= [] }, $demon;
}
for my $type (keys %DEMONS_BY_TYPE) {
    my $demons = $DEMONS_BY_TYPE{$type};
    @$demons = sort { $a->level <=> $b->level } @$demons;
}

sub from_name {
    my ($class, $name) = @_;

    die "unknown demon $name" unless $DEMONS_BY_NAME{$name};

    return $DEMONS_BY_NAME{$name};
}

sub all_demons {
    my $class = shift;
    return @DEMONS;
}

sub from_fusion_stats {
    my ($class, $options) = @_;

    die "unknown type $options->{type}"
        unless $DEMONS_BY_TYPE{$options->{type}};

    my @possible = @{ $DEMONS_BY_TYPE{$options->{type}} };

    @possible = grep { $_->fusion_type eq $options->{fusion_type} } @possible
        if $options->{fusion_type};

    my %bosses = map { $_ => 1 } @{ $options->{bosses} || [] };
    @possible = grep { !$_->boss || $bosses{$_->name} } @possible;

    my $found_idx;
    for my $i (0..$#possible) {
        $found_idx = $i;
        my $demon = $possible[$i];
        last if $demon->level >= $options->{level};
    }

    if ($options->{offset}) {
        $found_idx += $options->{offset} eq 'up' ? 1 : -1;
        $found_idx = 0 if $found_idx < 0;
        $found_idx = $#possible if $found_idx > $#possible;
    }

    return $possible[$found_idx];
}

sub from_type {
    my ($class, $type) = @_;

    die "unknown type $type" unless $DEMONS_BY_TYPE{$type};

    return @{ $DEMONS_BY_TYPE{$type} };
}


sub boss        { $_[0]->{boss} }
sub fusion_type { $_[0]->{fusion_type} }
sub level       { $_[0]->{level} }
sub name        { $_[0]->{name} }
sub type        { $_[0]->{type} }

sub to_string {
    my $self = shift;
    return '<' . $self->type . ' ' . $self->name . ' (' . $self->level . ')>'
}


1;

=pod

=encoding UTF-8

=head1 NAME

Games::SMTNocturne::Demons::Demon - an individual demon

=head1 VERSION

version 0.02

=head1 SYNOPSIS

  use Games::SMTNocturne::Demons 'demon';

  my $pixie = demon('Pixie');
  say $pixie->name  # 'Pixie'
  say $pixie->level # 2
  say $pixie->type  # 'Fairy'

=head1 DESCRIPTION

This class represents an individual demon. You typically create instances of
this class via the functions in the L package, and
you can then look up various data using the accessors here. This class also
includes a stringification overload to display the information about the demon
in a readable form.

=head1 METHODS

=head2 boss

True if the demon is a boss (meaning that fusing it will not be possible until
it has been defeated).

=head2 fusion_type

How this demon can be created. Can be C for demons that can be fused
normally, C for demons that must be evolved, C for demons
that require special fusions, and C for demons that require a
deathstone in order to fuse.

=head2 level

The base level of the demon. This level is what is used in the fusion process,
regardless of the experience level of the actual demon in your party.

=head2 name

The name of the demon.

=head2 type

The type of the demon (C, C, etc).

=for Pod::Coverage all_demons
  from_fusion_stats
  from_name
  from_type
  to_string

=head1 AUTHOR

Jesse Luehrs

=head1 COPYRIGHT AND LICENSE

This software is Copyright (c) 2014 by Jesse Luehrs.

This is free software, licensed under:

  The MIT (X11) License

=cut

__DATA__