mirror of
https://github.com/EQEmu/Server.git
synced 2026-01-08 19:43:53 +00:00
331 lines
6.5 KiB
C++
331 lines
6.5 KiB
C++
#include "misc_functions.h"
|
|
#include <string.h>
|
|
#include <time.h>
|
|
#include <math.h>
|
|
#ifndef WIN32
|
|
#include <netinet/in.h>
|
|
#include <sys/socket.h>
|
|
#endif
|
|
#include <iostream>
|
|
#include <iomanip>
|
|
#ifdef WIN32
|
|
#include <io.h>
|
|
#endif
|
|
|
|
using namespace std;
|
|
|
|
#ifdef WIN32
|
|
#include <windows.h>
|
|
|
|
#define snprintf _snprintf
|
|
#if (_MSC_VER < 1500)
|
|
#define vsnprintf _vsnprintf
|
|
#endif
|
|
#define strncasecmp _strnicmp
|
|
#define strcasecmp _stricmp
|
|
#else
|
|
#include <stdlib.h>
|
|
#include <ctype.h>
|
|
#include <stdarg.h>
|
|
#include <sys/types.h>
|
|
#include <sys/time.h>
|
|
#ifdef FREEBSD //Timothy Whitman - January 7, 2003
|
|
#include <sys/socket.h>
|
|
#include <netinet/in.h>
|
|
#endif
|
|
#include <sys/stat.h>
|
|
#include <unistd.h>
|
|
#include <netdb.h>
|
|
#include <errno.h>
|
|
#endif
|
|
|
|
char* strn0cpy(char* dest, const char* source, int32 size) {
|
|
if (!dest)
|
|
return 0;
|
|
if (size == 0 || source == 0) {
|
|
dest[0] = 0;
|
|
return dest;
|
|
}
|
|
strncpy(dest, source, size);
|
|
dest[size - 1] = 0;
|
|
return dest;
|
|
}
|
|
|
|
// String N w/null Copy Truncated?
|
|
// return value =true if entire string(source) fit, false if it was truncated
|
|
bool strn0cpyt(char* dest, const char* source, int32 size) {
|
|
if (!dest)
|
|
return 0;
|
|
if (size == 0 || source == 0) {
|
|
dest[0] = 0;
|
|
return dest;
|
|
}
|
|
strncpy(dest, source, size);
|
|
dest[size - 1] = 0;
|
|
return (bool) (source[strlen(dest)] == 0);
|
|
}
|
|
|
|
const char *MakeUpperString(const char *source) {
|
|
static char str[128];
|
|
if (!source)
|
|
return NULL;
|
|
MakeUpperString(source, str);
|
|
return str;
|
|
}
|
|
|
|
void MakeUpperString(const char *source, char *target) {
|
|
if (!source || !target) {
|
|
*target=0;
|
|
return;
|
|
}
|
|
while (*source)
|
|
{
|
|
*target = toupper(*source);
|
|
target++;source++;
|
|
}
|
|
*target = 0;
|
|
}
|
|
|
|
const char *MakeLowerString(const char *source) {
|
|
static char str[128];
|
|
if (!source)
|
|
return NULL;
|
|
MakeLowerString(source, str);
|
|
return str;
|
|
}
|
|
|
|
void MakeLowerString(const char *source, char *target) {
|
|
if (!source || !target) {
|
|
*target=0;
|
|
return;
|
|
}
|
|
while (*source)
|
|
{
|
|
*target = tolower(*source);
|
|
target++;source++;
|
|
}
|
|
*target = 0;
|
|
}
|
|
|
|
int MakeAnyLenString(char** ret, const char* format, ...) {
|
|
int buf_len = 128;
|
|
int chars = -1;
|
|
va_list argptr;
|
|
va_start(argptr, format);
|
|
while (chars == -1 || chars >= buf_len) {
|
|
safe_delete_array(*ret);
|
|
if (chars == -1)
|
|
buf_len *= 2;
|
|
else
|
|
buf_len = chars + 1;
|
|
*ret = new char[buf_len];
|
|
chars = vsnprintf(*ret, buf_len, format, argptr);
|
|
}
|
|
va_end(argptr);
|
|
return chars;
|
|
}
|
|
|
|
int32 AppendAnyLenString(char** ret, int32* bufsize, int32* strlen, const char* format, ...) {
|
|
if (*bufsize == 0)
|
|
*bufsize = 256;
|
|
if (*ret == 0)
|
|
*strlen = 0;
|
|
int chars = -1;
|
|
char* oldret = 0;
|
|
va_list argptr;
|
|
va_start(argptr, format);
|
|
while (chars == -1 || chars >= (sint32)(*bufsize-*strlen)) {
|
|
if (chars == -1)
|
|
*bufsize += 256;
|
|
else
|
|
*bufsize += chars + 25;
|
|
oldret = *ret;
|
|
*ret = new char[*bufsize];
|
|
if (oldret) {
|
|
if (*strlen)
|
|
memcpy(*ret, oldret, *strlen);
|
|
safe_delete_array(oldret);
|
|
}
|
|
chars = vsnprintf(&(*ret)[*strlen], (*bufsize-*strlen), format, argptr);
|
|
}
|
|
va_end(argptr);
|
|
*strlen += chars;
|
|
return *strlen;
|
|
}
|
|
|
|
int32 hextoi(char* num) {
|
|
int len = strlen(num);
|
|
if (len < 3)
|
|
return 0;
|
|
|
|
if (num[0] != '0' || (num[1] != 'x' && num[1] != 'X'))
|
|
return 0;
|
|
|
|
int32 ret = 0;
|
|
int mul = 1;
|
|
for (int i=len-1; i>=2; i--) {
|
|
if (num[i] >= 'A' && num[i] <= 'F')
|
|
ret += ((num[i] - 'A') + 10) * mul;
|
|
else if (num[i] >= 'a' && num[i] <= 'f')
|
|
ret += ((num[i] - 'a') + 10) * mul;
|
|
else if (num[i] >= '0' && num[i] <= '9')
|
|
ret += (num[i] - '0') * mul;
|
|
else
|
|
return 0;
|
|
mul *= 16;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
int64 hextoi64(char* num) {
|
|
int len = strlen(num);
|
|
if (len < 3)
|
|
return 0;
|
|
|
|
if (num[0] != '0' || (num[1] != 'x' && num[1] != 'X'))
|
|
return 0;
|
|
|
|
int64 ret = 0;
|
|
int mul = 1;
|
|
for (int i=len-1; i>=2; i--) {
|
|
if (num[i] >= 'A' && num[i] <= 'F')
|
|
ret += ((num[i] - 'A') + 10) * mul;
|
|
else if (num[i] >= 'a' && num[i] <= 'f')
|
|
ret += ((num[i] - 'a') + 10) * mul;
|
|
else if (num[i] >= '0' && num[i] <= '9')
|
|
ret += (num[i] - '0') * mul;
|
|
else
|
|
return 0;
|
|
mul *= 16;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
bool atobool(char* iBool) {
|
|
if (!strcasecmp(iBool, "true"))
|
|
return true;
|
|
if (!strcasecmp(iBool, "false"))
|
|
return false;
|
|
if (!strcasecmp(iBool, "yes"))
|
|
return true;
|
|
if (!strcasecmp(iBool, "no"))
|
|
return false;
|
|
if (!strcasecmp(iBool, "on"))
|
|
return true;
|
|
if (!strcasecmp(iBool, "off"))
|
|
return false;
|
|
if (!strcasecmp(iBool, "enable"))
|
|
return true;
|
|
if (!strcasecmp(iBool, "disable"))
|
|
return false;
|
|
if (!strcasecmp(iBool, "enabled"))
|
|
return true;
|
|
if (!strcasecmp(iBool, "disabled"))
|
|
return false;
|
|
if (!strcasecmp(iBool, "y"))
|
|
return true;
|
|
if (!strcasecmp(iBool, "n"))
|
|
return false;
|
|
if (atoi(iBool))
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
* solar: generate a random integer in the range low-high
|
|
* this should be used instead of the rand()%limit method
|
|
*/
|
|
int MakeRandomInt(int low, int high)
|
|
{
|
|
if(low >= high)
|
|
return(low);
|
|
|
|
return (rand()%(high-low+1) + (low));
|
|
}
|
|
|
|
double MakeRandomFloat(double low, double high)
|
|
{
|
|
if(low >= high)
|
|
return(low);
|
|
|
|
return (rand() / (double)RAND_MAX * (high - low) + low);
|
|
}
|
|
|
|
// solar: removes the crap and turns the underscores into spaces.
|
|
char *CleanMobName(const char *in, char *out)
|
|
{
|
|
unsigned i, j;
|
|
|
|
for(i = j = 0; i < strlen(in); i++)
|
|
{
|
|
// convert _ to space.. any other conversions like this? I *think* this
|
|
// is the only non alpha char that's not stripped but converted.
|
|
if(in[i] == '_')
|
|
{
|
|
out[j++] = ' ';
|
|
}
|
|
else
|
|
{
|
|
if(isalpha(in[i]) || (in[i] == '`')) // numbers, #, or any other crap just gets skipped
|
|
out[j++] = in[i];
|
|
}
|
|
}
|
|
out[j] = 0; // terimnate the string before returning it
|
|
return out;
|
|
}
|
|
|
|
const char *ConvertArray(int input, char *returnchar)
|
|
{
|
|
sprintf(returnchar, "%i" ,input);
|
|
return returnchar;
|
|
}
|
|
|
|
const char *ConvertArrayF(float input, char *returnchar)
|
|
{
|
|
sprintf(returnchar, "%0.2f", input);
|
|
return returnchar;
|
|
}
|
|
|
|
float EQ13toFloat(int d)
|
|
{
|
|
return ( float(d)/float(1<<2));
|
|
}
|
|
|
|
float NewEQ13toFloat(int d)
|
|
{
|
|
return ( float(d)/float(1<<6));
|
|
}
|
|
|
|
float EQ19toFloat(int d)
|
|
{
|
|
return ( float(d)/float(1<<3));
|
|
}
|
|
|
|
int FloatToEQ13(float d)
|
|
{
|
|
return int(d*float(1<<2));
|
|
}
|
|
|
|
int NewFloatToEQ13(float d)
|
|
{
|
|
return int(d*float(1<<6));
|
|
}
|
|
|
|
int FloatToEQ19(float d)
|
|
{
|
|
return int(d*float(1<<3));
|
|
}
|
|
|
|
/*
|
|
Heading of 0 points in the pure positive Y direction
|
|
|
|
*/
|
|
int FloatToEQH(float d)
|
|
{
|
|
return(int((360.0f - d) * float(1<<11)) / 360);
|
|
}
|
|
|
|
float EQHtoFloat(int d)
|
|
{
|
|
return(360.0f - float((d * 360) >> 11));
|
|
} |