-#include <World.h>\r
-\r
-World::World(float width){\r
- unsigned int i;\r
- double f;\r
- lineCount=width/HLINE+1;\r
- if((line=(struct line_t *)calloc(lineCount,sizeof(struct line_t)))==NULL){\r
- std::cout<<"Failed to allocate memory!"<<std::endl;\r
- abort();\r
- }\r
- line[0].start=(rand()%100)/100.0f-0.8f; // lazy\r
- if(line[0].start>-0.5f)line[0].start=-0.7f;\r
- for(i=10;i<lineCount;i+=10){ \r
- line[i].start=((double)(rand()%40+200))/1000.0f-1;\r
- }\r
- for(i=0;i<lineCount;i++){\r
- if(!(i%10)||!i){\r
- f=line[i+10].start-line[i].start;\r
- f/=10.0f;\r
- }else{\r
- line[i].start=line[i-1].start+f;\r
- }\r
- }\r
-}\r
-void World::draw(void){\r
- unsigned int i;\r
- glBegin(GL_QUADS);\r
- for(i=0;i<lineCount;i++){\r
- glColor3ub(0,255,0);\r
- glVertex2f((HLINE*i)-1 ,line[i].start);\r
- glVertex2f((HLINE*i)-1+HLINE,line[i].start);\r
- glVertex2f((HLINE*i)-1+HLINE,line[i].start-HLINE*2);\r
- glVertex2f((HLINE*i)-1 ,line[i].start-HLINE*2);\r
- glColor3ub(150,100,50);\r
- glVertex2f((HLINE*i)-1 ,line[i].start-HLINE*2);\r
- glVertex2f((HLINE*i)-1+HLINE,line[i].start-HLINE*2);\r
- glVertex2f((HLINE*i)-1+HLINE,-1);\r
- glVertex2f((HLINE*i)-1 ,-1);\r
- }\r
- glEnd();\r
-}\r
-void World::detect(vec2 *v,const float width){\r
- unsigned int i;\r
- for(i=0;i<lineCount;i++){\r
- if(v->y<line[i].start){\r
- if(v->x>(HLINE*i)-1&&v->x<(HLINE*i)-1+HLINE){\r
- v->x=(HLINE*i)-1+HLINE;\r
- }else if(v->x+width>(HLINE*i)-1&&v->x+width<(HLINE*i)-1+HLINE){\r
- v->x=(HLINE*i)-1-width;\r
- }else{\r
- v->y=line[i].start;\r
- }\r
- }else if(v->y>line[i].start+HLINE/2){\r
- v->y-=HLINE/4;\r
- }\r
- }\r
-}\r
++<<<<<<< HEAD
+#include <World.h>
+
+World::World(float width){
+ unsigned int i;
+ lineCount=width/HLINE+1;
+ if((line=(struct line_t *)calloc(lineCount,sizeof(struct line_t)))==NULL){
+ std::cout<<"Failed to allocate memory!"<<std::endl;
+ abort();
+ }
+ line[0].start=(rand()%100)/100.0f-1; // lazy
+ for(i=1;i<lineCount;i++){
+ line[i].start=line[i-1].start+(float)((rand()%20)-10)/1000.0f;
+ }
+}
+void World::draw(void){
+ unsigned int i;
+ glBegin(GL_QUADS);
+ for(i=0;i<lineCount;i++){
+ glColor3ub(0,255,0);
+ glVertex2f((HLINE*i)-1 ,line[i].start);
+ glVertex2f((HLINE*i)-1+HLINE,line[i].start);
+ glVertex2f((HLINE*i)-1+HLINE,line[i].start-HLINE*2);
+ glVertex2f((HLINE*i)-1 ,line[i].start-HLINE*2);
+ glColor3ub(150,100,50);
+ glVertex2f((HLINE*i)-1 ,line[i].start-HLINE*2);
+ glVertex2f((HLINE*i)-1+HLINE,line[i].start-HLINE*2);
+ glVertex2f((HLINE*i)-1+HLINE,-1);
+ glVertex2f((HLINE*i)-1 ,-1);
+ }
+ glEnd();
+}
++=======
++#include <World.h>
++
++World::World(float width){
++ unsigned int i;
++ double f;
++ lineCount=width/HLINE+1;
++ if((line=(struct line_t *)calloc(lineCount,sizeof(struct line_t)))==NULL){
++ std::cout<<"Failed to allocate memory!"<<std::endl;
++ abort();
++ }
++ line[0].start=(rand()%100)/100.0f-0.8f; // lazy
++ if(line[0].start>-0.5f)line[0].start=-0.7f;
++ for(i=10;i<lineCount;i+=10){
++ line[i].start=((double)(rand()%40+200))/1000.0f-1;
++ }
++ for(i=0;i<lineCount;i++){
++ if(!(i%10)||!i){
++ f=line[i+10].start-line[i].start;
++ f/=10.0f;
++ }else{
++ line[i].start=line[i-1].start+f;
++ }
++ }
++}
++void World::draw(void){
++ unsigned int i;
++ glBegin(GL_QUADS);
++ for(i=0;i<lineCount;i++){
++ glColor3ub(0,255,0);
++ glVertex2f((HLINE*i)-1 ,line[i].start);
++ glVertex2f((HLINE*i)-1+HLINE,line[i].start);
++ glVertex2f((HLINE*i)-1+HLINE,line[i].start-HLINE*2);
++ glVertex2f((HLINE*i)-1 ,line[i].start-HLINE*2);
++ glColor3ub(150,100,50);
++ glVertex2f((HLINE*i)-1 ,line[i].start-HLINE*2);
++ glVertex2f((HLINE*i)-1+HLINE,line[i].start-HLINE*2);
++ glVertex2f((HLINE*i)-1+HLINE,-1);
++ glVertex2f((HLINE*i)-1 ,-1);
++ }
++ glEnd();
++}
++void World::detect(vec2 *v,const float width){
++ unsigned int i;
++ for(i=0;i<lineCount;i++){
++ if(v->y<line[i].start){
++ if(v->x>(HLINE*i)-1&&v->x<(HLINE*i)-1+HLINE){
++ v->x=(HLINE*i)-1+HLINE;
++ }else if(v->x+width>(HLINE*i)-1&&v->x+width<(HLINE*i)-1+HLINE){
++ v->x=(HLINE*i)-1-width;
++ }else{
++ v->y=line[i].start;
++ }
++ }else if(v->y>line[i].start+HLINE/2){
++ v->y-=HLINE/4;
++ }
++ }
++}
++>>>>>>> origin/master
-#include <common.h>\r
-#include <ctime>\r
-\r
-SDL_Window *window = NULL;\r
-SDL_Surface *renderSurface = NULL;\r
-SDL_GLContext mainGLContext = NULL;\r
-\r
-bool gameRunning = true;\r
-\r
-UIClass ui;\r
-Entities *entit1;\r
-Player player;\r
-\r
-int main(int argc,char **argv){\r
- // Initialize SDL\r
- if(!SDL_Init(SDL_INIT_VIDEO)){\r
- atexit(SDL_Quit);\r
- }else{\r
- std::cout << "SDL was not able to initialize! Error: " << SDL_GetError() << std::endl;\r
- return -1;\r
- }\r
- // Initialize SDL_image\r
- if((IMG_Init(IMG_INIT_PNG|IMG_INIT_JPG)&(IMG_INIT_PNG|IMG_INIT_JPG))){\r
- atexit(IMG_Quit);\r
- }else{\r
- std::cout<<"Could not init image libraries!\n"<<std::endl;\r
- return -1;\r
- }\r
- // Create the window\r
- SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);\r
- window = SDL_CreateWindow("Independent Study v.0.1 alpha", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, SCREEN_WIDTH, SCREEN_HEIGHT, SDL_WINDOW_SHOWN | SDL_WINDOW_OPENGL\r
- #ifdef FULLSCREEN\r
- | SDL_WINDOW_FULLSCREEN\r
- #endif // FULLSCREEN\r
- );\r
- if(!window){\r
- std::cout << "The window failed to generate! Error: " << SDL_GetError() << std::endl;\r
- return -1;\r
- }\r
- // Set OpenGL context\r
- if((mainGLContext = SDL_GL_CreateContext(window))==NULL){\r
- std::cout << "The OpenGL context failed to initialize! Error: " << SDL_GetError() << std::endl;\r
- }\r
- // Setup rand() and OpenGL\r
- srand(time(NULL));\r
- glClearColor(.3,.5,.8,0);\r
- glEnable(GL_BLEND);\r
- glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);\r
- \r
- /**************************\r
- **** GAMELOOP ****\r
- **************************/\r
-\r
- entit1 = &player;\r
- entit1->spawn(0,0);\r
-\r
- World *w=new World(2);\r
- \r
- while(gameRunning){\r
- ui.handleEvents(); // Handle events\r
- //a matrix is a blank canvas for the computer to draw on, the matrices are stored in a "stack"\r
- //GL_PROJECTION has 2 matrices\r
- //GL_MODELVIEW has 32 matrices\r
- glMatrixMode(GL_PROJECTION); //set the matrix mode as projection so we can set the ortho size and the camera settings later on\r
- glPushMatrix(); //push the matrix to the top of the matrix stack\r
- glLoadIdentity(); //replace the entire matrix stack with the updated GL_PROJECTION mode\r
- glOrtho(-1,1,-1,1,-1,1); //set the the size of the screen\r
- glMatrixMode(GL_MODELVIEW); //set the matrix to modelview so we can draw objects\r
- glPushMatrix(); //push the matrix to the top of the matrix stack\r
- glLoadIdentity(); //replace the entire matrix stack with the updated GL_MODELVIEW mode\r
- glPushMatrix(); //basically here we put a blank canvas (new matrix) on the screen to draw on\r
- glClear(GL_COLOR_BUFFER_BIT); //clear the matrix on the top of the stack\r
-\r
- /**************************\r
- **** RENDER STUFF HERE ****\r
- **************************/\r
- \r
- w->draw();\r
- glColor3ub(0,0,0);\r
- glRectf(player.loc.x, player.loc.y, player.loc.x + player.width, player.loc.y + player.height);\r
- \r
- /**************************\r
- **** CLOSE THE LOOP ****\r
- **************************/\r
-\r
- glPopMatrix(); //take the matrix(s) off the stack to pass them to the renderer\r
- SDL_GL_SwapWindow(window); //give the stack to SDL to render it\r
- }\r
- \r
- /**************************\r
- **** CLOSE PROGRAM ****\r
- **************************/\r
- \r
- //closes the window and frees resources\r
- SDL_GL_DeleteContext(mainGLContext);\r
- SDL_DestroyWindow(window);\r
- return 0;\r
-}\r
++<<<<<<< HEAD
+#include <common.h>
+#include <ctime>
+
+SDL_Window *window = NULL;
+SDL_Surface *renderSurface = NULL;
+SDL_GLContext mainGLContext = NULL;
+
+bool gameRunning = true;
+
+const float ticksPerSec = 20;
+const float msecPerTick = 1000 / ticksPerSec;
+int prevTime = GetTickCount();
+int currentTime = 0;
+float deltaTime = 0;
+
+Entities *entit1;
+Player player;
+UIClass ui;
+
+float interpolate(float goal, float current, float dt){
+ float difference = goal - current;
+ if(difference > dt){
+ return current + dt;}
+ if(difference < dt){
+ return current - dt;}
+ return goal;
+}
+
+
+World *w=new World(2);
+void render();
+
+int main(int argc,char **argv){
+ //runs start-up procedures
+ if(!SDL_Init(SDL_INIT_VIDEO)){
+ atexit(SDL_Quit);
+ if(!(IMG_Init(IMG_INIT_PNG|IMG_INIT_JPG)&(IMG_INIT_PNG|IMG_INIT_JPG))){
+ std::cout<<"Could not init image libraries!\n"<<std::endl;
+ return -1;
+ }
+ atexit(IMG_Quit);
+ //Turn on double Buffering
+ SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
+ //create the window
+ window = SDL_CreateWindow("Independent Study v.0.1 alpha", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, SCREEN_WIDTH, SCREEN_HEIGHT, SDL_WINDOW_SHOWN | SDL_WINDOW_OPENGL
+ #ifdef FULLSCREEN
+ | SDL_WINDOW_FULLSCREEN
+ #endif // FULLSCREEN
+ );
+ if(window){
+ //set OpenGL context
+ mainGLContext = SDL_GL_CreateContext(window);
+ if(mainGLContext == NULL){
+ std::cout << "The OpenGL context failed to initialize! Error: " << SDL_GetError() << std::endl;
+ }
+ }else{
+ std::cout << "The window failed to generate! Error: " << SDL_GetError() << std::endl;
+ return -1;
+ }
+ }else{
+ std::cout << "SDL was not able to initialize! Error: " << SDL_GetError() << std::endl;
+ return -1;
+ }
+ srand(time(NULL));
+ glClearColor(.3,.5,.8,0);
+ glEnable(GL_BLEND);
+ glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
+
+ /**************************
+ **** GAMELOOP ****
+ **************************/
+
+ entit1 = &player;
+ entit1->spawn(4, 0);
+
+ while(gameRunning){
+ prevTime = currentTime;
+ currentTime = GetTickCount();
+ deltaTime = currentTime - prevTime;
+
+ if(prevTime + msecPerTick <= GetTickCount()){ //HANDLE ALL LOGIC STUFF HERE
+ ui.handleEvents(); // Handle events
+
+ player.vel.x = 0;
+
+ std::cout << player.vel.x << std::endl;
+ std::cout << player.velg.y << std::endl;
+ std::cout << "d:" << deltaTime << std::endl;
+
+ prevTime = GetTickCount();
+ }
+ //DO ALL RENDERING HERE
+ player.vel.x = interpolate(player.velg.x, player.vel.x, deltaTime) * .001;
+ if(player.vel.x > .05) player.vel.x = .05;
+ if(player.vel.x < -.05) player.vel.x = -.05;
+ player.loci.x += player.vel.x;
+
+ render();
+
+ }
+
+ /**************************
+ **** CLOSE PROGRAM ****
+ **************************/
+
+ //closes the window and frees resources
+ SDL_GL_DeleteContext(mainGLContext);
+ SDL_DestroyWindow(window);
+ return 0;
+}
+
+void render(){
+ //a matrix is a blank canvas for the computer to draw on, the matrices are stored in a "stack"
+ //GL_PROJECTION has 2 matrices
+ //GL_MODELVIEW has 32 matrices
+ glMatrixMode(GL_PROJECTION); //set the matrix mode as projection so we can set the ortho size and the camera settings later on
+ glPushMatrix(); //push the matrix to the top of the matrix stack
+ glLoadIdentity(); //replace the entire matrix stack with the updated GL_PROJECTION mode
+ glOrtho(-1 + player.loci.x, 1 + player.loci.x , -1, 1, -1,1); //set the the size of the screen
+ glMatrixMode(GL_MODELVIEW); //set the matrix to modelview so we can draw objects
+ glPushMatrix(); //push the matrix to the top of the matrix stack
+ glLoadIdentity(); //replace the entire matrix stack with the updated GL_MODELVIEW mode
+ glPushMatrix(); //basically here we put a blank canvas (new matrix) on the screen to draw on
+ glClear(GL_COLOR_BUFFER_BIT); //clear the matrix on the top of the stack
+
+ /**************************
+ **** RENDER STUFF HERE ****
+ **************************/
+
+ w->draw();
+ glColor3ub(0,0,0);
+ glRectf(player.loci.x, player.loci.y, player.loci.x + player.width, player.loci.y + player.height);
+
+ /**************************
+ **** CLOSE THE LOOP ****
+ **************************/
+
+ glPopMatrix(); //take the matrix(s) off the stack to pass them to the renderer
+ SDL_GL_SwapWindow(window); //give the stack to SDL to render it
- }
++}
++=======
++#include <common.h>
++#include <ctime>
++
++SDL_Window *window = NULL;
++SDL_Surface *renderSurface = NULL;
++SDL_GLContext mainGLContext = NULL;
++
++bool gameRunning = true;
++
++UIClass ui;
++Entities *entit1;
++Player player;
++
++int main(int argc,char **argv){
++ // Initialize SDL
++ if(!SDL_Init(SDL_INIT_VIDEO)){
++ atexit(SDL_Quit);
++ }else{
++ std::cout << "SDL was not able to initialize! Error: " << SDL_GetError() << std::endl;
++ return -1;
++ }
++ // Initialize SDL_image
++ if((IMG_Init(IMG_INIT_PNG|IMG_INIT_JPG)&(IMG_INIT_PNG|IMG_INIT_JPG))){
++ atexit(IMG_Quit);
++ }else{
++ std::cout<<"Could not init image libraries!\n"<<std::endl;
++ return -1;
++ }
++ // Create the window
++ SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
++ window = SDL_CreateWindow("Independent Study v.0.1 alpha", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, SCREEN_WIDTH, SCREEN_HEIGHT, SDL_WINDOW_SHOWN | SDL_WINDOW_OPENGL
++ #ifdef FULLSCREEN
++ | SDL_WINDOW_FULLSCREEN
++ #endif // FULLSCREEN
++ );
++ if(!window){
++ std::cout << "The window failed to generate! Error: " << SDL_GetError() << std::endl;
++ return -1;
++ }
++ // Set OpenGL context
++ if((mainGLContext = SDL_GL_CreateContext(window))==NULL){
++ std::cout << "The OpenGL context failed to initialize! Error: " << SDL_GetError() << std::endl;
++ }
++ // Setup rand() and OpenGL
++ srand(time(NULL));
++ glClearColor(.3,.5,.8,0);
++ glEnable(GL_BLEND);
++ glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
++
++ /**************************
++ **** GAMELOOP ****
++ **************************/
++
++ entit1 = &player;
++ entit1->spawn(0,0);
++
++ World *w=new World(2);
++
++ while(gameRunning){
++ ui.handleEvents(); // Handle events
++ //a matrix is a blank canvas for the computer to draw on, the matrices are stored in a "stack"
++ //GL_PROJECTION has 2 matrices
++ //GL_MODELVIEW has 32 matrices
++ glMatrixMode(GL_PROJECTION); //set the matrix mode as projection so we can set the ortho size and the camera settings later on
++ glPushMatrix(); //push the matrix to the top of the matrix stack
++ glLoadIdentity(); //replace the entire matrix stack with the updated GL_PROJECTION mode
++ glOrtho(-1,1,-1,1,-1,1); //set the the size of the screen
++ glMatrixMode(GL_MODELVIEW); //set the matrix to modelview so we can draw objects
++ glPushMatrix(); //push the matrix to the top of the matrix stack
++ glLoadIdentity(); //replace the entire matrix stack with the updated GL_MODELVIEW mode
++ glPushMatrix(); //basically here we put a blank canvas (new matrix) on the screen to draw on
++ glClear(GL_COLOR_BUFFER_BIT); //clear the matrix on the top of the stack
++
++ /**************************
++ **** RENDER STUFF HERE ****
++ **************************/
++
++ w->draw();
++ glColor3ub(0,0,0);
++ glRectf(player.loc.x, player.loc.y, player.loc.x + player.width, player.loc.y + player.height);
++
++ /**************************
++ **** CLOSE THE LOOP ****
++ **************************/
++
++ glPopMatrix(); //take the matrix(s) off the stack to pass them to the renderer
++ SDL_GL_SwapWindow(window); //give the stack to SDL to render it
++ }
++
++ /**************************
++ **** CLOSE PROGRAM ****
++ **************************/
++
++ //closes the window and frees resources
++ SDL_GL_DeleteContext(mainGLContext);
++ SDL_DestroyWindow(window);
++ return 0;
++}
++>>>>>>> origin/master
projects / clyne / gamedev.git / commitdiff