xavi
/
PocketEmpires
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Merge branch 'master' of https://github.com/XaviDCR92/PocketEmpires

This commit is contained in:
XaviDCR92 2017-08-26 11:18:11 +02:00
parent 35937cb697 54ea724c5d
commit e944ccbfc5
6 changed files with 453 additions and 19 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
GameStructures.h
View File

@ -41,6 +41,7 @@ typedef struct t_Unit
uint8_t hp;
uint8_t id;
bool dir; // False = up-down; true = left-right
bool mirror; // True = down or left; true = up or right
bool walking;
bool alive;
bool selected;

13
MouseSpr.c Normal file
View File

@ -0,0 +1,13 @@
const uint8_t PROGMEM MouseSprData[] =
{
8,8, //width and height
B11111100,
B10000100,
B10001000,
B10000100,
B10100010,
B11010001,
B00001010,
B00000100,
};

118
Player.cpp
View File

@ -9,6 +9,8 @@
* **************************************/
#define CANCEL_SELECTION_NO_FRAMES 5
#define ACCEPT_UNIT_BUILDING_OPTIONS_FRAMES 5
#define MAX_SELECTION_DIST 400
/* **************************************
* Local variables *
@ -133,6 +135,11 @@ void Player::DrawHandler(void)
UnitSelectedOptions(u);
}
}
if(progress_bar != 0)
{
GfxDrawRectangle(X_SCREEN_RESOLUTION - 16, Y_SCREEN_RESOLUTION - 4, progress_bar, 2, GFX_BLACK);
}
}
bool Player::checkNewBuildingPosition(TYPE_COLLISION_BLOCK * cb)
@ -264,7 +271,7 @@ void Player::UnitBuildingSelection(void)
{
TYPE_UNIT * u = &units[i];
if(u->alive == false)
if( (u->alive == false) || (u->selected == true) )
{
continue;
}
@ -291,7 +298,7 @@ void Player::UnitBuildingSelection(void)
{
TYPE_BUILDING * b = &buildings[i];
if(b->built == false)
if( (b->built == false) || (b->selected == true) )
{
continue;
}
@ -322,9 +329,9 @@ void Player::UnitBuildingSelection(void)
selectedBuilding = NULL;
}
if( (nearest_unit_dist > 400)
if( (nearest_unit_dist > MAX_SELECTION_DIST)
&&
(nearest_building_dist > 400) )
(nearest_building_dist > MAX_SELECTION_DIST) )
{
selectedUnit = NULL;
selectedBuilding = NULL;
@ -341,20 +348,68 @@ void Player::UnitBuildingSelection(void)
GfxPrintText(buf, X_SCREEN_RESOLUTION - 32, 24);*/
}
void Player::Handler(void)
void Player::BuildingUnitActions(void)
{
static bool bCancelSelection = false;
const char* pActionStr = NULL;
for(uint8_t i = 0; i < PLAYER_MAX_BUILDINGS; i++)
{
if(buildings[i].selected == true)
{
BuildingSelectedOptions(selectedBuilding);
break;
}
}
if(pActionStr == NULL)
{
for(uint8_t i = 0; i < PLAYER_MAX_UNITS; i++)
{
if(units[i].selected == true)
{
pActionStr = UnitSelectedOptions(selectedUnit);
break;
}
}
}
if(pActionStr != NULL)
{
GfxPrintTextFont(pActionStr, font3x3, 48, Y_SCREEN_RESOLUTION - 4);
}
}
void Player::Handler(void)
{
CameraHandler(&Camera);
UnitBuildingSelection();
for(int i = 0; i < PLAYER_MAX_UNITS; i++)
for(uint8_t i = 0; i < PLAYER_MAX_UNITS; i++)
{
TYPE_UNIT * ptrUnit = &units[i];
UnitHandler(ptrUnit);
}
ButtonHandler();
BuildingUnitActions();
GfxShowResources(&Resources);
}
void Player::ButtonHandler(void)
{
static bool bCancelSelection = false;
if(PadButtonPressed(PAD_A) == true)
{
if(progress_bar < ACCEPT_UNIT_BUILDING_OPTIONS_FRAMES)
{
progress_bar++;
}
}
if(PadButtonReleased(PAD_A) == true)
{
@ -374,7 +429,7 @@ void Player::Handler(void)
GfxPrintText_Flash(F("Building built!\0"));
}*/
for(int i = 0; i < PLAYER_MAX_UNITS; i++)
for(uint8_t i = 0; i < PLAYER_MAX_UNITS; i++)
{
TYPE_UNIT * u = &units[i];
@ -384,7 +439,7 @@ void Player::Handler(void)
}
}
for(int i = 0; i < PLAYER_MAX_BUILDINGS; i++)
for(uint8_t i = 0; i < PLAYER_MAX_BUILDINGS; i++)
{
TYPE_BUILDING * b = &buildings[i];
@ -394,18 +449,31 @@ void Player::Handler(void)
}
}
}
else if(PadButtonPressedFrames(PAD_A, ACCEPT_UNIT_BUILDING_OPTIONS_FRAMES) == true)
{
for(uint8_t i = 0; i < PLAYER_MAX_UNITS; i++)
{
TYPE_UNIT* u = &units[i];
if(u->selected == true)
{
UnitAcceptAction(u);
break;
}
}
}
else if( (PadButtonPressedFrames(PAD_B, CANCEL_SELECTION_NO_FRAMES) == true)
&&
(bCancelSelection == false) )
{
for(int i = 0; i < PLAYER_MAX_UNITS; i++)
for(uint8_t i = 0; i < PLAYER_MAX_UNITS; i++)
{
TYPE_UNIT * u = &units[i];
u->selected = false;
}
for(int i = 0; i < PLAYER_MAX_BUILDINGS; i++)
for(uint8_t i = 0; i < PLAYER_MAX_BUILDINGS; i++)
{
TYPE_BUILDING * b = &buildings[i];
@ -416,30 +484,42 @@ void Player::Handler(void)
selectedBuilding = NULL;
bCancelSelection = true;
showUnitBuildingOptions = true;
}
else
{
// Button A is not pressed. Reset progress bar.
progress_bar = 0;
}
if( (PadButtonReleased(PAD_B) == true)
&&
(bCancelSelection == false) )
{
TYPE_COLLISION_BLOCK cursor = GetCursorPos();
for(int i = 0; i < PLAYER_MAX_UNITS; i++)
if(showUnitBuildingOptions == false)
{
TYPE_UNIT * u = &units[i];
TYPE_COLLISION_BLOCK cursor = GetCursorPos();
if(u->selected == true)
for(uint8_t i = 0; i < PLAYER_MAX_UNITS; i++)
{
UnitMoveTo(u, cursor.x, cursor.y);
TYPE_UNIT * u = &units[i];
if(u->selected == true)
{
UnitMoveTo(u, cursor.x, cursor.y);
}
}
}
else
{
showUnitBuildingOptions = false;
}
}
else if( (PadButtonReleased(PAD_B) == true)
&&
(bCancelSelection == true) )
{
bCancelSelection = false;
UnitResetMenuLevel();
}
GfxShowResources(&Resources);
}

5
Player.h
View File

@ -47,7 +47,10 @@ class Player
bool checkNewBuildingPosition(TYPE_COLLISION_BLOCK * cb);
void UnitBuildingSelection(void);
void showHealth(uint8_t hp);
void ButtonHandler(void);
void BuildingUnitActions(void);
TYPE_COLLISION_BLOCK GetCursorPos(void);
char name[PLAYER_NAME_LENGTH];
TYPE_UNIT units[PLAYER_MAX_UNITS];
TYPE_BUILDING buildings[PLAYER_MAX_BUILDINGS];
@ -57,8 +60,10 @@ class Player
uint8_t unit_i;
uint8_t bldg_i;
bool human;
bool showUnitBuildingOptions;
TYPE_CAMERA Camera;
TYPE_RESOURCES Resources;
uint8_t progress_bar;
//Print _serial;
};

285
Unit.c Normal file
View File

@ -0,0 +1,285 @@
/* **************************************
* Includes *
* **************************************/
#include "Unit.h"
#include "PeasantSpr.c"
/* **************************************
* Defines *
* **************************************/
/* **************************************
* Local prototypes *
* **************************************/
static void UnitIncreaseMenuLevel(void);
static void UnitBuildAccept(TYPE_UNIT* ptrUnit);
/* **************************************
* Local variables *
* **************************************/
static uint8_t menuLevel;
typedef struct
{
const char* str;
void (*pAction)(TYPE_UNIT*);
}TYPE_UNIT_ACTION;
/* Sprites */
static TYPE_SPRITE PeasantSpr;
static TYPE_SPRITE PeasantWalkingSpr;
/* Tables */
static uint8_t const UnitHPTable[] = { 25 };
static uint8_t const UnitSpeedTable[] = { 1 };
static TYPE_UNIT_ACTION const UnitActionsTable_Level0[] = { {"Build", NULL} };
static TYPE_UNIT_ACTION const UnitActionsTable_Level1[] = { {"Barracks", &UnitBuildAccept} };
static TYPE_SPRITE * const UnitSprTable[] = {&PeasantSpr};
static TYPE_SPRITE * const UnitWalkingSprTable[] = {&PeasantWalkingSpr};
void UnitInit(void)
{
PeasantSpr.Data = Peasant_SprData;
PeasantSpr.w = GfxGetWidthFromSpriteData(Peasant_SprData);
PeasantSpr.h = GfxGetHeightFromSpriteData(Peasant_SprData);
PeasantSpr.flip = 0;
PeasantSpr.rotation = 0;
PeasantSpr.color = GFX_BLACK;
PeasantWalkingSpr.Data = Peasant_Walking_SprData;
PeasantWalkingSpr.w = GfxGetWidthFromSpriteData(Peasant_Walking_SprData);
PeasantWalkingSpr.h = GfxGetHeightFromSpriteData(Peasant_Walking_SprData);
PeasantWalkingSpr.flip = 0;
PeasantWalkingSpr.rotation = 0;
PeasantWalkingSpr.color = GFX_BLACK;
}
void UnitDraw(TYPE_CAMERA * ptrCamera, TYPE_UNIT * ptrUnit, bool bSelected)
{
uint8_t id = ptrUnit->id;
TYPE_SPRITE * ptrSpr;
static uint8_t walk_counter = 0;
static bool mirror = false;
if(ptrUnit->alive == false)
{
return;
}
ptrSpr = ptrUnit->walking ? UnitWalkingSprTable[id] : UnitSprTable[id];
ptrSpr->rotation = ptrUnit->dir ? ROTCCW : NOROT;
ptrSpr->flip = GFX_NOFLIP;
if(ptrUnit->walking == true)
{
if(mirror == true)
{
if(ptrUnit->dir == false)
{
ptrSpr->flip = GFX_FLIPH;
}
else
{
ptrSpr->flip = GFX_FLIPV;
}
}
else
{
ptrSpr->flip = NOROT;
}
}
if(ptrUnit->mirror == false)
{
if(ptrUnit->dir == false)
{
ptrSpr->flip |= GFX_FLIPV;
}
else
{
ptrSpr->flip |= GFX_FLIPH;
}
}
CameraApplyCoordinatesToSprite( ptrCamera,
ptrSpr,
ptrUnit->x,
ptrUnit->y );
GfxDrawSprite(ptrSpr);
if( (bSelected == true) && (ptrUnit->selected == false) )
{
TYPE_COLLISION_BLOCK cb;
cb = CameraApplyCoordinatesToCoordinates(ptrCamera, ptrUnit->x, ptrUnit->y);
GfxDrawCircle(cb.x + 3, cb.y + 3, UnitGetWidthFromID(ptrUnit->id), GFX_GRAY);
}
else if(ptrUnit->selected == true)
{
TYPE_COLLISION_BLOCK cb;
cb = CameraApplyCoordinatesToCoordinates(ptrCamera, ptrUnit->x, ptrUnit->y);
GfxDrawCircle(cb.x + 3, cb.y + 3, UnitGetWidthFromID(ptrUnit->id), GFX_BLACK);
}
/*char str[2];
snprintf(str, 2, "%u", walk_counter);
GfxPrintText(str, 60, 20);
snprintf(str, 2, "%u", mirror);
GfxPrintText(str, 60, 30);*/
if(++walk_counter > 4)
{
walk_counter = 0;
mirror = mirror ? false : true;
}
}
uint8_t UnitGetWidthFromID(uint8_t id)
{
return GfxGetWidthFromSpriteData(UnitSprTable[id]->Data);
}
uint8_t UnitGetHeightFromID(uint8_t id)
{
return GfxGetHeightFromSpriteData(UnitSprTable[id]->Data);
}
uint8_t UnitGetHpFromID(uint8_t id)
{
return UnitHPTable[id];
}
void UnitMoveTo(TYPE_UNIT * ptrUnit, uint16_t x, uint16_t y)
{
ptrUnit->target_x = x;
ptrUnit->target_y = y;
ptrUnit->walking = true;
}
void UnitHandler(TYPE_UNIT * ptrUnit)
{
bool bMoving = false;
if(ptrUnit->walking == true)
{
if( (ptrUnit->x - UnitSpeedTable[ptrUnit->id]) > ptrUnit->target_x)
{
ptrUnit->x -= UnitSpeedTable[ptrUnit->id];
//ptrUnit->rotation = GFX_ROTCCW;
bMoving = true;
ptrUnit->dir = true;
ptrUnit->mirror = false;
}
else if( (ptrUnit->x + UnitSpeedTable[ptrUnit->id]) < ptrUnit->target_x)
{
ptrUnit->x += UnitSpeedTable[ptrUnit->id];
//ptrUnit->rotation = GFX_ROTCCW;
bMoving = true;
ptrUnit->dir = true;
ptrUnit->mirror = true;
}
if( (ptrUnit->y - UnitSpeedTable[ptrUnit->id]) > ptrUnit->target_y)
{
ptrUnit->y -= UnitSpeedTable[ptrUnit->id];
//ptrUnit->rotation = 0;
bMoving = true;
ptrUnit->dir = false;
ptrUnit->mirror = false;
}
else if( (ptrUnit->y + UnitSpeedTable[ptrUnit->id]) < ptrUnit->target_y)
{
ptrUnit->y += UnitSpeedTable[ptrUnit->id];
//ptrUnit->rotation = 0;
bMoving = true;
ptrUnit->dir = false;
ptrUnit->mirror = true;
}
if(bMoving == false)
{
ptrUnit->walking = false;
}
}
}
const char* UnitSelectedOptions(TYPE_UNIT* ptrUnit)
{
const TYPE_UNIT_ACTION* tUnitAction = NULL;
switch(menuLevel)
{
case 0:
tUnitAction = &UnitActionsTable_Level0[ptrUnit->id];
break;
case 1:
tUnitAction = &UnitActionsTable_Level1[ptrUnit->id];
break;
default:
return NULL;
break;
}
return tUnitAction->str;
}
void UnitAcceptAction(TYPE_UNIT* ptrUnit)
{
const TYPE_UNIT_ACTION* tUnitAction = NULL;
switch(menuLevel)
{
case 0:
tUnitAction = &UnitActionsTable_Level0[ptrUnit->id];
break;
case 1:
tUnitAction = &UnitActionsTable_Level1[ptrUnit->id];
break;
default:
return NULL;
break;
}
if(tUnitAction->pAction == NULL)
{
UnitIncreaseMenuLevel();
}
else
{
tUnitAction->pAction(ptrUnit);
}
}
void UnitIncreaseMenuLevel(void)
{
if(menuLevel < 1)
{
menuLevel++;
}
}
void UnitBuildAccept(TYPE_UNIT* ptrUnit)
{
}
void UnitResetMenuLevel(void)
{
menuLevel = 0;
}

50
Unit.h Normal file
View File

@ -0,0 +1,50 @@
#ifndef __UNIT_HEADER__
#define __UNIT_HEADER__
/* **************************************
* Includes *
* **************************************/
#include "Global_Inc.h"
#include "Gfx.h"
#include "GameStructures.h"
#include "Camera.h"
#ifdef __cplusplus
extern "C"
{
#endif //__cplusplus
/* **************************************
* Defines *
* **************************************/
/* **************************************
* Structs and enums *
* **************************************/
enum
{
PEASANT = 0
};
/* **************************************
* Global prototypes *
* **************************************/
void UnitInit(void);
uint8_t UnitGetHpFromID(uint8_t id);
uint8_t UnitGetWidthFromID(uint8_t id);
uint8_t UnitGetHeightFromID(uint8_t id);
void UnitDraw(TYPE_CAMERA * ptrCamera, TYPE_UNIT * ptrUnit, bool bSelected);
const char* UnitSelectedOptions(TYPE_UNIT* ptrUnit);
void UnitMoveTo(TYPE_UNIT * ptrUnit, uint16_t x, uint16_t y);
void UnitHandler(TYPE_UNIT * ptrUnit);
void UnitAcceptAction(TYPE_UNIT* ptrUnit);
void UnitResetMenuLevel(void);
#ifdef __cplusplus
}
#endif //__cplusplus
#endif //__UNIT_HEADER__