Von Thomas Antoni und Triton, 2001 - 17.2.2004
*** Inhalt
1. Was ist SelfQB?
2. Was ist QBasic?
3. Wie bekomme ich QBasic auf meinen Computer?
4. Mein erstes Programm
5. Farbcodes
6. Variablen und Datentypen
7. Verzweigungen und Anwendereingaben
8. Schleifen und Abfrage von Einzeltasten-Betätigungen
9. Die QBasic-Onlinehilfe
10. Wartezeiten erzeugen
11. Mathe-Funktionen und FOR...NEXT-Schleifen
12. Zufallszahlen
13. Text bearbeiten
14. Subroutinen
15. Funktionen
16. Grafik
17. Sound
18. Felder
19. Arbeiten mit Dateien
20. Mehrfachverzweigungen mit SELECT CASE
21. EXE-Dateien erstellen
22. Tipps und Tricks
23. Wie steige ich noch tiefer in QBasic ein?
24. Liste der Beispielprogramme
 
 
*** 1. Was ist SelfQB?
SelfQB ist ein QBasic- Selbstlernkurs, der Anfängern einen blitzschnellen Einstieg in QBasic innerhalb von 2 bis 3 Stunden ermöglicht. Du brauchst keinerlei Vorkenntnisse in der Datenverarbeitung und im Programmieren. Der Kurs führt Dich ohne unnötigen theoretischen Ballast anhand leicht nachvollziehbarer Beispiele bequem in die wichtigsten Aspekte der QBasic- Programmierung ein. Für die ganz Eiligen unter euch reicht es aus, zunächst nur die Kapitel 1 bis 11 durchzuarbeiten, was in ca. einer Stunde möglich sein sollte.
 
Die 20 Beispielprogramme sind im letzten Kapitel aufgelistet und stehen im Verzeichnis Progs\ zur Verfügung sowie online unter www.antonis.de/faq/progs/ . Die blaugrün formatierten -> Fachbegriffe sind im LEXIKON der QB-MonsterFAQ näher erläutert.
 
Diesen Kurs gibt es exklusiv nur auf www.qbasic.de und www.silizium-net.de sowie in der QB-MonsterFAQ. Eine Veröffentlichung auf anderen Webseiten ist nur mit Erlaubnis der Autoren gestattet.
 
 
*** 2. Was ist QBasic?
QBasic ist eine Programmierprache für MS-DOS, die aber problemlos auch unter allen Windows-Versionen lauffähig ist. QuickBasic ist der ältere und größere Bruder von QBasic und dazu 100% kompatibel. QuickBasic hat mehr Befehle als QBasic und beinhaltet einen zusätzlichen Compiler zum Erstellen von EXE-Dateien. QBasic hingegen ist ein so genannter Interpreter und kann erstellte Programme nur mit Hilfe der Entwicklungsumgebung Zeile für Zeile ablaufen lassen. QBasic wurde mit den MS-DOS Versionen 5.0 - 7.0 sowie Windows 95 und 98 kostenlos mitgeliefert. QB ist die Abkürzung für diese beiden Programmiersprachen. QB erfreut sich auch über 10 Jahre nach Erscheinen der letzten offiziellen Version von 1991 immer noch großer Beliebtheit. Im Internet findest Du hunderte von Webseiten zu QB mit Unmengen von Beispielprogrammen, Tutorials und Foren.
 
Doch was heißt eigentlich "BASIC"? -> BASIC ist eine Abkürzung für: "Beginner's All-purpose Symbolical Instruction Code". Was übersetzt etwa "symbolische Allzweck- Programmiersprache für Anfänger" heißt. Wobei diese Bezeichnung nicht mehr ganz zutrifft, denn auch Profis benutzen heutzutage verschiedene BASIC-Sprachen.
 
Die Geschichte von BASIC beginnt 1960. Die Herren Kemmeny und Kurtz stellen die erste Version vor. Bis heute ist BASIC berüchtigt als Sprache mit der Programme entstehen, die schwer lesbar und voller Fehler (-> Bugs) sind, eine schlechte Bedienung enthalten, sehr langsam sind usw. Diese Vorurteile stammen alle aus der Zeit der Homecomputer. Und die waren bekanntlich ziemlich dürftig ausgestattet. 40 KB RAM und schnecken- langsame Prozessoren gab es da! Das ist natürlich kein Vergleich zu den Resourcen heutiger PCs. Die Programmierer waren damals also gezwungen durch Tricks Anweisungen zu sparen. Das führte schon bald zum sogenannten -> Spagetticode der häufig so extrem unübersichtlich war, dass die Programmierer ihn selber kaum noch verstanden. Und gerade dieser "Spagetticode" ist auch der Grund dafür, dass BASIC- Dialekte auch heute noch bei vielen Informatik-Professoren indiskutabel sind. Und gerade weil BASIC fast jeder hatte, gab es auch mehr BASIC-Spagetti :). Wäre z.B -> Pascal die vorherrschende Sprache geworden, hätte es genauso Pascal-Spagetti gegeben. Auch die Bedienung von BASIC selber war früher sehr schlecht.
 
Das alles hat sich aber mit Erscheinen der Microsoft-BASIC-Varianten -> QuickBasic und QBasic entscheidend geändert. Nun steht eine sehr leistungsfähige Entwicklungsumgebung zur Verfügung. Ein weiteres Argument gegen BASIC war der geringe Sprachumfang. Das kann man QBasic/QB aber nicht mehr anlasten. Dinge wie -> Prozeduren, -> Unterprogramme, Einbindung von -> Assembler und -> C, Hardware-Programmierung und Ähnliches sind nun selbstverständlich. Bei etwas Disziplin kann man sauber, übersichtlich und ohne -> Spagetticode programmieren. Du siehst also: BASIC ist ein modernes Entwicklungssystem und beliebter denn je. Die alten Vorurteile gegen BASIC treffen alle nicht mehr zu. Vor allem ist BASIC eine Sprache mit Zukunft, denn es gibt immer mehr und leistungsfähigere Dialekte. Besondes erwähnenswert sind hier -> FreeBASIC, -> Blitz Basic, -> PureBasic, -> DarkBasic, -> PowerBASIC und -> VisualBasic.
Heute wird QBasic hauptsächlich von Programmier- Einsteigern und im IT-Unterricht der Schulen verwendet. Stelle bitte nicht all zu hohe Ansprüche daran, und versuche nicht, ein Spiel wie Quake 3 oder einen Internet-Browser damit zu programmieren. QBasic ist nach wie vor die ideale Sprache um die Grundlagen des Programmierens zu lernen. Alles, was Du mit QBasic lernst, kannst Du beim Aufstieg zu einem anderen BASIC-Dialekt oder zu einer ganz anderen Programmierprache sehr gut brauchen.
 
3. Wie bekomme ich QBasic auf meinen Computer?
Die QBasic-Entwicklungsumgebung besteht aus den beiden Dateien QBASIC.EXE und QBASIC.HLP, die insgesamt nur 335 KB groß sind. Du kannst QBasic auf vielen Webseiten herunterladen, z.B. auf www.qbasic.de unter "QBasci -> Download -> Compiler".
Kopiere die Dateien auf Deine Festplatte, z.B. in den Ordner "C:\QBASIC\". Bei der Gelegenheit solltest Du auch gleich einen Unterordner für Deine selbst erstellten QBasic-Programme anlegen, z.B. "C:\QBASIC\PROGS\.
Jetzt noch schnell eine Verknüpfung auf dem Desktop zu QBASIC.EXE eingerichtet und fertig ist die Installation.
Wenn Du willst, kannst Du im Windows-Eigenschaften-Dialog einige Optimierungen durchführen. Klicke dazu mit der rechten Maustaste auf QBasic.exe. Dort solltest Du die folgenden Anpassungen machen:

---=== Ende von SelfQB ===---
 
 
 
Answer 2
~~~~~~~~~~~~~~~~~
[ By Matthew R.Knight ]
 

INTRODUCTION TO QBASIC SERIES, PART 1
 
This article is dedicated solely to those who have never programmed before or know next to nothing about programming in QBasic. Starting here, the QB Cult magazine begins a step-by-step series that explains, from the beginning all you need to know to be able to create your own top quality programs successfully.
Many people find that after a while, the pre packaged programs and games that they've bought for their computer start to become a little boring and they begin to wonder if they can modify them or even write their own. But a computer can do nothing by itself. It must be given a list of instructions telling it in minute detail exactly what to do and how to go about achieving it. These instructions form what is called a program and the art and science of creating them is called programming.
 
There is nothing difficult about programming. You dont even have to be good at maths, unless of course, you want to write programs to perform mathematical tasks. All you need to begin with is to understand BASIC.
 
In order to write programs you are going to have to get a version of BASIC. As this magazine is dedicated to QuickBASIC users, you are going to have to download it, if you dont already have it. If you have a WINDOWS 95 CD then go to the directory OLDMSDOS and there you will find two files: QBASIC.EXE and QBASIC.HLP. Copy these files onto your hard drive, and then double click on the application QBASIC. You are now ready to write your first program in BASIC!
Let us begin by writing a small program and seeing what happens. This one will ask you to enter a number. It will then add one to that number and display the result. Type in the following program exactly as it is shown here, and once that has been done, push the F5 key to run the program.
 
REM Simple addition program
CLS
PRINT "Type in a number and push the ENTER key"
INPUT n
n = n + 1
PRINT "The number that you typed plus 1 is"; n
 
Let us examine what is actually going on in the above program. The first line of code uses the REM statement. REM stands for REMark. It is used to allow explanatory remarks to be inserted in a program. REM statements are not executed. Once a REM or its abbreviation, an apostrophe (') is encountered, the program ignores everything else until the next line of code.
 
The second line of code uses the CLS command. This stands for 'CLear Screen' and removes everything currently being displayed on the screen.
 
Line three uses a very useful command called PRINT. This command outputs text to the screen. Everything that is in the inverted commas " " will be displayed. For example, if you had to type PRINT "Hello world" and run the program, Hello world would be displayed on the screen.
 
Line four uses the INPUT command. It allows you to enter something into a program. It is followed by what is called a variable. The variable is the name of the place in the computers memory where the information that you typed will be stored. The enter key must be pushed after the information has been entered, as seen in the simple addition program above. Please note that you may call the variable anything you like.
 
Line five tells the computer to add one to the variable named n.
The last line of code once again uses the PRINT command, however, in this case it is used far more cleverly. It displays a message and then displays the value of the variable n. This is done by the adding of a ; sign after the last " sign, and then writing the name of the variable whose contents you wish to display.
 
I will now give you another example. This one is quite simular to the above with the exception that the variables will be used to store letters and words instead of numbers. To achieve this, a dollar sign $ will be added to the end of the name of the variable, for example: W$ In adding a $ sign to the end of the name of the variable, you tell the computer that you wish to store letters/text in the variable instead of numbers. These kinds of variables that store text are called string variables. This program also demonstrates that you can use several letters to form the name of a variable. Type out the following program exactly as shown here, and then run it by pushing the F5 key.
 
REM This program asks for your name and displays it
CLS
PRINT "Enter your name and then press the ENTER key"
INPUT NAME$
PRINT "Hello"; NAME$; "how are you doing?"
 
Okay, now you have learned how to work with variables, and how to display the values they contain. However, so far we have only been able to add and subtract values from the numeric variables, what if we want to multiply and divide numbers? Well, lets see if we can answer that question by means of an example. We will also use INPUT in a slightly better way. Type out the following program exactly as it is seen here, and then push the F5 key when done to see how it works.
 
REM Multiplying and dividing numbers in Qbasic
CLS
INPUT "Enter your first number and then press the ENTER key"; Number1
INPUT "Enter your second number and then press the ENTER key"; Number2
PRINT "Number 1 multiplied by number 2 = "; Number1 * Number2
PRINT "Number 1 divided by number 2 = "; Number1 / Number2
 
Well, that brings us to the end of part one in the series of this helpfull section for beginners. With what you have learned here you can easily create some nice text adventure games, or even some simple business software. Next month we will be looking at loop structures and graphics.
 
Happy programming! (is there any other kind?)
 
 

Introduction to Qbasic Part 2

 
Welcome to part 2 of the Introduction to Qbasic Series, QB newbies! I hope you have been doing some experiments with what you have learnt! Last month we covered only the simplest of Qbasic statements/functions. With that knowledge it would be possible to make some simple programs...pherhaps even a very simple game...but that's not where we're headed with these tuts! We want to make kick @$$ games like Wetspot 2 and Shadow of Power! Yeah! ^_^
 
There is a lot that we have to cover in this series...I want to go over a few more of the Qbasic text handling routines, after which I'd like to cover the basics behind graphics in Qbasic, and the various methods of controlling program flow. I'll bet even at this stage of the tutorial you're confused... don't worry, soon it will all make sense!
 
Okay, to get started, let's make a program similar to the type of programs that we were doing last issue - but with a few enhancements!
 
'Program to test if the product of two numbers is greater than 10.
CLS
COLOR 1
INPUT "Enter your 1st number:", n
INPUT "Enter your 2nd number:", n2
product = n * n2 'Multiply the two numbers together.
COLOR 12
IF product > 10 THEN PRINT "Your 1st number x 2nd number is bigger than 10"
 
Alright, the above program introduces several new concepts of programming in Qbasic. The first thing you're probably wondering about is the COLOR statement. Let me explain...the COLOR statement is used to select the color of the text that will next be PRINTed or displayed from within an INPUT statement.
 
The COLOR statement is always followed by a number. In the example program above, it is 1. The number tells the computer which color to use. The number may range from 0 to 15, and each number displays a different color. Try experimenting with different numbers and see what color is shown!
Okay, now that you've mastered that, lets's do something a bit cooler with COLOR. COLOR not only allows you to select the color of the text being PRINTed, it also allows you to select the background color! Let me demonstrate this by means of an example. Try this:
 
COLOR 2, 5
PRINT "Pretty cool, huh?"
 
Let's get back to the example code we wrote earlier. The last line of the program uses the IF statement. We have never encountered IF before, but it is likely that you can already see how it works. The line of code translated to english means "If number is greater than 10 then print...". Simple no?
There are other ways that you can use IF. It can also be accompanied by the ELSE statement. Let's demonstate this by example:
 
INPUT "Enter a number:", n
IF n = 10 THEN PRINT "Number is 10" ELSE PRINT "Number is not 10"
 
The ELSE statement really has exactly the same meaning in Qbasic as it does in english! Wow! Is Qbasic easy to understand or what?!
 
The last thing you are probably wondering about is the ' character in the code. That means the same as REM. It is slightly more versatile than REM though, since you can also use it like this:
 
PRINT "Hello world" 'Say hi to the world
 
You are advised to use ' instead of REM since it is more versatile and it is obviously much easier to use.
 

Controlling program flow:
Up until now we have only written programs that when run are executed from the first line, down to the last, one after another. Fortunately we are not limited to this. It is infact possible to make the computer go to another line of code, run it, then jump somewhere else in the code, and run code from there, and so on.
 
Before I explain this in any further detail, it is necessary that I explain what line labels are. You may not be aware of it but a programmer is capable of giving a certain line of code in his program a name. There are two ways of doing this:
You can either give it a name which is just a number, like this:
 
10 PRINT "Hello, this is line of code 10"
11 COLOR 2
12 PRINT "Hello world!"
 
Or, you can give your lines of code more meaningfull names like this:
 
FirstLineOfCode: PRINT "MyProg.bas - Written by Joe Soap"
PRINT
PRINT "What is your name"; name$
PRINT "What is your age"; age
WriteName: PRINT name$
WriteAge: PRINT age
EndOfCode: PRINT "Goodbye!"
 
You can also use a combination of the two if you want.
Okay, now let's see how we can make the computer read lines of code in different ways instead of just top to bottom!!!
 
PRINT "Hello"
GOTO EndOfCode
PRINT "This line will be skipped"
EndOfCode: PRINT "Bye"
 
The above program uses a new statement: GOTO. As you probably already guessed, GOTO stands for go to. It is used to GOTO a certain specified line label. Let's try another example just to clarify this further!
 
count = 0
Start: PRINT "This will be PRINTed 10 times"
count = count + 1
IF count <10 THEN GOTO Start
PRINT "That's it!"
 
The above program uses GOTO to perform what is known as a loop. This is a really bad way of performing loops. There are better ways of doing this. Here's a demonstration:
 
FOR n = 1 TO 10
PRINT "This will be PRINTed 10 times"
NEXT
PRINT "That's it!"
 
This program uses a FOR...NEXT type of loop structure. Everything in between FOR and NEXT will be done 1, up until 10 times. Try experimenting with this!
 
What actually happens in the FOR...NEXT loop is that the variable, in this case n, starts at 1, and is then increased by 1 until it reaches 10. When n is equal to 10 then the loop stops! Simple eh?!
 
But what if we didn't want the variable n to increase by only 1 at a time? Well, it is actually possible to make it increase by any number we want!
Let's demonstrate this by means of an example:
 
FOR n = 1 TO 20 STEP 2
PRINT "Another way of doing a FOR...NEXT loop"
NEXT
 
In the above example, n is increased by 2 every loop! You could have made the STEP any number you like. Try it! Experiment! That's the best way to learn about programming!
 
FOR...NEXT loops are not the only kind of loops in Qbasic. There is another type too! Let's demonstrate it as an example:
 
number = 0
DO
PRINT "Loop the loop!"
number = number + 1
LOOP UNTIL number = 10
 
As you can see, the DO...LOOP performs the loop until the variable called number is equal to 10.
What if you wanted to create a loop that would go on forever you ask? Well, it's simple to do with DO...LOOP. Try this:
 
DO
PRINT "This message will go on forever!"
LOOP
 
In the above program the message will continue to be PRINTed for as long as your computer is on, or until you push reset. In order to get out of the program, just press CTRL and BREAK together.
 
It's up to you whether you want to use the FOR...NEXT or DO...LOOP type of loop structures in your code, though, for certain types of programs you will find the one type of loop more useful than the other.
 

Graphics:
Until now we have only written programs that display text. However, text is rather boring, and it would be nice to know how to draw graphics eh?!
Okay, in order to use Qbasic's graphics functions we are first going to have to tell the computer which graphics mode to use. You have probably all heard of CGA, EGA, VGA and SVGA. These are all different graphics modes.
 
CGA is the worst of the graphics modes. It has only a few colors available for its use, and any graphics drawn in this mode will be very blocky.
EGA is a little better than CGA. The graphics will also be blocky, but at least you have 16 colors to play with, which is much better than in CGA!
VGA is the mode used by most Qbasic programmers today. It is also the newest graphics mode supported by Qbasic since it was made quite a long time ago. But don't worry, lots of Qbasic programmers, including myself, are constantly working on new functions for Qbasic, and many of these functions allow you to use graphics modes more up to date than VGA! In VGA you have 256 colors to play with. With this you can do some pretty cool graphics.
 
SVGA is the latest in graphics modes. It is not supported by Qbasic, although new add-on functions have been made for Qbasic which does allow you to use it. SVGA comes in many flavours. We'll discuss this screen mode at a later stage, when we have improved our programming abilities.
 
Okay, in order to tell the computer which screen mode to use, we use the SCREEN statement. SCREEN is followed by a number, and this number tells the computer which screen mode to use. To use CGA we type SCREEN 1. To use EGA we type SCREEN 7. To use VGA we type SCREEN 13
 
There are a number of other numbers that can be put after SCREEN, but the ones that I have listed above are the most commonly used ones.
Now it's time to learn our first graphics drawing function! Let's first type in some code and then we'll explain how it works afterwards...
 
SCREEN 13
PSET (160, 100), 14
 
All that this simple program does is draw a dot (known as a pixel) on the screen in yellow, in SCREEN mode 13(VGA).
 
It is now necessary that I explain what the term screen resolution means. Your monitor is like a grid. Every square on the grid is a place where a pixel can be drawn. In SCREEN mode 13, there are 320 blocks on the grid going across your screen, and 200 going downwards. SCREEN mode 13 is thus said to have a screen resolution of 320x200 since there are 320x200 blocks on the 'grid' in that screen mode.
 
In the example code above, we used the PSET statement to draw a dot on the screen. Let's say we wanted to draw a red dot on the screen 'grid' that is 10 pixels across on the grid (measured from the top left hand corner of the screen), and 100 blocks down on the 'grid'. We would use this code:
 
SCREEN 13
PSET (10, 100), 4
 
As you can see, the syntax for PSET is:
 
PSET (x, y), c
 
where:
x is the horizontal position on the screen 'grid' measured from the top left hand corner of the screen.
y is the vertical position on the screen 'grid' measured from the top left hand corner of the screen.
c is the color of the pixel you want to draw.
 
This is all very good, but it would take a very long time to draw a car, for example, using PSET. Can you imagine trying to draw the whole thing one pixel at a time?! That would take all day!
 
I bet right now you'r thinking "Boy would it be great if there was a Qbasic statement to draw lines!" Well, guess what, there is! And it's called LINE!
LINE is used like this: let's say we wanted to draw a blue line from the PSET position (10,10) to (80,95) then all we would have to do is this:
 
SCREEN 13
LINE (10,10)-(80,95)
 
That's it! Simple eh?!
If you're still confused, take a look at Provgamer's excellent graphics tutorial, which explains these graphics commands in greater depth.
There are a lot of other Qbasic graphics commands, but this entry into the series has got far too big already! We'll cover that another time! Until next issue, experiment with all that you have learned so far! It would not be a bad idea to try make a simple game of some sort - an adventure game, pherhaps. If you make anything, and you would like others to see it, then send it to me via email and I'll include it with the next issue of QBCM!
 
 
 

Introduction to Qbasic Part 3
 
Welcome to the third part in the Introduction to Qbasic Series! We went over quite a lot of information last time, having covered some more of the capabilites of Qbasic with regard to the handling of text, demonstrated how to allow the user input from the keyboard, did some LOOPing, and we even took a brief look at how to display graphics in Qbasic. This time I'd like to cover some more of these simple things before we go onto more difficult areas of programming, hopefully picking up some information that we left out along the way.
 
First of all, let's take a look at what else we can do with Qbasic as far as text handling is concerned. For starters, it would be nice if we could place text at a specific location on the screen wouldn't it? Lucky for us, Microsoft wrote made a nice little routine to do this for us. This is the LOCATE statement. The LOCATE statement tells the computer at which location on the screen the next PRINTed text must be placed. You'll recall that last issue, in order to explain how PSET works, I described the screen as a grid. When using LOCATE you also have to think of the screen as a grid, but it works a little differently. The 'grid' that we're talking about when using LOCATE is not made up of pixel spaces, it is made up of much larger blocks that are basically the same size as your average ASCII character. And what is an ASCII character you ask? Well, all the letters and numbers you see on the screen in DOS are ASCII characters. Apart from the number and letter characters, there are also some other ASCII's which look quite strange. You have seen some of them before. Some of them are used by the Qbasic editor to draw the menu's and the scrollbar, etc. ASCII stands for American Standard
Code for Information Interchange.
 
Another way of thinking about how LOCATE works is like this: suppose you wanted to put some text, for example "Qbasic rulz!", 5 ASCII spaces across the screen, and 10 ASCII spaces down. Then all you'd have to do is this:
 
LOCATE 10, 5
PRINT "Qbasic rulz!"
 
Try experimenting with different numbers and see what results you get. Using LOCATE will make your life much easier when using text! There are some other similar text handling routines, but there is no need to use them since LOCATE is generally capable of doing exactly the same as them, but is easier to use and more versatile.
 
Okay, now onto something more fun ^_^ Last time when we looked at using graphics in Qbasic we really didn't do very much. All we used was PSET and LINE - not too interesting. So we'll cover some better stuff this time round. It is sometimes necessary that you know the color code of a certain pixel on
the screen. You can actually do some pretty cool graphics effects just by knowing this simple information. In Qbasic, we use the POINT statement to obtain the color code of a certain pixel on the screen. The POINT statement is very versatile in the way that it may be used, and this makes it very
easy to understand.
 
For example, if you wish to get the color of a pixel at the coordinates (2,5) on the screen 'grid' into the Col variable then all you do is this:
 
PSET (2, 5), 2 'Place a green pixel at coodinates (2,5)
Col = POINT(2, 5) 'Get the color code of the pixel at (2,5)
 
You can also use POINT like this:
 
IF POINT(2, 5) = 2 THEN PRINT "That pixel is green"
 
Try playing around with this, and maybe you'll figure out how to do something cool using a combination of POINT and one of the other Qbasic drawing routines. I once wrote a little program using PSET and POINT that allowed you to print text on the screen, and it melted what looked like lava around it. There is no reason why you couldn't write a program to do exactly that!
 
Okay, now on to something a bit more cool. You have probably found that using LINE to draw graphics is rather difficult and time consuming. There is another Qbasic command for drawing that is much easier to use. It's called DRAW! It works quite unlike any other Qbasic routines we have covered so
far, as you'll soon see.
 
The DRAW statement has its own commands for doing things. For example, it has the U command for drawing lines up, and the D command for drawing lines down. Let's demonstrate this by means of an example:
 
SCREEN 13
PSET (10, 10), 2 'Start drawing at (10,10) in green
DRAW "U100" 'Draw a line up, 100 pixels in length
PSET (100, 100), 14 'Start drawing at (100,100) in yellow
DRAW "D20" 'Draw a line down, 20 pixels in length
 
There are lots of commands used with DRAW, but you'll probably never use half of them. We'll cover the most commonly used ones. If you want to know the others then you'll have to take a look at the Qbasic help file. You have probably already guessed that in order to draw right, you use the DRAW command R, and to draw left you use L. This should have been obvious. But what if you want to draw diagonally? Well, to draw diagonally up and right you use the DRAW command En, where n is a number specifying the pixel length of the line to be drawn. To draw diagonally down and right you use the commnd, F. To draw diagonally down and left you use G, and lastly, to draw diagonally up and left you use H. Simple no? Okay, here's an example:
 
SCREEN 13
PSET (160, 100), 2 'Start drawing at (160,100) in green
DRAW "H20 E20 F20 G20"
 
Note that I have put a space between each of the DRAW commands in order to make it easier for you to read. You don't have to do it this way though. You could just as easily have left them out, and it would do exactly the same thing. Like this:
 
SCREEN 13
PSET (160, 100), 2 'Start drawing at (160,100) in green
DRAW "H20E20F20G20"
 
It really doesn't make a difference.
 
Another usefull DRAW command is C which sets the DRAWing color. All you do is say Cn where n is the color code of the color in which you'd like to DRAW, and voila - you're DRAWing in that color. Could it really be any easier?! Let's demonstrate this by means of an example:
 
SCREEN 13
PSET (160, 100), 2 'Start drawing at (160,100) in green
DRAW "C2 H20 C3 E20 C4 F20 C5 G20"
 
Once again you can see that I've put spaces between each of the DRAW commands in order to make this easier to read and understand. If I were writing a program in which readability was not a necessity, I'd have left the spaces out since they're a waste of space.
 
There are many other DRAW commands that can be used, but I'm not going to cover it all here, when there is a perfectly good description of all of them sitting right there in the Qbasic help files. One thing that I should mention before we go onto something else is that you are able to use DRAW
with strings instead of specifying it right after the command. This allows you to save a lot of space. To clarify this further, here's an example:
 
Diamond$ = "C2 H20 C3 E20 C4 F20 C5 G20"
SCREEN 13
PSET (160, 100), 2 'Start drawing at (160,100) in green
DRAW Diamond$
 
In the above example you can clearly see that we have used DRAW with a string variable, instead of placing all the commands right after the DRAW statement. You will find this ability very usefull when you find the need to DRAW an object more than once. Without this ability you'd have to specify all those commands to draw the object again, and again, and again, which is really a waste of space.
 
Right. Now we've covered PSET, POINT, LINE and DRAW. With that you can, with some ingenuity, draw some fairly good graphics. But what if you want to draw a circle? Can you imagine writing the DRAW code for all of that! Yeah, it would be a total nightmare! Fortunately there is a Qbasic statement called
CIRCLE which allows you to draw circles. It's actually a bit more versatile than that in the light that it can not only draw circles, but also ellipses, and fractions of circles/elipses. It's a really great little routine. So let's learn how to use it!
 
We'll start off using CIRCLE just to do simple stuff, and then we'll work our way up, step-by-step, finally getting onto some more difficult stuff. Okay. In order to draw a yellow (color code 14) circle with a radius of 15 at the coordinates (160,100) on the screen 'grid' we'd type the following code:
 
SCREEN 13
CIRCLE (160, 100), 15, 14
 
Now that wasn't so hard, was it? Right, now that we've mastered the drawing of circles, I think it's time that we move onto ellipses. You may not have heard of an ellipse before, so this is what it is: an ellipse is, in the most simple terms I can think of, basically like a squashed circle! You can
probably imagine what I mean. It can be squashed from the top, or from the side. It doesn't really matter. Any squashed circle is an ellipse!
 
Let's, for example, say you wanted to have a circle that looked squashed from the top. First thing you have to think about is how squahed you want it to be. If we wanted to squash the circle, from the top, by 50% then we'd do this:
 
SCREEN 13
CIRCLE (160, 100), 15, 14, , , 50 / 100
 
If we wanted it squashed by 70%, from the top, then we'd do this:
 
SCREEN 13
CIRCLE (160, 100), 15, 14, , , 30 / 100
 
Simple no? Unfortunately, although we are able to describe the squashing effect in degrees here, the CIRCLE routine doesn't actually think of it that way, and that makes life quite difficult when we want to squash a circle from the sides - the degrees thing doesn't work anymore. It actually works like this: the division (above it is 29/100) which is actually called the aspect describes the ratio of the x radius to the y radius (x;y). The default aspect ratio depends on the screen mode, but gives a visual circle in any graphics mode, assuming a standard monitor screen aspect ratio of 4:3.
 
Did that make you a little dizzy? Yep? Okay, well, then let's go about it this way...practise! Play around with this until you understand! That's the best way to understand programming. Just to get you started, here's an example program showing you how to squash a circle from the side:
 
SCREEN 13
CIRCLE (160, 100), 15, 14, , , 170 / 100
 
Play around with this and it'll soon make sense.
 
Okay, as I mentioned earlier, it is possible to draw fractions of the circle, but that is slightly mathematical so I'll leave that for another time. I think I've confused you enough for one day!
There are still other graphics routines to cover, but we'll have to leave that for another issue. We have said more than enough about graphics this month!
 
Okay, we'll cover one more aspect of programming before I leave you to play around with what you've learned this issue. Sound in Qbasic! Before we even start this I need to explain one simple thing - Qbasic is, ordinarily, only able to produce sound through the internal PC speaker. You probably didn't even know that you have a speaker inside your computer, but you do. In the old days of computing there was no such thing as sound cards, and sound amplifiers for the computer. Such things were unheard of. In those days everyone used to have to play sound through the little speaker inside the computer. Unfortunately the internal speaker is really junky. Any sound that comes from it sounds terrible. But, as a newbie, it's the only sound that'll be available to you for a while. There are ways to use the sound card in Qbasic, but it's really difficult, so we are not going to cover that
at this stage.
 
Okay, I have rambled on long enough! We have quite a few Qbasic statements at hand which generate sound through the PC speaker. We'll start off with some simple stuff. It's fairly clear that the simplest form of sound we could possibly get the computer to do is just a beep. What could be easier
than that? Well, there is a Qbasic statement called BEEP that does just that!
 
BEEP generates a beep-like noise from the internal speaker at 800hz (800 cycles per second) for one-quarter of a second. It's really easy to use BEEP. Let's test it:
 
BEEP
 
Yep! That's it! That's all you have to type to use BEEP. Could anything be any easier than that?! Well congratulations, you've just mastered yet another Qbasic statement, and it's only taken you two seconds! ^_^
 
Okay, soon you're likely to get bored with BEEP. With BEEP you are not able to specify the pitch of the BEEP and the duration for which it plays. And that is no good. No good at all. Okay, well this isn't much of a problem. There is a Qbasic statement called SOUND which allows you to do exactly
what BEEP won't allow you to do! The syntax of SOUND is:
 
SOUND frequency, duration
 
frequency is the pitch of the sound. For those of you who don't know what this means (get a dictionary!) here's some examples - an example of a low pitch would be thunder. It sounds deep and has a low pitch. An example of a high pitch would be the squeek of a mouse. It has a high pitch. The higher the number is in place of frequency, the higher the pitch of the sound. The frequency may not be lower than 37, and not higher than 32767.
 
duration specifies the amount of time the computer has to spend making the sound. It is measured in clock ticks. Clock ticks occur 18.2 times per second. The duration may not be less than 0, and not higher than 65535.
 
Ah, okay, now is a good time for an example, no?
 
SOUND 300, 70
 
If you really want to give yourself a headache (why would you want to do
that?!) then run the following program:
 
SOUND 5000, 65535
 
I would not advise running that program. You'll get a terrible headache. You could easily write a program that would trick somebody into thinking there's a mosquito in the room ;)
 
Now the problem with this stuff is that it's really hard to write music with it. It's even harder to try and write sound effects. With music we are accustomed to sounds being described as A,B,C,D,E,F and G. Well

Here's a list of the equivelent frequency's for them! ^_^ I took this list from a book I have on Qbasic. For some reason there are a number of different A's, B's, C's...etc. I know nothing about music so I have no idea why this is the case. Those of you who know about music will be able to make more sense of this than I can ;)
 
Note Frequency Note Frequency
C 130.810 C* 523.250
D 146.830 D 587.330
E 164.810 E 659.260
F 174.610 F 698.460
G 196.000 G 783.990
A 220.000 A 880.000
B 246.940 B 987.770
C 261.630 C 1046.500
D 293.660 D 1174.700
E 329.630 E 1318.500
F 349.230 F 1396.900
G 392.000 G 1568.000
A 440.000 A 1760.000
B 493.880 B 1975.500
*Middle C.
 
By doubling or halving the frequency, the coinciding note values can be estimated for the preceding and following octaves.
 
To produce periods of silence, use the following statement: SOUND 32767, duration To calculate the duration of one beat, divide the beats per minute into the number of clock ticks in a minute (1092).
The following table illustrates tempos requested by clock ticks:
 
Tempo Notation Beats/Minute Ticks/Beat
very slow Larghissimo
Largo 40-46 27.3-18.2
Larghetto 60-66 18.2-16.55
Grave
Lento
Adagio 66-76 16.55-14.37
slow Adagietto
Andante 76-108 14.37-10.11
medium Andantino
Moderato 108-120 10.11-9.1
fast Allegretto
Allegro 120-168 9.1-6.5
Vivace
Veloce
Presto
very fast Prestissimo
 
Like I said, I know nothing about music, and I thus have no idea what the above table is talking about. The only thing that I know about music is that it comes out of the radio! ;) Those of you who know about music will probably find the above information very usefull, but as for the rest of you
who know no more about that stuff than me, don't worry about it. It's still possible to do cool stuff with SOUND without any knowledge of music.
 
There's another way to use music with the internal speaker in Qbasic, but we'll cover that (and other things) next issue. Until next month, just play around with what you have learned, and see if you can come up with something
 
Cool. If you make a little program, and you are proud of it and would like others to see it, then email it to me at horizonsqb*hotmail.com and I'll include with the next issue of the QBCM! Have fun with Qbasic!!! ^_^
 
 

Answer 3
~~~~~~~~~~~~~
[ By Sane <sane*telia.com> ]
 

 

The Very BASICs
This is a pretty old tutorial that I wrote about 2 years ago or something, and thanks to Wildcard, I came to think of that it could be used in QBCM, so now it's here, and I hope someone gets something useful out of it. Otherwise it does its job as a filler :)
 
A simple Hello World program...
 
As almost all other programming tutorials for beginners, this tutorial has also got a "Hello World" program.
The program is basically a program printing "Hello World" to the screen, and here it comes:
 
'A simple "hello world" program, made by Sane
PRINT "Hello World"
END
 
If you typed that text into QB, you have already made your first program!
As you can see, if you typed this program into QB, and started it using Shift+F5, the PRINT function in QB prints what is between the quotes.
If you use ' at a line, everything after that sign on the line will be ignored by QB, and thus you can make comments or remarks in your programs, to make understanding your own programs easier.
 
Now you may ask: "Why wouldn't I understand my own programs, I'm not that stupid", or something like that, but if you start getting used to making remarks and comments now when your a beginner at programming, you won't have to learn the hard way, when you make larger projects, why you should use comments. For example, when I started to make a big program about one and a half year ago, and I didn't program on it for about half a year, I couldn't understand what I had been doing in the program, how, or why, when I thought that I should start programming on it again, and thus I was forced to start making comments...
 
My suggestion to you is, as you may have understood, to always make comments in your programs, for your own sake, and to make extra empty lines where you see it needed to make the program code easier to read.
The function END is optional to use in cases as this one, but further on we may want to end the programs when a certain event occurs or so, and thus the END function is useful anyway.
 
Getting a bit more complicated...
 
'A program for getting and printing the users name to the screen
'Made by Sane
INPUT "What is your name"; Name$
PRINT "Your name is "; Name$; "!"
END
 
From now on, it's suggested to type and run every program shown in this tutorial, unless told otherwise.
 
After you have executed this program in QB (using Shift+F5, as always), return to this tutorial.
 
The program shown above introduces three new things:
- the INPUT function
- more on using PRINT
- variables
 
Here comes an explanation:
INPUT is a function that prints the text within quotes, and lets the user type a line of text into a variable.
 
The semicolon after the quotes in this example makes INPUT type a ? sign after the text within quotes.
 
If you do not want a ? sign there, use a comma instead of a semicolon.
Name$ is a variable, which means a place in the memory where information can be stored, that is called using a symbolic name, in this case Name$.
 
The dollar-sign in Name$ means that the variable is of the type STRING, which is a text-variable type, and the only one QB uses.
QB doesn't take any notice wether letters in variablenames are uppercase or lowercase letters, and thus Variable% refers to the same variable as VaRiAbLe%.
 
What symbolic name the variable should have is in general up to you, but there are some rules for variable names:
The variable name may not start with a number. Variable names can't use any characters but A-Z, a-z and 0-9 (except for dollar-signs for example, but dollar-signs and other "type signs" may only be used as last character in the variable) Variable names may not use the same names as existing QB functions. Variable names may not contain more than 40 characters.
A variable uses the same name in the whole program, so if you want to reach the variable blah$, for example, you can't use the name blahahah$ instead.
 
Variables can be of other types too, like integers, long integers and such, but more of that will be discussed later on.
 
If you want to print a variable using the PRINT function, use for example PRINT Variable$
 
If you want to use variables together with text, you may do it like this:
 
PRINT "Text";Variable$
 
When using PRINT, semicolon makes PRINT continue printing directly after the last text printed, and thus, if Variable$ would contain "blah" in the previous example, the text printed would be "Textblah". If you use a semicolon at the end of the PRINT line, the next PRINT call would print its text directly after the previous text printed. If you use a comma instead of semicolon when using print, there will be a TAB space between the text before and after the comma. If you don't understand what I mean, try it out yourself.
 
This is all that should be needed for this section, I think, so let's move on to some more about variables...
 
More about variables
As mentioned earlier, there are other types of variables than string variables.
 
If you have not declared that a variable should be of a certain type, either using for example $, or done it some other way, the variable is of the type SINGLE, which means that it's a "single-precision value" variable, which in turn means that the variable can contain decimal values, but not with as many decimals as "double-precision value" variables.
 
The "type sign" for variables of the type SINGLE, is !, just as $ is the "type sign" for variables of the type STRING. INTEGER variables have the type sign %, LONG(long integer) variables have got the type sign &, and DOUBLE(double-precision) variables have got the type sign #.
All value type of variables can be used in mathematic statements, here are some examples:
 
a%=(a%/2)*1.5
t%=t%+2
 
Note that if you for example do as in the second example above(t%=t%+2), t% becomes what it is, plus 2, so if t% is equal to 4 before, t is equal to 6 after.
 
String variables can also be used with the + sign, like this:
 
S$="Hello"+" "+"World"
 
Note that if you for example do as in the second example above(t%=t%+2), t% becomes what it is, plus 2, so if t% is equal to 4 before, t is equal to 6 after.
 
Here comes a small table with the limits of the different variable types:
 

Type (Suffix) :Min to Max:
- String ($): length 0 characters to 32,767 characters
- Integers (%): -32,768 to 32,767
- Long Integers (&): -2,147,483,648 to 2,147,483,647
- Single precision numbers (! or missing)
Positive:1.401298 E-45 to 3.402823 E+38
Negative:-3.402823 E+38 to -1.401298 E-45
- Double precision numbers (#)
Positive: 4.940656458412465 D-324 to 1.797693134862315 D+308
Negative: -1.797693134862315 D+308 to -4.940656458412465 D-324
At first, I was going to write some more boring variable stuff, but then I realized how boring it would be for me if I was a person reading this as a beginner programmer, so I think we'll leave the rest until it's needed later on...
 
Labels, GOTO and GOSUB
In QB there are functions for jumping between different places in your program, and this is what this chapter will be all about...
The first function you'll learn how to use is GOTO.
GOTO is used to jump to the row with the label you specify, here comes an example:
 
Label:
PRINT "This program won't ever stop..."
GOTO Label
 
If you type the program above into QB and run it, you'll notice that it prints "This program won't ever stop..." until you end the program, which is done using Ctrl+Break on the keyboard.
 
The only label in this program is the label named Label, as you might have noticed...
 
Labels are defined by putting a name at the beginning of a row, followed by a colon, or by using a number. When using a number only, you can choose by yourself wether to use a colon, or just a space.
The rules you need to think about when making label names (except for when you use numbers only), are the same as for variable names.
Now on to using GOSUB...
 
GOSUB is a bit different from GOTO, in the way that GOSUB returns to the place where it was if you put RETURN where you want GOSUB to return, here comes an example:
 
GOSUB PrintText
PRINT "GOSUB finished"
END
PrintText:
PRINT "This text is called using GOSUB"
RETURN
 
This program will call the text printing using GOSUB, and then print "GOSUB finished", and end after that.
 
GOSUB is pretty useful for making sub-programs, and there is a better way to do that, but for now we'll stay with GOSUB.
 
Well, seems as if this chapter is already completed... :)
 
So you want to stop making linear programs, huh?
Ok, we'll find something for ya... :)
 
This chapters first command is IF, which is used for condition checking.
And here comes the example, as usual...
 
Start:
CLS
INPUT "Do you like this program?(Yes/No)", Answer$
IF Answer$="No" THEN GOTO Start
PRINT "Oh, so you like my program. Thank you."
 
If you try running this program, then you might notice that it doesn't accept "No" as an answer (even though it accepts "no" or "NO"...).
The IF statement in the program checks if Answer$ is equal to "No", and if it is, it jumps back to the start.
 
Another new command for you is the CLS command, which CLears the Screen, and when I noticed that I had forgotten to write about good ol' CLS, i was pretty shocked :), but at least it's not still in the "land of forgottenness"... :)
 
Back to the IF command, you see that IF is used like this:
 
IF condition THEN statement
 
In the condition part, you may use the following operators:
 

Operator Meaning
= Equals
< Less than
> Greater than
=< Less than or equal
=> Greater than or equal
<> Not equal

Example of another way of using IF:
 
'Made by Sane
INPUT "How old are you?";age%
IF age%<13 THEN
PRINT "You're a child"
ELSEIF age%>=13 AND age%<20
PRINT "You're a teenager"
ELSE
PRINT "You're an adult"
END IF
 
As you saw when you executed this program, it asks for the user to give it his/her age, and using that, tells the user what he/she is: a child, teenager or adult (as if the user didn't know that already :)
 
Some not-so-obvious info about the new things introduced in the example:
In IF commands, you might have use of either AND, OR or XOR. AND is for checking if both conditions of two conditions are true, OR checks if one/both of them are true, and XOR checks if one and no more are true. It's possible to use as many ELSEIF:s as you want to. You don't have to use ELSE/ELSEIF. You always have to use END IF in an IF statement spanning over multiple rows.
 
-Sane
 
 

Answer 3
~~~~~~~~~~~~~~~~~
[ ]
Author: Maxim Kakitsev
maksim*freeuk.com
Created on 26.03.01
Source URL: http://www.geocities.com/maxspaceuk
 

Qbasic Tutorial

Chapter I

Basic Commands

 
When you open QBasic, you see a blue screen where you can type your program. Let's begin with the basic commands that are important in any program.

PRINT
Command PRINT displays text or numbers on the screen.
The program line looks like this:

PRINT "My name is Nick."
Type the bolded text into QBasic and press F5 to run the program. On the screen you'll see
My name is Nickos.
Note: you must put the text in quotes, like this – "text". The text in quotes is called a string.
If you put the PRINT alone, without any text, it will just put an empty line.
PRINT can also put numbers on the screen.

PRINT 57 will show the number 57. This command is useful for displaying the result of mathematical calculations. But for calculations, as well as for other things in the program, you need to use variables.

Variables
When you think, you keep words or numbers in your mind. This allows you to speak and to make calculations. Qbasic also needs to keep words or numbers in its memory. To do this, you use variables, pieces of Qbasic memory, which can keep information. A variable can be named with any letter, for example – a. It can also have a longer name, which can be almost any word. It is important to know that there are two main types of variables – that keep a number and that keep a word or a string of words.

INPUT
INPUT is a command that allows you or anybody else who runs the program to enter the information (text or number) when the program is already running. This command waits for the user to enter the information and then assigns this information to a variable. Since there are two types of variables, the INPUT command may look like this – INPUT a (for a number), or INPUT a$ (for a string).
Example (Type this program into Qbasic and run it by pressing F5)

PRINT "What is your name?"
INPUT name$
PRINT "Hi, "; name$; ", nice to see you!"
PRINT "How old are you?"
INPUT age
PRINT "So you are "; age; " years old!"
END
Note: The END command tells Qbasic that the program ends here.
You don't have to use PRINT to ask the user to enter the information. Instead, you can use

INPUT "Enter your name"; name$
and the result will be the same.

GOTO
Quite often you don't want the program to run exactly in the order you put the lines, from the first to the last. Sometimes you want the program to jump to a particular line. For example, your program asks the user to guess a particular number:

~ ~ ~ ~ 'some of the program here
INPUT "Guess the number"; n
~ ~ ~ ~ 'some of the program there
The program then checks if the entered number is correct. But if the user gives the wrong answer, you may want to let him try again. So you use the command GOTO, which moves the program back to the line where the question is asked. But first, to show Qbasic where to go, you must "label" that line with a number:

1 INPUT "Guess the number"; n 'this line is labelled with number 1
Then, when you want the program to return to that line, you type

GOTO 1
You can use GOTO to jump not only back but also forward, to any line you want. Always remember to label that line. You can have more than one label, but in that case they should be different.

Chapter II

Mathematical Calculations
QBasic was obviously created for us to have fun, play games, draw nice graphics and even make sounds.
But, as you might guess, nothing good comes without a bit of effort that has to be put in it. In the most QBasic programs a bit of math has to be done.
The math… Doh!
If you hate mathematics, don't worry. Qbasic will do it all for you, you just need to know how to tell QBasic to do that.
Qbasic can perform the following mathematical operations:
Operator What it does Example Result
+ Add 7 + 2 9
- Subtract 7 – 2 5
* Multiply 7 * 2 14
/ Divide 7 / 2 3.5
Examples: