Posts Tagged ‘qbasic

09
Apr
19

Modern BASIC: PCBasic and QB64

Last month I had intended to make the next Sparcstation desktop post, but unfortunately have been having trouble getting the software I had intended to cover to build. So that’s still in the works and today we’re going to look at something else interesting: modern implementations of old BASIC Languages. It seems I’m not the only one that feels nostalgia for the old BASIC interpreters that were common to almost every machine. The two I’m looking at today are particularly nostalgic for me as I learned to program on the original interpreters.

The first, PC-BASIC is made by Rob Hagemans and is an extremely well polished GWBasic emulator. It seems to be 100% compatible as I’ve been able to run all of my old basic programs including ones that use graphics and sound. Here are some images of programs running.

This slideshow requires JavaScript.

The graphics and sound are indeed very accurate compared to MS-DOS hardware and the original interpreter. There is good support for all the graphics modes including those from special machines such as the Tandy/PCjr and Olivetti machines that had special versions of the interpreter. The PC speaker is emulated quite well (better than under Dosbox) and support for Tandy 3-voice sound is included. I’m not sure if it was deliberate, but it seems that the processing speed on my laptop is similar to what I used to experience on our old 386sx back in the day.

The next program, QB64, is a new language designed to mimic QBasic and QuickBasic with extensions that provide access to modern graphics and sound libraries. It can build native executables for Linux, Windows and Mac OS, so it’s pretty impressive and capable of producing programs for modern systems. Here are some programs running.

This slideshow requires JavaScript.

I tried to compile some of my old programs, from both GWBasic and Qbasic, and found some worked without modification whilst others didn’t work or required modification. I had some issues with the programs that did build, the first and most obvious is that the programs started in what is initially a very small window. Resizing the window doesn’t stretch the display, but pressing alt+enter does give a nice full screen display. The second issue is more complex and arises from the fact the programs are compiled and not interpreted. Basically they run way too fast because they are running at native speeds on modern hardware. This issue however should be fixable by modifying your programs with better timing code. Thirdly I’ve found one or two features from the old languages aren’t implemented, meaning some old programs won’t work, the Gorilla game that came with Qbasic being one.

An IDE is provided which looks almost identical to QBasic, so it’s very familiar and relatively easy to use. Auto indentation seems to fix old programs as they are loaded and parsed, and there is some very nice syntax highlighting, making even old programs much more readable. Although one negative point is the built-in help only covers items specific to QB64 and has omitted a language reference for the base QBasic language.

Given that we can run the original interpreters in Dosbox, how do these modern interpretations compare?

PC-BASIC is quite good in the compatibility department, working with basically everything I threw at it. The only real disadvantage it has is speed compared to running GWBasic in Dosbox, and the ability to change the emulation speed. On the other hand it has some features that appeared in real hardware, but aren’t emulated in Dosbox. (such as screen borders on CRTs) It also gives access to features found on special versions of GWBasic, such as the special Tandy graphics and sound that would be otherwise inaccessible on the standard interpreter. You can get this interpreter from his github website, I recommend using the development version as it is more compatible and has fewer bugs.

QB64 doesn’t fair so well with every older program, those that work do so quite well however. Many programs will work with a little modification, whilst others will require major re-working. I suspect the main benefit of QB64 is less about running old programs and more about building new programs. It features some extensions to the QBasic/QuickBasic language that allow more modern features of the operating system to be used such as 3d graphic acceleration and digital sound. You can get QB64 from their website, I used the stable version and found it worked quite well.

28
Feb
19

QB Debugger Heroes for DOS

I wasn’t sure whether I should include today’s game as a home brew as it’s creator, Gemini (Kris Asick), has produced commercial games. From the file date it was made sometime in November 2017. He made it using QBasic during a live stream, which is certainly interesting, unfortunately there doesn’t seem to be a recording to watch now.

QB Debugger Heroes is a fairly simple Robotron 2084 clone using text mode for graphics and lacking any sound effects. This is relatively common for games implemented using gwbasic or Qbasic languages as it makes development much faster, and whilst there are graphics commands they don’t generally perform well so aren’t suited for action games. Although it is technically possible. Whilst it’s just textmode style graphics, they are nice to look at and includes some basic animation that looks quite nice.

The game controls requires the numpad on your keyboard, so you won’t be playing on a laptop. It works kinda like the twin stick design of the arcade game, with two clusters of keys, one for movement and the other for directing your fire. However unlike a real joystick each keypress changes your movement and gun fire, but you continue moving and firing in that direction until you press a key to change it. This is partly because of limitations within Qbasic when reading input from the keyboard.

For best results I suggest using a modern machine with Dosbox to run it, as you’ll be able to adjust the speed as needed. 30,000 cycles was suggested and is about right for a faster more challenging play experience. If you’re playing on real hardware you’ll need a Pentium era machine to get a decent challenge. Older 286 and 386 machines will work, but it runs slower and will be significantly easier.

The game play has the main elements of Robotron, but is simplified and has some elements removed. Like the arcade game, enemies spawn in continuously (in short bursts) and you finish a wave when your destroy a set number of them. However it appears there are fewer enemy types and there aren’t any humans to rescue. This was to be expected as it was developed in a relatively small time frame, and additions such as those would have degraded the game speed. Difficulty ramps up with each wave mostly just by number of enemies present.

Obviously QB Debugger Heroes isn’t anything special as far as Robotron clones go, but it is a good example of what can be done fairly quickly with a language like QBasic. Gemini has managed to create a reasonably faithful Robotron clone that is polished in 6 hours, which in my book is pretty darn impressive. You can find a download for it on his website.

This slideshow requires JavaScript.

 

20
Oct
15

QBasic Gorillas

Qbasic GorillasToday I’m looking at the classic old artillery game Gorillas, it was an example program for the Qbasic interpreter that was packaged with MS-DOS 5.0 and later. Because it was so widespread, being on practically every machine of its time, it was widely played and loved by many. I first encountered it on our high school computers in computer studies classes, we often got to play some games after we finished our work. We played many games, but Gorillas  (and Nibbles) were favourites.

Dancing Gorillas!

Dancing Gorillas!

Being written in Qbasic graphics and sound support is fairly basic. Unless you’re using an old machine with CGA only, the graphics are in high resolution EGA (640x350x16) and whilst not spectacular have some charm. Sound is PC speaker, again largely due to the limits of Qbasic. Most sounds are fairly basic, although the intro tune is kinda cool.

City Skyline

City Skyline

The game field consists of a city skyline with two Gorillas atop a building at opposite ends of the screen. Each Gorilla takes turns hurling an explosive banana at the other, with the player aiming the shots by entering the angle and velocity. The round only ends when one of the Gorillas is hit by a banana, with the survivor being the winner. There was no computer AI, so you had to play it in a hot-seat style or on your own. It’s simple and fun to play, although there isn’t much variety.

Target hit!

Target hit!

Normally this is where a post like this would end, with some kind of summary of what I thought. Today however I decided to have a quick go at making a simple modification to the game, adding an AI to the game so you can play solo. The tricky part with making an AI player in this case isn’t making something that will play well, but making something a human has a chance of beating. I could quite easily make it simply calculate the ideal velocity and angle, but that wouldn’t be much fun.

A winner is you.

A winner is you.

So what have I done instead? It’s a fairly simple algorithm, I set the initial aim to some sensible defaults and after each shot adjust the velocity depending on whether the shot landed short or long. This actually proved to be quite good at making hits, but not before making a few shots giving a human player a chance. Occasionally they will make a hit on the first shot, but that only happens when the buildings are set up just right. One circumstance that the computer does poorly is when a tall building is blocking the path of the bananas. I deal with this to a degree by making the angle higher when the banana doesn’t go very far. It will still take many shots for the AI to succeed.

I’ve made the modified version available here. It requires the original Qbasic to run and DOS in one form or another (Dosbox recommended). The game is pretty much unchanged apart from adding the AI, which you activate by naming a player Computer. You can have the computer play itself by naming both players Computer. Another improved version of the game exists, and has improvements such as a league table and improved graphics and sound. It’s called Gorillas Deluxe and can be found here.

12
Feb
12

Qbasic

Qbasic Intro Screen

Qbasic Intro Screen

Back when I was at high school we got some newish 486 workstations in our computer labs. Fortunately for me they had a copy of Qbasic on them which I quickly put to use. Qbasic is the language I primarily used whilst I was at high school, I wrote many larger projects than I ever could with gwbasic with the knowledge I had at the time. One of the main differences was the ability to use non-numeric labels that could mean something, and the ability to have functions separate to the main body of code. As I learned to use these features my code got neater and easier to modify, which was a good thing because the projects got significantly larger! I only ever had the version that came for free with ms-dos 6 so I couldn’t use many features that other Qbasic programmers use. This didn’t really matter cause at the time I had no other programmers (and no internet) to help guide me on how to use features and hardware directly that I had no prior knowledge of. This meant that I only really used whatever I could invent easily, or find in the user guide for Qbasic or the reference manual for gwbasic. Here are some of the projects that I made during these years.

Flight

Flight game screen

Flight game screen

This was originally a game written in gwbasic based on some space ship/jet designs me and my brother built out of lego. Here I had added many new features that were a lot like those found in the game f117a by microprose. The main goal of the game is to destroy land facilities whilst avoiding planes and SAM radar installations. The graphics were generated by vectors mostly and the small icons for the tactical display were created using the draw statement. The draw statement generated graphics in pretty much the same way as you would use the turtle in the logo language. You gave the cursor instructions on where to go and which colours to use. This was good in that I could draw images of any size and not worry about the amount of memory used, but bad in that the amount of detail was quite limited. Really it was more suited to gwbasic where I initially used this technique. One of the features in this version I learned in maths class in school. Yes, trigonometry at school helped me make the players plane fly using proper vectors flying at all angles instead of the 8 directions many games offered. Who would have thought something at school would turn out to be useful!

Puzzle and Mazing

Puzzle game screen

Puzzle game screen

One thing I did do quite a bit when learning something new was write a clone of another game to practise the technique. Most of the time the clones were a shadow of the original and puzzle is definitely one of those clones. Back in the day we used to play a game called Squarez deluxe by Adam Pederson rather a lot, I was just starting out with the bitmapped graphics and had completed two very simple games in gwbasic called jump and dodge. So to try out some ideas I had for having a lot of bitmaps I started to write a clone of squarez of sorts. I first started writing puzzle in gwbasic before I had Qbasic. I quickly ran into problems running out of memory partly because I didn’t know how to save memory on the graphics. When I got Qbasic I migrated the code across and built the rest of the game. You only got to place one tile at a time, and they usually did their thing as soon as you placed them. It was pretty much a matter of luck as to how the game played out, but this was one of the first games I built that had more than just a few sprites in them. The code became a horrible mess because I didn’t use the function feature of qbasic, and there were many remnants of the old gwbasic line numbers and code around.

Mazing game screen

Mazing game screen

Puzzle did spawn a somewhat more original game design in mazing. I took the basic tiles from puzzle and scattered them randomly around a play field, with the numbers of each tile weighted according to a difficulty level. The player had to navigate through the play field from the bottom to the top, activating some tiles as they go to help them reach the end. Some tiles blocked you from moving, some trapped you and others cleared portions of the field. You got points based on the tiles you triggered instead of a time frame reaching the exit. So when playing against another player you could lose in the sense that you didn’t make the exit, but win based on points. The code for this game was not really any better than puzzle, mostly because it was based of the puzzle code. But given that it was an experiment in game design it kinda worked alright as a game.

Bobs fury

Bobs Fury game screen

Bobs Fury game screen

One of my favourite genres of game is the platform game. Back in the day I used to play two games in particular a lot, both Xargon and Hocus Pocus. They inspired me to want to make a proper original platform game of my own. Working with my younger brother we created a simple platform game. I did the programming as my younger brother was a bit young to be able to do it, and my younger brother helped me with some of the graphics and level design. The game engine was a lot more limited than I really wanted to make when I first started, we were stuck with only two screens per level, and I couldn’t program scrolling at the time. A lot of features were cut out, I had wanted water levels like some of those that were in Xargon, as well as the normal ones within a castle or other area. But with my limited skills (and the limitations of Qbasic) we couldn’t add levels like that.  The code was a lot neater as this was one of the first programs that I wrote that used the qbasic function support. Using functions made the code a lot easier to read, but I still had a lot of bad coding habits from gwbasic, and from being self-taught. The game itself is playable but quite slow, although this could be because I’m testing it in dosbox, I believe some delay loops could be the issue. We made something like 40 or 50 different levels so there was plenty of content. I made a very basic music system for the pc speaker (via the play statement) that had a short bit of music looping that can get a bit annoying after a while. The collision detection wasn’t always the best either, mostly having issues with collisions with wall tiles rather than monsters.

Tomb game screen

Tomb game screen

I later used this engine to create another platform game called tomb, that was kinda based on an idea I saw in a magazine, a game called Pharaohs Tomb that I was not going to be able to get (but now have).  The game was different because you couldn’t kill the monsters and they couldn’t hurt you by shooting. You had to avoid the enemies whilst trying to collect the treasure. We created a different boss, either shown as a sphinx or mummy it walked back and forth across the level.

I’ve since made a Pascal port of Bobs Fury adding many features that I hadn’t even thought of back then, but remaining true enough to the old game to be able to play the old levels. I still continue to work on that version to this day, and probably have some more features to add!

Weird

Wierd game screen

Weird game screen

Yes one of my old qbasic games is named weird. This one is another attempted clone of Squarez, but one that worked out a whole lot better in game play. In order to score you have to put tiles togethor so that there are 3 or more surrounding the last tile you place. The tiles still come out individually, so it’s still not on par with squarez, but it’s quite playable and the graphics are weird to fit in with the name. Code wise it is a heap neater than it’s puzzle ancestor, but it is still all in one lump without functions. I’m not sure when in the time scale I wrote this one.

War

War game screen

War game screen

A game we played quite often was civilization, but one feature that was missing from the DOS version was some simple multiplayer support. Hot-seat play would have been fine by us as we only has the one machine! So I decided to create a simplified war game based on how you fight wars in civilization. War is played as a hot seat game, has some basic units you can build, a single screen map, and some simple to manage cities for each player. The goal being to destroy the enemies cities. I did make a basic AI, but it wasn’t very good. There are several versions of the game adapted to different scenarios and differing levels of advancement in the engine. This was one of the last games I wrote for Qbasic, and it pushes the limits in terms of complexity and sheer size in both code and memory usage. Fortunately it’s also one of the better designed games, mainly because it had to be. The user interface isn’t as well designed as I’d like, but I was running out of memory to add any thing extra. It plays quite well, and speed doesn’t seem to be an issue.

Conclusion

Qbasic Gorillas

Qbasic Gorillas

Qbasic is a powerful language for learning to program. The feature set is better than older versions of basic by a long way, encouraging programmers to make neater code, not by forcing you to, but by providing a better means of writing the same thing. I personally got a lot out of writing the projects that I did, not all my code was well written, in fact I think a lot of it wasn’t, but I learned a lot in the process. There are not many good languages good for learner programmers that also give you the power to create more complex applications. Qbasic fits the bill in many ways, but is difficult to get working on modern machines. So if you have an interest in programming I suggest you use QB64 which is basically a clone of Qbasic for modern systems with many added features, but compatibility with the old Qbasic. Microsoft also have made a nice starter language in small basic, but it is not compatible with Qbasic, which wont be a problem if you don’t require it.




Blogs I Follow

Enter your email address to follow this blog and receive notifications of new posts by email.


Mister G Kids

A daily comic about real stuff little kids say in school. By Matt Gajdoš

Random Battles: my life long level grind

completing every RPG, ever.

Gough's Tech Zone

Reversing the mindless enslavement of humans by technology.

Retrocosm's Vintage Computing, Tech & Scale RC Blog

Random mutterings on retro computing, old technology, some new, plus radio controlled scale modelling.

ancientelectronics

retro computing and gaming plus a little more

Retrocomputing with 90's SPARC

21st-Century computing, the hard way

lazygamereviews

MS-DOS game reviews, retro ramblings and more...