Kreation’s Edge

This afternoon after I get in from enjoying the sunlight I started up GODZ and get a crash right off da bat. Wow. So resolved the read/write data race and uploaded a new build. This build I was in the middle of optimizing game->render thread updates. So this build is a big jump over the former. When I’m finished things should be running really smoothly.

After I’m done with the optimizations I had planned I’ll look into adding some smooth blends between animation playbacks. Right now when you switch animations I believe this occurs immediately rather then interpolating between the two animations. Animation playback should look a lot smoother when I’m done

So beat Too Human last weekend with bout 15 hours clocked in. Beat Soul Calibur IV single player mode using a few different characters…. Right now working on Lost Odyssey when I get time to play. Played Ninja Gaiden II a bit but only had time to get past the first level. Trying to knock out a few titles before Spore and all the other craziness hits. But it appears I won’t be done with my current mountain of games in time.

Got Mercenaries 2 on the way should hopefully get here in the mail shortly….

This is really a sweet time for gamers. There are so many nice looking titles to look forward too

One really good question I’ve seen interviewers ask is a basic math question dealing with number sets. Just to trip up the applicant just a little, they ask in reverse order.

If you have a number range {10….6} please find the number that is 10% within this number range.

This is actually a very good question to determine basic math skills. Dealing with Number sets might be used for Targeting gameplay systems whereas the joystick value is used to sample a number within a number set (for instance, the number set is our set threshold that we are sampling a value from).

Anyway the solution is simple.

First determine the difference between [x,y] where x=10 and y = 6

size = 4 (10 - 6 = 4)

This is the size of our entire boundary. Now, multiply the size of our number range by z (z = 10%)

result = size * z;(result = 4 x 0.10 = 0.4)

Next, take x and subtract the result to get our answer.

solution =  x - result;

solution = 10 - 0.4 = 9.6

Ericson brings up an interesting point on Bit Manipulation. Yep, it’s a very important skill to have and it’s not a bad idea to keep reviewing at the very least, the basics. I’m linking this article more for my own selfish reasons though. Many interviews will contain at least one Bit Manipulation question so this looks like a very good read. I have to go to bed so only made it halfway through atm. So will have to review it more tomorrow when I’m fully rested

So I have a close friend that works at a studio that had layoffs…. This is unfortunate however it is a blessing they kept him. Having worked with him closely on a few titles I know for a fact he’s a hard worker and will put in extra time to meet deadlines, etc. So even though it’s sad that many good people have lost their jobs its great that the employers still recognized his invaluable contributions and kept him around.

So the message for today is to stay motivated and focused on your work. Work hard to do right by your fellow coworkers because you never know- one day they might be the one making the decision to hire you at another studio in the future. Small world, small industry….

Uploaded a new demo. This version is a significant jump over it’s predecessor in performance and runs a lot more stable. Ah, I’m feeling warm and happy inside

Lately I’ve been thinking about playing around with integrating multicore physics. Currently, the physics system I coded occurs in the main game thread pass. You know the routine. Multicore physics or rather in my case, Multicore Collision Detection would involve the main thread passing collision volumes to a concurrent physics thread. The physics thread takes the velocities of the objects and watches for collisions. When a collision is detected, this information is propagated to the main thread

The gains for the average title might not be all that huge but for a title with hundreds of entities in the physics world the savings might be worth it. In my case though I mostly interested in leveraging more cores.

I’m a little hesitant though to go rip apart my engine yet again to introduce another layer of complexity. Actually, what I really dread is the thought of having to chase a potential read/write data race issue.

But if I do decide to pursue this my thought is that I would write this as a “Job” that runs asynchronously, running the physics simulation on its’ own Core. Essentially it would work like this:

- Loop

– Check queue for collision volume updates

— Run the physics simulation

—- Copy current state into a list of events that the main thread can query at anytime for current status of the physics world

The only bottleneck here is the last step, when the main thread queries “Physics World” for the current state. But it shouldn’t really be a bottleneck if this is handled properly.

Should be a fairly straight forward thing really unless I’m missing something. The main game thread and physics really shouldn’t be sharing much information beyond the current state of the physics world. If I do implement this will make sure to keep it all configurable so I can switch between single threaded and multi-threaded physics.

Yep, they covered that whole debacle well here already

Yep it was a read/write data race condition that was causing the issues. The render thread was creating Game objects on the heap that represented the DirectX driver. The problem was this game object could be registered while an asynchronous read was taking place in another thread. So the threads were clashing which resulted in the occasional crash I experienced when starting up the game. The only clue I got was that I was seeing impossible memory values for these game objects sometimes.

What blew it only happened in Release. Never could get it to happen in Debug. So it kinda sucked trying to go through that call stack.

Anyway I’m just going to make sure to put some thread checks around the hot spots to insure this won’t happen again.

Happy me, feels great to resolve this issue. Will be uploading a new Demo later tonight / tomorrow

I’ve worked at companies that existed at both extremes of the spectrum on this issue. Most companies do not perform code reviews. However, a few do. I’m indifferent on it’s use however I do think it’s very effective for a few reasons:

• When a programmer modifies code in the domain of a peer. This way, this programmer is not unintentionally breaking something the domain expert has implemented. So say, a game programmer should conduct a code review with the graphics programmer when they tresspass into each other’s domain
• When the source codebase is locked down. Programmers can send code reviews which can go up the chain to upper management giving them the opportunity to verify if the feature should go into the build.
• Helps insure coding guidelines are enforced

Those are the main benefits I’ve noticed from integrating applications like CodeReviewer.