gist: 140261


  
    
      Perl
    
    
      
      
        embed
        
      
      
      
      raw
    
  
  
  
    
      
        
          
            
            1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

          
          
            
              #!/usr/bin/perl 
use strict;
use warnings;
 
use Moose::Autobox;
 
sub Moose::Autobox::SCALAR::split {
  my $self  = shift;
  my $delim = shift;
  [ split( $delim, $self ) ];
}
 
sub Moose::Autobox::SCALAR::sprintf {
  my $self = shift;
  sprintf( $self, @_ );
}
 
sub Moose::Autobox::ARRAY::stringify {
  my $self = shift;
  my $delim = shift || " ";
  join $delim, map { $_->stringify } @{$self};
}
 
use MooseX::Declare;
 
class Property {
  use MooseX::Has::Sugar;
  use MooseX::Types::Moose (':all');
  use Moose::Autobox;
  use Carp;
 
  has name            => ( isa => Str, rw, required, );
  has income          => ( isa => Num, rw, required, );
  has cost            => ( isa => Num, rw, required, );
  has owned           => ( isa => Num, rw, required, );
  has effectiveness   => ( isa => Num, rw, lazy_build, );
  has units_buildable => ( isa => Num, rw, default => 0, );
  has cash_needed     => ( isa => Num, rw, default => 0, );
 
  method income_expected {
    $self->income * $self->owned;
  }
 
  method parse( ClassName $class: $str ) {
      my $tokens = $str->split(qr/ /);
      return $class->new(
        name   => $tokens->at(0),
        income => $tokens->at(1),
        cost   => $tokens->at(2),
        owned  => $tokens->at(3),
      );
  };
 
  method build( Num $bank , Num $play ) {
      $self->units_buildable( int( ( $bank + $play ) / $self->cost ) );
      if ( $self->units_buildable < 1 ) {
        $self->units_buildable(0);
      }
      elsif ( $self->units_buildable < 5 ) {
        $self->units_buildable(1);
      }
      elsif ( $self->units_buildable < 10 ) {
        $self->units_buildable(5);
      }
      elsif ( $self->units_buildable > 10 ) {
        $self->units_buildable(10);
      }
      $self->cash_needed( ( $self->units_buildable * $self->cost ) - $play );
      if ( $self->cash_needed < 0 ) {
        $self->cash_needed(0);
      }
      return $self;
  };
 
  method _build_effectiveness {
    ( $self->income / $self->cost ) * 100;
  };
 
  method compare( Property $other, Str $field ) {
      my $mymethod    = $self->can($field);
      my $othermethod = $other->can($field);
      unless ( $mymethod && $othermethod ) {
        croak("No Field $field");
      }
      my $x = $self->$mymethod();
      my $y = $other->$othermethod();
      return $x <=> $y;
  };
 
  method header( ClassName $class: ) {
      my $h = '            Property: [ Cost          , Income    , ROI/Turn , Build, Cashout    , Owned , Net       ]';
 
      #      my $fm = '%20s: [ %13s , %11s , roi/t %2.3f%%, b %2.0f, cn %7.0f ]';
      #      $d = $fm->sprintf( 'Property', 'Cost', 'Income', 'ROI/Turn', 'Buildable','BuildCost' );
      $h .= ( "\n" . "-" x length($h) );
      $h;
  };
 
  method stringify {
      my $fm = '%20s: [ $%12.0f , $%8.0f , %8.5f%%, b  %2.0f, cn %7.0f , %3.0f u , %10.0f]';
      $fm->sprintf( $self->name, $self->cost, $self->income, $self->effectiveness, $self->units_buildable, $self->cash_needed,
        $self->owned, $self->income_expected );
  };
}
 
my $d = <<'EOF';
GarageWarehouse 100 21000 33
AutoBodyShop 400 66000 23
Nightclub 2000 310000 21
BallerMansion 7000 840000 14
MalibuEstate 65000 9000000 20
Casino 150000 168800000 4
PrivateIsland 200000 50000000 10
TopsyTurvy 14000 999999999999 1
EOF
 
my $data = $d->split(qr/\n/)->map( sub {     Property->parse($_);   } );
 
my $total = 0;
 
$data->map( sub {  $total += $_->income_expected;  } );
 
 # Bank , Working Balance
$data->map( sub {  $_->build( 4_244, 3_982_961 ); } );
 
my $buildable = $data->grep( sub { $_->units_buildable > 0 } );
 
Property->header->say();
$data->sort( sub { $_[0]->compare( $_[1], 'effectiveness' ) } )->stringify("\n")->say;
 
$total->say;