indeed...

$ perl -le ' "abcd" =~ /.{2,}(?{print $&})(*FAIL)/ '
abcd
abc
ab
bcd
bc
cd
$ perl -le ' "abcdefg" =~ /.{2,}(?{print $&})(*FAIL)/ '
abcdefg
abcdef
abcde
abcd
abc
ab
bcdefg
bcdef
bcde
bcd
bc
cdefg
cdef
cde
cd
defg
def
de
efg
ef
fg
$
[download]

Alright, well I used 4.say.pl to look at values as they occur in this part of the script. I realize it takes me forever and a day to get through this, but I only get windows of opportunity to do a proper write-up, for example. This one is conditioned on everyone else being asleep. With the dirge of the carol music, it makes a fine perl moment.

    $board =~ /(?<!\w).{2,}(?!\w)(?{ push @pat, [ $-[0], $& ] })(*FAIL
+)/;

    #dd @pat;
    @pat = map expand($_), @pat;
    @pat = sort { length $b->[1] <=> length $a->[1] } @pat;
    say "patterns----------------";

    dd @pat;
[download]

Typical output is:

default is 71 d.
old is d.
highs is 10
under is d
underpat is (?^u:[^db e h i n n o])
words are de do
changed is 21
--------------------three choses: 1 38 vibe   score: 20  20
..........   0000000000
..........   0000000000
..........   0000000000
..........   0000000000
....m.....   0000100000
..avoid...   0011111000
...it.....   0001100000
...bi.....   0001100000
...ef.....   0001100000
....s.....   0000100000
/home/bob/4.scripts/distro/games/29-11-2019-16-37-01.txtmove is 2
end of move, continue?
[download]

I needed another little helper program to see how the match variables worked:

$ ./1.perlvar.pl 
10
15
This is a Hello World program
 World 
$
[download]

Source:

#!/usr/bin/perl

use 5.016;
use warnings;

my $str="This is a Hello World program";
$str=~/Hello/;


say $-[0]; # $-[0] is the offset of the start of the last successful m
+atch. 

say $+[0]; # $+[0] is the offset into the string of the end of the ent
+ire match. 

$str=~/(This)(.*?)Hello(.*?)program/;

say $str;

say $+;            # This returns the last bracket result
[download]

I understand the above line in question now and wanted to move down to where I lose my grip again, which is here:

    my $newmask = ( $old ^ $word ) =~ tr/\0/\xff/cr;
    $flip and ( $board, $heights ) = flip $board, $heights;
    substr $board, $pos, length $word, $word;

    #say "new mask is $newmask";
    substr $heights, $pos, length $highs,
      ( $highs & $newmask ) =~ tr/0-4/1-5/r | ( $highs & ~$newmask );
    $flip and ( $board, $heights ) = flip $board, $heights;
    my $tiles = join '', @tiles;
    say "word is $word";
    $tiles =~ s/$_// for split //, $word & $newmask;
[download]

I still haven't penetrated the logic for this masking. (?) It's similar to the logic used in two of the subroutines, with this as the shorter and more transparent:

sub matchrule {
  my ( $old, $highs, $word ) = @_;
  $old eq $word and return 0;
  my $newmask = ( $old ^ $word ) =~ tr/\0/\xff/cr;
  ( $newmask & $highs ) =~ tr/5// and return 0;
  my $tiles = "@tiles";
  $tiles =~ s/$_// or return 0 for ( $newmask & $word ) =~ /\w/g;
  return 1;
}
[download]

I believe the logic of this routine is that it returns zero if not a legal match and one if it is. I don't understand the relevance of character \xff to any of this, for example. What is the methodology that the use of ^ followed by & ? It would seem to me that the truth value is ^'ed to every bit in $newmask, and the bits correspond to whether the letter in that position matches the one below it. It then meets the logic of where it tests whether it is 5 high, and there it loses me.

As for where I'm going with this, the first "direction" is to get games logged in a reasonable way so that one can manage the output. Any look at the small workings of this program is accompanied by a flood of data, as it is trying out the entire lexicon. I have struggled immensely with Path::Tiny to serialize data that easily shows in STDOUT.

Latest version of working script has a naive way to measure time, but witness these failures:

#my $return2=$save_file->append_utf8(@players);
#say "return2 is $return2";

#my $return2=$save_file->append_utf8(@{players});
#say "return2 is $return2";

#my $return2=$save_file->append_utf8($players);
#say "return2 is $return2";

#my $return2=$save_file->append_utf8(`dd @players`);
#say "return2 is $return2";

#my $return2=$save_file->append_utf8({@players});
#say "return2 is $return2";
[download]

, where @player was thus defined:

@ARGV or @ARGV = qw( one two three four );    # for testing
# ...
my @players;
my $maxname = '';
for (@ARGV) {
  $maxname |= $_;
  push @players,
    {
    name  => $_,
    score => 0,
    tiles => [ sort splice @drawpile, 0, $maxtiles ]
    };
}
[download]

To see this on STDOUT, all I do is

Similarly, I seek a syntax for printing the time prettily:

# initiate time
my $start = [gettimeofday];

#print qq|$time{'yyyymmdd hh:mm:ss.mmm', $start}\n|;
#$save_file->append_utf8("$time{'yyyymmdd hh:mm:ss.mmm', $start}\n");
[download]

Typical output:

...
Duration of move 4 is 27.942196
Current player is 0
Board is 
..........
..........
..........
..........
..........
.gridders.
..........
..........
..........
..........

Heights is 
0000000000
0000000000
0000000000
0000000000
0000000000
0324441110
0000000000
0000000000
0000000000
0000000000

patterns----------------
Board is 
..........
.....g....
.....r....
.....i....
.....d....
.....d....
.....e....
.....r....
.....s....
..........

Heights is 
0000000000
0000030000
0000020000
0000040000
0000040000
0000040000
0000010000
0000010000
0000010000
0000000000

patterns----------------
Duration of move 5 is 31.07824
Current player is 1
[download]

As the grid fills up in complexity, so does the time for each move. There would need to be a ceiling time of something like 2 minutes. What I would like is a listing of the best 5 words every ten seconds or so.

I have had some successes, as with this related facility for help for wordscapes: find all english words with seven letters or less given their input as a word on ARGV. I've tested it on my phone, and it's a significant tool. I'd like to thank all those who contribute to such mild successes, and in particular tybalt89.