Copy Link
Add to Bookmark
Report
The Basix Fanzine issue 04
--------[ T H E ]-------------------------------------------------------
BBB A SSS IIIII X X
B B A A S S I X X THE BASIX FANZINE WRITTEN FOR
BBB AAA SS I X BASIC PROGRAMMERS BY BASIC
B B A A S I X X PROGRAMMERS
BBB A A SSSS IIIII X X
------------------------------------------------------------------------
The BASIX for BASIC for 1996! Written by Peter Cooper of Peco Software
------------------------------------------------------------------------
peter@trenham.demon.co.uk
INTRODUCTION:
I have some VERY big apologies to make. Last month, in the Christmas
Special, there were some really big mistakes such as missing names,
unfinished last words etc.. sorry. I posted it without looking at it.
That was on Christmas day.... sorry 8-) Hopefully no such mistakes with
this fanzine. Same format as last month but better! hehe 8-)
The fanzine has a WWW page now as well, and a mailing list so you don't
miss new fanzines! Also sorry for the delay for this fanzine to appear
I did not have a very good response during January but now I have enough
articles to place in the fanzine. Thanks for your help.
______________________________________________________________________________
| CONTENTS PAGE | The standard stuff here! |
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
SECTION ONE) - [SPECIALIZED ARTICLES]
- Part [a] ADVANCED\HARDER STUFF
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1) GFX Colliding! The regular Wrox Press article QBasic + upwards
2) Char. Redefine Redefining text mode characters QuickBasic\PDS
3) 3D Programming The first in a series of 3D tuts PB (QB poss)
- Part [b] EASIER MORE DOWN TO EARTH STUFF
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1) Basic Tutorials Zooming into the third installment QBasic + up
2) GFX Tips+Tactic How to load+read the display fully QBasic + up
SECTION TWO) - [ALL LEVELS ARTICLES]
1) Useful sources Places to get basic stuff on inet Any
2) Basic on IRC IRC? What is it? Is basic there? Any
3) Structured Progs Being stylish (and more compact!) QBasic + up
SECTION THREE) - [YOUR SHOUT!+FUN]
1) Q+A Your questions\our answers Any
2) Your programs All of your programs.. here! Various
3) Zephyrs Lib A readers look at a super lib. QuickBasic/PDS
SECTION FOUR) - [DETAILS ABOUT THE FANZINE]
1) Latest developments
2) How do you contribute?
3) How do you contact the author?
4) Credits
5) Last words + next month
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
- SECTION ONE -----------------------------------------------------------------
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Specialized articles:
This section is split into two parts. Part A is for the more advanced or
intermediate programmer in basic and Part B is more for the beginners of
BASIC. This sort of layout was something people wanted. Sorry if it seems
rather insulting but well sorry.
______________________________________________________________________________
| SECTION 1 PART A SUBPART 1 | GFX Colliding! |
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Our regular article from Wrox Press!
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Perhaps I had better go into a more detailed description of the book. If
you ever want to see more of the companies books and samples of them then
check out their WWW site: point your URL browser at: http://www.wrox.com/
See more info in the Q+A section of the fanzine about what is in the book.
COLLISION DETECTION
~~~~~~~~~~~~~~~~~~~
We could convert the previous example to check for our sprite crashing into
the furniture, but it would be slow and tedious if the room were full of
armchairs.
So we must use another method for detecting collisions between sprites. One
way is to check certain pixels around our sprite for a change in color,
using PSET, and react according to the color found. If, for example our
spaceship encountered an asteroid field which consisted of brown asteroids
, we could check all the points around the spaceship every time it is
moved and, if a brown pixel was detected, an explosion would occur.
But checking every point around our sprite is very time consuming. A much
better technique is to check the most prominent points - 5 points at the
nose, 5 at the tail and perhaps 10 points above and 10 points below. This
would enable us to keep detecting while maintaining an adequate speed.
Let's take a look at this next piece of code which you can find at work in
\CHAP12\CH12_5.BAS on the disk (which comes with the book):
starcolor% = 2 'Select green stars
FOR top% = Ship.X% TO Ship.X% + 10 '10 pixels above sprite
pixelcolortop% = POINT(top%, Ship.Y% - 1) 'Get pixels color
IF pixelcolortop% = starcolor% THEN 'Is it green?
LOCATE 1, 1 'If it is...
PRINT "Top hit!" '...then print this...
GOTO Finishdetect '...and exit loop
END IF 'Or else...
NEXT top% '...try next pixel
FOR bottom% = Ship.X% + 5 TO Ship.X% + 15 '10 pixels below sprite
pixelcolorbottom% = POINT(bottom%, Ship.Y% + 10)
IF pixelcolorbottom% = starcolor% THEN
LOCATE 1, 1
PRINT "Bottom hit!"
GOTO Finishdetect
END IF
NEXT bottom%
FOR left% = Ship.Y% TO Ship.Y% + 5 '5 pixels left of sprite
pixelcolorleft% = POINT(Ship.X% - 3, left%)
IF pixelcolorleft% = starcolor% THEN
LOCATE 1, 1
PRINT "Left hit!"
GOTO Finishdetect
END IF
NEXT left%
FOR right% = Ship.Y% + 2 TO Ship.Y% + 7 '5 pixels right of sprite
pixelcolorright% = POINT(Ship.X% + 25, right%)
IF pixelcolorright% = starcolor% THEN
LOCATE 1, 1
PRINT "Right hit!"
GOTO Finishdetect
END IF
NEXT right%
Finishdetect: 'End detection
The listing is fairly straightforward and has the added bonus of ending
detection immediately when a collision has been detected.
Good collision detection is essential and the lack of it is one the
main reasons for games receiving poor comments from reviewers. Test
, test and test it again.
You can contact Wrox Press, the publishers of this book, at the following
places using the following methods:
Editorial : Unit 16, 20 James Road, Tyseley, Birmingham, B28 0EE, UK
Marketing : 2710 W. Touhy, Chicago, Illinois, 60645, USA
Internet : adrians@wrox.com Or the Web Site: http://WWW.WROX.COM/
So after the 20th February where will you be? At the bookshop! 8-)
______________________________________________________________________________
| SECTION 1 PART A SUBPART 2 | Redefining Characters |
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
This program will change ascii character 65 (A) into a small stick figure
So all of the As will be stick men. This program is fully tested but it may
be incompatable with your BIOS. (I have a very popular AMI BIOS)
Remember that QB4.5 or PDS7 should be loaded with the /L switch to have
QBX.QLB or QB.QLB loaded.
This program I am sure will interest you people out there that want to write
games in text mode and have your own custom characters.
'$INCLUDE: 'qbx.bi' 'Change to QB.BI for QB4.5
DIM SHARED inregsx AS RegTypeX
DIM SHARED outregsx AS RegTypeX
DIM chardata AS STRING
chardata = CHR$(60) + CHR$(66) + CHR$(66) + CHR$(129) + CHR$(129) + CHR$(66) + CHR$(24) + CHR$(24) + CHR$(126) + CHR$(24) + CHR$(24) + CHR$(24) + CHR$(36) + CHR$(36) + CHR$(195)
inregsx.ax = &H1100
inregsx.bx = &H1000
inregsx.cx = &H1
inregsx.dx = 65
inregsx.es = SSEG(chardata)
inregsx.bp = SADD(chardata)
CALL InterruptX(&H10, inregsx, outregsx)
Let me step through the code and explain it...
'$INCLUDE: 'qbx.bi' 'Change to QB.BI for QB4.5
DIM SHARED inregsx AS RegTypeX
DIM SHARED outregsx AS RegTypeX
DIM chardata AS STRING
This loads up the include file for your MicroSoft basic compiler and also
declares some variables for use by the program.
chardata = CHR$(60) + CHR$(66) + CHR$(66) + CHR$(129) + CHR$(129) + CHR$(66) + CHR$(24) + CHR$(24) + CHR$(126) + CHR$(24) + CHR$(24) + CHR$(24) + CHR$(36) + CHR$(36) + CHR$(195)
This is more interesting. This creates the shape that asc character 65 is
changed to. It is made up like so (only shown the first line):
This is a grid of 8 bits for the first line. Each bit has a value doubling
each time.
Value: 128 64 32 16 8 4 2 1
_________________________________________
| | | | | | | | |
| | | | | | | | |
| | | | | | | | |
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
For the value 60 (the first, top line) the following bits would be set:
Value: 128 64 32 16 8 4 2 1
_________________________________________
| | |XXXX|XXXX|XXXX|XXXX| | |
| | |XXXX|XXXX|XXXX|XXXX| | |
| | |XXXX|XXXX|XXXX|XXXX| | |
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
That is because as you can see the 4,8,16,32 valued bits are set. These
numbers add up to 60 and so that is what the top line of the character looks
like. It's hard to grasp and understand, perhaps could be the subject of a
tutorial some time? (binary)
inregsx.ax = &H1100
inregsx.bx = &H1000
inregsx.cx = &H1
inregsx.dx = 65
This section of code sets some registers for calling the interrupt. You do
not really need to worry about all of these but the inregsx.dx one is useful
The dx one selects which ASCII character you want to adjust, 65 is A, 66 is
B and so on, there is an ascii code for every character that you can see on
your screen.
inregsx.es = SSEG(chardata)
inregsx.bp = SADD(chardata)
CALL InterruptX(&H10, inregsx, outregsx)
This sets some other special registers to the memory segment and offset that
the character shape data is at. The CALL InterruptX then calls the hardware
interrupt that changes the shape of the ascii character in DX (65).
So now many of you can probably understand how to make any type of
characters you want. You have a nice grid of 8x16 to use and in that you
can fit maybe a character of a house, man etc...
______________________________________________________________________________
| SECTION 1 PART A SUBPART 3 | 3D Programming |
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
--------------------------------------------
/ / |
--------------------------------------------- |
3D Graphics in BASIC - Part I.1: Introduction /
---------------------------------------------
HEY YOU !
Interrested in programming vector graphics ? Bored of painting 2 dimensional
diagrams. Feared of using C/C++ ? Or are you a math dummie ?
No panic.
Spend some time (and of course even more time at your PC) with me and join
me into the wonderful world of ...
3D Graphics in BASIC (yep, it's possible !!!)
Before I fill your brain with lot of stuff like vectors, matrix, filled
polygons or shading techniques in the next five parts (this text included),
I'll introduce me to my person:
I'm Christian Garms, a german chemistry student and programmer. Last year
I've made some nice money with Visual Basic programs in MS Excel and that's
why I think BASIC is the opposite of a dead programming language. I'm a
registered PB user but the examples that will be post in this article should
work with both QB and PB (eventually with minor modifications).
For questions, REMarks or comments send an e-mail to:
garms@chemie.uni-hamburg.de
I assume that you're not a BASIC beginner. Hope that you're at least an
advanced programmer because this article is not a bedtime story.
But the sweetest fruits are hidden and hard to get.
Most programs will do the trick without any assembly additives to speed up
the code. If x86-ASM is necessary I'll write it as INLINE Assembler.
Sorry QB Users but I have not much time to spend for converting INLINE code
into suitable OBJ-Files.
************************************************************************
Disclaimer:
The author, Christian Garms, is not responsible for any errors or damage
to your computer system caused by the posted BASIC programs.
The BASIC programs and snippets are free for any use.
************************************************************************
------------------------------------------------
/ / |
------------------------------------------------ |
3D Graphics in BASIC - Part I.2: some basic math /
------------------------------------------------
The hardest part to understand of 3D graphics is the mathematical background
that is - politely spoken - abstract.
But lets begin with an easier entry point. Point - that is the right object
to start with. In our three dimensional world all points consist of three
components, the x-, y- and z-coordinate. With these values every point is
strongly determined in his position. But to whom ?
That is the next thing to be dealt with: Coordinate systems !
For the beginning we start with only one coordinate system, the world
coordinates. That means all coordinates are related to an absolut center
somewhere in our real world. E.g.: a value of x = 0 , y = 0 and z = 0 define
a point exactly in the center of our world.
For a mathematician every point in the whole 3D world is a vector. That's why
3D graphics is also called vector graphics.
If we had a point Z who lies in the center of our world than the definition
of Z will be:
Z = (0 0 0)
Any other point P with unequal values to zero of x-, y-, and z-coordinates
would look like:
P = (<x> <y> <z>)
The letters in the brackets are placeholders for the corresponding values.
OK, lets return from the equation thicket to programming.
For further use we should define our own TYPE of variable, a vector !
**************************************************************************
' Creating own definition
TYPE vector
x AS INTEGER
y AS INTEGER
z AS INTEGER
END TYPE
' Declare p as vector
DIM p AS vector
' Sets p to the center of the world
p.x = 0
p.y = 0
p.z = 0
**************************************************************************
Listing I-2.1
Listing I-2.1 demonstrates the usage of user-defined types. User-defined
types makes your programs more structured and better understandable
than Listing I-2.2.
Especially when you have more than one point !
As you can see I'm using mostly integer arithmetics. That is a common trick
to speed up the output of 3D graphics enormously.
**************************************************************************
' Define point in the middle of the universe
px% = 0
py% = 0
pz% = 0
**************************************************************************
Listing I-2.2
------------------------------------------------
/ / |
------------------------------------------------ |
3D Graphics in BASIC - Part I.3: transformations /
------------------------------------------------
Now we have the simpliest object: a point. The next question is: How to
convert a point in our 3D world - or mathematically spoken a vector - into
a flat pixel on the screen.
So here comes the moment to introduce you with a new coordinate system - the
eye coordinate system. I think that you, dear reader, will ask WHY. Well,
imagine a scenery from any 3D game you have in mind. In most cases of these
games there is a craft that you fly, drive or move and others that will be
steered by your computer or someone else. You can look in all directions
without steering into this directions. This would be impossible if your
eye coordinate system is non-existant. In other words: The eye coordinate
system allows watching different from the world coordinate systems.
And now the strategy to convert a point into a pixel:
1. Transformation of the world coordinates into eye coordinates
2. Transformation of eye coordinates into screen coordinates
But some mathematics first. I hope you've got your machet right by your
hand and follow me again into the equation jungle. This time it will be
harder than last time.
Mathematicians are sometimes lazy to write complex formulas. In the case of
transformation of a vector to a new vector in another coordinate system like
the transformation of the world coordinate system into the eye coordinate
system they simply write:
P_eye = P_world * T
with P_eye eye coordinate vector
P_world world coordinate vector
T Transformation operator
That means: transformation of coordinates is only a "simple" mathematical
operation. But I would not go any further now because I've saved that for
Part II.
This time I'll explain the transformation by an example. Once again
you must imagine to sit in a craft in our virtual 3D game. Say you're at
Position x=100, y=0, z=0 and look to the center of our world. If you've
reset your nav computer and set the absolute position (0 0 0) to your craft
(the eye coordinate system) the center of the world now lies at
x=-100, y=0, z=0.
In Summary: the world coordinates of a point will transformed to
eye coordinates via the following equations:
x_eye = x_world - eyepos_x
y_eye = y_world - eyepos_y
z_eye = z_world - eyepos_z
with x_eye x-coordinate of the point (eye coordinate system)
dito with y_eye, z_eye
x_world x-coordinate of the point (world coordinate system)
dito with y-world, z_world
eyepos_x position of the watcher (relative to world center)
dito with eyepos_y, eyepos_z
But we gained also a three-dimensional point. How to convert this one into
a pixel? Now the mathematician comes in action. And he won't be lazy any
more ! He will tell you something about triangles, pyramids ... and you're
stuck complete helpless in the thickest formula thicket you could
think about. If there would be a chalkboard he would easily write it full
just for explanations. Simple, isn't it ?
Instead of molto formulos there is THE golden wisdom of every 3D-Programmer:
"The screen coordinates could be calculated by dividing the x- and y-
position through the depth (z-coordinate)"
In formula speak:
x_screen = x_eye / z_eye
y_screen = y_eye / z_eye
with x_screen x-coordinate of the pixel
y_screen y-coordinate of the pixel
x_eye, y_eye, see above
z_eye
You gain a dimensionless number that must be fit to screen coordinates and
to the middle of the screen.
I assume that the width and the height of the screen are given so the formula
results to:
x_screen = (x_eye / z_eye) * width + width / 2
y_screen = (y_eye / z_eye) * height + height / 2
Now we've got all parts together to write some real 3D stuff.
**************************************************************************
' Simple 3D Object (Pyramid)
' Type declarations
TYPE vector
x AS INTEGER
y AS INTEGER
z AS INTEGER
END TYPE
TYPE pixel
x AS INTEGER
y AS INTEGER
END TYPE
' Variable declaration
DIM p(3) AS vector
DIM eye AS vector
DIM s(3) AS pixel
DIM maxx AS INTEGER ' width of screen
DIM maxy AS INTEGER ' height of screen
' Screen resolution
maxx = 640
maxy = 480
' Read Object Data
FOR i = 0 TO 3
READ p(i).x
READ p(i).y
READ p(i).z
NEXT i
' Definition of object
DATA 30, 1, 1
DATA 1,30, 1
DATA 1, 1,30
DATA -30,-30,-30
' Set Eye position (change if desired)
eye.x = 0
eye.y = 0
eye.z = 100
' Calculate the eye coordinates
FOR i = 0 TO 3
p(i).x = p(i).x - eye.x
p(i).y = p(i).y - eye.y
p(i).z = p(i).z - eye.z
NEXT i
' Calculate screen coordinates
FOR i = 0 TO 3
s(i).x = (p(i).x / p(i).z) * maxx + maxx / 2
s(i).y = (p(i).y / p(i).z) * maxy + maxy / 2
NEXT i
' Draw object
CLS
SCREEN 12
FOR i = 0 TO 5
READ pt1, pt2
LINE (s(pt1).x,s(pt1).y)-(s(pt2).x,s(pt2).y)
NEXT i
DATA 0, 1, 0, 2, 0, 3, 1, 2, 1, 3, 2, 3
**************************************************************************
Listing I-3.1
OK, folks. Next time I will introduce you to animated vector graphics and
the calclulation with matrix. Stay tuned and I hope that you enjoy this article.
______________________________________________________________________________
| SECTION 1 PART B SUBPART 1 | Basic Tutorials - Part 3 |
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
BASIC Tutorials - installment 3
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Howdy! 8-) So what do you want to learn this week starting BASIC programmers?
I thought I'd go over a few BASICs (pun) and some useful routines. If you
want to have basic tutorials on anything else then mail the fanzine and I'll
be happy to type them up for you!
Recap:
- Variables are memory stores.
- Variables with text in are proceeded with a $
- Variables to store numbers are usually proceeded with a %
So the following program would take your age and store it in age%.
PRINT "Age:"
INPUT age%
A new format of the INPUT command:
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
In the previous example we displayed the question we wanted to ask 'Age:'
with a print routine. We can simplify that whole previous routine into one
INPUT command, look at this:
INPUT "Age:",age%
Basically what this means is that after the prompt 'Age:' is displayed then
read in the age and place it into age%. Look at the following:
INPUT "Name:",n$
Common-sense should tell you that that command would display 'Name:' on the
screen and then place whatever you type into n$.
Looks so simple, doesn't it?
Other commands which are useful to use:
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
We can use other commands in conjunction with the INPUT and PRINT commands
to make it all look prettier. The first command is CLS . Looking at it it
means:
CLear the Screen = CLS
That will clear the screen of all of its text and leave you with a clean
screen to place text on.
There is also another command which you will find useful. It is called COLOR
and yes I know it is spelt a bit strangely but thats the American way of
spelling it (although I assume 90% of readers are American). 8-) Anyway
this command is followed by a number which dictates what colour the text will
be shown as:
0 - Black
1 - Blue 9 - Bright Blue
2 - Green 10- Bright Green
3 - Cyan 11- Bright Cyan
4 - Red\Brown 12- Bright Red
5 - Dull Purple 13- Bright Purple
6 - Brown 14- Bright Yellow
7 - Dark White 15- Bright White
8 - Dark Gray
You can place a COLOR command before any PRINT or INPUT command to change
the colour of its text. Look at this:
CLS
COLOR 15
PRINT "Details Program"
PRINT ""
COLOR 6
INPUT "Age?",age%
COLOR 14
INPUT "Name?",n$
CLS
COLOR 15
PRINT age%
PRINT n$
As with the INPUT command the PRINT command can also have variables
attached to it for it to print. For example if the previous program could
actually say 'Hello [your name] You are [age] years old.', it would be
better. It can! Look at this example of the print command.
PRINT "Hello, ",n$
print "You are ",age%," years old"
If you can get your head around the working of this then you'll be a master
in no time.
In Closing
~~~~~~~~~~
I'll be going into explaining the last piece of code in the next fanzine.
It'll be part 4 of the Basic Tutorials. Part 5 will cover location, loops
and logic. After that more tutorials will follow but in more specific
areas of BASIC.
Cheerio
______________________________________________________________________________
| SECTION 1 PART B SUBPART 2 | Graphics tips and tactics |
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
This article is by James Erickson, he can be reached at:
ericksnj@teleport.com
For how long I don't know.. he changes email address a lot. 8-)
Cheers, James 8-)
Have you ever wanted to save a graphic in BASICs Screen 13. Or more
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
importantly load one quickly? Well its easy! Here's how...
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
First you'll need to draw something on the screen.. It doesn't matter
how. Then you need to save it. The first step is to point to the
segment of the video address. Then you want to bSAVE the graphic:
DEF SEG=&HA000
BSAVE "filename",0,64000
64000 will save the entire screen. So use that to save an entire screen.
It works sort of like Peter Coopers putpixel. Just multiply the y value
by 320 and the x value and add by one. So if you only wanted to save the
upper half of the screen it would be ((y*320)+x)+1. In this case y would
be 99 and x would be 319. The reason you need to add by one is when you
are saving the graphic it thinks of (0,0) as 1 instead of 0. So that means
you have to add the entire thing by one. So once again here is the equation:
((Y*320)+X)+1
The parenthesis are not really needed, but they are good to put in.
To Load the screen back up later, just do this simple thing:
Def Seg=&HA000
BLOAD "filename"
That's it!!!
-----------------------------------------------------------------------------
Well those loading and saving routines are all well and good if you want
to grab the entire screen, or the upper parts, but what if you want to save
and load a sprite? Well that is a little more complex, but it is still
easy!
First as usual you draw something on the screen. Then you need to make
an array for your sprite. I am not sure how you demention your array
based on the graphic size, because the demensions of the array can be
smaller then the sprite's demensions! So if anyone knows what the equation
is for dimensioning an array based on the sprites dimensions then I would
LOVE to know. But until then I just dimention the array according to the
sprite size. So if the sprite is 20x20 the the I make the array 20x20.
What I do is say
Dim array(20*20) or..
Dim array(20,20)
Then you need to get the image. If you don't know how GET works then look
it up in you BASICs help file.
Like..
GET (1,1)-(20,20),array
Now you need to point to that array like so..
DEF SEG=VARSEG(array(0))
Now it is safe to save it. Like so...
BSAVE "filename",Varptr(array(0)),length
The equation for the length of the file does not work for saving a sprite
either. it is not X*Y, so I don't know what the equation for it is. So
I hope someone who knows the equation can contribute it to the fanzine.
Meanwhile for length I usually use 16384, but if the sprite does not load
up all the way when you try to load it, then increase that number.
VARPTR tells BSAVE where to look for the info. In this case it is the
memory location where the array is stored.
OK, now that you have the image saved, you can use it in one of your
programs. But this time when you load up the graphic, you load it into
an array instead of to the screen. Don't worry it is just as fast.
First dimension your array, the way you did before...
Dim array(20*20) or..
Dim array(20,20)
Now point to that array again:
DEF SEG=VARSEG(array(0))
Now Load the graphic the same way you did before, but this time load it into
the array. Like so:
BLOAD "filename",VARPTR(array(0))
Now that it is in the array you can put it on the screen whenever you want!
Just use PUT. If you don't know what PUT is then look it up in the online
help. But here is the general idea...
PUT (x,y),array,PSET
I Hope I have not further confused you, but nevertheless those things work.
----------------------------------------------------------------------------
Ok, now you can load and save graphics, but what about palettes?
Well palettes are easy too. But I think I'll save that for next Fanzine.
I'll probably make a PCX to BSAVE format, some more advanced graphics
arrays, and some fade in and out subs as well.
I'm sure people'll be looking foward to seeing the PCX to BSAVE thing.
Palettes too! 8-) Thank you James. This sort of tutorial is exactly
what the fanzine needs. Can anyone else write tutorials? I'd love to
publish them... for example do you control your house with a QBasic
program or little robots etc... probably not but if you do I would love
to hear from you.
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-------------------------------------------------------------------------------
- SECTION TWO -----------------------------------------------------------------
-------------------------------------------------------------------------------
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
All levels articles:
This is where general BASIC info is presented. People of different levels
(novice,advanced etc) can use this section to their benefit.
______________________________________________________________________________
| SECTION 2 SUBPART 1 | Useful Resources ON THE NET!!! |
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
We've had some additions this week! Haev fun with this little lot of
lists as to where you can get BASIC stuff on the net.
FTP SITES:
SimTel Mirrors - you can get tonnes of Basic stuff here,
look at
ftp.coast.net (U.S.)
/Simtel/msdos/basic
/Simtel/msdos/qbasic
ftp.demon.co.uk (U.K.)
/pub/simtel/msdos/basic
/pub/simtel/msdos/qbasic
Archives of the fanzine are available on the
SimTel Mirror sites now! in the BASIC directory
PCGPE (Pc Games Programmers Encyclopedia) -
this is a VERY VERY good set of text files about
programming (not just games), learn about sound
+ grafix + mouse etc. VGood. 700k though.
x2ftp.oulu.fi
/pub/msdos/programming/gpe
General cool Basic site -
filled with loads of cool stuff, i know. i've looked
FTP SITE : users.aol.com
/blood225
Games Programmers site- oulu -
x2ftp.oulu.fi
/pub/msdos/programming/docs
/formats
/gpe
/...
This directory /programming is a directory
all for you game programmers out there, check it
out. There's info on loads of file formats etc..
In the /gpe directory is the programmers
encyclopedia.. loads of format and programs!
HTML\WWW SITES:
THE Basic Fanzine - http://www.teleport.com/~ericksnj/fanzine/
ABC home page - http://users.aol.com/mhscards/abc.html
Jumbo shareware - http://www.jumbo.com/
PBSOUND WWW site - http://www.snafu.de/~pbsound/
(Pbsound is a shareware library to use the soundblaster. It supports all
types and allows you to play all sorts of music formats on them + more,
it is for PowerBasic only)
The programming page-http://www.geocities.com/RodeoDrive/2238/
I run this page and it'll be good. It is not full up yet but I hope
to place some cool stuff on there.
If you know of any others then please tell me and it'll be added, if you
actually own\run the site then please include some info about it and I'll
check it out.
______________________________________________________________________________
| SECTION 2 SUBPART 2 | Basic on IRC |
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
I suppose all of you programmers have heard of IRC.. If you have then skip
this part and jump to the end.
IRC (Internet Relay Chat) is a system available on the internet for you
to type to people from all over the world in real time. You join channels
such as #c (aggh!) or #chatcafe and so on and there may be several people
there, you can then start off a conversation or join in with one that is
already going. It's like a worldwide real time conferencing system. Contact
your internet provider to see if you have IRC access. If so then download
an IRC client. This is a program that lets you do all the IRC stuff.
For Windows: MIRC or WS_IRC
ftp://ftp.demon.co.uk/pub/ibmpc/winsock/apps/mirc
ftp://ftp.funet.fi/pub/msdos/networks/irc/windows/wsirc14e.zip
respectively
For DOS: You will need a telnet connection although clients are
available. Ask your internet provider for info.
After you have that, READ THE DOCUMENTATION FULLY! Then surf along to:
http://unixg.ubc.ca:780/~abbott/blues/irc.html#undernet
and that should answer your questions (if you can log onto it)...
So now all of you regular IRCers can read on now, come back! Ok, well
on the basic newsgroups there has been talk (now and then) of the #basic
irc channel.. I use IRC (an awful lot) and I visit this channel. There is
never anyone else on it! Perhaps all of us on the newsgroup could arrange
a time (at the weekend) when we can discuss BASIC issues. Please get back
to me if you want to do this or start a thread on the newsgroups discussing
a suitable time, it's great fun y'know... You see, the C programming
language has a constantly busyish irc channel and we can't really have C
being really more popular than BASIC , (although admittedly C has larger
support) 8-) But we want basic to rise as one of the most powerful and
supported languages. Come on programmers lets get something going! MORE
Web Pages, MORE IRC Channels, MORE FTP sites.
Update: I went onto #basic the other day and two people were there. One who
reads this fanzine, I asked him.. He mentioned that we could get a
bot to keep the channel open. Is there anyone who could do this for
the whole basic community or who will tell how it is done? I'm sure
it'd be appreciated.
______________________________________________________________________________
| SECTION 2 SUBPART 3 | Structured Programming |
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
The point of this article is to make your programs flexible, easier to read
and have a better style. Having your programs more structured will enable
you to cross the path into the world of C, C++ and PASCAL far easier. It
will make basic gurus look at your work in a different light. Anyway, that
aside, at least you'll have the satisfaction of knowing you can program in
a tidy structured way.
A good first example would be the question 'Are you sure you want to exit?'
at the end of a program. If you answer Y then the program would exit but
if you answer N then the program will restart. You may use this method to
accomplish that:
'METHOD1
lp2:
'main program goes in here
lp1:
print "Are you sure you want to exit?"
a$ = input$(1)
if a$ = "Y" then system
if a$ = "N" then goto lp2:
goto lp1:
As you can see that looks better than the first method but in structured
programming GOTO commands are *rarely* used. I cannot even remember how to
do gotos in some structured languages! ;-) So how can we get rid of them?
Well if we go back to one of the earliest things you learn when you study
(and learn) BASIC, DO..WHILE loops... They can be used to return control
to earlier points in the program.
'METHOD2
do
'main program goes in here
do
print "Are you sure you want to exit?"
a$ = input$(1)
loop until a$ = "Y" or a$ = "N"
loop until a$ = "Y"
That is a structured program although there is one thing we could amend to
make the program have a small boost of quality. Change the line:
a$ = input$(1)
to:
a$ = ucase$(input$(1))
So now the person doesn't have to press Y . They can press Y or just y.
Or N and n. So let me go over a few dos and don'ts (please, it doesn't mean
you're a bad programmer):
Use of DO..WHILE loops
Jumping out of FOR loops with GOTO
Nesting loops cleverly
Nesting loops very deeply
Use of SYSTEM and not of END
Unneccersary use of GOTO
Just a few points there. I hope this all helps you see that it can be
profitable to use more structured programming, the structured code even
uses less lines (of proper code) than the original method shown! 8-) In
processor (or graphic) intensive programs this is very important to save
time and have the program running at its best. Another important thing
that should be used in programs is 'proper subroutines'. In BASIC the way
was always to go like this:
print "This will say hello"
GOSUB sayhello:
print "Bye!"
system
sayhello:
print "Hello!"
return
Nowadays this type of code should not be used. It originated in the first
early basics and has only continued to be supported due to GWBASIC and also
due to tradition. There is a better alternative (in QBASIC+up) now. You can
create and edit subroutines separate from the main module (main part of
program). If you select New Sub.. from the Edit menu (in QBASIC) then a
dialog box will appear asking for what you want the subroutine to be called.
In this case we want it to be called sayhello so type that and press
ENTER. We are then shown a new piece of program starting with 'SUB sayhello'
and ending with 'END SUB'. All of your code goes between these lines. If now
in here we type:
print "Hello!"
We can go back to the main program by pressing F2 and going up to the main
routine. If you press ENTER then it is flashed back up. If you replace
GOSUB sayhello with CALL sayhello then it will call the new procedure you
have created.
So it will look like this:
print "This will say hello"
CALL sayhello
print "Bye!"
system
SUB sayhello
print "Hello!"
END SUB
That program is easier to edit, easier to understand and more stylish than
the first method. If you have had any problems with this then mail me and
I'll give you a hand. More examples on this next issue. Cheerio!
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
- SECTION THREE ---------------------------------------------------------------
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Your Shout:
Anything that is sent for use for the zine that doesn't fit into the other
chapters is here. It's where your questions and programs go unless they fit
into an article or if you actually write an article or tutor.
______________________________________________________________________________
| SECTION 3 SUBPART 1 | Q+A |
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Q-
Where can I get a good QBasic Book?
Nick Blomstrand + various newsgroup members
Well if you can wait until February 20th (which isn't long away) then Wrox
Press will have released their 'Revolutionary Guide To QBasic'. From what
I have seen of the book (from beta-testing) I was very impressed. I have
recently heard about what else is in the book and believe it or not I was
even more impressed! It will have techniques and tips on creating 3D style
landscapes and games, fast graphics routines, Sound Blaster programming,
Virtual stack systems and more! This book is recommended to *anyone* who
is related with Basic. Even if you're an expert I will say you can find
something in the book that you will find useful and learn from. If you're
a beginner then you will learn Basic right from typing QBASIC to using the
menu system, then to writing simple programs to loops, jumps and
eventually games, graphics and sound. If you'd like a book for programming
then I suggest you point your web-browser to the [Wrox Press WWW Site]
http://www.wrox.com/
If you wish to mail someone about the book then you can do so from the WWW
site or alternatively you can mail [Adrian Sill]. He is one of the editors
of the book and the man I correspond with and he'll be happy to answer any
problems you may have.
adrians@wrox.demon.co.uk (adrians@wrox.com)
There you go problem solved!
Q- How do I go about using overlays and how do they work?
A- This mail was from a man developing a medical system. It has been used for
a while now but he needs to use overlays to program it now. PLEASE mail
us if you know how to use overlays and I'll forward onto him.
______________________________________________________________________________
| SECTION 3 SUBPART 2 | Your Programs |
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Our first program is from Virtual Simulations. I cannot test this program
because I do not have PowerBasic and this fanzine is on a rush schedule. I
promise to get all programs tested in future. Sorry! Virtual Simulations can
be grabbed at: vsim@xs4all.nl
or from WWW page: http://www.xs4all.nl/~vsim/
' START OF PROGRAM
' DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD
' DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD
' Program Title: Clock
' Copyright: Virtual Simulations 1995
' Author: AA v Zoelen
' Last Modified: 08-02-1996
' Version: 1.0
' DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD
' Description: Just a little clock demo
' DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD
' Notes: Public Domain. For personal use only.
' DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD
' History: First issue 08-02-1996
' DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD
$CPU 8086 ' program works on any CPU
$OPTIMIZE SPEED ' make fastest possible executable
$COMPILE EXE ' compile to an EXE
$DEBUG MAP OFF ' turn off map file generation
$DEBUG PBDEBUG OFF ' don't include pbdebug support in our executable
$LIB COM OFF ' turn off PowerBASIC's communications library.
$LIB CGA OFF ' turn off PowerBASIC's CGA graphics library.
$LIB EGA OFF ' turn off PowerBASIC's EGA graphics library.
$LIB VGA ON ' turn off PowerBASIC's VGA graphics library.
$LIB HERC OFF ' turn off PowerBASIC's hercules graphics library.
$LIB LPT OFF ' turn off PowerBASIC's printer support library.
$LIB IPRINT OFF ' turn off PowerBASIC's interpreted print library.
$LIB FULLFLOAT OFF ' turn off PowerBASIC's floating point support.
$ERROR BOUNDS ON ' turn off bounds checking
$ERROR NUMERIC ON ' turn off numeric checking
$ERROR OVERFLOW ON ' turn off overflow checking
$ERROR STACK ON ' turn off stack checking
$FLOAT PROCEDURE ' use procedural floating point to optimize for
' machines without a co-processor
$COM 0 ' set communications buffer to nothing
$STRING 2 ' set largest string size at 1024-18 CHAR.
$STACK 2048 ' let's use a 2k stack
$SOUND 1 ' smallest music buffer possible
$DIM ARRAY ' force arrays to be pre-dimensioned before they
' can be used
$DYNAMIC ' all arrays will be dynamic by default
$OPTION CNTLBREAK OFF ' don't allow Ctrl-Break to exit program
' DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD
DIM X AS INTEGER
DIM Y AS INTEGER
DIM Radian AS SINGLE
DIM Radius AS BYTE
DIM Count AS BYTE
DIM Seconds AS BYTE
DIM Minutes AS BYTE
DIM Hours AS BYTE
DIM ColErase AS BYTE
DIM ColPlate AS BYTE
DIM ColBox AS BYTE
DIM ColSec AS BYTE
DIM ColMin AS BYTE
DIM ColHour AS BYTE
DIM PlateDotsX(61) AS SINGLE
DIM PlateDotsY(61) AS SINGLE
DIM Digital AS STRING * 1
DIM CMDLine AS STRING * 10
CMDLine = COMMAND$
SCREEN 12
' Screen 12 have a size of 640X480 so the
' values for X, Y and Radius should stay
' between limits. You only need to change
' this few values below for adjusting
' the whole clock.
X = 100 ' X - Center location of the clock
Y = 50 ' Y - Center location of the clock
Radius = 150 ' The size of the clock
ColErase = 1 ' Color for erase
ColPlate = 9 ' Color for the plate of the clock
ColBox = 1 ' The color of the box around the clock
ColSec = 15 ' Color of the seconds hand
ColMin = 4 ' Color of the minutes hand
ColHour = 12 ' Color of the hours hand
Digital = "Y" ' Place also a digital clock on the screen if
' the clock's radius is larger then 75.
' If there is a radius value on the commandline then
' use that one instead.
IF CMDLine <> "" THEN Radius = VAL(CMDLine$)
Radius = MAX(Radius, 13) ' The radius can't be smaller then 10
X = MAX(X, Radius) ' Let the clock not go beyond the X<0 and Y<0
Y = MAX(Y, Radius) ' The other sides is your responsibility. :-)
DECR Radius, 3 ' Make the clock fit into the box.
GOSUB Plate ' Setup and draw the plate of the clock
DO
IF Seconds <> VAL(RIGHT$(TIME$, 2)) THEN GOSUB UpdateHands
LOOP UNTIL INKEY$ <> ""
END
' DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD
' SUB ROUTINES
'
' Update this hands of the clock every second.
' Redraw all the hands just incase there was a pass
' over it by the seconds hand.
UpdateHands:
IF Radius > 72 AND UCASE$(Digital) = "Y" THEN
' Replace damaged text.
LOCATE INT(Y/12) , INT(X/8) - 2 ' Place also the digital time
PRINT TIME$ ' on screen, but only if the
END IF ' clock is large enough.
' Erase all hands first
LINE (X, Y) - (X + PlateDotsX(Seconds + 1), Y + PlateDotsY(Seconds + 1)), ColErase
LINE (X, Y) - (X + PlateDotsX(Minutes), Y + PlateDotsY(Minutes)), ColErase
LINE (X, Y) - (X + (PlateDotsX(Hours)/1.2), Y + (PlateDotsY(Hours)/1.2)), ColErase
' Update the Minute hand
Minutes = 1 + VAL(MID$(TIME$,4, 2))
LINE (X, Y) - (X + PlateDotsX(Minutes), Y + PlateDotsY(Minutes)), ColMin
' Update the Hours hand
Hours = VAL(LEFT$(TIME$, 2))
IF Hours > 12 THEN DECR Hours, 12
Hours = (Hours * 5) + 1 + INT(Minutes/12)
LINE (X, Y) - (X + (PlateDotsX(Hours)/1.2), Y + (PlateDotsY(Hours)/1.2)), ColHour
' Do seconds at the last moment to get the most actual time.
Seconds = VAL(RIGHT$(TIME$, 2))
LINE (X, Y) - (X + PlateDotsX(Seconds + 1), Y + PlateDotsY(Seconds + 1)), ColSec
RETURN
Plate:
' Start at 30 to get the clock in the right position
' Translate degrees to radians and at the and swap
' the order of the coordinates because otherwise the
' clock is running backwards.
LINE (X - (Radius + 3), Y - (Radius + 3)) - (X + Radius + 3, Y + Radius + 3), ColBox, bf
LINE (X - (Radius + 3), Y - (Radius + 3)) - (X + Radius + 3, Y + Radius + 3), ColPlate, b
FOR Count = 30 TO 91
Radian = Count * 6 * (3.14159 / 180)
PlateDotsX(91 - Count) = SIN(Radian) * Radius
PlateDotsY(91 - Count) = COS(Radian) * Radius
IF Count / 5 = INT( Count / 5 ) THEN ' Place every 5 min. a dot.
Dot = MIN(Radius / 10, 2) ' and also for every minute.
IF Radius < 32 THEN Dot = 1
ELSE
Dot = 1
IF Radius < 32 THEN Dot = 0 ' But if the clock is to small
END IF ' then forget then minute dots.
IF Dot <> 0 THEN CIRCLE (X + PlateDotsX(91 - Count), Y + PlateDotsY(91 - Count)), Dot, ColPlate
NEXT
' Get the time to start with
Minutes = VAL(MID$(TIME$, 4, 2)) ' Get the minutes
Hours = VAL(LEFT$(TIME$, 2)) ' Get the Hours
IF Hours > 12 THEN
DECR Hours, 12 ' Adjust from 24h to a 12h clock.
Hours = (Hours * 5) + 1 + INT(Minutes/12)
END IF
Seconds = VAL(RIGHT$(TIME$, 2)) ' Get the seconds
RETURN
' END OF PROGRAM
I know a lot of you sent in programs but the length of this fanzine is
already too much I think. Your programs will be included next issue.
______________________________________________________________________________
| SECTION 3 SUBPART 3 | Zephyrs SVGA library | By Marco Koegler
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Two weeks ago I downloaded a shareware evaluation copy of Zephyr
Software's SVGA library for VBDOS/QuickBasic/PDS. Knowing the limitations of
the BASIC environment in terms of graphics, I was very impressed with the
vast array of subs and functions that where provided in their product.
What I immediately loved about the library was, that it enables the
programmer to use screen modes up to 1024x768 with 256 colors. A dream come
true for anyone frustrated with SCREEN 12 or 13. In order to ensure that no
hardware conflicts will result from running the software, Zephyr has built in
functions to check the CPU type (need at least a 386), the amount of XMS
memory (FULL version only), and if the graphics card is VESA compatible. The
library supports and detects about 20 different graphics card. If your card
supports bank switching, then several video memory pages are waiting to be
used (in hi-res). Also a rather nifty feature, is that you can turn the video
output "off," do some modifications to the screen and reveal them by turning
the video output back on.
Since BASIC doesn't know how to address the higher screen resolutions,
the old BASIC commands, such as LINE and PSET or even PRINT won't work
anymore, but Zephyr has replaced them with even better and faster commands.
For example, with the library you would be able to determine whether you want
to PRINT text in SET, XOR, OR, or AND mode, just like PUT for BASIC. Besides
boosting regular graphic commands we also have unusual routines for 3D and 2D
graphics, sprite rotation, collision detection, and mouse functions.
This has only been a small selection of highlights. In the full
version you can also save a screen or GET/PUT to XMS memory save PCX files.
The documentation of the library is excellent (a 270 KB text file filled with
explanations and examples) and the only downside to it is its size. The QLB
weighs in at a whopping 110 KB, although the evaluation copy also is slightly
crippeled (no XMS support). All in all I still love it and once I get some
money together I'll buy the full version. If you would like to check it out,
you can reach their site at http://www.phoenix.net/~balkum!
If anyone wants to chat with this guy then well go ahead, he can be found at:
marco@umr.edu
He has many useful programs and stuff which will be published into the next
fanzine. Thanks Marco.
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
- SECTION FOUR ----------------------------------------------------------------
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Details about the fanzine:
This section of the fanzine is the last. It covers topics such as how to get
in touch with the author,who contributed to the fanzine and my last words.
There is also a new section, 'Latest Developments'. That section is for info
that describes new developments on the fanzine. Read it! 8-)
______________________________________________________________________________
| SECTION 4 SUBPART 1 | Latest Developments | EVERYBODY READ!!! FAQS!!
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
This section is to show what new developments the fanzine is going through.
i) Web Site
The WWW site for issues of the fanzine is:
http://www.teleport.com/~ericksnj/fanzine/
ii) Mailing List
The fanzine now has a mailing list. It will provide you with fanzines as soon
as they are released so you don't miss them. It will provide addtional info
too as well as the fanzine so join it! To join mail
arelyea@vt.edu
with the following line in the subject header:
subscribe basix-fanzine
Any text in the body of the message will be ignored. I hope you will use this
service. Who knows, if there is enough members I will stop posting to the
newsgroups and the people on the mailing list will be the only to get it, in
text form.
iii) Interfaced version of the Fanzine
Someone has proposed that I make the fanzine interactive. Ie.. what I do is
write an interface with menus and mouse support and you can use it to read
the fanzine and to extract code etc.. There will be a program you download
and then every month you will be sent a specially formatted file which
will be read by the interface program. Is this a good idea?
If you would like to see further developments to the fanzine then please give
me some ideas! :-)
______________________________________________________________________________
| SECTION 4 SUBPART 2 | How do you contribute? |
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
So how do you contribute?
All you have to do is e-mail all of your source code\articles and ideas to:
peter@trenham.demon.co.uk - with everything
The bmag@trenham.demon.co.uk address is up and running again so please
send there with any contributions , if that fails send to peter@ .
______________________________________________________________________________
| SECTION 4 SUBPART 3 | How do you contact the author? |
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
If you have something to share with everyone then post onto the alt.lang.basic
or comp.lang.basic.misc newsgroups (I read the former most due to less noise).
Mention the fanzine in it if you want me to read it! 8-)
______________________________________________________________________________
| SECTION 4 SUBPART 4 | Credits |
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Greets go to (in no real order) :
The people at Wrox Press yet again,
for contributing a super article to the fanzine this issue, their book
should be out on 20th February. (basically when you read this!) 8-)
(adrians@wrox.demon.co.uk)
James Erickson,
who's cool...
(ericksnj@teleport.com)
Tony Relyea,
who is the maintainer of the mailing list and owns Russian-under Ware
,a software company! (arelyea@vt.edu)
Douggie Green,
author of the great FAQ (you must read it to answer those questions!)
(douggie@blissinx.demon.co.uk)
Other people who wrote to me and who contributed code, gave me ideas or
helped in any way:
Ben Ashley
Nick Blomstrand
Issac Grover
The people on #basic (IRC)
John Woodgate
Marco Koegler
Remember that this fanzine relies on your contributions. Cheers, ;-)
______________________________________________________________________________
| SECTION 4 SUBPART 5 | Last Words+Next month |
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
agggh!! I forgot to write this bit properly last month! 8-( never mind.
8-)
NEXT MONTH (March 1996):
SPECIALIZED ARTICLES:
[Advanced\Intermediate]
3D Programming Part 2
How *does* FM synthesis work?
[Novice]
Basic Tutorial 4/5
What is binary and the binary operations?
ALL LEVELS ARTICLES:
Yet More WWW pages and FTP sites
YOUR SHOUT:
Update on IRC
Your Questions, Answers and programs
DETAILS ABOUT THE FANZINE:
How to contribute, and the usual twaddle. hehe 8-)
Rundown on the April 1996 fanzine.
Well, hopefully you'll see the next fanzine during March although I've got
hardly any work to do for the next 4-5 weeks so it may be sooner! Watch out
on the mailing list and newsgroups.
Last words:
It has been quite fun this time creating the fanzine. I am still deeply
sorry for the delay in its appearance and I'm also sorry to the people who
sent in stuff for this fanzine but that couldn't be published. It's just
that this fanzine is very large now and I'm not very organized. I'll get
all of the missed articles into the next issue (which I am doing now!).
Well thats the end of fanzine 4 now, I better not waste any more time and
space. Cheerio 8-)
--
from the desk of 'Fanzine'
