A hash of hashes will do the trick nicely and is infinitely extensible. Here I populate a game board that extends from x = -5 to x = +5 with the same range for y then pluck a value from one square (I store the co-ordinates there for simplicity). Probably the simplest, if not the most memory efficient way to do it.

Hope this helps.

Cheers

tachyon

# declare $grid to hold ref to anon hashes (thanks tye)
my $grid; 
for my $x(-5..5) {
    for my $y(-5..5) {
        $grid->{$x}{$y} = "co-ords x:$x, y:$y";
    }
}

print "Here is -2,3 : ", $grid->{-2}{3};
print "\nHere is 0,0 : ", $grid->{0}{0};
[download]

If you want to store a range of attributes for each square a super grid made of a hash of hashes will work.

Note this has been modified for efficiency based on tye's post:

my %grid1;

for my $x(-5..5) {
    for my $y(-5..5) {
        $grid1{$x,$y} = { name  => "$x,$y", 
                          power => int rand(10),
                          allow => "all" };
    }
}

print "\nHere is name 0,0 : ", $grid1{0,0}{'name'};
print "\nHere is power -2,3 : ", $grid1{-2,3}{'power'};
print "\nHere is allow 5,4 : ", $grid1{0,0}{'allow'};
[download]

A hash of hash of arrays is more space efficient but you must index the contents of each square numerically

my %grid2;

for my $x(-5..5) {
    for my $y(-5..5) {
        $grid2{$x,$y} = ["$x,$y",int rand(10),"all"];
    }
}

print "\nHere is name 0,0 : ", $grid2{0,0}[0];
print "\nHere is power -2,3 : ", $grid2{-2,3}[1];
print "\nHere is allow 5,4 : ", $grid2{0,0}[2];
[download]

I'd actually use a single hash here to save space:

my %grid;
keys %grid= 11*11;    # preallocate our hash size
for my $x(-5..5) {
    for my $y(-5..5) {
        $grid{$x,$y} = "co-ords x:$x, y:$y";
    }
}
[download]

Also note that you either need to remove the "->"s from your code or change "my %grid" to "my $grid".
        - tye (but my friends call me "Tye")

Good point, in my examples $grid, $grid1 and $grid2 store refs to the data structure not %grid....Damn sloppy. I will take the liberty of fixing the code if that's OK

I love the economy of $grid{$x,$y} to give keys like "0.-1"- very neat. Q: How much space does it save over and above the 11 unnecessary keys (121 hash keys - all in one hash in your case and in 132 in 12 hashes in mine). Or to put it another way how big is the memory penalty in setting up each extra anon hash?

Also can you explain the purpose of the preallocation? No doubt it is an efficiency measure but does it commit to a set board size? If not why do we need it as we are about to allocate values to all the keys.

cheers

tachyon

If however, you don't want to create arbitrary limits, and you plan on designing a non-static gameboard, which expands to theoretical infinities in all directions as the game progresses and objects are moved, then you should use an object to encapsulate the functionality of your gameboard, and as part of that object's state, store an offset or any other data required to translate between the coordinates you use in gameplay, and the indexes necessary to reference your data structures.

If you plan on having a very large gameboard, and you are concerned with performance and efficiency, consider using a bit vector or even PDL to internally represent your gameboard. Native lists and hashes are not the way to go. Then again, if you really were concerned about those things, you wouldn't choose Perl to write your game in :)

   MeowChow                                   
               s aamecha.s a..a\u$&owag.print