#nogdus

[therichardmarks]

NOGDUS Archives - Obscure C++ Syntax

Originally written for NOGDUS in 2010. Edited and formatted for ToV in 2014.

OK, today I just discovered an apparently undocumented (as far as I can tell - hours of googling has returned nothing) feature of the C++ language.

You likely already know that you can create arrays of data types using the brackets:

int myarray[100];

And that the size is optional if you initialize inline:

int myarray[] = {1,2,3,4,5,6};

And that you access the elements of the array like this:

int index = 4; int value = myarray[index]; // value = 5 using the array init above

But here is what I just learned.

You can use the array name as the index and the index as the variable! :o

int index = 3; int value = index[myarray]; // value = 4 using the array init above

This also works:

int value = 3[myarray];

Woah.. coolness! This lets you do some interesting things. Here is a fun little program. See if you can figure out what it does BEFORE you try it out!

#include <iostream> using namespace std; int main(int argc, char* argv[]) {    char god[] = " !ABCDEFGHIJKLMNOPQRSTUVWXYZ";    int am_a[] = { 9, 6, 13, 13, 16, 0, 24, 16, 19, 13, 5, 1 };    for (unsigned int i = 0; i < (sizeof(am_a) / sizeof(int)); i++)    {        cout << i[am_a][god];    }    cout << endl;    return(0); }

Pretty slick stuff. I love C++. 8)

[therichardmarks]

NOGDUS Archives - Manual Number Base Conversions

Originally written for NOGDUS in 2008. Edited and formatted for ToV in 2014.

As a programmer, numbers should not intimidate you. I find that many people (myself included) have trouble understanding different number systems such as hexadecimal and binary. I recently had to deal with these two bases a LOT and learned a few tricks that I'm going to share with you.

You can easily convert binary to hex as long as you can count. Let us start simple. The letter A in ASCII has a decimal value of 65. Let us see what that looks like to the computer eg. in binary.

01000001

Well thats confusing isn't it? Not really if you understand how to read it. I'm going to display that vertical to make explaining this easier.

0 - bit # 7 | 128     off 1 - bit # 6 | 64     on    64 + 0 - bit # 5 | 32     off 0 - bit # 4 | 16     off 0 - bit # 3 | 8        off 0 - bit # 2 | 4        off 0 - bit # 1 | 2        off 1 - bit # 0 | 1        on    1 = 65

Okay? Got it? It is just that simple. Big numbers scare the hell out of a LOT of people. You're about to see some VERY big numbers. Don't run away! Now, counting keeps going the more bits your have (that was just 1 byte) What if you have a 32-bit number? Well you have to keep on adding up those numbers!

Let us take the decimal value 4294836225 for instance. In binary it looks like this:

11111111 11111110 00000000 00000001 Byte 3   Byte 2   Byte 1   Byte 0

But what does it mean and how does that mean that BIG number? I'm going to show you how! And I promise this is the last vertical binary listing I'll do.

Byte 3 1 - bit # 7 | 2147483648     on    2147483648 + 1 - bit # 6 | 1073741824     on    1073741824 + 1 - bit # 5 | 536870912        on    536870912 + 1 - bit # 4 | 268435456        on    268435456 + 1 - bit # 3 | 134217728        on    134217728 + 1 - bit # 2 | 67108864         on    67108864 + 1 - bit # 1 | 33554432         on    33554432 + 1 - bit # 0 | 16777216         on    16777216 + Byte 2 1 - bit # 7 | 8388608         on    8388608 + 1 - bit # 6 | 4194304         on    4194304 + 1 - bit # 5 | 2097152         on    2097152 + 1 - bit # 4 | 1048576         on    1048576 + 1 - bit # 3 | 524288         on    524288 + 1 - bit # 2 | 262144         on    262144 + 1 - bit # 1 | 131072         on    131072 + 0 - bit # 0 | 65536         off Byte 1 0 - bit # 7 | 32768         off 0 - bit # 6 | 16384         off 0 - bit # 5 | 8192         off 0 - bit # 4 | 4096         off 0 - bit # 3 | 2048         off 0 - bit # 2 | 1024         off 0 - bit # 1 | 512         off 0 - bit # 0 | 256         off Byte 0 0 - bit # 7 | 128         off 0 - bit # 6 | 64         off 0 - bit # 5 | 32         off 0 - bit # 4 | 16         off 0 - bit # 3 | 8             off 0 - bit # 2 | 4             off 0 - bit # 1 | 2             off 1 - bit # 0 | 1             on    1 = 4294836225

As you can see above, each bit (counting from the right) is exactly double the previous bit. Okay, so now you know a bit about binary numbers.What about the cryptic hexadecimal numbers that scare away so many? Yeah thats easy too. I'm sure that you have seen hexadecimal numbers somewhere in your programming life. If not, if you are running linux, open a terminal and type in xxd -u /boot/vmlinux > ~/vmlinux.hex and open that up in a text editor. I like SciTE personally. Okay, so yeah..thats hex and quite confusing if you're uninformed.

Hexadecimal, or Hex for short, is a base 16 counting system.

Decimal:     0  1  2  3  4  5  6  7  8  9  10 11 12 13 14 15 Hexadecimal: 0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F

Let's look at the letter A in decimal again: 65

Now, in hexadecimal what would that be? Well there is an easy way to find out! Remember the binary for 65? Here it is again incase you forgot.

01000001

Cut that in half creating two "nibbles" of 4 bits each:

left (low) nibble right (high) nibble 0100 0001

Forget about the high nibble for now. Now you only have 4 bits to worry about.

0100

That in itself is what? ... (look at the first vertical byte list if you forgot)

Got it yet? I did. ....  4h!

Now what about the high nibble?

0001

.... Easy. It is 1h

Now put them together, 41h ... that is the hexadecimal equivalent of 65 in decimal!   So, when ever you need to convert a decimal number to hex, its easiest to first get the binary of it, then bust that into nibbles. :) As a final example, lets look at a stream of binary bits of no origin than my head.

101010101100010111100010101010010101001010100101

Yikes... Okay.. We can do this...Easy.

First, just break that scary string of digits into nibbles:

1010 1010 1100 0101 1110 0010 1010 1001 0101 0010 1010 0101

Now let us convert each nibble into hexadecimal

A A C 5 E 2 A 9 5 2 A 5  

That wasn't hard. Okay, that is it for today. Want to know more? Ask me.

[therichardmarks]

NOGDUS Archives - Function Calling Tricks with AS3

Originally written for NOGDUS in 2011. Edited and formatted for ToV in 2014.

Going to show you how to call a static public function of a specific class from a class reference variable.

Let us use a fantasy rpg game as our example. Let us now assume we have four classes: * Barbarian * Thief * Wizard * Knight

Now, let us assume that each class has a static public function called load

static public function load():void { ..loading code omitted for brevity of example.. }

Let us put all the names of the classes into an array:

var actors:Array = [Barbarian, Thief, Wizard, Knight];

Let us say that selectedClass is an integer that gets set from some UI callback when the user selects which class that they want to play. Let us get a class reference to the selected class:

var actorClass:Class = actors[selectedClass];

Now, we can call the load function by passing in function name as a string inside square brackets.

actorClass['load']();

And just to show another shortcut you could use, we do everything in just a single line of code:

([Barbarian, Thief, Wizard, Knight][selectedClass])['load']();

I hope this sheds some light on the subject of calling static public functions from class reference variables.

[therichardmarks]

NOGDUS Archives - How to SMUBT Your Sprites!

Originally written for NOGDUS in 2012. Edited and formatted for ToV in 2014.

Here is a killer programming gem that I have developed myself. :) The purpose of this code is to ensure that your sprites move at the same speed in all 8 directions. Typically this is done by using a normalized (unit) Vector (maths. ick) and requires both a call to a square root function and two division operations. My technique reduces the code complexity to that of a simple array look-up. No extra branching, no square root calculations, just nice fast easy code.

To my knowledge, this technique has never been done like this before, and so I hereby claim this technique as my own, and give it the official oh-so-clever name of SMUBT(pronounced as smoo bit)

Please be sure to give credit if you happen to smubt your sprites in your code.

An implementation using ActionScript 3.0 follows.

// Sprite Motion Using Bitmasking Technique // (C) 2012, by Richard Marks 02/07/2012 // Please give credit if you use this technique in your code. // // movement control code reference table // 0x00 : no motion // 0x02 : -y motion // 0x04 : +y motion // 0x08 : -x motion // 0x10 : +x motion const mm:Array = [0, 0, 1, 3, 1, 2, 0, 0, 3, 1, 5, 5, 5, 4, 0, 0, 2, 1, 4, 5, 4, 4]; const mt:Array = [0, 0.0, 1.0, -1.0, 0.7071067811865475, -0.7071067811865475]; // set movement control code based on key input var mcc:uint = 0x00; if (GameController.dPadUp) { mcc |= 0x02; } else if (GameController.dPadDown) { mcc |= 0x04; } if (GameController.dPadLeft) { mcc |= 0x08; } else if (GameController.dPadRight) { mcc |= 0x10; } // look up movement value to obtain unit vector var mx:Number = mt[mm[mcc]]; var my:Number = mt[mm[mcc + 1]]; // scale by speed for motion vector mx *= speed; my *= speed; // apply motion vector to position to move sprite sprite.x += mx; sprite.y += my;

[therichardmarks]

NOGDUS Archives - A Number Guessing Game in Pascal!

Originally written for NOGDUS in 2008. Edited and formatted for ToV in 2014.

Ready for something completely strange, yet new and exciting? So am I and this is not it. :D

I knocked this up after only 2 hours of reading pascal tutorials to learn the syntax. And actually, the majority of the time was spent following along with the tutorials, and trying to code the programming assignments. Anyway, without any more delay...here is guess.pas

(* guess.pas Simple number guessing game in Pascal Written by Richard Marks <[email protected]> *) program Guess; uses crt; const MAX_GUESSES = 5; var myNumber, yourNumber, guesses : integer; guessing, playing : boolean; response : char; (* main code *) begin Randomize; playing := true; writeln('Guess'); writeln('Written by Richard Marks <[email protected]>'); writeln(''); writeln('Guess a number from 1 to 100 in 5 tries or less.'); writeln(''); (* main game loop - keep asking the user to play again after he or she wins or loses *) while playing do begin (* init game vars *) myNumber := Random(101); guessing := true; guesses := 1; (* game play - the actual game logic loop *) while guessing do begin (* if we run out of guesses *) if guesses >= MAX_GUESSES then begin writeln('Sorry, you did not guess my number fast enough! You lose!'); guessing := false; end; (* if we have not run out of guesses *) if guesses < MAX_GUESSES then begin (* get the guess from the player *) writeln(''); write('(', guesses, '/', MAX_GUESSES, ') What is your guess? '); read(yourNumber); (* if we guessed the number *) if myNumber = yourNumber then begin writeln('Hey you guessed my number in only ', guesses, ' tries! You win!'); guessing := false; end else (* if we guessed too low *) if myNumber > yourNumber then begin writeln('Nope, sorry. ', yourNumber, ' is too low!'); end else (* if we guessed too high *) if myNumber < yourNumber then begin writeln('Nope, sorry. ', yourNumber, ' is too high!'); end; end; (* increment the guess counter *) guesses := guesses + 1; end; (* game is over, ask the user to play again *) playing := false; writeln('G A M E O V E R'); write('Would you like to play again? (Y or N) '); response := readkey; if upcase(response) = 'Y' then playing := true; end; (* game is totally over *) writeln(''); writeln('Thanks for playing!'); readln; end.

If you're on linux, $ sudo apt-get fpc then use $ fpc ./guess.pas to compile the game. If you're on windows, get the windows version of the free pascal compiler (google it) and compile the game. If you're on another OS, get a free pascal compiler and compile the game.

Then, let me know what you think. :D