|
|
|
QBASIC Tutorials
|
|
These are tutorials in various QBASIC techniques that range from very basic techniques to the very advanced (Assembly, etc.). If you've got questions, we've got answers!
[ Assembly | Game Design | Graphics | Sound | Miscellaneous ]
|
|
Assembly |
| General Assembly Tutorials |
| Link | Description | Author |
| Assembly in QBasic |
A good tutorial for beginners in ASM. You should know HEX first. (HEX tutorial is located in the misc. section) |
Aaron Severn |
| Assembly Language Tutorial v0.3 |
A very good tutorial for ASM beginners. Includes some source. Only about 1/2 done, and most likely will never be finished. |
Milo Sedlacek & Drew Vogel |
| Assembly Language Tutor |
A very large ASM tutorial. Highly recommended! Created by a student at the University of Guadalajara. |
Hugo Perez |
| Assembly in QBasic: Code .386 |
A nice tutorial including lots of source. Basically shows how to do 386 ASM in QuickBASIC. |
Rick Elbers |
|
Assembly in QB |
The start of a great ASM series that was unfortunately never finished. This tutorial covers just the basics of ASM, for the new assembler programmer. (QB Chronicles #4)
| Fling-master |
|
Assembler Programming for QuickBasic |
Creating assembly routines specifically for QuickBasic -- dealing with common variables and such. Assumes you already know both QuickBasic and ASM. (QBNews Vol. 1 No. 3)
| Tom Hanlin |
|
ASM Graphics & Mouse |
Using snippets of assembly in your QB program to speed up graphics and use the mouse.
| Charles Johnson |
|
ASM in QB: Interrupt Handlers |
Discusses interrupt vectors and interrupt handlers, and explains how you can incorporate ASM code into your QBasic programs through a variety of tricks and "short longcuts".
| Rick Elbers |
|
ASM Libraries |
A very short tutorial on making ASM libraries for QB.
| Spirit and Source |
| ASM Vectors |
A nice tutorial that shows how to use interrupts through ASM. Useful! |
Rick Elbers |
|
Converting ASM String Functions to BASIC 7.X |
Using both Near Strings and Far Strings in PDS 7.X, and dealing with their memory locations. (QBNews Vol. 3 No. 1)
| Jay Munro |
|
DEBUG Tutorial |
Explains how to use DEBUG.COM to create your own assembler programs. Covers the basics of the ASM language.
| Unknown |
|
Extending the QBasic Interpreter |
Achieving advanced QuickBasic functions through the free QBasic interpreter, using CALL ABSOLUTE and assembly routines. This tutorial explains how to do DOS and BIOS interrupt calls, instant memory block copies and fast color single-line box drawings in QBasic. (QBNews Vol. 3 No. 1)
| Brent Ashley |
| How To: Assembly Language Routines, Fast Graphical Routines, Mouse Stuff and More. |
Includes mouse routines, fast graphics routines and a several custom ASM graphics routines too. |
Charles Johnson |
|
Infix to ASM Convertor Plan |
Infix notation is the arithmetic formula notation where numbers and operations are written in a "tree format". This will show you how to convert this notation to ASM. (QBOA Issue 4)
| Logiclrd |
|
The PC Assembler Tutor |
A giant book covering all aspects of ASM programming (more than 26 chapters). Incredibly thorough, and hits on topics that none of the other ASM tutorials don't touch. This also includes a nice BASIC tutorial. Not recommended for newbies.
| Species (Distributor) |
|
QB Parameter Passing |
Passing parameters between ASM code and QB functions. (QBOA Issue 4)
| Sten Daniel Sørsdal |
|
Secret ASM tricks for QB |
Some tricks you can do with ASM in QuickBasic -- retreiving DEF SEG segments, various screen info, and a bit more. (QBOA Issue 2)
| Sten Daniel Sørsdal |
|
Shimmer QuickBasic ASM Tutorial |
A great ASM tutorial for beginners. This tutorial is tailored especially toward QuickBasic, and gives a lot of good insights. Better-written and more interesting than most.
| CGI Joe |
|
Using Assembly in QuickBasic: Part I |
A well-written introduction to ASM covering topics like 'Assembling' in DEBUG, using CALL ABSOLUTE and exchanging variable data between QB and ASM. This tutorial is far from complete, but it covers the most important topics right of the bat. A good supplement to one of the more complete series.
| Raze |
|
Writing Your Own GET & PUT Routines |
Using ASM to create faster and improved GET/PUT routines for your QB program. (QB Cult Magazine #2)
| Matthew R. Knight |
| Petter Holmberg's ASM Series |
| Link | Description | Author |
|
Part 1: Getting Started |
Getting Started -- History of assembler, binary and hexadecimal numbers
| Petter Holmberg |
|
Part 2: The Basics |
Your first assembly routine.
| Petter Holmberg |
|
Part 3: Data Manipulation |
Registers, the stack, MOV, arithmetic operations, using CALL ABSOLUTE and a whole lot more!
| Petter Holmberg |
|
Part 4: Flow Control |
Controlling the program flow, JMP, CALL, RET, how to make a PUT routine with clipping, and much more.
| Petter Holmberg |
|
Part 5: I/O |
Using com ports, interrupts, and making a keyboard handler.
| Petter Holmberg |
|
Part 6: Closing Up |
Numbers in assembler, optimizing ASM code, when to use ASM code in QB, finding errors, and a list of ASM commands.
| Petter Holmberg |
| Absolute Assembly v2.1 |
Absolute Assembly. Petter's application which allows you to insert Assembly commands into your QB program easily. |
Petter Holmberg |
| Petter Holmberg's ASM Series: Original QB:TM Versions |
| Link | Description | Author |
|
Assembly Series: Part 1 |
"What is assembler?" and working with hexadecimal and binary numbers as well as memory addresses. (QB:TM #4)
| Petter Holmberg |
|
Assembly Series: Part 2 |
The basics: MOV, PUSH, etc., then incorporating your new assembly program into QBasic. (QB:TM #5)
| Petter Holmberg |
|
Assembly Series: Part 4 |
Controlling program flow: using the equivalent of GOTO and subroutines in assembly. (QB:TM #7)
| Petter Holmberg |
|
Assembly Series: Part 5 |
Hardware I/O: using the ports and getting user input. (QB:TM #8)
| Petter Holmberg |
|
Assembly Series: Part 6 |
Some more on using numbers in assembly, how to optimize your code, and some appendices of everything you've learned in this great series. (QB:TM #9)
| Petter Holmberg |
| "Learn ASM In One Hour Flat" Series by abionnnn |
| Link | Description | Author |
|
ASM in QBasic (Part 1) |
A brief introduction to ASM programming covering the basics like MOV and ADD. (QB Times #1)
| abionnnn |
|
ASM in QBasic (Part 2) |
Lessons 3 and 4: More ASM commands and how to make ASM procedures. (QB Times #2)
| abionnnn |
|
ASM in QBasic (Parts 3 & 4) |
Part 3 of abionnnn's ASM series, with Lesson No. 5 on a Different Approach to ASM programming. (QB Times #4)
| abionnnn |
|
ASM in QBasic (Part 5) |
Lesson no. 6 -- 8-bit registers; Lesson no. 7 -- Segment Registers and memory; Lesson no. 8 -- Basics of the Stack; Lesson no. 9 -- Procedures 2;
| abionnnn |
|
ASM in QBasic (Part 6) |
Lesson No. 9: Putting it together; Lesson No. 10: Extended Mov commands. (QB Times #9)
| abionnnn |
|
Logic |
Introduction to using logic gates, with ASM code. Covers AND, NOT and Redundanments. (QB Times #9)
| abionnnn |
| Doorknob Software ASM Tutorials |
| Link | Description | Author |
|
Part 1 |
Introduction, interrupts, registers, compiling, memory, addressing, variables and more.
| Doorknob Software |
|
Part 2 |
Special segments, loops, line labels, graphics, graphics file loading and more.
| Doorknob Software |
|
Part 3 |
The palette.
| Doorknob Software |
|
Appendix 1 |
Including ASM code in your QB program: The Call Absolute Way, The LINKing way, and making a library.
| Doorknob Software |
|
Appendix 2 |
Logical Operators
| Doorknob Software |
|
Appendix 3 |
Non-Decimal Numbering
| Doorknob Software |
| Submitted Assembly Tutorials |
| Link | Description | Author |
| ASM.zip |
All in 1!. This is all the ASM tutorials here as of August 16 put into 1 zip file and all in .txt format but 1 that is in HTML format because I could not convert it. (Submitted by Nathan1993 on August 16, 2005) |
Many |
| asm.txt |
The ULTAMITE ASM Tutorial!. This tutorial teaches everything about assembler, from numbering systems to GFX, but it does not say anything about how to put it into QB. FB for dos, anyone? (Submitted by Nathan1993 on August 17, 2005) |
Ralph (fu@ckz.org) |
|
|
Game Design |
| General Game Design |
| Link | Description | Author |
| Course in Game Design |
A two week and five day course on game design, where you make several simple games of increasing complexity. A great intro to game programming, especially for QB programmers! Lots of sample code. |
Andre Van Wyk |
|
The Game Design Process |
How to create any game from start to finish. Explains Game Design in "six easy steps" and teaches you about deisgn documents, product specifications and screenplays.
| Francois Dominic Laramee |
|
How To Write Good Quality QBasic Action Games |
A very thorough theory tutorial on creating both single player and multi-player action games. Discusses everything from point of view to radar to two player keyboard layouts. Created for The QBasic Station by Jack Thomson.
| Jack Thomson |
|
Simple Game Design |
Takes beginners through the steps of designing any game -- planning, gathering tools, designing the algorithm. Includes an example of how to make a PONG game. (BASIX Fanzine #5)
| Diego |
|
Rant: Necessity or Accessory? |
A game programming theory article that discusses what are the most important aspects of a game. These include Ease of Play, Graphics, Sound/Music, Storyline and Fun/Replayability. An important read for game designers trying to decide where to focus their programming time. (QB Chronicles #4)
| Singsong |
|
30 Tips To Make Your Game More Fun To Play |
Thirty great tips on game design, especially for the QB programmer. (QB Cult Magazine #11)
| Terry Cavanagh |
|
How To Make A Game That's Fun To Play |
Some tips and theory discussing what makes games fun to play. (QB Cult Magazine #13)
| Sane |
|
Non-Linearity In Games |
Game theory article on making open-ended games. (QB Cult Magazine #17)
| Wildcard |
|
Writing User Friendly Programs |
What you should and shouldn't do to make your programs easy and intuitive for users to use... and not frusterating. (QB Cult Magazine #2)
| Matthew R. Knight |
|
Player Too |
Strategies for making two player games in QB; either having two players play with the same keyboard, or playing over the phone modem. (QDF #1)
| Lord Acidus |
|
"What Are You Doing Dave?" |
A rudimentary introduction to Artificial Intelligence programming. Simple stuff. (QDF #2)
| Lord Acidus |
|
Game Design |
Short theory article on how to make your games challenging, entertaining and unique. (Razor Diskmag #1)
| Tim Ryan |
|
How To Program Everything - A Step By Step Guide |
"There has only ever been one program ever written, and every other has been a clone of that. In these paragraphs, I'm going to explain The One Program in detail, I'm going to point how that original program works, and how you can use the innate knowledge of The One Program to code anything you've ever wanted." (QBOA Issue 11)
| SJ Zero |
| The PC Game Programmer's Encyclopedia |
The PC Game Programmer's Encyclopedia.. LOTS of great resources! |
Mark Feldman (editor) |
| Tile Engines |
| Link | Description | Author |
| Scrolling |
A great scrolling tutorial, includes examples for MODE X, regular 13H scrolling, and parallax scrolling. Psuedo-code. |
Alec Thomas |
| Pixel By Pixel Scrolling |
Wanna make a pixel scroller? This will show you how. |
Aaron Severn |
| Tile-Based Game FAQ v1.2 |
The famous 'Tile-Based Games FAQ' Very useful! Mostly pseudo-code |
Greg Taylor |
| Tek's Tile Engine 3 |
Tek's Tile-engine 3. A working demo of a tile-scrolling engine with great commentary. Budding RPG programmers, this is THE place to start! |
Tek |
|
Animation |
An introduction to animation in an RPG tile engine. Very short.
| Tal Bereznitskey |
|
Clipping |
Clipping -- cutting up a sprite and only putting part of it down -- is explained. Useful if you want to make a pixel*pixel scrolling engine.
| Entropy |
|
Tile-by-Tile Scrolling |
A beginner's look at tile engines; well-documented and easy to understand code, but it will only make the simplest tile engine imaginable.
| Entropy |
|
TileEx |
A barebones tile engine with very well-commented source code.
| James Tonn |
|
Special Effects for a Tile Engine |
A great tutorial covering the following tile engine special effects: animated objects, particle systems, water flow and reflections, high grass (over tiles) and more.
| Michael Dowling (Typosoft) |
|
Making A Good RPG Engine: Setting Up |
An overview of how to get started on your RPG engine. This explains which modules you should include, which variables to allocate at the beginning of your RPG, and what you should do about a map editor. Doesn't really teach you commands or techniques -- it's more of an outline.
| Michael Dowling (Typosoft) |
|
Z-Buffer |
A brief discussion on using the Z-Buffer in 2D, sprite-based games to have multiple layers of sprites.
| Kackurot |
|
RPG Development and Design Series |
Four short tutorials on RPG Development from Venosoft (venosoft.com). Focuses mainly on Engine Development, and discusses methods for QB, VB and C/C++. The code examples, however, are in C++.
| jkettles16 |
|
Tile Graphics Techniques 1.0 |
A theory article explaining the techniques behind many parts of a tile engine, including clipping, masking, plotting tiles, NPCs, objects, maps, map layers, and some scripting techniques. Highly recommended.
| Jason McIntosh |
|
Making a TRUE Pixel Scrolling Engine at Tile Scrolling Speeds |
Making an optimized pixel-scrolling engine in QB. (QBOA Issue 2)
| QbProgger |
|
Creating A Physics-Based Scroller |
Making your game engine based on Velocity, Acceleration, Friction, or other environmental variables instead of a uniform speed environment. (QB Cult Magazine #7)
| QbProgger |
|
Physics Engines Part 2 |
"Fighter Games In A Nutshell." A very short summary of a typical 2D fighting game algorithm. (QB Cult Magazine #8)
| QbProgger |
|
Map Engines: Zelda Style Free Movement and Pixel by Pixel Scrolling |
How to make your own pixel scrolling engine, like you see in Zelda-style adventure games. (QB Times #3)
| Maz (Greg McAusland) |
|
A Real Easy Pixel*Tile Engine Using Blast! |
How to create a simple RPG tile engine using the old Blast! graphics engine. Based on Tsugumo's RPG engine. (VSNews Aug. '98)
| 19day |
| Other Game Engine Tutorials |
| Link | Description | Author |
|
How To Program Text Adventures |
A nice tutorial covering many aspects of text adventure programming, such as the Parser, moving around your world, and usable objects to pick up.
| Terry Cavanagh |
|
PlatForm Engines 101 |
Creating a simple platform engine from a regular old pixel scrolling engine. (QBOA Issue 4)
| Necrolyte |
|
Finite State Machines For Fighting Game Design (Part 1) |
"A finite state machine (henceforth abbreviated FSM) is an automaton with a finite set of subroutines, each of which performs some function and then employs some criterion to choose the next subroutine to jump to. Each subroutine is called a "state", and the FSM is said to be in a given state when it is currently processing the directives in that state. A FSM can only be in one state at any given time." (QBOA Issue 11)
| Nekrophidius |
|
'Doom' 3D Engine Techniques |
A very thorough explanation of how Doom's raytracing engine works, as well as enemies, bullet trajectories and more. Includes little actual code, but gives a good theoretical explanation of the engine. (QB Times #9)
| Brian 'Neuromancer' Marshall |
|
Preliminary Particle Systems |
A source-code heavy introduction to creating simple particle systems for your game. This is useful for things like gunfire and explosion effects. (QBXL)
| SJ Zero |
|
Using Circle Routines As Title Screens |
A rather pointless tutorial on designing your own program title screen through CIRCLE statements. (BASIX Fanzine #16)
| Gloria McMillan |
|
Collision Detection |
A simple method of collision detection based on the pixel color of a sprite's outline. (BASIX Fanzine #4)
| Adrian Sills |
|
Heightmapped Landscapes |
Creating 3D landscapes from 2D color-coded images. A really neat technique. (QB Cult Magazine #17)
| Qasir |
|
Index Lists |
Using index lists (simple 'lists' of 'array subscripts') to speed up your game's object handling routine. Written specifically for shooting games with a lot of bullets to keep track of at once. (QB:TM #12)
| MA SNART |
| RPG Scripting |
| Link | Description | Author |
|
Realistic NPCs (Active vs Reactive) |
A theory article posted on a Usenet group that discusses how to make NPCs act more intelligent.
| Dan Shiovitz |
|
Scripting in QB |
How to make a very basic scripting engine for your RPG. Does not explain the theory behind scripting (or what you're really trying to achieve) -- just jumps right into the code.
| Kackurot |
|
Build Style Scripting |
An interesting scripting tutorial that explains how to incorporate scripting into an already well-developed game engine. Comes with a lot of source.
| SJ Zero |
|
Scripting And You |
A great explanation of how to make a scripting engine for your QB RPG. Includes sourcecode for a well-made scripting engine that is easy to understand.
| Michael Dowling (Typosoft) |
|
19Day's Scripting Tutorial |
Probably the first QB RPG scripting tutorial that came out, this one is still relevant. Covers a lot of theory and interesting ideas, and concludes with a list of command ideas you can use to improve your scripting engine.
| 19Day |
|
Smart NPCs |
Some theory and speculating on how to make NPCs in your RPG act intelligently. Includes only pseudo-code, but makes some interesting points.
| Dancer |
|
RPG Tutorial - Object Systems |
Increase the complexity and interactivity of your RPG engine by making every object in your world interactive -- for both the player and the NPCs to play around with. (QB Cult Magazine #5)
| QbProgger |
|
Script Engines |
19day's old scripting tutorial, reformatted by QBCM so that it's easier to read than the original text version. (QB Cult Magazine #7)
| 19day |
|
Object Systems! |
Introduction to creating an object system for your RPG. (QBOA Issue 1)
| QbProgger |
|
Writing Your Own Scripting Language |
One simple method of creating a scripting language for events in your game. (QB Times #1)
| Nightwolf |
|
Writing Your Own Scripting Language (Part 2) |
Expanding on the scripting engine described in part one: adding variables, equations, and a whole lot more. Lots of source.(QB Times #3)
| Nightwolf |
|
RPG Script Language |
Introduction to RPG scripting engines; handling NPC conversations and message boxes. (QB:TM #5)
| MA SNART |
|
BUILD Style Scripting |
Creating a script routine similar to the BUILD-Engine, which allows your NPCs or environment to react to your character based on pre-determined external scripts. (QBXL)
| SJ Zero |
|
RPG Dialogue Engines |
Create a simple NPC scripting engine using the instructions in this tutorial. Covers the theory behind scripting engines quite well. (VSNews Nov. '98)
| 19day |
| General RPG Tutorials |
| Link | Description | Author |
|
Medieval Economics |
An role playing game theory document that explains relative prices for different items in medieval Europe. Useful if you want to make your medieval RPG historically accurate (though historical accuracy usually makes games a whole lot more boring, heh).
| Phillip McGregor |
|
QB-RPG Techniques |
This tutorial takes an unconventional look at RPG-making. It explains techniques like creating your game map as a string array instead of an integer array, some theory behind improving your game's shops by adding the option to barter, and some neat under-used special effects.
| Tal Bereznitskey |
|
How To Make Your RPG Not Suck |
A rant that discusses many of the pitfalls of amateur (and some professional) RPGs. Has a lot of great ideas and theory on topics like storylines, NPC scripting engines, your tile engine and more.
| Frozen Emu |
|
Adventure Game Making : Episode 1 |
Incorporating good puzzle elements in your QB adventure game. (QBOA Issue 3)
| The Specialist |
|
Plots, characters, and bears Oh My! |
Eliminating the "Do this. Do that." interface of plot design in your QB RPG. (QBOA Issue 3)
| QbProgger |
|
RPGs Unravelled |
What you should do in the planning and story design stages of your RPG development. A game design theory tutorial. (QB Times #9)
| Nightwolf |
|
RPG Battle Design |
An article on designing fun RPG battle engines that will keep gamers interested. Covers a lot of theory over different styles of engines, and keeping your battles fresh and enjoyable. (QB:TM #11)
| Zkman |
|
RPG Story Writing |
How to improve your RPG's backstory, plot events and character interaction. (QB:TM #9)
| Zkman |
|
Plots, Characters and Bears! Oh My! |
Nine tips for making a non-cliched RPG. (QB Cult Magazine #7)
| QbProgger |
|
RPG Development, Part 1 |
Useful tutorial on creating highly-modular RPGs, either through scripts, subroutines, or CHAINing together several .bas files. Goes over some preliminary engine design code too. (QB Cult Magazine #12)
| Matt2Jones |
|
Creating Shining-Force-like Battle Engines |
Short introduction on making your own tactical battle engines in QB. (QB Times #7)
| Maxx |
|
Shining Force-like Battle Engines (Part 2) |
Covers character movement and restrictions to movement for your tactical battle engine. (QB Times #8)
| Maxx |
| Fling-master's RPG Creation 101 |
| Link | Description | Author |
|
RPG Creation 101 (Part 1) |
The beginning of Fling-master's great RPG series. This first part discusses standard RPG engines, and shows you how to make a simple tile engine. (QB Chronicles #1)
| Fling-master |
|
RPG Creation 101 (Part 2) |
Part 2 of a great series. This edition shows you how to expand your engine to accomodate NPCs into your RPG world. (QB Chronicles #2)
| Fling-master |
|
RPG Creation 101 (Part 3) |
Another expansion on the NPC engine. This explains how to make your NPCs walk around, talk, and react to your player. (QB Chronicles #4)
| Fling-master |
| RRC2Soft RPG Programming Tutorials Series |
| Link | Description | Author |
|
File 0: Graphic mode 320x200x256 |
An RPG programming series not specifically for QB, but it's VERY helpful, with lots of great examples. Includes a lot of ASM source code. This first tutorial covers things you should know before you start your game: segments and offsets, the 320x200x256 screen mode, the vertical retrace, virtual screens and source code.
| RRC2Soft |
|
File 1: Graphic Creation and Usage |
Covers sprites, useful graphics formats and the how you should go about creating sprites for your game.
| RRC2Soft |
|
File 2: Tiles |
Discusses the art / theory aspect of RPG sprites. Tells you what you should put in your tiles, how to compose a map, about animation, transparent tiles, palette rotation and more.
| RRC2Soft |
|
File 3: Maps & Their Problems |
How to make good tile maps. Also discusses movement flags, enemy encounters, plot events and more.
| RRC2Soft |
|
File 4: Script languages, compilers and Interpreters |
Making a scripting language for NPC conversations and RPG plot events.
| RRC2Soft |
|
File 5: Combats & Types of Combats |
CRPG Combat engines and their history -- Discusses dozens of different battle engines that have been used over the years in professional compuer RPGs. Analyzes the good and bad points of engines from Dragon Quest to Final Fantasy VIII.
| RRC2Soft |
| Submitted Game Design Tutorials |
| Link | Description | Author |
| Levi.doc |
Levi's Game Plot tutorial. An on going attempt at covering the vast number of elements one should consider when making a computer game. Just a general tutorial on basic plot line and character development, not in depth in any way. (QB Express #1) (Submitted by Levi on July 29, 2004) |
Levi |
| Scrolling Credits.txt |
Scrolling Credits!. How to make your credits scroll from the bottom of the screen and up off the top. (Submitted by Kevin on December 14, 2004) |
x.t.r.GRAPHICS |
| Dialogue and Character creation.doc |
Dialogue and Character Creation --Game Plot lines 2. Today I thought I'd finally update these tutorials and bring to you a very important concept. Dialogue. How is dialogues made? How does it push the story forward? I answer all of these questions and more in this tutorial. Enjoy. (QB Express #8) (Submitted by Levi on February 23, 2005) |
Levi |
|
|
Graphics |
| Beginners |
| Link | Description | Author |
| Animated Graphics in QBasic |
Using DATA statements to make graphics. Beginner stuff, loads of source. |
Mallard |
|
Game Tutorial Series - Graphics |
SCREEN, PSET, LINE, CIRCLE and DATA statement graphics, in a nutshell. (QB Cult Magazine #2)
| Provgamer |
| Graphics Tutorial |
A good beginners' graphics tutorial, including CIRCLE, LINE, PAINT, PSET, and SCREEN modes. |
Chris Williamson |
|
Graphics Tutorial on BASIC |
Take all the small graphics tutorials you've seen around and combine them, and this is what you get. Covers the basic built-in commands (LINE, DRAW, PSET, etc.), how to draw graphics with DATA statements, GET and PUT, using multiple pages, masking, editing the palette, BSAVE / BLOAD, fast palette and reducing flicker.
| Lucas K. Tavares |
|
Jonathon's Advanced Graphics Tutorial |
An overview of graphics programming in QB that covers some lesser-known techniques like using multiple pages in SCREEN 7, 8 and 9. However, this tutorial is hardly "advanced".
| Jonathon |
|
Screen 13 Graphics |
Introduction to Screen 13 and plotting pixels with POKE rather than PSET. (BASIX Newsletter #1)
| Screech |
|
Screen 13 Graphics Part 2 |
Includes ASM and Blast! routines for plotting a pixel, and information on manipulating the RGB Palette. (BASIX Newsletter #2)
| Screech |
| Sprites |
| Link | Description | Author |
| Mode 13 VGA GET/PUT Information and Techniques |
THE tutorial on using GET and PUT, along with DIMing your graphics. |
Andrew L. Ayers |
| GIF 2 BSV |
Learn how to convert a .gif to a BSAVE file, which makes loading much faster. |
James Kurth |
| Bsaving and Bloading in QBasic |
BLOAD and BSAVE in EGA/VGA |
Mallard |
| Sprites #1 |
Part 1 of an In-depth tutorial on making and plotting sprites. |
Unknown |
| Sprites #2 |
Part 2 of the sprite tutorial -- BSAVING, BLOADING, masking and more. |
Unknown |
|
QB Graphics Tutorials |
Graphics arrays, GET and PUT. This tutorial is nicely-formatted and comes with a lot of code examples.
| RokFOX |
|
Sprites in QBASIC |
Covers the basics you'd expect, but also goes into things like page flipping, transparency and clipping. Additionally, this includes source code for "Making a new PUT", a pure QB improvement over the native PUT statement.
| Ted Felix |
|
Saving and Loading Graphics in Binary Mode |
Explains "What's wrong with BSAVE and BLOAD" and teaches you some simple binary graphics saving and loading techniques.
| Lior Zur |
|
GET.BAS |
A well-commented program that introduces sprite graphics, GET and PUT and WAITing for the vertical retraice.
| Matt Bross |
|
CHARN's QBasic Tutorial, Part 1 |
Brief explanation of screen modes and GET and PUT.
| CHARN |
|
QBasic Graphics Tutorial |
Sprites through DATA statements, then making a tile map with your shiny new graphics.
| James Kinney |
|
Beginning Sprites |
Explains several key aspects of drawing animated sprites. Includes animated graphical examples. (QB Cult Magazine #9)
| Rancid |
|
Getting and Putting Graphics |
A thorough article on storing images in numeric arrays, and manipulating their appearance (such as "flipping", rotating, or changing colors in an image). (QBNews Vol. 1 No. 2)
| Frederick Volking |
|
Manipulating Sprites in Screen 13 |
A GET and PUT introduction, as well as information on how to mirror (flip) sprites and a few other techniques. (QBNews Vol. 2 No. 3)
| Fred Sexton Jr. |
|
Power Programming: Sprite Management |
Covers several essential skills on sprite management that you might have missed; how to dimension proper arrays, store multiple sprites in a single array, BLOAD and BSAVE, VARSEG And VARPTR and some other topics. Useful stuff! (QB:TM #10)
| Seav |
|
Saving A Graphic in Screen 13 |
Introduction to BSAVE and BLOAD, as well as video addresses, VARSEG and VARPTR. (BASIX Fanzine #4)
| James Erickson |
|
GET...PUT For Beginners |
Introduction to using GET and PUT for Screen 13 graphics. Covers masking, buffers and arrays too. (QB:TM #3)
| NetherGoth |
| Palette and Colors |
| Link | Description | Author |
|
Controlling The Palette in QuickBasic |
Very well-written tutorial on palette manipulation, including instructions on fades and various eye-pleasing color effects. (QB Cult Magazine #5)
| Terry Cavanagh |
|
EGA Color Layout (Base 16 Colors) |
An insightful explanation of the sixteen standard, "base" colors available in QB. (QB Cult Magazine #17)
| Nexinarus |
| How To Do A Good VGA Palette |
A good tutorial on using RGB values to set the palette. Lots of source. |
abionnn |
|
How To Save and Load Screen Colors |
Changing the palette without the PALETTE command, and saving / loading your own custom palette.
| JMB |
|
Million-Color Palette for IBM PC |
Explains the basics of computer color theory, and how to manipulate colors in several different screen modes. This information applies to all versions of BASIC.
| John and Jeff Klein |
|
The Palette in QB |
Explains the basics of palette manipulation through OUT and such (the standard way of doing this, it seems), and also includes a nice explanation of how to do translucency effects, which is very helpful. (QB Chronicles #2)
| Fling-master |
| Palette Tricks By Zkman |
*Another* palette tutorial. This one was featured in QB:TM. Contains some great info on doing translucency by using a lookup table. |
Zkman |
|
Palettes in QBasic (Part A) |
Basics of Palette manipulation, and how to speed it up through interrupts. (BASIX Fanzine #6)
| Joe Lawrence |
|
QB's Palette |
All about adjusting QB's palette...without the PALETTE statement. Includes some sample programs that demonstrate some of the neat tricks you can achieve through palette rotation.
| James Kinney |
|
Saving The Pallete With Your Sprites |
How to save the palette along with the BSAVE image data into one image file. (QB:TM #11)
| Nekrophidius |
|
Understanding The VGA Palette |
A standard introduction to editing the color palette in QB. This one also includes instructions on doing palette fades and gradients. (QB Cult Magazine #1)
| Matthew R. Knight |
| The VGA Palette, QBasic, and You |
A palette tutorial. Very nice, and in-depth. Lots of source |
Brian Bartels |
| Animation |
| Link | Description | Author |
| BMP Slideshow Animations |
Learn how to animate a series of BMP images with this tutorial. A nice example of how to do a cinematic-type sequence in QB. |
Unknown |
| Waiting For The Vertical Retrace |
A small tutorial discussing one method of reducing flicker in your program. Teaches you how to wait for the Vertical Retrace. |
HAL_8900 |
|
Generating Animations Using QBASIC |
Covers the fundamentals of animation in QBASIC. This is for absolute beginners.
| Peter Smith |
| 3D Graphics |
| Link | Description | Author |
|
3D in QB |
An introduction to how three dimensional graphics work, and some short code examples. (QB Times #2)
| BlackBird |
|
3D Graphics |
Introduction to creating 3D graphics and objects in commercially-available 3D rendering software. (QB Times #7)
| Nightwolf |
|
3D Graphics (Part 2) |
Using Extreme 3D to design and render your first 3D graphics. (QB Times #8)
| Nightwolf |
|
3D Graphics In BASIC: Part I |
Introduction to basic three-dimensional (X,Y,Z) math and 3D transformations. (BASIX Fanzine #4)
| Christian Garms |
|
3D Graphics In BASIC: Part II |
Introduction to 3D animation, moving objects and rotating objects. Covers other topics too, such as double buffering. (BASIX Fanzine #8)
| Christian Garms |
|
3D Graphics Rendering, Part 1 |
Explains shading the colors of 3D objects based on the arithmetic mean. Mostly pseudo-code. (BASIX Fanzine #13)
| Damien Nikodem |
|
3D Tutorial |
A short tutorial accompanied by a 3D utility program with some valuable code examples that can help introduce you to 3D graphics. (QBXL)
| Xerol |
| 3D Tutorial For QBasic |
A huge 3D graphics tutorial with a TON of source. This goes into a lot of depth, covering advanced material like raycasting and 3D shading. |
Matt Bross |
|
BASIC Guide to 3D Programming |
Covers the very basics of 3D programming, with an introduction to 3D space. This tutorial shows you how to draw a 3D cube.
| Chronomaster |
| The Basics of 3D Graphics For QBasic |
A great tutorial on 3D graphics in QB with source. Includes an intro to 3D objects, and then shows how to create and rotate basic 3D shapes! |
Aaron Severn |
|
Faster 3D Rotation |
Optimizations to the standard 3D rotating formulas that will save you some processing time. (QB Cult Magazine #5)
| Eclipzer |
|
Hidden Surface Removal for Three-Dimensional Drawing |
Removing hidden / unnecessary surfaces when rendering your 3D graphics to save processing speed and prevent graphical glitches. (QB Times #8)
| Matthew R. Knight |
|
Introduction to 3D Series #1 |
A user-friendly introduction to 3D space, with several essential equations, but very little actual sample code. (QB Cult Magazine #3)
| Matthew R. Knight |
|
Introduction To 3D Series #2 |
Rotating 3D objects, then plotting them on the screen. (QB Cult Magazine #4)
| Matthew R. Knight |
|
Implicit Surface Polygonization |
A short article explaining how to polygonize implicit surfaces: "The surface is not defined explicitly (as in polygons), or parametrically (as in spline grids), but rather, well, implicitly. Basically, you have a function f(x,y,z) which is 0 for any point on a closed surface, negative on the 'inside' of that surface, and positive on the 'outside'." (QBOA Issue 4)
| Logiclrd |
|
Jian2587's Raycasting Tutorial |
Well-written tutorial covering only the basics of raycasting. A good introduction -- read this before moving on to the other raycasting tuts. Includes some useful text diagrams.
| Tze Jian Chear |
|
More About Shading, Z-Buffer and Textures |
Improve your 3D game program through Gouraud shading, adding textures, Phong shading and more. This is not a QB tutorial, but includes examples in both pseudo-code and ASM.
| Karma |
|
One Approach to Real Time Texture Mapping |
Shows you how to apply textures to 3D objects...discusses texturing true polygons as well as raycasters. Unfortunately, the diagram images are missing.
| William D. Doughty |
|
Perspective Projection |
A great explanation of the mathematics behind 3D graphics, including several text diagrams. Well-written and easy to understand!
| Toshi Horie |
|
Raycasting In QBasic |
A tiny tutorial that introduces you to making "a game like DOOM." The majority of the content is in the included .bas file. (QB Cult Magazine #4)
| William Moores |
|
Raycasting Tutorial |
A seven-part tutorial, which shows the evolution of a raycaster. Starts with the absolute basics, then builds on them by gradually improving the program, step-by-step. A great series -- highly recommended!
| Joe King |
|
Taking the Convex Hull of a Set of Points |
"The convex hull of a set of points is the smallest convex polygon containing all of the points. This is a helpful thing to know when creating isosurfaces, and a bunch of other shit." (QB Cult Magazine #8)
| EvilGeek |
|
Texture Mapping Mathematics |
This document explains the formulas that are used to perform texture mapping for a polygon. The (small amount of) source code included is for a Linux system, but the majority of the document is a listing of useful texture-mapping formulas and equations.
| Jorrit Tyberghein |
|
Why Divide By Z? |
An excellent explanation of the process of "perspective projection" along the Z-axis in your 3D programs. (QB Cult Magazine #5)
| Toshi Horie |
|
Zed3D: A Compact Reference For 3D Computer Graphics Programming |
A 115-page book that discusses all aspects of 3D graphics programming. Covers everything you could ever need to program a 3D game, though much of the information is incredibly advanced-- by no means meant for beginners.
| Sébastien Loisel |
| 2D Graphical Manipulation / Effects |
| Link | Description | Author |
|
Coderz Series: Plasma |
Creating plasma effects through sine waves. (BASIX Fanzine #6)
| Peter Cooper |
|
Coderz Series: The STATIC Effect |
Creating a static effect, like what you see on your TV when you're having bad reception. (BASIX Fanzine #7)
| Peter Cooper |
|
2D Graphics Rotation |
Rotating two-dimensional sprites. Very handy tutorial. (BASIX Fanzine #9)
| Alex Warren |
|
Fractals With QB - Part 1 |
A good explanation of what fractals are, with a lot of graphics and diagrams. Some of them are even animated. This tutorial contains no source code. (QB Cult Magazine #15)
| Jark |
|
Fractals With QB - Part 2 |
The meat and potatoes of fractals -- how to create your own in QB. Also discusses raytracing of fractals. Includes source code and some amazing screenshots. (QB Cult Magazine #16)
| Jark |
|
Puzzle Effect Explained |
How to create a cool "swipe" effect, as seen on the Windows installation screen. (QB Cult Magazine #16)
| RelSoft |
|
Plasmas Revealed |
An explanation of how to make plasmas using both palette rotation and functional trigonometry. (QB Cult Magazine #17)
| RelSoft |
|
2-Dimensional Rotation |
Short and sweet tutorial on rotating 2D sprites. (QB Cult Magazine #5)
| Matthew R. Knight |
|
How To Create A Ripple Effect |
Making your 2D graphics "ripple" out from a point. A cool effect. (QB Cult Magazine #7)
| Zap |
|
Lines With Style |
Using the "FUSION" routines to create cool plasma and "energy" effects. (QBNews Vol. 2 No. 3)
| Larry Stone and Charles Graham |
|
Bumpmapping |
Introduction to creating bump texture / light effects in QuickBasic. (Razor Diskmag #1)
| Entropy |
|
Binding Sprites to Sinewaves |
Creating a "wave" animation effect on sprite-based QB games. (QBXL)
| SJ Zero |
| Coding Your Own "Fire" Routines |
The basics of doing the grandfather of all graphics routines, the FIRE algorithm! |
Phil Carlisle |
| Pixel Morphing |
Tutorial on pixel morphing. |
Terminator_Z |
| Crossfading |
Tutorial on crossfading |
Terminator_Z |
|
QB Rotation Primer |
A well-written explanation of how to rotate graphics in QB, as well as change their scale, or perform other "math tricks". Essential for the graphics demo coder, but also valuable to anyone who wants to incorporate Mode 7 (SNES) style sprite effects in their game.
| Toshi Horie |
| Pixel Art |
| Link | Description | Author |
|
Beginning Tile Graphics |
A pixel art tutorial on how you should go about designing your sprites to fit together seamlessly in a grid. (QB Cult Magazine #11)
| Rancid |
|
Pixel Art |
Step-by-step explanation of how to make a 16x16 RPG character sprite. A good template if you've got to make a lot of NPCs for your RPG.
| Hungry |
|
So You Want To Be A Pixel Artist? |
Tsugumo's famous eleven-part tutorial series covering all aspects of pixel art for videogames. Full of great sample images, well-written, humorous, insightful and incredibly helpful. This has a heavy focus on RPG and 2D fighting game sprites. The BEST tutorial series I've ever seen. Must see! (This is an external link to Tsugumo's site, since the tutorial is almost 3MB in total.)
| Tsugumo |
|
Tesselations |
A brief look at creating sprite-based tesselations. ("Tessellation" is the name for systems of interlocking geometric forms or shapes which fill the entire surface of the screen (or tile, or quilt, or other flat plane) without overlapping and without any gaps.) This is useful for making interlocking repeated tiles for your RPG's map.
| Tsugumo |
| Graphics File Formats |
| Link | Description | Author |
|
BMP's Explained |
Shows you how to load Windows-format BMPs in QB. (QB Cult Magazine #12)
| Golrien |
|
File Formats: BMP |
A very thorough explanation of the bitmap file format. If you're planning on making a BMP loader, this will come in handy. (QB Times #1)
| Unknown |
|
File Format: GIF 89A |
All you'll ever want to know about the GIF file format. (QB Times #4)
| CompuServe, Inc. |
|
File Format: PCX |
Explanation of the PCX image file format. (QB Times #4)
| ZSoft Corp. |
|
Loading BMP Files in QBasic |
A step-by-step tutorial on loading BMP image files in QB. Includes speed optimizations through interrupts.
| CGI Joe |
| SVGA Graphics |
| Link | Description | Author |
|
SVGAQB Tutorial (Part 2) |
Part two of Digital Dude's tutorial series on using the Zephyr SVGA library. (QBOA Issue 2)
| Digital Dude |
|
SVGA Programming |
A short introduction to graphics screen modes and Super VGA programming. This tutorial barely scratches the surface, but includes quality source code. (QB Chronicles #4)
| Fling-master |
|
Using ZSVGA (Part 1) |
Zephyr's SVGA Lib is a full-featured lib for QuickBasic with great SVGA functions. This will show you how to use it...or at least give you an introduction. (QBOA Issue 1)
| Digital Dude |
|
VESA BIOS Core Function Standards (PDF) |
Specification documents for SVGA programming and VESA BIOS chips. A resource for really smart programmers. :)
| VESA |
| VESA Super VGA Standards |
The SVGA specs, straight from VESA. Know what you're doing before reading this. |
VESA |
| Apester's Sprite Editing Series |
| Link | Description | Author |
|
Part 1: Sprite Editing & Theory |
An introduction to sprite editing and graphical arrays using DATA statements.
| Apester |
|
Part 2: More On Sprite Editing |
Discusses BLOAD and BSAVE, sprite masks and other miscellaneous sprite techniques.
| Apester |
|
Part 3: A Decent Sprite Editor |
What to look for in a sprite editor and how to save and load the sprites created by your editor. This tutorial tailors to Apester's own sprite editor, ApeDraw.
| Apester |
|
ApeDraw |
Apester's sprite editor, which is discussed in this tutorial series.
| Apester |
| Aaron Severn's SVGA Series |
| Link | Description | Author |
|
SVGA Series: Part I |
An introduction to VESA SVGA standards, and then using SVGA screen modes in QB. (QB:TM #1)
| Aaron Severn |
|
SVGA Series: Part II |
A continuation of Aaron Severn's SVGA series; covers topics like direct color modes, page flipping and bank switching. (QB:TM #2)
| Aaron Severn |
|
SVGA Series: Part III |
Some appendices; VESA VGA BIOS Extension function reference, VESA defined screen modes, Required TYPE definitions and descriptions and more. (QB:TM #3)
| Aaron Severn |
| Damien Nikodem's Graphics Series |
| Link | Description | Author |
|
Graphics In QBasic Tutorial (Part 1) |
Explains how to use the palette and plot pixels using interrupts. (BASIX Fanzine #10)
| Damian Nikodem |
|
Graphics In QBasic Tutorial (Part 2) |
A brief summary of the PCX image file format. (BASIX Fanzine #11)
| Damian Nikodem |
|
Graphics In QBasic Tutorial (Part 3) |
Discusses "randomic algorithms" -- creating graphical effects based on random variables. There is an example on how to make a random number grass routine included. (BASIX Fanzine #12)
| Damien Nikodem |
| Gavan's Pixel Art Series |
| Link | Description | Author |
|
Pixel Art Series #1 |
The Dark Ages 2 graphics artist provides an introduction to pixel art theory, and covers topics like shading, texturing and creating metallic / chrome effects. (QB:TM #10)
| Gavan |
|
Pixel Art Series #2 |
Instructions on doing many common graphic effects in pixel art: bump, diffusion, extrusion, pattern, and specular mapping; transparency and refraction effects; dithered or hue/value transparency; true refraction and pseudo-refraction; and more. (QB:TM #11)
| Gavan |
|
Pixel Art Series #3 |
Discusses seamless tiling and eliminating that "grid" look on your sprites. (QB:TM #12)
| Gavan |
| QB:TM 3D Series by MA SNART and Alias |
| Link | Description | Author |
|
3D Series: Part 2 |
Translation and rotation across 2D planes. Includes quite a bit of source. (QB:TM #7)
| MA SNART |
|
3D Series: Part 3 |
ASTEROIDS as a primer to 3d; make your own 3D "Asteroids" clone. Includes source and a lot of commentary. (QB:TM #8)
| MA SNART |
|
3D Series: Part 4 |
An introduction to an alternate 3D graphics method: voxels. (QB:TM #9)
| Alias and MA SNART |
|
3D Series: Part 5 |
Brief introduction to creating voxel-based 3D landscapes, and then a summary of other methods of creating 3D environments. (QB:TM #10)
| Alias |
|
3D Series Part 6: Interpolation For Dummies |
Using list voxels and editors to create 3D environments with voxels. (QB:TM #11)
| Alias |
|
3D Series Part 7: Voxel Render Problems |
Explains how to solve problems that might occur when rendering voxel graphics, such as solidity issues, hollowness, etc. (QB:TM #12)
| Alias |
| Misc. |
| Link | Description | Author |
|
Beginner's Guide To VARSEG and VARPTR |
Shows you how to use VARSEG and VARPTR. Unlike most tutorials, it actually shows you how these commands work so you understand, instead of just giving you example code that uses the commands. (QB Chronicles #1)
| Fling-master |
|
Double Buffering |
Speeding up and smoothing out your graphics without the use of external libraries through the process of double buffering. (VSNews Jan. '99)
| Richard Russo |
|
Graphical Memory |
Virtual screens, memory addressing and more. Lots of good stuff on dealing with bitmap graphics in QB. (QB:TM #8)
| WhiteShadow |
|
Page Flipping in 13h |
One method of page flipping in Screen 13 -- which isn't a built-in function of QB like on other screen modes (ie: 7). This is a work around to the limited array sizes allowed by QB. (QB Cult Magazine #1)
| Matthew R. Knight |
| Tutorial For OUT, PEEK and POKE |
A good tutorial for using OUT, PEEK, and POKE in your programs. |
Danny Beardsley |
| Submitted Graphics Tutorials |
| Link | Description | Author |
| bsave.txt |
QBasic BSAVE Files. Shows you how to BSAVE and BLOAD graphics in Screen 13, and discusses memory offsets. (Submitted by Pete on July 21, 2004) |
Tek |
|
|
Sound |
| Link | Description | Author |
| DMA Play 5 |
If you want to play .wav files in your program, take a gander at this. This program can play 8-bit and 16-bit .wav files in both mono and stereo! |
Mike Huff, Martin Rampersad & Toshi Horie |
|
DMA Play 6 |
The newest version of the acclaimed QB WAV player.
| Toshi Horie |
|
DMA WAV |
A well-commented WAV player for QB. Reading over this program can give you a good understanding of the .WAV file format and how to create SoundBlaster sound effects.
| Ken Rockot |
|
Play.bas |
A good explanation of how to use the PLAY command, which is presented through a well-commented example program. This plays "All Apologies" by Nirvana.
| Mallard |
|
Music, Sounds, ON PLAY and Using the Soundcard |
A good overview of creating sound / music with QB's built-in sound statements. Toward the end, it goes into some more advanced topics like using the soundcard and the microphone.
| Anastasios Yalanopoulos |
|
Programming the SoundBlaster Card |
An introduction to programming the SoundBlaster and using the DSP (Digital Sound Processing chip). Gives the basics you'll need to play WAV, VOC or RAW files. (BASIX Fanzine #1)
| Peter Cooper |
|
Manipulating Sound In QBasic |
An old tutorial posted on a BBS with a wealth of information on using interrupts to play sound on both a soundcard and the internal speaker. (QB Cult Magazine #3)
| Edward Schlunder |
|
Soundcard Special |
How to program the Soundblaster Card, and an explanation of the MIDI file format. (QB Times #2)
| Nightwolf |
|
Making a basic GDM player |
Using BWSB's GDM sound format can be a pain -- but this tutorial will make it easy. (QB Times #3)
| Nekrophidius |
|
BWSB Revealed: Sound Effects |
Using the BWSB (Bells, Whistles and Soundboards) library to add complex sound effects into your QB program. (QB Times #4)
| Nekrophidius |
|
MOD Player Tutorial |
Create your own MOD audio player in QB. (QB:TM #11)
| Bill McDonald |
| MIDI Composing |
| Link | Description | Author |
|
MIDI Composing |
Be Mozart, thanks to 19day. An introduction to MIDI composing and the MIDI file format. (QB:TM #7)
| 19day |
|
MIDI Composing: Part II |
A continuation of this MIDI composing tutorial, with information on composing with WinJammer, and then a bit about putting them into your game. (QB:TM #8)
| 19day |
|
Basics of Tracking: Part One |
"For those of you unfamiliar with the term "tracking", in this sense, it refers to digital music creation. This is not a tutorial on how to make a MIDI, if you want that, go elsewhere. This is merely an informational article on a different style of music format that has been gaining popularity in the QB gaming world in the last years." (QBOA Issue 7)
| Nekrophidius |
|
Basics of Tracking: Part Two |
The second part of this series on Tracking. This explains how to make your own songs using the shareware program Modplug. (QBOA Issue 8)
| Nekrophidius |
| Submitted Sound Tutorials |
| Link | Description | Author |
| (No tutorials submitted yet.) |
|
|
Miscellaneous |
| Link | Description | Author |
| ABC Packets FAQs |
All of the FAQs (frequently asked questions) from the ABC packets. Lots of good stuff here. |
Various |
| Frequently Asked Questions: QBasic |
Many different programming examples, very useful. |
W.M. Bergmann (editor) |
| BIOS Calls in QuickBasic |
Ever wanted to program your BIOS through QB? Read this. |
Aaron Severn |
| Bits |
A good explanation of BITs and BYTEs. Includes source |
Ximmer |
| Computer History Up To 1952 |
A history of the computer up to 1952. Not really relating to QB, but you should still read it. |
Mark Brader |
| Compiling |
A tutorial that shows you how to split up and link together .bas files when your program gets too large to compile. |
WisdomDude |
| Segments and Offsets |
Segments and Offsets explained. Short. |
Milo Sedlacek |
| PC Magazine's POKEs & PEEKs |
An excellent and in-depth article on using PEEK and POKE. This one is unique because it contains info on not just using PEEK and POKE for graphics, but also for accessing just about anything on your computer! (From PC Magazine.) |
David I. Schneider |
| TSR Programming in QuickBasic |
Explains how to write a TSR (Terminate and Stay Resident) program in QB, which is useful because DOS can't run more than one program at once. TSRs are a work-around. |
G.M. McKay |
|
QB Error Codes |
A list of all the QBasic / QuickBasic error codes that you might face while debugging.
| Microsoft |
|
Appending Data to a .EXE File |
This tutorial explains how you can append a data file, such as BMP, to the end of a compiled QuickBasic program (an EXE file) and have the program access it when it's running.
| Dav |
|
QB Mini Encyclopedia |
Hur's famous QB Mini Encyclopedia. It has more than 50 QB tutorials that Hur found interesting, and comes with a custom GUI program for viewing the tuts. Useful, but many of the topics discussed have since been covered by better tutorials.
| Hur |
|
Building a Compiler |
An extremely brief look at making your own compiler. For beginners.
| Brenden Homan |
|
Copyrights |
How to protect your intellectual property through copyrights. Teaches you what you need to do to ensure that someone else can't steal your code.
| Antony Chesworth |
|
Bit Manipulation |
Doorknob Software explains how to change values on a binary level. This tutorial focuses on changing colors on a bit-by-bit basis, but the information applies to all binary values.
| Doorknob Software |
|
Using Interrupts in QuickBasic |
An overview of how to use interrupts. Includes several examples and then culminates in an interrupt BMP loader program.
| CGI Joe |
|
Using QBASIC to "Prepend" to All Lines in a File |
"QBASIC allows a straightforward solution to the problem of how to add any desired text to the beginning of all lines in a file."
| Unknown |
|
Simple Physics Programming |
A collection of small programs and formulas which simulate various physics effects like wheel skidding, bullet trajectories and car braking.
| Twisted Matrix |
|
The Matrix Tutorial |
"This program uses basic Matrices with the traditional two for-next loops to display rows and columns." A .BAS program with a built-in tutorial.
| Truth and Reconciliation |
|
PEEK, POKE, Memory Management and I/O Ports |
Covers BSAVE and BLOAD, PEEK and POKE and much more. This also teaches you memory commands like DEF SEG, FRE, SADD, SETMEM and CLEAR. I/O commands discussed include INP, OUT, Peek and Poke. The three V's are also discussed: VARPTR, VARPTR$ and VARSEG. Many more commands are covered too. This tutorial covers a ton of random commands, so it's hard to summarize in a few lines. Check it out!
| Anastasios Yalanopoulos |
|
How To Compute Planetary Positions |
A collection of formulas and algorithms to compute elliptical orbits, adjust orbits based on gravity and to mimic the orbits of all the planets in our solar system. Good for making space shooter games, and these formulas can be used to plot the "orbits" of anything, including enemies and bullets.
| Paul Schlyter |
|
Advanced Speed Optimization Techniques for QB |
This has some great tricks for speeding up your program, such as unrolling loops, code movement, precalculated numbers and constants, variable caching, POKE over PSET, and a whole lot more. Highly recommended!
| Toshi Horie |
|
QuickBasic Summary |
A brief outline of just about everything you need to know about QB. It's more of a cheat sheet / reference document that can refresh you on various commands and how to use the GUI. This covers EVERYTHING, but is not thorough at all.
| Prof. Nam Sun Wang |
|
Intermediate Programming Tips (Part 1) |
Discusses user-defined variable types and screen swapping in various screen modes. (BASIX Fanzine #12)
| Alex Warren |
|
Long Filenames From DOS |
Avoiding "Bad Filename" errors when you try to load long Windows filenames in your QB programs. (BASIX Fanzine #11)
| Alex Warren |
|
Including Files In EXEs |
Explains how to append binary files to the end of your EXE programs for use within the program. (BASIX Fanzine #12)
| Ollie Cook |
|
Data Manipulation Tutorials, Parts 1 & 2 |
Part 1 explains many data encryption techniques, including Bit Shifting and Bit Switching. Part 2 explains how to create your own file format, and the basics of reading and decoding other peoples' file formats. (BASIX Fanzine #13)
| Damien Nikodem |
|
Heuristics For A Self-Organizing Sequential File |
Theory article describing what a program must do to self-organize a sequential file, instead of always re-creating files start-to-finish. (BASIX Fanzine #13)
| RudeJohn |
|
Basiliar Data Types |
Covers the various different types of variables available in QB, the advantages and disadvantages of each, and how to use them effectively. Goes into great depth. (BASIX Fanzine #16)
| Unknown |
|
Fast Read From A File |
Explains a quicker way to open binary data files in QB -- instead of byte by byte, you can now open them faster by using a buffer. (BASIX Fanzine #16)
| Thomas Laguzzi |
|
Sleep Via Interrupt |
Mimic the native QB SLEEP command with ASM code and interrupts which will not fill up your buffer. (BASIX Fanzine #16)
| Thomas Laguzzi |
|
Manipulating External Files |
Explains how to use external data files in great depth. Covers OPEN, INPUT, OUTPUT, RANDOM, BINARY, APPEND, LINE INPUT, GET, PUT, EOF and LOF...and more. Very useful! (BASIX Fanzine #17)
| Chris Neth |
|
Formatting Text Into Checkese |
Tutorial on writing out numbers in English text. "Checkese" is taken from the word "check", because we write dollar amounts in both English text and numbers in order to prevent banking mistakes. (BASIX Fanzine #17)
| The Math Wizard |
|
Reading The CMOS |
Accessing the CMOS to determine how much memory your computer has, especially if your BIOS returns the wrong amount. (BASIX Fanzine #2)
| John Woodgate |
|
All About ANSI |
An introduction to ANSI (American National Standards Institute) codes, which are used for controlling output on a remote computer. A thorough introduction. (BASIX Fanzine #3)
| Ben Ashley |
|
Binary Tree Search |
Part of the Wrox Press's QBasic book, this tutorial discusses searching through pyramid-ordered data sets. (BASIX Fanzine #3)
| Adrian Sill |
|
Rant: Advanced Math Vs. Programming |
How much math do you need to know to be a good QB programmer? This tutorial also does a good job of explaining how to use the oft-misunderstood logical operators AND and XOR. (QB Chronicles #3)
| Singsong |
|
To All Space Wasters Out There |
Some simple ways to decrease the file size of your finished QB programs, for people with limited bandwidth or harddrive space. (QB Cult Magazine #14)
| Sane |
|
Making A Formatted Text Viewer Using DQB - Part 1 |
Instructions on making a readme viewer for your QB program, in case you want to include documentation or a help file for your user to read. (QB Cult Magazine #15)
| Zap |
|
Object Oriented BASIC - Possibility or Pipe Dream? |
Pseudo-code rich article on treating BASIC programming as if it were object-oriented. An interesting and insightful read. (QB Cult Magazine #3)
| Unknown |
|
Coding A Compiler Series #1 |
A brief overview of how to make your own compiler. It briefly covers many important elements of a compiler, with source code examples of an very simple compiler. (QB Cult Magazine #4)
| Gabriel Fernandez |
|
Using The FPU |
"The FPU is a math processor inside your computers processor. Early computers had an external FPU processor, unlike today." This tutorial tells you how to make use of the FPU, with the help of a little bit of assembler. (QB Cult Magazine #6)
| Frej |
|
Introduction To Trigonometry |
Your introduction to SIN, COSINE and TANGENT, as well as the Pythagorean Theorem...and more. Some basic math that is absolutely essential for any type of advanced programming. (QB Cult Magazine #7)
| Matthew R. Knight |
|
Errorcodes, Long File Names, and Other Neat Tricks |
Two unrelated topics discussed in one tutorial: Errorlevels and using "Long" (Windows) filenames in QB. (QB Cult Magazine #8)
| Christopher Charabaruk |
|
Appending Data To Your .EXEs |
"Sometimes, you'll want to have certain data for your program that you don't want to put into a seperate data file (configuration info, CRC signiture for the program part of the executable or other files, etc.). There is a method to check data at the end of your program's .exe file, and to write to it too." (QB Cult Magazine #9)
| Chris Charabaruk |
|
The Printer Is Your Slave! |
Printing text on to your printer using LPRINT. This also discusses more advanced options like outputting italics or underlined text. (QDF #2)
| Lord Acidus |
|
The Boolean Hell |
Boolean logic in QB. Explains AND, OR and XOR, as well as how binary numbers work. (QDF #2)
| Lord Acidus |
|
Face Lift: Signed Variables |
Improving the speed of your program through signed number variables (ie: integers instead of floating points). Helpful and well-written. (QDF #2)
| Lord Acidus |
|
Booting Your Computer |
A look at what happens to your computer when it boots, and some methods to reboot your computer through QB. (QDF #3)
| Lord Acidus |
|
"My Mind Is Going..." |
Using COMMONs and CHAINs to "dump" data and share it between several different programs / modules. (QDF #4)
| Lord Acidus |
|
Warping The CPU |
How to physically modify the annoying internal PC speaker. This tutorial explains how to add a volume control, a headphone jack and an on/off switch. It even explains how to attach a stereo...but I don't know why you'd want PC speaker music playing on your stereo. :P (QDF #4)
| Lord Acidus |
|
QuickBasic Directories |
How to do directory searches in QB by utilizing DOS directly via Interrupt. (QBNews Vol. 1 No. 1)
| Hector Plasmic |
|
QuickInsert Sort Algorithm |
Explains how to use and improve upon the free Microsoft QuickSort program, which comes packaged with QuickBasic. (QBNews Vol. 3 No. 1)
| Larry Stone |
|
Using Stub Files to Reduce EXE Size |
"Microsoft BASIC Professional Development System version 7.1 comes with many 'stub' files to help reduce the size of your EXE programs. By linking with these stub files under certain conditions, you will see reductions in EXE size of 2 - 15K." (QBNews Vol. 3 No. 1)
| David Cleary |
|
File Types 100 |
"This article will familiarize beginners to computer programming and the QuickBASIC programming language with the basics of file creation and a brief on the types of files generally used in computer programs." (QBNews Vol. 3 No. 2)
| Richard Vannoy
| |
Indexing 101 |
The basics of file indexing. (QBNews Vol. 3 No. 2)
| Richard Vannoy
| |
Using The PSP |
Using COMMAND$ and interrupts to look at the PSP (Program Segment Prefix); useful if you'd like to load your programs from DOS using command line switches. (QBNews Vol. 1 No. 2)
| Hector Plasmic |
|
Using The DOS EXEC Function From QB |
Receiving ERRORLEVEL messages from DOS's SHELL command. Requires assembler. (QBNews Vol. 1 No. 2)
| Harold Thomson |
|
The Speedy INSTR Function - Programming a Backwards INSTR Routine |
Searching a string for a sub-string using the INSTR function instead of a FOR...NEXT loop. (QBNews Vol. 1 No. 2)
| Larry Stone |
|
Directory Swapping |
Using interrupts to return users to the proper DOS drive and subdirectory when they exit your program. (QBNews Vol. 1 No. 3)
| Hector Plasmic |
|
Fast File I/O in QuickBasic |
How to speed up the saving and loading of large disk data files. (QBNews Vol. 1 No. 3)
| Ethan Winer |
|
Using Stay-Res Plus to make TSR's |
Using Stay-Res Plus by MicroHelp to create terminate-and-stay-resident QB programs. (QBNews Vol. 1 No. 4)
| Larry Stone |
|
Peeking at DOS with P.D.Q. |
Using Crescent Software's P.D.Q. program to create TSR programs in QB. (QBNews Vol. 1 No. 4)
| Ethan Winer |
|
Format Floppy Disks With QB |
The basics of formatting floppies with QuickBasic. (QBNews Vol. 1 No. 5)
| Cornel Huth |
|
Making a Self-Cloning EXE in QuickBasic |
How to create an EXE file that "clones" information to itself by creating a "recognizable" area inside of the EXE itself that can be quickly read and modified. (QBNews Vol. 1 No. 3)
| Larry Stone |
|
Self-Cloning EXE's Revisited |
A follow-up to Larry Stone's QBNews Vol. 1 No. 3 article on self-cloning programs. Goes into more depth, and helps with troubleshooting. (QBNews Vol. 1 No. 5)
| Ronny Ong |
|
Scenic Views by way of the Video Map |
How to make your QB programs have more "sizzle" along with the "steak" of the programming code. Basically a marketing ploy. (QBNews Vol. 1 No. 5)
| Larry Stone |
|
Fast Screen Printing |
"This article presents a rapid method of displaying a string of ASCII characters on the screen without updating the cursor position." (QBNews Vol. 2 No. 2)
| Christy Gemmel |
|
Multiplications |
Nice tutorial on ASM multiplication functions, such as SHL and SHR. (QB Times #9)
| abionnnn |
|
A Bug Free CALL INTERRUPT |
In the QuickBASIC 4.x environment any fatal DOS error during a CALL INTERRUPT crashes the system. This tells you how to solve that problem. (QBNews Vol. 2 No. 3)
| Cornel Huth |
|
Segments and Offsets |
Memory addresses, segments and offsets. A good explanation, and pretty easy to follow. (QB Times #4)
| abionnnn |
|
Overcoming Procrastination |
A motivational self-help essay on how to overcome procrastination in your programming project...or just about anything else. (QB Cult Magazine #14)
| Steve Pavlina, CEO, Dexterity Software |
|
Organizational Skills: The Key to a Finished Game |
How to organize your time in order to maximize your coding potential, and ability to create a finished game. (QB Cult Magazine #9)
| Gianfranco (Pigeon) |
| User Input |
| Link | Description | Author |
|
New Assembly Multikey Function |
A highly-commented keyboard handling function that supports multiple keypresses through interrupts. A version of this was used in Milo Sedlacek's famous MonoSpace shooter.
| Milo Sedlacek and Joe Huber Jr. |
|
A Key Handling Routine |
Shows the evolution of a simple INKEY$ key handling routine through several different dialects of BASIC.
| Unknown |
|
Mouse Programming |
Simple mouse programming with CALL INTERRUPT. A good introduction.
| Alex Warren |
|
QB Mouse Tutorial |
The best mouse tutorial I've seen for QB. A thorough explanation of mouse programming through Interrupts in both QuickBasic and QBASIC 1.1.
| Antoni Gual |
|
Keys Detection for QBasic and QuickBasic |
Great tutorial discussing ASCII functions and INKEY$, ON KEY and INP. Has some good tips on improving keyboard input handling in your game program.
| Mod |
|
Keys Tutorial |
INKEY$, UCASE$, LCASE$ and detecting arrow key presses.
| Meech Productions |
|
No Break |
Explains how to disable CTRL+BREAK. Short.
| Daniel Trimble |
|
Working with the Rodent |
A handy introduction to mouse programming in QuickBasic using interrupts. (QBNews Vol. 2 No. 2)
| Daniel R. Berry |
|
An Event-driven Mouse Support Library |
"The two mouse-programming paradigms, 'polled' and 'event-driven,' each have advantages and disadvantages. We will discuss each in detail as the routines are being presented [in this article]." (QBNews Vol. 2 No. 3)
| Tony Elliot |
|
Joystick Usage in QB |
"The purpose of this tutorial basically is to allow you to write joystick routines without having to resort to QB's crappy STRIG routines which are anoyingly bad and can be sometimes confusing!" (QB Times #2)
| Greg McAusland (Maz) |
|
A Powerful Line Editor For QB |
Getting around the limits of QB's native INPUT statement by creating a line editing program. (QBNews Vol. 3 No. 2)
| Larry Stone |
|
Mouse Programming |
A pretty good introduction to using the mouse in QB via CALL INTERRUPT. Discusses several different screen modes. (BASIX Fanzine #9)
| Alex Warren |
|
Advanced Keyboard Programming |
Brief tutorial explaining how to check keyboard input using interrupts. Also includes a Keyboard Scan Code chart. (BASIX Newsletter #1)
| Screech |
|
Programming The Mouse |
Introduction to mouse programming through use of CALL INTERRUPT. (BASIX Fanzine #3)
| Peter Cooper |
|
Using The Mouse |
A short and sweet tutorial on using INTERRUPTs to get input from the mouse. (QB Chronicles #3)
| Fling-master |
|
Morphing The Mouse |
Using CALL ABSOLUTE to program the mouse, and then replacing the standard arrow pointer with your own mouse graphic. (QDF #1)
| Lord Acidus |
|
Extended Key Codes Made Easy |
A list of CHR$ values for just about every extended / compound key press you could ever need. Includes alt combinations and function (F) key codes. (QBNews Vol. 1 No. 2)
| William R. Hliwa, Jr. |
| Libraries |
| Link | Description | Author |
|
Microsoft Library (.LIB) Format |
An explanation of the Microsoft .lib format. (QB Times #9)
| Nightwolf |
|
Future Library Document |
A tutorial on using several of the functions of the Future Library, including making your library, setting the screen mode and using fonts. (QB Times #9)
| Stefan Hendriks |
|
Using Utilities |
An interesting article on how and why you should use libraries / third party utilities to improve your QB program, with a focus on using QMIDI, BWSB or other sound addons. (QB:TM #2)
| 19day |
|
Creating Your Own Library |
"Many people have wondered how to link other languages into Quickbasic. Some think it is not possible but to my knowledge C, Fortran, and of course ASM of been succesfully intergrated with QB code. To do this you need to compile this code into a library." This will show you how. (QBOA Issue 2)
| FlySwat99 |
|
Building A Library |
Simple guide to creating your own quicklibraries, then loading them up (one at a time or chained together) in QB. (QB Cult Magazine #3)
| Chris Charabaruk |
|
Making Libraries |
A simple demonstration on how to create and use your own quicklibraries, generated from your QB subroutines. (BASIX Fanzine #10)
| Alan Copeland |
| QLB Tutor |
A very complete tutorial on inserting and using QuickLibraries in your program. |
Michael Hoopman |
|
How To Make a QLB File |
A very brief tutorial explaining how to link multiple library files together and to create .qlb libraries.
| Glenn and Dav |
|
Using C Routines in QuickBasic |
Teaches you how to use C/C++ code in QB by turning C .obj files into Quick Libraries.
| CGI Joe |
|
Direct QB Manual |
The incredibly thorough and informative manual that comes packaged with Direct QB. This explains EVERYTHING about Enhanced Creations' awesome graphic library.
| Angelo Mottola |
| Memory |
| Link | Description | Author |
|
Dynamic Data Structures |
An introduction to dynamic data structures including: the stack, the queue, the linked list and the tree. (QB Times #9)
| Matthew R. Knight |
|
Memory In QBasic |
Tricks to managing and preserving your runtime stack memory in QB, and how to use arrays and variable types. (QB:TM #5)
| Thav |
|
Memory Usage |
A simple, yet effective method of freeing up some memory in your QB game. Create a memory handler to load individual tilesets instead of loading all of them at once. (QB:TM #9)
| Mandrake |
|
Improving Your IQUEUE |
Managing your Data Stack in QB (with the help of ASM). (QBNews Vol. 1 No. 4)
| Jim Mack |
|
Implementing a Stack in QBasic |
Explains how to create an unbounded memory stack in QB. Includes examples from the Wrox Press's 'Revolutionary Guide to QBasic'. (BASIX Fanzine #1)
| Adrian Sill |
|
Using XMS in QB (Part 1) |
Nice tutorial on using XMS extended memory in QB. You must know some basic assembler first. (QB Chronicles #1)
| Fling-master |
|
Using XMS in QB (Part 2) |
Expands on what you learned in the first tutorial with several new functions that will allow you to increase the amount of memory you can use. (QB Chronicles #2)
| Fling-master |
|
Arrays Near and Far |
Some tricks on declaring arrays in QB, for both arrays less than 64KB and greater than 64KB. Covers commands like $DYNAMIC, $STATIC and TYPE. (BASIX Fanzine #13)
| RudeJohn |
|
Why 64K? |
Discusses the theory behind memory segments and memory limits, with an emphasis on QB programming and dimensioning variables properly. (BASIX Fanzine #13)
| RudeJohn |
|
Using EMS in QB |
A thorough tutorial on using EMS extended memory in QB. Includes information on all the most important interrupts that you will need if you use EMS. (QB Chronicles #3)
| Plasma357 |
|
Using EMS in QB (Part 2) |
This second edition of Plasma357's EMS series focuses entirely on using EMS memory to play WAV sounds in QB through the Soundblaster card. Very thorough. (QB Chronicles #4)
| Plasma357 |
|
Memory Moves With QB |
How to move data in QB using B$ASSN. (QBNews Vol. 1 No.1)
| David Cleary |
|
Thanks For The Memories |
Some techniques on using HIMEM.SYS and XMS memory. (QBNews Vol. 3 No. 1)
| Robin Duffy |
| Dynamic Memory |
A VERY useful tutorial on using DYNAMIC MEMORY (to give your program more mem to use) |
Charles Johnson |
| Structured Programming |
| Link | Description | Author |
|
How To Use Subs |
Brief introduction to using subroutines / subprocedures in your QB programs. (QB:TM #2)
| NetherGoth |
|
What is the difference between SUBs and FUNCTIONs? |
A short tutorial on SUB and FUNCTION usage. Written as a program, with the tutorial's text printed on screen when you execute the .BAS file.
| Kurt Kuzba |
|
Subroutines, Functions, SHARED, GOSUB and GOTO |
A very thorough and complete look at subs and functions. Includes tons of example code.
| Anastasios Yalanopoulos |
|
Basic Subroutines and Functions |
A good guide to subs and functions, covering the most important topics. Well-written.
| Unknown |
|
Subs |
A short introduction to subroutines. Poorly written; in their own words, it's "clear as mud".
| qbasic@usa.com |
|
Modular Programming |
An excellent introduction to programming subs and functions. Includes information on global variables, the module interface and commands you can't use in a sub/function. (BASIX Fanzine #15)
| David Tordrup |
|
Structured Programming |
A great resource on structuring your algorithm so that it is easy to understand and follow. Covers everything from initializing datatypes and allocating memory to structuring your loops properly. Great! (BASIX Fanzine #15)
| David Tordrup |
|
Structured Programming |
Turning spaghetti code into more managable program loops and subroutines. (BASIX Fanzine #4)
| Peter Cooper |
|
Power Coding |
Simplifying your main program module, and making common sense subroutines. (QB Cult Magazine #8)
| QbProgger |
|
Face Lift: Code Formatting |
How to organize and format your code so that it's easy to understand. (QDF #3)
| Lord Acidus |
|
How To Write Bad Code |
A tongue-in-cheek tutorial on how and why you should write bad code. However, if you read it with an open mind, you might find some good hints on how to write *good* code.
| Hans Spiller |
| Fonts |
| Link | Description | Author |
|
Customized Fonts |
Explains how to make your own 140-character "bitwise" memory-saving fonts in QB.(BASIX Fanzine #10)
| Jakob Krarup |
|
Fonts: An Alternative Graphic |
Discusses the use of fonts as graphics rather than actual bitmap graphics. Includes several character charts. (BASIX Fanzine #12)
| RudeJohn |
|
Fonts in QuickBasic |
An excellent tutorial on using custom fonts in QB -- both graphical fonts and by editing the standard DOS character set. (QB Cult Magazine #6)
| Sam Thursfield |
|
Fonts in a Can |
Using a routine called PrintROMtable to produce a library of graphics fonts without a font library! (QBNews Vol. 2 No. 3)
| Larry Stone |
|
Redefining Characters |
Change characters in the standard DOS font to your own graphical creations. This tutorial explains how to change ascii character 65 (A) into a small stick figure.
| Unknown |
|
Transforming Text |
"Do you want to transform your text? Here are a few tips to modify your text to any kind of form!" (QB Times #6)
| Maxx |
| Using the Modem or COM Ports |
| Link | Description | Author |
|
Using The Modem In QBasic |
An introduction on using dial-up modems in QB. Covers the ports and the "Modem Language" you will have to use if you'd like to send information to another computer over a phone modem. (BASIX Fanzine #17)
| Matthew River Knight |
|
Using The Modem In QBasic |
A modem tutorial that was featured in QBCM Issue #1. Large parts of this tutorial were plagiarized from Lord Acidus' QBasic Developers Forum modem tutorial, also listed here. (QB Cult Magazine #1)
| Matthew R. Knight |
|
"Ground Control to Major Tom..." |
A great introduction to dial-up modem programming, telling you how to access the COM ports, dial numbers and more. (QDF #1)
| Lord Acidus |
|
Using COM 3 and COM 4 with QB |
Getting around limitations with the COM 1 and COM 2 ports by using COM 3 and COM 4 instead. (QBNews Vol. 2 No. 4)
| Dick Dennison |
|
The BASICS of QB's Serial Communications |
Sending information over COM ports to the modem or other serial devices. (QBNews Vol. 1 No. 4)
| Ranjit Aiyagari |
|
Using The Modem in QBasic |
Simple modem programming. This was heavily plagiarized from Lord Acidus's modem tutorial. (QB Times #6)
| Matthew R. Knight |
|
Programming The Parallel Port In QBasic |
Explains how to transfer data over the LPT1 parallel port, which is usually used for a printer.
| Aaron |
|
Serial I/O Routines For QB 4.x |
A tutorial and library that will provide you with serial I/O communications in QB, as well as other DOS languages. This program will allow you to control 8250 and 16450 type communications ports (UARTS) at speeds of up to 115200 baud. Communication ports 1 - 4, and non-standard addresses are supported.
| QBSerial |
| Timing |
| Link | Description | Author |
|
Power Programming: Time |
Doing precise timing using TIMER, ON TIMER, dealing with midnight, and using TIMER alternatives in your program. (QB:TM #12)
| Seav |
|
Timing |
Shows how to use the TIMER statement to do more precise timing in QB. (BASIX Fanzine #10)
| Jakob Krarup |
|
Face Lift: TIMER |
Replacing your FOR...NEXT timing loops with more precise TIMER statements. (QDF #1)
| Lord Acidus |
|
The UEVENT Bug |
If you are trying to use ON TIMER and ON UEVENT in the same program, it probably won't work. This will help you get around that bug. (QBNews Vol. 2 No. 4)
| Ray Crumrine |
|
In Search of the Elusive UEVENT |
A different strategy for handling "events" in QB. (QBNews Vol. 1 No. 3)
| Jim Mack |
|
Face Lift: Dealing With Military Time |
Brief tutorial on converting military time to 12-hour clock time. Lots of source. (QDF #4)
| Lord Acidus |
| GUI / Operating Systems |
| Link | Description | Author |
|
Creating Menus For Your Programs |
An article for newbies that covers: "simple 'press a key menus', menus with a 'highlight selection bar', graphical menus and even mosue driven menus. I'll discuss each type of menu with the pros & cons, an example how to make one." (QB Times #7)
| Nightwolf |
|
Popup Windows |
Very thorough tutorial on using ASM to create a complete GUI windowing system in QuickBasic. (QBNews Vol. 2 No. 4)
| Christy Gemmel |
|
BASIC Menuing and Graphics |
Beginner's look ar designing simple GUIs in QB, using only simple commands. (QBNews Vol. 1 No. 3)
| Ryan Snodgrass |
|
'Menu' Screens |
"This little example is to show how you can have a 'menu' screen with various selections, and also have rather detailed information also presented to the user regarding each of his potential selections." (QBNews Vol. 1 No. 2)
| Don Avila |
|
Creating A Soul |
Introduction to making your own Operating System. This is a long article explaining the most important aspects of OS's, and what yours should include. (QDF #3)
| Lord Acidus |
| Debugging / Optimizing |
| Link | Description | Author |
|
Marcade Goes Bughuntin' |
An introduction to debugging your QB source code, including some useful tricks that will save you quite a bit of frustration. (QB Times #9)
| Marcade |
|
Advanced Speed Optimization Techniques |
A VERY useful collection of tips and tricks to optimize your code and speed up your programs. Highly recommended! (QB Cult Magazine #10)
| Toshi Horie |
|
Debugging in QB |
One good method of debugging your QB program. Especially useful for determining at which loop number your program crashes (the "breakpoint"). (QB Chronicles #3)
| Fling-master |
|
FPS: Frames Per Second |
Incorporating a FPS counter into your program to help you maximize your game engine's speed. (QB Times #8)
| Nightwolf |
|
Errors, Error Traps and Fixing Errors |
Bughunting and beta testing is explained through good examples and a lot of source code. This tutorial goes through the most common errors you will see in QB, such as "Out of Stack Space" or "Illegal Function Call".
| Anastasios Yalanopoulos |
|
Frames Per second |
A simple tutorial on how to add a FPS counter into your game program.
| Tal Bereznitskey |
| Numbering Systems |
| Link | Description | Author |
|
Binary Numbers |
An introduction to binary numbers and the binary counting system, and how to use them effectively in your QuickBasic program. (BASIX Fanzine #9)
| Alex Warren |
|
Hexadecimal and Binary Numbers |
A short explanation of hexadecimal and binary numbering systems. Includes sample math problems that you might find helpful. (BASIX Newsletter #2)
| Screech |
|
Hex Tutorial |
Brief explanation of hexadecimal numbers. (QB Times #1)
| abionnnn |
|
Hexadecimal and Binary Notations |
A "quick little reference document" on hexadecimal and binary notations as well as the use of the logical operators AND and OR. Includes information on using QB commands like HEX$ and converting binary or hexadecimal numbers to different formats.
| Earl Montgomery |
| Hexadecimal Numbers |
An intro to the Hexadecimal number system. Very useful for ASM. |
Milo Sedlacek |
| Encryption / Compression |
| Link | Description | Author |
|
The Password Encryption Technique |
Nicely-formatted tutorial by SEAV Softwares that shows you some useful data-encryption techniques. SEAV says it best: "Let's suppose you have in your arcade game a password input dialog box (probably to a specified level) or a very hard riddle. You might want to encrypt the password or the answer to the riddle so that the player cannot find the answer by examining your code."
| SEAV |
|
Simple Encryption |
Short example of one way to encrypt string variables.
| Nick Emblow |
|
Data Encryption |
Some simple methods of Data Encryption, using a "key" statement to encode and decode text strings. (QB Cult Magazine #2)
| Lord Acidus |
|
Big Brother Is Puzzled By You |
Encryption techniques in QB: how to encode / decode your message based on a key phrase. (QDF #4)
| Lord Acidus |
|
File Compression |
Instructions / decriptor for the VirtuaSoft Implode compression algorithm. Useful if you're interested in creating your own file compression format. (VSNews Dec. '98)
| Danny Gump |
|
The ZIP File Format |
All about ZIP archive compression. (QB Times #3)
| PKZip Website |
| PC Magazine's BASIC Techniques and Utilities |
| Link | Description | Author |
| PC Magazine's BASIC Techniques and Utilities |
PC Magazine's BASIC Techniques and Utilities. A gigantic book that covers just about every advanced QuickBasic programming technique you can think of. This book has also been serialized, chapter-by-chapter in QB Cult Magazine. |
Ethan Winer |
|
PC Magazine's BASIC Techniques and Utilities - PDF Version |
A PDF version of Ethan Winer's incredible book. Good for printing, but this does not come with the source code of the other archive.
| Ethan Winer |
|
Chapter 1 |
An Introduction To Compiled BASIC. (QB Cult Magazine #5)
| Ethan Winer |
|
Chapter 2 |
Variables and Constant Data. (QB Cult Magazine #6)
| Ethan Winer |
|
Chapter 3 |
Programming Methods. (QB Cult Magazine #7)
| Ethan Winer |
|
Chapter 4 |
Debugging Strategies. (QB Cult Magazine #8)
| Ethan Winer |
|
Chapter 5 |
Compiling and Linking. (QB Cult Magazine #9)
| Ethan Winer |
|
Chapter 6 |
File And Device Handling. (QB Cult Magazine #10)
| Ethan Winer |
|
Chapter 7 |
Network and Database Programming. (QB Cult Magazine #11)
| Ethan Winer |
|
Chapter 8 |
Sorting and Searching (QB Cult Magazine #12)
| Ethan Winer |
|
Chapter 9 |
Program Optimization. (QB Cult Magazine #13)
| Ethan Winer |
|
Chapter 10 |
Key Memory Areas in the PC. (QB Cult Magazine #14)
| Ethan Winer |
|
Chapter 11 |
Accessing DOS and BIOS Services. (QB Cult Magazine #15)
| Ethan Winer |
|
Chapter 12 |
Assembly Language Programming. (QB Cult Magazine #16)
| Ethan Winer |
|
Chapter 12B |
Assembly Language Programming (continued). (QB Cult Magazine #17)
| Ethan Winer |
| Homayoon P.A.'s "Writing Organized QB Code" Tutorials |
| Link | Description | Author |
|
Writing Understandable Code |
Formatting your code so that it's to understand and easy to debug. Has good tips like commenting, naming your variables with meaningful names and indenting your code.
| Homayoon P.A. |
|
Coding Techniques |
A short theory article explaining different ways to organize a program. Modular Programming and Procedural Programming are discussed, though this does not contain any actual code.
| Homayoon P.A. |
|
A Modular Programming Way in QB |
A quick summary of subs, functions, and sharing variables between your modules.
| Homayoon P.A. |
| Danny Gump's Optimization Series |
| Link | Description | Author |
| Optimize 1 |
Mathematical calculations and such in QB. You should know a little before reading this one. |
Danny Gump |
| Optimize 2 |
Using POKE and PEEK for graphics. Good examples, also discusses INTEGERS. |
Danny Gump |
| Optimize 3 |
Palette tutorial. Discusses PALETTE USING, and making palettes with OUT. |
Danny Gump |
|
Optimize 4 |
Debabelizing (converting True-color to 8-bit color) by combining like colors and customizing your palette.
| Danny Gump |
| Optimize 5 |
Basics of sprites, and plotting of sprites. |
Danny Gump |
|
Optimize 6 |
Double Buffering, part I and how it can improve your GET and PUT.
| Danny Gump |
|
Optimize 7 |
Explains BLOAD and BSAVE, as well as dealing with memory offsets.
| Danny Gump |
|
Misc. Graphics Techniques |
Danny Gump's QB graphics manifesto, which explains how to speed up and improve many different graphics techniques. You'll learn POKE and PEEK, Double Buffering (part II), faster ways to save and load a palette and more.
| Danny Gump |
| Submitted Miscellaneous Tutorials |
| Link | Description | Author |
| Subs.txt |
Useful Subs. The title says it all!!! MEH!!! (I have always wanted to do that, lol) (Submitted by Nathan1993 on September 3, 2004) |
Nathan1993 |
| Basic to Advance Keyboard Programming.txt |
Basic-Advance Keyboard Programming. This teaches basic keyboard(A-Z / 1-0) to advance( etc.) (Submitted by Kevin on December 22, 2004) |
x.t.r.GRAPHICS |
| MacQBKB.chm |
Microsoft QuickBasics Knowledge Base for Apple Macintosh.. Program in format CHM. 484 articles. Prepared and compiled by Macric. 771 kbs. (Submitted by Macric on May 20, 2006) |
Microsoft |
|
|
Programs
