Subsections

• base95 Numeric System
• Conversion Between Bases
• Simple Conversion Functions
• Advanced Conversion Functions
• Digit Table

base95 Numeric System

You might have already noticed that Furcadia doesn't use a decimal numeric system to specify coordinates and just about anything else in the protocol. In order to reduce bandwidth usage in favor of those who don't own a fast connection to the server (as well as allowing more users to use the server without causing lag), the system uses base95 numbers instead of base10.

Why? The decimal numeric system only allows 10 digits in total (0 - 9), while in base95 system you can get up as high as 95 digits (0 - 94 [sp - ~]). In other words, in case of decimal numeric system you can fit only 10 numbers in a byte, while base95 allows you to have 95 numbers in one.

Now think what ranges you can get to when you're using two digits. In this case we are talking about 100 numbers (00 - 99) versus 9025 numbers (0 - 9024 [spsp - ~~]) that can go in two bytes. base95 seems more efficient, no? ;)

To explain a bit what are base95 numbers - they are numbers that have 95 digits and each digit is represented as a character from the second "block" of the ASCII table (the characters we can freely type with a keyboard) - starting from the space character (32) and ending with the ~ character (126). If you look carefully at one digit of the base95 number and an ASCII table, you will notice each number is actually a character in the table +32.

Conversion Between Bases

Obviously, base95 is not the kind of system we're used to count in (along with our computers), so to perform mathematical calculations or just about anything else, we'd need to convert them weird digits into the decimal system. Here is a simple way to convert a two-digit base95 number into a decimal one:

Note that we're normally dealing with unsigned numbers - there should be no negative values in Furcadia's data! Here is a simple equasion to convert a number between 0 and 9024 into a base95 string:

Basicly, that's all to it when it comes to converting between base95 and decimal numbers and since you will most likely not deal with numbers higher than two digits in Furcadia, you wouldn't need fancier conversion algoritm. If you wish to be able to convert at a higher range, have a look below for a pair of functions that do just that.

Simple Conversion Functions

The functions below are C/C++ compatible and allow base95 conversion between 2-byte strings and numbers from 0 to 9024 - it's pretty much their limit:

/*** String -> Integer ***/
short StoI (const char * byte)
{
    if (((unsigned char) byte[0] < 32) || (unsigned char) byte[0] > 126)) return -1;
    if (((unsigned char) byte[1] < 32) || (unsigned char) byte[1] > 126)) return -1;
    return (((unsigned char) byte[0] - 32) * 95) + ((unsigned char) byte[1] - 32));
}

/*** Integer -> String ***/
void ItoS (char * byte, short n)
{
    if (n < 0)    n = 0;
    if (n > 9024) n = 9024;
    
    byte[0] = (unsigned char)((n / 95) + 32);
    byte[1] = (unsigned char)((n % 95) + 32);
    byte[2] = '\0';
}

Advanced Conversion Functions

The functions here perform the same conversion routines, but their limits are a lot more flexible: they are not limited to 9025 numbers, but can go as far as a long (32bit) number can! They take more resources, so think carefully if you really need to use these...

/*** String -> Integer ***/
long StoI (char * str, unsigned char len)
{
    long n = 0; // Output number
    int  m = 1;
    
    while (len > 0)
    {
	n += (str[--len] - 32) * m;
	m *= 95;
    }
    
    return n;
}

/*** Integer -> String ***/
char * ItoS (char * str, long n)
{
    int len = 0;
    
    ItoS_ (str, n, &len);
    str[len] = '\0';
    
    return str;
}

/*** ItoS Helper Function ***/
void ItoS_ (char * str, long n, int * len)
{
    if (n > 0)
	ItoS_ (str, n / 95, len);
    else
	return;

    str[*len] = (n % 95) + 32; // Reverse order
    *len += 1;
}

base95 Digit Table

If you can't be bothered doing it on your own, here is a table of digits for the base95 numeric system, it's decimal value nearby.