This week, Ghasatta showed up for his farewell address as he heads down under to the Shire.
Davion and Asylumius also showed up to eat, drink, and something or other…
And Retnur made a welcome return too!
I believe Bleas tried to show up, but some technical difficulties kept him stuck in traffic.

We did talk shop briefly, so you can still write it off as a business lunch!

Here is the log output from 20090118.log!

Damn I'm bad at making these meetings.

I'm usually slavering over some task for RaM, but I've been preoccupied since I got a new Core2 Duo laptop and installed 64-bit Linux.

I've been pulling my hair out trying to get some of my personal projects to function correctly… it took a long time (and lots of hair) for me to figure out that my foolish assumptions about the "long" datatype being 32-bits wide have finally come back to gnaw on my @55.

Anyway, I *just* finished updating my current beast of a project, and I figured I'd check in. I'll probably grab some bit of RaM code and convert some (const char*)s to (std::string)s. Also I had this quandary I was hoping to get some feedback on, so I can call the language implementation finished:

Listener comprehension skills are important, while speaker comprehension skills aren't. This means that the speaker is considered to speak a language perfectly, even if they have a meager comprehension skill. I'm considering a filter for speech output that will garble words when the speaker isn't proficient in the language they are speaking. Maybe move words around in the sentence, maybe move letters around in words, maybe add letters to words… this would make those who comprehend the language *likely* able to understand what the speaker is saying, while still sounding awkward. Wondering if anyone has any implementation ideas. The ideal implementation would result in speech like when you translate something from english to another language then back to english using google language. Obviously we can't have a database of thousands of words for this purpose, so without google language's help, any ideas on how to identify / move / corrupt certain parts of speech to make someone sound like they are just learning a language?

Yes, that's another annoyance of C/C++… there's not really a single standard way to perfectly specify that you WANT a 32-bit integer. There are defines you can use, but I don't think they're guarenteed to be there on all platforms.

That's the main reason I moved all integers in RaM to be "int" instead of short int, or long int. Not that "int" will always be 32-bit, but if all integers are the same, all the various I/O functions dealing with them should also be the same.

All bets are off with nasty bit-related code, of course. :)

I think tracking language skills on both ends is probably overkill here, although in a chat room it would be a LOT of fun! The basic idea of languages in a MUD is to encourage role-play, be a money/skill-point sink, and allow for some minor strategic decisions if a common language isn't available.

For example, you can make the uber sword of d3th 8unn13s to be a crafted elven sword, only available by learning mastercraft swords + gathering rare mats + enchanting it – and some of those prereqs might only be available from elves, and they might only deal with people who speak their language.

It doesn't so much matter how the text really looks, although for decent immersion, you'd like each langauge to be distinct and recognizable from each other, as long as it's difficult or impossible to decypher without the appropriate language skill.

It's also worth considering how much of a CPU impact layering too many filters might have on folks who pay for their CPU time. My MUD runs at home on a 900MHz CPU, all by itself… so I can do quite a lot of text processing before it ever becomes noticeable, but if you're paying for a virtual machine that gives you the equivalent of a 300MHz CPU, and charges you if you spike it for too long – they might prefer to spend their cash on better mob AI. :)

I would use int32_t and friends – I'm not sure if they are strictly speaking part of the standard, but they are available on very, very many platforms. For those cases where they aren't available, you can typedef the appropriate platform type to int32_t and not have to change a single piece of your remaining code.

But, you're also right that if you use ints to represent only ints, it doesn't really matter. Issues crop up when people do funky things like storing pointers in ints, or making assumptions about the exact size of the int.

My general rule: if I actually care, I specify the type exactly using e.g. uint16_t. If I don't care, I use the generic "int" type.

Yeah, most of my faux pas involved using what I (erroneously) assumed to be a 32-bit unsigned integer to store RGBA color values. Four bytes fit so nicely in a 32-bit bit integer, I used this all over the place, and was merrily swizzling bytes about like a fool. I defined flexible vertex formats (maybe I stole this term and perhaps a chunk of Direct3D8.h from Microsoft) and had CVertDiff defined as a vertex that contained a 3-space vector and a diffuse color value. I finally checked the size of CVertDiff and found out it was larger than I assumed. You can imagine how OpenGL felt about my glDrawArray(…) calls.

Even worse things happened when I was writing to SDL surfaces 0x00000000 values cast into (64-bit) longs assuming one per pixel when the surface had a 32-bit color depth. O_O

Sounds like int32_t and friends would make good friends. =)

As far as the languages… I figure that even the current implementation is overkill, but if we are going for accurate languages, the speaker's comprehension should be taken into account. Due to the centralized speech channel, the language implementation can be entirely removed very easily. The drunken speech is in the same boat and independent of languages, so admins can fully adjust the speech filters with about 2 seconds of code modification. The current implementation is definitely processor heavy as previously discussed, but only compared to the rest of ROM, which as Quix pointed out, wouldn't even tax the CPU in your cell phone.

For RGBA values, you might find your best bang for the buck is to use an array of four unsigned char's. That way, you not only get your 32-bits (assuming your compiler follows the rules and doesn't try to "unicode" you), but you get them in the order you want them (in case you ever leave the land of intel), and you get to fiddle with green via foo[1], or the whole thing via (uint32_t)foo.

Of course, you could get snazzy and make a union too.

:stare:killkillKILLKILLKILLLSTSBBITYSTABBITYAAAAAAAARGHHASSFDAHRJEO"FHDJKLGH#RIOYASHFD NAEHKLHFSAHKAFJKAAAAAAAAAAAARGHKILLKILLKILLKILLKILL…………………….<NO CARRIER>

Don't make me come out there and smack you with a union of bit fields… (NOT the C++ bit vectors, the good old C bit field, that everyone fears for some reason).



:devil:

I SAW MY NAME

Oh drat… hide the booze!

Welp, I've been AWOL for a while again. I hope to make the weekly meeting tomorrow (today), and see whats cooking on RaM's burners. For some reason tonight the answer to the speaking proficiencies implemenation jumped out of nowhere and slapped me in the face.

Since the translation system is word-based, I can take spoken common words, and then translate them into the target language with some fuzzy logic. The fuzz depth would be based on the speaker's proficiency. Imagine a dwarf grouped with two elves… he is somewhat proficient in elven comprehension, but has some way to go before he is fluent. The dwarf takes a dagger he found, but doesn't care for and gives it to one of the elves, as he sees they are using a less powerful dagger in combat. He then speaks in elven:

You say in elven 'Wield the dagger.'

The speech system would look at his proficiency, and for each spoken word check to see if it was spoken correctly. If it was not, the system would replace the word with a random word from the language's dictionary. Lets assume the proficiency check for the word "dagger" fails, and that word is in the dictionary for that language. It is then replaced with a different word, so in reality the dwarf said something like:

Grendas says in elven 'Wield the donkey.'

The elves would then look at one another and stifle a laugh.

Similarly, if a spoken word proficiency check fails, and the word isn't found in the dictionary, the letters it contains can be replaced with a random letter from the letter translation table. This will make words perhaps be legible, but incorrectly pronounced.

I feel like once this change is in place, the language system will provide a very realistic language barrier that can easily be modified or extended… I'm somewhat of a perfectionist, but after a few tweaks I could even call the translation implementation complete.

As far as the RGBA color / union thing… this ought to provide some amusement:

// 4D Vector used for rects and quaternions as well.
template <typename tVect>
class CVector4
{
public:
	union { tVect x; tVect r; tVect left; tVect Left;	};
	union { tVect y; tVect g; tVect top; tVect Top; 	};
	union { tVect z; tVect b; tVect right; tVect Right; 	};
	union { tVect w; tVect a; tVect bottom; tVect Bottom; 	};
	// Default, individual values, and copy constructors
	inline CVector4() : x(0), y(0), z(0), w(0) {};
	inline CVector4(const tVect X, const tVect Y, const tVect Z, const tVect W) : x(X), y(Y), z(Z), w(W) {};
	inline CVector4(const CVector4<tVect> &vIn) : x(vIn.x), y(vIn.y), z(vIn.z), w(vIn.w) {};
<snip/>

I have a templated vector library I made that I use for blasted everything. Its pretty handy… probably scary to some. Lets me do easy stuff like this though:

// integral types for raster stuff & colors
	typedef CVector4<unsigned long> Rect;
	typedef CVector2<unsigned long> Point;
	typedef CVector3<unsigned char> Color3;
	typedef CVector4<unsigned char> Color4;

	// floats
	typedef CVector4<float> Rectf;
	typedef CVector2<float> Pointf;

Oh, and you want to convert that Color4 to a 32-bit color value?

// Return 32bit color integer
inline const unsigned int RGBAColor(const CVector4<unsigned char> &C)
{ return (unsigned int)((((C.a)&0xff)<<24)|(((C.b)&0xff)<<16)|(((C.g)&0xff)<<8)|((C.r)&0xff));	}

*ducks*

Now, if you want to make that fuzz a bit smarter, go ahead and pre-compute soundex values for all the words in your table and choose one that has the closest soundex match but isn't the same word. :)

"Hold the orc while I loot the chest" => "Hold the cork while I shoot the dress"

*grin*