-Nightwolf
Pokemon 2: Xenophobic Continuum, once it is completed will be an advanced tile game, with high adventure, obscure puzzles to solve, and many strange places to explore. The raw power of the game engine and the limitless possibilities of gameplay, along with the sparkling wonder of the graphics, will leave any gameplayer wondering if this game was really programmed in simple QuickBasic. By using an innovative technique, Pokemon 2: Xenophobic Continuum has virtually no limits to the amount of tiles that can be used, giving the game a more appealing look and feel. With powerful NPC scripting, the people you meet will seem as alive as must of your friends or family. The player interface is highly configurable, to allow the game to be played without the interface being in the way. And with on the fly configurability, the player can set the way the game plays, to best meet the speed of there computer. Unfortunately, Pokemon 2 is still under development, with the development team working hard to bring you this unique game. As of now, the game engine is 20% complete, but you can still check the progress made on the game so far by downloading the Pre-Alpha Demo release, which be available shortly at www.quickbasic.com This very early demo shows the powerful NPC capabilities of the Pokemon 2 engine. This Demo release also features a surprise appearance by the venerable Jedi Master Yoda.
| Future Software | ||
| Future Software is one of the mayor QB sites out there. When you enter Future software you come to a page that ask you to bookmark it and then says that all QBasic programmers can enter... Well since I'm a QB programmer I entered. The first thing I noticed is the great layout! There is a nice looking navigation bar on the left of the page, two search engines in the bottom and the navigation for the files page is on top in a pulldown window, this is really good! On to the page, Future Software has more than 400 files, a really neat QB sites search engine, a message board, site reviews and some information about them. Ok, that's about the introduction now read the scores! | ||
| . | ||
| General Appearance: | 80/100 | A well thought out layout, also the Files pull-down menu is really nice. The MsgBoard & Guestbook are all local CGI-Script, heavily modified by Future Software. |
| Images: | 95/100 | Just great looking images!! |
| Sound: | N/A | No sound |
| Programs/Links: | 90/100 | Lots of files and a good search engine with many sites!! |
| QBasic: | 95/100 | All about QBasic! |
| Unique: | 75/100 | Well the search engine is pretty unique but that's all... |
| Total: | 87/100 | A good site to bookmark and come back often! |
| Nemesis Software | ||
| Nemesis Software is a fairly new page, it has a really good layout; the page title is in a top frame, there's a body frame with some borders around it, and a bottom frame with a menu. Whenever a topic you select from the menu has categories a little menu frame pops up at the top of the body frame which keeps the page clearly structures. There is a banner exchange, some links, awards page, about 60 files, some Q&A question, and their programs and information about Nemesis Software | ||
| General Appearance: | 87/100 | A very good layout, very clear and easy to navigate. There are some JavaScripts on Nemesis Software all written by themself. |
| Images: | 80/100 | Just 3 words: Simple but nice! |
| Sound: | N/A | No Sound |
| Programs/Links: | 77/100 | Not so much programs and only a few links, but there is a search engine with more links. |
| QBasic: | 82/100 | There are lots of things about QBasic but also lots of things not about QBasic. |
| Unique: | 80/100 | The Banner Exchange and the Search Engine are pretty unique. |
| Total: | 80/100 | A good looking page with not too much programs and links but with some unique features. |
No, I'm not kidding! There are two NES emulators written in QBasic now! The first is called: uNESsential and the second if called DRR-Nes. DRR-NES now emulates some games. But not that many... uNESsential emulates also very little games.
More people moving to .quickbasic.com
Many QBasic sites are moving to a new .quickbasic.com address. This includes NeoZones, QBasic The Magazine, Enchanted Creations and Alternatelogic. If you want your own .quickbasic.com address go to Darkelf Productions
Qlympics STILL in Preliminary Rounds
As of now the Qlympics are still in Preliminary Rounds. It's almost two months since the Preliminary Rounds have started. When will the real voting on the Qlympics begin? The QB Times will keep you informed
You can make objects by placing planes in the workarea. Then you can shape up the plane. You can edit in 3 views: top view, front view and side view. You need to fool around a bit but when you get the hang of it it's really cool!
The version avaible on the internet is version 0.42B. The version I reviewed was version 0.43B. I really liked the interface of 3DES Designer, it's very clear. The pre-made objects made by BlackBird are also very nice to look at. I think if this program continues it could be one of the best QB programs ever made!
The author of this article is Greg McAusland ( Maz )
We'll start with showing how about digits and stuff of the sort,
Base 1: Base 2: Base 8: Base 10: 0 01 01234567 0123456789OK there you have is some different numbering systems. As you can see Base 1, has only one possibility, it is useless and wont be used. Base 2 has 2, from where you get 'bi', therefor getting the word binary. Base 8 has 8,from where you get 'oct', therefor giving you octal. And obviously comes good old base 10 (the one you should use in your head.) from where you get 'dec', therefor giving you decimal.
Now you might already know all that, but why I'm here is to show you how to count in HEXADECIMAL. It's a Base 16 numbering system.
Base 16:
0 1 2 3 4 5 6 7 8 9 A B C D E F
----------------------------------------------
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
There you have it, now you know what all those As Bs and Cs are!
You might be asking how to count double hexadigits. Well it's
simple, let's take 11 as an example.
(First digit*16)+(second digit)Which gives us 17. Simple? Sure is, a similar concept applies to quad hexadigits.
(First digit*4096)+(Second digit*256)+(Third digit*16)+Fourth digitOr you could just use calculator to give you the answer, but I'm sure it's too hard to press Start, Programs, Accessories, Calculator ... no no no ... What's the world coming to??? So back to the real world lets take 2222 as an example, you get 8738! Simple right? Try making your own functions if you want, although it will be useless, there's always HEX$. Now that over, you could go back to whatever you were reading and finish this tutorial! =)
OPENBOX
DISPLAYTEXT Hi! This text is written in a box
WAITKEY
CLOSEBOX
END
That are some simple instructions you can make a program respond on.
Like, with OPENBOX it opens a box, then displays the text, waits
for a key to be pressed, closes the box and ends. How do you make
this stuff with QBasic? Well, that's why I'm writing this, to explain that
to you!
A simple scripting language
CLEARSCREEN
DISPLAYTEXT Wow! This is my first scripting language!!
DISPLAYTEXT Press any key to end...
WAITFORKEY
DISPLAYTEXT You pressed a key and now the program ends!
ENDSCRIPT
DISPLAYTEXT This action will NOT be executed because there
DISPLAYTEXT is an ENDSCRIPT command before it!
Save it as script.dat. So now we have some commands in an external file.
But QBasic can't do anything with that so we need to make a program
that reads the script-file and ports it so QBasic can understand it.
A good way is to read the script-file line by line, then check if the line contains
commands and what they are, if there are any expressions after the command
store them in a temporarily variable and then execute the command. For example
to let the program execute the commands we just used you could use this code:
OPEN "script.dat" FOR INPUT AS #1
DO
INPUT #1, ReadLine$
ReadLine$ = LTRIM$(RTRIM$(ReadLine$)
IF LEFT$(ReadLine$, 11) = "DISPLAYTEXT" THEN
Temp1$ = RIGHT$(ReadLine$, LEN(ReadLine$) - 12)
PRINT Temp1$
END IF
IF LEFT$(ReadLine$, 7) = "WAITKEY" THEN
WHILE INKEY$ = "": WEND
END IF
IF LEFT$(ReadLine$, 9) = "ENDSCRIPT" THEN
EXIT DO
END IF
LOOP UNTIL EOF(1)
CLOSE #1
I'll discuss the code line by line now:
OPEN "script.dat" FOR INPUT AS #1
Opens our scripting file 'script.dat' for reading as file #1
DO
Start the Do...Loop event that runs until the file ends
INPUT #1, ReadLine$
Reads a single line from the file.
ReadLine$ = LTRIM$(RTRIM$(ReadLine$)
Removes all the spaces from the left and right of the line.
IF LEFT$(ReadLine$, 11) = "DISPLAYTEXT" THEN
If the first 11 characters from the line we just read form the word
DISPLAYTEXT the DISPLAYTEXT command is run.
Temp1$ = RIGHT$(ReadLine$, LEN(ReadLine$) - 12)
The DISPLAYTEXT command contains one expression so we just read the
right part of the line we took minus twelve character (the DISPLAYTEXT
command + the space).
PRINT Temp1$
We PRINT the expression we just took.
END IF
End the IF...THEN command
IF LEFT$(ReadLine$, 7) = "WAITKEY" THEN
If the first 7 characters from the line we read are WAITKEY we run it.
WHILE INKEY$ = "": WEND
We wait until a key is pressed
END IF
End the IF...THEN command
IF LEFT$(ReadLine$, 9) = "ENDSCRIPT" THEN
If the first 9 characters from the line we read are ENDSCRIPT we run the command.
EXIT DO
We exit the DO...LOOP event.
END IF
End the IF...THEN command
LOOP UNTIL EOF(1)
Loop back to the DO
CLOSE #1
We close the file.
Now you have your first (small) scripting language! Now onto the harder things!
Well, this isn't exactly hard but I still wanted to include it. I'll now explain on how to add QBasic like comments (the little ' thing). Add a line with a command somewhere in the 'script.dat' file before the ENDSCRIPT command.
Ok, now add this 2 lines somewhere in the do loop:
IF LEFT$(ReadLine$,1) = "'" THEN
END IF
This checks if the first command is a ' and if it is, it just does nothing
because a comment does nothing. Good, now you can have comments in your scripts!
Next time I'll talk about variables and IF...THEN commands. Maybe also about DO...LOOPs and FOR...NEXTs. Until then, enjoy the rest of the issue!
Lesson no.1 The 4 basic registers
First I'd like to start with a brief explaination of variables in ASM. ASM is very diffrent from QB and high-level languages, as it doesn't use variable names. (well assemblers do in their way, but at a pure level there is no variable naming system) Of course, you can store data in the computers memory, but it wont be "tagged" with a variable name like i% or num1.
When fooling around with asm, you get many preset (variables) to temporarly hold critical data. The first four registers we will learn today are:
AX 16-bit register BX 16-bit register CX 16-bit register DX 16-bit register
Well you see AX, BX, CX and DX are all really integers (can have a value between -32766 to 32767) inside your CPU. You're probably thinking "4 integers! How am I ment to work with that many variables!" You see that's the art of ASM (ofcourse there are more than 4 registers but I'll introduce them later) you must challenge your self programming in it! If you don't want to be challenged and you just want to use other people's librarys, please stop now and spare yourself some precious time, ASM is not for everybody.
Lesson no.2 Some very basic commands
Before starting this section, read the HEX tutorial if you have no previous knowledge of using hexadecimal.
In order to give a register a value, you must "move" the value into the register. It's simpler than you think, here is an example:
MOV AX,1
that command tells the CPU to assign register AX a value of &H1.
So in other words ax% = &H1. Here's another example:
MOV CX,32
That command tells the CPU to assign register CX a value of &H32.
that mean cx% = &H32.
You can also assign values from one register to another like so:
MOV BX,DX
This give BX the value of DX. As you can see it's easier than you
probably thought, Moving a value from one register to another, or
assigning a value to a register takes a bit of time, but when I say
a bit of time I mean 2 clocks* on a 80286 (really old processor) or
1 clock on a 486/Pentium.
To add a value to register you use the simple "add" code like so:
ADD AX,4
This increases the value of AX by &H4. You can also add another
register to an other register like you would when "mov"ing. Heres
an example code :
MOV AX,3
MOV DX,AX
ADD DX,4
ADD AX,DX
What does the value of AX end up? Simple, &H7! Look at the code
carefully if you don't agree with my calculations.
Well that's it for this artical, in part two we'll be discussing some more productive methods of using ASM.
* A Clock cycical is used to mesure time taken by the processor to process a command, to find the nanosecond taken you use this simple command : (1000Mhz/(n Mhz))=X nanoseconds Where n is the Mhz speed of the computer.
The author of this article can be contacted at: abionnnn@geocities.com
I suppose in its simplest form a quest follows these steps:
1. Attain quest - usually by talking to a non-player character (NPC)
2. Perform quest - do the action commanded by the NPC
3. Accept reward - get something in return for completing the quest
To give an example of the above steps as they should appear in your game commands, here is what happens: Store a variable in your code called BEARQUEST. Set it's value to 0. You talk to the village elder (an NPC) who's code is partitioned in this manner:
If BEARQUEST =0 then say a$
If BEARQUEST =1 then say b$
If BEARQUEST =2 then say c$
If BEARQUEST =3 then say d$
Since your BEARQUEST variable is 0 at the moment, he says a$ which could be this.
"A bear is eating all the children. If you slay him, I will reward you with 500 gold coins."
Once the text is said, have the code change BEARQUEST to 1.
If you now talk to the elder, he will say b$, which could be "Please hurry in your quest."
At this point the player wanders all around the game until the bear is found. Once killed change
BEARQUEST to 2. Now return to the village elder who now says c$, "You've saved us! Here is 500 gold coins!"
Now to complete the quest, change BEARQUEST to 3 so that from now on, everytime you talk to the elder he will
say d$, "Thank you for saving the children. Good luck in all your future adventures."
Congratulations if you could follow that, it's all there is to making a quest.
Now you're probably thinking, "That's not hard at all! I thought this was advanced quest design!" Don't worry, I'm not finished yet. The above design was more or less what was used in Dark Ages I. Its brilliance is in its simplicity (and that it works), but its drawbacks are impracticality, informal structure, and wasted space. While programming Dark Ages II, I discovered something better structured, external, and more malleable is necessary for what is going to be a much larger and more complex program. Using the basic concepts of the above example and integrating better structured coding such as scripting, I believe I have come up with a great quest system.
In order for this to make sense, you need to be familiar with scripting. I can't give you a good impression of it here, but it's basically a few lines of code that get their data from external files (usually .txt) and perform the actions based on the data read. The advantages are almost essential in programming because they save a lot of code space, structure your program, and organize what would otherwise be an uncontrollable amount of variables. In my strategy, quest coding requires three things: speech scripting, object scripting, and a universal variable dimension. The universal variable dimension (UVD) is a simple integer dimension from 1 to whatever, where each number represents a variable and could have a value from 0 to whatever. Now here comes the surprise, this strategy is advanced, yet amazingly simple. My speech script contains the following necessities, but yours could be modified to your needs. It contains the variables required, the text that is spoken, and the variables that are changed. The text scripting code would be read whenever a player attempts to talk to someone.
Let's look at some pseudo code of my script:
*"1","0"
*"1","1"
*"Help me, I have a horrible disease and need a magic cure potion!"
*"1","1"
*"1","2"
*"Thank you for saving my life. Take this magic item as thanks."
*"1","3"
*"2","1"
*"1","3"
*"I'll never forget how you saved my life."
Here's how it works. Variable 1 from your UVD currently has a value of 0. According to the above script, if
it has a value of 0 or 1, the text would read, "Help me, I have a...etc." and then change variable 1 to have
a value of 1 (obviously if it was 1 already, changing it to 1 would mean keeping it the same). If it had a value
of 2, it would read the corresponding text, change it to 3, then change varialbe 2 (perhaps a magic sword variable)
to have a value of 1. After that, every time the text is read, it would find variable 1, value 3 and read that
corresponding text, never making any more changes.
"Hold up! Where did variable 1, value 2 come from?" Ahh, good question! Here's where object scripting comes in. Object scripting is in many ways similar to text scripting. The basics that I have integrated are type of object, variables required, text to be read, and variables changed when activated.
Let's look at some object pseudo code:
*"1"
*"1","1"
*"You have found a magic cure potion."
*"1","2"
Unlike text scripting, object scripting needs to be read twice in the game. The first time it is read is when
the map loads. You have to write a script that will search your file for the objects that will show up on the
map, then a separate script for what happens when you manipulate those objects while playing the game. In the
case of the above code, the first "1" represents that the object is something that you pick up if the UVD variable
1 has a value of 1 (as shown in the second line of code above). If you had a value of "2" for the first line, it
could be an object that you activate, but do not pick up, like a lever or switch. In this manner, if you load the
map before you have been given the quest to find the magic cure potion, then your UVD variable 1 would have a
value of 0 and the potion would not appear on the map. But if you have been given the quest, then your UVD
variable 1 would have a value of 1 and the potion would appear. The third line of code is what appears signifying
you have picked up the potion and the fourth line gives variable 1 a value of 2. Now if you redraw your map and
check your object script, it will no longer draw the object because your UVD variable 1 has a value other than 1.
If you've been following all this then you will notice that variable 1, value 2 is the key to finishing the quest
you started in the scripting code. You can now return to the NPC who sent you on the quest and get your reward.
Obviously this is a very basic example of advanced quest programming. Your scripts may contain up to 20 lines, and manage up to 10 variables as some of mine do in DA2. It just depends on how complex of an engine you desire. But hopefully you've picked up what a quest is in an RPG computer game. Simply put, a quest is just the manipulation of people and objects in the game. You could even go so far as to create your own program to manage your NPC and object scripts while you write them.
The I-Face Warehouse is a site about graphics, web-design, etc. They provide you with a huge collection of interfaces you can freely use on your site! (like Future Software did) They also have tons of website templates, all top-notch design! Now, see how many points they scored:
| Topic: | Mark: | Description: |
| Design: | 7.3 | Could have been better, if their menu was in a side-frame, while the content was in the main-frame.. Also, i would have used another font, like Verdana, and not the standard one.. |
| Compatibility: | 7.0 | This site works just fine with with a resolution of 800x600, and higher, but not when you're viewing the site with a resolution of 640x480.. |
| Content: | 9.5 | This site is really filled with lots of good, useable information and cool interfaces, banners, website-templates, etc... |
| Updating: | 9.0 | This guy updates his site a lot, that's all I can say here.. |
| Overall: | 8.2 | |
This topic describes the graphics-file formats used by the Microsoft Windows operating system. Graphics files include bitmap files, icon-resource files, and cursor-resource files.
Bitmap-File Formats
Windows bitmap files are stored in a device-independent bitmap (DIB) format that allows Windows to display the bitmap on any type of display device. The term "device independent" means that the bitmap specifies pixel color in a form independent of the method used by a display to represent color. The default filename extension of a Windows DIB file is .BMP.
Bitmap-File Structures
Each bitmap file contains a bitmap-file header, a bitmap-information header, a color table, and an array of bytes that defines the bitmap bits. The file has the following form:
BITMAPFILEHEADER bmfh;
BITMAPINFOHEADER bmih;
RGBQUAD aColors[];
BYTE aBitmapBits[];
The bitmap-file header contains information about the type, size, and layout
of a device-independent bitmap file. The header is defined as a
BITMAPFILEHEADER structure.
The bitmap-information header, defined as a BITMAPINFOHEADER structure, specifies the dimensions, compression type, and color format for the bitmap.
The color table, defined as an array of RGBQUAD structures, contains as many elements as there are colors in the bitmap. The color table is not present for bitmaps with 24 color bits because each pixel is represented by 24-bit red-green-blue (RGB) values in the actual bitmap data area. The colors in the table should appear in order of importance. This helps a display driver render a bitmap on a device that cannot display as many colors as there are in the bitmap. If the DIB is in Windows version 3.0 or later format, the driver can use the biClrImportant member of the BITMAPINFOHEADER structure to determine which colors are important.
The BITMAPINFO structure can be used to represent a combined bitmap-information header and color table. The bitmap bits, immediately following the color table, consist of an array of BYTE values representing consecutive rows, or "scan lines," of the bitmap. Each scan line consists of consecutive bytes representing the pixels in the scan line, in left-to-right order. The number of bytes representing a scan line depends on the color format and the width, in pixels, of the bitmap. If necessary, a scan line must be zero-padded to end on a 32-bit boundary. However, segment boundaries can appear anywhere in the bitmap. The scan lines in the bitmap are stored from bottom up. This means that the first byte in the array represents the pixels in the lower-left corner of the bitmap and the last byte represents the pixels in the upper-right corner.
The biBitCount member of the BITMAPINFOHEADER structure determines the number of bits that define each pixel and the maximum number of colors in the bitmap. These members can have any of the following values:
| Value | Meaning |
| 1 | Bitmap is monochrome and the color table contains two entries. Each bit in the bitmap array represents a pixel. If the bit is clear, the pixel is displayed with the color of the first entry in the color table. If the bit is set, the pixel has the color of the second entry in the table. |
| 4 | Bitmap has a maximum of 16 colors. Each pixel in the bitmap is represented by a 4-bit index into the color table. For example, if the first byte in the bitmap is 0x1F, the byte represents two pixels. The first pixel contains the color in the second table entry, and the second pixel contains the color in the sixteenth table entry. |
| 8 | Bitmap has a maximum of 256 colors. Each pixel in the bitmap is represented by a 1-byte index into the color table. For example, if the first byte in the bitmap is 0x1F, the first pixel has the color of the thirty-second table entry. |
| 24 | Bitmap has a maximum of 2^24 colors. The bmiColors (or bmciColors) member is NULL, and each 3-byte sequence in the bitmap array represents the relative intensities of red, green, and blue, respectively, for a pixel. |
The biClrUsed member of the BITMAPINFOHEADER structure specifies the number of color indexes in the color table actually used by the bitmap. If the biClrUsed member is set to zero, the bitmap uses the maximum number of colors corresponding to the value of the biBitCount member. An alternative22 form of bitmap file uses the BITMAPCOREINFO, BITMAPCOREHEADER, and RGBTRIPLE structures.
Bitmap Compression
Windows versions 3.0 and later support run-length encoded (RLE) formats for compressing bitmaps that use 4 bits per pixel and 8 bits per pixel. Compression reduces the disk and memory storage required for a bitmap.
Compression of 8-Bits-per-Pixel Bitmaps
When the biCompression member of the BITMAPINFOHEADER structure is set to BI_RLE8, the DIB is compressed using a run-length encoded format for a 256-color bitmap. This format uses two modes: encoded mode and absolute mode. Both modes can occur anywhere throughout a single bitmap.
Encoded Mode
A unit of information in encoded mode consists of two bytes. The first byte specifies the number of consecutive pixels to be drawn using the color index contained in the second byte. The first byte of the pair can be set to zero to indicate an escape that denotes the end of a line, the end of the bitmap, or a delta. The interpretation of the escape depends on the value of the second byte of the pair, which must be in the range 0x00 through 0x02. Following are the meanings of the escape values that can be used in the second byte: