I added a new section to the mag called "Index". There you'll find printable versions of all of our issues (including this one). By printable, I mean black text on white, cuz most of you have probably noticed that white on blue has a thing for not printing on most 'puters. But anyway, reading the back issues, I've noticed that I use a lot of big words. Wierd. Mebbe I should give these to my lit teacher for extra credit :). Like, last issue, I used the word "qualms". Wow. Impressive. :)

Whoa! I almost forgot! 'Tis the end of the year. It's been a great one, with releases in '98 such as Wetspot 2, Monospace Shooter Full, SFB2, Dark Ages, Dash, and dqb. I'm sure 1999 will be even better! Have a good Christmas/ Chanakauh / Kwanzaa / whatever and I'll...

See ya' next month!

zkman

Back to top

   The entry period for qbasic's biggest award has started. Run 
   by SonicBlue, with Danny Gump of virtuaSoft as co-sponsor, the
   2nd Qlympics kicked off on 1 December, taking entries in 
   nearly every category. The entry period is schedueled to last
   until 31 December at press time, but we've heard rumours that
   the date might be moved up to 1 February. 

   I'm sure everyone remembers the sham that occured in last
   year's Qlympics in the "Best Game" category, with Wetspot 2
   being "beaten" by the mediocre-at-best Elysian Fields. 
   SonicBlue has implemented anti-cheating features this time.
   If you have a qb program released in the last year and would
   like to submit, go to the  official site for details. 

   Last month, we reported that the qbt50 was for sale. We've
   now learnt that it can be yours for the mere asking price
   of 1500 big ones (in American, that is). And what do you
   get for that price? How about 800hits/day!

   Steve Martin, the owner of qbt50, told us that the price
   includes the cgi script program that runs qbt50, plus
   all rights and licenses to the site name. He mentioned
   that he has had one advertiser that paid $100 for 10000
   impressions, as well as lower-paying banner ads. 

   If you're willing to do the work to find advertisers, this
   site could end up being a very valuable investment. If 
   interested, contact Steve and tell him qb:tm
   sent ya'!

Qb: the Greatest Hits

   Earlier this month, Danny Gump announced intentions to 
   create a CD compilation of the best qbasic programs.
   This will become a reality now, thanks to Qlympics 99.
   The winners in each category will be featured on the
   cd and also may recieve a share of the proceeds! If
   you're interested in acquiring one of these fab items,
   which should be out around mid-99, contact SonicBlue
   or Danny Gump

   Most qb'ers have heard that a man calling himself 
   RavenNight has appeared with a new website, which is
   apparently the site of DarkDread. It features all
   of DD's proggies, as well as info on his "next
   project". Qb:tm doubts that RavenNight is DarkDread,
   just because "RavenNight" has not appeared on any
   of the boards/irc's that DD used to frequent. But,
   hey, we could be wrong. More on this in future issues.

"Nemesis" and "unnamed"

   Late last month, we picked up word that Pyrus was 
   intending to develop a dqb/dash style library called 
   "Nemesis". This lib will run in protected mode, giving
   it lots of fast access (compared to ems) memory for
   your use! More news as it comes on this one.
 
   Also, we've heard rumours that LordQB was developing
   a library set also. We currently have no other info
   on this one either, but we'll try for next issue.

Speaking about Libraries...

   Yup, Directqb and Dash have both been updated a few times
   since last issue. Here's the rundown of new features:
   
   dqb added a bunch of stuff like a neato-keen Tools program
   that included things like a Font Editor, as well as a
   blender map program, and 3 new versions of the base 
   library. In there, you'll find cool stuff like alpha-
   blending, texture-mapping, and more sound support. 
   Rockin!
 
   On the Dash front, we've seen the biggest change in it's 
   addition of flat-poly filling and texture-mapping 
   routines. It seems that Dash fell a bit behind this 
   month, but qb:tm is sure that it'll have matched dqb's
   collection by next issue.

Qbasic: the Future Part II

   It seems that the biggest new innovation in the world
   of qb this month has been the interest in voxel, or
   volumetric pixel, engines, such as the one synnine's
   Vampire engine is made of.  Voxels are pretty much a
   cross between Pixel graphics and 3d, so this is 
   definitely a cool thing. Look for more "voxel engines"
   to start appearing next quarter.

Neozones hits the big 1-0-0-0-0-0

   On 7 December, Neozones hit 100,000 hits, becoming
   the 3rd qbasic site to do so (qbasic.com and qbt50.com 
   were first and second). Congratulations! As far as
   qb:tm knows, the next site on track to hit the sixth
   digit is Qbasic Mania.

I like qmidi4.1

   Qmidi, the best current mid file player for qbasic
   released version 4.1 earlier this month and I like it
   a lot. Why? Not only does it use less memory than
   prior versions, it comes with 2 versions, one with
   less subs for smaller programs (sort of like dqbLite).
   But, also, it's the only qmidi version that seems to
   work with my computer. And since I'll probably be
   reviewing your game, you better use qmidi4.1 so you
   can get a high score, right? So go download it now!

   "Project RT":
   From here on, qb:tm will be referring to the new
   top-secret project from Enhanced Creations as "Project
   RT". We're allowed to tell you a really, really small
   hint this month. I'm talking like, thing of something
   really small, and divide that by infinity. The hint
   is even smaller. Okay, here goes:
   Enhanced's top-secret really super cool game will have 
   "twitch" elements (i.e. it's not an rpg) and will not
   be an arcade-style game (i.e., it's not Wetspot 3 or
   anything like that). We'd tell you so much more if 
   Enhanced would let us! If you want some more news, go
   to echome.hypermart.net and diluge them with email :). 
   Heh. Not really. But if they don't let us print something
   next month, we'll have to print Angelo's home phone 
   number and have you all call once an hour requesting 
   information :).

   BREAKING NEWS! Just as we were going to press, we
   picked up the specs on Dqb version 1.4! This new 
   version, which might be out as you read this, will
   feature flipped sprite drawing, blended gourard-shaded
   and blended texture-mapped triangles. But the most
   important feature will be that it's now split into
   15 object files! No more dqblite! Now you only link
   the .obj you need, making your proggie much smaller!
   
   An issue or two ago, we said that WoodLands, Pyrus's
   strategy game, had been cancelled. Well, Pyrus has
   changed his mind! WoodLands has been brought back from
   the land of the dead-qb-game. Yay! But, in less 
   fortunate news, we've heard that Marcade's strat game
   "Low Radiation" has been canned. More news as it comes.
   
   NutzBoy is working on a side-scroller project called "peanut
   patrol". This Mario Bros. style game casts you as a Peanut
   on a mission of rescue. All right! Anyways, the most current
   version allows you to walk and jump thru two levels. Only
   one of the many enemies has been implemented already, though.

   Enigma's next big project after Eldim will be a massive rpg
   by the name of "Realms". This project will be a 320x200 rpg
   with a long playtime, 500+ tiles, 20 characters and tons of
   rippin' gear! Not to mention asm special effects! Enigma's
   other project is called Bubble Fighters. It features 
   textured, scaled graphics, used fast asm and Dash, and 
   is, as Enigma put it, "Killer Instinct meets SFB2". This
   game will come out before "realms". BREAKING NEWS: Just 
   before publication, we've learnt that Eldim has been delayed,
   and that this might be a permanent delay! Enigma has noted
   that it may be resurrected at a later date, though.

   Pasco has 3! major projects in the works, all of which look
   super-cool. The first, Soccer 98, is being updated constantly,
   and qb:tm looks forward to it because Pasco is not American!
   Yeah! That means we'll have accurate football :). Us Yanks
   tend not to be good at that kinda thing, y'know? Also in 
   development is Groov Buggies 2. This project's pretty far
   off in the horizon, but it's going to be the first "real"
   3d (i.e., not wireframe) game in qbasic. His third project
   is codenamed "Vertical" and is a topdown shooter. The demo
   has great-lookin' animated tiles and translucent shadows,
   as well as it being already cool to shoot things :). Check
   out all of these at Pasco's Page
   
   Here come the shorts:
   Dunric is working on a strat/wargame called "Gradius". Set
   at the end of the the 18th century, it's a game of global
   conquest with Civ like elements....Hal_8900's and Necrolyte's
   game, Red Planet, has ditched svga in favour of fast GTA
   style scrolling...Seav has released a demo of his game called
   "labyrinth". It appears to be a faster version of DD's engine
   from "Legend of Lith 2" but looks pretty raycaster-ish. Not 
   too bad...BREAKING NEWS! Just as we went to press, we heard of
   a new project from a party wishing to remain unnamed. Based on
   what we've heard, it's gonna rock. Qb:tm will refer to this
   project as "Xeno" from now on, and try to break the veil of
   secrecy.
   

That's all the latest news for this month. Remember, if you have any news or rumours, send them along to Qbasic: The Magazine

Back to Top

By ZKman

Here's what you had to say about last month. Be sure and send us more letters soon!

Quote :
"What the heck? There's not a singlue blurd about qbasic on this site! It's all asm and C++!

Ahhh...that's what I thought, too, when I first went to gameprog.com, but I was wrong. What this has is a gold mine of TECHNIQUES, which are the same whether done in C or qb."

I run Game Programming '98 and I want to say, thanks a lot for noticing. I haven't put things like DirectX up because it was too language specific. I'm glad you noticed the theme of my site, though, as it is easily missed. (i.e., "Why don't you have DirectX info, more source, etc.) =) I'd say you are one of the first [to notice]. When i first saw your review, I thought to myself, "Wow, someone has finally caught on". heheh.

Often, I see Game Programming '98 given names like...Game Programming in Pascal, Game Programming in C++, etc. I suppose I am accomplishing my coals with the site. =)

And I have to say, your page is great. It looks as if each issue is a monumental undertaking. Keep up the good work! Oh yes, thanks a lot for reviewing Game Programming '98. I appreciate it very much.

Take care!

Michael Tanczos
Game Programming '98

For any of you readers that didn't notice, gameprog.com was 
the winner of our Site of the Month last month. Be sure and
go there soon to get whatever you need in the way of 
programming techniques, from starfields to .mod file formats.

Hi there,

Can you release Issue 5 right now??? I really like to see more of Petter's ASM series. His first article is really great. I understand it all (it's not always that way with me), unlike some other tutorials. Doesn't know what we need, but what we want!!!

Seyuan Yang

Thanks for the letter! Sorry we can't release more often 
(due to the amount of time it takes to prep an issue). I love 
Petter's series, too! One of the first asm tutorials that I've
read where I understand every word.

Hey

My name is David Devenaud. While doing a history project, I had an inspiration, and wrote this:

Is it just me, or are Qbasic games getting better by the week? QB programmers are now creating games that people outsite the community might actually play! Gone are the crappy little text games that had no interface; now everyone is making an RPG, and that isn't a coincidence, I think.

RPG's are the hardest type of game to make, and the most fun to play if done right. Look at Zelda 64; it's supposed to be the game of the decade that will decide the fate of the N64. Because of all sorts of libraries, sound, graphics, and other tools, it is now possible to raise the standards and make games that are good quality.

Not that RPG's are teh only games that can be good. Every type of game can. But because of all these semi-finished projects, good QB games are like diamonds in the rough. We need to make it more like there's a few bad apples out of all the QB games.

The old, good QB games are not going to go away. We will have as many games and possibly could make commercial-quality games.

Here's an idea: maybe all Qb programmers could come together; sort of in one big software company, creating excellent games very quickly. We could be the next Microsoft (but less evil) of games. One idea would be passed along, improved upon, written, compiled, artwork drawn, in like a month. A new good product every month, with Silicon Valley headhunters beating a path to our door (Maybe). What would it's name be? With this idea, we could make some money, maybe. Anyway, that's just an idea. Keep on programming.

Even though, as I've said on almost every webboard, I am 
totally against the idea of more than 4 or 5 person qb groups,
if you're interested in this idea, contactDavid. 

Dontcha think a product a month seems a little fast though? Square
has 100 ppl working round the clock on FFVIII and it's taking years!

Wow! Issue 4 of QBASIC: the Magazine was undoubtedly teh best collection of qbasic related rants, raves, articles, etc. that I have ever read! I knew that you were going to release Issue 4 today, so I stayed up to get it! Now it's 12:30 on the 15th of November. (Yes...only 39 minutes since you released Issue 4 to the world)! Good job!

Pete

Why thank ya! Why can't more of you be like good ol' Pete here? :)

qbasic: the magazine reserves the right to edit any letter recieved for purposes of clarity and space. But you already knew that.

Here's the results of the third survey from Qbasic: The Magazine! We need more people to Vote! So do it!

    Favourite Game     |  Last Month  | Change    
    1. Wetspot 2              1           <> 
    2. Dark Ages              2(t)        <> 
    3. SFB2 (t)               2(t)        D1  
    3. Groov Buggies (t)      -           --
    5. Monospace S. (t)       -           -- 
    
    Comments: Wetspot 2 did well again. Dark Ages pulls ahead  
       of SFB2, and Groov and Monospace Shooter join the list.

    Favourite Utility  |  Last Month  | Change
    1. DirectQB               1           <>
    2. DashX (t)              2           <>
    2. N!Media (t)            -           --

    Comments: Dqb and Dash were very close this month, with
       N!Media's new version helping it garner votes. QMIDI
       didn't get enough votes to make the list.

    Best Upcoming      |  Last Month  | Change
    1. Dark Ages 2            3(t)        U2
    2. "Project RT" (t)       -           --
    2. Sypharage (t)          -           --
    4. Mario Clone (t)        1(t)        D3
    4. Last of Legends (t)    -           --
    4. Pasco Soccer (t)       -           --
    4. Groov 2 (t)            -           --
  
    Comments: Dark Ages 2 beat everything by a TON, easily
       pulling back into first. Mario Clone fell from the 
       top spot, and Wrath of Sona didn't get any votes this
       month. Enhanced's new project, "Project RT", got a
       lot of votes despite being top-secret! Wow!

Make your vote count! Vote today by emailing your votes for:
favourite game
favourite utility
Game/utility that you're most looking forward to.
Send your vote here

Must Downloads returns for another showing. This month, we've added Absolute Assembly , by our good friend Petter. Why use DEBUG when this nifty tool exists? We've also changed the recommended qmidi from 2.0 to 4.1. Everyone knows that there are a god-awful amount of qb games out there, but what's worth downloading? These, my friend. Here, you'll find a list of the best of the best in QB progs. See something that should be here? Tell us and we'll check it out. You HAVE to have this stuff!

Absolute Assembly
Petter Holmberg of Enhanced Creations's assembly converter. By typing in normal asm, this proggy will convert the asm into goods that qb will understand. Super-spiffy!

Dark Ages
One of the most engaging QB games ever, as well as one of the only complete rpg's. This was featured in PC Gamer! Check it out!

Groov Buggies
The best QB racer ever. Although it has some control problems and some clipping glitches, this wireframer set a new standard.

Lianne...in the Dark Crown
Darkdread best and most complete game. Many hours of gameplay, and featuring a battle system that's been imitated in countless qb projects since. Not to mention you get cat food from the enemies!

Monospace Shooter
Gradius' 2 color side-scrolling space shooter. Featuring very detailed enemies, flickerless animation and a devious AI, this game is a classic

Wetspot & Wetspot 2
Wetspot, the bubble-bobble like block-pushing action game was one of the best QB games when it came out, but W2 is just incredible. Super midi sound, great fast graphics, tons of variety, an insane number of levels...everything you could want. GET this game. Now.

SFB2
One of only 2 fighters in QB (the other being Sphere Fighter) this newly released game is Super-fab. Even though it's wireframe, it has cool particles and smooth animation as well as rippin' gameplay.

PP256
Called the best tile editor in QB ever, PP256 has loads of tile-editing options at your disposal. If you use tiles in your game, you can't live without this.

DirectQB/DashX/Blast!
These 3 sets of libraries take QB graphics to the extreme. They all have strenghts and weaknesses, but you should check them all out before you start a big project. You'll save a lot of coding plus get a big speed increase (and in DQB's case, save memory). Try these now.

QMIDI4.1
This is the best version of Qmidi. Play .mid's in your game! The new qmidi4.1 rules! It has tons of features and a "light" version. Get it now!

Pb3d
Marko Dokic's 3d routines. Phong shading, gourard shading, environment mapping, you name it- it's here. If you want to see how to do good 3d, come here!

Alternate Logic

Alternate Logic, a site run by HAL_8900, is the site to go to if you're lookin' for qb specific tutorials. From beginners to advanced, you'll be able to get whatever you need to do at this resource.

Need to know what bits are, or how to write a tsr in qbasic? You'll find it here. When I say this is the place for qb tutorials, I mean, this is THE place. That's why Alternate logic is the third winner of qb:tm's Site of the Month award.

Back to Top

To begin with, we will work with DEBUG and CALL ABSOLUTE as our tools to learn assembler. But as I told you, DEBUG is hard to use, so I have created a program that makes everything a whole lot easier. It is called Absolute Assembly, and it can be downloaded at the Enhanced Creations website at this address. The last version was written many months ago, but it works fine. This program releaves you from the pain of using DEBUG manually to create a program. It takes a raw text file with assembly code as input, and through DEBUG generates a snippet of QuickBASIC code in a file of your choice. I'll give you the details as we continue.

The basics of assembler:
Now we are ready to begin discussing some serious stuff: The first steps into the asm world!
First of all: When working with assembler, you mainly process a lot of numbers. These numbers needs to be stored somewhere. You can of course use the memory to store your data, but there's another way to do it: Through registers. Registers are a bit like variables, but they're not stored in the memory as variables are. They are stored in the microprocessor, where they can be accessed instantly and effectively. However, there are only a few of them, so you'll have to use them carefully and keep track of what you're doing with them. Many registers also have special uses, so you can, and must, use them only in certain places. This may seem a little confusing to you right now, but you will soon understand how it works.

There are four basic registers that can be used for almost anything. They are called AX, BX, CX and DX. You can think of these registers as INTEGER variables in QuickBASIC. They are small memory cells that can store a 16-bit large number. If you want to use only one of the two bytes in these registers, you can do so by calling them AH/AL, BH/BL, CH/CL, and DH/DL. The H and L stands for "high" and "low". So you can use only the upper 8 bits of the AX register by calling it AH, and the lower 8 bits by calling it AL. On 386 computers and later, you can also call these registers EAX, EBX, ECX and EDX, and use them to store 32-bit large numbers. I'll better draw this to make you understand it:

Writing data into AL doesn't affect AH, but it affects AX and EAX. The same rules goes for BX, CX and DX. Remember that this is all just different names to access different parts in the same register. As DEBUG cannot handle any 386 or above processor instuctions, we won't be using 32 bits registers as long as we're working with it.

Although these four general purpose registers can be used for almost everthing, they also have special purposes. The A, B, C and D in the registers actually stand for Accumulator, Base, Counter and Data. I will tell you when they should be used when we come to such situations. There are many other registers with more special uses that you will need to learn, but I will return to them later when we need them. Now we're going to learn our first assembly instruction!

MOV, your key to data transfer:
The most common and important assembly instruction is called MOV. Assemblers in most platforms have this instruction. It's purpose is to move or copy values between memory and registers. As you probably guessed, MOV is short for move. Most assembly instructions are three letters long. The name is a little misleading, because moving a value would mean taking it away from the source, but MOV actually copies the value. The general syntax for MOV is:

MOV destination, source

Beginners always tend to mix up the positions of the source and destination with MOV. It may seem more natural to put the source first, but if you think about it you'll see that you do the same in BASIC. (destination = source) The source can be a direct number, a register or a value in the memory. The destination can be a register or a memory position. Here are some exaples: If you want to put the value 8 in the AX register, you type:

MOV AX, 8

If you would like to copy the contents of the CH register into BL, you type:

MOV CH, BL

A thing that you cannot do is to move a 16-bit value into an 8-bit register. An instruction like MOV AL, BX is therefore not possible.

But what about values in the memory? Well, then you must learn to use three new registers: DS, SI and DI.

Accessing the memory:
In order to be able to read and write in the memory, you need the special memory addressing registers. If you want to read data from the memory, you must put the memory address into the two registers DS and SI. Their full names are the Data Segment register and the Source Index register. In DS, you should put the segment address of the memory position you want to read from, and in SI you should put the offset address. How this works was discussed in part 1 of this tutorial.

Suppose you want to copy byte number 18 in the memory into AL. Then you need the following assembly code:

MOV BX, 1
MOV DS, BX
MOV SI, 2
MOV AL, [SI]

This requires some explaining. First of all: It's impossible to move direct values into the DS register. Don't ask me why, but it has to do with the Intel PC processor architecture. So what you need to do is to put a value in one of the general purpose registers, here I used BX, often used in this situation, and then copy the contents of that register into DS. That explains the first two lines. Next we put a value into the SI registers. Luckilly this can be done directly. We wanted memory position 18, and now the DS register is 1 and the SI register is 2. Remember that the actual memory position is the segment times 16 plus the offset. In our case this gives us 1*16+2=18. The final line copies the byte located at this memory position into AL. The brackets [] around SI means that the computer should fetch the byte at the memory position pointed out by SI, (DS is automatically assumed to hold the correct segment address) instead of the value in SI itself. Without the brackets, the value of SI, 1, would get into AL. Well, actually that wouldn't work because AL is only 8 bits and SI is 16 bits. If it had been the whole AX register it would work though. But with the brackets, the value from memory position DS * 16 + SI is read.

If you want to do the opposite, write to memory, you use DI instead of SI. DI is short for Destination Index. Writing data is done in almost the same way as reading data. If you would like to write the value 5 into the same memory position as we were reading from in the previous example, you type this:

MOV BX, 1
MOV DS, BX
MOV DI, 2
MOV AL, 5
MOV [DI], AL

Easy, huh? Here the DS register is also used for the segment address. In this example, AL, an 8 bit register part, is used, and so 8 bits will be written to memory. If you had changed AL to AX, 16 bits would have been written.

Now you should know how to read and write values from/to registers, and how to access specific memory positions. But you can't do much with it yet. Now it's time to learn how to call asm routines from QB!

The interface:
Now you need to have both DEBUG and Absolute Assembly, the two programs I talked about earlier. You won't have to know how to use DEBUG, because Absolute Assembly will do all the dirty work for you. You can use your favorite text editor when creating your assembly routines. Just make sure the code is saved in a file of the standard ASCII .TXT format. When you want the code to be fed into QB, you just start Absolute Assembly. You will be asked to type in the name of the text file containing the asm source, the QB program file to put the code in, and the name of a code string. Make sure you have saved the BAS file in standard ASCII format (this only applies to QuickBASIC users). The code string is a string variable name that is going to be used in the QB program to access the code. If you're making an asm routine to draw pixels on the screen, you should call it drawpixel$ or something like that. You don't have to type in the $ sign in Absolute Aseembly. Next, you will be asked to answer yes or no to two questions. The first asks you if you want to append the code to the basic source file. If you answer no, your BAS file will be cleared before the code is written to it. If you answer yes, the ASM code will end up in the bottom of the file, without erasing its old contents. The other question is if you want to add CALL ABSOLUTE lines to the program. This is a little hard to explain right now. I'll get back to it soon.

Our first assembly routine:
It's time to try writing an asm routine for QB. The first test routine won't do anything, it's just a test. First, start your favorite text editor and type in the following lines:

PUSH BP
MOV BP, SP
POP BP
RETF

Now you wonder what this means, but don't worry, I will explain it to you. The first line is a new assembly instruction for you: PUSH. This introduces a new part of assembly programming. PUSH is an instruction used to put values on the stack. What is the stack then? Well, it's a part of the memory that can be used to store temporary values. You will often have the need to keep track of more numbers than there are registers, and the most convenient way to go then is to use the stack. The stack is a place where you can shuffle away values until you want to use them. PUSH is the instruction you use to copy a value to the stack. When you want to get the value back, you use the opposite of PUSH, an instruction called POP. You can see that POP is used on the third line of the program. There's a special register that keeps track of where in the memory the stack is located. It is called the Stack Pointer, or SP. When you use PUSH, the value goes to the memory address in SP. Then SP is changed, so that it points at a new memory position in the stack. This works a little strange. You can think of the stack as a stack of plates. When you use PUSH, it's like you were putting a new plate on the stack. When you use POP, you remove it, revealing the plate underneath. So you must keep order of the values you put on the stack. Consider this example:

PUSH AX
PUSH BX
POP AX
POP BX

First, AX is copied to the stack, and then BX. When the first POP instruction is called, the value that was last put on the stack, the BX value, is returned to AX. When the second POP is called, the first value of AX gets into BX. So this example will actually swap the values in AX and BX, using the stack. If you want the values to get back in the right order, you must POP them in the opposite order:

PUSH AX
PUSH BX
POP BX
POP AX

This would correctly return the values to their original registers. This is a technique called LIFO, and it stands for Last In, First Out. Get it? Of course, there's no reason to PUSH and POP values like in the example above, but if you needed AX and BX for other things between the PUSH and POP calls, you would find it very useful.

There's a strange thing about the stack that you need to know also. The image of a stack of plates is not entirely correct. The value in the SP register is not increased after each PUSH, it's actually decreased! So it would be more like a stack of plates turned upside down, even though earthly physics obviously woldn't accept stacks of plates hanging upside down on the roof. :-) This is not something you need to care about now though.

Now let's return to the test program. As you can see, the PUSH instruction uses a register called BP. This is another new thing for you. BP is short for Base Pointer, and it is a value that points to the base of the stack. So in the plate example, it would point at the plate in the bottom of the stack, (if you ignore the upside down-thing for a while). It's essential that this value stays the same before and after the call to the asm routine, because QB uses it too. So therefore we always PUSH it in the beginning of the routine, and then POP:s it back in the end.

Now we have come to the second line. By now you should understand what it does: It puts the value of the SP register in BP. Now the computer will think that the bottom of the stack is at what's actually the top of the stack. In the next part of this tutorial series I will explain why we do this. After the first two lines, we would be free to write anything, but as we don't want the routine to do anything yet, we'll just POP the old value of BP back and return to QB. The last line with an instruction called RETF, which stands for Return Far, will make sure we get back to the BASIC program.

Let's try this out:

• First, type the four lines into a text file and save it. Let's call it ASMTEST.TXT!
• Then: Run Absolute Assembly.
• First you will be asked to type in the name of the asm sourcefile. Type ASMTEST.TXT. Usually, assembly source files have the extension .ASM, but it doesn't matter what name you use.
• Then you type in the name of the BASIC sourcefile. Since we don't have one, just type ASMTEST.BAS, and this file will be created.
• Then you must type in the name of the code string. call it test.
• The program now asks if you want to append the asm code to the BASIC file. Since the BAS file is empty, press the N key for no.
• Finally the program asks if you want to add CALL ABSOLUTE lines. Press Y.
• Now DEBUG should be executed by the program, and it will prompt you what is happening. If everything was done correctly, the program will ask you if you want to convert another file. Press N and exit the program.
• Now open the file ASMTEST.BAS in QB. You will see this:

' ------ Created with Absolute Assembly 2.1 by Petter Holmberg, -97. ------- '

test$ = ""
test$ = test$ + CHR$(&H55)              ' PUSH BP
test$ = test$ + CHR$(&H89) + CHR$(&HE5) ' MOV BP,SP
test$ = test$ + CHR$(&H5D)              ' POP BP
test$ = test$ + CHR$(&HCB)              ' RETF

offset% = SADD(test$)
DEF SEG = VARSEG(test$)
CALL ABSOLUTE(offset%)
DEF SEG

' ------ Created with Absolute Assembly 2.1 by Petter Holmberg, -97. ------- '

As you see, there's now a string variable called test$. For each line, numbers (converted to ASCII codes) are added to the string. On the right, you can see the assembly instructions you typed in earlier as comments. For each line, one assembly instruction, or more correctly, one machine language equvivalent to an assembly instruction, is added to the string.

Because we answered yes to the question if we wanted to add CALL ABSOLUTE lines to the BAS file, there are also four other lines under the test$ declaration. the offset% variable gets the offset address of the string test$, and the DEF SEG instruction makes sure the default segment is the segment of the test$ string. (DEF SEG in QB is almost the same as typing MOV DS, BX in assembler)

And now comes the CALL ABSOLUTE call. This line will execute the code located at the start of the test$ string. As this test program doesn't really do anything, you won't see anything happening. Finally, the second DEF SEG resets the default QB segment. Run the program and make sure it actually works! It won't do anything, but just the fact that it didn't crash is enough to make an assembly programmer happy!

This is the end of the second part of my assembly tutorial. I've tried to go slowly in the beginning so that you would understand everything, but now the vital basics of assembler should be crystal clear for you. The next time we can start the fun! I will teach you more assembler instructions, and we will start writing programs that can do something useful, such as manipulating BASIC variables and returning the answer. As the last time, make sure you understand everything I explained in this part, and I'll see you in January!

Have a Merry Christmas and a Happy new Year!

Petter Holmberg

Back to Top

Back to Top

SUB SCRIPTINTERPRETER (SCRIPTFILENAME$)

  OPEN SCRIPTFILENAME$ FOR INPUT AS #1

DO UNTIL EOF(1)
 
  INPUT #1, SCRIPTCODE$
  
    IF MID$(SCRIPTCODE$,1,1) <> "*" THEN
   
        KEYWORD$=""
        PERAMITER$=""
      FOR I=1 to LEN(SCRIPTCODE$)
        IF MID$(SCRIPTCODE$,I,1) = ":" THEN
           KEYWORD$ = MID$(SCRIPTCODE$,1,I-1)
           PERAMITER$ = MID$(SCRIPTCODE$,I+1,LEN(SCRIPTCODE$))
          EXIT FOR
        END IF
      NEXT I
    
       SELECT CASE KEYWORD$
   
           CASE "MESSAGE BOX"
             CALL MESSAGEBOX(PERAMITER$)
   
       END SELECT

    END IF

LOOP

  CLOSE #1

RETURN

*This is the first script!
*The line below will allow us to do a MESSAGE BOX
MESSAGE BOX: What do you think?
*Okay now this maybe simple so far but check back for the 
*next article installment
MESSAGE BOX: Bye-Bye!

Back to Top

Enigma, artist extraordinaire and writer of the Art article in this issue, will be doing anime-style cutscenes for the game, which will have a look much like what was seen in the Dark Ages 2 preview movie (address is below). Sylvain Mercure of Quebec will be creating a Windows installation program and also be doing a French Translation! Next spring, I'm gonna be the first one lined up to download DA2, and as this month's Survey shows, there're lotsa people who agree. If you need more DA2 action, haul your browser to the official "Dark Ages 2: Tatkraftengel" web site.

Back to Top

SUB BlowStack()
CALL BlowStack()
END SUB

TYPE PersonalInfoType
  theName as string * 10
  age as integer
  address1 as string * 20
  address2 as string * 20
END TYPE

DIM info AS PersonalInfoType

info.theName = "John"
info.age = 23

DIM info(3000) as PersonalInfoType

Back to Top

Thanks for reading Issue 5! Next issue is coming on 16 January, so mark your calenders! We should have the next asm article, another part of the RPG script series, possibly an art article and more! Yeah, baby! Also, don't forget to register your QB company with the Visionaries Exchange. Till next time... END