But I understand now why cold weather exists:

SNOWBOARDING.

I went for the first time this month when some people invited me for work, and now I don't want to stop.  I even bought some gear:

It's a little bright, but when else do you get to wear interesting colors like that?  

I also started going with Tokyo Snow Club, their trips are pretty fun.

Furnished Apartment Photos

For comparison, here's what it looked like a year ago when I first moved in:

Empty New Apartment Photos (1 year ago)

I took some photos:

Tohoku Recovery and Volunteer Trip Photo Album

This is a video someone took of a similar trip the week before us:

 And here's a stupid video of us driving through high tide on the roads of Katsurashima:

--> Open PoolAllocator.cpp in a new window <--

The code above is hosten on Google Code, and you can comment by double clicking anywhere, or by clicking in the left hand margin on the little speech balloon plus icon. You need to be signed in with a google account.  Please comment and tell me if my code sucks!

Implementing a stack allocator isn't hard, but there is one important memory saving trick I'll discuss below:

1. When creating the pool, preallocate a large block of memory, the size of which is a multiple of the size of the separate pool elements.
2. Add each of the free elements to a linked list.
3. When someone wants to use a block, pop one off the free list and return it to the user.
4. When a block is freed, add it back to the free list.
5. When deleting the pool, assert that the number of free elements is equal to the pool size divided by the size of an individual element.

That part is easy.  But we have to consider where we will get memory for the linked list to track the free elements.  Or do we?  We have all this free space in each of the free elements, why not put it to good use?

NOTE: The one caveat here is that the size of each element in the list must be larger than sizeof(void*)

To track the free items in the free list itself we do the following.

1. When creating the pool, after allocating the memory, starting with the beggining of the list, write the address of the next free block at the start of the current block.
2. When providing a block to the user, return the start of the list, but not before setting the pointer to the start of the list to the next block.
3. When returning a block to the free list, write the address of the start of the free list into the start of the newly free block, and set the start of the free list to the newly freed block's address.

Remember that when using the memory of the free block itself as the pointer to the next block, the equivalent to 

mFreeListStart = mFreeListStart->next;

Becomes:

mFreeListStart = (u32*)*mFreeListStart;

Where mFreeListStart is a u32* to the start of memory of the first element in the list,

next is a u32* to the next element,

and  u32 is a 32-bit unsigned integer type.

Working on what?  On Memory!

I've written a few different memory algorithms now, but I'll start with the simplest: a Stack Allocator.

--> Open StackAllocator.cpp in a new window <--

The code above is hosten on Google Code, and you can comment by double clicking anywhere, or by clicking in the left hand margin on the little speech balloon plus icon. You need to be signed in with a google account.  Please comment and tell me if my code sucks!

A stack allocator is useful in games because many games allocate memory for levels in a stack like manner.  When a new game level is loaded, the memory for all the textures and meshes etc is loaded at once, and then nothing more is allocated during the duration of the level.  When the level is unloaded, all of the memory is freed.  A stack memory allocator is perfect for this sort of application.

Implementing a stack allocator is pretty simple:

1. In the constructor, malloc a block of memory to use as the stack, and set it as the base of the stack and as the current top (ensuring it's not NULL).
2. When memory is requested from the stack, store the address of the current top to return, and then move the current top up by the size requested.
3. When freeing, you just set the current top back to the marker passed to the freeToMarker function.
4. Clear the stack by setting the current top back to the base of the stack.
5. When deleting the whole stack, you can ensure all memory has been freed by asserting that the current top is the same memory address as the base. 

The next write up I believe will be Pool Allocators.

Here's a video of what I made:

As you can see, it's a Pac-man themed dot-eating game.  I implemented 3 modes:

• The first mode is an attract mode, like you'd see in arcades (when nobody's playing the game, it plays itself).  The dots slowly enter Pac-man's mouth and he eats them and gets larger and it flashes when he's at maximum size.  Also the digital display (the green number 8 LED) spins around in a circle.
• The second mode is a timing game, where you have to push the green button when the dot is in Pac-man's mouth.  He eats it and grows larger.
• The third mode is a button sequence game in which you just push the buttons in the correct order to feed pack man. (When we were soldering on the components, there was a lot of colored switches, so I put as many on as I could, and I had to think of something to use them for so they didn't go to waste.)

In addition to being able to change modes with the black button, the brown button changes difficulty, which is actually adjusting the speed of the timer that controls everything.

Here's a picture of the circuit diagram as planned in advance, though it is a little different than how it turned out in the end:

Circuit Diagram!The code was written entirely in assembly, which was a new challenge for me.  Compared to writing in C++, it felt like everything took years to do.  But it does make you realize how every line of code you write in C++ is really comprised of a multitude of these moves between registers and RAM (not to mention chip cache) and how all this complex logic breaks simplifies down into branch-if-zero's and other simple math equations. One thing I didn't have time to do was to understand argument passing in functions.  It looked complex and I had a lot to implement, so I just copied and pasted a few functions rather than mess with trying to use a feature I don't fully understand on a platform with no debugging to help me understand what I'm doing wrong.  But it would have been nice to learn if I had the time.

The (amateurishly written) source is available for download here, and is also after the break, with some unfortunately pink syntax highlighting.

I mean, that's my new computer and my new desk! (Also, if you look closely, you can see my space-saving strategy: my futon bed rolled out beneath the desk. I now sleep under my desk every night.)

Why did I spend ~$1,900? Because I'm crazy.  Because I have a plan!

I want to start writing my own game engine. I've recently been reading Jason Gregory's Game Engine Architecture book, and it made me want to have the experience of writing all these systems myself.

While it may take a few years, I'm going to start doing just that, in my spare time.  I wanted to write for code to run on a game console, but the closest thing I have is this iPad, so I bought a new mac computer. (My previous one is about 5 years old, the first Intel mac.) I also spent $100 on an iOS developer license, so now we're up over $2,000.

If you want to follow along with my progress, bookmark this link. I'll try to post on here somewhat frequently about how the project is going, but it will be slow, especially while I'm still taking masters classes part time in Japanese, and working full time.  But maybe in summer the pace will pick up a bit.

And oh yeah, the internship at Bandai Namco Games ended, all the interns that applied (including myself) got full time job offers, and I'm living in Yokohama and working in Tokyo full time now, and it's awesome, my friends here are awesome, blahdy blah blah.  You know, minor details. 

Later I will update the resume, LinkedIn, Facebook... oh god nevermind, there's too much to update,  I quit.

Here's some pictures of my new apartment before I put anything in it:

Empty New Yokohama Apt

And here's a picture of where I work now, taken back in the summer:

On Friday, I got kind of soaked going home from work because I still have not bought an umbrella.  We wanted to go out, but since it was kind of nasty out, we stayed in and watched this Gambling Apocalypse Kaiji movie, based on this manga/anime series of the same name.  I don't think me and Yan understood much, but Karen had read the manga or watched the anime before, so she explained it all to us.  It was pretty interesting.  Basically this guy has some debt to a yakuza like organization, and he has to gamble his way out of it, or spend his life as an indentured servant.  The way the main actor played the role was kind of annoying though, he just basically cried and complained the whole time.

Saturday night we were invited to our work friend Ogura's house again for dinner and drinks, but this time we planned ahead and paid for him.  We played the same drinking game we played last friday, and it was just as loud as before, but at least it wasn't in the hotel.

Sunday I had plans to meet my coworker Daigo from VV, who's working in Tokyo at Square Enix now.

Game Center

It was a Namco arcade I guess, so we played some Tekken, we all lost badly to Daigo.  Maybe he's related to this Daigo.

Then I went home and played a ton of Final Fantasy 13.  Man this game won't end.  I hope I can finish it soon, I really need to start playing something else!

It is the home of Fuji Television:

Odaiba Photos

We ate in this fancy shopping mall, had some pretty delicious chinese food:

After that we headed for this museum, but we ran into this big cosplay gathering before we got there.  Apparently you were supposed to pay to take pictures, but nobody stopped us:

At the museum, they had an Asimo robot, it was pretty cool, a little creepy how human-like it is:

After that, we played some pool and had okonomiyaki, and it was awesome.  Of course our senpais paid for more than their share of everything, because they are too nice.  

The rest of this week has been going pretty smoothly... I was pretty exhausted the beginning of the week, from not sleeping much on Saturday, and from staying up on Tuesday to watch the Japan world cup game, which they lost in penalty kicks, unfortunately.

On Friday, we went with the same people went to Odaiba with for Thai food, and then some of us also went out to do Karaoke, but everywhere was full since it was Friday night.  So we went to an izakaya instead.  After that we partied in my room for a few hours, playing some drinking games.  We were so loud, I'm wondering how long it's going to be before they kick us out of this hotel.

Maybe we'll find out next week. But hopefully not.