Elysian Shadows

Code: Select all

#define MAP_WIDTH 400
#define MAP_HEIGHT 300
const size_t VISIBLE_WIDTH = 1024.0/32.0; //Assuming 1024x760 resolution and tile is 32x32
const size_t VISIBLE_HEIGHT = 768.0/32.0;
Tile* tiles[MAP_WIDTH][MAP_HEIGHT]; //Load all images once, then point to them
Object* objects[MAP_WIDTH][MAP_HEIGHT]; //Same, except you don't draw when you encouter a NULL.

Code: Select all

#include <vector>
using namespace std;

vector <Object*> objects;
...
sort objects by x-coordinate (or y-coordinate, whichever is 'more important') on load
...
Jump in at x-coordinate

Code: Select all

//Variables
vector<CSpriteImg*> BGTest; // Vector to hold all of the background tiles
int cMapX, cMapY; //Current map's x and y dimensions

//So rather than:
for(int i = 0; i < cMapX * cMapY; i++){
	BGTest.push_back(NULL);
}

//I have:
for(int i = 0; i < (cMapX / 10) * (cMapY / 10); i++){
	BGTest.push_back(NULL);
}

//And to call a given point at the center of my map i would have:
int point = ((centY / 10) * (cMapX / 10)) + (centX / 10);
Draw(BGTest.at(point));

Code: Select all

BGTest.push_back(NULL);

Code: Select all

vector< vector<myMapObj*> >::iterator i;
vector<myMapObj*>::iterator j;
for (i = myMapVec.begin(); i != myMapVec.end();++i) {
    for (j = i.begin();j != i.end();++j) {
        j->getAttribute(); //equivalent to myMapVec[index]->getAttribute();
        passThePointer(&(*j)); //j == ...::iterator, *j == myMapObj due to dereference overload, so &(*j) == &myMapObj == myMapObj*, I think
        //I might have this confused and passThePonter(*j) might be the one that works... actually it probably is, so yeah.
    }
}

Code: Select all

myYArray* myMapArray[]

Code: Select all

myYArray** myMapArray = new myArrayOfPointersToYArrays[NUMBER_OF_Y_ENTRIES]
myMapArray[0] = new myYArray(first column)
myMapArray[1] = new myYArray(second column)

Code: Select all

const float ROOT_2_OVER_2 = sqrt(2.0)/2.0f;
const int SHOW_WIDTH = ceil(ROOT_2_OVER_2 * VIEW_WIDTH);
const int SHOW_HEIGHT = ceil(ROOT_2_OVER_2 * VIEW_HEIGHT);
for (int x = cameraX;x < SHOW_WIDTH;++x) {
    for (int y = cameraY; y < SHOW_WIDTH;++y) {
        draw(tile[x][y]);
    }
}

Code: Select all

void GraphicsBuffer::addCleans(vector<Clean> toAdd){
	addTemp.insert(addTemp.end(), toAdd.begin(), toAdd.end());
	if(!swappingA){
		adding = true;
		add.insert(add.begin(), addTemp.begin(), addTemp.end());
		addTemp.erase(addTemp.begin(), addTemp.end());
		adding = false;
	}
}

void GraphicsBuffer::getCleans(vector<Clean> &toGet){
	if(swappingB){return;}
	getting = true;
	toGet = get;
	get.erase(get.begin(), get.end());
	getting = false;
}

void GraphicsBuffer::step(){
	while(adding){}
	swappingA = true;
	swap = add;
	add.erase(add.begin(), add.end());
	swappingA = false;
	while(getting){}
	swappingB = true;
	get.insert(get.begin(), swap.begin(), swap.end());
	swappingB = false;
}

Code: Select all

// Define function signature   GLOBAL SCOPE  //
typedef BOOL (APIENTRY *PFNWGLSWAPINTERVALFARPROC)( int );

// Initialize func ptr  GLOBAL SCOPE //
PFNWGLSWAPINTERVALFARPROC wglSwapIntervalEXT = 0;

// Subsequent code is in Initialization time //
//Obtain supported extensions string //
LPCSTR extstr = glGetString(GL_EXTENSIONS);

// Check that function is supported //
if(strstr(extstr, "WGL_EXT_swap_control") == 0)
       return;   // device does not support this extension

// Otherwise obtain procedure address //
else
{
    wglSwapIntervalEXT = (PFNWGLSWAPINTERVALFARPROC) wglGetProcAddress("wglSwapIntervalEXT");

    // Check that function pointer was obtained //
    if(wglSwapIntervalEXT)
    {
          // Turn v-sync off //
          wglSwapIntervalEXT(0);    // A value of 1 turns it back on //
    }

}