Lmst

Using PS/2 Mouse in SuperBasic
#FoenixF256K2 #SuperBasic #RetroComputing #PS2Mouse #BASICProgramming #8BitReimagined
https://theoasisbbs.com/using-ps-2-mouse-in-superbasic/?feed_id=3687&_unique_id=6842eb8251cdf

Nostalgie années lycée #backto1990 #linux #turbopascal #basicprogramming #assembler

Bible TurboPascal 5.0 et RedHat Linux 5.3 secrets

SuseLinux 6.2 7.0 , TurboAssembler 3.0 et Basic mode d'emploi

BBC Basic for SDL2 – for 80s fans!

https://dimalinkeng.blogspot.com/2025/05/bbc-basic-for-sdl2-for-80s-fans.html

#bbcbasicforsdl2 #retroprogramming #ide #80sprogramming #1980s #bbcmicro #basic #8bit #modernqbasic #programmingtool #soft #software #developmenttool #coolthing #uniquebasic #oldschool #8bitcomputers #writeprogram #codeeditor #retrosoft #basicprogramming #compile #like80s #modern80s

ugBASIC Programming Guide Updated
#ugBASIC #RetroComputing #8bitCoding #BASICLanguage #Commodore64 #MSX #ZXSpectrum #AmstradCPC #GameDevRetro #BASICProgramming
https://theoasisbbs.com/ugbasic-programming-guide-updated/?feed_id=3525&_unique_id=68370a7d8e450

I like Basic a lot

https://dimalinkeng.blogspot.com/2025/05/i-like-basic-lot.html

#Basicprogramminglanguage #retroprogramming #qbasic #qb64 #bbcbasicforsdl2 #freebasic #vim #basicprogramming #startingprogramming #80s #modern #software #ide #simpleprogramming #itisfun #compiler #codeeditor #dialectsBasic #differentversions #soft #app #application #development #coolretro #thisismodern #retrofuture

BASIC MEGA65 Dungeon Crawler Crammed Into One Screen
#Mega65 #BASICProgramming #8BitTheory #RetroDev #OneScreenGame #DungeonCrawler #RetroComputing #GameDev
https://theoasisbbs.com/basic-mega65-dungeon-crawler-crammed-into-one-screen/?feed_id=3256&_unique_id=6821f498e55b8

Tried my hand at the Bally Basic tutorial. It doesn't take long to get used to the keypad for programming. Powerful for a game console of it's time. #astrocade #BallyAstrocade #basicprogramming
#retrogaming

Teaching a Commodore 64 to “Think” — ProjectCD.Chronicles Pulls It Off in BASIC
#C64 #RetroComputing #NeuralNetwork #ProjectCDChronicles #BASICProgramming #Commodore64 #8bitAI #PatternRecognition
https://theoasisbbs.com/teaching-a-commodore-64-to-think-projectcd-chronicles-pulls-it-off-in-basic/?feed_id=3043&_unique_id=6810d028ad1e3

Classic Snake Game Now Playable on Commodore 64 and VIC-20
#C64 #VIC20 #RetroGaming #Commodore64 #BASICProgramming #Homebrew #SnakeGame #8bitgames
https://theoasisbbs.com/classic-snake-game-now-playable-on-commodore-64-and-vic-20/?feed_id=2861&_unique_id=68024e06524c6

MEGA65 Intro Disk V4: New Demos, Tools, Games & Community Highlights
#MEGA65 #IntroDiskV4 #Commodore65 #XEMU #BASICProgramming #RetroComputing #TypeInGames #8BitCommunity #HomebrewSoftware
https://theoasisbbs.com/mega65-intro-disk-v4-new-demos-tools-games-community-highlights/?feed_id=2823&_unique_id=67ffabf98a11f

How to Grab Commodore 64 Kernel Data Using BASIC
#Commodore64 #C64 #RetroComputing #BASICProgramming #SD2IEC #JosipRetroBits #Code
https://theoasisbbs.com/how-to-grab-commodore-64-kernel-data-using-basic/?feed_id=2487&_unique_id=67e69fb2e8227

Retronaut Revisits C&VG - February 1982: Arcade Classics & 8-Bit Coding
#RetroGaming #VintageComputing #ArcadeClassics #8Bit #BASICProgramming #GamingHistory #C64 #Commodore64 #ZXSpectrum #Atari
https://theoasisbbs.com/retronaut-revisits-cvg-february-1982-arcade-classics-8-bit-coding/?feed_id=1895&_unique_id=67c07330e82ce

Apple IIe — Snake Game in BASIC

Captured a nostalgic moment with my Apple IIe running a Snake game I coded in BASIC. The classic green monochrome monitor brings back the retro vibes of early computing. 💾

#AppleIIe #RetroComputing #VintageTech #SnakeGame #BASICProgramming #80sGaming #OldSchoolGaming #AppleII #ClassicComputer #GreenMonitor #RetroGaming #CodingInBASIC #MonochromeMonitor

Color Bars Effect in C64 BASIC
#Commodore64 #C64 #RetroComputing #BASICProgramming #C64Demo #RetroCoding #JosipRetroBits
https://theoasisbbs.com/color-bars-effect-in-c64-basic/?feed_id=1081&_unique_id=677e86e0bc168

Exploring Commodore User (Dec 1986): Fixing & Optimizing the Christmas Eve BASIC Game!
#c64 #Commodore64, #CommodoreUser, #BASICProgramming, #TypeInGames, #ChristmasEveGame, #SandyMunro, #RetroComputing, #VintageMagazines, #8BitGaming, #GameOptimization, #C64Bugs, #RetroChristmas
https://theoasisbbs.com/exploring-commodore-user-dec-1986-fixing-optimizing-the-christmas-eve-basic-game/?feed_id=902&_unique_id=676ee81dc8507

Sad news, specially for the #BASICProgramming community 😞

https://computerhistory.org/blog/in-memoriam-thomas-e-kurtz-1928-2024/

Sinclair User Club Volume 8 for the ZX81

https://www.youtube.com/watch?v=pJewOQBq7jQ

#SinclairUserClubVolume8 #SinclairUserClub #ZX81 #Collection #Compilation #BasicProgramming #Radiator #Golf #YearsEnd #Program #Programs #Finance #SinclairUser

C64 Text Adventure Game Programming Tutorial

We wrote a kind of C64 text adventure in the previous part of this series, but it was more of a "choose your own" adventure kind of style.

Now let's take a look at writing a true text adventure for the Commodore 64 using BASIC.

C64 text adventure game

There is a lot of benefit to writing these kinds of games, even if the game itself is not the end result you are working towards. A text adventure is really a kind of interactive database, with some logic, but to fit on a C64 it needs to be highly efficient in how it handles that data.

Planning the Adventure Game Engine

Commodore 64 BASIC Programming Series

Part 1: Introduction to Commodore BASIC

Part 1.5: Installing CBM Prg Studio on Mac/Linux

Part 2: Commodore BASIC Commands GOSUB and FOR Loops

Part 3: If/Then, Game Logic and Cursor Movement

Part 4: The Magic of POKE

Part 5: C64 DOS Commands

Part 6: Working with Data Files

Part 7: Programming C64 with Visual Studio Code

Part 8: C64 BASIC String Manipulation

Part 9: C64 Text Adventure Game

What do we need for a minimal text adventure?

Navigatable map represented in data.
Description of locations.
Objects to interact with in those locations.
Inventory.
Text input parser.

That is quite a to-do list, let's start with the map.

Representing Maps in C64 BASIC

3D Monster Maze

There are a few ways we can approach the map, but for a text adventure the first question we need to ask ourselves is how much freedom should the user have?

If you consider the games that we are familiar with, there are the most basic two dimensional games like 3D Monster Maze where the player can go North, South, East or West, all the way to the modern day first-person shooter where the player can essentially move in full 360 degress.

The former option is the easiest, and can be represented by a two-dimensional array:

dim m$(4,4)

Adventure Game Map Array

In the example above, our player can move North or South only where he currently sits at the coordinate 2,3 (arrays start counting at zero, and I am listing the horizontal coordinate before the vertical).

It is quite possible to have a three-dimensional array in Commodore BASIC programming, but once you start fleshing out your map you will see allocating space in memory for unused areas, so we should try another approach here.

Another disadvantage with the traditional 2D or 3D array for our map is it leads to a grid-based structure. In dungeon or maze style scenarios, this is perfect, but for a text adventure you soon start to find it restrictive.

For example, what if your player steps out of an airlock into space? Or descends to the bottom of the ocean in a submarine? Or even walks along the shore picking up driftwood, assembles a raft and explores the nearby island?

Linked Lists

You might be familiar already with Linked Lists, they have been around since the early days of computing, but essentially they are simply lists of data items where each item points to the next (or more) item in the list:

In computer science, a linked list is a linear collection of data elements whose order is not given by their physical placement in memory. Instead, each element points to the next. It is a data structure consisting of a collection of nodes which together represent a sequence. In its most basic form, each node contains data, and a reference (in other words, a link) to the next node in the sequence. This structure allows for efficient insertion or removal of elements from any position in the sequence during iteration. More complex variants add additional links, allowing more efficient insertion or removal of nodes at arbitrary positions

https://en.wikipedia.org/wiki/Linked_list

In our case we can use several single dimensioned arrays as our linked lists, but especially for things like the map and even our inventory.

Linked Lists

Taking the map first, using a linked list means we only need to set up data for locations that actually need to exist, and each location can point to the other locations the user can get to from there. This means they can go up and down, as well as the cardinal directions, if we want them to.

Our objects can also start at a location and be moved to other locations, or be held by the player, by giving each object a current location that points to an entry in the map.

rc = 3 : rem room count
dim lo$(rc)
lo$(0)="inventory"
lo$(1)="dank basement"
lo$(2)="furnace room"
lo$(3)="service hatch"

oc = 2 : rem object count
dim ob$(oc)
ob$(0)="matches"
ob$(1)="brass key"

rem object's locations
rem loc 0 = player's inventory
dim ol(oc)
ol(0)=0
ol(1)=1

In the example above, we have our locations listed and you will notice the first item, item zero, we consider the player holding in their inventory.

This means when we look at the Object Locations list, we can see the first object ("Matches") is being held by the player, but the "Brass Key" is in room 1, the "Dank Basement".

If the player goes to Dank Basement and picks up the key, the location for that object changes to zero. If they then drop the Matches then the Matches object location changes to room 1.

Listing the Inventory then becomes a case of going through the objects where the location is 0:

rem check object location from the first object to object count
for i = 0 to oc-1             
if ol(i) = 0 then print ". ";ob$(i)     : rem if the object is in zero print it
next i

Room descriptions follow the same pattern:

rem room descriptions (rc is the room count)
dim rd$(rc)
rd$(0)=""
rd$(1)="a chillingly damp, bare-bricked room with poured cement floor and timber beamed ceiling. window frames are boarded along one wall."
rd$(2)="this room is obviously a later addition, thrown together with drywall, and just large enough to section off the furnace from the main basement."
rd$(3)="up above the furnace, this tiny space must have been built to allow access to hvac ducting."

When the player steps into a new room/location, we print the selected name from the list, but we could if we wanted to also present the description without expecting the player to request that explicitly:

PRINT RD$(PL)

This is far easier to accomplish in a modern programming environment, where you might have a class with name, location, and other properties, but it is the closest we can get with the tools we have!

Look at that to-do list now, four out of five items checked off with one data structure!

Coding a Verb-Noun Text Parser in BASIC

Back when text adventures were popular, a lot of people were blown away as they got more and more sophisticated, but under the hood they were always very simple, because they had to be.

We didn't have the "AI" tools that we have today, the programs would simply look for patterns and react or branch appropriately.

The first check is to allow the player to "GO WEST" or simply enter "W" for their movements. It soon gets annoying to repeatedly write things out in full when you don't need to.

Checking for I is just as easy, but if we are careful to not have another command that starts with that letter, it also serves to check for Inventory too.

25 PRINT "WHAT NOW?"
26 INPUT I$
27 IF LEFT$(I$,3) = "GO " THEN GOSUB 42
28 IF I$ = "N" THEN GOSUB 46
29 IF I$ = "E" THEN GOSUB 46
30 IF I$ = "S" THEN GOSUB 46
31 IF I$ = "W" THEN GOSUB 46
32 IF I$ = "U" THEN GOSUB 46
33 IF I$ = "D" THEN GOSUB 46
34 IF LEFT$(I$,1) = "I" THEN GOSUB 58

When the player uses GO then we need to find the direction part of that instruction using our neat MID$ command we are now familiar with from last time.

42 REM FULLY WRITTEN OUT MOVE (EG. GO SOUTH OR GO S)
43 D$ = MID$(I$,4,1)
44 GOSUB 50
45 RETURN
46 REM ABBREVIATED MOVE (EG. N)
47 D$ = I$
48 GOSUB 50
49 RETURN

With a single letter now in hand we need to check where to take the player to next.

Rather than put together a multi-dimensional array, I opted to use strings for each location and the available exits. If there is a number greater than 00 in the string location then we get the VAL() to return the numeric versus string value, and that is the players new room to explore:

50 REM GO TO THE NEW PLAYER LOCATION (PL)
51 IF D$ = "N" THEN PL = VAL(MID$(EX$(PL),1,2))
52 IF D$ = "E" THEN PL = VAL(MID$(EX$(PL),3,2))
53 IF D$ = "S" THEN PL = VAL(MID$(EX$(PL),5,2))
54 IF D$ = "W" THEN PL = VAL(MID$(EX$(PL),7,2))
55 IF D$ = "U" THEN PL = VAL(MID$(EX$(PL),9,2))
56 IF D$ = "D" THEN PL = VAL(MID$(EX$(PL),11,2))
57 RETURN

More complicated instructions are really just a variation on what we did with GO, we split the instruction into verbs and nouns.

Verbs are actions, so in the instruction they should come first, followed by a space.
Nouns are names of things, so we look at that part to see which object we are referring to.

C64 BASIC does not have a way to search within a string like other dialects (usually the INSTR command), so we can not look for the space character efficiently. Instead we need to check the start of the string for each specific word.

Once we know the verb we can handle the noun in the subroutine that we then branch to.

There is likely a more efficient way to do this, but this suffices:

35 IF LEFT$(I$,4) = "GET " THEN GOSUB 73
36 IF LEFT$(I$,5) = "TAKE " THEN GOSUB 69
37 IF LEFT$(I$,5) = "DROP " THEN GOSUB 93
38 IF LEFT$(I$,8) = "EXAMINE " THEN GOSUB 107
39 IF LEFT$(I$,4) = "LOOK" THEN PRINT"":PRINT RD$(PL):PRINT"":GOSUB 65
40 IF LEFT$(I$,1) = "Q" THEN GOTO 190

Q or QUIT, of course, takes you to the "ARE YOU SURE?" screen before closing the program.

Text Adventure Code So Far

1 REM TEXT ADVENTURE GAME BY CHRIS GARRETT 2024 RETROGAMECODERS.COM
2 REM SET UP VARIABLES ETC
3 GOSUB 128
4 REM SHOW ROOM DETAILS
5 GOSUB 126
6 IF PL=0 THEN PL = PP : REM PLAYER LOCATION CAN NOT BE 00 AS THAT IS INVENTORY
7 PP = PL : REM BACKUP THE LOCATION IN CASE ILLEGAL MOVE MADE
8 PRINT RV$+LO$(PL)+RO$
9 PRINT ""
10 PRINT "OBJECTS VISIBLE:"+LB$
11 FOR I = 0 TO OC-1 : REM CHECK OBJECT LOCATIONS FROM THE FIRST OBJECT TO OBJECT COUNT
12 IF OL(I) = PL THEN PRINT ". ";OB$(I) : REM IF THE OBJECT IS IN CURRENT LOCATION PRINT IT
13 NEXT I
14 PRINT ""
15 PRINT WT$+"EXITS AVAILABLE:"+LB$
16 REM CHECK EACH POSSIBLE EXIT
17 IF MID$(EX$(PL),1,2)&lt;&gt;"00" THEN PRINT ". NORTH"
18 IF MID$(EX$(PL),3,2)&lt;&gt;"00" THEN PRINT ". EAST"
19 IF MID$(EX$(PL),5,2)&lt;&gt;"00" THEN PRINT ". SOUTH"
20 IF MID$(EX$(PL),7,2)&lt;&gt;"00" THEN PRINT ". WEST"
21 IF MID$(EX$(PL),9,2)&lt;&gt;"00" THEN PRINT ". UP"
22 IF MID$(EX$(PL),11,2)&lt;&gt;"00" THEN PRINT ". DOWN"
23 I$=""
24 PRINT ""
25 PRINT YL$+"WHAT NOW?"+LB$
26 INPUT I$
27 IF LEFT$(I$,3) = "GO " THEN GOSUB 42
28 IF I$ = "N" THEN GOSUB 46
29 IF I$ = "E" THEN GOSUB 46
30 IF I$ = "S" THEN GOSUB 46
31 IF I$ = "W" THEN GOSUB 46
32 IF I$ = "U" THEN GOSUB 46
33 IF I$ = "D" THEN GOSUB 46
34 IF LEFT$(I$,1) = "I" THEN GOSUB 58
35 IF LEFT$(I$,4) = "GET " THEN GOSUB 73
36 IF LEFT$(I$,5) = "TAKE " THEN GOSUB 69
37 IF LEFT$(I$,5) = "DROP " THEN GOSUB 93
38 IF LEFT$(I$,8) = "EXAMINE " THEN GOSUB 107
39 IF LEFT$(I$,4) = "LOOK" THEN PRINT"":PRINT RD$(PL):PRINT"":GOSUB 65
40 IF LEFT$(I$,1) = "Q" THEN GOTO 190
41 GOTO 4
42 REM FULLY WRITTEN OUT MOVE (EG. GO SOUTH OR GO S)
43 D$ = MID$(I$,4,1)
44 GOSUB 50
45 RETURN
46 REM ABBREVIATED MOVE (EG. N)
47 D$ = I$
48 GOSUB 50
49 RETURN
50 REM GO TO THE NEW PLAYER LOCATION (PL)
51 IF D$ = "N" THEN PL = VAL(MID$(EX$(PL),1,2))
52 IF D$ = "E" THEN PL = VAL(MID$(EX$(PL),3,2))
53 IF D$ = "S" THEN PL = VAL(MID$(EX$(PL),5,2))
54 IF D$ = "W" THEN PL = VAL(MID$(EX$(PL),7,2))
55 IF D$ = "U" THEN PL = VAL(MID$(EX$(PL),9,2))
56 IF D$ = "D" THEN PL = VAL(MID$(EX$(PL),11,2))
57 RETURN
58 REM OBJECTS THE PLAYER IS CARRYING
59 PRINT ""
60 PRINT "OBJECTS IN YOUR POSSESSION:"
61 FOR I = 0 TO OC-1 : REM CHECK OBJECT LOCATION FROM THE FIRST OBJECT TO OBJECT COUNT
62 IF OL(I) = 0 THEN PRINT ". ";OB$(I) : REM IF THE OBJECT IS IN ZERO PRINT IT
63 NEXT I
64 PRINT ""
65 PRINT CY$+RV$+" PRESS A KEY TO CONTINUE "+RO$
66 GET I$
67 IF I$="" GOTO 66
68 RETURN
69 REM ALTERNATIVE ACTION TO GET
70 F=-1:R$=""
71 R$ = MID$(I$,6) : REM R$ IS OBJECT REQUESTED
72 GOTO 76
73 REM ALLOW PLAYER TO GET AVAILABLE OBJECT AND PUT IN INVENTORY
74 F=-1:R$=""
75 R$ = MID$(I$,5) : REM R$ IS OBJECT REQUESTED
76 REM GET THE OBJECT ID
77 FOR I = 1 TO OC
78 IF OB$(I-1) = R$ THEN F=I : REM IT EXISTS
79 NEXT I
80 REM CAN'T FIND IT?
81 PRINT ""
82 IF F=-1 THEN PRINT "CAN'T SEE THAT HERE, CHECK SPELLING AND BE SPECIFIC?" : GOTO 90
83 IF OL(F-1)=PL THEN GOTO 87
84 IF OL(F-1)=0 THEN PRINT "YOU ALREADY HAVE THAT" : GOTO 90
85 PRINT "I CAN'T SEE THAT AROUND HERE"
86 GOTO 90
87 OL(F-1)=0 : REM SET THE OBJECT LOCATION TO INVENTORY AKA ROOM ZERO
88 PRINT ""
89 PRINT "GOT THE ";OBJ$(F-1)
90 PRINT ""
91 GOSUB 65
92 RETURN
93 REM DROP OBJECTS THE PLAYER IS CARRYING
94 F=-1:R$=""
95 R$ = MID$(I$,6) : REM R$ IS OBJECT REQUESTED
96 REM GET THE OBJECT ID
97 FOR I = 1 TO OC
98 IF OB$(I-1) = R$ THEN F=I : REM IT EXISTS
99 NEXT I
100 REM CAN'T FIND IT?
101 PRINT ""
102 IF F=-1 THEN PRINT "CAN'T SEEM TO FIND THAT, CHECK SPELLING AND BE SPECIFIC?" : GOTO 105
103 IF OL(F-1)=0 THEN PRINT "OK, DROPPED!" : OL(F-1)=PL : GOTO 105
104 PRINT "NO CAN DO, ARE YOU SURE YOU HAVE THAT?"
105 GOSUB 65
106 RETURN
107 REM EXAMINE OBJECTS THE PLAYER IS CARRYING
108 F=-1:R$=""
109 R$ = MID$(I$,9) : REM R$ IS OBJECT REQUESTED
110 REM GET THE OBJECT ID
111 FOR I = 1 TO OC
112 IF OB$(I-1) = R$ THEN F=I : REM IT EXISTS
113 NEXT I
114 REM CAN'T FIND IT?
115 PRINT ""
116 IF F=-1 THEN PRINT "CAN'T SEEM TO FIND THAT, CHECK SPELLING AND BE SPECIFIC?" : GOTO 119
117 IF OL(F-1)=0 THEN PRINT OD$(F-1) : GOTO 119
118 PRINT "NO CAN DO, ARE YOU SURE YOU HAVE THAT?"
119 GOSUB 65
120 RETURN
121 REM CLEAR SCREEN AND SET UP COLOURS
122 POKE 53281,6 : POKE 53280,6: REM SCREEN COLOURS
123 LB$=CHR$(154): WT$=CHR$(5): REM LIGHT BLUE, WHITE
124 YL$=CHR$(158): CY$=CHR$(159): REM YELLOW AND CYAN
125 RV$=CHR$(18): RO$=CHR$(146): BL$=CHR$(13) + CHR$(187) + CHR$(32): REM REVERSE ON AND OFF TO MAKE LISTING THE CODE EASIER
126 PRINT WT$: PRINT CHR$(147): PRINT CHR$(19);: REM CLEAR SCREEN, WHITE TEXT
127 RETURN
128 REM SET UP THE GAME AND THE DISPLAY
129 GOSUB 121
130 REM OBJECTS AND LOCATIONS
131 REM =====================
132 REM OBJECTS
133 OC = 2 : REM OBJECT COUNT
134 DIM OB$(OC)
135 OB$(0)="MATCHES"
136 OB$(1)="BRASS KEY"
137 REM OBJECT DESCRIPTIONS
138 DIM OD$(OC)
139 OD$(0)="A SMALL BOOK OF PROMOTIONAL MATCHES ADVERTISING PATTY'S BAR AND GRILL, NORTH LAKES"
140 OD$(1)="A LARGE AND HEAVY KEY MADE OUT OF BRASS."
141 REM LOCATIONS
142 RC = 3 : REM ROOM COUNT
143 DIM LO$(RC)
144 LO$(0)="INVENTORY"
145 LO$(1)="DANK BASEMENT"
146 LO$(2)="FURNACE ROOM"
147 LO$(3)="SERVICE HATCH"
148 REM ROOM DESCRIPTIONS
149 DIM RD$(RC)
150 RD$(0)=""
151 RD$(1)="A CHILLINGLY DAMP, BARE-BRICKED ROOM WITH POURED CEMENT FLOOR AND TIMBER BEAMED CEILING. WINDOW FRAMES ARE BOARDED ALONG ONE WALL."
152 RD$(2)="THIS ROOM IS OBVIOUSLY A LATER ADDITION, THROWN TOGETHER WITH DRYWALL, AND JUST LARGE ENOUGH TO SECTION OFF THE FURNACE FROM THE MAIN BASEMENT."
153 RD$(3)="UP ABOVE THE FURNACE, THIS TINY SPACE MUST HAVE BEEN BUILT TO ALLOW ACCESS TO HVAC DUCTING."
154 REM OBJECT'S LOCATIONS
155 REM LOC 0 = PLAYER'S INVENTORY
156 DIM OL(OC)
157 OL(0)=0
158 OL(1)=1
159 REM EXIT NAMES
160 DIM EN$(6)
161 EN$(0)="NORTH"
162 EN$(1)="EAST"
163 EN$(2)="SOUTH"
164 EN$(3)="WEST"
165 EN$(4)="UP"
166 EN$(5)="DOWN"
167 REM ROOM EXITS
168 REM N E S W U D
169 DIM EX$(20)
170 EX$(1)="000002000000"
171 EX$(2)="010000000300"
172 EX$(3)="000000000002"
173 REM PLAYER
174 REM ======
175 PL = 1 : REM PLAYER LOCATION
176 PP = 1 : REM PLAYER PREVIOUS LOCATION
177 GOSUB 121
178 PRINT " MURDER HOUSE"
179 PRINT " A TEXT ADVENTURE GAME"
180 PRINT " BY CHRIS GARRETT"
181 PRINT " 2024"
182 PRINT""
183 PRINT LG$
184 PRINT " RETROGAMECODERS.COM"
185 PRINT""
186 PRINT""
187 PRINT""
188 GOSUB 65
189 RETURN
190 GOSUB 126
191 POKE 53281,6 : POKE 53280,14
192 PRINT "GOODBYE!"
193 PRINT ""
194 PRINT FRE(0)
195 PRINT ""

Here above is the C64 BASIC code for the text adventure so far, and it is also available on Github9.

It is sufficient to make a game, even though we have some pieces missing if you wanted to go full Zork.

How would you make it so that the player wins if they find the treasure?
Could you score the player based on completing the game in as few steps as possible?
Can you figure out how to have closed or even hidden doors?

The post C64 Text Adventure Game Programming Tutorial appeared first on Retro Game Coders.

#programming #basicprogramming #commodore64c64

The BASIC programming language turned 60 years old this week (May 1st). For so many people (myself included) BASIC was their first venture into computer programming. A simple, easy to read language that inspired many of the programming languages we use today. HAPPY BIRTHDAY!
#BASICProgramming #BASIC #Programming #Computer #ComputerHistory

https://arstechnica.com/gadgets/2024/05/the-basic-programming-language-turns-60/

“On many early microcomputers, BASIC was more than a language — it was also the operating system of the machine, the interface between the electronics inside the beast and the gawk-eyed neophyte at the keyboard.”

⸺ G. Michael Vose

From page 298 of Byte Magazine Volume 09 Number 04 (1984 April) - "Real-World Interfacing"

#basic #basicProgramming #retroComputing #vintageComputing

#basicprogramming

Client Info