| 1 | package Game::Dominoes::Layout; | ||
| 2 | |||
| 3 | 3 | ▶ | use strict; |
|
Subroutine
BEGIN: called CC=1 SCAR=0.0
| |||
| 4 | 3 | ▶ | use warnings; |
|
Subroutine
BEGIN: called CC=1 SCAR=0.0
| |||
| 5 | |||
| 6 | 0 | ▶ | use Object::Proto::Sugar -types; |
|
Subroutine
BEGIN: called CC=1 SCAR=2.6
| |||
| 7 | |||
| 8 | use Game::Dominoes::Play; | ||
| 9 | |||
| 10 | our $VERSION = '0.04'; | ||
| 11 | |||
| 12 | our @ARMS = qw/L R U D/; | ||
| 13 | |||
| 14 | has line => ( | ||
| 15 | is => 'rw', | ||
| 16 | isa => ArrayRef, | ||
| 17 | default => [] | ||
| 18 | ); | ||
| 19 | |||
| 20 | has spinner_index => ( | ||
| 21 | is => 'rw', | ||
| 22 | isa => Int | ||
| 23 | ); | ||
| 24 | |||
| 25 | has u => ( | ||
| 26 | is => 'rw', | ||
| 27 | isa => ArrayRef, | ||
| 28 | default => [] | ||
| 29 | ); | ||
| 30 | |||
| 31 | has d => ( | ||
| 32 | is => 'rw', | ||
| 33 | isa => ArrayRef, | ||
| 34 | default => [] | ||
| 35 | ); | ||
| 36 | |||
| 37 | sub is_empty { | ||
| 38 | return scalar @{ $_[0]->line } ? 0 : 1; | ||
| 39 | } | ||
| 40 | |||
| 41 | sub count { | ||
| 42 | my ($self) = @_; | ||
| 43 | return scalar(@{ $self->line }) + scalar(@{ $self->u }) + scalar(@{ $self->d }); | ||
| 44 | } | ||
| 45 | |||
| 46 | sub tiles { | ||
| 47 | my ($self) = @_; | ||
| 48 | return [ map { $_->{tile} } @{ $self->line }, @{ $self->u }, @{ $self->d } ]; | ||
| 49 | } | ||
| 50 | |||
| 51 | sub pips { | ||
| 52 | my ($self) = @_; | ||
| 53 | my $total = 0; | ||
| 54 | $total += $_->pips for @{ $self->tiles }; | ||
| 55 | return $total; | ||
| 56 | } | ||
| 57 | |||
| 58 | sub spinner { | ||
| 59 | my ($self) = @_; | ||
| 60 | my $i = $self->spinner_index; | ||
| 61 | return undef unless defined $i; | ||
| 62 | return $self->line->[$i]{tile}; | ||
| 63 | } | ||
| 64 | |||
| 65 | sub sides_covered { | ||
| 66 | my ($self) = @_; | ||
| 67 | my $i = $self->spinner_index; | ||
| 68 | return 0 unless defined $i; | ||
| 69 | my $last = $#{ $self->line }; | ||
| 70 | return ($i > 0 ? 1 : 0) + ($i < $last ? 1 : 0); | ||
| 71 | } | ||
| 72 | |||
| 73 | sub arms_open { | ||
| 74 | my ($self) = @_; | ||
| 75 | return ('L') if $self->is_empty; | ||
| 76 | return ('L', 'R') unless defined $self->spinner_index && $self->sides_covered == 2; | ||
| 77 | return @ARMS; | ||
| 78 | } | ||
| 79 | |||
| 80 | sub face_of { | ||
| 81 | my ($self, $arm) = @_; | ||
| 82 | return undef unless defined $arm && grep { $_ eq $arm } $self->arms_open; | ||
| 83 | return undef if $self->is_empty; | ||
| 84 | return $self->line->[0]{left} if $arm eq 'L'; | ||
| 85 | return $self->line->[-1]{right} if $arm eq 'R'; | ||
| 86 | my $arms = $arm eq 'U' ? $self->u : $self->d; | ||
| 87 | return scalar @$arms ? $arms->[-1]{outer} : $self->spinner->high; | ||
| 88 | } | ||
| 89 | |||
| 90 | sub open_ends { | ||
| 91 | my ($self) = @_; | ||
| 92 | return () if $self->is_empty; | ||
| 93 | return map { $self->face_of($_) } $self->arms_open; | ||
| 94 | } | ||
| 95 | |||
| 96 | sub ends { | ||
| 97 | my ($self) = @_; | ||
| 98 | return () if $self->is_empty; | ||
| 99 | |||
| 100 | my $line = $self->line; | ||
| 101 | if (@$line == 1 && !@{ $self->u } && !@{ $self->d }) { | ||
| 102 | return ({ | ||
| 103 | arm => 'L', | ||
| 104 | tile => $line->[0]{tile}, | ||
| 105 | face => $line->[0]{left}, | ||
| 106 | sole => 1, | ||
| 107 | }); | ||
| 108 | } | ||
| 109 | |||
| 110 | my @ends = ( | ||
| 111 | { arm => 'L', tile => $line->[0]{tile}, face => $line->[0]{left}, sole => 0 }, | ||
| 112 | { arm => 'R', tile => $line->[-1]{tile}, face => $line->[-1]{right}, sole => 0 }, | ||
| 113 | ); | ||
| 114 | for my $arm (qw/U D/) { | ||
| 115 | my $arms = $arm eq 'U' ? $self->u : $self->d; | ||
| 116 | next unless @$arms; | ||
| 117 | push @ends, { | ||
| 118 | arm => $arm, | ||
| 119 | tile => $arms->[-1]{tile}, | ||
| 120 | face => $arms->[-1]{outer}, | ||
| 121 | sole => 0, | ||
| 122 | }; | ||
| 123 | } | ||
| 124 | return @ends; | ||
| 125 | } | ||
| 126 | |||
| 127 | sub clone { | ||
| 128 | my ($self) = @_; | ||
| 129 | return ref($self)->new( | ||
| 130 | line => [ map { { %$_ } } @{ $self->line } ], | ||
| 131 | u => [ map { { %$_ } } @{ $self->u } ], | ||
| 132 | d => [ map { { %$_ } } @{ $self->d } ], | ||
| 133 | (defined $self->spinner_index | ||
| 134 | ? (spinner_index => $self->spinner_index) : ()), | ||
| 135 | ); | ||
| 136 | } | ||
| 137 | |||
| 138 | sub can_place { | ||
| 139 | my ($self, $tile, $arm) = @_; | ||
| 140 | return 0 unless ref $tile; | ||
| 141 | return 0 unless defined $arm && grep { $_ eq $arm } $self->arms_open; | ||
| 142 | return 1 if $self->is_empty; | ||
| 143 | return $tile->has_face($self->face_of($arm)); | ||
| 144 | } | ||
| 145 | |||
| 146 | sub place { | ||
| 147 | my ($self, $tile, $arm) = @_; | ||
| 148 | die 'Game::Dominoes::Layout: place wants a tile' unless ref $tile; | ||
| 149 | $arm = 'L' unless defined $arm; | ||
| 150 | die "Game::Dominoes::Layout: arm '$arm' is not open" | ||
| 151 | unless grep { $_ eq $arm } $self->arms_open; | ||
| 152 | die 'Game::Dominoes::Layout: ' . $tile->stringify . " does not match arm $arm" | ||
| 153 | unless $self->can_place($tile, $arm); | ||
| 154 | |||
| 155 | if ($self->is_empty) { | ||
| 156 | $self->line([ { tile => $tile, left => $tile->high, right => $tile->low } ]); | ||
| 157 | $self->spinner_index(0) if $tile->is_double; | ||
| 158 | return Game::Dominoes::Play->new( | ||
| 159 | tile => $tile, | ||
| 160 | arm => 'L', | ||
| 161 | spinner => $tile->is_double, | ||
| 162 | ends => [ $self->open_ends ], | ||
| 163 | ); | ||
| 164 | } | ||
| 165 | |||
| 166 | my $matched = $self->face_of($arm); | ||
| 167 | my $showing = $tile->other($matched); | ||
| 168 | my $made_spinner = ($tile->is_double && !defined $self->spinner_index) ? 1 : 0; | ||
| 169 | |||
| 170 | if ($arm eq 'L') { | ||
| 171 | unshift @{ $self->line }, { tile => $tile, right => $matched, left => $showing }; | ||
| 172 | $self->spinner_index($self->spinner_index + 1) if defined $self->spinner_index; | ||
| 173 | $self->spinner_index(0) if $made_spinner; | ||
| 174 | } | ||
| 175 | elsif ($arm eq 'R') { | ||
| 176 | push @{ $self->line }, { tile => $tile, left => $matched, right => $showing }; | ||
| 177 | $self->spinner_index($#{ $self->line }) if $made_spinner; | ||
| 178 | } | ||
| 179 | else { | ||
| 180 | my $arms = $arm eq 'U' ? $self->u : $self->d; | ||
| 181 | push @$arms, { tile => $tile, inner => $matched, outer => $showing }; | ||
| 182 | } | ||
| 183 | |||
| 184 | return Game::Dominoes::Play->new( | ||
| 185 | tile => $tile, | ||
| 186 | arm => $arm, | ||
| 187 | matched => $matched, | ||
| 188 | showing => $showing, | ||
| 189 | spinner => $made_spinner, | ||
| 190 | ends => [ $self->open_ends ], | ||
| 191 | ); | ||
| 192 | } | ||
| 193 | |||
| 194 | 1; | ||
| 195 | |||
| 196 | __END__ | ||