Starting a fighting game

[na_th_an]

1.- Using a buffer: basicly you blit stuff to a buffer, which is a virtual screen. Then, when you're done, you copy your buffer to screen to make changes visible, usually synchronizing it with the VGA refresh (WAIT &H3DA,8: WAIT &H3DA,8,8 stuff).

A buffer is just a piece of memory. It is very handy making it just like your screen, so copy is direct. VGA mode13h screen takes 64000 contiguous bytes, so that's all what we need. The easiest way of allocating 64000 contiguous bytes in QB is DIMming an array that takes 64000 bytes. For example, an integer array of 32000 elements (each element is 2 bytes, so 32000x2=64000):

Code:

DIM MyBuffer%(31999)  ' 0 to 31999 -> 32000 elements

You have three choices to implement a double buffer:

a.- The easiest: use a lib.
b.- Use GET and PUT along with Plasma357's routines (SetVideoSeg). SetVideoSeg just changes the VGA segment (&HA000) so QB thinks VGA is where you tell him it is (i.e. your buffer) so graphic stuff will be drawn on your buffer and not on screen.
c.- The hardest: Code your own blitters that draw to a buffer instead of drawing to screen.

To copy the buffer to video memory you can do three things, again:

a.- The easiest: Use a lib.
b.- You can grab somewhere a short ASM code embedded into a SUB that copies memory. It is called MemCopy and you can get it in the ABC packets (search google with qb memory copy abc). You can use SETVIDEOSEG to draw in your buffer, and MEMCOPY to copy to the actual screen.
c.- The hardes: Make your array compatible with the GET/PUT format and use PUT to copy it to screen. This involves doing some calculations, but SETVIDEOSEG won't work straightforward (without having to play a little bit with it).

This works 'cause while you are drawing stuff it is not seen, so you can clear the buffer and put your sprites again without being noticed by the player. When you copy the buffer to screen the objects will be completely drawn.

The basic double-buffer loop can be as follows:

Code:

DO
   ' Do game (movement and stuff).
   ' Draw stuff on buffer.
   ' Wait to VGA refresh (WAIT &H3DA,8: WAIT &H3DA,8,8)
   ' Copy buffer to screen
LOOP

2.- Segments and offsets come to play when you are doing buffering or when you want to access memory directly. How do you use them? Well, usually you use them in two circumstances:

a.- Directly accessing to variables and/or arrays to BSAVE or BLOAD stuff, that case you just use VARSEG(variable%) or VARSEG(array%(0)) to know the segment and VARPTR(variable%) or VARPTR(array%(0)) to know the offset.
b.- To use with libraries/SetVideoSeg/Memcopy: Just the same. For example, SetVideoSeg needs your buffer's segment, so you can call it with VARSEG(buffer%(0)). Memcopy needs segment and offset of source and destination. To copy your buffer to screen just...

Code:

MemCopy VARSEG(buffer%(0)), VARPTR(buffer%(0)), &HA000, 0, 64000

You are giving: 1.- your buffer segment. 2.- Your buffer offset. 3.- VGA segment, 4.- VGA offset, 5.- # of bytes to copy (64000).

3.- Of course it matters. It is not a good policy to consider stuff as "black boxes" that simply "do stuff". If you understand how things work you'll be able to improve your algorithms and/or maybe change some stuff when you come to a problem.

---

PS.- I suggest you to learn basic stuff like double buffering before trying to code a fighting game... Or it will be a nightmare.