---

util.cpp

Go to the documentation of this file.

#include <vector>
#include <fstream>
#include <string>
#include <SDL/SDL.h>

#include "graphics.h"
#include "sprite.h"
#include "util.h"

nnctime Util_GetTime()
{
        nnctime nt;
        Uint32 x = SDL_GetTicks();

        nt.secs = x / 1000;
        nt.msecs = x % 1000;

        return nt;
}

nnctime Util_DiffTime(nnctime *old, nnctime *now)
{
        nnctime diff;
        nnctime ntmp;

        if(now == NULL) {
                ntmp = Util_GetTime();
                now = &ntmp;
        }

        diff.secs = now->secs - old->secs;
        if(diff.secs < 0) diff.secs = -diff.secs;
        diff.msecs = now->msecs - old->msecs;

        if(diff.msecs < 0) {
                diff.secs--;
                diff.msecs += 1000;
        }

        return diff;
}

nnctime operator-(nnctime &a, nnctime &b)
{
        nnctime n;

        n.secs = a.secs - b.secs;
        n.msecs = a.msecs - b.msecs;
        if(n.msecs < 0) {
                n.secs--;
                n.msecs += 1000;
        }
        return n;
}

//changes the old time for you... 
int Util_TimePassed(nnctime *old, Uint32 ms)
{
        nnctime now = Util_GetTime();
        nnctime diff = Util_DiffTime(old, &now);
        Uint32 tell = (diff.secs * 1000) + diff.msecs;

        if(tell >= ms) {
                int count = tell / ms;
                int rem   = tell - (count * ms);
                nnctime t;
                t.secs = rem / 1000;
                t.msecs = rem % 1000;
                *old = now - t;
               return count;
        }

        return 0;
}       

Rect Util_BuildRect(int x, int y, int w, int h)
{
        Rect r;
                r.x = x;
                r.y = y;
                r.w = w;
                r.h = h;
        return r;
}

Velocity Util_BuildVelocity (double dx, double dy, nnctime *old, nnctime *now)
{
        Velocity v;
        nnctime temp = Util_DiffTime(old, now);
        v.dx = dx;
        v.dy = dy;
        v.pertime.msecs = temp.msecs;
        v.pertime.secs = temp.secs;
        return v;
}

int Util_Random(int max)
{       
        static bool init = false;
        
        if(!init) {
                nnctime nt = Util_GetTime();
                srand(nt.secs);
                init = true;
        }

        return (rand() % max);
}


bool Util_Intersect(Rect &R1, Rect &R2) {
//checking all four corners
        //box 1
        //upper left
        if ( (R2.x >= R1.x) && (R2.x <= (R1.x + R1.w)) 
                && (R2.y >= R1.y) && (R2.y <= (R1.y + R1.h)) ) return true;
        //upper right
        if ( ((R2.x + R2.w) >= R1.x) && ((R2.x + R2.w) <= (R1.x + R1.w)) 
                && (R2.y >= R1.y) && (R2.y <= (R1.y + R1.h)) ) return true;
        //lower left
        if ( (R2.x >= R1.x) && (R2.x <= (R1.x + R1.w)) 
                && ((R2.y + R2.h) >= R1.y) && ((R2.y + R2.h) <= (R1.y + R1.h)) ) return true;
        //lower right
        if ( ((R2.x + R2.w) >= R1.x) && ((R2.x + R2.w) <= (R1.x + R1.w)) 
                && ((R2.y + R2.h) >= R1.y) && ((R2.y + R2.h) <= (R1.y + R1.h)) ) return true;

        //box 2
        //upper left
        if ( (R1.x >= R2.x) && (R1.x <= (R2.x + R2.w)) 
                && (R1.y >= R2.y) && (R1.y <= (R2.y + R2.h)) ) return true;
        //upper right
        if ( ((R1.x + R1.w) >= R2.x) && ((R1.x + R1.w) <= (R2.x + R2.w)) 
                && (R1.y >= R2.y) && (R1.y <= (R2.y + R2.h)) ) return true;
        //lower left
        if ( (R1.x >= R2.x) && (R1.x <= (R2.x + R2.w)) 
                && ((R1.y + R1.h) >= R2.y) && ((R1.y + R1.h) <= (R2.y + R2.h)) ) return true;
        //lower right
        if ( ((R1.x + R1.w) >= R2.x) && ((R1.x + R1.w) <= (R2.x + R2.w)) 
                && ((R1.y + R1.h) >= R2.y) && ((R1.y + R1.h) <= (R2.y + R2.h)) ) return true;

        //otherwise
        return false;
}


vector<Surface *> Util_parseImage(string filename) 
{
  string textfile = filename + ".txt";
  vector<Surface *> images;

  ifstream input(textfile.c_str());

  string spriteName;
  string spritePath;

  while (true) {
    input >> spriteName;
    input >> spritePath;
    if (input.eof()) break;
    Surface *temp = Sprite::cache.Find(spritePath);
        //Graphics::loadImage(spritePath);
        //Surface *temp2= Graphics::displayFormat(temp, true);
        //Graphics::freeImage(temp);
    images.push_back(temp);
  }
  
  return images;
}

int Util_FindBestSurfaceSize(int w, int h)
{
        if (w <= 128 && h <= 128)
                return 128;
        if (w <= 256 && h <= 256)
                return 256;
        if (w <= 512 && h <= 512)
                return 512;
        if (w <= 1024 && h <= 1024)
                return 1024;
        if (w <= 2048 && h <= 2048)
                return 2048;
        return 0;
}

---