You just started counting at 0 ;)

Whoops!

I didn't notice.

With all your mega drive knowledge, do you ever feel like making a 16bit game again?

*D'oh!

Good comments and variable names.

The code is trivial, have you seen all the multitudes of sonic hacks around, they did not even have the original source code, they were made using a disassembly.

@@sonicmastersword8080 *COUGH COUGH SONIC 3K CIGH COUGH*

I can't even do that with code I wrote 2 weeks ago.

@@sonicmastersword8080 "Hack" "Ynot" "Aok3" uh huh. Nah, some people can just code without comments, and that's why they get paid a lot for doing big projects by themselves. It's a thing you can learn, by never reading comments in the first place. Competitive programming sites and competitions, and stuff like code golf, are also great ways to learn it. There's an OG Microsoft programmer on youtube who talks about it too, he's also a big fan of competitions

I was about to say the same thing lol "if you want me to do a video about this, let me know in the comm-" YES YES YES

And, like most good ideas in programming, it's a built-in feature of Ada.

Not sure about that. I'm going to over explain this a bit so it hopefully makes sense even to someone without background knowledge. What he did is basically the same thing that floating point does where you have a number multiplied by another number representing an either very large or very small number. With both fixed point and floating point you have a certain number of bits to represent your number (I believe it's 32 bits in most modern systems). In fixed point every bit before a certain position in the number is before the 'decimal' point and every number after is after the 'decimal' point, excepting 1 bit that's used for the sign, that is whether the number is positive or negative. This allows you to have extremely precise fractional numbers that are easy to work with but the size of the number is very limited (the point is fixed). With Floating point you have a certain number of bits that represent a number, let's say X, and a certain number of bits that represents another number, we'll go with n. The actual number this represents is X * 10^n (there's also 1 bit for sign just like with fixed point). This allows for much larger numbers BUT you lose accuracy. So with fixed point you might only get 15 (binary) digits before the 'decimal' point and 16 after while with floating point you might get 65,000 digits before OR after the 'decimal' point but only the first OR last 15 bits (0 through 32,767) would be unique numbers (assuming 15 bits for X and 16 for n, and 1 bit for sign). 32767.3255 might be possible with fixed point but not floating point while 32767*10^65000 might be possible with floating point but way out of the scope of fixed point. To be clear I'm not sure how many bits are actually reserved for X and n in a standard floating point and I'm even less certain what the standards are for fixed point (or if there even are standards for modern languages though I presume there'd have to be). I just remember the basics of how they work and did some math using a few presumptions. Since he's multiplying or dividing a number by 2048 (2^11, he misspoke during the video and meant to say dividing by 11) that seems a lot closer to the way floating points are handled and as such won't have the same precision as a fixed point (of course a good programmer will take measures to offset the inaccuracies of floating point numbers). I should probably also mention that while 32-bit is standard most modern hardware can handle 64-bit (or perhaps even higher) precision variables (the general name for floats, ints, strings, ect in programming). In fact it wasn't that long ago that KZfaq switched the views variable from an INT (32-bits) to a LONG (64-bits) because the Gangnam Style video exceeded 2,147,483,647 views [(2^31)-1]* and started appearing negative . Suppose you have a 4 bit number 1110 and you add 1 you would get 1111, if you add another 1 you get 11111 but obviously that's more digits than you're supposed to have, that's called an overflow. In an INT (just like floating and fixed point number) the number farthest to the left represents the sign so if the number overflows the sign can end up flipped. Technically KZfaq could have used a different type of variable called an unsigned integer (literally doesn't have the sign) and that would have prevented the number from appearing negative but it's generally best practice (and standard practice for Google Engineer apparently) to avoid using unsigned numbers when possible (it opens up the possibility of more severe and harder to diagnose bugs). *Continuing to try to over-explain for those less knowledgeable on the subject, 2^32 would be the number represented by an unsigned Integer if we started at 1 (not 0). We use 31 since one of the bits contains the sign and we subtract 1 to include 0 so a 32-bit (signed) Integer can represent any number from -2,147,483,648 to 2,147,483,647 (we can go 1 lower on the negative side since we subtract 1 from the positive side to include 0, technically we could go the other way and have 648 on the positive side and 647 on the negative side but for whatever, probably arbitrary, reason that's not the standard). Edit: Wanted to mention that converting to a floating point still has some advantages since he can do some math on the expanded, more accurate form before reverting (dividing) to a smaller number. When the number is divided back it loses some of it's accuracy but it's still more accurate than doing the math without having multiplied it out first.

This guy gets it

It's the worst part of development. SDKs, toolchains, all that garbage... I'd rather build separate (virtual) machines or OSs specifically for each dev environment.

Its worse now than in the past, I would guess that to build that game just requires a few exe files on path.

The other day I tried setting one up which I found online, as I wanted to mess around with something. Took forever to compile/install and it still didn’t work.

@@michaelstamper1191 You needed multiple machines in the process. A Mac was needed just to do audio and graphics.

Reminds me of this kzfaq.info/get/bejne/iNShdLumscDQkXk.html

That's not C# That's 68k ASM (sorry if I annoyed you,but I just want to correct the com- wait,i misread the comment)

@@nil8659 You misread the comment.

@@nolram ohhhhh

Well, he's got those sharp quills on his back, so it makes sense.

Bye poochie

Basically he only has integer so he does the binarey equivalent of multyplying by 10000 and dividing by 10000

@@auxencefromont1989 It's a little more complex than that. While the number is expanded (multiplied) he can do various operations to it with more accuracy than he could with smaller numbers. When he divides it back he loses some of that accuracy but it's still closer than when he started. It's basically the same thing as floating point numbers (a few people here have mentioned fixed point numbers but that's not really accurate since fixed point has perfect precision at the cost of a smaller range).

what a weird comment to get a heart like...

@@ForeverMan Hey ForeverMan, hope you're having a great day!

Here's a good starting point en.wikipedia.org/wiki/Fixed-point_arithmetic

Hey my dad makes cars and says they don't use floats, they just store a int for each digit. Just wanted to say fixed point is still being used nowadays!!

ComputerPhile has some good (albeit older) videos on the subject. There's a few tricks that were discovered that allow floating point math to be done a lot faster and of course modern CPUs (and GPUs) have dedicated floating point modules.

Creative guy. He should go into gamedevelopment or something

@@acos21 hahah funny

I agree!!!!!!

There's a short series on the GameHut channel about making a Genesis game in ASM: kzfaq.info/sun/PLi29TNPrdbwLmUjiVvLLrRky7cXrlSIYr

Ask any developer you know, or find a friendly one on Twitter. They will tell you the same - they don't remove stuff that was meant for debugging purposes, because they don't know what other important functions they do.

Doh!

wow shift to left by x = divide og number by 2^x

@@Mizu2023, just like in decimal shifting decimal point to the left by one position divides the number by 10.

Your compiler should be doing that already, assuming the variable isn't floating point. If it's an "integer" variable (regardless of the bit size) then the compiler will do everything it can to substitute division with bit shifting if you're dividing by a power of 2.

That's probs the buzz factor for angrybirds addicts/gamers Lol

I'd love to see if he has the coding genius (and enough of its source code) to make a Dreamcast port of the original LEGO Star Wars. I _know_ it can be done, it's all just a matter of actually doing it that just hasn't happened yet! Surely with enough elbow grease I believe Jon could make it happen.

I feel ya. Man, if I had a few $$$s to spare I'd legit consider hunting down Gems Collection on PS2. Thing is absurdly expensive, but totally worth it to me.

Look up "68000 Tricks and Traps" and you'll find a few