#include <ui.h>
#include <entities.h>
-#define TICKS_PER_SEC 20 // The amount of game ticks that should occur in one second
-#define MSEC_PER_TICK (1000/TICKS_PER_SEC) // The amount of milliseconds there should be between ticks
-
-SDL_Window *window = NULL; // The game's window
+/*
+ * TICKS_PER_SEC & MSEC_PER_TICK
+ *
+ * The game's main loop mainly takes care of two things: drawing to the
+ * screen and handling game logic, from user input to world gravity stuff.
+ * The call for rendering is made every time the main loop loops, and then
+ * uses interpolation for smooth drawing to the screen. However, the call
+ * for logic would be preferred to be run every set amount of time.
+ *
+ * The logic loop is currently implemented to run at a certain interval
+ * that we call a 'tick'. As one may now guess, TICKS_PER_SEC defines the
+ * amount of ticks that should be made every second. MSEC_PER_TICK then
+ * does a simple calculation of how many milliseconds elapse per each
+ * 'tick'. Simple math is then done in the main loop using MSEC_PER_TICK
+ * to call the logic handler when necessary.
+ *
+*/
+
+#define TICKS_PER_SEC 20
+#define MSEC_PER_TICK (1000/TICKS_PER_SEC)
+
+/*
+ * window & mainGLContext
+ *
+ * In order to draw using SDL and its openGL facilities SDL requires
+ * an SDL_Window object, which spawns a window for the program to draw
+ * to. Once the SDL_Window is initialized, an SDL_GLContext is made so
+ * that openGL calls can be made to SDL. The game requires both of these
+ * variables to initialize.
+ *
+*/
+
+SDL_Window *window = NULL;
SDL_GLContext mainGLContext = NULL;
-static GLuint bgImage;
-
-bool gameRunning = true; // The game will exit if this is false
-
-World *currentWorld=NULL; // A pointer to the world that the player is currently in
-Player *player; // The player
-std::vector<Entity*>entity; // An array of all entities in existance
-std::vector<NPC>npc; // An array of all NPCs in existance (entries in `entity` point to these)
-std::vector<Structures *>build; // An array of all Structures in existance (entries in `entity` point to these)
-std::vector<Mob>mob; // An array of all Mobs in existance (entries in `entity` point to these)
+/*
+ * bgImage contains the GLuint returned when creating a texture for the
+ * background image. Currently there is only one background image for the
+ * main world; this will be changed and bgImage likely removed once better
+ * backgrounds are implemented.
+ *
+*/
-unsigned int tickCount = 0, // The amount of generated ticks since the game entered the main loop
- deltaTime = 0; // Used for frame regulation / smooth animation n' stuff
-
-int mx, my; // The mouse's coordinates in the window
+static GLuint bgImage;
-FILE *names; // A pointer to the file containing possible NPC names
+/*
+ * gameRunning
+ *
+ * This is one of the most important variables in the program. The main
+ * loop of the game is set to break once this variable is set to false.
+ * The only call to modify this variable is made in src/ui.cpp, where it
+ * is set to false if either an SDL_QUIT message is received (the user
+ * closes the window through their window manager) or if escape is pressed.
+ *
+*/
+
+bool gameRunning = true;
+
+/*
+ * currentWorld - This is a pointer to the current world that the player
+ * is in. Most drawing/entity handling is done through this
+ * variable. This should only be changed when layer switch
+ * buttons are pressed (see src/ui.cpp), or when the player
+ * enters a Structure/Indoor World (see src/ui.cpp again).
+ *
+ * player - This points to a Player object, containing everything for
+ * the player. Most calls made with currentWorld require a
+ * Player object as an argument, and glOrtho is set based
+ * off of the player's coordinates. This is probably the one
+ * Entity-derived object that is not pointed to in the entity
+ * array.
+ *
+ * entity - Contains pointers to 'all' entities that have been created in
+ * the game, including NPCs, Structures, and Mobs. World draws
+ * and entity handling done by the world cycle through entities
+ * using this array. Entities made that aren't added to this
+ * array probably won't be noticable by the game.
+ *
+ * npc - An array of all NPCs in the game. It's not exactly clear how
+ * NPC initing is done, their constructed in this array, then set
+ * to be pointed to by entity, then maybe spawned with Entity->spawn().
+ * See src/entities.cpp for more.
+ * This variable might be referenced as an extern in other files.
+ *
+ * build - An array of all Structures in the game. Entries in entity point to
+ * these, allowing worlds to handle the drawing and stuff of these.
+ * See src/entities.cpp for more.
+ *
+ * mob - An array of all Mobs in the game, entity entries should point to these
+ * so the world can take care of them. See src/entities.cpp for more.
+ *
+*/
+
+World *currentWorld=NULL;
+Player *player;
+std::vector<Entity * > entity;
+std::vector<NPC > npc;
+std::vector<Structures *> build;
+std::vector<Mob > mob;
+
+/*
+ * tickCount contains the number of ticks generated since main loop entrance.
+ * This variable might be used anywhere.
+ *
+ * deltaTime is used for interpolation stuff.
+ *
+ * Pretty sure these variables are considered static as they might be externally
+ * referenced somewhere.
+*/
+
+unsigned int tickCount = 0;
+unsigned int deltaTime = 0;
+
+/*
+ * names is used to open a file containing all possible NPC names. It is externally
+ * referenced in src/entities.cpp for getting random names.
+ *
+*/
+
+FILE *names;
+
+/*
+ * These variables are used by SDL_mixer to create sound.
+ * horn is not currently used, although it may be set.
+ *
+*/
Mix_Music *music;
Mix_Chunk *horn;
+
+/*
+ * loops is used for texture animation. It is believed to be passed to entity
+ * draw functions, although it may be externally referenced instead.
+ *
+*/
+
unsigned int loops = 0; // Used for texture animation
extern void initEverything(void); // Sets up the worlds and NPCs, see gameplay.cpp
debugY = player->loc.y;
}
- mx = (ui::mouse.x+player->loc.x) - (SCREEN_WIDTH/2);
- my = SCREEN_HEIGHT - ui::mouse.y;
+ //mx = (ui::mouse.x+player->loc.x) - (SCREEN_WIDTH/2);
+ //my = SCREEN_HEIGHT - ui::mouse.y;
render();
}
fps,player->ground,SCREEN_WIDTH,SCREEN_HEIGHT,entity.size(),player->loc.x,debugY,player->qh.current.size());
}
- glColor3ub(255,255,255); // Draw the mouse
- glBegin(GL_TRIANGLES); //
- glVertex2i(mx,my); //
- glVertex2i(mx+HLINE*3.5,my); //
- glVertex2i(mx,my-HLINE*3.5); //
- glEnd(); //
+ glColor3ub(255,255,255); // Draw the mouse
+ glBegin(GL_TRIANGLES); //
+ glVertex2i(ui::mouse.x,ui::mouse.y); //
+ glVertex2i(ui::mouse.x+HLINE*3.5,ui::mouse.y); //
+ glVertex2i(ui::mouse.x,ui::mouse.y-HLINE*3.5); //
+ glEnd(); //
/**************************
**** END RENDERING ****
SDL_GL_SwapWindow(window); //give the stack to SDL to render it
}
-void logic(){
+void logic(){
ui::handleEvents(); // Handle keyboard / mouse input
currentWorld->detect(player); // Handle gravity and world bounds
if(entity[i]->canMove)entity[i]->wander((rand()%120 + 30), &entity[i]->vel); // Make the NPC wander
// Check if the NPC is near the player and handle potential interaction
- if(pow((entity[i]->loc.x - player->loc.x),2) + pow((entity[i]->loc.y - player->loc.y),2) <= pow(40*HLINE,2)){
- if(mx >= entity[i]->loc.x && mx <= entity[i]->loc.x + entity[i]->width &&
- my >= entity[i]->loc.y && my <= entity[i]->loc.y + entity[i]->width){
+ if(pow((entity[i]->loc.x - player->loc.x),2) + pow((entity[i]->loc.y - player->loc.y),2) <= pow(40*HLINE,2)){ // NPC in range
+ if(ui::mouse.x >= entity[i]->loc.x && ui::mouse.x <= entity[i]->loc.x + entity[i]->width && // Mouse is hovering over NPC
+ ui::mouse.y >= entity[i]->loc.y && ui::mouse.y <= entity[i]->loc.y + entity[i]->width){
entity[i]->near=true; // Allows the NPC's name to be drawn
- if(SDL_GetMouseState(NULL, NULL)&SDL_BUTTON(SDL_BUTTON_RIGHT)){
- entity[i]->interact(); // Interact with the player
- //Mix_PlayChannel( -1, horn, 0);
+ if(SDL_GetMouseState(NULL, NULL)&SDL_BUTTON(SDL_BUTTON_RIGHT)){ // If right click
+ entity[i]->interact(); // Interact with the player
+ //Mix_PlayChannel( -1, horn, 0); // Audio feedback
}
}else entity[i]->near=false;
}
extern Player *player; // 'player' should be (must be) defined in main.cpp
extern World *currentWorld; // should/must also be defined in main.cpp
-extern std::vector<NPC>npc;
+extern std::vector<int (*)(NPC *)> AIpreload; // see entities.cpp
+extern std::vector<void *> AIpreaddr; //
static FT_Library ftl; // Variables for the FreeType library and stuff
static FT_Face ftf;
setFontSize(16);
putString(x+HLINE,y-fontSize-HLINE,dialogBoxText);
}
+ setFontSize(16);
+ putText(((SCREEN_WIDTH/2)+player->loc.x)-125,SCREEN_HEIGHT-fontSize,"Health: %u/%u",player->health>0?(unsigned)player->health:0,
+ (unsigned)player->maxHealth);
+ if(player->alive){
+ glColor3ub(255,0,0);
+ glRectf((SCREEN_WIDTH/2+player->loc.x)-125,
+ SCREEN_HEIGHT-32,
+ ((SCREEN_WIDTH/2+player->loc.x)-125)+((player->health/player->maxHealth)*100),
+ SCREEN_HEIGHT-32+12);
+ }
}
void handleEvents(void){
static bool left=false,right=false;
+ static vec2 premouse={0,0};
SDL_Event e;
+ mouse.x=premouse.x+player->loc.x-(SCREEN_WIDTH/2);
+ mouse.y=SCREEN_HEIGHT-premouse.y;
while(SDL_PollEvent(&e)){
switch(e.type){
case SDL_QUIT:
gameRunning=false;
break;
case SDL_MOUSEMOTION:
- mouse.x=e.motion.x;
- mouse.y=e.motion.y;
+ premouse.x=e.motion.x;
+ premouse.y=e.motion.y;
break;
case SDL_MOUSEBUTTONDOWN:
if((e.button.button&SDL_BUTTON_RIGHT)&&dialogBoxExists){
break;
}
}
- static bool once=false;
+
unsigned int i;
- if(!dialogBoxExists&&!once){
- for(i=0;i<npc.size();i++){
- npc[i].flushAIFunc();
+ if(!dialogBoxExists&&AIpreaddr.size()){ // Flush preloaded AI functions if necessary
+ for(i=0;i<AIpreaddr.size();i++){
+ NPCp(AIpreaddr.front())->addAIFunc(AIpreload.front(),false);
+ AIpreaddr.erase(AIpreaddr.begin());
+ AIpreload.erase(AIpreload.begin());
}
- once=true;
- }else once=false;
+ }
}
}
projects / clyne / gamedev.git / commitdiff