main.exe\r
main\r
-game.odt\r
+\r
+.kdev4\r
+gamedev.kdev4\r
- began documenting entities.h/.cpp and world.h/.cpp
- fixed structure physics
- improved include locations
+
+10/22/2015:
+===========
+
+ - 1 month Changelog anniversary :)
+ - successfully built and ran game on 64-bit linux
+ - successfully build game on 32-bit Windows (game crashes on execution)
+ - removed npc array; NPCs are now created in the entity array
+ - created a basic texture handling library
+
+
\ No newline at end of file
LIBS = -lGL\r
WIN_LIBS = -lopengl32 -lmingw32\r
\r
-FLAGS = -m32 -std=c++11 -Iinclude -Iinclude/freetype2 -lGL -lGLEW -lSDL2main -lSDL2 -lfreetype -lSDL2_image -lSDL2_mixer\r
+FLAGS = -std=c++11 -Iinclude -Iinclude/freetype2 -lGL -lGLEW -lSDL2 -lfreetype -lSDL2_image -lSDL2_mixer\r
\r
all:\r
@rm -f out/*.o\r
#define DEBUG
-#define NPCp(n) ((NPC *)n)
+#define NPCp(n) ((NPC *)n)
+#define Structurep(n) ((Structures *)n)
+#define Mobp(n) ((Mob *)n)
#define PLAYER_INV_SIZE 30 // The size of the player's inventory
#define NPC_INV_SIZE 3 // Size of an NPC's inventory
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).
+ * 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.
+ * 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.
+ * 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.
+ * 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.
+ * 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.
+ * 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;
LIBS = -lGL -lSDL2_image -lSDL2_mixer
-FLAGS = -m32 -std=c++11 -I../include -I../include/freetype2 -lSDL2main -lSDL2 -lfreetype
+FLAGS = -std=c++11 -I../include -I../include/freetype2 -lSDL2main -lSDL2 -lfreetype
OUT = `echo "" $$(ls -c $(wildcard *.cpp)) | sed s/.cpp/.o/g | sed 's/ / ..\/out\//g'`
#include <ui.h>
extern std::vector<Entity*>entity;
-extern std::vector<NPC>npc;
+//extern std::vector<NPC>npc;
extern std::vector<Structures>build;
extern FILE* names;
loc.y = y;
vel.x = 0;
vel.y = 0;
- right = false;
- left = false;
- near = false;
- ticksToUse = 0;
- canMove = true;
- ground = false;
alive = true;
- if(!maxHealth)health = maxHealth = 50;
+ right = true;
+ left = false;
+ near = false;
+ canMove = true;
+ ground = false;
+ ticksToUse = 0;
+ if(!maxHealth)health = maxHealth = 1;
name = (char*)malloc(16);
getName();
}
subtype = 0;
maxHealth = 100;
health = maxHealth;
- alive = true;
- ground = false;
- near = true;
texture[0] = loadTexture("assets/player.png");
texture[1] = loadTexture("assets/player1.png");
texture[2] = loadTexture("assets/player2.png");
speed = 1;
type = NPCT; //sets type to npc
subtype = 0;
- alive = true;
- canMove = true;
- near = false;
texture[0] = loadTexture("assets/NPC.png");
texture[1] = 0;
texture[2] = 0;
Structures::Structures(){ //sets the structure type
type = STRUCTURET;
speed = 0;
- alive = true;
- near = false;
texture[0] = loadTexture("assets/house1.png");
texture[1] = 0;
texture[2] = 0;
speed = 1;
type = MOBT; //sets type to MOB
subtype = 1; //SKIRL
- alive = true;
- canMove = true;
- near = false;
texture[0] = loadTexture("assets/rabbit.png");
texture[1] = loadTexture("assets/rabbit1.png");
texture[2] = 0;
int tempN = (getRand() % 5 + 2); //amount of villagers that will spawn
for(int i=0;i<tempN;i++){
entity.push_back(new NPC()); //create a new entity of NPC type
- npc.push_back(NPC()); //create new NPC
- entity[entity.size()] = &npc[npc.size()-1]; //set the new entity to have the same traits as an NPC
- entity[entity.size()-1]->spawn(loc.x + (float)(i - 5),100); //sets the position of the villager around the village
+ NPCp(entity[entity.size()-1])->spawn(loc.x + (float)(i - 5),100); //sets the position of the villager around the village
}
return entity.size();
}
bool debug=false;
bool dialogBoxExists=false;
unsigned int fontSize;
+
/*
* initFonts(), setFontFace(), and setFontSize() are pretty self-explanatory
*/
+
void initFonts(void){
if(FT_Init_FreeType(&ftl)){
std::cout<<"Error! Couldn't initialize freetype."<<std::endl;
#define getWidth(w) ((w->lineCount-GEN_INC)*HLINE) // Calculates the width of world 'w'
#define GEN_INC 10 // Defines at what interval y values should be calculated for the array 'line'.
- // As explained in World(), the last few lines in the array 'line' are incorrectly calculated
- // or not calculated at all, so GEN_INC is also used to decrease 'lineCount' in functions like draw()
- // and detect().
-#define GRASS_HEIGHT 4 // Defines how long the grass layer of a line should be in multiples of HLINE.
+ // As explained in World(), the last few lines in the array 'line' are incorrectly calculated
+ // or not calculated at all, so GEN_INC is also used to decrease 'lineCount' in functions like draw()
+ // and detect().
+
+#define GRASS_HEIGHT 4 // Defines how long the grass layer of a line should be in multiples of HLINE.
#define DRAW_Y_OFFSET 50 // Defines how many pixels each layer should be offset from each other on the y axis when drawn.
}
void World::generate(unsigned int width){ // Generates the world and sets all variables contained in the World class.
- unsigned int i; // Used for 'for' loops
- float inc; // See line 40
+ unsigned int i; // Used for 'for' loops
+ float inc; // See line 40
/*
* Calculate the world's real width. The current form of generation fails to generate
void World::singleDetect(Entity *e){
unsigned int i;
+
+ /*
+ * Kill any dead entities.
+ */
+
if(e->health<=0){
+
e->alive=false;
- }else if(e->alive){
- i=(e->loc.x+e->width/2-x_start)/HLINE; // Calculate what line the player is currently on
- if(e->loc.y<line[i].y){
- e->vel.y=0;
+
+ }
+
+ /*
+ * Handle only living entities.
+ */
+
+ if(e->alive){
+
+ /*
+ * Calculate the line that this entity is currently standing on.
+ */
+
+ i=(e->loc.x + e->width / 2 - x_start) / HLINE;
+
+ /*
+ * If the entity is under the world/line, pop it back to the surface.
+ */
+
+ if(e->loc.y < line[i].y){
+
e->ground=true;
- e->loc.y=line[i].y-.001*deltaTime;
- }else if(e->loc.y>line[i].y-.002*deltaTime){
+
+ e->vel.y=0;
+ e->loc.y=line[i].y - .001 * deltaTime;
+
+ /*
+ * Otherwise, if the entity is above the line...
+ */
+
+ }else if(e->loc.y > line[i].y - .002 * deltaTime){
+
+ /*
+ * Check for any potential platform collision (i.e. landing on a platform)
+ */
+
for(i=0;i<platform.size();i++){
- if(((e->loc.x+e->width>platform[i].p1.x)&(e->loc.x+e->width<platform[i].p2.x))||
- ((e->loc.x<platform[i].p2.x)&(e->loc.x>platform[i].p1.x))){
- if(e->loc.y>platform[i].p1.y&&e->loc.y<platform[i].p2.y){
- if(e->vel.y<0){
+
+ if(((e->loc.x + e->width > platform[i].p1.x) & (e->loc.x + e->width < platform[i].p2.x)) || // Check X left bounds
+ ((e->loc.x < platform[i].p2.x) & (e->loc.x>platform[i].p1.x))){ // Check X right bounds
+ if(e->loc.y > platform[i].p1.y && e->loc.y < platform[i].p2.y){ // Check Y bounds
+
+ /*
+ * Check if the entity is falling onto the platform so
+ * that it doesn't snap to it when attempting to jump
+ * through it.
+ *
+ */
+
+ if(e->vel.y<=0){
+
+ e->ground=2;
+
e->vel.y=0;
e->loc.y=platform[i].p2.y;
- e->ground=2;
- return;
+
+ //return; // May not be necessary
}
}
}
}
- e->vel.y-=.001*deltaTime;
+
+ /*
+ * Handle gravity.
+ */
+
+ e->vel.y-=.001 * deltaTime;
+
}
- if(e->loc.x<x_start){ // Keep the player inside world bounds (ui.cpp handles world jumping)
+
+ /*
+ * Insure that the entity doesn't fall off either edge of the world.
+ */
+
+ if(e->loc.x<x_start){ // Left bound
+
e->vel.x=0;
- e->loc.x=x_start+HLINE/2;
- }else if(e->loc.x+e->width+HLINE>x_start+getWidth(this)){
+ e->loc.x=x_start + HLINE / 2;
+
+ }else if(e->loc.x + e->width + HLINE > x_start + getWidth(this)){ // Right bound
+
e->vel.x=0;
- e->loc.x=x_start+getWidth(this)-e->width-HLINE;
+ e->loc.x=x_start + getWidth(this) - e->width - HLINE;
+
}
}
}
-extern unsigned int newEntityCount;
void World::detect(Player *p){
unsigned int i;
+
+ /*
+ * Handle the player.
+ */
+
singleDetect(p);
- for(i=0;i<entity.size()+1;i++){
+
+ /*
+ * Handle all remaining entities in this world.
+ */
+
+ for(i=0;i<entity.size();i++){
+
if(entity[i]->inWorld==this){
+
singleDetect(entity[i]);
+
}
}
}
projects / clyne / gamedev.git / commitdiff