unbibium / baba-is-c64 Goto Github PK

The line numbers are too crowded to effectively add new features. Find a line renumbering utility that will also work on the GOTO/GOSUB statements, and renumber the program.

It seems that when I experiment too long, the BASIC program runs out of memory. I didn't think this was possible considering all the arrays are DIM'd in advance. I thought garbage collection would take care of everything.

this seems more pronounced in the large-pf branch, where the playfield is twice the size. It happened when I was editing a level, and then tried to explore it.

the next time it happens, I need to examine memory in the monitor to see what's taking up all the space.

haven't seen it in the compiled version yet; maybe it won't happen there.

The primary requirement of this level is that the user must be taught that a horizontal rule and a vertical rule may share an IS tile.

Accomplished like this:

• One starting Baba tile
• One starting Flag tile, within easy reach of Baba
• Accessible BABA IS YOU rule
• The only other accessible tiles are scattered FLAG and WIN tiles.
• Player wins by creating a FLAG IS WIN rule that crosses the BABA IS YOU rule.

The 2017 demo contains a level that fits this criteria, with the following embellishments:

• Baba, the flag, and the accessible tiles are all surrounded by a wall.
• There are also background-looking grass tiles inside the wall.
• There is an immutable GRASS IS STOP rule outside the wall.
• There is no WALL IS STOP rule.
• It is difficult, if not impossible, to build the win rule by trying to maneuver the word tiles around the grass.
• It is easy to build the win rule by pushing the word tiles outside of the wall, and maneuvering them away from the grass.

Level where Baba and the flag are trapped in two different rooms, and Baba must disrupt "WALL IS STOP" to reach it.

In this level, Baba is in a nook with two rocks and the "ROCK IS PUSH" rule, and can only get to the other room by pushing something into the goop, which is SINK. The flag is behind two goop tiles, so the remaining rock is inadequate to reach it. The player must change the "FLAG IS WIN" condition to "ROCK IS WIN" to beat the level.

this is where I start to wonder if there are alternative expert-mode solutions that I don't know and will have to test for.

also, it looks like TEXT IS FLOAT is in effect, because you can't push text to get across. so I may have to implement FLOAT or change how text works.

This project is going to be hard to share with other people because the build cycle is a bit backwards. I've been using an emulator to edit baba.prg directly, and using petcat to generate baba.bas so that people can read the source code online, and so that I can do diffs.

people on Facebook have mentioned toolchains out there that will build a PRG file from text source, so I should use one of them, and document it accordingly.

Objects with the LOSE property should destroy any overlapping object with the YOU property.

will go into more detail later. but MOVE tiles may be impossible; they require a facing-direction attribute to be added.

the 2017 level looks like this:

• One starting BABA tile
• An unbroken wall of the barrier tile is between starting BABA
• A structure of WALL tiles that traverses both sides of the barrier
• WALL IS STOP rule that can be disassembled immediately
• BABA IS YOU rule that can be edited eventually
• Immutable rules that FLAG IS WIN, and the barrier tile is LOSE.
  • possibly protect these rules with a different barrier tile.
• user wins by taking control of some tile on the other side of the barrier:
  • adding WALL IS BABA to existing BABA IS YOU rule
  • changing BABA IS YOU rule to WALL IS YOU rule

A level from the 2017 game meets these criteria and looks like this screenshot:

There should be two new property tiles: HOT and MELT.

MELT objects should be destroyed when they overlap HOT objects.

Support a new HAS verb in the rule-scanning loop.

When the sentence pattern "NOUN1 HAS NOUN2" is encountered, any rule that causes a NOUN1 object to be destroyed will replace it with a NOUN2 object instead of the background tile.

Add the second level, in which Baba is trapped in a room with the flag, and the words "FLAG", "IS", and "WIN.

Immutable rules: BABA IS YOU, WALL IS STOP

Source stage has some decorative tiles in the background, and the room is 11 tiles wide by 8 tiles tall. could be turned sideways to maintain tile resolution.

Having only seven tiles in the whole game is too limiting. But adding more would require changing the bit structure of the game state, and would probably force each playfield tile state to be stored in 2 bytes instead of 1 in the compiled version.

The following assumptions give us our options and limitations:

• The player only moves forward in the game
• No object has any meaning until it is given a rule.
• The initial seven tiles are not required for every level.
• The playfield data structure should not be changed, only the graphics.

We can provide additional level-specific objects by creating a table of replacement objects, with a column each for starting level, object index, replacement graphic, and replacement noun.

For example, given this entry:

9500 data 3,5,"{yel}%%%%","{wht}lava"

Upon loading level 3, the game should replace the water tile with a lava tile. Specifically, it should replace GR$(5) with the first string, and GR$(13) with the second string.

Alternately, we can keep a table of alternate objects, and a separate table of which objects go into which levels.

Note that CBM BASIC's READ statement does not add to the string heap, so if you want to keep a backup copy of the original GR$ array, it will only take up an additional 50 bytes (2 for the name, 48 for the string pointers and lengths), assuming you only store the first 16 entries.

FLOAT objects should ignore all other rules in the overlap-detection phase, unless both the background and foreground objects are FLOAT.

FLOAT property does not need to be checked in the movement phase, because PUSH and STOP still take effect.