Page 2 of 3

Re: How Many Pac-Man Mazes Are There?

Posted: Tue Jun 30, 2020 3:29 pm
by MatGubbins

Re: How Many Pac-Man Mazes Are There?

Posted: Tue Jun 30, 2020 5:37 pm
by Joefish
I'd heard he was doing Aladdin... :lol:

Not sure if it's a regular term, but the sprite engine that came with STOS on the Atari ST allowed you to designate a pixel on a sprite as your 'hot spot'. This meant that the sprite would be positioned relative to that point rather than its top-left corner.

With my maze shapes, because of the column order they're being filled in, I need to focus on whichever bit of the shape sticks out most on the left-hand-side. So for a left-pointing 'T' that's the tip of the 'T'. But for a right-pointing 'T', it's the top-left corner.

Re: How Many Pac-Man Mazes Are There?

Posted: Tue Jun 30, 2020 6:09 pm
by MatGubbins
Joefish wrote:
Tue Jun 30, 2020 5:37 pm
I'd heard he was doing Aladdin... :lol:

Not sure if it's a regular term, but the sprite engine that came with STOS on the Atari ST allowed you to designate a pixel on a sprite as your 'hot spot'. This meant that the sprite would be positioned relative to that point rather than its top-left corner.

With my maze shapes, because of the column order they're being filled in, I need to focus on whichever bit of the shape sticks out most on the left-hand-side. So for a left-pointing 'T' that's the tip of the 'T'. But for a right-pointing 'T', it's the top-left corner.
I recall that it was also used on the Amiga version AMOS for the sprite routine. I didn't really use the AMOS sprite routine, used the BOB routine more.


Image
Some ideas for storing a pre-made map

Version A
At 26 bytes per map, 2 bytes per row with lots of bits left over.

Code: Select all

DEFG X....X.. ........
DEFG .X.X..X. X.......
DEFG X.X.XXX. X.......
DEFG X.X....X .X......
DEFG ........ ........
DEFG X.X.XX.X .X......
DEFG X.X.X.X. X.......
DEFG ....XX.. ........
DEFG XX.X...X .X......
DEFG .X..XX.. X.......
DEFG X..X.X.X ........
DEFG .X...... X.......
DEFG X...X.X. ........
This would make it easier to have a mix 'n' match top half and bottom half and then join them together and decode into the main map buffer

Version B
13 bytes, just store the left side only, decode it into a minibuffer, mirror flip the bits over into the other half and decode into the main map buffer.
The last 2 bits on the right are not used, every odd line has an extra bit at the front. Depends how easy it is to flip the bits.

Code: Select all

DEFG X....X ..
DEFG ..X.X. ..
DEFG X.X.XX ..
DEFG .X.X.. ..
DEFG ...... ..
DEFG .X.X.X ..
DEFG X.X.X. ..
DEFG .....X ..
DEFG XX.X.. ..
DEFG ..X..X ..
DEFG X..X.X ..
DEFG ..X... ..
DEFG X...X. ..


Version C
At 20 bytes per map, reading down each green lettered column, decoding into the main map buffer as you go.

Code: Select all

DEFG XX.XXXX. ;A
DEFG .XX..... ;B
DEFG ....X... ;C
DEFG X...XX.. ;D
DEFG .X.X.... ;E
DEFG .XX..... ;F
DEFG ....XX.. ;G
DEFG X....... ;H
DEFG .X.X..X. ;I
DEFG ..XXX... ;J
DEFG XX...X.. ;K
DEFG ..XXX... ;L
DEFG .X.X..X. ;M
DEFG X....... ;N
DEFG ....XX.. ;O
DEFG .XX..... ;P
DEFG .X.X.... ;Q
DEFG X...XX.. ;R
DEFG ....X... ;S
DEFG .XX..... ;T
Bomb Munchies uses 6 bytes per map, storing only the top right part. It mirror flips the bits in X then in Y, decoding them into the main buffer.
Tryanulas PacMunchies will pic one map for the top half and then pic another map, flip it into the lower half, mirror into Y and decode it.
That's 6bytes X 36maps = 216 bytes
Decoder routine = 150 bytes

Re: How Many Pac-Man Mazes Are There?

Posted: Tue Jun 30, 2020 6:14 pm
by Joefish
What you've just done on a diagram is way the working memory of the map generation routine is arranged! Though it works rather wastefully with bytes, rather than bits. Come to think of it, there's also an extra byte for whether the white dot at the centre of each cell is filled or not. That is redundant but only once they are all filled.

But the point of generating them at random is you don't need to store any maps!

Having said that, I was thinking of converting the algorithm into C, reducing the resultant map down to a handful of bits, then running it thousands of times to see how many genuinely different mazes it can come up with... Be interesting to see if the resultant list of mazes is shorter or longer than the code to generate them! :D

Re: How Many Pac-Man Mazes Are There?

Posted: Wed Jul 01, 2020 11:27 am
by MatGubbins
Image


Here we go...
This will decode a 14 byte map, to the screen attributes. It will also flip the map at random.
14bytes per map times 16 maps = 224 bytes.
Plus you get the flipped maps for free! = 32 maps
I've hopefully kept the code below simple to read.

All that needs to be added is the code to put the correct junction graphic/data into the white spots and sort the ghost house door.

Code: Select all


Screen        Equ  16384
ScreenAttribs Equ  22528

; colour definitions
Flash                   Equ    128
Bright                  Equ     64

iBlack                  EQU      0
iBlue                   Equ      1
iRed                    Equ      2
iMagenta                Equ      3
iGreen                  Equ      4
iCyan                   Equ      5
iYellow                 Equ      6
iWhite                  Equ      7

pBlack                  EQU      0
pBlue                   Equ      8
pRed                    Equ     16
pMagenta                Equ     24
pGreen                  Equ     32
pCyan                   Equ     40
pYellow                 Equ     48
pWhite                  Equ     56




ORG 32768  


; this will decode a map to the screen attribute area.
                LD    DE,Map0001       ; at map data

                  ; get a random 0/1
                LD    A,R
                BIT   0,A
                CALL  Z,FlipTheMapRoutine

                LD    HL,ScreenAttribs
                INC   HL               ; move along place from the top left corner

 ; this draws the top bar with spaces for the junction parts
                LD    A,pCyan
                LD    B,10
topbarloop      LD    (HL),A
                INC   HL
                LD    (HL),A
                INC   HL
                INC   HL
                DJNZ  topbarloop
                INC   HL



 ; now let's get decoding!
                LD    B,7               ; loop counter for all 14 lines of map data
DecoderLoop     PUSH  BC                ; store loop counter

                LD    A,(DE)            ; get byte from map data
                PUSH  DE                ; store map place
                LD    DE,30             ; add offset
                LD    C,A

                LD    B,6               ; loop counter
COLUMNBARSLoop  PUSH  BC                ; store counter and C
                PUSH  HL                ; store screen attr address
                LD    A,pGreen          ; wall OK
                BIT   7,C               ; check the bit
                JR    NZ,CBplacecolour  ;
                LD    A,pWhite          ; not wanted value
CBplacecolour   LD    (HL),A            ; onto screen
                LD    BC,32             ; down a line
                ADD   HL,BC
                LD    (HL),A            ; onto screen
                ADD   HL,DE
                LD    (HL),A            ; onto screen
                LD    BC,32             ; up a line
                SBC   HL,BC
                LD    (HL),A            ; onto screen
                LD    A,E
                SUB   6
                LD    E,A
                POP   HL                ; recall the screen attr address
                INC   HL                ; move along
                INC   HL
                INC   HL
                POP   BC                ; recall the loop counter and C
                RL    C                 ; RotL C
                DJNZ  COLUMNBARSLoop

ROWBARS         LD    BC,47             ; offset to move to the correct place
                ADD   HL,BC             ; saves a PUSH/POP and then adding

; now do a row of lines
                POP   DE
                INC   DE                ; next map data
                LD    A,(DE)            ; read byte
                PUSH  DE                ; store map place

                LD    DE,26             ; add offset
                LD    C,A
                LD    B,5
ROWBARSloop     PUSH  BC                ; store counter and C
                PUSH  HL
                LD    A,pCyan           ; wall OK
                BIT   7,C               ; check the bit
                JR    NZ,RBplacecolour  ;
                LD    A,pWhite          ; not wanted value
RBplacecolour   LD    (HL),A            ; onto screen
                INC   HL
                LD    (HL),A
                ADD   HL,DE
                LD    (HL),A
                INC   HL
                LD    (HL),A
                LD    A,E
                SUB   6
                LD    E,A
                POP   HL                ; recall the screen attr address
                INC   HL                ; move along
                INC   HL
                INC   HL
                POP   BC                ; recall the loop counter and C
                RL    C                 ; RotL C
                DJNZ  ROWBARSloop
                XOR   A
                LD    BC,16             ; offset to move to the next place
                ADD   HL,BC
                POP   DE
                INC   DE                ; next map data
                POP   BC                ; recall loop counter
                DJNZ  DecoderLoop
                RET

FlipTheMapRoutine    ; this will flip the map data for good (until it is flipped again)
                     ; or you can copy the map data to a buffer and flip that instead
                PUSH  DE                ; store the map place
                PUSH  DE                ; put DE into HL
                POP   HL
                LD    BC,12
                ADD   HL,BC
                LD    B,6               ; loop counter
flipthemaploop  LD    C,(HL)
                LD    A,(DE)
                LD    (HL),A
                LD    A,C
                LD    (DE),A
                INC   DE
                DEC   HL
                DJNZ  flipthemaploop
                POP   DE                ; recall the map place
                RET

; Maps 14 bytes each
Map0001      ;  Wall data left hand side of the map
  ; first line is the | coloumn walls
  ; second line is the - row walls
DEFB %10000100   ; | ; 6bits from left
DEFB %01010000   ; - ; 5bits from left
DEFB %10101100   ; | ; 6bits from left
DEFB %10100000   ; - ; 5bits from left
DEFB %00000000   ; | ; 6bits from left
DEFB %10101000   ; - ; 5bits from left
DEFB %10101000   ; | ; 6bits from left
DEFB %00001000   ; - ; 5bits from left
DEFB %11010000   ; | ; 6bits from left
DEFB %01001000   ; - ; 5bits from left
DEFB %10010100   ; | ; 6bits from left
DEFB %01000000   ; - ; 5bits from left
DEFB %10001000   ; | ; 6bits from left
DEFB %11111100   ; - ; 5bits from left  ; this should be the same for all maps - great for a data marker



; end
[code]

Re: How Many Pac-Man Mazes Are There?

Posted: Wed Jul 01, 2020 12:14 pm
by Joefish
Well, technically it can be done in 7 bytes. The whole area around the Ghost House is common to all variants, and there's no need to store the outer walls. You could even spare 3 bits to say which row the tunnel was on, or simply deduce it from a dead-end being formed on the left-hand side.

Re: How Many Pac-Man Mazes Are There?

Posted: Wed Jul 01, 2020 10:00 pm
by MatGubbins
Image

Ah! If I read down each letter column, each map will be 11 bytes.
The decode routine and a map flipper in at 150 bytes - that's with my average programming skills.

16 maps 11 bytes per = 176 bytes + 150 byte routine = 326 bytes with another 16 flipped maps free
32 maps 11 bytes per = 352 bytes + 150 byte routine = 502 bytes with another 32 flipped maps free

Code: Select all

Org 32768
                LD    IX,Map0002   ; put map address into IX and save a headache
                CALL  UnpackMap

; all unpacked, now flip the map at a toss of a bit
                LD    A,R
                BIT   0,A
                RET   Z

FlipMap         LD    DE,ScreenAttribs+32
                LD    HL,ScreenAttribs+(20*32)
                LD    B,11
mainfliploop    PUSH  BC
                LD    B,32
fliponeline     LD    C,(HL)
                LD    A,(DE)
                LD    (HL),A
                LD    A,C
                LD    (DE),A
                INC   DE
                INC   HL
                DJNZ  fliponeline
                LD    BC,65536-64
                ADD   HL,BC
                POP   BC
                DJNZ  mainfliploop
                RET


UnpackMap       LD    HL,ScreenAttribs+32   ; unpack data here
                LD    DE,30                 ; offset to jump to the other side of the screen
                LD    B,5                   ; repeat counter
mainloop        PUSH  BC                    ; store repeat counter
                PUSH  HL                    ; store place

                CALL  ColARoutine           ;

                POP   HL                    ; recall place
                LD    BC,65536-31           ; move up one line and one place right
                ADD   HL,BC

                INC   IX                    ; next place for the map data
                LD    C,(IX+0)              ; read the byte

                DEC   DE                    ; decrease the jump value to the other side
                DEC   DE
                DEC   DE
                DEC   DE

                PUSH  HL                    ; store place
                LD    B,8                   ; counter
ColBloop        PUSH  BC                    ; store count and C

                LD    A,pCyan               ; wall OK
                BIT   0,C                   ; check the bit
                JR    NZ,ColBplacecolour    ;
                LD    A,pBlue               ; not wanted value
ColBplacecolour LD    (HL),A                ; onto screen
                PUSH  HL                    ; store for a moment
                INC   HL                    ; move along
                LD    (HL),A                ; onto screen
                ADD   HL,DE                 ; to the opposite side
                LD    (HL),A                ; onto the screen
                INC   HL                    ; move along
                LD    (HL),A                ; onto the screen
                POP   HL                    ; recall place
                LD    BC,96                 ; down 3 lines
                ADD   HL,BC
                POP   BC                    ; recall count and C
                RR    C                     ; RoL C
                DJNZ  ColBloop

                POP   HL                    ; recall place to top of screen
                LD    BC,34                 ; move one line down and two places
                ADD   HL,BC
                DEC   DE                    ; decrease the jump value
                DEC   DE
                INC   IX                    ; next place in the map data
                POP   BC                    ; recall the counter
                DJNZ  mainloop              ; loop until done



; this is here so that the middle column is completed
ColARoutine     LD    C,(IX+0)          ; read from the map data
                LD    B,7               ; counter
ColAloop        PUSH  BC                ; store count and C
                LD    A,pGreen          ; wall OK
                BIT   0,C               ; check the bit
                JR    NZ,ColAplacecolour  ;
                LD    A,pBlue           ; not wanted value
ColAplacecolour LD    (HL),A            ; onto screen
                LD    BC,32             ; down a line
                ADD   HL,BC
                LD    (HL),A            ; onto screen
                PUSH  HL                ; store for a moment
                ADD   HL,DE             ; jump to the other side of the screen
                LD    (HL),A            ; onto the screen
                SBC   HL,BC             ; up one line
                LD    (HL),A            ; onto the screen
                POP   HL                ; recall the place
                ADD   HL,BC             ; down two lines
                ADD   HL,BC
                POP   BC                ; recall count and C
                RR    C                 ; RoL C
                DJNZ  ColAloop
                RET                     ; exit to basic

Map0002 ; at 11 bytes
DEFB %01111011 ; A   ; left wall, bit 0 right is the top left corner of the map data
DEFB %10001101 ; B   ; next column in, bit 0 and bit 7 are the outer walls
DEFB %00010000 ; C
DEFB %11100011 ; D
DEFB %00001010 ; E
DEFB %10001101 ; F
DEFB %00110000 ; G
DEFB %10000011 ; H
DEFB %01001010 ; I
DEFB %10111001 ; J
DEFB %00100011 ; K   ; middle column

I can see an advantage to a random map generator, but if it consumes more memory than a good bagful of pre-made maps then I dunno, but it'll certainly keep Pavero mapping busy!
This has been great fun and kept the grey matter ticking over.

Re: How Many Pac-Man Mazes Are There?

Posted: Sun Jul 05, 2020 12:05 am
by Joefish
It's actually really hard to just sit down with a 32x24 grid of squares and sketch out a half-decent maze, especially with only 1-wide walls but 2-wide passageways. Unless you apply at least some of the rules I've devised for this process, anyway. You keep painting yourself into a crap corner where nothing quite lines up. The thought of doing 20 or so that don't all look the same is quite challenging!

I have just refined the shape-fitting algorithm to better cope with a few patterns. Before, it would only ever fit a right-facing T just over the Ghost House, but now I can see it using it in more places. I've also added a couple of rules, that if there's a straight run between the two tunnels with no vertical walls in the way, or if there's fewer than 3 vertical walls in one half of the maze (not counting the permiter nor the row the Ghost House is on), then it re-runs the whole algorithm, up to four times, to try and ensure a maze with a decent amount of variety.

Next step is to convert the walls into specific UDGs for all the bends, ends and branches; place the power-pills; then fill the rest of the maze with dots.

Re: How Many Pac-Man Mazes Are There?

Posted: Sun Jul 05, 2020 2:05 am
by MatGubbins
Map designing, that is where I would've cracked out some Lego bricks and randomly placing them onto a huge grey baseboard, but you designed a map maker and made a bloody good job of it too! Glad that you're making progress on finding ways of getting the maps to behave better.

Spent an evening screen grabbing a whole lot of maps made by your map maker, numbering them up with 1s and 0s, and typing in the data and this is the result so far...

https://www.sendspace.com/file/p3i9gj

It contains 25 random maps made by your program, converted into 11 bytes per map, decodes, random flip a bit to mirror it, sort the corners and ends out, bung in the ghost door, do a simple print using the rom routine.
700 bytes with udgs.
Just need to byte align the map to a 256 boundary and add the dots.

Reminded me of the R'n'R Gnasher pacman clone re-released by Mastertronic.

Code: Select all

Screen        Equ  16384
ScreenAttribs Equ  22528


Org 32768

Start
                LD    A,2 ; always print to the top area
                CALL  05633
                LD    HL,UDGs
                LD    (23675),HL

                LD    IX,Map0001   ; put map address into IX and save a headache
               
pickagain       LD    A,R
                CP    25
                JR    NC,pickagain
                LD    B,A  ;1
                ADD   A    ;2
                ADD   A    ;4
                ADD   B    ;5
                ADD   A    ;10
                ADD   B    ;11
                LD    C,A
                LD    B,0
                ADD   IX,BC


mapaa

                CALL  UnpackMap
                ; all unpacked,
                CALL  FlipMap      ; now flip the map at a toss of a bit
                CALL  PutCornersIn ; and place the ghost door


PrintTheMapToTheScreen ;
                ; Print AT 0,0
                LD    A,22  ;Print AT control
                RST   16
                XOR   A     ; 0
                RST   16
                RST   16
                 ;
                LD    HL,Map           ; place of the unpacked map data
                LD    BC,768-64        ; amount of bytes to process
printloop       LD    A,(HL)           ; read byte
                ADD   144              ; add the UDG offset
                RST   16               ; print the UDG to the scree
                INC   HL               ; shuffle along the map data
                DEC   BC               ; decrease the counter
                LD    A,B              ;
                OR    C                ; does B and C match zero?
                JR    NZ,printloop     ; JR if no
                RET


;---------------------------------------------------------------
FlipMap         LD    A,R
                BIT   0,A
                RET   Z
                LD    DE,Map+32
                LD    HL,Map+(20*32)
                LD    B,11
mainfliploop    PUSH  BC
                LD    B,32
fliponeline     LD    C,(HL)
                LD    A,(DE)
                LD    (HL),A
                LD    A,C
                LD    (DE),A
                INC   DE
                INC   HL
                DJNZ  fliponeline
                LD    BC,65536-64
                ADD   HL,BC
                POP   BC
                DJNZ  mainfliploop
                RET

;---------------------------------------------------------------
PutCornersIn    LD    IX,Map
                LD    B,8            ; Counter for rows
Cornerloop      PUSH  BC             ; store counter
                LD    B,11           ; Counter for columns
Cornerbitsloop  XOR   A              ; set A to zero
                LD    D,A            ; D to zero ; part of the jump offset, saves a byte
                LD    C,A            ; C to zero for totals
CheckUP         CP    (IX-32)        ; is the square above empty
                JR    Z,Exitup       ; yes, do JR
                SET   0,C            ; no, add 1
Exitup
CheckRIGHT      CP    (IX+1)         ; is square to the right empty
                JR    Z,Exitright    ; yes, do JR
                SET   1,C            ; no, add 2
Exitright
CheckDOWN       CP    (IX+32)        ; is square below empty
                JR    Z,Exitdown     ; yes, do JR
                SET   2,C            ; no, add 4
Exitdown
CheckLEFT       CP    (IX-1)         ; is squre to the left empty
                JR    Z,Exitleft     ; yes, do JR
                SET   3,C            ; no, add 8
Exitleft
                LD    (IX+0),C       ; put C into the empty square
                LD    E,3            ; offset jump
                ADD   IX,DE          ; move along
                DJNZ  Cornerbitsloop ; loop
                LD    E,63           ; offset jump to move down 2 lines
                ADD   IX,DE          ; move
                POP   BC             ; recall counter
                DJNZ  Cornerloop     ; loop

PlaceTheGhostDoor
                LD    HL,GhostDoorData
                LD    DE,Map+(9*32)+13
                LD    BC,5
                LDIR
                RET
GhostDoorData   DEFB 8,0,0,0,2


;---------------------------------------------------------------
UnpackMap       LD    HL,Map+32             ; unpack data here
                LD    DE,30                 ; offset to jump to the other side of the screen
                LD    B,5                   ; repeat counter
mainloop        PUSH  BC                    ; store repeat counter
                CALL  ColARoutine           ;
                LD    BC,64833 ;65536-31-768+96           ; move up one line and one place right
                ADD   HL,BC
                DEC   DE                    ; decrease the jump value to the other side
                DEC   DE
                DEC   DE
                DEC   DE

                INC   IX                    ; next place for the map data
                LD    C,(IX+0)              ; read the byte

                LD    B,8                   ; counter
ColBloop        PUSH  BC                    ; store count and C

                LD    A,10                  ; wall OK
                BIT   0,C                   ; check the bit
                JR    NZ,ColBplacecolour    ;
                XOR   A                     ; not wanted value
ColBplacecolour LD    (HL),A                ; onto screen
                PUSH  HL                    ; store for a moment
                INC   HL                    ; move along
                LD    (HL),A                ; onto screen
                ADD   HL,DE                 ; to the opposite side
                LD    (HL),A                ; onto the screen
                INC   HL                    ; move along
                LD    (HL),A                ; onto the screen
                POP   HL                    ; recall place
                LD    BC,96                 ; down 3 lines
                ADD   HL,BC
                POP   BC                    ; recall count and C
                RR    C                     ; RoR C
                DJNZ  ColBloop

                LD    BC,34-768             ; move one line down and two places
                ADD   HL,BC
                DEC   DE                    ; decrease the jump value
                DEC   DE
                INC   IX                    ; next place in the map data
                POP   BC                    ; recall the counter
                DJNZ  mainloop              ; loop until done



; this is here so that the middle column is completed
ColARoutine     LD    C,(IX+0)          ; read from the map data
                LD    B,7               ; counter
ColAloop        PUSH  BC                ; store count and C
                LD    A,5               ; wall OK
                BIT   0,C               ; check the bit
                JR    NZ,ColAplacecolour  ;
                XOR   A                 ; not wanted value ; wipes old data too!
ColAplacecolour LD    (HL),A            ; onto screen
                LD    BC,32             ; down a line
                ADD   HL,BC
                LD    (HL),A            ; onto screen
                PUSH  HL                ; store for a moment
                ADD   HL,DE             ; jump to the other side of the screen
                LD    (HL),A            ; onto the screen
                SBC   HL,BC             ; up one line
                LD    (HL),A            ; onto the screen
                POP   HL                ; recall the place
                ADD   HL,BC             ; down two lines
                ADD   HL,BC
                POP   BC                ; recall count and C
                RR    C                 ; RoR C
                DJNZ  ColAloop
                RET                     ;

DEFW 255,255
;---------------------------------------------------------------

Map0001
DEFB %01111011; A
DEFB %10101101; B
DEFB %00000000; C
DEFB %11010011; D
DEFB %00101000; E
DEFB %10110111; F
DEFB %00000100; G
DEFB %11000101; H
DEFB %00001000; I
DEFB %10111011; J
DEFB %01000010; K

Map0002
DEFB %01111011 ; A
DEFB %10101101 ; B
DEFB %00000000 ; C
DEFB %11010011 ; D
DEFB %00011010 ; E
DEFB %11000001 ; F
DEFB %00010101 ; G
DEFB %10000101 ; H
DEFB %00001000 ; I
DEFB %11111011 ; J
DEFB %00000010 ; K

Map0003
DEFB %01111110 ; A
DEFB %10001011 ; B
DEFB %00100000 ; C
DEFB %11010101 ; D
DEFB %00010100 ; E
DEFB %10010011 ; F
DEFB %00100100 ; G
DEFB %11000111 ; H
DEFB %00001000 ; I
DEFB %10111001 ; J
DEFB %00100011 ; K

Map0004
DEFB %01101111 ; A
DEFB %10110001 ; B
DEFB %00000100 ; C
DEFB %11001011 ; D
DEFB %00010000 ; E
DEFB %10011111 ; F
DEFB %00100000 ; G
DEFB %10000101 ; H
DEFB %00101000 ; I
DEFB %10111011 ; J
DEFB %01000010 ; K

Map0005
DEFB %01101111 ; A
DEFB %10110101 ; B
DEFB %00000000 ; C
DEFB %11001011 ; D
DEFB %00101010 ; E
DEFB %10001101 ; F
DEFB %01010000 ; G
DEFB %10000011 ; H
DEFB %00001010 ; I
DEFB %11111001 ; J
DEFB %00000011 ; K

Map0006
DEFB %01111110 ; A
DEFB %10001011 ; B
DEFB %00100000 ; C
DEFB %11010101 ; D
DEFB %00011010 ; E
DEFB %10010011 ; F
DEFB %00100100 ; G
DEFB %11000001 ; H
DEFB %00001010 ; I
DEFB %10111001 ; J
DEFB %00100011 ; K

Map0007
DEFB %01111110 ; A
DEFB %10100011 ; B
DEFB %00000100 ; C
DEFB %11011001 ; D
DEFB %00010010 ; E
DEFB %10000001 ; F
DEFB %00110101 ; G
DEFB %10000101 ; H
DEFB %00101000 ; I
DEFB %10111011 ; J
DEFB %01000010 ; K

Map0008
DEFB %01111111 ; A
DEFB %10001001 ; B
DEFB %00100010 ; C
DEFB %10110011 ; D
DEFB %00001000 ; E
DEFB %11100111 ; F
DEFB %00001000 ; G
DEFB %11000101 ; H
DEFB %00001000 ; I
DEFB %10111011 ; J
DEFB %01000010 ; K

Map0009
DEFB %01111111 ; A
DEFB %10001001 ; B
DEFB %00010010 ; C
DEFB %11010001 ; D
DEFB %00000010 ; E
DEFB %11111001 ; F
DEFB %00000001 ; G
DEFB %10000101 ; H
DEFB %01001000 ; I
DEFB %10111011 ; J
DEFB %00100010 ; K

Map0010
DEFB %01110111 ; A
DEFB %10011001 ; B
DEFB %00100010 ; C
DEFB %10100011 ; D
DEFB %00001000 ; E
DEFB %11010111 ; F
DEFB %00100100 ; G
DEFB %11000001 ; H
DEFB %00001010 ; I
DEFB %10111001 ; J
DEFB %01000011 ; K

Map0011
DEFB %01111110 ; A
DEFB %10100011 ; B
DEFB %00000100 ; C
DEFB %11010001 ; D
DEFB %00000010 ; E
DEFB %10101001 ; F
DEFB %00110101 ; G
DEFB %10000101 ; H
DEFB %00101000 ; I
DEFB %10111011 ; J
DEFB %01000010 ; K

Map0012
DEFB %01111111 ; A
DEFB %10100101 ; B
DEFB %00001000 ; C
DEFB %11001011 ; D
DEFB %00100010 ; E
DEFB %10110011 ; F
DEFB %00001000 ; G
DEFB %11000101 ; H
DEFB %00001010 ; I
DEFB %10111001 ; J
DEFB %01000011 ; K

Map0013
DEFB %01111111 ; A
DEFB %10001001 ; B
DEFB %00100010 ; C
DEFB %11010011 ; D
DEFB %00010100 ; E
DEFB %10100101 ; F
DEFB %00001001 ; G
DEFB %11000101 ; H
DEFB %00001000 ; I
DEFB %10111011 ; J
DEFB %01000010 ; K

Map0014
DEFB %01111011 ; A
DEFB %10001101 ; B
DEFB %00100000 ; C
DEFB %10010011 ; D
DEFB %00010010 ; E
DEFB %11001101 ; F
DEFB %00101000 ; G
DEFB %11000011 ; H
DEFB %00001010 ; I
DEFB %10111001 ; J
DEFB %01000011 ; K

Map0015
DEFB %01101111 ; A
DEFB %10110001 ; B
DEFB %00000010 ; C
DEFB %11001011 ; D
DEFB %00010100 ; E
DEFB %11100111 ; F
DEFB %00001000 ; G
DEFB %10000001 ; H
DEFB %00001010 ; I
DEFB %11111001 ; J
DEFB %00000011 ; K

Map0016
DEFB %01111111 ; A
DEFB %10001001 ; B
DEFB %00100000 ; C
DEFB %10110111 ; D
DEFB %00000000 ; E
DEFB %11011001 ; F
DEFB %00100000 ; G
DEFB %10000111 ; H
DEFB %00001000 ; I
DEFB %11111001 ; J
DEFB %00000011 ; K

Map0017
DEFB %01111111 ; A
DEFB %10010001 ; B
DEFB %00000010 ; C
DEFB %11101011 ; D
DEFB %00010100 ; E
DEFB %10000111 ; F
DEFB %00101000 ; G
DEFB %11000001 ; H
DEFB %00001010 ; I
DEFB %10111001 ; J
DEFB %00100011 ; K

Map0018
DEFB %01111111 ; A
DEFB %10100101 ; B
DEFB %00001000 ; C
DEFB %11001011 ; D
DEFB %00000010 ; E
DEFB %10110011 ; F
DEFB %01001000 ; G
DEFB %10000101 ; H
DEFB %00001000 ; I
DEFB %11111011 ; J
DEFB %00000010 ; K

Map0019
DEFB %01111011 ; A
DEFB %10101101 ; B
DEFB %00000000 ; C
DEFB %11010011 ; D
DEFB %00100010 ; E
DEFB %10101101 ; F
DEFB %01001000 ; G
DEFB %10000011 ; H
DEFB %00001010 ; I
DEFB %11111001 ; J
DEFB %00000011 ; K

Map0020
DEFB %01101111 ; A
DEFB %10110001 ; B
DEFB %00000100 ; C
DEFB %11001011 ; D
DEFB %00000010 ; E
DEFB %10110011 ; F
DEFB %00101000 ; G
DEFB %10000101 ; H
DEFB %01001010 ; I
DEFB %10111001 ; J
DEFB %00100011 ; K

Map0021
DEFB %01110111 ; A
DEFB %10011001 ; B
DEFB %00100010 ; C
DEFB %10100011 ; D
DEFB %00000100 ; E
DEFB %11110101 ; F
DEFB %00001000 ; G
DEFB %11000011 ; H
DEFB %00001010 ; I
DEFB %10111001 ; J
DEFB %00100011 ; K

Map0022
DEFB %01110111 ; A
DEFB %10011001 ; B
DEFB %00100010 ; C
DEFB %10100011 ; D
DEFB %00000100 ; E
DEFB %11110001 ; F
DEFB %00000101 ; G
DEFB %11000101 ; H
DEFB %00001000 ; I
DEFB %10111011 ; J
DEFB %01000010 ; K

Map0023
DEFB %01111111 ; A
DEFB %10100101 ; B
DEFB %00000000 ; C
DEFB %11011011 ; D
DEFB %00000000 ; E
DEFB %10111111 ; F
DEFB %01000000 ; G
DEFB %10000101 ; H
DEFB %00001000 ; I
DEFB %11111011 ; J
DEFB %00000010 ; K

Map0024
DEFB %00111111 ; A
DEFB %11010001 ; B
DEFB %00000100 ; C
DEFB %10101011 ; D
DEFB %00110010 ; E
DEFB %10001001 ; F
DEFB %00110000 ; G
DEFB %10000111 ; H
DEFB %00101000 ; I
DEFB %10111001 ; J
DEFB %01000011 ; K

Map0025 ; at 11 bytes
DEFB %01111011 ; A   ; left wall, bit 0 right is the top left corner of the map data
DEFB %10001101 ; B   ; next column in, bit 0 and bit 7 are the outer walls
DEFB %00010000 ; C
DEFB %11100011 ; D
DEFB %00001010 ; E
DEFB %10001101 ; F
DEFB %00110000 ; G
DEFB %10000011 ; H
DEFB %01001010 ; I
DEFB %10111001 ; J
DEFB %00100011 ; K   ; middle column

DEFW 255





UDGs
DEFB 000,000,000,000,000,000,000,000
DEFB 195,195,195,195,195,231,126,060
DEFB 063,127,224,192,192,224,127,063
DEFB 195,195,192,192,192,224,127,063
DEFB 060,126,231,195,195,195,195,195
DEFB 195,195,195,195,195,195,195,195
DEFB 063,127,224,192,192,192,195,195
DEFB 195,195,192,192,192,192,195,195
DEFB 252,254,007,003,003,007,254,252
DEFB 195,195,003,003,003,007,254,252
DEFB 255,255,000,000,000,000,255,255
DEFB 195,195,000,000,000,000,255,255
DEFB 252,254,007,003,003,003,195,195
DEFB 195,195,003,003,003,003,195,195
DEFB 255,255,000,000,000,000,195,195
DEFB 195,195,000,000,000,000,195,195
DEFB 060,126,231,195,195,231,126,060


DEFB 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
DEFB 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
Map

DEFB 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0

Re: How Many Pac-Man Mazes Are There?

Posted: Mon Jul 06, 2020 12:01 am
by MatGubbins
Dotty thoughts...
Image