Double edit: Parts of this post no longer appear valid to me. In particular, the "table" of bits is wrong, and my gripes about the leading zero are unnecessary. See my later post for the corrections.

Arrrgh, I think I may be on the right track to understanding those eight bytes of unknown data now, but I can't figure out exactly how I did what I did. (I was using a program I threw together in Java to handle the numbers for me and now I can't make it work when I do it by hand!) Basically, you have to consider the binary form of the eight bytes as two rows, alternating digits on the top and bottom. If you line these up with the letters A-W (representing the 23 movable parts of Serge), then a 1 in one row indicates that translational data should be applied to that part, and a 1 in the other indicates that rotational data should be applied to that part. Mine looks like this, with translation being the top row and rotation being the bottom row: (I think I reversed the bit order to make it look like this. I think it should look roughly the same if you don't flip it and put the letters in reverse order instead.)

ABCDEFGHIJKLMNOPQRSTUVW

1000001000100000000000

1111101000100001110111

Clear as mud, right? The fact that it doesn't line up unless I ignore A bugs me as well, but I think I might be getting close-ish. If someone can understand it from that, feel free to give a better explanation. If nobody beats me to it, I'll post one as soon as I can figure out how exactly I got there.

For a demonstration of what I managed to make happen, though, look at

this and

this. The first video is the result of me mucking around with the rotational data in Serge's idle animation and changing the rotations that are applied to the model as a whole and his waist in particular. (I believe these are articulations B and C from the old thread.) It may be worth noting that there were no translation commands for his waist, just the rotations.

The second video is the fun part. I changed one of the bits in the eight bytes of unknown data from a 1 to a 0 like so:

ABCDEFGHIJKLMNOPQRSTUVW

1000001000100000000000

0111101000100001110111

If my hypothesis is correct (or at least on the right track), the bit I changed was the bit that told the game that the entirety of Serge's model can be rotated. Doing this should cause Serge to stop spinning because he's no longer affected by rotational commands. Additionally, the rotational commands that were supposed to be applied to the body should now fall through to the waist articulation, the waist articulation's commands that cause it to face backwards should now fall through to the head, etc. The waist and head definitely seem to be acting as predicted. The interesting part for me is that Serge's arms are now screwed up. This would, I assume, be the result of rotation commands falling through and being interpreted as translation commands.

It's entirely possible that I'm way off track here, but I'm gonna keep fiddling with it and see what I can come up with.

EDIT: Ok, I think I can duplicate what exactly I did, but I'm still having problems with either a spare 0 or one 0 too few (depending on how you look at it), which means I don't think it's right yet. I'm almost certain it has to be something sort of along these lines, though.

For Serge's idle animation, the eight bytes we're concerned with are "5665600015150000." The PlayStation reads the bytes "backwards," right? So it interprets this as "0000151500606556." Convert this to binary and you get "0000000000000000000101010001010100000000011000000110010101010110."

I reverse the bits here so that I don't strain my inferior mind. It's probably not necessary.

"0110101010100110000001100000000010101000101010000000000000000000"

Now, here's the part that doesn't work. We need to line this binary string up with the set of Serge's articulations. (I was using the set

here, which may or may not still be accurate. I'm clearly way off if it's not.) See that leading zero on the binary string? It throws everything off. If you delete the zero, you have to ignore A for the part that follows. If you ADD another zero, you can still use A. Anyways, from here you divide the binary into two rows, with the first digit on the top row, second digit on the bottom, third digit on top, and so on. It should look something like this (Note that I opted to add a zero.):

010000010001000000000000000000000

01111101000100001110111000000000

Now we put Serge's articulations on top of it:

ABCDEFGHIJKLMNOPQRSTUVW

010000010001000000000000000000000

01111101000100001110111000000000

See how that works? Any articulation with a 1 in the top row will be translated at some point in the animation, and any articulation with a 1 in the bottom row will be rotated. Now I'm going to do what I did for the second video and change one bit.

ABCDEFGHIJKLMNOPQRSTUVW

010000010001000000000000000000000

00111101000100001110111000000000

Now to convert back to hex. The first step is to get the modified binary string. Again, one must add or remove a leading zero depending on what you did to make it fit the table. Here's the binary:

0100101010100110000001100000000010101000101010000000000000000000

Now I reverse the bits again to undo the reversal I did at the start:

0000000000000000000101010001010100000000011000000110010101010010

And now I convert back to hex:

0000151500606552

Last order of business is to reverse the order of bytes so it can be read correctly:

5265600015150000

And there ya go. I stuck that into my game and it went from my first video to my second.