gemrb/core/Core.cpp

   1 /* GemRB - Infinity Engine Emulator
   2  * Copyright (C) 2003 The GemRB Project
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License
   6  * as published by the Free Software Foundation; either version 2
   7  * of the License, or (at your option) any later version.
   8
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  17  *
  18  *
  19  */
  20
  21 /**
  22  * @file Core.cpp
  23  * Some compatibility and utility functions
  24  * @author The GemRB Project
  25  */
  26
  27 #include "globals.h"
  28 #include "exports.h"
  29
  30 #include "Interface.h"
  31 #include "Scriptable/Actor.h"
  32
  33 #include <cmath>
  34 #include <ctype.h>
  35 #ifdef WIN32
  36 #include "win32def.h"
  37 #ifdef _DEBUG
  38 #include <stdlib.h>
  39 #include <crtdbg.h>
  40 #endif
  41
  42 BOOL WINAPI DllEntryPoint(HINSTANCE /*hinstDLL*/, DWORD /*fdwReason*/,
  43         LPVOID /*lpvReserved*/)
  44 {
  45         return true;
  46 }
  47 #endif
  48
  49 //// Globally used functions
  50
  51 ieByte pl_uppercase[256];
  52 ieByte pl_lowercase[256];
  53
  54 // these 3 functions will copy a string to a zero terminated string with a maximum length
  55 void strnlwrcpy(char *dest, const char *source, int count)
  56 {
  57         while(count--) {
  58                 *dest++ = pl_lowercase[(ieByte) *source];
  59                 if(!*source++) {
  60                         while(count--) *dest++=0;
  61                         break;
  62                 }
  63         }
  64         *dest=0;
  65 }
  66
  67 void strnuprcpy(char* dest, const char *source, int count)
  68 {
  69         while(count--) {
  70                 *dest++ = pl_uppercase[(ieByte) *source];
  71                 if(!*source++) {
  72                         while(count--) *dest++=0;
  73                         break;
  74                 }
  75         }
  76         *dest=0;
  77 }
  78
  79 // this one also filters spaces
  80 void strnspccpy(char* dest, const char *source, int count)
  81 {
  82         memset(dest,0,count);
  83         while(count--) {
  84                 char c = pl_lowercase[(ieByte) *source];
  85                 if (c!=' ') {
  86                         *dest++=c;
  87                 }
  88                 if(!*source++) {
  89                         return;
  90                 }
  91         }
  92 }
  93
  94 #ifndef HAVE_STRNLEN
  95 int strnlen(const char* string, int maxlen)
  96 {
  97         if (!string) {
  98                 return -1;
  99         }
 100         int i = 0;
 101         while (maxlen-- > 0) {
 102                 if (!string[i])
 103                         break;
 104                 i++;
 105         }
 106         return i;
 107 }
 108 #endif // ! HAVE_STRNLEN
 109
 110 static const unsigned char orientations[25]={
 111 6,7,8,9,10,
 112 5,6,8,10,11,
 113 4,4,0,12,12,
 114 3,2,0,14,13,
 115 2,1,0,15,14
 116 };
 117
 118 /** Calculates the orientation of a character (or projectile) facing a point */
 119 unsigned char GetOrient(const Point &s, const Point &d)
 120 {
 121         int deltaX = s.x - d.x;
 122         int deltaY = s.y - d.y;
 123         int div = Distance(s,d);
 124         if(!div) return 0; //default
 125         if(div>3) div/=2;
 126         int aX=deltaX/div;
 127         int aY=deltaY/div;
 128         return orientations[(aY+2)*5+aX+2];
 129 }
 130
 131 /** Calculates distance between 2 points */
 132 unsigned int Distance(Point p, Point q)
 133 {
 134         long x = ( p.x - q.x );
 135         long y = ( p.y - q.y );
 136         return (unsigned int) sqrt( ( double ) ( x* x + y* y ) );
 137 }
 138
 139 /** Calculates distance squared from a point to a scriptable */
 140 unsigned int SquaredMapDistance(Point p, Scriptable *b)
 141 {
 142         long x = ( p.x/16 - b->Pos.x/16 );
 143         long y = ( p.y/12 - b->Pos.y/12 );
 144         return (unsigned int)(x*x + y*y);
 145 }
 146
 147 /** Calculates distance between 2 points */
 148 unsigned int Distance(Point p, Scriptable *b)
 149 {
 150         long x = ( p.x - b->Pos.x );
 151         long y = ( p.y - b->Pos.y );
 152         return (unsigned int) sqrt( ( double ) ( x* x + y* y ) );
 153 }
 154
 155 unsigned int PersonalDistance(Point p, Scriptable *b)
 156 {
 157         long x = ( p.x - b->Pos.x );
 158         long y = ( p.y - b->Pos.y );
 159         int ret = (int) sqrt( ( double ) ( x* x + y* y ) );
 160         if (b->Type==ST_ACTOR) {
 161                 ret-=((Actor *)b)->size*10;
 162         }
 163         if (ret<0) return (unsigned int) 0;
 164         return (unsigned int) ret;
 165 }
 166
 167 unsigned int SquaredPersonalDistance(Point p, Scriptable *b)
 168 {
 169         long x = ( p.x - b->Pos.x );
 170         long y = ( p.y - b->Pos.y );
 171         int ret =  x*x + y*y;
 172         if (b->Type==ST_ACTOR) {
 173                 ret-=((Actor *)b)->size*100;
 174         }
 175         if (ret<0) return (unsigned int) 0;
 176         return (unsigned int) ret;
 177 }
 178
 179 /** Calculates map distance between 2 scriptables */
 180 unsigned int SquaredMapDistance(Scriptable *a, Scriptable *b)
 181 {
 182         long x = (a->Pos.x/16 - b->Pos.x/16 );
 183         long y = (a->Pos.y/12 - b->Pos.y/12 );
 184         return (unsigned int)(x*x + y*y);
 185 }
 186
 187 /** Calculates distance between 2 scriptables */
 188 unsigned int Distance(Scriptable *a, Scriptable *b)
 189 {
 190         long x = ( a->Pos.x - b->Pos.x );
 191         long y = ( a->Pos.y - b->Pos.y );
 192         return (unsigned int) sqrt( ( double ) ( x* x + y* y ) );
 193 }
 194
 195 /** Calculates distance squared between 2 scriptables */
 196 unsigned int SquaredDistance(Scriptable *a, Scriptable *b)
 197 {
 198         long x = ( a->Pos.x - b->Pos.x );
 199         long y = ( a->Pos.y - b->Pos.y );
 200         return (unsigned int) ( x* x + y* y );
 201 }
 202
 203 /** Calculates distance between 2 scriptables, including feet circle if applicable */
 204 unsigned int PersonalDistance(Scriptable *a, Scriptable *b)
 205 {
 206         long x = ( a->Pos.x - b->Pos.x );
 207         long y = ( a->Pos.y - b->Pos.y );
 208         int ret = (int) sqrt( ( double ) ( x* x + y* y ) );
 209         if (a->Type==ST_ACTOR) {
 210                 ret-=((Actor *)a)->size*10;
 211         }
 212         if (b->Type==ST_ACTOR) {
 213                 ret-=((Actor *)b)->size*10;
 214         }
 215         if (ret<0) return (unsigned int) 0;
 216         return (unsigned int) ret;
 217 }
 218
 219 unsigned int SquaredPersonalDistance(Scriptable *a, Scriptable *b)
 220 {
 221         long x = ( a->Pos.x - b->Pos.x );
 222         long y = ( a->Pos.y - b->Pos.y );
 223         int ret =  x*x + y*y;
 224         if (a->Type==ST_ACTOR) {
 225                 ret-=((Actor *)a)->size*100;
 226         }
 227         if (b->Type==ST_ACTOR) {
 228                 ret-=((Actor *)b)->size*100;
 229         }
 230         if (ret<0) return (unsigned int) 0;
 231         return (unsigned int) ret;
 232 }
 233
 234 // returns EA relation between two scriptables (non actors are always enemies)
 235 // it is used for protectile targeting/iwd ids targeting too!
 236 int EARelation(Scriptable* Owner, Actor* target)
 237 {
 238         ieDword eao = EA_ENEMY;
 239
 240         if (Owner && Owner->Type==ST_ACTOR) {
 241                 eao = ((Actor *) Owner)->GetStat(IE_EA);
 242         }
 243
 244         ieDword eat = target->GetStat(IE_EA);
 245
 246         if (eao<=EA_GOODCUTOFF) {
 247
 248                 if (eat<=EA_GOODCUTOFF) {
 249                         return EAR_FRIEND;
 250                 }
 251                 if (eat>=EA_EVILCUTOFF) {
 252                         return EAR_HOSTILE;
 253                 }
 254
 255                 return EAR_NEUTRAL;
 256         }
 257
 258         if (eao>=EA_EVILCUTOFF) {
 259
 260                 if (eat<=EA_GOODCUTOFF) {
 261                         return EAR_HOSTILE;
 262                 }
 263                 if (eat>=EA_EVILCUTOFF) {
 264                         return EAR_FRIEND;
 265                 }
 266
 267                 return EAR_NEUTRAL;
 268         }
 269
 270         return EAR_NEUTRAL;
 271 }
 272
 273 /** Returns the length of string (up to a delimiter) */
 274 GEM_EXPORT int strlench(const char* string, char ch)
 275 {
 276         int i;
 277         for (i = 0; string[i] && string[i] != ch; i++)
 278                 ;
 279         return i;
 280 }
 281
 282 //// Compatibility functions
 283 #ifndef HAVE_STRNDUP
 284 GEM_EXPORT char* strndup(const char* s, size_t l)
 285 {
 286         size_t len = strlen( s );
 287         if (len < l) {
 288                 l = len;
 289         }
 290         char* string = ( char* ) malloc( l + 1 );
 291         strncpy( string, s, l );
 292         string[l] = 0;
 293         return string;
 294 }
 295 #endif
 296
 297 #ifdef WIN32
 298
 299 #else
 300
 301 char* strupr(char* string)
 302 {
 303         char* s;
 304         if (string) {
 305                 for (s = string; *s; ++s)
 306                         *s = toupper( *s );
 307         }
 308         return string;
 309 }
 310
 311 char* strlwr(char* string)
 312 {
 313         char* s;
 314         if (string) {
 315                 for (s = string; *s; ++s)
 316                         *s = tolower( *s );
 317         }
 318         return string;
 319 }
 320
 321
 322 #endif // ! WIN32
 323