Topic: Petit Computer Tutorials

Expand

I guess I'll repost all my tutorially stuff here:

When you use PRINT (or ?) you can use either , or ; to separate normal text from variables.
, will print the variable after a "tab" while ; will print it right after the text.

: is used to separate different functions on the same line, like PRINT "HI": PRINT "HI AGAIN".

Oh, and to generate saves for your games you will most likely need to use str$(), val() and the "search and replace" functions ejamer mentioned.
To save the state of your game you need to fill the MEM$ variable which you can then save using SAVE"MEM:name of the file" and load using LOAD"MEM:name of the file".
All you need to do is save all the important variables values to that file at the moment of saving and then download them back on the variables when you want to load.
I think I read that every mem file is limited to 255 bytes (1 character = 1 byte) so you need to squeeze all you can out from those bytes.

CHRED lets you edit CHR files, these are the ones that you can use as sprites AND background tiles.
The CHR files you create with this can be loaded to a game to replace one of the following default settings:
BGU0-3 (background tiles)
SPU0-7(sprites)
BGF0(text characters)
Example, the comand LOAD "SPU1:mysprites" will replace the default SPU1 page of sprites (the one with the warrior and the witch) with those on the CHR file named "mysprites".
It doesn't matter where in the program you create your sprites, once you save them as a CHR flie, you can use them for any of these purposes.

Note: saving will only save the page of sprites shown on the upper screen, if you edited more than one page you need to save each one manually before leaving the program.

SCRED allows you to create SCR files, SCR files are actually just "premade" backgrounds you can load directly to your game and use them without the need to set every single tile manually by code, backgrounds can use two layers, layer 0 and Layer 1. You need to be very careful with these, L0 is actually the top-most layer and L1 is under it.
The SCRED program start asking if you want to load a character, saying yes brings up the oportunity to load the CHR files you created with CHRED.
To save your background just press X to bring up the menu and then A to pen the File Menu. If you type just S it will only save the layer you're working with right now, type SW to save both (the program will save 2 files, one for layer 0 and another for layer 1)
To use them on your game you need to load both files using LOAD "SCR0:background0" and then LOAD "SCR1:background1"

GRPED lets you create and edit GRP files, which are pretty much just drawings you can load to your game to use instead of backgrounds or something idk. GRP files can be loaded to 1 of 4 layers by using LOAD "GRP(0-3):grpfile".

I don't really fully understand the other one though.

Yeah, that's because CHRED auto-arranges anything you load as background tiles (BGU) in 8x8 squares, so anything you draw in sprite mode (SPU, which by default is 16x16) and load as background tiles (BGU) looks different.

This

QW
ER

Becomes this

QWER

I'm glad I could help.

All the graphical "layers" (but the console) have 2 "pages".
Page 0 is the top screen
Page 1 is the bottom screen.

For example
GPAGE 0
GFILL 0,0,255,191,COLOR
GPAGE 1
GFILL 0,0,128,191,COLOR

Will fill the top screen with a solid color (stored in the COLOR variable) AND fill half of the touch screen with the same color.

Other graphical layers have their own PAGE commands

So, in a way you can only work with a screen at a time, but it's so fast you won't notice it.

Peidorrento wrote:

Does anyone knows how to save and load a single variable in a file? I couldn't figure out googling it... I found that it has something to do with a "mem" file, but I don't understand how to manipulate it.

You need to use the variable MEM$.
As you can see it is an alphanumeric variable so you'll need to use the command STR$(Variable) to save numbers on it.
MEM$ can contain only 255 characters (or was it 256?) so you need to think of a good way to use that space.
After you fill MEM$ with the contents you want to save just use SAVE "MEM:name", that will save all the contents of MEM$ on the MEM file named "name".

Example:
MEM$=STR$(highscore)
SAVE "MEM:HSCORES"

To load it back, you need to use LOAD "MEM:name", that will replace the local MEM$ variable with the contents on the MEM file named "name".
Then you can start reading MEM$, since it is actually a string of characters, if you want to read numbers you'll need to use VAL(string).

Example:
LOAD "MEM:HSCORES"
highscore=VAL(MEM$)

If you have more than one value stored on MEM$, then you'll have to use MID$ or something similar to search through MEM$.
And of course you can save and load more than one MEM file for the same program, but there is only one MEM$ variable.

Well you see, these one of the few things that are actually explained quite nicely on the manual, but I'll try to explain the logic behind sprites.

You can set up to about 100 sprites at the same time on the screen, though you could see them more as "objects" than sprites.
To "initiate" a Sprite (or object) you use SPSET (look the manual for the parameters), the one thing you need to remember is the "Control Number" you give to that sprite (which can be any number from 0 to 99 I think), using that control number you can then use other comands like SPOFS (which allows you to move the sprite around), SPSCALE, SPANGLE, etc.
The same control number is used with the colition detection commands (which are also explained in the manual), so you can check if the sprite 0 is colliding with the sprite 1 or any other sprite and tell the game what to do.
You can reinitialize sprites as much as you want so you can reuse Control Numbers, just remember, only 100 at a time on the screen

I'd recommend you to get a notebook and write all the SP-related commands.

This language is very old school so you won't find any easy solution to make "walls" from the background, you could use invisible sprites or something completely different, you need to think of various ways to solve that, just look at it from different angles until you find the solution that best suits your project, then you'll even be able to reuse that solution in other games!

Backgrounds are limited to 512*512 pixels (that's a little more than 4 full DS screens) and you can scroll through these pixels with easy to use commands, just keep in mind this: Even if you scroll through the background, sprites will stay in the same position until you move them by code, and.... If you want bigger enviroments, you'll need to find a way to update the background by code.

It may sound a little overwhelming, but it is not as hard as it seems... Playing some old games or reading about how they work will help you.
For example: Metroid has actually a set number of pre-made rooms or "room styles" that repeat themselves around the game world with different palletes to create the different areas of planet Zebes (several other NES games work in the same way), by using the DATA and READ commands, that would be actually quite easy to do!

ON-GOSUB/GOTO

It works in this way (writing by memory, I could have something wrong):
You have a numeric variable X and you use:
ON X GOSUB @sub,GOSUB @sub2, GOSUB @sub3

What it really does:

If X==0 THEN GOSUB @sub
If X==1 THEN GOSUB @sub2
If X==2 THEN GOSUB @sub3

It is useful for things like menus.

names can only be 8 characters long.

Eh let's see...
You have
@MAP1
DATA "111111"
DATA "100001"
DATA "102201"
DATA "102201"
DATA "100001"
DATA "111111"

And you want to use that data to draw a 6*6 room using some background tiles.

LABEL$="@MAP1" 'set the label where the DATA is

@DROOM 'a subroutine to draw a 6*6 room using DATA
RESTORE LABEL$ 'set the DATA pointer to that label
FOR Y=0 to 5 'start Y for
READ L$ 'read a line of DATA
FOR X=0 to 5 'start X for
IF MID$(L$,X,1)=="0" THEN BGPUT 0,X,Y,45,8,0,0 'draw background tile 45 if the Xth data of the Yth DATA line is 0
IF MID$(L$,X,1)=="1" THEN BGPUT 0,X,Y,54,8,0,0 'draw background tile 54 if the Xth data of the Yth DATA line is 1
IF MID$(L$,X,1)=="2" THEN BGPUT 0,X,Y,65,8,0,0 'draw background tile 65 if the Xth data of the Yth DATA line is 2
NEXT X:NEXT Y 'Move on
RETURN 'Return

That way you can write yourself multiple DATA structures with number variations to draw different rooms using the same code.
Or something like that.

If you want to make Game and Watch games. I just thought this up:
You could use GRP background with certain higlighted areas (think: Game and Watch character's "shadows") and use GPAINT to make them black or a color similar to the background depending on what should be on screen.

I may need to try it myself now.

Dim is used to set arrays.

Example:

DIM MYARRAY(X)
Creates a numeric array named MYARRAY with space for X numeric values.

These values can be assignated and used by writing MYARRAY(I), where I is any numer from 0 to X-1. Example:

DIM MYARRAY(3)
MYARRAY(0)=5
MYARRAY(1)=2
MYARRAY(2)=MYARRAY(0)+MYARRAY(1)
PRINT MYARRAY(2)

(That will print 7)

You can also create alphanumeric arrays to hold strings. Also, arrays in petit computer can have up to 2 dimensions.
(example)
DIM AR$(X,Y)
Creates an alphanumeric array with space for X*Y string lines.

GOSUB is pretty important, it allows you to go somewhere else on the code without terminating what you're doing at that moment. Example

You have:

PRINT "This goes first"
GOSUB @DOSOMETHING
PRINT "This will be printed 3rd"
GOTO @DOOTHERTHING
PRINT "This won't be printed"

@DOSOMETHING
PRINT "This will be printed 2nd"
RETURN

@DOOTHERTHING
PRINT "This will be printed last"
END

See the difference?
When you use GOSUB you need to end the code of the subroutine with RETURN. When RETURN is reached, the program will go back to where it was before using GOSUB.
When you use GOTO, the program will continue on with whatever is on the new routine, never turning back.

About SPREAD, it works differently from normal commands in that it needs variables to store the info it returns.
The most basic form of the command would be like this:

SPREAD (<control number>), X, Y

That means that you must indicate the control number of the sprite you want to check in the () and then put two variables, one for storing the current X coordinate of that sprite and another for the Y coordinate of it.

It can be expanded (optionally) to include more data:

SPREAD (<cn>),X,Y,Angle,Scale,Character

Only X and Y are required, and you can expand it in that order.
In other words, if you want to obtain the current character data (the image being displayed to represent the sprite), you MUST also ask for X, Y, the angle AND the scale, designating a variable for each (or make them share the same variable, since it will be overwritten anyway). But if you only want to know the angle, there's no need to ask for the scale and character

Expand

I found this on another website (I dont read the terms, so i dunno if i can post the website XD, i will read them, i promise).

Alternate Loops
How Alternate Loops Work
Although these alternate uses of FOR~NEXT might not be easy to understand at first glance, remember that TRUE and FALSE values returned by any conditional statement are actually integer values 1 and 0. TRUE is always equal to 1, while FALSE is always equal to 0.
While Loop
In some cases you may want to enter and then repeat a section of code as long as a specific condition is true.
Syntax:
FOR I=1 TO (while condition)
I=0
...
NEXT I
Note that the upper limit for the loop (ie: condition) is re-evaluated for each iteration. Setting I=0 inside the loop and then incrementing (+1) that value with the NEXT statement ensures that I is always equal to 1 when the FOR statement is evaluated. In this case, the loop continues running as long as the while condition is TRUE (1) and ends as soon as the specified condition returns a value of FALSE (0).
Example: Print the value of X while X is less than 10.
X=0
FOR I=1 TO (X<10)
I=0
PRINT "Value of X is: ";X
X=X+1
NEXT I
Do~While Loop
Although similar to the While loop discussed above, a Do~While loop differs by ensuring that the loop body is always executed at least once and continues to execute as long as the (while condition) remains true.
Syntax:
FOR I=0 TO 1
...
I=!(while condition)
NEXT I
Note that you must negate the while condition in this case. Using the logical NOT operator (!) changes a TRUE (1) result to FALSE (0) and vice versa, so that the value of I is always the opposite of the while condition. In this case, the only way to exit the loop is for the while condition to return FALSE (0), which sets the value of I to TRUE (1). When incremented at the end of the loop, I becomes 2 and the loop ends.
Example: Print the value of X, and continue printing that value while X is less than 10.
X=0
FOR I=0 TO 1
PRINT "Value of X is: ";X
X=X+1
I=!(X<10)
NEXT I
IF~ENDIF and Nested IF Blocks
Petit Computer limits the commands you can use after an IF statement to a single line. When larger blocks of code need to be executed after an if statement, the most obvious solutions are to:
string together several commands on the same line, separating them with colons (
use a GOSUB command and create a subroutine with the code you want to execute
make creative use of GOTO statements and multiple labels
One other option you can use is a FOR~NEXT block of code.
Syntax:
FOR I=1 TO (if condition)
...
NEXT
In this code, if the condition is FALSE (0) then the value of I is already larger and the loop body is skipped. If the condition is TRUE (1) then the values are equal and the loop body will execute exactly once - after which the value of I is increased to 2, larger than both TRUE and FALSE values, ensuring the loop can never run twice.
An added benefit of creating blocks of code this way is that it's easy to nest multiple IF statements within the FOR~NEXT body.
Example:
INPUT "Enter your score and username";myScore,myName$
FOR I=1 TO (highScore<myScore)
PRINT " High Score Achieved! Way To Go ";myName$
IF highScoreName$!="" AND highScoreName$!=myName$ THEN PRINT " You Beat ";highScoreName;"!"
highScore=myScore : highScoreName$=myName$
NEXT
PRINT "Thanks for playing!"
This sample program can be run multiple times to see the different possible results, as high scores and names are carried over until memory is cleared using the CLEAR command.
BREAK (Exit a FOR Loop)
When written as follows, you can exit the FOR loop without using the GOTO command.Syntax:
FOR I=0 TO value
IF (break condition) THEN I=value : NEXT : FOR J=1 to 0
...
NEXT
The key here is to understand the three steps in the break process. When you want to break out of the FOR~NEXT loop, the following things must happen:
First the value of I is incremented to be greater than or equal to the value checked in the initial FOR loop.
Then a NEXT command is used, so that I is incremented and the FOR condition is checked again.
Finally, the program tries to continue with the statement after the NEXT command , where a second "dummy" loop (FOR J=1 TO 0) is declared that is designed to automatically jump to code underneath the following NEXT command.
Note that you can re-use the variable I in the second FOR statement, but using a different variable will preserve the value of I when the break occurs - often desirable behavior if you want to know how many times the initial loop was run.
Important Note: Use caution when using this BREAK syntax if specifying variables with the NEXT commands or nesting FOR~NEXT commands.