@grabsomeeyes
the load screen thing didn't work for me

@everyone
I will release the portal "tech-demo" soon. It is a bit buggy, and it doesn't use the best techniques, but I will be updating it, and fixing that stuff.

I will also attempt making an ai chatterbot (siri is chatterbot mixed with voice control) but thry take FOREVER to make(it is alot of busy-work just making as many words and responses as possible).
btw, feel free to steal any work that I have posted on here for petit computer(or ideas, for that matter)

I put up half the source code up for my 'haloween project' Zombie Horde up on http://petitcomputer.com/Zombie_Horde . I'll try to finish it by Wensday. Meanwhile, get a head start on putting the code in.

Thanks a bunch, man .

I had a question regarding the use of Binary and Hexidecimal. I've figured out so far that I can use &B and &H respectively to manually enter values in Binary or Hexidecimal, as well the use of HEX$() to convert a numerical into a hexidecimal figure. However what I'd like to do is to read a String (or even a portion of it) as a hexidecimal numeral and have it output as a regular numerical (ie to read 'B' from a string to get '11' as an output). The immediate purpose for this is to be able to select from all ranges of the color pallettes using a single figure (using hexidecimal 0-F to reach the range 0-15 respectively)

As well I'm looking at using CHRSET to build a small stable of graphics for a game I'm working on (in lue of dedicating a whole GRP file to download along with it). I'm using a method to save myself some space, using in string character multiplication formula to save space (ex; "F"*24"0"*2). While this works even within the CHRSET command I could not use this through the DATA/READ method as it would then insert the formula into the string itself instead of translating the formula into the string proper. Does DATA only read these as literal strings or can it be made to recognize formulas?

Yes. For some reason, BUTTON 1-3 all take place in 1/60 of a second, so any longer than that, and the input goes missing. I have been relying on BUTTON(0) ever since. I'd do it like this, though:

BTO=BTN
BTN=BUTTON(0)
BTX=BTO XOR BTN
BTP=BTX AND BTN
BTR=BTX AND BTO

Does that make sense?

If you're looking for Petit Asteroid source code: It's out on Petit Computer Journal #11. Still raw, though. I'm too busy prepping for Nanowrimo. Will not be updating it unless I'm ahead of schedule.

@Rambler
Hex2Dec? Something like this?

H$="B"
? INSTR("0123456789ABCDEF",H$)

Wait, INSTR("0123456789ABCDEF",H$) can be used to convert Hex (a single digit) to Dec?
Oh I love you so much right now.

I had no idea INSTR even existed

Sorry. I made a mistake in the address it is http://petitcomputer.wikia.com/wiki/Zombie_Horde . Please note, it is still unfinished (and will be finished sometime Wensday, just in time for Haloween Night, All Saints Day, All Souls Day, and Day of the Dead).

better way to transfer a hex to "normal" number is VAL("&HB") will return 11, just change the B to whatever the hex number is.

edit: just tried and you don't need the VAL() command at all, just use the hex number anywhere a normal number would be used but with &H in front of it.
ex: A=&HB:?A prints 11

as a plus, this can be used for more than one digit hex. ?&HFF will print 255 (and so on)

Thanks! I guess there must be a &H equivalent for OCT and BIN too.
(though INSTR is still nice to know)

I think what was required was to have a hex string be converted to a number. The VAL method works, but the latter doesn't, as the hex number isn't an actual string. With the VAL method, one could simply append "&H" in front of a literal hex string to make the conversion work.

H$="B12"
A=VAL("&H"+H$)
PRINT A

It also works with negative numbers, though the hex string would require being 5 characters long (ex - "FFFFF"=-1 because there are only 19 bits dedicated to the integer portion of the value. The remaining goes towards the rest, 12 bits for the decimal, and 1 to the sign).

edit
Also works with binary if you have a binary string of 0s and 1s and replace "&H" with "&B"

Thanks Ramstrong and Discostew, these methods are exactly what I was looking for

To take things a step further, I would also like to know if it's possible to break down an exsisting number into Binary and break that down into further segments (ie; Turning 55 into 00110111 and then 3 (0011) and 7 (0111) respectively or into even smaller segments ( 00, 11, 01, 00 or 0,3,1,0).

I'm looking to use these to create a much more compact graphical writer for use with a smaller color pallete, but without the need of using whole integers (Perhaps even using ASC to pull 8 bits out of a single character), I think programs that use a smaller color pallete (typically those that intentionally try to emulate the look of classic games) would benefit the most from this.

Yea, its not too hard to break an int into its smaller components:

To break down 55 (00110111):
N1=( &B00110111 AND &B11000000 ) / POW(2,6)
answer: 00
N2=( &B00110111 AND &B00110000 ) / POW(2,4)
answer: 11
N3=( &B00110111 AND &B00001100 ) / POW(2,2)
answer: 01
N4=( &B00110111 AND &B00000011 ) / POW(2,0)
answer: 11

The 11's in the numbers on the right line up with the two digits on the left number that you want to find. The operator 'AND' will separate those digits lined up with the 11's. You also have to shrink the resulting number though as the extra 0s on the right will still remain. You do this by dividing (called bit-shifting) by 2 to the power of the number of zeros to the right of the 11's in the second number.
example: POW ( 2 , number of 0s on the right to get rid of )

Well, I did it! It is done, at least in source code formate. Good luck typeing it in. Err...wrong adress. Try this one. http://petitcomputer.wikia.com/wiki/Zombie_Horde

can somebody explain the conceps of hexidecimal numbers to me?

Hexadecimal is simply a different way of representing numbers. It's useful because computers 'think' in binary - i.e. think in factors of two. While we are used to using decimal numbers in everyday life, it's not a natural numbering system for computers.

First, let's review the decimal system. It has digits 0,1,2,3,.....,9. Now, the way we write a number in any base (be that decimal, binary, hexadecimal etc.) is in the form:

xyzw

If we are in base ten (decimal), we would write the number "one thousand, four hundred and sixty seven" as:

1467 (I know you know this, but I'm trying to keep things flowing well).

Now, what 1467 means is that we have:

1x1000 + 4x100 + 6x10 + 7x1.

1, 10, 100, 1000 etc. are all powers of ten. So we can write the above line as:

1x10^3 + 4x10^2 + 6x10^1 + 7x10^0

so as we read from right to left, each digit indicates the number of tens to the appropriate power that the number contains (so the rightmost is 7 lots of ten to the zero, 6 lots of 10 to the one etc.) Thus, we can write any integer number in this format. Note that the number:

0000000000000001467

is exactly the same number, but for convenience we just discard the left-most zeros.

You may be familiar with binary, which is a similar idea - we just replace the powers of ten with powers of two.

so:

1011011

would be:

1x2^6 + 0x2^5 + 1x2^4 + 1x2^3 + 0x2^2 + 1x2^1 + 1x2^0

which, if we work out the exponents of 2:

2^0 = 1
2^1 = 2
2^2 = 4
2^3 = 8
2^4 = 16
2^5 = 32
2^6 = 64

So, sticking those back into our expanded formula above, we have:

1x64 + 0x32 + 1x16 + 1x8 + 0x4 + 1x2 + 1x1 = 91 (If I've done my maths correctly)

It's just like the decimal you're used to, just with powers of two.

Now, we can use those same ideas with hexadecimal - now our base is 16. So the right-most digit is the number of sixteen-to-the-zeros, the one to the left the number of sixteen-to-the-ones, etc.

If you look at our decimal numbering system, you'll quickly notice that we only have 10 digits. However, that poses a problem - how do you write the number "14" in hexadecimal?

14 is less than 16^1 (=16), so we need to write it as 14x16^0. However, how do we do that with a single digit? (which is the idea - a number should only have one 'digit' for each power of your base). Thus, it was decided to use the beginning of the alphabet. 0-9 are as normal, but we then start with "A" and go on. Thus, when reading hexadecimal, we find:

0-9 = as normal
A = 10
B = 11
C = 12
D = 13
E = 14
F = 15

Thus, to write the number '14' in hexadecimal, we simply write Ex16^0 (or, as it is usually seen, just E). When reading hex, people automatically convert that to mean 14.

So, if we have the number: A48, what does that mean? Just like before, we have:

Ax16^2 + 4x16^1 + 8x16^0, which (remembering A=10) gives us: 10x256 + 4x16 + 8x1 = 2632 in decimal.

Hexadecimal is useful, because to write 2632 in binary, we would require: 101001001000, which is obviously much more unwieldy than A48. Thus, hex is seen a lot in computing.

One final thing is that it's not always obvious what base someone is using. If I write the number:

10011110

how do you interpret that? Is it decimal, is it binary, is it hex, or is it something else entirely? Often contextual clues will tell you, but to be sure there are a variety of schemes. Sometimes you'll see a subscript at the right-hand side of the number (so if the above was binary, it would have a little '2' in subscript on the right-hand side). A common way of denoting hex (such as in the C and C++ programming languages) is to precede it with "0x". Thus, if I wrote:

0x847,

you'd know that it's in hex and not the number "eight hundred and forty-seven".

I hope that helps!

EDIT: Bonus points for telling me what 0x847 is in decimal!

In case of TL:DR:

Hexadecimal numbers use 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E and F as digits (with A being the equivalent to 10 in decimal and so on).
As you may notice, you can use Hexadecimals to write large numbers with fewer digits.

I'm having trouble with my level editor reading graphics files for data. What I'm trying to do is read 400 pixels from a grp file, going to the next line when it gets to the edge, or 255. The thing is that, I have a fairly large grp file, and I want to read 400 pixels from somewhere in the middle, just reading the specific data I need, and I'm having trouble with figuring out an equation where it will give me the starting location of where to read when I give it a number. So lets say I want to load data for the screen at X=2, Y=3, then, 2 x 3 = 6, so I put that number in and load the appropriate screen.

I've been busting my brain on this for a while, and I can't come up with something that works, so if someone could kindly push me in the right direction, I would be grateful

Are you trying to access the GRP section like an array (with a range from 0 to 49151), indexing it with a single value? Try the following line...

VALUE=GSPOIT(IDX AND 255,IDX / 256)

Where IDX is the value that ranges from 0 to 49151. Increment IDX to get the very next byte, whether that is the next pixel on the line, or the first pixel on the next line.

About your method earlier. 2x3 may equal 6, but with a GRP file, acting like an image, getting data at (2,3) would actually use the formula ((y * 256)+x), making it ((3*256)+2)=770. So, with the line I displayed earlier, you can set IDX to 770, and increment IDX after you read each byte, and it'll increment sequentially, because 770 AND 255 = 2, and 770 / 256 = 3.0078 (but the GSPOIT function only accepts integers, so it floors it automatically to 3).

@petiSnail
Great explanation! Are you going to post it on Petit Tutorial thread?

I wrote a simple program for the algorithm:
CLS
?"FOR BITS:"
?"DEC:1=10;2=100;3=1000"
?"BIN:1=2;2=4;3=8;4=16"
INPUT "NUMBER,BITS";N,B
@LOOP
?N%B
N=FLOOR(N/B)
IF N!=0 GOTO @LOOP
?"DONE!"

SAMPLE OUTPUT
55,16
7
3

55,4
3
1
3

123456,100
56
34
12

hey swordx my 3DS friend code is 3136-7615-5907 please register me i have already registered you