Mahtan/wagic
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

J :

Browse Source 
* Remove ^M's.
* Re-indent automatically.
* Remove whitespace at the end of lines.
This commit is contained in:
jean.chalard
2008-11-12 13:45:42 +00:00
parent 6ad6f9b668
commit c97dd1f260
116 changed files with 18073 additions and 18073 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1248
projects/mtg/src/AIPlayer.cpp
View File

File diff suppressed because it is too large Load Diff

252
projects/mtg/src/AIStats.cpp
View File

@@ -1,129 +1,129 @@
#include "../include/debug.h"
#include "../include/AIStats.h"
#include "../include/GameObserver.h"
#include "../include/Player.h"
#include "../include/MTGCardInstance.h"
bool compare_aistats(AIStat * first, AIStat * second){
float damage1 = first->value / first->occurences;
float damage2 = second->value/ second->occurences;
return (damage1 > damage2);
}
AIStats::AIStats(Player * _player, char * _filename){
filename = _filename;
load(_filename);
player = _player;
}
AIStats::~AIStats(){
list<AIStat *>::iterator it;
for ( it=stats.begin() ; it != stats.end(); it++ ){
AIStat * stat = *it;
delete stat;
}
}
void AIStats::updateStatsCard(MTGCardInstance * cardInstance, Damage * damage, float multiplier){
MTGCard * card = cardInstance->model;
AIStat * stat = find(card);
if (!stat){
stat = NEW AIStat(card->getMTGId(),0,1,0);
stats.push_back(stat);
}
if (damage->target == player){
stat->value+= multiplier * STATS_PLAYER_MULTIPLIER * damage->damage;
}else if (damage->target->type_as_damageable == DAMAGEABLE_MTGCARDINSTANCE){
MTGCardInstance * target = (MTGCardInstance *)damage->target;
if (target->controller() == player && !target->isInPlay()){
//One of my creatures got lethal damage...
stat->value+= multiplier * STATS_CREATURE_MULTIPLIER * damage->damage;
}
}
}
void AIStats::updateStats(){
GameObserver * game = GameObserver::GetInstance();
ActionStack * as = game->mLayers->stackLayer();
Damage * damage = ((Damage * )as->getNext(NULL,ACTION_DAMAGE, RESOLVED_OK));
MTGGameZone * opponentZone = player->opponent()->game->inPlay;
while(damage){
MTGCardInstance * card = damage->source;
updateStatsCard(card,damage);
//Auras on damage source can be the cause
for (int i=0; i < opponentZone->nb_cards; i++){
MTGCardInstance * aura = opponentZone->cards[i];
if (aura->target == card){
updateStatsCard(aura,damage, STATS_AURA_MULTIPLIER);
}
}
damage = ((Damage * )as->getNext(damage,ACTION_DAMAGE, RESOLVED_OK));
}
stats.sort(compare_aistats);
save();
}
bool AIStats::isInTop(MTGCardInstance * card, unsigned int max, bool tooSmallCountsForTrue ){
if (stats.size()<max) return tooSmallCountsForTrue;
unsigned int n = 0;
MTGCard * source = card->model;
int id = source->getMTGId();
list<AIStat *>::iterator it;
for ( it=stats.begin() ; it != stats.end(); it++ ){
if (n >= max) return false;
AIStat * stat = *it;
if (stat->source == id){
if (stat->value>=0) return true;
return false;
}
n++;
}
return false;
}
AIStat * AIStats::find(MTGCard * source){
int id = source->getMTGId();
list<AIStat *>::iterator it;
for ( it=stats.begin() ; it != stats.end(); it++ ){
AIStat * stat = *it;
if (stat->source == id) return stat;
}
return NULL;
}
void AIStats::load(char * filename){
std::ifstream file(filename);
#include "../include/debug.h"
#include "../include/AIStats.h"
#include "../include/GameObserver.h"
#include "../include/Player.h"
#include "../include/MTGCardInstance.h"
bool compare_aistats(AIStat * first, AIStat * second){
float damage1 = first->value / first->occurences;
float damage2 = second->value/ second->occurences;
return (damage1 > damage2);
}
AIStats::AIStats(Player * _player, char * _filename){
filename = _filename;
load(_filename);
player = _player;
}
AIStats::~AIStats(){
list<AIStat *>::iterator it;
for ( it=stats.begin() ; it != stats.end(); it++ ){
AIStat * stat = *it;
delete stat;
}
}
void AIStats::updateStatsCard(MTGCardInstance * cardInstance, Damage * damage, float multiplier){
MTGCard * card = cardInstance->model;
AIStat * stat = find(card);
if (!stat){
stat = NEW AIStat(card->getMTGId(),0,1,0);
stats.push_back(stat);
}
if (damage->target == player){
stat->value+= multiplier * STATS_PLAYER_MULTIPLIER * damage->damage;
}else if (damage->target->type_as_damageable == DAMAGEABLE_MTGCARDINSTANCE){
MTGCardInstance * target = (MTGCardInstance *)damage->target;
if (target->controller() == player && !target->isInPlay()){
//One of my creatures got lethal damage...
stat->value+= multiplier * STATS_CREATURE_MULTIPLIER * damage->damage;
}
}
}
void AIStats::updateStats(){
GameObserver * game = GameObserver::GetInstance();
ActionStack * as = game->mLayers->stackLayer();
Damage * damage = ((Damage * )as->getNext(NULL,ACTION_DAMAGE, RESOLVED_OK));
MTGGameZone * opponentZone = player->opponent()->game->inPlay;
while(damage){
MTGCardInstance * card = damage->source;
updateStatsCard(card,damage);
//Auras on damage source can be the cause
for (int i=0; i < opponentZone->nb_cards; i++){
MTGCardInstance * aura = opponentZone->cards[i];
if (aura->target == card){
updateStatsCard(aura,damage, STATS_AURA_MULTIPLIER);
}
}
damage = ((Damage * )as->getNext(damage,ACTION_DAMAGE, RESOLVED_OK));
}
stats.sort(compare_aistats);
save();
}
bool AIStats::isInTop(MTGCardInstance * card, unsigned int max, bool tooSmallCountsForTrue ){
if (stats.size()<max) return tooSmallCountsForTrue;
unsigned int n = 0;
MTGCard * source = card->model;
int id = source->getMTGId();
list<AIStat *>::iterator it;
for ( it=stats.begin() ; it != stats.end(); it++ ){
if (n >= max) return false;
AIStat * stat = *it;
if (stat->source == id){
if (stat->value>=0) return true;
return false;
}
n++;
}
return false;
}
AIStat * AIStats::find(MTGCard * source){
int id = source->getMTGId();
list<AIStat *>::iterator it;
for ( it=stats.begin() ; it != stats.end(); it++ ){
AIStat * stat = *it;
if (stat->source == id) return stat;
}
return NULL;
}
void AIStats::load(char * filename){
std::ifstream file(filename);
std::string s;
if(file){
while(std::getline(file,s)){
int cardid = atoi(s.c_str());
std::getline(file,s);
int value = atoi(s.c_str());
std::getline(file,s);
int direct = atoi(s.c_str());
AIStat * stat = NEW AIStat(cardid,value,1,direct);
stats.push_back(stat);
}
file.close();
}else{
//TODO Error management
}
}
void AIStats::save(){
std::ofstream file(filename.c_str());
char writer[128];
if (file){
list<AIStat *>::iterator it;
for ( it=stats.begin() ; it != stats.end(); it++ ){
AIStat * stat = *it;
if (stat->value > 0){
sprintf(writer,"%i\n%i\n%i\n", stat->source,stat->value/2,stat->direct);
file<<writer;
}
}
file.close();
}
if(file){
while(std::getline(file,s)){
int cardid = atoi(s.c_str());
std::getline(file,s);
int value = atoi(s.c_str());
std::getline(file,s);
int direct = atoi(s.c_str());
AIStat * stat = NEW AIStat(cardid,value,1,direct);
stats.push_back(stat);
}
file.close();
}else{
//TODO Error management
}
}
void AIStats::save(){
std::ofstream file(filename.c_str());
char writer[128];
if (file){
list<AIStat *>::iterator it;
for ( it=stats.begin() ; it != stats.end(); it++ ){
AIStat * stat = *it;
if (stat->value > 0){
sprintf(writer,"%i\n%i\n%i\n", stat->source,stat->value/2,stat->direct);
file<<writer;
}
}
file.close();
}
}

56
projects/mtg/src/ActionElement.cpp
View File

@@ -4,52 +4,52 @@
#include "../include/TargetChooser.h"
ActionElement::ActionElement(int id):JGuiObject(id){
activeState = INACTIVE;
modal = 0;
waitingForAnswer = 0;
currentPhase = -1;
newPhase = -1;
tc = NULL;
activeState = INACTIVE;
modal = 0;
waitingForAnswer = 0;
currentPhase = -1;
newPhase = -1;
tc = NULL;
}
/*
void ActionElement::RenderMessageBackground(float y0, int _height){
float height = _height;
PIXEL_TYPE colors_up[] =
{
ARGB(0,255,255,255),
ARGB(0,255,255,255),
ARGB(128,255,255,255),
ARGB(128,255,255,255)
};
void ActionElement::RenderMessageBackground(float y0, int _height){
float height = _height;
PIXEL_TYPE colors_up[] =
{
ARGB(0,255,255,255),
ARGB(0,255,255,255),
ARGB(128,255,255,255),
ARGB(128,255,255,255)
};
PIXEL_TYPE colors_down[] =
{
ARGB(128,255,255,255),
ARGB(128,255,255,255),
ARGB(0,255,255,255),
ARGB(0,255,255,255)
};
{
ARGB(128,255,255,255),
ARGB(128,255,255,255),
ARGB(0,255,255,255),
ARGB(0,255,255,255)
};
JRenderer * renderer = JRenderer::GetInstance();
renderer->FillRect(0,y0,SCREEN_WIDTH,height/2,colors_up);
renderer->FillRect(0,y0+height/2,SCREEN_WIDTH,height/2,colors_down);
// mEngine->DrawLine(0,y0,SCREEN_WIDTH,y0,ARGB(128,255,255,255));
// mEngine->DrawLine(0,y0+height,SCREEN_WIDTH,y0+height,ARGB(128,255,255,255));
}*/
}*/
int ActionElement::getActivity(){
return activeState;
return activeState;
}
int ActionElement::isReactingToTargetClick(Targetable * object){
if (object && object->typeAsTarget() == TARGET_CARD) return isReactingToClick((MTGCardInstance *)object);
return 0;
if (object && object->typeAsTarget() == TARGET_CARD) return isReactingToClick((MTGCardInstance *)object);
return 0;
}
int ActionElement::reactToTargetClick(Targetable * object){
if (object->typeAsTarget() == TARGET_CARD) return reactToClick((MTGCardInstance *)object);
return 0;
}
if (object->typeAsTarget() == TARGET_CARD) return reactToClick((MTGCardInstance *)object);
return 0;
}

268
projects/mtg/src/ActionLayer.cpp
View File

@@ -5,195 +5,195 @@
int ActionLayer::unstopableRenderInProgress(){
for (int i=0;i<mCount;i++){
if (mObjects[i]!=NULL){
ActionElement * currentAction = (ActionElement *)mObjects[i];
if (currentAction->getActivity() > 0){
return 1;
}
}
}
return 0;
for (int i=0;i<mCount;i++){
if (mObjects[i]!=NULL){
ActionElement * currentAction = (ActionElement *)mObjects[i];
if (currentAction->getActivity() > 0){
return 1;
}
}
}
return 0;
}
void ActionLayer::CheckUserInput(float dt){
if (menuObject){
abilitiesMenu->Update(dt);
return;
}
for (int i=0;i<mCount;i++){
if (mObjects[i]!=NULL){
ActionElement * currentAction = (ActionElement *)mObjects[i];
currentAction->CheckUserInput(dt);
}
}
if (menuObject){
abilitiesMenu->Update(dt);
return;
}
for (int i=0;i<mCount;i++){
if (mObjects[i]!=NULL){
ActionElement * currentAction = (ActionElement *)mObjects[i];
currentAction->CheckUserInput(dt);
}
}
}
void ActionLayer::Update(float dt){
if (menuObject){
return;
}
modal = 0;
for (int i=mCount -1 ;i>=0;i--){
if (mObjects[i]!= NULL){
ActionElement * currentAction = (ActionElement *)mObjects[i];
if (currentAction->testDestroy()){
currentAction->destroy();
Remove(currentAction);
}
}
}
int newPhase = GameObserver::GetInstance()->getCurrentGamePhase();
for (int i=0;i<mCount;i++){
if (mObjects[i]!=NULL){
ActionElement * currentAction = (ActionElement *)mObjects[i];
currentAction->newPhase = newPhase;
currentAction->Update(dt);
currentAction->currentPhase = newPhase;
}
}
if (menuObject){
return;
}
modal = 0;
for (int i=mCount -1 ;i>=0;i--){
if (mObjects[i]!= NULL){
ActionElement * currentAction = (ActionElement *)mObjects[i];
if (currentAction->testDestroy()){
currentAction->destroy();
Remove(currentAction);
}
}
}
int newPhase = GameObserver::GetInstance()->getCurrentGamePhase();
for (int i=0;i<mCount;i++){
if (mObjects[i]!=NULL){
ActionElement * currentAction = (ActionElement *)mObjects[i];
currentAction->newPhase = newPhase;
currentAction->Update(dt);
currentAction->currentPhase = newPhase;
}
}
}
void ActionLayer::Render (){
if (menuObject){
abilitiesMenu->Render();
return;
}
for (int i=0;i<mCount;i++){
if (mObjects[i]!=NULL){
ActionElement * currentAction = (ActionElement *)mObjects[i];
//if (currentAction->getActivity() > 0){
currentAction->Render();
//return;
//}
}
}
if (menuObject){
abilitiesMenu->Render();
return;
}
for (int i=0;i<mCount;i++){
if (mObjects[i]!=NULL){
ActionElement * currentAction = (ActionElement *)mObjects[i];
//if (currentAction->getActivity() > 0){
currentAction->Render();
//return;
//}
}
}
}
TargetChooser * ActionLayer::getCurrentTargetChooser(){
for (int i=0;i<mCount;i++){
ActionElement * currentAction = (ActionElement *)mObjects[i];
if(currentAction->waitingForAnswer) return currentAction->tc;
}
return NULL;
for (int i=0;i<mCount;i++){
ActionElement * currentAction = (ActionElement *)mObjects[i];
if(currentAction->waitingForAnswer) return currentAction->tc;
}
return NULL;
}
int ActionLayer::isWaitingForAnswer(){
for (int i=0;i<mCount;i++){
ActionElement * currentAction = (ActionElement *)mObjects[i];
if(currentAction->waitingForAnswer) return 1;
}
return 0;
for (int i=0;i<mCount;i++){
ActionElement * currentAction = (ActionElement *)mObjects[i];
if(currentAction->waitingForAnswer) return 1;
}
return 0;
}
int ActionLayer::isReactingToTargetClick(Targetable * card){
int result = 0;
int result = 0;
if (isWaitingForAnswer()) return -1;
if (isWaitingForAnswer()) return -1;
for (int i=0;i<mCount;i++){
ActionElement * currentAction = (ActionElement *)mObjects[i];
result += currentAction->isReactingToTargetClick(card);
}
return result;
for (int i=0;i<mCount;i++){
ActionElement * currentAction = (ActionElement *)mObjects[i];
result += currentAction->isReactingToTargetClick(card);
}
return result;
}
int ActionLayer::reactToTargetClick(Targetable * card){
int result = 0;
int result = 0;
for (int i=0;i<mCount;i++){
ActionElement * currentAction = (ActionElement *)mObjects[i];
if(currentAction->waitingForAnswer){
return currentAction->reactToTargetClick(card);
}
}
for (int i=0;i<mCount;i++){
ActionElement * currentAction = (ActionElement *)mObjects[i];
if(currentAction->waitingForAnswer){
return currentAction->reactToTargetClick(card);
}
}
for (int i=0;i<mCount;i++){
ActionElement * currentAction = (ActionElement *)mObjects[i];
result += currentAction->reactToTargetClick(card);
}
return result;
for (int i=0;i<mCount;i++){
ActionElement * currentAction = (ActionElement *)mObjects[i];
result += currentAction->reactToTargetClick(card);
}
return result;
}
//TODO Simplify with only object !!!
int ActionLayer::isReactingToClick(MTGCardInstance * card){
int result = 0;
int result = 0;
for (int i=0;i<mCount;i++){
ActionElement * currentAction = (ActionElement *)mObjects[i];
if(currentAction->waitingForAnswer) return -1;
}
for (int i=0;i<mCount;i++){
ActionElement * currentAction = (ActionElement *)mObjects[i];
if(currentAction->waitingForAnswer) return -1;
}
for (int i=0;i<mCount;i++){
ActionElement * currentAction = (ActionElement *)mObjects[i];
result += currentAction->isReactingToClick(card);
}
for (int i=0;i<mCount;i++){
ActionElement * currentAction = (ActionElement *)mObjects[i];
result += currentAction->isReactingToClick(card);
}
return result;
return result;
}
int ActionLayer::reactToClick(MTGCardInstance * card){
int result = 0;
int result = 0;
for (int i=0;i<mCount;i++){
ActionElement * currentAction = (ActionElement *)mObjects[i];
if(currentAction->waitingForAnswer){
return currentAction->reactToClick(card);
}
}
for (int i=0;i<mCount;i++){
ActionElement * currentAction = (ActionElement *)mObjects[i];
if(currentAction->waitingForAnswer){
return currentAction->reactToClick(card);
}
}
for (int i=0;i<mCount;i++){
ActionElement * currentAction = (ActionElement *)mObjects[i];
result += currentAction->reactToClick(card);
}
return result;
for (int i=0;i<mCount;i++){
ActionElement * currentAction = (ActionElement *)mObjects[i];
result += currentAction->reactToClick(card);
}
return result;
}
int ActionLayer::isModal(){
if (modal) return 1;
if (menuObject) return 1;
for (int i=0; i<mCount; i++){
ActionElement * currentAction = (ActionElement *)mObjects[i];
if (currentAction->modal) return 1;
}
return 0;
if (modal) return 1;
if (menuObject) return 1;
for (int i=0; i<mCount; i++){
ActionElement * currentAction = (ActionElement *)mObjects[i];
if (currentAction->modal) return 1;
}
return 0;
}
void ActionLayer::setMenuObject(Targetable * object){
menuObject = object;
if (abilitiesMenu){
delete abilitiesMenu;
}
JLBFont * mFont = GameApp::CommonRes->GetJLBFont(MAIN_FONT);
abilitiesMenu = NEW SimpleMenu(10, this, mFont, 100, 100, 200);
for (int i=0;i<mCount;i++){
ActionElement * currentAction = (ActionElement *)mObjects[i];
if (currentAction->isReactingToTargetClick(object)){
abilitiesMenu->Add(i,currentAction->getMenuText());
}
}
abilitiesMenu->Add(-1, "Cancel");
modal = 1;
menuObject = object;
if (abilitiesMenu){
delete abilitiesMenu;
}
JLBFont * mFont = GameApp::CommonRes->GetJLBFont(MAIN_FONT);
abilitiesMenu = NEW SimpleMenu(10, this, mFont, 100, 100, 200);
for (int i=0;i<mCount;i++){
ActionElement * currentAction = (ActionElement *)mObjects[i];
if (currentAction->isReactingToTargetClick(object)){
abilitiesMenu->Add(i,currentAction->getMenuText());
}
}
abilitiesMenu->Add(-1, "Cancel");
modal = 1;
}
void ActionLayer::ButtonPressed(int controllerid, int controlid){
if (controlid == -1){
if (controlid == -1){
}else{
ActionElement * currentAction = (ActionElement *)mObjects[controlid];
currentAction->reactToTargetClick(menuObject);
}
menuObject = 0;
}else{
ActionElement * currentAction = (ActionElement *)mObjects[controlid];
currentAction->reactToTargetClick(menuObject);
}
menuObject = 0;
}
}

1380
projects/mtg/src/ActionStack.cpp
View File

File diff suppressed because it is too large Load Diff

234
projects/mtg/src/Blocker.cpp
View File

@@ -1,117 +1,117 @@
#include "../include/debug.h"
#include "../include/Blocker.h"
Blocker::Blocker(int id, MTGCardInstance * card):MTGAbility(id, card){
init ( NEW ManaCost());
}
Blocker::Blocker(int id, MTGCardInstance * card, ManaCost * _cost):MTGAbility(id, card){
init(_cost);
}
Blocker::Blocker(int id, MTGCardInstance * card, MTGCardInstance *_target, ManaCost * _cost):MTGAbility(id, card,_target){
init(_cost);
}
Blocker::~Blocker(){
delete manaCost;
}
void Blocker::init(ManaCost * _cost){
currentPhase = -1;
manaCost = _cost;
}
//Default behaviour for blockers : they block the card they're attached to
void Blocker::Update(float dt){
game = GameObserver::GetInstance();
int newPhase = game->getCurrentGamePhase();
if (newPhase != currentPhase){
MTGCardInstance * _target;
if (target){
_target = (MTGCardInstance *) target;
}else{
_target = source;
}
_target->getBlockers()->Add(this);
#if defined (WIN32) || defined (LINUX)
char buf[4096];
sprintf(buf, "Adding Blocker to %s \n", _target->model->getName());
OutputDebugString(buf);
#endif
}
currentPhase = newPhase;
}
int Blocker::destroy(){
MTGCardInstance * _target;
if (target){
_target = (MTGCardInstance *) target;
}else{
_target = source;
}
_target->getBlockers()->Remove(this);
return 1;
}
Blockers::Blockers(){
init();
}
int Blockers::init(){
cursor = -1;
for (int i=0; i< MAX_BLOCKERS ; i++){
blockers[i] = 0;
}
return 1;
}
int Blockers::Add (Blocker * ability){
game = GameObserver::GetInstance();
int index = game->mLayers->actionLayer()->getIndexOf(ability);
blockers[index] = 1;
return index;
}
int Blockers::Remove (Blocker * ability){
game = GameObserver::GetInstance();
int index = game->mLayers->actionLayer()->getIndexOf(ability);
blockers[index] = 0;
return index;
}
int Blockers::rewind(){
cursor = -1;
return 1;
}
Blocker * Blockers::next(){
cursor++;
game = GameObserver::GetInstance();
while (blockers[cursor] == 0){
cursor ++;
if (cursor == MAX_BLOCKERS){
cursor = -1;
return NULL;
}
}
return (Blocker *) (game->mLayers->actionLayer()->getByIndex(cursor));
}
int Blockers::isEmpty(){
for (int i=0; i< MAX_BLOCKERS ; i++){
if (blockers[i])
return 0;
}
return 1;
}
Blockers::~Blockers(){
}
#include "../include/debug.h"
#include "../include/Blocker.h"
Blocker::Blocker(int id, MTGCardInstance * card):MTGAbility(id, card){
init ( NEW ManaCost());
}
Blocker::Blocker(int id, MTGCardInstance * card, ManaCost * _cost):MTGAbility(id, card){
init(_cost);
}
Blocker::Blocker(int id, MTGCardInstance * card, MTGCardInstance *_target, ManaCost * _cost):MTGAbility(id, card,_target){
init(_cost);
}
Blocker::~Blocker(){
delete manaCost;
}
void Blocker::init(ManaCost * _cost){
currentPhase = -1;
manaCost = _cost;
}
//Default behaviour for blockers : they block the card they're attached to
void Blocker::Update(float dt){
game = GameObserver::GetInstance();
int newPhase = game->getCurrentGamePhase();
if (newPhase != currentPhase){
MTGCardInstance * _target;
if (target){
_target = (MTGCardInstance *) target;
}else{
_target = source;
}
_target->getBlockers()->Add(this);
#if defined (WIN32) || defined (LINUX)
char buf[4096];
sprintf(buf, "Adding Blocker to %s \n", _target->model->getName());
OutputDebugString(buf);
#endif
}
currentPhase = newPhase;
}
int Blocker::destroy(){
MTGCardInstance * _target;
if (target){
_target = (MTGCardInstance *) target;
}else{
_target = source;
}
_target->getBlockers()->Remove(this);
return 1;
}
Blockers::Blockers(){
init();
}
int Blockers::init(){
cursor = -1;
for (int i=0; i< MAX_BLOCKERS ; i++){
blockers[i] = 0;
}
return 1;
}
int Blockers::Add (Blocker * ability){
game = GameObserver::GetInstance();
int index = game->mLayers->actionLayer()->getIndexOf(ability);
blockers[index] = 1;
return index;
}
int Blockers::Remove (Blocker * ability){
game = GameObserver::GetInstance();
int index = game->mLayers->actionLayer()->getIndexOf(ability);
blockers[index] = 0;
return index;
}
int Blockers::rewind(){
cursor = -1;
return 1;
}
Blocker * Blockers::next(){
cursor++;
game = GameObserver::GetInstance();
while (blockers[cursor] == 0){
cursor ++;
if (cursor == MAX_BLOCKERS){
cursor = -1;
return NULL;
}
}
return (Blocker *) (game->mLayers->actionLayer()->getByIndex(cursor));
}
int Blockers::isEmpty(){
for (int i=0; i< MAX_BLOCKERS ; i++){
if (blockers[i])
return 0;
}
return 1;
}
Blockers::~Blockers(){
}

262
projects/mtg/src/CardDescriptor.cpp
View File

@@ -1,131 +1,131 @@
#include "../include/debug.h"
#include "../include/CardDescriptor.h"
CardDescriptor::CardDescriptor(): MTGCardInstance(){
init();
mode = CD_AND;
}
int CardDescriptor::init(){
return MTGCardInstance::init();
}
MTGCardInstance * CardDescriptor::match_or(MTGCardInstance * card){
int found = 1;
for (int i = 0; i< nb_types; i++){
found = 0;
if (card->hasSubtype(types[i])){
found = 1;
break;
}
}
if (!found) return NULL;
for (int i = 0; i< MTG_NB_COLORS; i++){
found = 0;
if (colors[i] == 1 && card->hasColor(i)){
found = 1;
break;
}
}
if (!found) return NULL;
return card;
}
MTGCardInstance * CardDescriptor::match_and(MTGCardInstance * card){
#ifdef WIN32
OutputDebugString("Match AND\n");
#endif
MTGCardInstance * match = card;
for (int i = 0; i< nb_types; i++){
if (!card->hasSubtype(types[i])){
#ifdef WIN32
OutputDebugString(card->name.c_str());
OutputDebugString("Subtype No Match\n");
#endif
match = NULL;
}
}
for (int i = 0; i< MTG_NB_COLORS; i++){
if ((colors[i] == 1 && !card->hasColor(i))||(colors[i] == -1 && card->hasColor(i))){
match = NULL;
#ifdef WIN32
OutputDebugString(card->name.c_str());
OutputDebugString("Color No Match\n");
#endif
}
}
return match;
}
MTGCardInstance * CardDescriptor::match(MTGCardInstance * card){
MTGCardInstance * match = card;
if (mode == CD_AND){
match = match_and(card);
}else{
match=match_or(card);
}
//Abilities
for (int j = 0; j < NB_BASIC_ABILITIES; j++){
if ((basicAbilities[j] == 1 && !card->basicAbilities[j]) || (basicAbilities[j] == -1 && card->basicAbilities[j])){
match = NULL;
}
}
if ((tapped == -1 && card->isTapped()) || (tapped == 1 && !card->isTapped())){
match = NULL;
}
if (attacker == 1){
if ((int)defenser == 1){
if (!card->attacker && !card->defenser) match = NULL;
}else{
if (!card->attacker) match = NULL;
}
}else if (attacker == -1){
if ((int)defenser == -1){
if (card->attacker || card->defenser) match = NULL;
}else{
if (card->attacker) match = NULL;
}
}else{
if ((int)defenser == -1){
if (card->defenser) match = NULL;
}else if ((int)defenser == 1){
if (!card->defenser) match = NULL;
}else{
// we don't care about the attack/blocker state
}
}
return match;
}
MTGCardInstance * CardDescriptor::match(MTGGameZone * zone){
return (nextmatch(zone, NULL));
}
MTGCardInstance * CardDescriptor::nextmatch(MTGGameZone * zone, MTGCardInstance * previous){
int found = 0;
if (NULL == previous) found = 1;
for(int i=0; i < zone->nb_cards; i++){
if(found && match(zone->cards[i])){
#if defined (WIN32) || defined (LINUX)
char buf[4096];
sprintf(buf,"Card Descriptor MATCH!: %s \n" ,(zone->cards[i])->getName());
OutputDebugString(buf);
#endif
return zone->cards[i];
}
if (zone->cards[i] == previous){
found = 1;
}
}
return NULL;
}
#include "../include/debug.h"
#include "../include/CardDescriptor.h"
CardDescriptor::CardDescriptor(): MTGCardInstance(){
init();
mode = CD_AND;
}
int CardDescriptor::init(){
return MTGCardInstance::init();
}
MTGCardInstance * CardDescriptor::match_or(MTGCardInstance * card){
int found = 1;
for (int i = 0; i< nb_types; i++){
found = 0;
if (card->hasSubtype(types[i])){
found = 1;
break;
}
}
if (!found) return NULL;
for (int i = 0; i< MTG_NB_COLORS; i++){
found = 0;
if (colors[i] == 1 && card->hasColor(i)){
found = 1;
break;
}
}
if (!found) return NULL;
return card;
}
MTGCardInstance * CardDescriptor::match_and(MTGCardInstance * card){
#ifdef WIN32
OutputDebugString("Match AND\n");
#endif
MTGCardInstance * match = card;
for (int i = 0; i< nb_types; i++){
if (!card->hasSubtype(types[i])){
#ifdef WIN32
OutputDebugString(card->name.c_str());
OutputDebugString("Subtype No Match\n");
#endif
match = NULL;
}
}
for (int i = 0; i< MTG_NB_COLORS; i++){
if ((colors[i] == 1 && !card->hasColor(i))||(colors[i] == -1 && card->hasColor(i))){
match = NULL;
#ifdef WIN32
OutputDebugString(card->name.c_str());
OutputDebugString("Color No Match\n");
#endif
}
}
return match;
}
MTGCardInstance * CardDescriptor::match(MTGCardInstance * card){
MTGCardInstance * match = card;
if (mode == CD_AND){
match = match_and(card);
}else{
match=match_or(card);
}
//Abilities
for (int j = 0; j < NB_BASIC_ABILITIES; j++){
if ((basicAbilities[j] == 1 && !card->basicAbilities[j]) || (basicAbilities[j] == -1 && card->basicAbilities[j])){
match = NULL;
}
}
if ((tapped == -1 && card->isTapped()) || (tapped == 1 && !card->isTapped())){
match = NULL;
}
if (attacker == 1){
if ((int)defenser == 1){
if (!card->attacker && !card->defenser) match = NULL;
}else{
if (!card->attacker) match = NULL;
}
}else if (attacker == -1){
if ((int)defenser == -1){
if (card->attacker || card->defenser) match = NULL;
}else{
if (card->attacker) match = NULL;
}
}else{
if ((int)defenser == -1){
if (card->defenser) match = NULL;
}else if ((int)defenser == 1){
if (!card->defenser) match = NULL;
}else{
// we don't care about the attack/blocker state
}
}
return match;
}
MTGCardInstance * CardDescriptor::match(MTGGameZone * zone){
return (nextmatch(zone, NULL));
}
MTGCardInstance * CardDescriptor::nextmatch(MTGGameZone * zone, MTGCardInstance * previous){
int found = 0;
if (NULL == previous) found = 1;
for(int i=0; i < zone->nb_cards; i++){
if(found && match(zone->cards[i])){
#if defined (WIN32) || defined (LINUX)
char buf[4096];
sprintf(buf,"Card Descriptor MATCH!: %s \n" ,(zone->cards[i])->getName());
OutputDebugString(buf);
#endif
return zone->cards[i];
}
if (zone->cards[i] == previous){
found = 1;
}
}
return NULL;
}

304
projects/mtg/src/CardDisplay.cpp
View File

@@ -1,156 +1,156 @@
#include "../include/debug.h"
#include "../include/CardDisplay.h"
#include "../include/CardGui.h"
#include "../include/TargetChooser.h"
#include "../include/MTGGameZones.h"
CardDisplay::CardDisplay():PlayGuiObjectController(0, GameObserver::GetInstance()){
tc= NULL;
listener = NULL;
nb_displayed_items = 7;
start_item = 0;
x= 0;
y= 0;
}
CardDisplay::CardDisplay(int id, GameObserver* _game, int _x, int _y, JGuiListener * _listener, TargetChooser * _tc, int _nb_displayed_items ):PlayGuiObjectController(id, _game), x(_x), y(_y){
tc= _tc;
listener = _listener;
nb_displayed_items = _nb_displayed_items;
start_item = 0;
}
void CardDisplay::AddCard(MTGCardInstance * _card){
CardGui * card = NEW CardGui(mCount, _card, 40, x + 5 + (mCount - start_item) * 30, y + 5, (mCount == 0));
Add(card);
}
void CardDisplay::init(MTGGameZone * zone){
resetObjects();
start_item = 0;
for (int i= 0; i< zone->nb_cards; i++){
AddCard(zone->cards[i]);
}
}
void CardDisplay::rotateLeft(){
if (start_item==0) return;
for (int i= 0; i<mCount; i++){
CardGui * cardg = (CardGui *)mObjects[i];
cardg->x+=30;
}
start_item --;
}
void CardDisplay::rotateRight(){
if (start_item==mCount-1) return;
for (int i= 0; i<mCount; i++){
CardGui * cardg = (CardGui *)mObjects[i];
cardg->x-=30;
}
start_item ++;
}
void CardDisplay::CheckUserInput(float dt){
if (mEngine->GetButtonClick(PSP_CTRL_CROSS))
{
if (listener != NULL)
{
listener->ButtonPressed(mId, 0);
return;
}
}
if (!mCount)
return;
#include "../include/debug.h"
#include "../include/CardDisplay.h"
#include "../include/CardGui.h"
#include "../include/TargetChooser.h"
#include "../include/MTGGameZones.h"
if (mEngine->GetButtonClick(mActionButton))
{
if (mObjects[mCurr] && mObjects[mCurr]->ButtonPressed()){
CardGui * cardg = (CardGui *)mObjects[mCurr];
if (tc)
{
tc->toggleTarget(cardg->card);
return;
}else{
if (game) game->ButtonPressed(mId, cardg);
return;
}
}
}
CardDisplay::CardDisplay():PlayGuiObjectController(0, GameObserver::GetInstance()){
tc= NULL;
listener = NULL;
nb_displayed_items = 7;
start_item = 0;
x= 0;
y= 0;
}
if (mEngine->GetButtonState(PSP_CTRL_LEFT))
{
if (KeyRepeated(PSP_CTRL_LEFT, dt))
{
int n = mCurr;
n--;
if (n<start_item){
if (n< 0){n = 0;}
else{ rotateLeft();}
}
if (n != mCurr && mObjects[mCurr] != NULL && mObjects[mCurr]->Leaving(PSP_CTRL_LEFT)){
mCurr = n;
mObjects[mCurr]->Entering();
}
}
}
else if (mEngine->GetButtonState(PSP_CTRL_RIGHT))
{
if (KeyRepeated(PSP_CTRL_RIGHT, dt))
{
int n = mCurr;
n++;
if (n>= mCount){n = mCount-1;}
if (n>= start_item + nb_displayed_items){
rotateRight();
}
if (n != mCurr && mObjects[mCurr] != NULL && mObjects[mCurr]->Leaving(PSP_CTRL_RIGHT)){
mCurr = n;
mObjects[mCurr]->Entering();
}
}
}
CardDisplay::CardDisplay(int id, GameObserver* _game, int _x, int _y, JGuiListener * _listener, TargetChooser * _tc, int _nb_displayed_items ):PlayGuiObjectController(id, _game), x(_x), y(_y){
tc= _tc;
listener = _listener;
nb_displayed_items = _nb_displayed_items;
start_item = 0;
}
else{
mLastKey = 0;
void CardDisplay::AddCard(MTGCardInstance * _card){
CardGui * card = NEW CardGui(mCount, _card, 40, x + 5 + (mCount - start_item) * 30, y + 5, (mCount == 0));
Add(card);
}
void CardDisplay::init(MTGGameZone * zone){
resetObjects();
start_item = 0;
for (int i= 0; i< zone->nb_cards; i++){
AddCard(zone->cards[i]);
}
}
void CardDisplay::rotateLeft(){
if (start_item==0) return;
for (int i= 0; i<mCount; i++){
CardGui * cardg = (CardGui *)mObjects[i];
cardg->x+=30;
}
start_item --;
}
void CardDisplay::rotateRight(){
if (start_item==mCount-1) return;
for (int i= 0; i<mCount; i++){
CardGui * cardg = (CardGui *)mObjects[i];
cardg->x-=30;
}
start_item ++;
}
void CardDisplay::CheckUserInput(float dt){
if (mEngine->GetButtonClick(PSP_CTRL_CROSS))
{
if (listener != NULL)
{
listener->ButtonPressed(mId, 0);
return;
}
}
void CardDisplay::Render(){
JRenderer * r = JRenderer::GetInstance();
r->DrawRect(x,y,nb_displayed_items * 30 + 20, 50, ARGB(255,255,255,255));
if (!mCount) return;
for (int i = start_item; i< start_item + nb_displayed_items && i < mCount; i++){
if (mObjects[i]){
mObjects[i]->Render();
if (tc){
CardGui * cardg = (CardGui *)mObjects[i];
if( tc->alreadyHasTarget(cardg->card)){
r->DrawCircle(cardg->x + 5, cardg->y+5,5, ARGB(255,255,0,0));
}else if (!tc->canTarget(cardg->card)){
r->FillRect(cardg->x,cardg->y,30,40,ARGB(200,0,0,0));
}
}
}
}
if (mObjects[mCurr]){
mObjects[mCurr]->Render();
}
}
DefaultTargetDisplay::DefaultTargetDisplay(int id, GameObserver* _game, int _x, int _y,JGuiListener * _listener, int _nb_displayed_items ):CardDisplay(id, _game, _x, _y, _listener, NULL, _nb_displayed_items ){
tc = NEW TargetChooser();
}
DefaultTargetDisplay::~DefaultTargetDisplay(){
SAFE_DELETE(tc);
}
}
if (!mCount)
return;
if (mEngine->GetButtonClick(mActionButton))
{
if (mObjects[mCurr] && mObjects[mCurr]->ButtonPressed()){
CardGui * cardg = (CardGui *)mObjects[mCurr];
if (tc)
{
tc->toggleTarget(cardg->card);
return;
}else{
if (game) game->ButtonPressed(mId, cardg);
return;
}
}
}
if (mEngine->GetButtonState(PSP_CTRL_LEFT))
{
if (KeyRepeated(PSP_CTRL_LEFT, dt))
{
int n = mCurr;
n--;
if (n<start_item){
if (n< 0){n = 0;}
else{ rotateLeft();}
}
if (n != mCurr && mObjects[mCurr] != NULL && mObjects[mCurr]->Leaving(PSP_CTRL_LEFT)){
mCurr = n;
mObjects[mCurr]->Entering();
}
}
}
else if (mEngine->GetButtonState(PSP_CTRL_RIGHT))
{
if (KeyRepeated(PSP_CTRL_RIGHT, dt))
{
int n = mCurr;
n++;
if (n>= mCount){n = mCount-1;}
if (n>= start_item + nb_displayed_items){
rotateRight();
}
if (n != mCurr && mObjects[mCurr] != NULL && mObjects[mCurr]->Leaving(PSP_CTRL_RIGHT)){
mCurr = n;
mObjects[mCurr]->Entering();
}
}
}
else{
mLastKey = 0;
}
}
void CardDisplay::Render(){
JRenderer * r = JRenderer::GetInstance();
r->DrawRect(x,y,nb_displayed_items * 30 + 20, 50, ARGB(255,255,255,255));
if (!mCount) return;
for (int i = start_item; i< start_item + nb_displayed_items && i < mCount; i++){
if (mObjects[i]){
mObjects[i]->Render();
if (tc){
CardGui * cardg = (CardGui *)mObjects[i];
if( tc->alreadyHasTarget(cardg->card)){
r->DrawCircle(cardg->x + 5, cardg->y+5,5, ARGB(255,255,0,0));
}else if (!tc->canTarget(cardg->card)){
r->FillRect(cardg->x,cardg->y,30,40,ARGB(200,0,0,0));
}
}
}
}
if (mObjects[mCurr]){
mObjects[mCurr]->Render();
}
}
DefaultTargetDisplay::DefaultTargetDisplay(int id, GameObserver* _game, int _x, int _y,JGuiListener * _listener, int _nb_displayed_items ):CardDisplay(id, _game, _x, _y, _listener, NULL, _nb_displayed_items ){
tc = NEW TargetChooser();
}
DefaultTargetDisplay::~DefaultTargetDisplay(){
SAFE_DELETE(tc);
}

636
projects/mtg/src/CardGui.cpp
View File

@@ -1,318 +1,318 @@
#include "../include/debug.h"
#include "../include/CardGui.h"
#include <Vector2D.h>
void CardGui::alternateRender(MTGCard * card, JLBFont * mFont, JQuad ** manaIcons, float x, float y, float rotation, float scale){
JQuad * mIcons[7];
if (!manaIcons){
mIcons[MTG_COLOR_ARTIFACT] = GameApp::CommonRes->GetQuad("c_artifact");
mIcons[MTG_COLOR_LAND] = GameApp::CommonRes->GetQuad("c_land");
mIcons[MTG_COLOR_WHITE] = GameApp::CommonRes->GetQuad("c_white");
mIcons[MTG_COLOR_RED] = GameApp::CommonRes->GetQuad("c_red");
mIcons[MTG_COLOR_BLACK] = GameApp::CommonRes->GetQuad("c_black");
mIcons[MTG_COLOR_BLUE] = GameApp::CommonRes->GetQuad("c_blue");
mIcons[MTG_COLOR_GREEN] = GameApp::CommonRes->GetQuad("c_green");
for (int i=0; i < 7; i++){
mIcons[i]->SetHotSpot(16,16);
}
manaIcons = mIcons;
}
Vector2D v;
Vector2D points[4];
PIXEL_TYPE bgcolor = ARGB(255,128,128,128);
PIXEL_TYPE bgcolor2 = ARGB(255,80,80,80);
char buf[25];
int width = 200;
int height = 285;
JRenderer * renderer = JRenderer::GetInstance();
mFont->SetRotation(rotation);
mFont->SetScale(scale);
int color = card->getColor();
points[0].x = -width/2;
points[0].y = -height/2 ;
points[1].x = width/2;
points[1].y = -height/2;
points[2].x = width/2;
points[2].y = height/2;
points[3].x = -width/2;
points[3].y = height/2;
for (int i=0; i < 4; i++){
points[i].x *= scale;
points[i].y *= scale;
points[i].Rotate(rotation);
}
if (rotation == 0){
renderer->FillRoundRect(x+points[0].x + 2 ,y+points[0].y +2 ,width*scale-8,height*scale-8,2,ARGB(255,_r[color],_g[color],_b[color]));
renderer->FillRect(x+points[0].x + 6 ,y+points[0].y + 6 ,width*scale-12,height*scale-12,bgcolor2);
}else{
for (int i=0; i < 4; i++){
renderer->DrawLine(x + points[i].x,y + points[i].y,x + points[(i+1)%4].x,y + points[(i+1)%4].y,bgcolor);
}
}
ManaCost * manacost = card->getManaCost();
int nbicons = 0;
for (int i = 1; i < MTG_NB_COLORS - 1; i++){
int cost = manacost->getCost(i);
for (int j=0; j < cost; j++){
v.x = (width/2 - 20 - 16*nbicons)*scale;
v.y = ((-height/2) + 20) * scale;
v.Rotate(rotation);
renderer->RenderQuad(manaIcons[i],x+v.x,y+v.y,rotation,0.5*scale, 0.5*scale);
nbicons++;
}
}
int cost = manacost->getCost(0);
if (cost !=0){
v.x = (width/2 - 20 - 16*nbicons)*scale;
v.y = ((-height/2) + 14) * scale;
v.Rotate(rotation);
sprintf(buf,"%i",cost);
mFont->DrawString(buf,x+v.x,y+v.y);
}
if (!card->formattedTextInit){
std::string s(card->getText());
unsigned int found=s.find_first_of("{}");
while (found!=string::npos)
{
s[found]='/';
found=s.find_first_of("{}",found+1);
}
int len = 24;
while (s.length() > 0){
int cut = s.find_first_of("., \t)", 0);
if (cut >= len || cut == -1){
card->formattedText.push_back(s.substr(0,len));
if ((signed int)s.length() > len){
s = s.substr(len,s.length()-len);
}else{
s = "";
}
}else{
int newcut = cut;
while (newcut < len && newcut != -1){
cut = newcut;
newcut = s.find_first_of("., \t)", newcut + 1);
}
card->formattedText.push_back(s.substr(0,cut+1));
if ((signed int)s.length() > cut+1){
s = s.substr(cut+1,s.length()- cut - 1);
}else{
s = "";
}
}
}
card->formattedTextInit = 1;
}
for (unsigned int i=0; i < card->formattedText.size(); i++){
sprintf(buf, "%s", card->formattedText[i].c_str());
v.x = (-width/2 + 12 )*scale;
v.y = ((-height/2) + 50 + 16*i) * scale;
v.Rotate(rotation);
mFont->DrawString(buf,x+v.x,y+v.y);
}
v.x = ((-width/2)+10) * scale;
v.y = ((-height/2) + 25) * scale;
v.Rotate(rotation);
int over = strlen(card->getName()) - 23;
float multiply = 1.4;
if (over > 0){
multiply = 1.1;
}
mFont->SetScale(scale * multiply);
mFont->SetColor(ARGB(255,_r[color],_g[color],_b[color]));
mFont->DrawString(card->getName(),x+v.x,y+v.y);
mFont->SetScale(scale);
mFont->SetColor(ARGB(255,255,255,255));
if (card->isACreature()){
v.x = (width/2-40) * scale;
v.y = (height/2-30) * scale;
v.Rotate(rotation);
sprintf(buf,"%i/%i",card->power,card->toughness);
mFont->DrawString(buf,x+v.x,y+v.y);
}
}
CardGui::CardGui(int id, MTGCardInstance * _card, float desiredHeight,float _x, float _y, bool hasFocus): PlayGuiObject(id, desiredHeight, _x, _y, hasFocus){
LOG("==Creating NEW CardGui Object. CardName:");
LOG(_card->getName());
card = _card;
type = GUI_CARD;
alpha = 255;
mParticleSys = NULL;
if (card->hasColor(MTG_COLOR_RED)){
mParticleSys = GameApp::Particles[3];
}else if (card->hasColor(MTG_COLOR_BLUE)){
mParticleSys = GameApp::Particles[1];
}else if (card->hasColor(MTG_COLOR_GREEN)){
mParticleSys = GameApp::Particles[2];
}else if (card->hasColor(MTG_COLOR_BLACK)){
mParticleSys = GameApp::Particles[4];
}else if (card->hasColor(MTG_COLOR_WHITE)){
mParticleSys = GameApp::Particles[0];
}else{
mParticleSys = GameApp::Particles[5];
}
LOG("==CardGui Object Creation Succesfull");
}
void CardGui::Update(float dt){
alpha = 255;
if (card->changedZoneRecently > 0) alpha = 255.f - 255.f * card->changedZoneRecently;
if (mParticleSys && card->changedZoneRecently == 1.f){
mParticleSys->MoveTo(x+15, y+2*mHeight/3);
mParticleSys->Fire();
}
if (card->changedZoneRecently){
if (mParticleSys) mParticleSys->Update(dt);
card->changedZoneRecently-= (5 *dt);
if (card->changedZoneRecently < 0){
if (mParticleSys) mParticleSys->Stop();
}
if (card->changedZoneRecently < -3){
card->changedZoneRecently = 0;
mParticleSys = NULL;
}
}
PlayGuiObject::Update(dt);
}
void CardGui::RenderBig(float xpos, float ypos){
JRenderer * renderer = JRenderer::GetInstance();
JQuad * quad = card->getQuad();
if (xpos == -1){
xpos = 300;
if (x > SCREEN_WIDTH / 2)
xpos = 10;
}
if(ypos == -1)
ypos = 20;
if (quad){
quad->SetColor(ARGB(220,255,255,255));
renderer->RenderQuad(quad, xpos , ypos , 0.0f,0.9f,0.9f);
}else{
MTGCard * mtgcard = card->model;
JLBFont * font = GameApp::CommonRes->GetJLBFont("graphics/magic");
CardGui::alternateRender(mtgcard, font, NULL, xpos + 90 , ypos + 130, 0.0f,0.9f);
}
}
void CardGui::Render(){
JLBFont * mFont = GameApp::CommonRes->GetJLBFont(MAIN_FONT);
JRenderer * renderer = JRenderer::GetInstance();
JQuad * quad = card->getThumb();
if (!quad || quad->mHeight * 2 < mHeight){
JQuad * quad2 = card->getQuad();
if (quad2)
quad = quad2;
}
float tap = (float)(card->isTapped());
float rotation = M_PI_2 * tap;
if (quad){
float mScale = mHeight / quad->mHeight;
float myX = x + (quad->mHeight/2 * tap * mScale);
float myY = y+(quad->mWidth/2 * tap * mScale);
if (mHeight-defaultHeight){
if (card->isTapped()){
renderer->FillRect(myX + 1*(mHeight-defaultHeight) - quad->mHeight * mScale , myY + 1*(mHeight-defaultHeight) , quad->mHeight * mScale, quad->mWidth * mScale, ARGB(128,0,0,0));
}else{
renderer->FillRect(myX + 1*(mHeight-defaultHeight) , myY + 1*(mHeight-defaultHeight) , quad->mWidth * mScale, quad->mHeight * mScale, ARGB(128,0,0,0));
}
}
quad->SetColor(ARGB( alpha,255,255,255));
GameObserver * game = GameObserver::GetInstance();
TargetChooser * tc = NULL;
if (game) tc = game->getCurrentTargetChooser();
if (tc){
if (!tc->canTarget(card)){
quad->SetColor(ARGB( alpha,50,50,50));
}
}
renderer->RenderQuad(quad, myX , myY , rotation,mScale,mScale);
if (tc && tc->alreadyHasTarget(card)){
if (card->isTapped()){
renderer->FillRect(myX- quad->mHeight * mScale , myY , quad->mHeight * mScale, quad->mWidth * mScale, ARGB(128,255,0,0));
}else{
renderer->FillRect(myX , myY , quad->mWidth * mScale, quad->mHeight * mScale, ARGB(128,255,0,0));
}
}
quad->SetColor(ARGB( alpha,255,255,255));
}else{
int color = card->getColor();
float mScale = mHeight / 64;
float myX = x + (32 * tap * mScale);
float myY = y+(20 * tap * mScale);
char buffer[200];
sprintf(buffer, "%s",card->getName());
mFont->SetColor(ARGB(255,_r[color],_g[color],_b[color]));
if (card->isTapped()){
renderer->FillRect(myX - 64 * mScale , myY , 64 * mScale, 40 * mScale, ARGB(255,0,0,0));
renderer->DrawRect(myX - 64 * mScale , myY , 64 * mScale, 40 * mScale, ARGB(255,_r[color],_g[color],_b[color]));
mFont->SetScale(0.20);
mFont->DrawString(buffer,myX - (64 * mScale)+4,myY + 1);
}else{
renderer->FillRect(myX , myY , 40 * mScale, 64 * mScale, ARGB(255,0,0,0));
renderer->DrawRect(myX , myY , 40 * mScale, 64 * mScale, ARGB(255,_r[color],_g[color],_b[color]));
mFont->SetScale(0.40);
mFont->DrawString(buffer,myX+4,myY + 1);
}
mFont->SetScale(1.0);
}
if (card->isACreature()){
mFont->SetScale(0.75);
char buffer[200];
sprintf(buffer, "%i/%i",card->power,card->life);
renderer->FillRect(x+2,y + mHeight - 12, 25 , 12 ,ARGB(128,0,0,0));
mFont->SetColor(ARGB(255,255,255,255));
mFont->DrawString(buffer,x+4,y + mHeight - 10);
}
if (mParticleSys && card->changedZoneRecently > 0){
renderer->SetTexBlend(BLEND_SRC_ALPHA, BLEND_ONE);
mParticleSys->Render();
// set normal blending
renderer->SetTexBlend(BLEND_SRC_ALPHA, BLEND_ONE_MINUS_SRC_ALPHA);
}
}
CardGui::~CardGui(){
LOG("==Destroying CardGui object");
LOG(this->card->getName());
LOG("==CardGui object destruction Successful");
}
#include "../include/debug.h"
#include "../include/CardGui.h"
#include <Vector2D.h>
void CardGui::alternateRender(MTGCard * card, JLBFont * mFont, JQuad ** manaIcons, float x, float y, float rotation, float scale){
JQuad * mIcons[7];
if (!manaIcons){
mIcons[MTG_COLOR_ARTIFACT] = GameApp::CommonRes->GetQuad("c_artifact");
mIcons[MTG_COLOR_LAND] = GameApp::CommonRes->GetQuad("c_land");
mIcons[MTG_COLOR_WHITE] = GameApp::CommonRes->GetQuad("c_white");
mIcons[MTG_COLOR_RED] = GameApp::CommonRes->GetQuad("c_red");
mIcons[MTG_COLOR_BLACK] = GameApp::CommonRes->GetQuad("c_black");
mIcons[MTG_COLOR_BLUE] = GameApp::CommonRes->GetQuad("c_blue");
mIcons[MTG_COLOR_GREEN] = GameApp::CommonRes->GetQuad("c_green");
for (int i=0; i < 7; i++){
mIcons[i]->SetHotSpot(16,16);
}
manaIcons = mIcons;
}
Vector2D v;
Vector2D points[4];
PIXEL_TYPE bgcolor = ARGB(255,128,128,128);
PIXEL_TYPE bgcolor2 = ARGB(255,80,80,80);
char buf[25];
int width = 200;
int height = 285;
JRenderer * renderer = JRenderer::GetInstance();
mFont->SetRotation(rotation);
mFont->SetScale(scale);
int color = card->getColor();
points[0].x = -width/2;
points[0].y = -height/2 ;
points[1].x = width/2;
points[1].y = -height/2;
points[2].x = width/2;
points[2].y = height/2;
points[3].x = -width/2;
points[3].y = height/2;
for (int i=0; i < 4; i++){
points[i].x *= scale;
points[i].y *= scale;
points[i].Rotate(rotation);
}
if (rotation == 0){
renderer->FillRoundRect(x+points[0].x + 2 ,y+points[0].y +2 ,width*scale-8,height*scale-8,2,ARGB(255,_r[color],_g[color],_b[color]));
renderer->FillRect(x+points[0].x + 6 ,y+points[0].y + 6 ,width*scale-12,height*scale-12,bgcolor2);
}else{
for (int i=0; i < 4; i++){
renderer->DrawLine(x + points[i].x,y + points[i].y,x + points[(i+1)%4].x,y + points[(i+1)%4].y,bgcolor);
}
}
ManaCost * manacost = card->getManaCost();
int nbicons = 0;
for (int i = 1; i < MTG_NB_COLORS - 1; i++){
int cost = manacost->getCost(i);
for (int j=0; j < cost; j++){
v.x = (width/2 - 20 - 16*nbicons)*scale;
v.y = ((-height/2) + 20) * scale;
v.Rotate(rotation);
renderer->RenderQuad(manaIcons[i],x+v.x,y+v.y,rotation,0.5*scale, 0.5*scale);
nbicons++;
}
}
int cost = manacost->getCost(0);
if (cost !=0){
v.x = (width/2 - 20 - 16*nbicons)*scale;
v.y = ((-height/2) + 14) * scale;
v.Rotate(rotation);
sprintf(buf,"%i",cost);
mFont->DrawString(buf,x+v.x,y+v.y);
}
if (!card->formattedTextInit){
std::string s(card->getText());
unsigned int found=s.find_first_of("{}");
while (found!=string::npos)
{
s[found]='/';
found=s.find_first_of("{}",found+1);
}
int len = 24;
while (s.length() > 0){
int cut = s.find_first_of("., \t)", 0);
if (cut >= len || cut == -1){
card->formattedText.push_back(s.substr(0,len));
if ((signed int)s.length() > len){
s = s.substr(len,s.length()-len);
}else{
s = "";
}
}else{
int newcut = cut;
while (newcut < len && newcut != -1){
cut = newcut;
newcut = s.find_first_of("., \t)", newcut + 1);
}
card->formattedText.push_back(s.substr(0,cut+1));
if ((signed int)s.length() > cut+1){
s = s.substr(cut+1,s.length()- cut - 1);
}else{
s = "";
}
}
}
card->formattedTextInit = 1;
}
for (unsigned int i=0; i < card->formattedText.size(); i++){
sprintf(buf, "%s", card->formattedText[i].c_str());
v.x = (-width/2 + 12 )*scale;
v.y = ((-height/2) + 50 + 16*i) * scale;
v.Rotate(rotation);
mFont->DrawString(buf,x+v.x,y+v.y);
}
v.x = ((-width/2)+10) * scale;
v.y = ((-height/2) + 25) * scale;
v.Rotate(rotation);
int over = strlen(card->getName()) - 23;
float multiply = 1.4;
if (over > 0){
multiply = 1.1;
}
mFont->SetScale(scale * multiply);
mFont->SetColor(ARGB(255,_r[color],_g[color],_b[color]));
mFont->DrawString(card->getName(),x+v.x,y+v.y);
mFont->SetScale(scale);
mFont->SetColor(ARGB(255,255,255,255));
if (card->isACreature()){
v.x = (width/2-40) * scale;
v.y = (height/2-30) * scale;
v.Rotate(rotation);
sprintf(buf,"%i/%i",card->power,card->toughness);
mFont->DrawString(buf,x+v.x,y+v.y);
}
}
CardGui::CardGui(int id, MTGCardInstance * _card, float desiredHeight,float _x, float _y, bool hasFocus): PlayGuiObject(id, desiredHeight, _x, _y, hasFocus){
LOG("==Creating NEW CardGui Object. CardName:");
LOG(_card->getName());
card = _card;
type = GUI_CARD;
alpha = 255;
mParticleSys = NULL;
if (card->hasColor(MTG_COLOR_RED)){
mParticleSys = GameApp::Particles[3];
}else if (card->hasColor(MTG_COLOR_BLUE)){
mParticleSys = GameApp::Particles[1];
}else if (card->hasColor(MTG_COLOR_GREEN)){
mParticleSys = GameApp::Particles[2];
}else if (card->hasColor(MTG_COLOR_BLACK)){
mParticleSys = GameApp::Particles[4];
}else if (card->hasColor(MTG_COLOR_WHITE)){
mParticleSys = GameApp::Particles[0];
}else{
mParticleSys = GameApp::Particles[5];
}
LOG("==CardGui Object Creation Succesfull");
}
void CardGui::Update(float dt){
alpha = 255;
if (card->changedZoneRecently > 0) alpha = 255.f - 255.f * card->changedZoneRecently;
if (mParticleSys && card->changedZoneRecently == 1.f){
mParticleSys->MoveTo(x+15, y+2*mHeight/3);
mParticleSys->Fire();
}
if (card->changedZoneRecently){
if (mParticleSys) mParticleSys->Update(dt);
card->changedZoneRecently-= (5 *dt);
if (card->changedZoneRecently < 0){
if (mParticleSys) mParticleSys->Stop();
}
if (card->changedZoneRecently < -3){
card->changedZoneRecently = 0;
mParticleSys = NULL;
}
}
PlayGuiObject::Update(dt);
}
void CardGui::RenderBig(float xpos, float ypos){
JRenderer * renderer = JRenderer::GetInstance();
JQuad * quad = card->getQuad();
if (xpos == -1){
xpos = 300;
if (x > SCREEN_WIDTH / 2)
xpos = 10;
}
if(ypos == -1)
ypos = 20;
if (quad){
quad->SetColor(ARGB(220,255,255,255));
renderer->RenderQuad(quad, xpos , ypos , 0.0f,0.9f,0.9f);
}else{
MTGCard * mtgcard = card->model;
JLBFont * font = GameApp::CommonRes->GetJLBFont("graphics/magic");
CardGui::alternateRender(mtgcard, font, NULL, xpos + 90 , ypos + 130, 0.0f,0.9f);
}
}
void CardGui::Render(){
JLBFont * mFont = GameApp::CommonRes->GetJLBFont(MAIN_FONT);
JRenderer * renderer = JRenderer::GetInstance();
JQuad * quad = card->getThumb();
if (!quad || quad->mHeight * 2 < mHeight){
JQuad * quad2 = card->getQuad();
if (quad2)
quad = quad2;
}
float tap = (float)(card->isTapped());
float rotation = M_PI_2 * tap;
if (quad){
float mScale = mHeight / quad->mHeight;
float myX = x + (quad->mHeight/2 * tap * mScale);
float myY = y+(quad->mWidth/2 * tap * mScale);
if (mHeight-defaultHeight){
if (card->isTapped()){
renderer->FillRect(myX + 1*(mHeight-defaultHeight) - quad->mHeight * mScale , myY + 1*(mHeight-defaultHeight) , quad->mHeight * mScale, quad->mWidth * mScale, ARGB(128,0,0,0));
}else{
renderer->FillRect(myX + 1*(mHeight-defaultHeight) , myY + 1*(mHeight-defaultHeight) , quad->mWidth * mScale, quad->mHeight * mScale, ARGB(128,0,0,0));
}
}
quad->SetColor(ARGB( alpha,255,255,255));
GameObserver * game = GameObserver::GetInstance();
TargetChooser * tc = NULL;
if (game) tc = game->getCurrentTargetChooser();
if (tc){
if (!tc->canTarget(card)){
quad->SetColor(ARGB( alpha,50,50,50));
}
}
renderer->RenderQuad(quad, myX , myY , rotation,mScale,mScale);
if (tc && tc->alreadyHasTarget(card)){
if (card->isTapped()){
renderer->FillRect(myX- quad->mHeight * mScale , myY , quad->mHeight * mScale, quad->mWidth * mScale, ARGB(128,255,0,0));
}else{
renderer->FillRect(myX , myY , quad->mWidth * mScale, quad->mHeight * mScale, ARGB(128,255,0,0));
}
}
quad->SetColor(ARGB( alpha,255,255,255));
}else{
int color = card->getColor();
float mScale = mHeight / 64;
float myX = x + (32 * tap * mScale);
float myY = y+(20 * tap * mScale);
char buffer[200];
sprintf(buffer, "%s",card->getName());
mFont->SetColor(ARGB(255,_r[color],_g[color],_b[color]));
if (card->isTapped()){
renderer->FillRect(myX - 64 * mScale , myY , 64 * mScale, 40 * mScale, ARGB(255,0,0,0));
renderer->DrawRect(myX - 64 * mScale , myY , 64 * mScale, 40 * mScale, ARGB(255,_r[color],_g[color],_b[color]));
mFont->SetScale(0.20);
mFont->DrawString(buffer,myX - (64 * mScale)+4,myY + 1);
}else{
renderer->FillRect(myX , myY , 40 * mScale, 64 * mScale, ARGB(255,0,0,0));
renderer->DrawRect(myX , myY , 40 * mScale, 64 * mScale, ARGB(255,_r[color],_g[color],_b[color]));
mFont->SetScale(0.40);
mFont->DrawString(buffer,myX+4,myY + 1);
}
mFont->SetScale(1.0);
}
if (card->isACreature()){
mFont->SetScale(0.75);
char buffer[200];
sprintf(buffer, "%i/%i",card->power,card->life);
renderer->FillRect(x+2,y + mHeight - 12, 25 , 12 ,ARGB(128,0,0,0));
mFont->SetColor(ARGB(255,255,255,255));
mFont->DrawString(buffer,x+4,y + mHeight - 10);
}
if (mParticleSys && card->changedZoneRecently > 0){
renderer->SetTexBlend(BLEND_SRC_ALPHA, BLEND_ONE);
mParticleSys->Render();
// set normal blending
renderer->SetTexBlend(BLEND_SRC_ALPHA, BLEND_ONE_MINUS_SRC_ALPHA);
}
}
CardGui::~CardGui(){
LOG("==Destroying CardGui object");
LOG(this->card->getName());
LOG("==CardGui object destruction Successful");
}

82
projects/mtg/src/ConstraintResolver.cpp
View File

@@ -1,41 +1,41 @@
#include "../include/debug.h"
#include "../include/ConstraintResolver.h"
int ConstraintResolver::untap(GameObserver * game, MTGCardInstance * card){
if (!card->isUntapping()){
return 0;
}
int ok = 1;
ManaCost * untapManaCost = NEW ManaCost();
Blockers * blockers = card->getBlockers();
Blocker * blocker;
blockers->rewind();
Player * player = game->currentPlayer;
while ((blocker = blockers->next())){
#if defined (WIN32) || defined (LINUX)
char buf[4096];
sprintf(buf, "next\n");
OutputDebugString(buf);
#endif
untapManaCost->add(blocker->untapManaCost());
}
if (player->getManaPool()->canAfford(untapManaCost)){
blockers->rewind();
while ((blocker = blockers->next())){
if (!blocker->unblock()){
ok = 0;
break;
}
}
}else{
ok = 0;
}
if (ok) {
player->getManaPool()->pay(untapManaCost);
card->untap();
}
delete untapManaCost;
return ok;
}
#include "../include/debug.h"
#include "../include/ConstraintResolver.h"
int ConstraintResolver::untap(GameObserver * game, MTGCardInstance * card){
if (!card->isUntapping()){
return 0;
}
int ok = 1;
ManaCost * untapManaCost = NEW ManaCost();
Blockers * blockers = card->getBlockers();
Blocker * blocker;
blockers->rewind();
Player * player = game->currentPlayer;
while ((blocker = blockers->next())){
#if defined (WIN32) || defined (LINUX)
char buf[4096];
sprintf(buf, "next\n");
OutputDebugString(buf);
#endif
untapManaCost->add(blocker->untapManaCost());
}
if (player->getManaPool()->canAfford(untapManaCost)){
blockers->rewind();
while ((blocker = blockers->next())){
if (!blocker->unblock()){
ok = 0;
break;
}
}
}else{
ok = 0;
}
if (ok) {
player->getManaPool()->pay(untapManaCost);
card->untap();
}
delete untapManaCost;
return ok;
}

240
projects/mtg/src/Counters.cpp
View File

@@ -1,120 +1,120 @@
#include "../include/Counters.h"
#include "../include/debug.h"
#include "../include/MTGCardInstance.h"
Counter::Counter(MTGCardInstance * _target, int _power, int _toughness){
init(_target,"",_power, _toughness);
}
Counter::Counter(MTGCardInstance * _target, const char * _name,int _power, int _toughness ){
init(_target,_name,_power, _toughness);
}
int Counter::init(MTGCardInstance * _target,const char * _name, int _power, int _toughness){
target = _target;
name = _name;
power = _power;
toughness = _toughness;
nb = 1;
return 1;
}
bool Counter::sameAs(const char * _name, int _power, int _toughness){
if (power == 0 && toughness == 0) return (name.compare(_name) == 0);
return (power == _power && toughness == _toughness);
}
bool Counter::cancels(int _power, int _toughness){
if (power == 0 && toughness == 0) return false;
return (power == -_power && toughness == -_toughness);
}
int Counter::added(){
if (power != 0 || toughness != 0){
target->power+= power;
target->addToToughness(toughness);
}
return 1;
}
int Counter::removed(){
if (power != 0 || toughness != 0){
target->power-= power;
target->addToToughness(-toughness);
}
return 1;
}
Counters::Counters(MTGCardInstance * _target):target(_target){
mCount = 0;
}
Counters::~Counters(){
for (int i = 0; i < mCount; i++){
delete counters[i];
}
}
int Counters::addCounter(const char * _name,int _power, int _toughness){
for (int i = 0; i < mCount; i++){
if (counters[i]->cancels( _power,_toughness) && counters[i]->nb > 0){
counters[i]->removed();
counters[i]->nb--;
return mCount;
}
}
for (int i = 0; i < mCount; i++){
if (counters[i]->sameAs(_name, _power,_toughness)){
counters[i]->added();
counters[i]->nb++;
return mCount;
}
}
Counter * counter = NEW Counter(target,_name, _power, _toughness);
counters[mCount] = counter;
counter->added();
mCount++;
return mCount;
}
int Counters::addCounter(int _power, int _toughness){
return addCounter("",_power, _toughness);
}
int Counters::removeCounter(const char * _name,int _power, int _toughness){
for (int i = 0; i < mCount; i++){
if (counters[i]->sameAs(_name, _power,_toughness)){
if (counters[i]->nb < 1) return 0;
counters[i]->removed();
counters[i]->nb--;
return mCount;
}
}
return 0;
}
int Counters::removeCounter(int _power, int _toughness){
return removeCounter("",_power, _toughness);
}
Counter * Counters::hasCounter(const char * _name,int _power, int _toughness){
for (int i = 0; i < mCount; i++){
if (counters[i]->sameAs(_name, _power,_toughness)){
if (counters[i]->nb > 0) return counters[i];
}
}
return NULL;
}
Counter * Counters::hasCounter(int _power , int _toughness ){
return hasCounter("",_power, _toughness);
}
Counter * Counters::getNext(Counter * previous){
int found = 0;
for (int i = 0; i < mCount ; i++){
if (found && counters[i]->nb > 0) return counters[i];
if (counters[i] == previous) found = 1;
}
return NULL;
}
#include "../include/Counters.h"
#include "../include/debug.h"
#include "../include/MTGCardInstance.h"
Counter::Counter(MTGCardInstance * _target, int _power, int _toughness){
init(_target,"",_power, _toughness);
}
Counter::Counter(MTGCardInstance * _target, const char * _name,int _power, int _toughness ){
init(_target,_name,_power, _toughness);
}
int Counter::init(MTGCardInstance * _target,const char * _name, int _power, int _toughness){
target = _target;
name = _name;
power = _power;
toughness = _toughness;
nb = 1;
return 1;
}
bool Counter::sameAs(const char * _name, int _power, int _toughness){
if (power == 0 && toughness == 0) return (name.compare(_name) == 0);
return (power == _power && toughness == _toughness);
}
bool Counter::cancels(int _power, int _toughness){
if (power == 0 && toughness == 0) return false;
return (power == -_power && toughness == -_toughness);
}
int Counter::added(){
if (power != 0 || toughness != 0){
target->power+= power;
target->addToToughness(toughness);
}
return 1;
}
int Counter::removed(){
if (power != 0 || toughness != 0){
target->power-= power;
target->addToToughness(-toughness);
}
return 1;
}
Counters::Counters(MTGCardInstance * _target):target(_target){
mCount = 0;
}
Counters::~Counters(){
for (int i = 0; i < mCount; i++){
delete counters[i];
}
}
int Counters::addCounter(const char * _name,int _power, int _toughness){
for (int i = 0; i < mCount; i++){
if (counters[i]->cancels( _power,_toughness) && counters[i]->nb > 0){
counters[i]->removed();
counters[i]->nb--;
return mCount;
}
}
for (int i = 0; i < mCount; i++){
if (counters[i]->sameAs(_name, _power,_toughness)){
counters[i]->added();
counters[i]->nb++;
return mCount;
}
}
Counter * counter = NEW Counter(target,_name, _power, _toughness);
counters[mCount] = counter;
counter->added();
mCount++;
return mCount;
}
int Counters::addCounter(int _power, int _toughness){
return addCounter("",_power, _toughness);
}
int Counters::removeCounter(const char * _name,int _power, int _toughness){
for (int i = 0; i < mCount; i++){
if (counters[i]->sameAs(_name, _power,_toughness)){
if (counters[i]->nb < 1) return 0;
counters[i]->removed();
counters[i]->nb--;
return mCount;
}
}
return 0;
}
int Counters::removeCounter(int _power, int _toughness){
return removeCounter("",_power, _toughness);
}
Counter * Counters::hasCounter(const char * _name,int _power, int _toughness){
for (int i = 0; i < mCount; i++){
if (counters[i]->sameAs(_name, _power,_toughness)){
if (counters[i]->nb > 0) return counters[i];
}
}
return NULL;
}
Counter * Counters::hasCounter(int _power , int _toughness ){
return hasCounter("",_power, _toughness);
}
Counter * Counters::getNext(Counter * previous){
int found = 0;
for (int i = 0; i < mCount ; i++){
if (found && counters[i]->nb > 0) return counters[i];
if (counters[i] == previous) found = 1;
}
return NULL;
}

282
projects/mtg/src/Damage.cpp
View File

@@ -1,142 +1,142 @@
#include "../include/debug.h"
#include "../include/Damage.h"
#include "../include/MTGCardInstance.h"
#include "../include/Counters.h"
Damage::Damage(int id, MTGCardInstance * _source, Damageable * _target): Interruptible(id){
init(_source, _target, _source->getPower());
}
Damage::Damage(int id, MTGCardInstance * _source, Damageable * _target, int _damage): Interruptible(id){
init(_source, _target, _damage);
}
void Damage::init(MTGCardInstance * _source, Damageable * _target, int _damage){
target = _target;
source = _source;
if (_damage < 0) _damage = 0; //Negative damages cannot happen
damage = _damage;
mHeight = 40;
type = ACTION_DAMAGE;
}
int Damage::resolve(){
if (damage <0) damage = 0; //Negative damages cannot happen
if (target->type_as_damageable == DAMAGEABLE_MTGCARDINSTANCE){
MTGCardInstance * _target = (MTGCardInstance *)target;
if ((_target)->protectedAgainst(source)) return 0;
// Damage for WITHER on creatures
if (source->has(WITHER)){
for (int i = 0; i < damage; i++){
_target->counters->addCounter(-1, -1);
}
return 1;
}
_target->doDamageTest = 1;
}
int a = target->dealDamage(damage);
return a;
}
void Damage::Render(){
JLBFont * mFont = GameApp::CommonRes->GetJLBFont(MAIN_FONT);
mFont->SetBase(0);
mFont->SetScale(0.75);
char buffer[200];
sprintf(buffer, "Does %i damage to", damage);
mFont->DrawString(buffer, x + 20 , y, JGETEXT_LEFT);
JRenderer * renderer = JRenderer::GetInstance();
JQuad * quad = source->getThumb();
if (quad){
float scale = 30 / quad->mHeight;
renderer->RenderQuad(quad, x , y , 0,scale,scale);
}else{
//TODO
}
quad = target->getIcon();
if (quad){
float scale = 30 / quad->mHeight;
renderer->RenderQuad(quad, x + 150 , y , 0,scale,scale);
}else{
//TODO
}
}
DamageStack::DamageStack(int id, GameObserver * _game):GuiLayer(id, _game), Interruptible(id){
currentState = -1;
type = ACTION_DAMAGES;
}
int DamageStack::CombatDamages(){
CombatDamages(1);
CombatDamages(0);
return 1;
}
int DamageStack::CombatDamages(int strike){
mHeight = 0;
MTGInPlay * attackers = game->currentPlayer->game->inPlay;
MTGInPlay * defensers = game->opponent()->game->inPlay;
MTGCardInstance * attacker = attackers->getNextAttacker(NULL);
while (attacker != NULL){
int nbdefensers = defensers->nbDefensers(attacker);
if ((!strike && !attacker->has(FIRSTSTRIKE)) || (strike && attacker->has(FIRSTSTRIKE)) || attacker->has(DOUBLESTRIKE)){
if (nbdefensers == 0){
Damage * damage = NEW Damage (mCount, attacker, game->opponent());
Add(damage);
}else if (nbdefensers == 1){
Damage * damage = NEW Damage (mCount, attacker, defensers->getNextDefenser(NULL, attacker));
Add(damage);
}else{
//TODO Fetch list of defensers and allow user to choose targets
Damage * damage = NEW Damage (mCount, attacker, defensers->getNextDefenser(NULL, attacker));
Add(damage);
}
}
MTGCardInstance * defenser = defensers->getNextDefenser(NULL, attacker);
while (defenser != NULL){
if ((!strike && !defenser->has(FIRSTSTRIKE)) || (strike && defenser->has(FIRSTSTRIKE)) || defenser->has(DOUBLESTRIKE)){
Damage * damage = NEW Damage (mCount,defenser, attacker);
Add(damage);
}
defenser = defensers->getNextDefenser(defenser, attacker);
}
attacker = attackers->getNextAttacker(attacker);
}
for (int i = 0; i < mCount; i++){
Damage * damage = (Damage*)mObjects[i];
mHeight += damage->mHeight;
}
return mCount;
}
int DamageStack::resolve(){
for (int i = mCount-1; i>= 0; i--){
Damage * damage = (Damage*)mObjects[i];
damage->resolve();
}
for (int i = mCount-1; i>= 0; i--){
Damage * damage = (Damage*)mObjects[i];
damage->target->afterDamage();
}
return 1;
}
void DamageStack::Render(){
int currenty = y;
for (int i= 0; i < mCount; i++){
Damage * damage = (Damage*)mObjects[i];
damage->x = x;
damage->y = currenty;
currenty += damage->mHeight;
damage->Render();
}
}
#include "../include/debug.h"
#include "../include/Damage.h"
#include "../include/MTGCardInstance.h"
#include "../include/Counters.h"
Damage::Damage(int id, MTGCardInstance * _source, Damageable * _target): Interruptible(id){
init(_source, _target, _source->getPower());
}
Damage::Damage(int id, MTGCardInstance * _source, Damageable * _target, int _damage): Interruptible(id){
init(_source, _target, _damage);
}
void Damage::init(MTGCardInstance * _source, Damageable * _target, int _damage){
target = _target;
source = _source;
if (_damage < 0) _damage = 0; //Negative damages cannot happen
damage = _damage;
mHeight = 40;
type = ACTION_DAMAGE;
}
int Damage::resolve(){
if (damage <0) damage = 0; //Negative damages cannot happen
if (target->type_as_damageable == DAMAGEABLE_MTGCARDINSTANCE){
MTGCardInstance * _target = (MTGCardInstance *)target;
if ((_target)->protectedAgainst(source)) return 0;
// Damage for WITHER on creatures
if (source->has(WITHER)){
for (int i = 0; i < damage; i++){
_target->counters->addCounter(-1, -1);
}
return 1;
}
_target->doDamageTest = 1;
}
int a = target->dealDamage(damage);
return a;
}
void Damage::Render(){
JLBFont * mFont = GameApp::CommonRes->GetJLBFont(MAIN_FONT);
mFont->SetBase(0);
mFont->SetScale(0.75);
char buffer[200];
sprintf(buffer, "Does %i damage to", damage);
mFont->DrawString(buffer, x + 20 , y, JGETEXT_LEFT);
JRenderer * renderer = JRenderer::GetInstance();
JQuad * quad = source->getThumb();
if (quad){
float scale = 30 / quad->mHeight;
renderer->RenderQuad(quad, x , y , 0,scale,scale);
}else{
//TODO
}
quad = target->getIcon();
if (quad){
float scale = 30 / quad->mHeight;
renderer->RenderQuad(quad, x + 150 , y , 0,scale,scale);
}else{
//TODO
}
}
DamageStack::DamageStack(int id, GameObserver * _game):GuiLayer(id, _game), Interruptible(id){
currentState = -1;
type = ACTION_DAMAGES;
}
int DamageStack::CombatDamages(){
CombatDamages(1);
CombatDamages(0);
return 1;
}
int DamageStack::CombatDamages(int strike){
mHeight = 0;
MTGInPlay * attackers = game->currentPlayer->game->inPlay;
MTGInPlay * defensers = game->opponent()->game->inPlay;
MTGCardInstance * attacker = attackers->getNextAttacker(NULL);
while (attacker != NULL){
int nbdefensers = defensers->nbDefensers(attacker);
if ((!strike && !attacker->has(FIRSTSTRIKE)) || (strike && attacker->has(FIRSTSTRIKE)) || attacker->has(DOUBLESTRIKE)){
if (nbdefensers == 0){
Damage * damage = NEW Damage (mCount, attacker, game->opponent());
Add(damage);
}else if (nbdefensers == 1){
Damage * damage = NEW Damage (mCount, attacker, defensers->getNextDefenser(NULL, attacker));
Add(damage);
}else{
//TODO Fetch list of defensers and allow user to choose targets
Damage * damage = NEW Damage (mCount, attacker, defensers->getNextDefenser(NULL, attacker));
Add(damage);
}
}
MTGCardInstance * defenser = defensers->getNextDefenser(NULL, attacker);
while (defenser != NULL){
if ((!strike && !defenser->has(FIRSTSTRIKE)) || (strike && defenser->has(FIRSTSTRIKE)) || defenser->has(DOUBLESTRIKE)){
Damage * damage = NEW Damage (mCount,defenser, attacker);
Add(damage);
}
defenser = defensers->getNextDefenser(defenser, attacker);
}
attacker = attackers->getNextAttacker(attacker);
}
for (int i = 0; i < mCount; i++){
Damage * damage = (Damage*)mObjects[i];
mHeight += damage->mHeight;
}
return mCount;
}
int DamageStack::resolve(){
for (int i = mCount-1; i>= 0; i--){
Damage * damage = (Damage*)mObjects[i];
damage->resolve();
}
for (int i = mCount-1; i>= 0; i--){
Damage * damage = (Damage*)mObjects[i];
damage->target->afterDamage();
}
return 1;
}
void DamageStack::Render(){
int currenty = y;
for (int i= 0; i < mCount; i++){
Damage * damage = (Damage*)mObjects[i];
damage->x = x;
damage->y = currenty;
currenty += damage->mHeight;
damage->Render();
}
}

718
projects/mtg/src/DamageResolverLayer.cpp
View File

@@ -1,359 +1,359 @@
#include "../include/debug.h"
#include "../include/DamageResolverLayer.h"
#include "../include/GameObserver.h"
#include "../include/MTGCardInstance.h"
#include "../include/DamagerDamaged.h"
#include "../include/Damage.h"
DamageResolverLayer::DamageResolverLayer(int id, GameObserver * _game):PlayGuiObjectController(id, _game){
currentPhase = -1;
remainingDamageSteps = 0;
damageStack = NULL;
currentSource = NULL;
buttonOk = 0;
currentChoosingPlayer = NULL;
}
void DamageResolverLayer::Update(float dt){
int newPhase = game->getCurrentGamePhase();
if (newPhase == MTG_PHASE_COMBATDAMAGE){
if (!game->mLayers->stackLayer()->getNext(NULL,0,NOT_RESOLVED)){
if (newPhase != currentPhase){
init();
}
if (remainingDamageSteps && empty()){
initResolve();
}
}
}else{
remainingDamageSteps = 0;
}
currentPhase = newPhase;
PlayGuiObjectController::Update(dt);
}
Player * DamageResolverLayer::whoSelectsDamagesDealtBy(MTGCardInstance * card){
if (card->controller() == game->currentPlayer){ //Attacker
MTGInPlay * defensers = game->opponent()->game->inPlay;
int nbdefensers = defensers->nbDefensers(card);
if (nbdefensers == 0) return NULL;
if(nbdefensers == 1 && !card->has(TRAMPLE)) return NULL;
MTGCardInstance * defenser = defensers->getNextDefenser(NULL, card);
while (defenser != NULL){
if (defenser->has(BANDING)) return game->opponent();
defenser = defensers->getNextDefenser(defenser, card);
}
return game->currentPlayer;
}else{ //Defenser
MTGInPlay * attackers = game->currentPlayer->game->inPlay;
int nbattackers = attackers->nbPartners(card->isDefenser());
if(nbattackers <= 1) return NULL;
if (card->isDefenser()->banding) return game->currentPlayer;
return game->opponent();
}
}
int DamageResolverLayer::addAutoDamageToOpponents(MTGCardInstance * card){
if (card->controller() == game->currentPlayer){ //Attacker
MTGInPlay * defensers = game->opponent()->game->inPlay;
int nbdefensers = defensers->nbDefensers(card);
if (nbdefensers == 0){
Damage * damage = NEW Damage (0, card, game->opponent());
damageStack->Add(damage);
}else if (nbdefensers == 1){
Damage * damage = NEW Damage (0, card, defensers->getNextDefenser(NULL, card));
damageStack->Add(damage);
}else{
//SHOULDN'T HAPPEN !
}
}else{ //Defenser
Damage * damage = NEW Damage (mCount,card, card->isDefenser());
damageStack->Add(damage);
}
return 1;
}
int DamageResolverLayer::addIfNotExists(MTGCardInstance * card, Player * selecter){
for (int i = 0; i < mCount; i++){
DamagerDamaged * item = (DamagerDamaged *)mObjects[i];
if (item->card == card) return 0;
}
CardGui * cardg = game->mLayers->playLayer()->getByCard(card);
DamagerDamaged * item = NEW DamagerDamaged(cardg, selecter, mCount == 0);
Add(item);
mCurr = 0;
return 1;
}
//Adds a card and all its opponents to the Damagers' list
int DamageResolverLayer::addDamager(MTGCardInstance * card, Player * selecter){
addIfNotExists(card, selecter);
if (card->controller() == game->currentPlayer){ //Attacker
MTGInPlay * defensers = game->opponent()->game->inPlay;
MTGCardInstance * defenser = defensers->getNextDefenser(NULL, card);
while (defenser != NULL){
addIfNotExists(defenser, whoSelectsDamagesDealtBy(defenser));
defenser = defensers->getNextDefenser(defenser, card);
}
}else{ //Defenser
MTGInPlay * attackers = game->currentPlayer->game->inPlay;
MTGCardInstance * attacker = card->isDefenser();
addIfNotExists(attacker,whoSelectsDamagesDealtBy(attacker));
MTGCardInstance * banding = attacker->banding;
if (banding){
attacker = attackers->getNextAttacker(NULL);
while (attacker != NULL){
if (attacker->banding == banding){
addIfNotExists(attacker,whoSelectsDamagesDealtBy(attacker));
}
attacker = attackers->getNextAttacker(attacker);
}
}
}
return 1;
}
int DamageResolverLayer::initResolve(){
#if defined (WIN32) || defined (LINUX)
char buf[4096];
sprintf(buf, "starting resolve, remainingDamagesStep = %i\n", remainingDamageSteps);
OutputDebugString(buf);
#endif
if (damageStack) return 0;
#if defined (WIN32) || defined (LINUX)
sprintf(buf, "damageStack is NULL, we can resolve \n");
OutputDebugString(buf);
#endif
currentSource = NULL;
currentChoosingPlayer = game->currentPlayer;
damageStack = NEW DamageStack(mCount,game);
int strike = 0;
if (remainingDamageSteps == 2) strike = 1;
MTGInPlay * attackers = game->currentPlayer->game->inPlay;
MTGInPlay * defensers = game->opponent()->game->inPlay;
MTGCardInstance * attacker = attackers->getNextAttacker(NULL);
while (attacker != NULL){
#if defined (WIN32) || defined (LINUX)
sprintf(buf, "attacker : %s \n", attacker->getName());
OutputDebugString(buf);
#endif
if ((!strike && !attacker->has(FIRSTSTRIKE)) || (strike && attacker->has(FIRSTSTRIKE)) || attacker->has(DOUBLESTRIKE)){
Player * selecter = whoSelectsDamagesDealtBy(attacker);
if (!selecter){
addAutoDamageToOpponents(attacker);
}else{
addDamager(attacker, selecter);
}
}
MTGCardInstance * defenser = defensers->getNextDefenser(NULL, attacker);
while (defenser != NULL){
if ((!strike && !defenser->has(FIRSTSTRIKE)) || (strike && defenser->has(FIRSTSTRIKE)) || defenser->has(DOUBLESTRIKE)){
Player * selecterb = whoSelectsDamagesDealtBy(defenser);
if (!selecterb){
addAutoDamageToOpponents(defenser);
}else{
addDamager(defenser, selecterb);
}
}
defenser = defensers->getNextDefenser(defenser, attacker);
}
attacker = attackers->getNextAttacker(attacker);
}
if (empty()){
if (!damageStack->empty()){
game->mLayers->stackLayer()->addAction(damageStack);
}else{
SAFE_DELETE(damageStack);
}
remainingDamageSteps--;
damageStack = NULL;
modal = remainingDamageSteps;
}else{
if (canStopDealDamages()) currentChoosingPlayer = game->opponent();
}
return 1;
}
int DamageResolverLayer::init(){
modal = 1;
remainingDamageSteps = 2;
return 1;
}
DamagerDamaged * DamageResolverLayer::findByCard(MTGCardInstance * card){
for (int i =0; i < mCount; i++){
DamagerDamaged * current = (DamagerDamaged *) mObjects[i];
if (current->card == card) return current;
}
return NULL;
}
//Returns 1 if all "compulsory" damages have been assigned for current player
int DamageResolverLayer::canStopDealDamages(){
for (int i = 0; i < mCount ; i ++){
DamagerDamaged * current = (DamagerDamaged *) mObjects[i];
if (current->damageSelecter==currentChoosingPlayer && current->damageToDeal > 0){
MTGCardInstance * card = current->card;
if (card->controller() == game->currentPlayer){ //Attacker
if (card->has(TRAMPLE)){
MTGInPlay * defensers = game->opponent()->game->inPlay;
MTGCardInstance * defenser = defensers->getNextDefenser(NULL, card);
while (defenser != NULL){
DamagerDamaged * _defenser = findByCard(defenser);
if (!_defenser->hasLethalDamage()) return 0;
defenser = defensers->getNextDefenser(defenser, card);
}
}else{
return 0;
}
}else{ //Defenser
return 0;
}
}
}
return 1;
}
int DamageResolverLayer::trampleDamage(){
for (int i = 0; i < mCount ; i ++){
DamagerDamaged * current = (DamagerDamaged *) mObjects[i];
if (current->damageToDeal > 0){
MTGCardInstance * card = current->card;
if (card->controller() == game->currentPlayer){ //Attacker
if (card->has(TRAMPLE)){
Damage * damage = NEW Damage(0, card, game->opponent(), current->damageToDeal);
damageStack->Add(damage);
}
}
}
}
return 1;
}
int DamageResolverLayer::resolveDamages(){
trampleDamage();
for (int i = 0; i < mCount ; i++){
DamagerDamaged * current = (DamagerDamaged *) mObjects[i];
for (int j =0; j < current->mCount ; j++){
Damage * damage = NEW Damage(0, current->damages[j]->source, current->damages[j]->target, current->damages[j]->damage);
damageStack->Add(damage);
}
}
game->mLayers->stackLayer()->addAction(damageStack);
remainingDamageSteps--;
resetObjects();
damageStack = NULL;
modal = remainingDamageSteps;
return 1;
}
//a and b are opponents if b is blocking a band in which a belongs or blocking directly a
int DamageResolverLayer::isOpponent(DamagerDamaged * a, DamagerDamaged * b){
MTGCardInstance * carda = a->card;
MTGCardInstance * cardb = b->card;
if (cardb->controller() == game->currentPlayer) {//if b is the attacker switch the cards
carda = cardb;
cardb = a->card;
}
if (cardb->controller() == game->currentPlayer || carda->controller() == game->opponent()) return 0; //Same team, idiot !
if (!carda->banding){
if (cardb->isDefenser() == carda) return 1;
return 0;
}
if (cardb->isDefenser() && cardb->isDefenser()->banding == carda->banding) return 1;
return 0;
}
void DamageResolverLayer::nextPlayer(){
if (currentChoosingPlayer == game->currentPlayer){
currentChoosingPlayer = game->opponent();
if (canStopDealDamages()) resolveDamages();
}else{
resolveDamages();
}
}
void DamageResolverLayer::CheckUserInput(float dt){
if (!mCount) return;
if (mEngine->GetButtonClick(PSP_CTRL_CIRCLE)){
if (mObjects[mCurr] && mObjects[mCurr]->ButtonPressed()){
DamagerDamaged * current = (DamagerDamaged *) mObjects[mCurr];
if (!currentSource || !isOpponent(current,currentSource)){
for (int i = 0; i < mCount; i++){
DamagerDamaged * _current = (DamagerDamaged *) mObjects[i];
if (isOpponent(current,_current)){
currentSource = _current;
break;
}
}
}
if (currentSource){
if (currentSource->damageSelecter == currentChoosingPlayer){
if (isOpponent(current,currentSource)){
if (!currentSource->dealOneDamage(current)){
currentSource->removeDamagesTo(current);
}
}
}
}else{
if (current->damageSelecter == currentChoosingPlayer){
currentSource = current;
}
}
buttonOk = 0;
if (canStopDealDamages()) buttonOk = 1;
}
}else if (mEngine->GetButtonClick(PSP_CTRL_CROSS)){
if (mObjects[mCurr] && mObjects[mCurr]->ButtonPressed()){
DamagerDamaged * current = (DamagerDamaged *) mObjects[mCurr];
if (current->damageSelecter == currentChoosingPlayer){
currentSource = current;
}
}
}else if (mEngine->GetButtonClick(PSP_CTRL_SQUARE)){
if (canStopDealDamages()){
nextPlayer();
//switch to next player or end of selection
}
}else{
PlayGuiObjectController::CheckUserInput(dt);
}
}
void DamageResolverLayer::Render(){
if (!mCount) return;
JLBFont * mFont = GameApp::CommonRes->GetJLBFont(MAIN_FONT);
mFont->SetBase(0);
mFont->SetScale(0.75);
JRenderer * renderer = JRenderer::GetInstance();
renderer->FillRect(0 ,0 , SCREEN_WIDTH , SCREEN_HEIGHT , ARGB(200,0,0,0));
if (currentChoosingPlayer == game->currentPlayer){
mFont->DrawString("Player 1", 0,0);
}else{
mFont->DrawString("Player 2", 0,0);
}
if (currentSource){
currentSource->RenderBig(10, 20);
mFont->DrawString("Current Damager:", 10, 5);
}
for (int i = 0; i < mCount; i++){
((DamagerDamaged *)mObjects[i])->Render(currentChoosingPlayer);
}
if (mObjects[mCurr]){
((DamagerDamaged *)mObjects[mCurr])->Render(currentChoosingPlayer);
}
if (buttonOk){
mFont->DrawString("Damages Assigned, Click Square to Continue", 250, 5);
}
}
#include "../include/debug.h"
#include "../include/DamageResolverLayer.h"
#include "../include/GameObserver.h"
#include "../include/MTGCardInstance.h"
#include "../include/DamagerDamaged.h"
#include "../include/Damage.h"
DamageResolverLayer::DamageResolverLayer(int id, GameObserver * _game):PlayGuiObjectController(id, _game){
currentPhase = -1;
remainingDamageSteps = 0;
damageStack = NULL;
currentSource = NULL;
buttonOk = 0;
currentChoosingPlayer = NULL;
}
void DamageResolverLayer::Update(float dt){
int newPhase = game->getCurrentGamePhase();
if (newPhase == MTG_PHASE_COMBATDAMAGE){
if (!game->mLayers->stackLayer()->getNext(NULL,0,NOT_RESOLVED)){
if (newPhase != currentPhase){
init();
}
if (remainingDamageSteps && empty()){
initResolve();
}
}
}else{
remainingDamageSteps = 0;
}
currentPhase = newPhase;
PlayGuiObjectController::Update(dt);
}
Player * DamageResolverLayer::whoSelectsDamagesDealtBy(MTGCardInstance * card){
if (card->controller() == game->currentPlayer){ //Attacker
MTGInPlay * defensers = game->opponent()->game->inPlay;
int nbdefensers = defensers->nbDefensers(card);
if (nbdefensers == 0) return NULL;
if(nbdefensers == 1 && !card->has(TRAMPLE)) return NULL;
MTGCardInstance * defenser = defensers->getNextDefenser(NULL, card);
while (defenser != NULL){
if (defenser->has(BANDING)) return game->opponent();
defenser = defensers->getNextDefenser(defenser, card);
}
return game->currentPlayer;
}else{ //Defenser
MTGInPlay * attackers = game->currentPlayer->game->inPlay;
int nbattackers = attackers->nbPartners(card->isDefenser());
if(nbattackers <= 1) return NULL;
if (card->isDefenser()->banding) return game->currentPlayer;
return game->opponent();
}
}
int DamageResolverLayer::addAutoDamageToOpponents(MTGCardInstance * card){
if (card->controller() == game->currentPlayer){ //Attacker
MTGInPlay * defensers = game->opponent()->game->inPlay;
int nbdefensers = defensers->nbDefensers(card);
if (nbdefensers == 0){
Damage * damage = NEW Damage (0, card, game->opponent());
damageStack->Add(damage);
}else if (nbdefensers == 1){
Damage * damage = NEW Damage (0, card, defensers->getNextDefenser(NULL, card));
damageStack->Add(damage);
}else{
//SHOULDN'T HAPPEN !
}
}else{ //Defenser
Damage * damage = NEW Damage (mCount,card, card->isDefenser());
damageStack->Add(damage);
}
return 1;
}
int DamageResolverLayer::addIfNotExists(MTGCardInstance * card, Player * selecter){
for (int i = 0; i < mCount; i++){
DamagerDamaged * item = (DamagerDamaged *)mObjects[i];
if (item->card == card) return 0;
}
CardGui * cardg = game->mLayers->playLayer()->getByCard(card);
DamagerDamaged * item = NEW DamagerDamaged(cardg, selecter, mCount == 0);
Add(item);
mCurr = 0;
return 1;
}
//Adds a card and all its opponents to the Damagers' list
int DamageResolverLayer::addDamager(MTGCardInstance * card, Player * selecter){
addIfNotExists(card, selecter);
if (card->controller() == game->currentPlayer){ //Attacker
MTGInPlay * defensers = game->opponent()->game->inPlay;
MTGCardInstance * defenser = defensers->getNextDefenser(NULL, card);
while (defenser != NULL){
addIfNotExists(defenser, whoSelectsDamagesDealtBy(defenser));
defenser = defensers->getNextDefenser(defenser, card);
}
}else{ //Defenser
MTGInPlay * attackers = game->currentPlayer->game->inPlay;
MTGCardInstance * attacker = card->isDefenser();
addIfNotExists(attacker,whoSelectsDamagesDealtBy(attacker));
MTGCardInstance * banding = attacker->banding;
if (banding){
attacker = attackers->getNextAttacker(NULL);
while (attacker != NULL){
if (attacker->banding == banding){
addIfNotExists(attacker,whoSelectsDamagesDealtBy(attacker));
}
attacker = attackers->getNextAttacker(attacker);
}
}
}
return 1;
}
int DamageResolverLayer::initResolve(){
#if defined (WIN32) || defined (LINUX)
char buf[4096];
sprintf(buf, "starting resolve, remainingDamagesStep = %i\n", remainingDamageSteps);
OutputDebugString(buf);
#endif
if (damageStack) return 0;
#if defined (WIN32) || defined (LINUX)
sprintf(buf, "damageStack is NULL, we can resolve \n");
OutputDebugString(buf);
#endif
currentSource = NULL;
currentChoosingPlayer = game->currentPlayer;
damageStack = NEW DamageStack(mCount,game);
int strike = 0;
if (remainingDamageSteps == 2) strike = 1;
MTGInPlay * attackers = game->currentPlayer->game->inPlay;
MTGInPlay * defensers = game->opponent()->game->inPlay;
MTGCardInstance * attacker = attackers->getNextAttacker(NULL);
while (attacker != NULL){
#if defined (WIN32) || defined (LINUX)
sprintf(buf, "attacker : %s \n", attacker->getName());
OutputDebugString(buf);
#endif
if ((!strike && !attacker->has(FIRSTSTRIKE)) || (strike && attacker->has(FIRSTSTRIKE)) || attacker->has(DOUBLESTRIKE)){
Player * selecter = whoSelectsDamagesDealtBy(attacker);
if (!selecter){
addAutoDamageToOpponents(attacker);
}else{
addDamager(attacker, selecter);
}
}
MTGCardInstance * defenser = defensers->getNextDefenser(NULL, attacker);
while (defenser != NULL){
if ((!strike && !defenser->has(FIRSTSTRIKE)) || (strike && defenser->has(FIRSTSTRIKE)) || defenser->has(DOUBLESTRIKE)){
Player * selecterb = whoSelectsDamagesDealtBy(defenser);
if (!selecterb){
addAutoDamageToOpponents(defenser);
}else{
addDamager(defenser, selecterb);
}
}
defenser = defensers->getNextDefenser(defenser, attacker);
}
attacker = attackers->getNextAttacker(attacker);
}
if (empty()){
if (!damageStack->empty()){
game->mLayers->stackLayer()->addAction(damageStack);
}else{
SAFE_DELETE(damageStack);
}
remainingDamageSteps--;
damageStack = NULL;
modal = remainingDamageSteps;
}else{
if (canStopDealDamages()) currentChoosingPlayer = game->opponent();
}
return 1;
}
int DamageResolverLayer::init(){
modal = 1;
remainingDamageSteps = 2;
return 1;
}
DamagerDamaged * DamageResolverLayer::findByCard(MTGCardInstance * card){
for (int i =0; i < mCount; i++){
DamagerDamaged * current = (DamagerDamaged *) mObjects[i];
if (current->card == card) return current;
}
return NULL;
}
//Returns 1 if all "compulsory" damages have been assigned for current player
int DamageResolverLayer::canStopDealDamages(){
for (int i = 0; i < mCount ; i ++){
DamagerDamaged * current = (DamagerDamaged *) mObjects[i];
if (current->damageSelecter==currentChoosingPlayer && current->damageToDeal > 0){
MTGCardInstance * card = current->card;
if (card->controller() == game->currentPlayer){ //Attacker
if (card->has(TRAMPLE)){
MTGInPlay * defensers = game->opponent()->game->inPlay;
MTGCardInstance * defenser = defensers->getNextDefenser(NULL, card);
while (defenser != NULL){
DamagerDamaged * _defenser = findByCard(defenser);
if (!_defenser->hasLethalDamage()) return 0;
defenser = defensers->getNextDefenser(defenser, card);
}
}else{
return 0;
}
}else{ //Defenser
return 0;
}
}
}
return 1;
}
int DamageResolverLayer::trampleDamage(){
for (int i = 0; i < mCount ; i ++){
DamagerDamaged * current = (DamagerDamaged *) mObjects[i];
if (current->damageToDeal > 0){
MTGCardInstance * card = current->card;
if (card->controller() == game->currentPlayer){ //Attacker
if (card->has(TRAMPLE)){
Damage * damage = NEW Damage(0, card, game->opponent(), current->damageToDeal);
damageStack->Add(damage);
}
}
}
}
return 1;
}
int DamageResolverLayer::resolveDamages(){
trampleDamage();
for (int i = 0; i < mCount ; i++){
DamagerDamaged * current = (DamagerDamaged *) mObjects[i];
for (int j =0; j < current->mCount ; j++){
Damage * damage = NEW Damage(0, current->damages[j]->source, current->damages[j]->target, current->damages[j]->damage);
damageStack->Add(damage);
}
}
game->mLayers->stackLayer()->addAction(damageStack);
remainingDamageSteps--;
resetObjects();
damageStack = NULL;
modal = remainingDamageSteps;
return 1;
}
//a and b are opponents if b is blocking a band in which a belongs or blocking directly a
int DamageResolverLayer::isOpponent(DamagerDamaged * a, DamagerDamaged * b){
MTGCardInstance * carda = a->card;
MTGCardInstance * cardb = b->card;
if (cardb->controller() == game->currentPlayer) {//if b is the attacker switch the cards
carda = cardb;
cardb = a->card;
}
if (cardb->controller() == game->currentPlayer || carda->controller() == game->opponent()) return 0; //Same team, idiot !
if (!carda->banding){
if (cardb->isDefenser() == carda) return 1;
return 0;
}
if (cardb->isDefenser() && cardb->isDefenser()->banding == carda->banding) return 1;
return 0;
}
void DamageResolverLayer::nextPlayer(){
if (currentChoosingPlayer == game->currentPlayer){
currentChoosingPlayer = game->opponent();
if (canStopDealDamages()) resolveDamages();
}else{
resolveDamages();
}
}
void DamageResolverLayer::CheckUserInput(float dt){
if (!mCount) return;
if (mEngine->GetButtonClick(PSP_CTRL_CIRCLE)){
if (mObjects[mCurr] && mObjects[mCurr]->ButtonPressed()){
DamagerDamaged * current = (DamagerDamaged *) mObjects[mCurr];
if (!currentSource || !isOpponent(current,currentSource)){
for (int i = 0; i < mCount; i++){
DamagerDamaged * _current = (DamagerDamaged *) mObjects[i];
if (isOpponent(current,_current)){
currentSource = _current;
break;
}
}
}
if (currentSource){
if (currentSource->damageSelecter == currentChoosingPlayer){
if (isOpponent(current,currentSource)){
if (!currentSource->dealOneDamage(current)){
currentSource->removeDamagesTo(current);
}
}
}
}else{
if (current->damageSelecter == currentChoosingPlayer){
currentSource = current;
}
}
buttonOk = 0;
if (canStopDealDamages()) buttonOk = 1;
}
}else if (mEngine->GetButtonClick(PSP_CTRL_CROSS)){
if (mObjects[mCurr] && mObjects[mCurr]->ButtonPressed()){
DamagerDamaged * current = (DamagerDamaged *) mObjects[mCurr];
if (current->damageSelecter == currentChoosingPlayer){
currentSource = current;
}
}
}else if (mEngine->GetButtonClick(PSP_CTRL_SQUARE)){
if (canStopDealDamages()){
nextPlayer();
//switch to next player or end of selection
}
}else{
PlayGuiObjectController::CheckUserInput(dt);
}
}
void DamageResolverLayer::Render(){
if (!mCount) return;
JLBFont * mFont = GameApp::CommonRes->GetJLBFont(MAIN_FONT);
mFont->SetBase(0);
mFont->SetScale(0.75);
JRenderer * renderer = JRenderer::GetInstance();
renderer->FillRect(0 ,0 , SCREEN_WIDTH , SCREEN_HEIGHT , ARGB(200,0,0,0));
if (currentChoosingPlayer == game->currentPlayer){
mFont->DrawString("Player 1", 0,0);
}else{
mFont->DrawString("Player 2", 0,0);
}
if (currentSource){
currentSource->RenderBig(10, 20);
mFont->DrawString("Current Damager:", 10, 5);
}
for (int i = 0; i < mCount; i++){
((DamagerDamaged *)mObjects[i])->Render(currentChoosingPlayer);
}
if (mObjects[mCurr]){
((DamagerDamaged *)mObjects[mCurr])->Render(currentChoosingPlayer);
}
if (buttonOk){
mFont->DrawString("Damages Assigned, Click Square to Continue", 250, 5);
}
}

190
projects/mtg/src/DamagerDamaged.cpp
View File

@@ -1,95 +1,95 @@
#include "../include/debug.h"
#include "../include/DamagerDamaged.h"
DamagerDamaged::DamagerDamaged(CardGui * cardg, Player * _damageSelecter, bool _hasFocus):CardGui(0, cardg->card,cardg->defaultHeight,cardg->x,cardg->y, _hasFocus){
mCount = 0;
damageSelecter = _damageSelecter;
damageToDeal = card->power;
}
DamagerDamaged::~DamagerDamaged(){
for (int i = 0; i < mCount; i++){
delete damages[i];
damages[i] = NULL;
}
}
int DamagerDamaged::sumDamages(){
int total = 0;
for (int i = 0; i < mCount; i++){
total += damages[i]->damage;
}
return total;
}
int DamagerDamaged::hasLethalDamage(){
if (sumDamages() >= card->toughness) return 1;
return 0;
}
int DamagerDamaged::dealOneDamage(DamagerDamaged * target){
if (!damageToDeal) return 0;
damageToDeal--;
#if defined (WIN32) || defined (LINUX)
char buf[4096];
sprintf(buf, "==========\n%s can still deal %i damages\n=============\n", card->getName(), damageToDeal);
OutputDebugString(buf);
#endif
return target->addDamage(1, this);
}
int DamagerDamaged::addDamage(int damage, DamagerDamaged * source){
for (int i = 0; i < mCount; i++){
if (damages[i]->source == source->card){
damages[i]->damage+= damage;
return damage;
}
}
damages[mCount] = NEW Damage(mCount, source->card, this->card,damage);
mCount++;
return damage;
}
int DamagerDamaged::removeDamagesTo(DamagerDamaged * target){
damageToDeal+= target->removeDamagesFrom(this);
return 1;
}
int DamagerDamaged::removeDamagesFrom(DamagerDamaged * source){
for (int i = 0; i < mCount; i++){
if (damages[i]->source == source->card){
int damage = damages[i]->damage;
delete(damages[i]);
damages[i] = NULL;
damages[i] = damages[mCount-1];
mCount--;
return damage;
}
}
return 0;
}
void DamagerDamaged::Render(Player * currentPlayer){
JLBFont * mFont = GameApp::CommonRes->GetJLBFont(MAIN_FONT);
mFont->SetBase(0);
mFont->SetScale(0.75);
CardGui::Render();
char buf[4096];
if (currentPlayer != damageSelecter){
if (hasLethalDamage()){
mFont->DrawString("X",x,y);
}
mFont->SetColor(ARGB(255,255,0,0));
sprintf(buf, "%i", sumDamages());
mFont->DrawString(buf,x+5, y+5);
}else{
mFont->SetColor(ARGB(255,0,0,255));
sprintf(buf, "%i", damageToDeal);
mFont->DrawString(buf,x+5, y+5);
}
mFont->SetColor(ARGB(255,255,255,255));
}
#include "../include/debug.h"
#include "../include/DamagerDamaged.h"
DamagerDamaged::DamagerDamaged(CardGui * cardg, Player * _damageSelecter, bool _hasFocus):CardGui(0, cardg->card,cardg->defaultHeight,cardg->x,cardg->y, _hasFocus){
mCount = 0;
damageSelecter = _damageSelecter;
damageToDeal = card->power;
}
DamagerDamaged::~DamagerDamaged(){
for (int i = 0; i < mCount; i++){
delete damages[i];
damages[i] = NULL;
}
}
int DamagerDamaged::sumDamages(){
int total = 0;
for (int i = 0; i < mCount; i++){
total += damages[i]->damage;
}
return total;
}
int DamagerDamaged::hasLethalDamage(){
if (sumDamages() >= card->toughness) return 1;
return 0;
}
int DamagerDamaged::dealOneDamage(DamagerDamaged * target){
if (!damageToDeal) return 0;
damageToDeal--;
#if defined (WIN32) || defined (LINUX)
char buf[4096];
sprintf(buf, "==========\n%s can still deal %i damages\n=============\n", card->getName(), damageToDeal);
OutputDebugString(buf);
#endif
return target->addDamage(1, this);
}
int DamagerDamaged::addDamage(int damage, DamagerDamaged * source){
for (int i = 0; i < mCount; i++){
if (damages[i]->source == source->card){
damages[i]->damage+= damage;
return damage;
}
}
damages[mCount] = NEW Damage(mCount, source->card, this->card,damage);
mCount++;
return damage;
}
int DamagerDamaged::removeDamagesTo(DamagerDamaged * target){
damageToDeal+= target->removeDamagesFrom(this);
return 1;
}
int DamagerDamaged::removeDamagesFrom(DamagerDamaged * source){
for (int i = 0; i < mCount; i++){
if (damages[i]->source == source->card){
int damage = damages[i]->damage;
delete(damages[i]);
damages[i] = NULL;
damages[i] = damages[mCount-1];
mCount--;
return damage;
}
}
return 0;
}
void DamagerDamaged::Render(Player * currentPlayer){
JLBFont * mFont = GameApp::CommonRes->GetJLBFont(MAIN_FONT);
mFont->SetBase(0);
mFont->SetScale(0.75);
CardGui::Render();
char buf[4096];
if (currentPlayer != damageSelecter){
if (hasLethalDamage()){
mFont->DrawString("X",x,y);
}
mFont->SetColor(ARGB(255,255,0,0));
sprintf(buf, "%i", sumDamages());
mFont->DrawString(buf,x+5, y+5);
}else{
mFont->SetColor(ARGB(255,0,0,255));
sprintf(buf, "%i", damageToDeal);
mFont->DrawString(buf,x+5, y+5);
}
mFont->SetColor(ARGB(255,255,255,255));
}

262
projects/mtg/src/DeckDataWrapper.cpp
View File

@@ -1,131 +1,131 @@
#include "../include/DeckDataWrapper.h"
#include "../include/MTGDeck.h"
DeckDataWrapper::DeckDataWrapper(MTGDeck * deck){
parent = deck;
for (int i = 0; i <= MTG_NB_COLORS; i++){
colors[i] = 0;
}
for (int i = 0; i < deck->totalCards(); i++){
MTGCard * card = deck->_(i);
Add(card);
}
currentposition = 0;
currentColor = -1;
}
void DeckDataWrapper::save(){
parent->removeAll();
map<MTGCard *,int,Cmp1>::iterator it;
for ( it=cards.begin() ; it != cards.end(); it++ ){
MTGCard * current = (*it).first;
for (int i = 0; i < (*it).second; i++){
parent->add(current);
}
}
parent->save();
}
DeckDataWrapper::~DeckDataWrapper(){
SAFE_DELETE(parent);
}
void DeckDataWrapper::updateCounts(MTGCard * card, int removed){
if (!card){
for (int i = 0; i < MTG_NB_COLORS+1; i++){
colors[i] = 0;
}
map<MTGCard *,int,Cmp1>::iterator it;
for ( it=cards.begin() ; it != cards.end(); it++ ){
MTGCard * current = (*it).first;
colors[MTG_NB_COLORS] += (*it).second;
for (int i = 0; i < MTG_NB_COLORS; i++){
if (current->hasColor(i)) colors[i]+=(*it).second;
}
}
}else{
int increment = 1;
if (removed) increment = -1;
colors[MTG_NB_COLORS] += increment;
for (int i = 0; i < MTG_NB_COLORS; i++){
if (card->hasColor(i)) colors[i]+=increment;
}
}
}
int DeckDataWrapper::Add(MTGCard * card){
if(cards.find(card) == cards.end()){
cards[card] = 1;
}else{
cards[card]++;
}
updateCounts(card);
return cards[card];
}
int DeckDataWrapper::Remove(MTGCard * card){
if(cards.find(card) == cards.end() || cards[card] == 0) return 0;
cards[card]--;
updateCounts(card,1);
return 1;
}
MTGCard * DeckDataWrapper::getNext(MTGCard * previous, int color){
map<MTGCard *,int,Cmp1>::iterator it;
it = cards.find(previous);
int found = 0;
while(1){
if (it == cards.end()){
it = cards.begin();
}else{
it++;
}
if (it == cards.end()) return NULL;
MTGCard * card = (*it).first;
if (card == previous) return NULL;
if ((*it).second >0 && (color ==-1 || card->hasColor(color))){
return card;
}
}
}
MTGCard * DeckDataWrapper::getPrevious(MTGCard * next, int color){
map<MTGCard *,int,Cmp1>::iterator it;
it = cards.find(next);
int found = 0;
while(1){
if (it == cards.begin()){
it = cards.end();
}else{
it--;
}
if (it == cards.end()) return NULL;
MTGCard * card = (*it).first;
if (card == next) return NULL;
if ((*it).second >0 && (color ==-1 || card->hasColor(color))){
return card;
}
}
}
void DeckDataWrapper::updateCurrentPosition(MTGCard * currentCard, int color){
currentposition = 0;
MTGCard * next = getNext(NULL,color);
while (next){
currentposition+=cards[next];
if (next == currentCard){
next = NULL;
}else{
next = getNext(next,color);
}
}
}
int DeckDataWrapper::getCount(int color){
if (color == -1) return colors[MTG_NB_COLORS];
return colors[color];
}
#include "../include/DeckDataWrapper.h"
#include "../include/MTGDeck.h"
DeckDataWrapper::DeckDataWrapper(MTGDeck * deck){
parent = deck;
for (int i = 0; i <= MTG_NB_COLORS; i++){
colors[i] = 0;
}
for (int i = 0; i < deck->totalCards(); i++){
MTGCard * card = deck->_(i);
Add(card);
}
currentposition = 0;
currentColor = -1;
}
void DeckDataWrapper::save(){
parent->removeAll();
map<MTGCard *,int,Cmp1>::iterator it;
for ( it=cards.begin() ; it != cards.end(); it++ ){
MTGCard * current = (*it).first;
for (int i = 0; i < (*it).second; i++){
parent->add(current);
}
}
parent->save();
}
DeckDataWrapper::~DeckDataWrapper(){
SAFE_DELETE(parent);
}
void DeckDataWrapper::updateCounts(MTGCard * card, int removed){
if (!card){
for (int i = 0; i < MTG_NB_COLORS+1; i++){
colors[i] = 0;
}
map<MTGCard *,int,Cmp1>::iterator it;
for ( it=cards.begin() ; it != cards.end(); it++ ){
MTGCard * current = (*it).first;
colors[MTG_NB_COLORS] += (*it).second;
for (int i = 0; i < MTG_NB_COLORS; i++){
if (current->hasColor(i)) colors[i]+=(*it).second;
}
}
}else{
int increment = 1;
if (removed) increment = -1;
colors[MTG_NB_COLORS] += increment;
for (int i = 0; i < MTG_NB_COLORS; i++){
if (card->hasColor(i)) colors[i]+=increment;
}
}
}
int DeckDataWrapper::Add(MTGCard * card){
if(cards.find(card) == cards.end()){
cards[card] = 1;
}else{
cards[card]++;
}
updateCounts(card);
return cards[card];
}
int DeckDataWrapper::Remove(MTGCard * card){
if(cards.find(card) == cards.end() || cards[card] == 0) return 0;
cards[card]--;
updateCounts(card,1);
return 1;
}
MTGCard * DeckDataWrapper::getNext(MTGCard * previous, int color){
map<MTGCard *,int,Cmp1>::iterator it;
it = cards.find(previous);
int found = 0;
while(1){
if (it == cards.end()){
it = cards.begin();
}else{
it++;
}
if (it == cards.end()) return NULL;
MTGCard * card = (*it).first;
if (card == previous) return NULL;
if ((*it).second >0 && (color ==-1 || card->hasColor(color))){
return card;
}
}
}
MTGCard * DeckDataWrapper::getPrevious(MTGCard * next, int color){
map<MTGCard *,int,Cmp1>::iterator it;
it = cards.find(next);
int found = 0;
while(1){
if (it == cards.begin()){
it = cards.end();
}else{
it--;
}
if (it == cards.end()) return NULL;
MTGCard * card = (*it).first;
if (card == next) return NULL;
if ((*it).second >0 && (color ==-1 || card->hasColor(color))){
return card;
}
}
}
void DeckDataWrapper::updateCurrentPosition(MTGCard * currentCard, int color){
currentposition = 0;
MTGCard * next = getNext(NULL,color);
while (next){
currentposition+=cards[next];
if (next == currentCard){
next = NULL;
}else{
next = getNext(next,color);
}
}
}
int DeckDataWrapper::getCount(int color){
if (color == -1) return colors[MTG_NB_COLORS];
return colors[color];
}

118
projects/mtg/src/DuelLayers.cpp
View File

@@ -1,63 +1,63 @@
#include "../include/debug.h"
#include "../include/DuelLayers.h"
#include "../include/MTGRules.h"
#include "../include/DamageResolverLayer.h"
void DuelLayers::init(){
#include "../include/debug.h"
#include "../include/DuelLayers.h"
#include "../include/MTGRules.h"
#include "../include/DamageResolverLayer.h"
//0 Stack Layer
ActionStack * mActionStack = NEW ActionStack(0, GameObserver::GetInstance());
//Damage Resolver
DamageResolverLayer * mDamageResolver = NEW DamageResolverLayer(1, GameObserver::GetInstance());
//1 Action Layer
GuiLayer * actionLayer = NEW ActionLayer(2, GameObserver::GetInstance());
MTGGamePhase * phaseManager = NEW MTGGamePhase(actionLayer->getMaxId());
actionLayer->Add(phaseManager);
//Add Magic Specific Rules
actionLayer->Add(NEW MTGAttackRule(-1));
actionLayer->Add(NEW MTGBlockRule(-1));
actionLayer->Add(NEW MTGLegendRule(-1));
actionLayer->Add(NEW MTGPersistRule(-1));
//2 Hand Layer
MTGGuiHand * mGuiHand = NEW MTGGuiHand(3, GameObserver::GetInstance());
//3 Game
MTGGuiPlay * play = NEW MTGGuiPlay(4, GameObserver::GetInstance());
void DuelLayers::init(){
//0 Stack Layer
ActionStack * mActionStack = NEW ActionStack(0, GameObserver::GetInstance());
//Damage Resolver
DamageResolverLayer * mDamageResolver = NEW DamageResolverLayer(1, GameObserver::GetInstance());
//1 Action Layer
GuiLayer * actionLayer = NEW ActionLayer(2, GameObserver::GetInstance());
MTGGamePhase * phaseManager = NEW MTGGamePhase(actionLayer->getMaxId());
actionLayer->Add(phaseManager);
//Add Magic Specific Rules
actionLayer->Add(NEW MTGAttackRule(-1));
actionLayer->Add(NEW MTGBlockRule(-1));
actionLayer->Add(NEW MTGLegendRule(-1));
actionLayer->Add(NEW MTGPersistRule(-1));
//2 Hand Layer
MTGGuiHand * mGuiHand = NEW MTGGuiHand(3, GameObserver::GetInstance());
//3 Game
MTGGuiPlay * play = NEW MTGGuiPlay(4, GameObserver::GetInstance());
Add(mActionStack);
Add(mDamageResolver);
Add(actionLayer);
Add(mGuiHand);
Add(play);
}
ActionStack * DuelLayers::stackLayer(){
return ((ActionStack *) (objects[0]));
}
DamageResolverLayer * DuelLayers::combatLayer(){
return ((DamageResolverLayer *) (objects[1]));
}
ActionLayer * DuelLayers::actionLayer(){
return ((ActionLayer *) (objects[2]));
}
MTGGuiHand * DuelLayers::handLayer(){
return ((MTGGuiHand *) (objects[3]));
}
MTGGuiPlay * DuelLayers::playLayer(){
return ((MTGGuiPlay *) (objects[4]));
}
Add(mActionStack);
Add(mDamageResolver);
Add(actionLayer);
Add(mGuiHand);
Add(play);
}
ActionStack * DuelLayers::stackLayer(){
return ((ActionStack *) (objects[0]));
}
DamageResolverLayer * DuelLayers::combatLayer(){
return ((DamageResolverLayer *) (objects[1]));
}
ActionLayer * DuelLayers::actionLayer(){
return ((ActionLayer *) (objects[2]));
}
MTGGuiHand * DuelLayers::handLayer(){
return ((MTGGuiHand *) (objects[3]));
}
MTGGuiPlay * DuelLayers::playLayer(){
return ((MTGGuiPlay *) (objects[4]));
}

500
projects/mtg/src/GameApp.cpp
View File

@@ -1,250 +1,250 @@
#include "../include/debug.h"
#include <JGE.h>
#include <JRenderer.h>
#if defined (WIN32) || defined (LINUX)
#else
#include <pspfpu.h>
#endif
#include "../include/GameApp.h"
#include "../include/Subtypes.h"
#include "../include/GameStateDeckViewer.h"
#include "../include/GameStateMenu.h"
#include "../include/GameStateDuel.h"
#include "../include/GameStateOptions.h"
#include "../include/GameStateShop.h"
const char * const GameState::menuTexts[]= {"--NEW--","Deck 1", "Deck 2", "Deck 3", "Deck 4", "Deck 5", "Deck 6"} ;
JResourceManager* GameApp::CommonRes = NEW JResourceManager();
hgeParticleSystem* GameApp::Particles[] = {NULL,NULL,NULL,NULL,NULL,NULL};
int GameApp::HasMusic = 1;
GameState::GameState(GameApp* parent): mParent(parent)
{
mEngine = JGE::GetInstance();
}
GameApp::GameApp(): JApp()
{
mScreenShotCount = 0;
for (int i=0; i < MAX_STATE ; i++)
mGameStates[i] = NULL;
mShowDebugInfo = false;
players[0] = 0;
players[1] = 0;
}
GameApp::~GameApp()
{
}
void GameApp::Create()
{
#if defined (WIN32)
_CrtSetDbgFlag ( _CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF );
#elif not defined (LINUX)
pspfpu_set_enable(0); //disable FPU Exceptions until we find where the FPU errors come from
#endif
//_CrtSetBreakAlloc(368);
LOG("starting Game");
//Test for Music files presence
std::ifstream file("Res/sound/Track0.mp3");
if(file){
file.close();
}else{
HasMusic = 0;
}
std::ifstream file2("Res/sound/Track1.mp3");
if(file2){
file2.close();
}else{
HasMusic = 0;
}
CommonRes->CreateTexture("graphics/menuicons.png");
//Creating thes quad in this specific order allows us to have them in the correct order to call them by integer id
CommonRes->CreateQuad("c_artifact", "graphics/menuicons.png", 10 + 6*32, 32, 32, 32);
CommonRes->CreateQuad("c_green", "graphics/menuicons.png", 10 + 0*32, 32, 32, 32);
CommonRes->CreateQuad("c_blue", "graphics/menuicons.png", 10 + 1*32, 32, 32, 32);
CommonRes->CreateQuad("c_red", "graphics/menuicons.png", 10 + 3*32, 32, 32, 32);
CommonRes->CreateQuad("c_black", "graphics/menuicons.png", 10 + 2*32, 32, 32, 32);
CommonRes->CreateQuad("c_white", "graphics/menuicons.png", 10 + 4*32, 32, 32, 32);
CommonRes->CreateQuad("c_land", "graphics/menuicons.png", 10 + 5*32, 32, 32, 32);
CommonRes->CreateTexture("sets/back.jpg");
CommonRes->CreateQuad("back", "sets/back.jpg", 0, 0, 200, 285);
CommonRes->CreateTexture("sets/back_thumb.jpg");
CommonRes->CreateQuad("back_thumb", "sets/back_thumb.jpg", 0, 0, 45, 64);
CommonRes->CreateTexture("graphics/particles.png");
CommonRes->CreateQuad("particles", "graphics/particles.png", 0, 0, 32, 32);
CommonRes->GetQuad("particles")->SetHotSpot(16,16);
CommonRes->LoadJLBFont("graphics/f3",16);
CommonRes->LoadJLBFont("graphics/magic",16);
//CommonRes->CreateTexture("graphics/interrupt.png");
//CommonRes->CreateQuad("interrupt", "graphics/interrupt.png", 0, 0, 256, 128);
cache = NEW TexturesCache();
collection = NEW MTGAllCards(cache);
Particles[0] = NEW hgeParticleSystem("graphics/particle1.psi", CommonRes->GetQuad("particles"));
Particles[1] = NEW hgeParticleSystem("graphics/particle2.psi", CommonRes->GetQuad("particles"));
Particles[2] = NEW hgeParticleSystem("graphics/particle3.psi", CommonRes->GetQuad("particles"));
Particles[3] = NEW hgeParticleSystem("graphics/particle4.psi", CommonRes->GetQuad("particles"));
Particles[4] = NEW hgeParticleSystem("graphics/particle5.psi", CommonRes->GetQuad("particles"));
Particles[5] = NEW hgeParticleSystem("graphics/particle7.psi", CommonRes->GetQuad("particles"));
mGameStates[GAME_STATE_DECK_VIEWER] = NEW GameStateDeckViewer(this);
mGameStates[GAME_STATE_DECK_VIEWER]->Create();
mGameStates[GAME_STATE_MENU] = NEW GameStateMenu(this);
mGameStates[GAME_STATE_MENU]->Create();
mGameStates[GAME_STATE_DUEL] = NEW GameStateDuel(this);
mGameStates[GAME_STATE_DUEL]->Create();
mGameStates[GAME_STATE_SHOP] = NEW GameStateShop(this);
mGameStates[GAME_STATE_SHOP]->Create();
mGameStates[GAME_STATE_OPTIONS] = NEW GameStateOptions(this);
mGameStates[GAME_STATE_OPTIONS]->Create();
//mGameStates[GAME_STATE_GAME] = NEW GameStateGAME(this);
mCurrentState = NULL;
mNextState = mGameStates[GAME_STATE_MENU];
}
void GameApp::LoadGameStates()
{
//mGameStates[GAME_STATE_MENU]->Create();
//mGameStates[GAME_STATE_GAME]->Create();
}
void GameApp::Destroy()
{
LOG("==Destroying GameApp==");
for (int i=GAME_STATE_MENU;i<=MAX_STATE-1;i++)
{
if (mGameStates[i]){
mGameStates[i]->Destroy();
delete mGameStates[i];
}
}
for (int i= 0; i < 6; i++){
delete Particles[i];
}
if (collection){
collection->destroyAllCards();
delete collection;
}
if (cache) delete cache;
if (CommonRes) delete CommonRes;
GameOptions::Destroy();
if (Subtypes::subtypesList) delete Subtypes::subtypesList;
if (MtgSets::SetsList) delete MtgSets::SetsList;
LOG("==Destroying GameApp Successful==");
}
void GameApp::Update()
{
JGE* mEngine = JGE::GetInstance();
if (mEngine->GetButtonState(PSP_CTRL_START) && mEngine->GetButtonClick(PSP_CTRL_TRIANGLE))
{
char s[80];
sprintf(s, "ms0:/psp/photo/MTG%d.png", mScreenShotCount++);
JRenderer::GetInstance()->ScreenShot(s);
}
//Exit when START and X ARE PRESSED SIMULTANEOUSLY
if (mEngine->GetButtonState(PSP_CTRL_START) && mEngine->GetButtonState(PSP_CTRL_CROSS)){
mEngine->End();
return;
}
float dt = mEngine->GetDelta();
if (dt > 35.0f) // min 30 FPS ;)
dt = 35.0f;
if (mCurrentState != NULL)
mCurrentState->Update(dt);
if (mNextState != NULL)
{
if (mCurrentState != NULL)
mCurrentState->End();
mCurrentState = mNextState;
mCurrentState->Start();
mNextState = NULL;
}
}
void GameApp::Render()
{
if (mCurrentState != NULL)
{
mCurrentState->Render();
}
}
void GameApp::SetNextState(int state)
{
mNextState = mGameStates[state];
}
void GameApp::Pause(){
}
void GameApp::Resume(){
}
#include "../include/debug.h"
#include <JGE.h>
#include <JRenderer.h>
#if defined (WIN32) || defined (LINUX)
#else
#include <pspfpu.h>
#endif
#include "../include/GameApp.h"
#include "../include/Subtypes.h"
#include "../include/GameStateDeckViewer.h"
#include "../include/GameStateMenu.h"
#include "../include/GameStateDuel.h"
#include "../include/GameStateOptions.h"
#include "../include/GameStateShop.h"
const char * const GameState::menuTexts[]= {"--NEW--","Deck 1", "Deck 2", "Deck 3", "Deck 4", "Deck 5", "Deck 6"} ;
JResourceManager* GameApp::CommonRes = NEW JResourceManager();
hgeParticleSystem* GameApp::Particles[] = {NULL,NULL,NULL,NULL,NULL,NULL};
int GameApp::HasMusic = 1;
GameState::GameState(GameApp* parent): mParent(parent)
{
mEngine = JGE::GetInstance();
}
GameApp::GameApp(): JApp()
{
mScreenShotCount = 0;
for (int i=0; i < MAX_STATE ; i++)
mGameStates[i] = NULL;
mShowDebugInfo = false;
players[0] = 0;
players[1] = 0;
}
GameApp::~GameApp()
{
}
void GameApp::Create()
{
#if defined (WIN32)
_CrtSetDbgFlag ( _CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF );
#elif not defined (LINUX)
pspfpu_set_enable(0); //disable FPU Exceptions until we find where the FPU errors come from
#endif
//_CrtSetBreakAlloc(368);
LOG("starting Game");
//Test for Music files presence
std::ifstream file("Res/sound/Track0.mp3");
if(file){
file.close();
}else{
HasMusic = 0;
}
std::ifstream file2("Res/sound/Track1.mp3");
if(file2){
file2.close();
}else{
HasMusic = 0;
}
CommonRes->CreateTexture("graphics/menuicons.png");
//Creating thes quad in this specific order allows us to have them in the correct order to call them by integer id
CommonRes->CreateQuad("c_artifact", "graphics/menuicons.png", 10 + 6*32, 32, 32, 32);
CommonRes->CreateQuad("c_green", "graphics/menuicons.png", 10 + 0*32, 32, 32, 32);
CommonRes->CreateQuad("c_blue", "graphics/menuicons.png", 10 + 1*32, 32, 32, 32);
CommonRes->CreateQuad("c_red", "graphics/menuicons.png", 10 + 3*32, 32, 32, 32);
CommonRes->CreateQuad("c_black", "graphics/menuicons.png", 10 + 2*32, 32, 32, 32);
CommonRes->CreateQuad("c_white", "graphics/menuicons.png", 10 + 4*32, 32, 32, 32);
CommonRes->CreateQuad("c_land", "graphics/menuicons.png", 10 + 5*32, 32, 32, 32);
CommonRes->CreateTexture("sets/back.jpg");
CommonRes->CreateQuad("back", "sets/back.jpg", 0, 0, 200, 285);
CommonRes->CreateTexture("sets/back_thumb.jpg");
CommonRes->CreateQuad("back_thumb", "sets/back_thumb.jpg", 0, 0, 45, 64);
CommonRes->CreateTexture("graphics/particles.png");
CommonRes->CreateQuad("particles", "graphics/particles.png", 0, 0, 32, 32);
CommonRes->GetQuad("particles")->SetHotSpot(16,16);
CommonRes->LoadJLBFont("graphics/f3",16);
CommonRes->LoadJLBFont("graphics/magic",16);
//CommonRes->CreateTexture("graphics/interrupt.png");
//CommonRes->CreateQuad("interrupt", "graphics/interrupt.png", 0, 0, 256, 128);
cache = NEW TexturesCache();
collection = NEW MTGAllCards(cache);
Particles[0] = NEW hgeParticleSystem("graphics/particle1.psi", CommonRes->GetQuad("particles"));
Particles[1] = NEW hgeParticleSystem("graphics/particle2.psi", CommonRes->GetQuad("particles"));
Particles[2] = NEW hgeParticleSystem("graphics/particle3.psi", CommonRes->GetQuad("particles"));
Particles[3] = NEW hgeParticleSystem("graphics/particle4.psi", CommonRes->GetQuad("particles"));
Particles[4] = NEW hgeParticleSystem("graphics/particle5.psi", CommonRes->GetQuad("particles"));
Particles[5] = NEW hgeParticleSystem("graphics/particle7.psi", CommonRes->GetQuad("particles"));
mGameStates[GAME_STATE_DECK_VIEWER] = NEW GameStateDeckViewer(this);
mGameStates[GAME_STATE_DECK_VIEWER]->Create();
mGameStates[GAME_STATE_MENU] = NEW GameStateMenu(this);
mGameStates[GAME_STATE_MENU]->Create();
mGameStates[GAME_STATE_DUEL] = NEW GameStateDuel(this);
mGameStates[GAME_STATE_DUEL]->Create();
mGameStates[GAME_STATE_SHOP] = NEW GameStateShop(this);
mGameStates[GAME_STATE_SHOP]->Create();
mGameStates[GAME_STATE_OPTIONS] = NEW GameStateOptions(this);
mGameStates[GAME_STATE_OPTIONS]->Create();
//mGameStates[GAME_STATE_GAME] = NEW GameStateGAME(this);
mCurrentState = NULL;
mNextState = mGameStates[GAME_STATE_MENU];
}
void GameApp::LoadGameStates()
{
//mGameStates[GAME_STATE_MENU]->Create();
//mGameStates[GAME_STATE_GAME]->Create();
}
void GameApp::Destroy()
{
LOG("==Destroying GameApp==");
for (int i=GAME_STATE_MENU;i<=MAX_STATE-1;i++)
{
if (mGameStates[i]){
mGameStates[i]->Destroy();
delete mGameStates[i];
}
}
for (int i= 0; i < 6; i++){
delete Particles[i];
}
if (collection){
collection->destroyAllCards();
delete collection;
}
if (cache) delete cache;
if (CommonRes) delete CommonRes;
GameOptions::Destroy();
if (Subtypes::subtypesList) delete Subtypes::subtypesList;
if (MtgSets::SetsList) delete MtgSets::SetsList;
LOG("==Destroying GameApp Successful==");
}
void GameApp::Update()
{
JGE* mEngine = JGE::GetInstance();
if (mEngine->GetButtonState(PSP_CTRL_START) && mEngine->GetButtonClick(PSP_CTRL_TRIANGLE))
{
char s[80];
sprintf(s, "ms0:/psp/photo/MTG%d.png", mScreenShotCount++);
JRenderer::GetInstance()->ScreenShot(s);
}
//Exit when START and X ARE PRESSED SIMULTANEOUSLY
if (mEngine->GetButtonState(PSP_CTRL_START) && mEngine->GetButtonState(PSP_CTRL_CROSS)){
mEngine->End();
return;
}
float dt = mEngine->GetDelta();
if (dt > 35.0f) // min 30 FPS ;)
dt = 35.0f;
if (mCurrentState != NULL)
mCurrentState->Update(dt);
if (mNextState != NULL)
{
if (mCurrentState != NULL)
mCurrentState->End();
mCurrentState = mNextState;
mCurrentState->Start();
mNextState = NULL;
}
}
void GameApp::Render()
{
if (mCurrentState != NULL)
{
mCurrentState->Render();
}
}
void GameApp::SetNextState(int state)
{
mNextState = mGameStates[state];
}
void GameApp::Pause(){
}
void GameApp::Resume(){
}

62
projects/mtg/src/GameApp.h
View File

@@ -1,31 +1,31 @@
//-------------------------------------------------------------------------------------
//
// JGE++ is a hardware accelerated 2D game SDK for PSP/Windows.
//
// Licensed under the BSD license, see LICENSE in JGE root for details.
//
// Copyright (c) 2007 James Hui (a.k.a. Dr.Watson) <jhkhui@gmail.com>
//
//-------------------------------------------------------------------------------------
#ifndef _GAMEAPP_H_
#define _GAMEAPP_H_
#include <JApp.h>
class GameApp: public JApp
{
public:
GameApp();
virtual ~GameApp();
virtual void Create();
virtual void Destroy();
virtual void Update();
virtual void Render();
virtual void Pause();
virtual void Resume();
};
#endif
//-------------------------------------------------------------------------------------
//
// JGE++ is a hardware accelerated 2D game SDK for PSP/Windows.
//
// Licensed under the BSD license, see LICENSE in JGE root for details.
//
// Copyright (c) 2007 James Hui (a.k.a. Dr.Watson) <jhkhui@gmail.com>
//
//-------------------------------------------------------------------------------------
#ifndef _GAMEAPP_H_
#define _GAMEAPP_H_
#include <JApp.h>
class GameApp: public JApp
{
public:
GameApp();
virtual ~GameApp();
virtual void Create();
virtual void Destroy();
virtual void Update();
virtual void Render();
virtual void Pause();
virtual void Resume();
};
#endif

72
projects/mtg/src/GameLauncher.cpp
View File

@@ -1,36 +1,36 @@
//-------------------------------------------------------------------------------------
//
// JGE++ is a hardware accelerated 2D game SDK for PSP/Windows.
//
// Licensed under the BSD license, see LICENSE in JGE root for details.
//
// Copyright (c) 2007 James Hui (a.k.a. Dr.Watson) <jhkhui@gmail.com>
//
//-------------------------------------------------------------------------------------
#include "../include/debug.h"
#include <string.h>
#include <JGameLauncher.h>
#include "../include/GameApp.h"
//-------------------------------------------------------------------------------------
JApp* JGameLauncher::GetGameApp()
{
return NEW GameApp();
};
//-------------------------------------------------------------------------------------
char *JGameLauncher::GetName()
{
return strdup("Wagic");
}
//-------------------------------------------------------------------------------------
u32 JGameLauncher::GetInitFlags()
{
return JINIT_FLAG_NORMAL;
}
//-------------------------------------------------------------------------------------
//
// JGE++ is a hardware accelerated 2D game SDK for PSP/Windows.
//
// Licensed under the BSD license, see LICENSE in JGE root for details.
//
// Copyright (c) 2007 James Hui (a.k.a. Dr.Watson) <jhkhui@gmail.com>
//
//-------------------------------------------------------------------------------------
#include "../include/debug.h"
#include <string.h>
#include <JGameLauncher.h>
#include "../include/GameApp.h"
//-------------------------------------------------------------------------------------
JApp* JGameLauncher::GetGameApp()
{
return NEW GameApp();
};
//-------------------------------------------------------------------------------------
char *JGameLauncher::GetName()
{
return strdup("Wagic");
}
//-------------------------------------------------------------------------------------
u32 JGameLauncher::GetInitFlags()
{
return JINIT_FLAG_NORMAL;
}

962
projects/mtg/src/GameObserver.cpp
View File

@@ -1,481 +1,481 @@
#include "../include/debug.h"
#include "../include/GameObserver.h"
#include "../include/GameOptions.h"
#include "../include/ConstraintResolver.h"
#include "../include/CardGui.h"
#include "../include/Damage.h"
#include "../include/DamageResolverLayer.h"
#include <JRenderer.h>
GameObserver * GameObserver::mInstance = NULL;
GameObserver* GameObserver::GetInstance()
{
return mInstance;
}
void GameObserver::EndInstance()
{
SAFE_DELETE(mInstance);
}
void GameObserver::Init(Player * _players[], int _nbplayers){
mInstance = NEW GameObserver(_players, _nbplayers);
mInstance->mLayers = NEW DuelLayers();
mInstance->mLayers->init();
}
GameObserver::GameObserver(Player * _players[], int _nb_players){
int i;
for (i =0; i < _nb_players;i ++){
players[i] = _players[i];
}
currentPlayer = players[0];
currentActionPlayer = currentPlayer;
isInterrupting = NULL;
currentPlayerId = 0;
nbPlayers = _nb_players;
currentRound = 1;
currentGamePhase = -1;
targetChooser = NULL;
cardWaitingForTargets = NULL;
reaction = 0;
gameOver = NULL;
phaseRing = NEW PhaseRing(_players,_nb_players);
}
void GameObserver::setGamePhaseManager(MTGGamePhase * _phases){
gamePhaseManager = _phases;
}
int GameObserver::getCurrentGamePhase(){
return currentGamePhase;
}
Player * GameObserver::opponent(){
int index = (currentPlayerId+1)%nbPlayers;
return players[index];
}
int GameObserver::enteringPhase(int phase){
//TODO
return 0;
}
void GameObserver::nextPlayer(){
currentPlayerId = (currentPlayerId+1)%nbPlayers;
currentPlayer = players[currentPlayerId];
currentActionPlayer = currentPlayer;
}
void GameObserver::nextGamePhase(){
phaseRing->forward();
Phase * cPhase = phaseRing->getCurrentPhase();
currentGamePhase = cPhase->id;
if (currentPlayer != cPhase->player) nextPlayer();
//init begin of turn
if (currentGamePhase == MTG_PHASE_BEFORE_BEGIN){
cleanupPhase();
currentPlayer->canPutLandsIntoPlay = 1;
mLayers->actionLayer()->Update(0);
return nextGamePhase();
}
//manaBurn
if (currentGamePhase == MTG_PHASE_UNTAP ||
currentGamePhase == MTG_PHASE_FIRSTMAIN ||
currentGamePhase == MTG_PHASE_COMBATBEGIN ||
currentGamePhase == MTG_PHASE_SECONDMAIN ||
currentGamePhase == MTG_PHASE_ENDOFTURN
){
currentPlayer->manaBurn();
}
//After End of turn
if (currentGamePhase == MTG_PHASE_AFTER_EOT){
//Auto Hand cleaning, in case the player didn't do it himself
while(currentPlayer->game->hand->nb_cards > 7){
currentPlayer->game->putInGraveyard(currentPlayer->game->hand->cards[0]);
}
mLayers->stackLayer()->garbageCollect(); //clean stack history for this turn;
mLayers->actionLayer()->Update(0);
return nextGamePhase();
}
//Phase Specific actions
switch(currentGamePhase){
case MTG_PHASE_UNTAP:
untapPhase();
break;
case MTG_PHASE_DRAW:
mLayers->stackLayer()->addDraw(currentPlayer,1);
break;
default:
break;
}
}
int GameObserver::cancelCurrentAction(){
SAFE_DELETE(targetChooser);
return 1;
}
void GameObserver::userRequestNextGamePhase(){
if (mLayers->stackLayer()->getNext(NULL,0,NOT_RESOLVED)) return;
if (getCurrentTargetChooser()) return;
if (mLayers->combatLayer()->remainingDamageSteps) return;
//TODO CHECK POSSIBILITY
if (opponent()->isAI() || GameOptions::GetInstance()->values[OPTIONS_INTERRUPTATENDOFPHASE_OFFSET+currentGamePhase]){
mLayers->stackLayer()->AddNextGamePhase();
}else{
nextGamePhase();
}
}
void GameObserver::startGame(int shuffle, int draw){
int i;
for (i=0; i<nbPlayers; i++){
players[i]->game->initGame(shuffle, draw);
}
phaseRing->goToPhase(MTG_PHASE_FIRSTMAIN, players[0]);
currentGamePhase = MTG_PHASE_FIRSTMAIN;
}
void GameObserver::addObserver(MTGAbility * observer){
mLayers->actionLayer()->Add(observer);
}
void GameObserver::removeObserver(ActionElement * observer){
if (observer){
observer->destroy();
}else{
//TODO log error
}
mLayers->actionLayer()->Remove(observer);
}
GameObserver::~GameObserver(){
LOG("==Destroying GameObserver==");
SAFE_DELETE(targetChooser);
SAFE_DELETE(mLayers);
SAFE_DELETE(phaseRing);
LOG("==GameObserver Destroyed==");
}
void GameObserver::Update(float dt){
Player * player = currentPlayer;
if (currentGamePhase == MTG_PHASE_COMBATBLOCKERS){
player = opponent();
}else if (currentGamePhase == MTG_PHASE_COMBATDAMAGE){
DamageResolverLayer * drl = mLayers->combatLayer();
if (drl->currentChoosingPlayer && drl->mCount) player = drl->currentChoosingPlayer;
}
currentActionPlayer = player;
if (isInterrupting) player = isInterrupting;
mLayers->Update(dt,player);
stateEffects();
oldGamePhase = currentGamePhase;
}
//applies damage to creatures after updates
//Players life test
void GameObserver::stateEffects(){
for (int i =0; i < 2; i++){
MTGGameZone * zone = players[i]->game->inPlay;
for (int j = zone->nb_cards-1 ; j>=0; j--){
MTGCardInstance * card = zone->cards[j];
card->afterDamage();
}
}
for (int i =0; i < 2; i++){
if (players[i]->life <= 0) gameOver = players[i];
}
}
void GameObserver::Render(){
mLayers->Render();
if (targetChooser || mLayers->actionLayer()->isWaitingForAnswer()){
JRenderer::GetInstance()->DrawRect(0,0,SCREEN_WIDTH,SCREEN_HEIGHT,ARGB(255,255,0,0));
}
}
void GameObserver::nextStep(){
}
void GameObserver::ButtonPressed (int controllerId, PlayGuiObject * _object){
#if defined (WIN32) || defined (LINUX)
OutputDebugString("Click\n");
#endif
int id = _object->GetId();
if (id >=0){
MTGCardInstance * card = ((CardGui *)_object)->card;
cardClick(card, card);
}
//if (id>= -6 && id <= -3){
if (id== -5 || id == -3){ //TODO libraries ???
GuiGameZone * zone = (GuiGameZone *)_object;
zone->toggleDisplay();
}
if (id == -1 || id == -2){
#if defined (WIN32) || defined (LINUX)
OutputDebugString("Click Player !\n");
#endif
cardClick(NULL, ((GuiAvatar *)_object)->player);
}
}
void GameObserver::stackObjectClicked(Interruptible * action){
if (targetChooser != NULL){
#if defined (WIN32) || defined (LINUX)
OutputDebugString("target chooser ok \n");
#endif
int result = targetChooser->toggleTarget(action);
if (result == TARGET_OK_FULL){
#if defined (WIN32) || defined (LINUX)
OutputDebugString("target chooser Full \n");
#endif
cardClick(cardWaitingForTargets);
}else{
return;
}
}else{
reaction = mLayers->actionLayer()->isReactingToTargetClick(action);
if (reaction == -1) mLayers->actionLayer()->reactToTargetClick(action);
}
}
void GameObserver::cardClick (MTGCardInstance * card, Targetable * object){
LOG("==GameObserver::cardClick");
if (card) {LOG(card->getName())};
Player * clickedPlayer = NULL;
if (!card) clickedPlayer = ((Player *)object);
if (targetChooser != NULL){
int result;
if (card) {
if (card == cardWaitingForTargets){
LOG("attempt to close targetting");
int _result = targetChooser->ForceTargetListReady();
if (_result){
result = TARGET_OK_FULL;
}else{
LOG("...but we cant!\n");
result = targetChooser->targetsReadyCheck();
}
}else{
result = targetChooser->toggleTarget(card);
}
}else{
result = targetChooser->toggleTarget(clickedPlayer);
}
if (result == TARGET_OK_FULL){
card = cardWaitingForTargets;
}else{
return;
}
}
if (card){
reaction = mLayers->actionLayer()->isReactingToClick(card);
if (reaction == -1) mLayers->actionLayer()->reactToClick(card);
}else{
reaction = mLayers->actionLayer()->isReactingToTargetClick(object);
if (reaction == -1) mLayers->actionLayer()->reactToTargetClick(object);
}
if (reaction != -1){
if (!card) return;
if (currentlyActing()->game->hand->hasCard(card)){
//Current player's hand
if (canPutInPlay(card)){
putInPlay(card);
if (card->hasType("land")){
currentPlayer->canPutLandsIntoPlay--;
}
}else if (currentPlayer->game->hand->hasCard(card)){ //Current player's hand
if (currentGamePhase == MTG_PHASE_CLEANUP && currentPlayer->game->hand->nb_cards > 7){
currentPlayer->game->putInGraveyard(card);
}
}
}else if (reaction){
if (reaction == 1){
mLayers->actionLayer()->reactToClick(card);
}else{
mLayers->actionLayer()->setMenuObject(object);
}
}else if (card->isTapped() && card->controller() == currentPlayer){
int a = ConstraintResolver::untap(this, card);
}
}
}
TargetChooser * GameObserver::getCurrentTargetChooser(){
TargetChooser * _tc = mLayers->actionLayer()->getCurrentTargetChooser();
if (_tc) return _tc;
return targetChooser;
}
//Check if it is possible to put a card into play
//TODO : improve according to spells in game...
int GameObserver::canPutInPlay(MTGCardInstance * card){
Player * player = currentlyActing();
LOG("CANPUTINPLAY- check if card belongs to current player\n");
if (!player->game->hand->hasCard(card)) return 0;
LOG("CANPUTINPLAY- check if card is land or can be played\n");
if (card->hasType("land")){
LOG("CANPUTINPLAY- card is land - check if can be played\n");
if (player == currentPlayer && currentPlayer->canPutLandsIntoPlay && (currentGamePhase == MTG_PHASE_FIRSTMAIN || currentGamePhase == MTG_PHASE_SECONDMAIN)){
LOG("CANPUTINPLAY- Land, ok\n");
return 1;
}
}else if ((card->hasType("instant")) || card->has(FLASH) || (player == currentPlayer && (currentGamePhase == MTG_PHASE_FIRSTMAIN || currentGamePhase == MTG_PHASE_SECONDMAIN))){
LOG("CANPUTINPLAY- correct time to play\n");
if (checkManaCost(card)){
LOG("CANPUTINPLAY- ManaCost ok\n");
if (targetListIsSet(card)){
#ifdef LOG
LOG("CANPUTINPLAY- Targets chosen -> OK\n");
#endif
return 1;
}else{
#ifdef LOG
LOG("CANPUTINPLAY- Targets not chosen yet\n");
#endif
return 0;
}
}
}
return 0;
}
void GameObserver::putInPlay(MTGCardInstance * card){
Player * player = currentlyActing();
ManaCost * previousManaPool = NEW ManaCost(player->getManaPool());
player->getManaPool()->pay(card->getManaCost());
ManaCost * spellCost = previousManaPool->Diff(player->getManaPool());
delete previousManaPool;
if (card->hasType("land")){
Spell * spell = NEW Spell(card);
player->game->putInZone(card, player->game->hand, player->game->stack);
spell->resolve();
delete spellCost;
delete spell;
}else{
if (targetChooser){
mLayers->stackLayer()->addSpell(card,targetChooser->targets,targetChooser->cursor, spellCost);
delete targetChooser;
targetChooser = NULL;
}else{
mLayers->stackLayer()->addSpell(card,NULL,0, spellCost);
}
player->game->putInZone(card, player->game->hand, player->game->stack);
}
}
/* Returns true if the card is in one of the player's play zone */
int GameObserver::isInPlay(MTGCardInstance * card){
for (int i = 0; i < 2; i++){
if (players[i]->game->isInPlay(card)) return 1;
}
return 0;
}
void GameObserver::draw(){
//TODO checks to allow multiple draw, or no draw, etc...
currentPlayer->game->drawFromLibrary();
}
void GameObserver::cleanupPhase(){
currentPlayer->cleanupPhase();
opponent()->cleanupPhase();
}
void GameObserver::untapPhase(){
currentPlayer->inPlay()->untapAll();
}
int GameObserver::isACreature(MTGCardInstance * card){
return card->isACreature();
}
Player * GameObserver::currentlyActing(){
if (isInterrupting) return isInterrupting;
return currentActionPlayer;
}
int GameObserver::tryToTapOrUntap(MTGCardInstance * card){
int reaction = mLayers->actionLayer()->isReactingToClick(card);
if (reaction){
if (reaction == 1){
mLayers->actionLayer()->reactToClick(card);
}else{
//TODO, what happens when several abilities react to the click ?
}
return reaction;
}else{
if (card->isTapped() && card->controller() == currentPlayer){
int a = ConstraintResolver::untap(this, card);
return a;
}else{
//TODO Check Spells
//card->tap();
return 0;
}
return 0;
}
}
//TODO CORRECT THIS MESS
int GameObserver::targetListIsSet(MTGCardInstance * card){
if (targetChooser == NULL){
TargetChooserFactory tcf;
targetChooser = tcf.createTargetChooser(card);
cardWaitingForTargets = card;
if (targetChooser == NULL){
return 1;
}
}
return (targetChooser->targetListSet());
}
int GameObserver::checkManaCost(MTGCardInstance * card){
ManaCost * playerMana = currentlyActing()->getManaPool();
ManaCost * cost = card->getManaCost();
if (playerMana->canAfford(cost)){
return 1;
}
return 0;
}
#include "../include/debug.h"
#include "../include/GameObserver.h"
#include "../include/GameOptions.h"
#include "../include/ConstraintResolver.h"
#include "../include/CardGui.h"
#include "../include/Damage.h"
#include "../include/DamageResolverLayer.h"
#include <JRenderer.h>
GameObserver * GameObserver::mInstance = NULL;
GameObserver* GameObserver::GetInstance()
{
return mInstance;
}
void GameObserver::EndInstance()
{
SAFE_DELETE(mInstance);
}
void GameObserver::Init(Player * _players[], int _nbplayers){
mInstance = NEW GameObserver(_players, _nbplayers);
mInstance->mLayers = NEW DuelLayers();
mInstance->mLayers->init();
}
GameObserver::GameObserver(Player * _players[], int _nb_players){
int i;
for (i =0; i < _nb_players;i ++){
players[i] = _players[i];
}
currentPlayer = players[0];
currentActionPlayer = currentPlayer;
isInterrupting = NULL;
currentPlayerId = 0;
nbPlayers = _nb_players;
currentRound = 1;
currentGamePhase = -1;
targetChooser = NULL;
cardWaitingForTargets = NULL;
reaction = 0;
gameOver = NULL;
phaseRing = NEW PhaseRing(_players,_nb_players);
}
void GameObserver::setGamePhaseManager(MTGGamePhase * _phases){
gamePhaseManager = _phases;
}
int GameObserver::getCurrentGamePhase(){
return currentGamePhase;
}
Player * GameObserver::opponent(){
int index = (currentPlayerId+1)%nbPlayers;
return players[index];
}
int GameObserver::enteringPhase(int phase){
//TODO
return 0;
}
void GameObserver::nextPlayer(){
currentPlayerId = (currentPlayerId+1)%nbPlayers;
currentPlayer = players[currentPlayerId];
currentActionPlayer = currentPlayer;
}
void GameObserver::nextGamePhase(){
phaseRing->forward();
Phase * cPhase = phaseRing->getCurrentPhase();
currentGamePhase = cPhase->id;
if (currentPlayer != cPhase->player) nextPlayer();
//init begin of turn
if (currentGamePhase == MTG_PHASE_BEFORE_BEGIN){
cleanupPhase();
currentPlayer->canPutLandsIntoPlay = 1;
mLayers->actionLayer()->Update(0);
return nextGamePhase();
}
//manaBurn
if (currentGamePhase == MTG_PHASE_UNTAP ||
currentGamePhase == MTG_PHASE_FIRSTMAIN ||
currentGamePhase == MTG_PHASE_COMBATBEGIN ||
currentGamePhase == MTG_PHASE_SECONDMAIN ||
currentGamePhase == MTG_PHASE_ENDOFTURN
){
currentPlayer->manaBurn();
}
//After End of turn
if (currentGamePhase == MTG_PHASE_AFTER_EOT){
//Auto Hand cleaning, in case the player didn't do it himself
while(currentPlayer->game->hand->nb_cards > 7){
currentPlayer->game->putInGraveyard(currentPlayer->game->hand->cards[0]);
}
mLayers->stackLayer()->garbageCollect(); //clean stack history for this turn;
mLayers->actionLayer()->Update(0);
return nextGamePhase();
}
//Phase Specific actions
switch(currentGamePhase){
case MTG_PHASE_UNTAP:
untapPhase();
break;
case MTG_PHASE_DRAW:
mLayers->stackLayer()->addDraw(currentPlayer,1);
break;
default:
break;
}
}
int GameObserver::cancelCurrentAction(){
SAFE_DELETE(targetChooser);
return 1;
}
void GameObserver::userRequestNextGamePhase(){
if (mLayers->stackLayer()->getNext(NULL,0,NOT_RESOLVED)) return;
if (getCurrentTargetChooser()) return;
if (mLayers->combatLayer()->remainingDamageSteps) return;
//TODO CHECK POSSIBILITY
if (opponent()->isAI() || GameOptions::GetInstance()->values[OPTIONS_INTERRUPTATENDOFPHASE_OFFSET+currentGamePhase]){
mLayers->stackLayer()->AddNextGamePhase();
}else{
nextGamePhase();
}
}
void GameObserver::startGame(int shuffle, int draw){
int i;
for (i=0; i<nbPlayers; i++){
players[i]->game->initGame(shuffle, draw);
}
phaseRing->goToPhase(MTG_PHASE_FIRSTMAIN, players[0]);
currentGamePhase = MTG_PHASE_FIRSTMAIN;
}
void GameObserver::addObserver(MTGAbility * observer){
mLayers->actionLayer()->Add(observer);
}
void GameObserver::removeObserver(ActionElement * observer){
if (observer){
observer->destroy();
}else{
//TODO log error
}
mLayers->actionLayer()->Remove(observer);
}
GameObserver::~GameObserver(){
LOG("==Destroying GameObserver==");
SAFE_DELETE(targetChooser);
SAFE_DELETE(mLayers);
SAFE_DELETE(phaseRing);
LOG("==GameObserver Destroyed==");
}
void GameObserver::Update(float dt){
Player * player = currentPlayer;
if (currentGamePhase == MTG_PHASE_COMBATBLOCKERS){
player = opponent();
}else if (currentGamePhase == MTG_PHASE_COMBATDAMAGE){
DamageResolverLayer * drl = mLayers->combatLayer();
if (drl->currentChoosingPlayer && drl->mCount) player = drl->currentChoosingPlayer;
}
currentActionPlayer = player;
if (isInterrupting) player = isInterrupting;
mLayers->Update(dt,player);
stateEffects();
oldGamePhase = currentGamePhase;
}
//applies damage to creatures after updates
//Players life test
void GameObserver::stateEffects(){
for (int i =0; i < 2; i++){
MTGGameZone * zone = players[i]->game->inPlay;
for (int j = zone->nb_cards-1 ; j>=0; j--){
MTGCardInstance * card = zone->cards[j];
card->afterDamage();
}
}
for (int i =0; i < 2; i++){
if (players[i]->life <= 0) gameOver = players[i];
}
}
void GameObserver::Render(){
mLayers->Render();
if (targetChooser || mLayers->actionLayer()->isWaitingForAnswer()){
JRenderer::GetInstance()->DrawRect(0,0,SCREEN_WIDTH,SCREEN_HEIGHT,ARGB(255,255,0,0));
}
}
void GameObserver::nextStep(){
}
void GameObserver::ButtonPressed (int controllerId, PlayGuiObject * _object){
#if defined (WIN32) || defined (LINUX)
OutputDebugString("Click\n");
#endif
int id = _object->GetId();
if (id >=0){
MTGCardInstance * card = ((CardGui *)_object)->card;
cardClick(card, card);
}
//if (id>= -6 && id <= -3){
if (id== -5 || id == -3){ //TODO libraries ???
GuiGameZone * zone = (GuiGameZone *)_object;
zone->toggleDisplay();
}
if (id == -1 || id == -2){
#if defined (WIN32) || defined (LINUX)
OutputDebugString("Click Player !\n");
#endif
cardClick(NULL, ((GuiAvatar *)_object)->player);
}
}
void GameObserver::stackObjectClicked(Interruptible * action){
if (targetChooser != NULL){
#if defined (WIN32) || defined (LINUX)
OutputDebugString("target chooser ok \n");
#endif
int result = targetChooser->toggleTarget(action);
if (result == TARGET_OK_FULL){
#if defined (WIN32) || defined (LINUX)
OutputDebugString("target chooser Full \n");
#endif
cardClick(cardWaitingForTargets);
}else{
return;
}
}else{
reaction = mLayers->actionLayer()->isReactingToTargetClick(action);
if (reaction == -1) mLayers->actionLayer()->reactToTargetClick(action);
}
}
void GameObserver::cardClick (MTGCardInstance * card, Targetable * object){
LOG("==GameObserver::cardClick");
if (card) {LOG(card->getName())};
Player * clickedPlayer = NULL;
if (!card) clickedPlayer = ((Player *)object);
if (targetChooser != NULL){
int result;
if (card) {
if (card == cardWaitingForTargets){
LOG("attempt to close targetting");
int _result = targetChooser->ForceTargetListReady();
if (_result){
result = TARGET_OK_FULL;
}else{
LOG("...but we cant!\n");
result = targetChooser->targetsReadyCheck();
}
}else{
result = targetChooser->toggleTarget(card);
}
}else{
result = targetChooser->toggleTarget(clickedPlayer);
}
if (result == TARGET_OK_FULL){
card = cardWaitingForTargets;
}else{
return;
}
}
if (card){
reaction = mLayers->actionLayer()->isReactingToClick(card);
if (reaction == -1) mLayers->actionLayer()->reactToClick(card);
}else{
reaction = mLayers->actionLayer()->isReactingToTargetClick(object);
if (reaction == -1) mLayers->actionLayer()->reactToTargetClick(object);
}
if (reaction != -1){
if (!card) return;
if (currentlyActing()->game->hand->hasCard(card)){
//Current player's hand
if (canPutInPlay(card)){
putInPlay(card);
if (card->hasType("land")){
currentPlayer->canPutLandsIntoPlay--;
}
}else if (currentPlayer->game->hand->hasCard(card)){ //Current player's hand
if (currentGamePhase == MTG_PHASE_CLEANUP && currentPlayer->game->hand->nb_cards > 7){
currentPlayer->game->putInGraveyard(card);
}
}
}else if (reaction){
if (reaction == 1){
mLayers->actionLayer()->reactToClick(card);
}else{
mLayers->actionLayer()->setMenuObject(object);
}
}else if (card->isTapped() && card->controller() == currentPlayer){
int a = ConstraintResolver::untap(this, card);
}
}
}
TargetChooser * GameObserver::getCurrentTargetChooser(){
TargetChooser * _tc = mLayers->actionLayer()->getCurrentTargetChooser();
if (_tc) return _tc;
return targetChooser;
}
//Check if it is possible to put a card into play
//TODO : improve according to spells in game...
int GameObserver::canPutInPlay(MTGCardInstance * card){
Player * player = currentlyActing();
LOG("CANPUTINPLAY- check if card belongs to current player\n");
if (!player->game->hand->hasCard(card)) return 0;
LOG("CANPUTINPLAY- check if card is land or can be played\n");
if (card->hasType("land")){
LOG("CANPUTINPLAY- card is land - check if can be played\n");
if (player == currentPlayer && currentPlayer->canPutLandsIntoPlay && (currentGamePhase == MTG_PHASE_FIRSTMAIN || currentGamePhase == MTG_PHASE_SECONDMAIN)){
LOG("CANPUTINPLAY- Land, ok\n");
return 1;
}
}else if ((card->hasType("instant")) || card->has(FLASH) || (player == currentPlayer && (currentGamePhase == MTG_PHASE_FIRSTMAIN || currentGamePhase == MTG_PHASE_SECONDMAIN))){
LOG("CANPUTINPLAY- correct time to play\n");
if (checkManaCost(card)){
LOG("CANPUTINPLAY- ManaCost ok\n");
if (targetListIsSet(card)){
#ifdef LOG
LOG("CANPUTINPLAY- Targets chosen -> OK\n");
#endif
return 1;
}else{
#ifdef LOG
LOG("CANPUTINPLAY- Targets not chosen yet\n");
#endif
return 0;
}
}
}
return 0;
}
void GameObserver::putInPlay(MTGCardInstance * card){
Player * player = currentlyActing();
ManaCost * previousManaPool = NEW ManaCost(player->getManaPool());
player->getManaPool()->pay(card->getManaCost());
ManaCost * spellCost = previousManaPool->Diff(player->getManaPool());
delete previousManaPool;
if (card->hasType("land")){
Spell * spell = NEW Spell(card);
player->game->putInZone(card, player->game->hand, player->game->stack);
spell->resolve();
delete spellCost;
delete spell;
}else{
if (targetChooser){
mLayers->stackLayer()->addSpell(card,targetChooser->targets,targetChooser->cursor, spellCost);
delete targetChooser;
targetChooser = NULL;
}else{
mLayers->stackLayer()->addSpell(card,NULL,0, spellCost);
}
player->game->putInZone(card, player->game->hand, player->game->stack);
}
}
/* Returns true if the card is in one of the player's play zone */
int GameObserver::isInPlay(MTGCardInstance * card){
for (int i = 0; i < 2; i++){
if (players[i]->game->isInPlay(card)) return 1;
}
return 0;
}
void GameObserver::draw(){
//TODO checks to allow multiple draw, or no draw, etc...
currentPlayer->game->drawFromLibrary();
}
void GameObserver::cleanupPhase(){
currentPlayer->cleanupPhase();
opponent()->cleanupPhase();
}
void GameObserver::untapPhase(){
currentPlayer->inPlay()->untapAll();
}
int GameObserver::isACreature(MTGCardInstance * card){
return card->isACreature();
}
Player * GameObserver::currentlyActing(){
if (isInterrupting) return isInterrupting;
return currentActionPlayer;
}
int GameObserver::tryToTapOrUntap(MTGCardInstance * card){
int reaction = mLayers->actionLayer()->isReactingToClick(card);
if (reaction){
if (reaction == 1){
mLayers->actionLayer()->reactToClick(card);
}else{
//TODO, what happens when several abilities react to the click ?
}
return reaction;
}else{
if (card->isTapped() && card->controller() == currentPlayer){
int a = ConstraintResolver::untap(this, card);
return a;
}else{
//TODO Check Spells
//card->tap();
return 0;
}
return 0;
}
}
//TODO CORRECT THIS MESS
int GameObserver::targetListIsSet(MTGCardInstance * card){
if (targetChooser == NULL){
TargetChooserFactory tcf;
targetChooser = tcf.createTargetChooser(card);
cardWaitingForTargets = card;
if (targetChooser == NULL){
return 1;
}
}
return (targetChooser->targetListSet());
}
int GameObserver::checkManaCost(MTGCardInstance * card){
ManaCost * playerMana = currentlyActing()->getManaPool();
ManaCost * cost = card->getManaCost();
if (playerMana->canAfford(cost)){
return 1;
}
return 0;
}

122
projects/mtg/src/GameOptions.cpp
View File

@@ -1,61 +1,61 @@
#include "../include/debug.h"
#include "../include/GameOptions.h"
#include <iostream>
#include <fstream>
#include <string>
#include <stdlib.h>
GameOptions* GameOptions::mInstance = NULL;
GameOptions * GameOptions::GetInstance(){
if (mInstance == NULL)
mInstance = NEW GameOptions();
return mInstance;
}
GameOptions::GameOptions(){
for(int i = 0; i < MAX_OPTIONS; i++){
values[i] = 0;
}
load();
}
int GameOptions::load(){
std::ifstream file(OPTIONS_SAVEFILE);
std::string s;
if(file){
for (int i = 0; i < MAX_OPTIONS; i++){
if(std::getline(file,s)){
values[i] = atoi(s.c_str());
}else{
//TODO error management
}
}
file.close();
}
return 1;
}
int GameOptions::save(){
std::ofstream file(OPTIONS_SAVEFILE);
char writer[10];
if (file){
for (int i = 0; i < MAX_OPTIONS; i++){
sprintf(writer,"%i\n", values[i]);
file<<writer;
}
file.close();
}
return 1;
}
GameOptions::~GameOptions(){
}
void GameOptions::Destroy(){
if (mInstance){
delete mInstance;
mInstance = NULL;
}
}
#include "../include/debug.h"
#include "../include/GameOptions.h"
#include <iostream>
#include <fstream>
#include <string>
#include <stdlib.h>
GameOptions* GameOptions::mInstance = NULL;
GameOptions * GameOptions::GetInstance(){
if (mInstance == NULL)
mInstance = NEW GameOptions();
return mInstance;
}
GameOptions::GameOptions(){
for(int i = 0; i < MAX_OPTIONS; i++){
values[i] = 0;
}
load();
}
int GameOptions::load(){
std::ifstream file(OPTIONS_SAVEFILE);
std::string s;
if(file){
for (int i = 0; i < MAX_OPTIONS; i++){
if(std::getline(file,s)){
values[i] = atoi(s.c_str());
}else{
//TODO error management
}
}
file.close();
}
return 1;
}
int GameOptions::save(){
std::ofstream file(OPTIONS_SAVEFILE);
char writer[10];
if (file){
for (int i = 0; i < MAX_OPTIONS; i++){
sprintf(writer,"%i\n", values[i]);
file<<writer;
}
file.close();
}
return 1;
}
GameOptions::~GameOptions(){
}
void GameOptions::Destroy(){
if (mInstance){
delete mInstance;
mInstance = NULL;
}
}

610
projects/mtg/src/GameStateDuel.cpp
View File

@@ -1,305 +1,305 @@
#include "../include/debug.h"
#include "../include/GameStateDuel.h"
#include "../include/utils.h"
#include "../include/AIPlayer.h"
#include "../include/PlayerData.h"
#ifdef TESTSUITE
#include "../include/TestSuiteAI.h"
#endif
GameStateDuel::GameStateDuel(GameApp* parent): GameState(parent) {
for (int i = 0; i<2; i ++){
deck[i]=NULL;
mPlayers[i]=NULL;
}
game = NULL;
deckmenu = NULL;
menu = NULL;
#ifdef TESTSUITE
testSuite = NULL;
#endif
}
GameStateDuel::~GameStateDuel() {
End();
}
void GameStateDuel::Start()
{
JRenderer * renderer = JRenderer::GetInstance();
renderer->ResetPrivateVRAM();
renderer->EnableVSync(true);
#ifdef TESTSUITE
if (testSuite) delete testSuite;
testSuite = NEW TestSuite("Res/test/_tests.txt");
#endif
mGamePhase = DUEL_CHOOSE_DECK1;
mFont = GameApp::CommonRes->GetJLBFont("graphics/f3");
mFont->SetBase(0); // using 2nd font
menu = NEW SimpleMenu(11,this,mFont,SCREEN_WIDTH/2-100,20,200);
menu->Add(12,"Back to main menu");
menu->Add(13, "Cancel");
int decksneeded = 0;
for (int i = 0; i<2; i ++){
if (mParent->players[i] == PLAYER_TYPE_HUMAN){
if (!deckmenu){
decksneeded = 1;
deckmenu = NEW SimpleMenu(1,this,mFont, 10 , 10, 100, "Choose a Deck");
char buffer[100];
for (int j=1; j<6; j++){
sprintf(buffer, "Res/player/deck%i.txt",j);
std::ifstream file(buffer);
if(file){
deckmenu->Add(j, GameState::menuTexts[j]);
file.close();
decksneeded = 0;
}
}
}
}
}
if (decksneeded)
mGamePhase = ERROR_NO_DECK;
}
void GameStateDuel::loadPlayer(int playerId, int decknb){
if (decknb){ //Human Player
char deckFile[255];
sprintf(deckFile, "Res/player/deck%i.txt",decknb);
char deckFileSmall[255];
sprintf(deckFileSmall, "player_deck%i",decknb);
int deck_cards_ids[100];
int nb_elements = readfile_to_ints(deckFile, deck_cards_ids);
deck[playerId] = NEW MTGPlayerCards(mParent->collection,deck_cards_ids, nb_elements);
mPlayers[playerId] = NEW HumanPlayer(deck[playerId],deckFileSmall);
}else{
AIPlayerFactory playerCreator;
mPlayers[playerId] = playerCreator.createAIPlayer(mParent->collection,NULL);
deck[playerId] = mPlayers[playerId]->game;
}
}
#ifdef TESTSUITE
void GameStateDuel::loadTestSuitePlayers(){
OutputDebugString ("loading suite 1\n");
if (!testSuite) return;
for (int i = 0; i < 2; i++){
if (mPlayers[i]){
delete mPlayers[i];
}
mPlayers[i] = NEW TestSuiteAI(mParent->collection,testSuite, i);
OutputDebugString ("loading suite 2\n");
deck[i] = mPlayers[i]->game;
}
if (game) delete game;
game = NULL;
if (!game){
GameObserver::Init(mPlayers, 2);
OutputDebugString ("loading suite 3\n");
game = GameObserver::GetInstance();
OutputDebugString ("loading suite 4\n");
game->startGame(0,0);
OutputDebugString ("loading suite 5\n");
}
}
#endif
void GameStateDuel::End()
{
#if defined (WIN32) || defined (LINUX)
OutputDebugString("Ending GamestateDuel\n");
#endif
GameObserver::EndInstance();
game = NULL;
SAFE_DELETE(deckmenu);
JRenderer::GetInstance()->EnableVSync(false);
for (int i = 0; i < 2; i++){
SAFE_DELETE(mPlayers[i]);
SAFE_DELETE(deck[i]);
}
SAFE_DELETE(menu);
#ifdef TESTSUITE
SAFE_DELETE(testSuite);
#endif
}
void GameStateDuel::Update(float dt)
{
if (mGamePhase == ERROR_NO_DECK){
if (mEngine->GetButtonClick(PSP_CTRL_CIRCLE)){
mParent->SetNextState(GAME_STATE_DECK_VIEWER);
}
}else if (mGamePhase == DUEL_CHOOSE_DECK1){
if (mParent->players[0] == PLAYER_TYPE_HUMAN){
deckmenu->Update(dt);
}
#ifdef TESTSUITE
else if (mParent->players[1] == PLAYER_TYPE_TESTSUITE){
if (testSuite && testSuite->loadNext()){
loadTestSuitePlayers();
mGamePhase = DUEL_PLAY;
testSuite->initGame();
char buf[4096];
sprintf(buf, "nb cards in player2's graveyard : %i\n",mPlayers[1]->game->graveyard->nb_cards);
LOG(buf);
}else{
mGamePhase = DUEL_END;
}
}
#endif
else{
loadPlayer(0);
mGamePhase = DUEL_CHOOSE_DECK2;
}
}else if(mGamePhase == DUEL_CHOOSE_DECK2){
if (mParent->players[1] == PLAYER_TYPE_HUMAN){
deckmenu->Update(dt);
}
else{
loadPlayer(1);
mGamePhase = DUEL_PLAY;
}
}else if (mGamePhase == DUEL_PLAY){
if (!game){
GameObserver::Init(mPlayers, 2);
game = GameObserver::GetInstance();
game->startGame();
}
game->Update(dt);
if (game->gameOver){
if (!mPlayers[0]->isAI() && mPlayers[1]->isAI() && mPlayers[0]!= game->gameOver){
#if defined (WIN32) || defined (LINUX)
char buf[4096];
sprintf(buf, "%p - %p", mPlayers[0], game->gameOver);
OutputDebugString(buf);
#endif
PlayerData * playerdata = NEW PlayerData(mParent->collection);
playerdata->credits+= 500;
playerdata->save();
delete playerdata;
}
mGamePhase = DUEL_END;
#ifdef TESTSUITE
if (mParent->players[1] == PLAYER_TYPE_TESTSUITE){
if (testSuite->loadNext()){
loadTestSuitePlayers();
mGamePhase = DUEL_PLAY;
testSuite->initGame();
}else{
mGamePhase = DUEL_END;
}
}else if (mParent->players[0] == PLAYER_TYPE_CPU && mParent->players[1] == PLAYER_TYPE_CPU){
End();
Start();
}
#endif
mFont->SetColor(ARGB(255,255,255,255));
}
if (mEngine->GetButtonClick(PSP_CTRL_START)){
mGamePhase = DUEL_MENU;
}
}else if (mGamePhase == DUEL_MENU){
menu->Update(dt);
}else{
if (mEngine->GetButtonClick(PSP_CTRL_CIRCLE)){
mParent->SetNextState(GAME_STATE_MENU);
}
}
}
void GameStateDuel::Render()
{
//Erase
JRenderer::GetInstance()->ClearScreen(ARGB(0,0,0,0));
if (game)
game->Render();
if (mGamePhase == DUEL_END){
JRenderer::GetInstance()->ClearScreen(ARGB(200,0,0,0));
char buffer[50];
int p0life = mPlayers[0]->life;
if (!mPlayers[0]->isAI() && mPlayers[1]->isAI() ){
if (game->gameOver !=mPlayers[0]){
sprintf (buffer, "Victory! Congratulations, You earn 500 credits");
}else{
sprintf (buffer, "You have been defeated");
}
}else{
int winner = 2;
if (game->gameOver !=mPlayers[0]){
winner = 1;
}
sprintf(buffer, "Player %i wins (%i)", winner, p0life );
}
mFont->DrawString(buffer, 10, 150);
}else if (mGamePhase == DUEL_CHOOSE_DECK1 || mGamePhase == DUEL_CHOOSE_DECK2){
if (deckmenu)
deckmenu->Render();
}else if (mGamePhase == ERROR_NO_DECK){
mFont->DrawString("NO DECK AVAILABLE,",0,SCREEN_HEIGHT/2);
mFont->DrawString("PRESS CIRCLE TO GO TO THE DECK EDITOR!",0,SCREEN_HEIGHT/2 + 20);
}else if (mGamePhase == DUEL_MENU){
menu->Render();
}
}
void GameStateDuel::ButtonPressed(int controllerId, int controlId)
{
switch (controlId)
{
case 1:
case 2:
case 3:
case 4:
case 5:
{
if (mGamePhase == DUEL_CHOOSE_DECK1){
loadPlayer(0,controlId);
mGamePhase = DUEL_CHOOSE_DECK2;
}else{
loadPlayer(1,controlId);
mGamePhase = DUEL_PLAY;
}
break;
}
case 12:
mParent->SetNextState(GAME_STATE_MENU);
break;
case 13:
mGamePhase = DUEL_PLAY;
break;
}
}
#include "../include/debug.h"
#include "../include/GameStateDuel.h"
#include "../include/utils.h"
#include "../include/AIPlayer.h"
#include "../include/PlayerData.h"
#ifdef TESTSUITE
#include "../include/TestSuiteAI.h"
#endif
GameStateDuel::GameStateDuel(GameApp* parent): GameState(parent) {
for (int i = 0; i<2; i ++){
deck[i]=NULL;
mPlayers[i]=NULL;
}
game = NULL;
deckmenu = NULL;
menu = NULL;
#ifdef TESTSUITE
testSuite = NULL;
#endif
}
GameStateDuel::~GameStateDuel() {
End();
}
void GameStateDuel::Start()
{
JRenderer * renderer = JRenderer::GetInstance();
renderer->ResetPrivateVRAM();
renderer->EnableVSync(true);
#ifdef TESTSUITE
if (testSuite) delete testSuite;
testSuite = NEW TestSuite("Res/test/_tests.txt");
#endif
mGamePhase = DUEL_CHOOSE_DECK1;
mFont = GameApp::CommonRes->GetJLBFont("graphics/f3");
mFont->SetBase(0); // using 2nd font
menu = NEW SimpleMenu(11,this,mFont,SCREEN_WIDTH/2-100,20,200);
menu->Add(12,"Back to main menu");
menu->Add(13, "Cancel");
int decksneeded = 0;
for (int i = 0; i<2; i ++){
if (mParent->players[i] == PLAYER_TYPE_HUMAN){
if (!deckmenu){
decksneeded = 1;
deckmenu = NEW SimpleMenu(1,this,mFont, 10 , 10, 100, "Choose a Deck");
char buffer[100];
for (int j=1; j<6; j++){
sprintf(buffer, "Res/player/deck%i.txt",j);
std::ifstream file(buffer);
if(file){
deckmenu->Add(j, GameState::menuTexts[j]);
file.close();
decksneeded = 0;
}
}
}
}
}
if (decksneeded)
mGamePhase = ERROR_NO_DECK;
}
void GameStateDuel::loadPlayer(int playerId, int decknb){
if (decknb){ //Human Player
char deckFile[255];
sprintf(deckFile, "Res/player/deck%i.txt",decknb);
char deckFileSmall[255];
sprintf(deckFileSmall, "player_deck%i",decknb);
int deck_cards_ids[100];
int nb_elements = readfile_to_ints(deckFile, deck_cards_ids);
deck[playerId] = NEW MTGPlayerCards(mParent->collection,deck_cards_ids, nb_elements);
mPlayers[playerId] = NEW HumanPlayer(deck[playerId],deckFileSmall);
}else{
AIPlayerFactory playerCreator;
mPlayers[playerId] = playerCreator.createAIPlayer(mParent->collection,NULL);
deck[playerId] = mPlayers[playerId]->game;
}
}
#ifdef TESTSUITE
void GameStateDuel::loadTestSuitePlayers(){
OutputDebugString ("loading suite 1\n");
if (!testSuite) return;
for (int i = 0; i < 2; i++){
if (mPlayers[i]){
delete mPlayers[i];
}
mPlayers[i] = NEW TestSuiteAI(mParent->collection,testSuite, i);
OutputDebugString ("loading suite 2\n");
deck[i] = mPlayers[i]->game;
}
if (game) delete game;
game = NULL;
if (!game){
GameObserver::Init(mPlayers, 2);
OutputDebugString ("loading suite 3\n");
game = GameObserver::GetInstance();
OutputDebugString ("loading suite 4\n");
game->startGame(0,0);
OutputDebugString ("loading suite 5\n");
}
}
#endif
void GameStateDuel::End()
{
#if defined (WIN32) || defined (LINUX)
OutputDebugString("Ending GamestateDuel\n");
#endif
GameObserver::EndInstance();
game = NULL;
SAFE_DELETE(deckmenu);
JRenderer::GetInstance()->EnableVSync(false);
for (int i = 0; i < 2; i++){
SAFE_DELETE(mPlayers[i]);
SAFE_DELETE(deck[i]);
}
SAFE_DELETE(menu);
#ifdef TESTSUITE
SAFE_DELETE(testSuite);
#endif
}
void GameStateDuel::Update(float dt)
{
if (mGamePhase == ERROR_NO_DECK){
if (mEngine->GetButtonClick(PSP_CTRL_CIRCLE)){
mParent->SetNextState(GAME_STATE_DECK_VIEWER);
}
}else if (mGamePhase == DUEL_CHOOSE_DECK1){
if (mParent->players[0] == PLAYER_TYPE_HUMAN){
deckmenu->Update(dt);
}
#ifdef TESTSUITE
else if (mParent->players[1] == PLAYER_TYPE_TESTSUITE){
if (testSuite && testSuite->loadNext()){
loadTestSuitePlayers();
mGamePhase = DUEL_PLAY;
testSuite->initGame();
char buf[4096];
sprintf(buf, "nb cards in player2's graveyard : %i\n",mPlayers[1]->game->graveyard->nb_cards);
LOG(buf);
}else{
mGamePhase = DUEL_END;
}
}
#endif
else{
loadPlayer(0);
mGamePhase = DUEL_CHOOSE_DECK2;
}
}else if(mGamePhase == DUEL_CHOOSE_DECK2){
if (mParent->players[1] == PLAYER_TYPE_HUMAN){
deckmenu->Update(dt);
}
else{
loadPlayer(1);
mGamePhase = DUEL_PLAY;
}
}else if (mGamePhase == DUEL_PLAY){
if (!game){
GameObserver::Init(mPlayers, 2);
game = GameObserver::GetInstance();
game->startGame();
}
game->Update(dt);
if (game->gameOver){
if (!mPlayers[0]->isAI() && mPlayers[1]->isAI() && mPlayers[0]!= game->gameOver){
#if defined (WIN32) || defined (LINUX)
char buf[4096];
sprintf(buf, "%p - %p", mPlayers[0], game->gameOver);
OutputDebugString(buf);
#endif
PlayerData * playerdata = NEW PlayerData(mParent->collection);
playerdata->credits+= 500;
playerdata->save();
delete playerdata;
}
mGamePhase = DUEL_END;
#ifdef TESTSUITE
if (mParent->players[1] == PLAYER_TYPE_TESTSUITE){
if (testSuite->loadNext()){
loadTestSuitePlayers();
mGamePhase = DUEL_PLAY;
testSuite->initGame();
}else{
mGamePhase = DUEL_END;
}
}else if (mParent->players[0] == PLAYER_TYPE_CPU && mParent->players[1] == PLAYER_TYPE_CPU){
End();
Start();
}
#endif
mFont->SetColor(ARGB(255,255,255,255));
}
if (mEngine->GetButtonClick(PSP_CTRL_START)){
mGamePhase = DUEL_MENU;
}
}else if (mGamePhase == DUEL_MENU){
menu->Update(dt);
}else{
if (mEngine->GetButtonClick(PSP_CTRL_CIRCLE)){
mParent->SetNextState(GAME_STATE_MENU);
}
}
}
void GameStateDuel::Render()
{
//Erase
JRenderer::GetInstance()->ClearScreen(ARGB(0,0,0,0));
if (game)
game->Render();
if (mGamePhase == DUEL_END){
JRenderer::GetInstance()->ClearScreen(ARGB(200,0,0,0));
char buffer[50];
int p0life = mPlayers[0]->life;
if (!mPlayers[0]->isAI() && mPlayers[1]->isAI() ){
if (game->gameOver !=mPlayers[0]){
sprintf (buffer, "Victory! Congratulations, You earn 500 credits");
}else{
sprintf (buffer, "You have been defeated");
}
}else{
int winner = 2;
if (game->gameOver !=mPlayers[0]){
winner = 1;
}
sprintf(buffer, "Player %i wins (%i)", winner, p0life );
}
mFont->DrawString(buffer, 10, 150);
}else if (mGamePhase == DUEL_CHOOSE_DECK1 || mGamePhase == DUEL_CHOOSE_DECK2){
if (deckmenu)
deckmenu->Render();
}else if (mGamePhase == ERROR_NO_DECK){
mFont->DrawString("NO DECK AVAILABLE,",0,SCREEN_HEIGHT/2);
mFont->DrawString("PRESS CIRCLE TO GO TO THE DECK EDITOR!",0,SCREEN_HEIGHT/2 + 20);
}else if (mGamePhase == DUEL_MENU){
menu->Render();
}
}
void GameStateDuel::ButtonPressed(int controllerId, int controlId)
{
switch (controlId)
{
case 1:
case 2:
case 3:
case 4:
case 5:
{
if (mGamePhase == DUEL_CHOOSE_DECK1){
loadPlayer(0,controlId);
mGamePhase = DUEL_CHOOSE_DECK2;
}else{
loadPlayer(1,controlId);
mGamePhase = DUEL_PLAY;
}
break;
}
case 12:
mParent->SetNextState(GAME_STATE_MENU);
break;
case 13:
mGamePhase = DUEL_PLAY;
break;
}
}

236
projects/mtg/src/GameStateOptions.cpp
View File

@@ -1,118 +1,118 @@
#include "../include/debug.h"
#include "../include/GameStateOptions.h"
#include "../include/GameApp.h"
#include "../include/OptionItem.h"
#include "../include/SimpleMenu.h"
#include "../include/GameOptions.h"
GameStateOptions::GameStateOptions(GameApp* parent): GameState(parent) {
optionsList = NULL;
optionsMenu = NULL;
}
GameStateOptions::~GameStateOptions() {
}
void GameStateOptions::Start()
{
mState = SHOW_OPTIONS;
JRenderer::GetInstance()->ResetPrivateVRAM();
JRenderer::GetInstance()->EnableVSync(true);
optionsList = NEW OptionsList();
if (GameApp::HasMusic) optionsList->Add(NEW OptionItem(OPTIONS_MUSICVOLUME, "Music volume", 100, 10));
JLBFont * mFont = GameApp::CommonRes->GetJLBFont("graphics/f3");
optionsMenu = NEW SimpleMenu(102, this,mFont, 50,170,SCREEN_WIDTH-120);
optionsMenu->Add(1, "Save & Back to Main Menu");
optionsMenu->Add(2, "Back to Main Menu");
optionsMenu->Add(3, "Cancel");
}
void GameStateOptions::End()
{
JRenderer::GetInstance()->EnableVSync(false);
SAFE_DELETE(optionsList);
}
void GameStateOptions::Update(float dt)
{
if (mState == SHOW_OPTIONS){
if (mEngine->GetButtonClick(PSP_CTRL_START)){
mState = SHOW_OPTIONS_MENU;
}
optionsList->Update(dt);
}else{
optionsMenu->Update(dt);
}
}
void GameStateOptions::Render()
{
//Erase
JRenderer::GetInstance()->ClearScreen(ARGB(0,0,0,0));
optionsList->Render();
const char * const CreditsText[] = {
"Wagic, The Homebrew ?! by WilLoW",
"This is a work in progress and it contains bugs, deal with it",
"updates on http://www.wololo.net/wagic",
"",
"Developped with the JGE++ Library",
"http://jge.khors.com",
"",
"this freeware app is not endorsed by Wizards of the Coast, Inc",
};
const char * const MusicText[] = {
"",
"Music by Celestial Aeon Project, under Creative Commons License",
"Their music can be downloaded at http://www.jamendo.com"
};
JLBFont * mFont = GameApp::CommonRes->GetJLBFont("graphics/f3");
mFont->SetColor(ARGB(255,200,200,200));
mFont->SetScale(0.80);
for (int i = 0; i < 8; i++){
mFont->DrawString(CreditsText[i],SCREEN_WIDTH/2, 40 +18*i,JGETEXT_CENTER);
}
if (GameApp::HasMusic){
for (int i = 0; i < 3; i++){
mFont->DrawString(MusicText[i],SCREEN_WIDTH/2, 40 +18*(8+i),JGETEXT_CENTER);
}
}
mFont->SetScale(1.f);
if (mState == SHOW_OPTIONS_MENU){
optionsMenu->Render();
}
}
void GameStateOptions::ButtonPressed(int controllerId, int controlId)
{
switch (controlId){
case 1:
optionsList->save();
case 2:
mParent->SetNextState(GAME_STATE_MENU);
break;
case 3:
mState = SHOW_OPTIONS;
break;
}
};
#include "../include/debug.h"
#include "../include/GameStateOptions.h"
#include "../include/GameApp.h"
#include "../include/OptionItem.h"
#include "../include/SimpleMenu.h"
#include "../include/GameOptions.h"
GameStateOptions::GameStateOptions(GameApp* parent): GameState(parent) {
optionsList = NULL;
optionsMenu = NULL;
}
GameStateOptions::~GameStateOptions() {
}
void GameStateOptions::Start()
{
mState = SHOW_OPTIONS;
JRenderer::GetInstance()->ResetPrivateVRAM();
JRenderer::GetInstance()->EnableVSync(true);
optionsList = NEW OptionsList();
if (GameApp::HasMusic) optionsList->Add(NEW OptionItem(OPTIONS_MUSICVOLUME, "Music volume", 100, 10));
JLBFont * mFont = GameApp::CommonRes->GetJLBFont("graphics/f3");
optionsMenu = NEW SimpleMenu(102, this,mFont, 50,170,SCREEN_WIDTH-120);
optionsMenu->Add(1, "Save & Back to Main Menu");
optionsMenu->Add(2, "Back to Main Menu");
optionsMenu->Add(3, "Cancel");
}
void GameStateOptions::End()
{
JRenderer::GetInstance()->EnableVSync(false);
SAFE_DELETE(optionsList);
}
void GameStateOptions::Update(float dt)
{
if (mState == SHOW_OPTIONS){
if (mEngine->GetButtonClick(PSP_CTRL_START)){
mState = SHOW_OPTIONS_MENU;
}
optionsList->Update(dt);
}else{
optionsMenu->Update(dt);
}
}
void GameStateOptions::Render()
{
//Erase
JRenderer::GetInstance()->ClearScreen(ARGB(0,0,0,0));
optionsList->Render();
const char * const CreditsText[] = {
"Wagic, The Homebrew ?! by WilLoW",
"This is a work in progress and it contains bugs, deal with it",
"updates on http://www.wololo.net/wagic",
"",
"Developped with the JGE++ Library",
"http://jge.khors.com",
"",
"this freeware app is not endorsed by Wizards of the Coast, Inc",
};
const char * const MusicText[] = {
"",
"Music by Celestial Aeon Project, under Creative Commons License",
"Their music can be downloaded at http://www.jamendo.com"
};
JLBFont * mFont = GameApp::CommonRes->GetJLBFont("graphics/f3");
mFont->SetColor(ARGB(255,200,200,200));
mFont->SetScale(0.80);
for (int i = 0; i < 8; i++){
mFont->DrawString(CreditsText[i],SCREEN_WIDTH/2, 40 +18*i,JGETEXT_CENTER);
}
if (GameApp::HasMusic){
for (int i = 0; i < 3; i++){
mFont->DrawString(MusicText[i],SCREEN_WIDTH/2, 40 +18*(8+i),JGETEXT_CENTER);
}
}
mFont->SetScale(1.f);
if (mState == SHOW_OPTIONS_MENU){
optionsMenu->Render();
}
}
void GameStateOptions::ButtonPressed(int controllerId, int controlId)
{
switch (controlId){
case 1:
optionsList->save();
case 2:
mParent->SetNextState(GAME_STATE_MENU);
break;
case 3:
mState = SHOW_OPTIONS;
break;
}
};

150
projects/mtg/src/GameStateShop.cpp
View File

@@ -1,5 +1,5 @@
/*
The shop is where the player can buy cards, decks...
The shop is where the player can buy cards, decks...
*/
#include "../include/debug.h"
#include <JRenderer.h>
@@ -12,7 +12,7 @@ GameStateShop::GameStateShop(GameApp* parent): GameState(parent) {}
GameStateShop::~GameStateShop() {
//End(); TODO FIX THAT
//End(); TODO FIX THAT
}
void GameStateShop::Create(){
@@ -24,55 +24,55 @@ void GameStateShop::Create(){
void GameStateShop::Start()
{
menu = NULL;
mFont = GameApp::CommonRes->GetJLBFont("graphics/magic");
mStage = STAGE_SHOP_SHOP;
bgTexture = JRenderer::GetInstance()->LoadTexture("graphics/shop.jpg", TEX_TYPE_USE_VRAM);
mBg = NEW JQuad(bgTexture, 0, 0, 400, 280); // Create background quad for rendering.
backTexture = JRenderer::GetInstance()->LoadTexture("sets/back.jpg", TEX_TYPE_USE_VRAM);
mBack = NEW JQuad(backTexture, 0, 0, 200, 285); // Create background quad for rendering.
menu = NULL;
mFont = GameApp::CommonRes->GetJLBFont("graphics/magic");
mStage = STAGE_SHOP_SHOP;
bgTexture = JRenderer::GetInstance()->LoadTexture("graphics/shop.jpg", TEX_TYPE_USE_VRAM);
mBg = NEW JQuad(bgTexture, 0, 0, 400, 280); // Create background quad for rendering.
backTexture = JRenderer::GetInstance()->LoadTexture("sets/back.jpg", TEX_TYPE_USE_VRAM);
mBack = NEW JQuad(backTexture, 0, 0, 200, 285); // Create background quad for rendering.
JRenderer::GetInstance()->ResetPrivateVRAM();
JRenderer::GetInstance()->EnableVSync(true);
int sets[500];
int nbsets = 0;
for (int i = 0; i < MtgSets::SetsList->nb_items; i++){
if (mParent->collection->countBySet(i) > 100){ //Only sets with more than 100 cards can get boosters and starters
sets[nbsets] = i;
nbsets++;
}
}
if (nbsets){
setId = sets[(rand() % nbsets)];
}else{
setId = (rand() % MtgSets::SetsList->nb_items);
}
JQuad * mBackThumb = GameApp::CommonRes->GetQuad("back_thumb");
shop = NEW ShopItems(10, this, mFont, 10, 10, mParent->collection, setId);
sprintf(starterBuffer, "%s Starter (60 cards)",MtgSets::SetsList->values[setId].c_str());
sprintf(boosterBuffer, "%s Booster (15 cards)",MtgSets::SetsList->values[setId].c_str());
shop->Add(starterBuffer,mBack,mBackThumb, 6000);
shop->Add(boosterBuffer,mBack,mBackThumb, 1900);
int sets[500];
int nbsets = 0;
for (int i = 0; i < MtgSets::SetsList->nb_items; i++){
if (mParent->collection->countBySet(i) > 100){ //Only sets with more than 100 cards can get boosters and starters
sets[nbsets] = i;
nbsets++;
}
}
if (nbsets){
setId = sets[(rand() % nbsets)];
}else{
setId = (rand() % MtgSets::SetsList->nb_items);
}
JQuad * mBackThumb = GameApp::CommonRes->GetQuad("back_thumb");
shop = NEW ShopItems(10, this, mFont, 10, 10, mParent->collection, setId);
sprintf(starterBuffer, "%s Starter (60 cards)",MtgSets::SetsList->values[setId].c_str());
sprintf(boosterBuffer, "%s Booster (15 cards)",MtgSets::SetsList->values[setId].c_str());
shop->Add(starterBuffer,mBack,mBackThumb, 6000);
shop->Add(boosterBuffer,mBack,mBackThumb, 1900);
for (int i = 0; i < 4; i++){
shop->Add(mParent->collection->randomCardId());
}
shop->Add(mParent->collection->randomCardId());
}
}
void GameStateShop::End()
{
JRenderer::GetInstance()->EnableVSync(false);
if (shop)
SAFE_DELETE(shop);
SAFE_DELETE(mBack);
if(bgTexture)
SAFE_DELETE(bgTexture);
if(mBg)
SAFE_DELETE(mBg);
if(menu)
SAFE_DELETE(menu);
JRenderer::GetInstance()->EnableVSync(false);
if (shop)
SAFE_DELETE(shop);
SAFE_DELETE(mBack);
if(bgTexture)
SAFE_DELETE(bgTexture);
if(mBg)
SAFE_DELETE(mBg);
if(menu)
SAFE_DELETE(menu);
}
void GameStateShop::Destroy(){
@@ -80,52 +80,52 @@ void GameStateShop::Destroy(){
void GameStateShop::Update(float dt)
{
if (mStage == STAGE_SHOP_MENU){
if (menu){
menu->Update(dt);
}else{
menu = NEW SimpleMenu(11,this,mFont,SCREEN_WIDTH/2-100,20,200);
menu->Add(12,"Save & Back to main menu");
menu->Add(13, "Cancel");
}
}else{
if (mEngine->GetButtonClick(PSP_CTRL_START)){
mStage = STAGE_SHOP_MENU;
}
if (shop)
shop->Update(dt);
}
if (mStage == STAGE_SHOP_MENU){
if (menu){
menu->Update(dt);
}else{
menu = NEW SimpleMenu(11,this,mFont,SCREEN_WIDTH/2-100,20,200);
menu->Add(12,"Save & Back to main menu");
menu->Add(13, "Cancel");
}
}else{
if (mEngine->GetButtonClick(PSP_CTRL_START)){
mStage = STAGE_SHOP_MENU;
}
if (shop)
shop->Update(dt);
}
}
void GameStateShop::Render()
void GameStateShop::Render()
{
//Erase
JRenderer::GetInstance()->ClearScreen(ARGB(0,0,0,0));
if (mBg)JRenderer::GetInstance()->RenderQuad(mBg,0,0);
if (mBg)JRenderer::GetInstance()->RenderQuad(mBg,0,0);
if (shop)
shop->Render();
if (mStage == STAGE_SHOP_MENU && menu){
menu->Render();
}
shop->Render();
if (mStage == STAGE_SHOP_MENU && menu){
menu->Render();
}
}
void GameStateShop::ButtonPressed(int controllerId, int controlId)
{
switch (controllerId){
case 10:
shop->pricedialog(controlId);
break;
case 11:
if (controlId == 12){
shop->saveAll();
mParent->SetNextState(GAME_STATE_MENU);
}else{
mStage = STAGE_SHOP_SHOP;
}
break;
}
switch (controllerId){
case 10:
shop->pricedialog(controlId);
break;
case 11:
if (controlId == 12){
shop->saveAll();
mParent->SetNextState(GAME_STATE_MENU);
}else{
mStage = STAGE_SHOP_SHOP;
}
break;
}
}

62
projects/mtg/src/GuiLayers.cpp
View File

@@ -5,7 +5,7 @@
GuiLayer::GuiLayer(int id, GameObserver* _game):JGuiController(id, NULL){
game = _game;
modal = 0;
hasFocus = 0;
hasFocus = 0;
}
GuiLayer::~GuiLayer(){
@@ -13,7 +13,7 @@ GuiLayer::~GuiLayer(){
}
int GuiLayer::getMaxId(){
return mCount;
return mCount;
}
void GuiLayer::Update(float dt){
@@ -24,16 +24,16 @@ void GuiLayer::Update(float dt){
void GuiLayer::resetObjects(){
for (int i=0;i<mCount;i++)
for (int i=0;i<mCount;i++)
if (mObjects[i])
delete mObjects[i];
mCount = 0;
mCurr = 0;
mCount = 0;
mCurr = 0;
}
void GuiLayer::RenderMessageBackground(float x0, float y0, float width, int height){
PIXEL_TYPE colors_up[] =
PIXEL_TYPE colors_up[] =
{
ARGB(0,255,255,255),
ARGB(0,255,255,255),
@@ -52,13 +52,13 @@ void GuiLayer::RenderMessageBackground(float x0, float y0, float width, int heig
JRenderer * renderer = JRenderer::GetInstance();
renderer->FillRect(x0,y0,width,height/2,colors_up);
renderer->FillRect(x0,y0+height/2,width,height/2,colors_down);
// mEngine->DrawLine(0,y0,SCREEN_WIDTH,y0,ARGB(128,255,255,255));
// mEngine->DrawLine(0,y0+height,SCREEN_WIDTH,y0+height,ARGB(128,255,255,255));
}
void GuiLayer::RenderMessageBackground(float y0, int height){
RenderMessageBackground(0,y0,SCREEN_WIDTH, height);
RenderMessageBackground(0,y0,SCREEN_WIDTH, height);
}
@@ -73,14 +73,14 @@ void GuiLayer::setModal(int _modal){
int GuiLayer::getIndexOf(JGuiObject * object){
for (int i=0; i<mCount; i++){
if (mObjects[i] == object)
return i;
}
return -1;
if (mObjects[i] == object)
return i;
}
return -1;
}
JGuiObject * GuiLayer::getByIndex(int index){
return mObjects[index];
return mObjects[index];
}
@@ -89,27 +89,27 @@ GuiLayers::GuiLayers(){
}
GuiLayers::~GuiLayers(){
LOG("==Destroying GuiLayers==");
for (int i=0; i<nbitems; i++){
delete objects[i];
}
LOG("==Destroying GuiLayers Successful==");
LOG("==Destroying GuiLayers==");
for (int i=0; i<nbitems; i++){
delete objects[i];
}
LOG("==Destroying GuiLayers Successful==");
}
int GuiLayers::unstopableRenderInProgress(){
for (int i=0; i<nbitems; i++){
if (objects[i]->unstopableRenderInProgress())
return 1;
return 1;
}
return 0;
return 0;
}
void GuiLayers::Add(GuiLayer * layer){
if (nbitems >=MAX_GUI_LAYERS || nbitems < 0){
LOG("OUT OF BOUND IN GuiLayers Add !!!");
return;
}
if (nbitems >=MAX_GUI_LAYERS || nbitems < 0){
LOG("OUT OF BOUND IN GuiLayers Add !!!");
return;
}
objects[nbitems] = layer;
nbitems++;
}
@@ -121,23 +121,23 @@ void GuiLayers::Remove(){
void GuiLayers::Update(float dt, Player * currentPlayer){
int i;
int modal = 0;
int isAI = currentPlayer->isAI();
int isAI = currentPlayer->isAI();
for (i=0; i<nbitems; i++){
objects[i]->hasFocus = 0;
objects[i]->hasFocus = 0;
objects[i]->Update(dt);
if (!isAI && !modal){
objects[i]->hasFocus = 1;
objects[i]->hasFocus = 1;
objects[i]->CheckUserInput(dt);
modal = objects[i]->isModal();
}
}
if (isAI){
currentPlayer->Act(dt);
}
if (isAI){
currentPlayer->Act(dt);
}
}
void GuiLayers::Render(){
for (int i=nbitems-1; i>=0; i--){
objects[i]->Render();
objects[i]->Render();
}
}

100
projects/mtg/src/GuiMessageBox.cpp
View File

@@ -2,60 +2,60 @@
void GuiMessageBox::CheckUserInput(){
if (mEngine->GetButtonClick(mActionButton))
if (mEngine->GetButtonClick(mActionButton))
{
if (mObjects[mCurr] != NULL && mObjects[mCurr]->ButtonPressed())
{
if (mObjects[mCurr] != NULL && mObjects[mCurr]->ButtonPressed())
{
if (mListener != NULL)
{
mListener->ButtonPressed(mId, mObjects[mCurr]->GetId());
return;
}
}
if (mListener != NULL)
{
mListener->ButtonPressed(mId, mObjects[mCurr]->GetId());
return;
}
}
if (mEngine->GetButtonState(PSP_CTRL_LEFT) || mEngine->GetButtonState(PSP_CTRL_UP) || mEngine->GetAnalogY()<64)
{
if (KeyRepeated(PSP_CTRL_UP, dt))
{
int n = mCurr;
n--;
if (n<0)
{
if ((mStyle&JGUI_STYLE_WRAPPING))
n = mCount-1;
else
n = 0;
}
}
if (n != mCurr && mObjects[mCurr] != NULL && mObjects[mCurr]->Leaving(PSP_CTRL_UP))
{
mCurr = n;
mObjects[mCurr]->Entering();
}
}
}
else if (mEngine->GetButtonState(PSP_CTRL_RIGHT) || mEngine->GetButtonState(PSP_CTRL_DOWN) || mEngine->GetAnalogY()>192)
if (mEngine->GetButtonState(PSP_CTRL_LEFT) || mEngine->GetButtonState(PSP_CTRL_UP) || mEngine->GetAnalogY()<64)
{
if (KeyRepeated(PSP_CTRL_UP, dt))
{
if (KeyRepeated(PSP_CTRL_DOWN, dt))
{
int n = mCurr;
n++;
if (n>mCount-1)
{
if ((mStyle&JGUI_STYLE_WRAPPING))
n = 0;
else
n = mCount-1;
}
int n = mCurr;
n--;
if (n<0)
{
if ((mStyle&JGUI_STYLE_WRAPPING))
n = mCount-1;
else
n = 0;
}
if (n != mCurr && mObjects[mCurr] != NULL && mObjects[mCurr]->Leaving(PSP_CTRL_DOWN))
{
mCurr = n;
mObjects[mCurr]->Entering();
}
}
if (n != mCurr && mObjects[mCurr] != NULL && mObjects[mCurr]->Leaving(PSP_CTRL_UP))
{
mCurr = n;
mObjects[mCurr]->Entering();
}
}
else
mLastKey = 0;
}
else if (mEngine->GetButtonState(PSP_CTRL_RIGHT) || mEngine->GetButtonState(PSP_CTRL_DOWN) || mEngine->GetAnalogY()>192)
{
if (KeyRepeated(PSP_CTRL_DOWN, dt))
{
int n = mCurr;
n++;
if (n>mCount-1)
{
if ((mStyle&JGUI_STYLE_WRAPPING))
n = 0;
else
n = mCount-1;
}
if (n != mCurr && mObjects[mCurr] != NULL && mObjects[mCurr]->Leaving(PSP_CTRL_DOWN))
{
mCurr = n;
mObjects[mCurr]->Entering();
}
}
}
else
mLastKey = 0;
}

46
projects/mtg/src/Logger.cpp
View File

@@ -1,23 +1,23 @@
#include "../include/debug.h"
#include "../include/Logger.h"
#include <iostream>
#include <fstream>
using namespace std;
#if defined (WIN32)
#include <windows.h>
#endif
void Logger::Log(char * text){
ofstream file (LOG_FILE,ios_base::app);
if (file){
file << text;
file << "\n";
file.close();
}
#if defined (WIN32) || defined (LINUX)
OutputDebugString(text);
OutputDebugString("\n");
#endif
}
#include "../include/debug.h"
#include "../include/Logger.h"
#include <iostream>
#include <fstream>
using namespace std;
#if defined (WIN32)
#include <windows.h>
#endif
void Logger::Log(char * text){
ofstream file (LOG_FILE,ios_base::app);
if (file){
file << text;
file << "\n";
file.close();
}
#if defined (WIN32) || defined (LINUX)
OutputDebugString(text);
OutputDebugString("\n");
#endif
}

3446
projects/mtg/src/MTGAbility.cpp
View File

File diff suppressed because it is too large Load Diff

620
projects/mtg/src/MTGCard.cpp
View File

@@ -1,310 +1,310 @@
//------------------------------------------------------
//MTGCard Class
//-------------------------------------------------
//TODO Fill BasicAbilities
#include "../include/debug.h"
#include "../include/MTGCard.h"
#include "../include/TexturesCache.h"
#include "../include/Subtypes.h"
#include <string>
#include <stdlib.h>
using std::string;
const char * const MTGCard::Colors_To_Text[] = {"Artifact", "Green", "Blue", "Red", "Black", "White", "Land"};
MTGCard::MTGCard(){
init();
mCache = NULL;
}
MTGCard::MTGCard(TexturesCache * cache, int set_id){
init();
mCache = cache;
setId = set_id;
}
const char * MTGCard::getSetName(){
return MtgSets::SetsList->values[setId].c_str();
}
MTGCard::MTGCard(MTGCard * source){
mCache = source->mCache;
for (int i = 0; i< NB_BASIC_ABILITIES; i++){
basicAbilities[i] = source->basicAbilities[i];
}
for (int i = 0; i< MAX_TYPES_PER_CARD; i++){
types[i] = source->types[i];
}
nb_types = source->nb_types;
for (int i = 0; i< MTG_NB_COLORS; i++){
colors[i] = source->colors[i];
}
manaCost.copy(source->getManaCost());
text = source->text;
name = source->name;
strcpy(image_name, source->image_name);
rarity = source->rarity;
power = source->power;
toughness = source->toughness;
mtgid = source->mtgid;
setId = source->setId;
formattedTextInit = 0;
magicText = source->magicText;
spellTargetType = source->spellTargetType;
alias = source->alias;
}
int MTGCard::init(){
nb_types = 0;
for (int i = 0; i< NB_BASIC_ABILITIES; i++){
basicAbilities[i] = 0;
}
for (int i = 0; i< MAX_TYPES_PER_CARD; i++){
types[i] = 0;
}
for (int i = 0; i< MTG_NB_COLORS; i++){
colors[i] = 0;
}
setId = 0;
formattedTextInit = 0;
magicText = "";
spellTargetType = "";
alias = 0;
return 1;
}
JQuad * MTGCard::getQuad(int type){
if (mCache == NULL){
return NULL;
}
return mCache->getQuad(this, type);
}
JQuad * MTGCard::getThumb(){
return getQuad(CACHE_THUMB);
}
JQuad * MTGCard::getQuad(TexturesCache * cache){
return cache->getQuad(this);
}
int MTGCard::isACreature(){
return (hasSubtype("creature"));
}
void MTGCard::setColor(int _color, int removeAllOthers){
if (removeAllOthers){
for (int i=0; i<MTG_NB_COLORS; i++){
colors[i] = 0;
}
}
colors[_color] = 1;
}
int MTGCard::getColor(){
int i = 0;
for (int i=0; i<MTG_NB_COLORS; i++){
if (colors[i]){
return i;
}
}
return 0;
}
int MTGCard::hasColor(int color){
return (colors[color]);
}
void MTGCard::setManaCost(string s){
ManaCost::parseManaCost(s, &manaCost);
for (int i = MTG_COLOR_GREEN; i <=MTG_COLOR_WHITE; i++){
if (manaCost.hasColor(i)){
setColor(i);
}
}
}
const char * MTGCard::colorToString(){
int color = getColor();
if (color>=0 && color <=5){
return Colors_To_Text[color];
}
return "Unknown";
}
void MTGCard::setMTGId(int id){
mtgid = id;
sprintf(image_name, "%d.jpg", mtgid);
}
int MTGCard::getMTGId(){
return mtgid;
}
int MTGCard::getId(){
return mtgid;
}
char MTGCard::getRarity(){
return rarity;
}
void MTGCard::setRarity(char _rarity){
rarity = _rarity;
}
void MTGCard::setType(const char * _type_text){
setSubtype(_type_text);
}
void MTGCard::addType(char * _type_text){
setSubtype(_type_text);
}
void MTGCard::setSubtype( string value){
string s = value;
while (s.size()){
unsigned int found = s.find(" ");
if (found != string::npos){
int id = Subtypes::subtypesList->Add(s.substr(0,found));
addType(id);
s = s.substr(found+1);
}else{
int id = Subtypes::subtypesList->Add(s);
addType(id);
s = "";
}
}
}
void MTGCard::addType(int id){
types[nb_types] = id;
nb_types++;
}
//Removes a type from the types of a given card
//If removeAll is true, removes all occurences of this type, otherwise only removes the first occurence
int MTGCard::removeType(string value, int removeAll){
int id = Subtypes::subtypesList->Add(value);
return removeType(id, removeAll);
}
int MTGCard::removeType(int id, int removeAll){
int result = 0;
for (int i = nb_types -1 ; i >=0; i--){
if (types[i] == id){
types[i] = types[nb_types -1];
nb_types--;
result++;
if (!removeAll) return result;
}
}
return result;
}
char * MTGCard::getImageName(){
return image_name;
}
void MTGCard::setText( string value){
text = value;
}
const char * MTGCard::getText(){
return text.c_str();
}
void MTGCard::addMagicText(string value){
std::transform( value.begin(), value.end(), value.begin(),::tolower );
if (magicText.size()) magicText.append("\n");
magicText.append(value);
}
void MTGCard::setName( string value){
name = value;
}
const char * MTGCard::getName(){
return name.c_str();
}
ManaCost * MTGCard::getManaCost(){
return &manaCost;
}
int MTGCard::hasType(int _type){
int i;
for (i = 0; i<nb_types; i++){
if(types[i] == _type){
return 1;
}
}
return 0;
}
int MTGCard::hasSubtype(int _subtype){
return(hasType(_subtype));
}
int MTGCard::hasType(const char * _type){
int id = Subtypes::subtypesList->Add(_type);
return(hasType(id));
}
int MTGCard::hasSubtype(const char * _subtype){
int id = Subtypes::subtypesList->Add(_subtype);
return(hasType(id));
}
int MTGCard::hasSubtype(string _subtype){
int id = Subtypes::subtypesList->Add(_subtype);
return(hasType(id));
}
int MTGCard::has(int basicAbility){
return basicAbilities[basicAbility];
}
//---------------------------------------------
// Creature specific
//---------------------------------------------
void MTGCard::setPower(int _power){
power = _power;
}
int MTGCard::getPower(){
return power;
}
void MTGCard::setToughness(int _toughness){
toughness = _toughness;
}
int MTGCard::getToughness(){
return toughness;
}
//------------------------------------------------------
//MTGCard Class
//-------------------------------------------------
//TODO Fill BasicAbilities
#include "../include/debug.h"
#include "../include/MTGCard.h"
#include "../include/TexturesCache.h"
#include "../include/Subtypes.h"
#include <string>
#include <stdlib.h>
using std::string;
const char * const MTGCard::Colors_To_Text[] = {"Artifact", "Green", "Blue", "Red", "Black", "White", "Land"};
MTGCard::MTGCard(){
init();
mCache = NULL;
}
MTGCard::MTGCard(TexturesCache * cache, int set_id){
init();
mCache = cache;
setId = set_id;
}
const char * MTGCard::getSetName(){
return MtgSets::SetsList->values[setId].c_str();
}
MTGCard::MTGCard(MTGCard * source){
mCache = source->mCache;
for (int i = 0; i< NB_BASIC_ABILITIES; i++){
basicAbilities[i] = source->basicAbilities[i];
}
for (int i = 0; i< MAX_TYPES_PER_CARD; i++){
types[i] = source->types[i];
}
nb_types = source->nb_types;
for (int i = 0; i< MTG_NB_COLORS; i++){
colors[i] = source->colors[i];
}
manaCost.copy(source->getManaCost());
text = source->text;
name = source->name;
strcpy(image_name, source->image_name);
rarity = source->rarity;
power = source->power;
toughness = source->toughness;
mtgid = source->mtgid;
setId = source->setId;
formattedTextInit = 0;
magicText = source->magicText;
spellTargetType = source->spellTargetType;
alias = source->alias;
}
int MTGCard::init(){
nb_types = 0;
for (int i = 0; i< NB_BASIC_ABILITIES; i++){
basicAbilities[i] = 0;
}
for (int i = 0; i< MAX_TYPES_PER_CARD; i++){
types[i] = 0;
}
for (int i = 0; i< MTG_NB_COLORS; i++){
colors[i] = 0;
}
setId = 0;
formattedTextInit = 0;
magicText = "";
spellTargetType = "";
alias = 0;
return 1;
}
JQuad * MTGCard::getQuad(int type){
if (mCache == NULL){
return NULL;
}
return mCache->getQuad(this, type);
}
JQuad * MTGCard::getThumb(){
return getQuad(CACHE_THUMB);
}
JQuad * MTGCard::getQuad(TexturesCache * cache){
return cache->getQuad(this);
}
int MTGCard::isACreature(){
return (hasSubtype("creature"));
}
void MTGCard::setColor(int _color, int removeAllOthers){
if (removeAllOthers){
for (int i=0; i<MTG_NB_COLORS; i++){
colors[i] = 0;
}
}
colors[_color] = 1;
}
int MTGCard::getColor(){
int i = 0;
for (int i=0; i<MTG_NB_COLORS; i++){
if (colors[i]){
return i;
}
}
return 0;
}
int MTGCard::hasColor(int color){
return (colors[color]);
}
void MTGCard::setManaCost(string s){
ManaCost::parseManaCost(s, &manaCost);
for (int i = MTG_COLOR_GREEN; i <=MTG_COLOR_WHITE; i++){
if (manaCost.hasColor(i)){
setColor(i);
}
}
}
const char * MTGCard::colorToString(){
int color = getColor();
if (color>=0 && color <=5){
return Colors_To_Text[color];
}
return "Unknown";
}
void MTGCard::setMTGId(int id){
mtgid = id;
sprintf(image_name, "%d.jpg", mtgid);
}
int MTGCard::getMTGId(){
return mtgid;
}
int MTGCard::getId(){
return mtgid;
}
char MTGCard::getRarity(){
return rarity;
}
void MTGCard::setRarity(char _rarity){
rarity = _rarity;
}
void MTGCard::setType(const char * _type_text){
setSubtype(_type_text);
}
void MTGCard::addType(char * _type_text){
setSubtype(_type_text);
}
void MTGCard::setSubtype( string value){
string s = value;
while (s.size()){
unsigned int found = s.find(" ");
if (found != string::npos){
int id = Subtypes::subtypesList->Add(s.substr(0,found));
addType(id);
s = s.substr(found+1);
}else{
int id = Subtypes::subtypesList->Add(s);
addType(id);
s = "";
}
}
}
void MTGCard::addType(int id){
types[nb_types] = id;
nb_types++;
}
//Removes a type from the types of a given card
//If removeAll is true, removes all occurences of this type, otherwise only removes the first occurence
int MTGCard::removeType(string value, int removeAll){
int id = Subtypes::subtypesList->Add(value);
return removeType(id, removeAll);
}
int MTGCard::removeType(int id, int removeAll){
int result = 0;
for (int i = nb_types -1 ; i >=0; i--){
if (types[i] == id){
types[i] = types[nb_types -1];
nb_types--;
result++;
if (!removeAll) return result;
}
}
return result;
}
char * MTGCard::getImageName(){
return image_name;
}
void MTGCard::setText( string value){
text = value;
}
const char * MTGCard::getText(){
return text.c_str();
}
void MTGCard::addMagicText(string value){
std::transform( value.begin(), value.end(), value.begin(),::tolower );
if (magicText.size()) magicText.append("\n");
magicText.append(value);
}
void MTGCard::setName( string value){
name = value;
}
const char * MTGCard::getName(){
return name.c_str();
}
ManaCost * MTGCard::getManaCost(){
return &manaCost;
}
int MTGCard::hasType(int _type){
int i;
for (i = 0; i<nb_types; i++){
if(types[i] == _type){
return 1;
}
}
return 0;
}
int MTGCard::hasSubtype(int _subtype){
return(hasType(_subtype));
}
int MTGCard::hasType(const char * _type){
int id = Subtypes::subtypesList->Add(_type);
return(hasType(id));
}
int MTGCard::hasSubtype(const char * _subtype){
int id = Subtypes::subtypesList->Add(_subtype);
return(hasType(id));
}
int MTGCard::hasSubtype(string _subtype){
int id = Subtypes::subtypesList->Add(_subtype);
return(hasType(id));
}
int MTGCard::has(int basicAbility){
return basicAbilities[basicAbility];
}
//---------------------------------------------
// Creature specific
//---------------------------------------------
void MTGCard::setPower(int _power){
power = _power;
}
int MTGCard::getPower(){
return power;
}
void MTGCard::setToughness(int _toughness){
toughness = _toughness;
}
int MTGCard::getToughness(){
return toughness;
}

814
projects/mtg/src/MTGCardInstance.cpp
View File

@@ -1,407 +1,407 @@
/*---------------------------------------------
Card Instance
Instance of a given MTGCard in the game
Although there is only one MTGCard of each type, there can be as much Instances of it as needed in the game
--------------------------------------------
*/
#include "../include/debug.h"
#include "../include/MTGCardInstance.h"
#include "../include/CardDescriptor.h"
#include "../include/Counters.h"
MTGCardInstance::MTGCardInstance(): MTGCard(), Damageable(0){
LOG("==Creating MTGCardInstance==");
initMTGCI();
LOG("==Creating MTGCardInstance Successful==");
}
MTGCardInstance::MTGCardInstance(MTGCard * card, MTGPlayerCards * _belongs_to): MTGCard(card), Damageable(card->getToughness()){
LOG("==Creating MTGCardInstance==");
initMTGCI();
model = card;
lifeOrig = life;
belongs_to=_belongs_to;
initAttackersDefensers();
life=toughness;
LOG("==Creating MTGCardInstance Successful==");
}
MTGCardInstance::~MTGCardInstance(){
LOG("==Deleting MTGCardInstance==");
SAFE_DELETE(blockers);
SAFE_DELETE(counters);
LOG("==Deleting MTGCardInstance Succesfull==");
}
void MTGCardInstance::initMTGCI(){
model=NULL;
lifeOrig = 0;
doDamageTest = 0;
belongs_to=NULL;
tapped = 0;
blockers = NEW Blockers();
untapping = 0;
summoningSickness = 0;
target = NULL;
nbprotections = 0;
type_as_damageable = DAMAGEABLE_MTGCARDINSTANCE;
banding = NULL;
owner = NULL;
changedZoneRecently = 0;
counters = NEW Counters(this);
}
void MTGCardInstance::addType(int type){
types[nb_types] = type;
nb_types++;
}
Blockers * MTGCardInstance::getBlockers(){
return blockers;
}
int MTGCardInstance::isInPlay(){
GameObserver * game = GameObserver::GetInstance();
for (int i = 0 ; i < 2 ; i++){
MTGGameZone * zone = game->players[i]->game->inPlay;
if (zone->hasCard(this)) return 1;
}
return 0;
}
int MTGCardInstance::afterDamage(){
if (!doDamageTest) return 0;
#if defined (WIN32) || defined (LINUX)
char buf[4096], *p = buf;
sprintf(buf,"After Damage Test, life is %i for %s \n",life,model->getName());
OutputDebugString(buf);
#endif
doDamageTest = 0;
if (life <=0 && isInPlay()){
GameObserver * game = GameObserver::GetInstance();
game->mLayers->stackLayer()->addPutInGraveyard(this);
return 1;
}
return 0;
}
MTGGameZone * MTGCardInstance::getCurrentZone(){
GameObserver * game = GameObserver::GetInstance();
for (int i = 0; i < 2; i++){
MTGPlayerCards * g = game->players[i]->game;
MTGGameZone * zones[] = {g->inPlay,g->graveyard,g->hand, g->library};
for (int k = 0; k < 4; k++){
MTGGameZone * zone = zones[k];
if (zone->hasCard(this)) return zone;
}
}
return NULL;
}
JQuad * MTGCardInstance::getIcon(){
return getThumb();
}
int MTGCardInstance::has(int basicAbility){
return basicAbilities[basicAbility];
}
//Taps the card
void MTGCardInstance::tap(){
tapped = 1;
}
void MTGCardInstance::setUntapping(){
untapping = 1;
}
int MTGCardInstance::isUntapping(){
return untapping;
}
//Untaps the card
void MTGCardInstance::untap(){
if (untapping){
tapped = 0;
untapping = 0;
}
}
//Tells if the card is tapped or not
int MTGCardInstance::isTapped(){
return tapped;
}
void MTGCardInstance::resetAllDamage(){
//for (int i=0;i<nb_damages;i++){
// delete damages[i];
//}
nb_damages = 0;
}
void MTGCardInstance::regenerate(){
tapped = 1;
life = toughness;
initAttackersDefensers();
}
int MTGCardInstance::initAttackersDefensers(){
attacker = 0;
defenser = NULL;
banding = NULL;
return 1;
}
//Function to call to remove all damages, etc to a card (generally at the end of the turn)
int MTGCardInstance::cleanup(){
initAttackersDefensers();
life=toughness;
GameObserver * game = GameObserver::GetInstance();
if (!game || game->currentPlayer == controller()) summoningSickness = 0;
return 1;
}
/* Summoning Sickness
* 212.3f A creature<72>fs activated ability with the tap symbol or the untap symbol in its activation cost
* can<61>ft be played unless the creature has been under its controller<65>fs control since the start of his or
* her most recent turn. A creature can<61>ft attack unless it has been under its controller<65>fs control
* since the start of his or her most recent turn. This rule is informally called the <20>gsummoning
* sickness<73>h rule. Ignore this rule for creatures with haste (see rule 502.5).
*/
int MTGCardInstance::hasSummoningSickness(){
if (!summoningSickness) return 0;
if (basicAbilities[HASTE]) return 0;
if (!isACreature()) return 0;
return 1;
}
int MTGCardInstance::changeController(Player * newController){
Player * originalOwner = controller();
if (originalOwner == newController) return 0;
originalOwner->game->inPlay->removeCard(this);
newController->game->inPlay->addCard(this);
summoningSickness = 1;
return 1;
}
//Reset the card parameters
int MTGCardInstance::reset(){
cleanup();
tapped=0;
SAFE_DELETE(counters);
counters = NEW Counters(this);
return 1;
}
Player * MTGCardInstance::controller(){
GameObserver * game = GameObserver::GetInstance();
if (!game) return NULL;
for (int i = 0; i < 2; i++){
if (game->players[i]->game->inPlay->hasCard(this)) return game->players[i];
if (game->players[i]->game->stack->hasCard(this)) return game->players[i];
if (game->players[i]->game->graveyard->hasCard(this)) return game->players[i];
}
return NULL;
}
int MTGCardInstance::canAttack(){
if (!hasSummoningSickness() && !tapped && isACreature() && basicAbilities[DEFENSER] !=1)
return 1;
return 0;
}
int MTGCardInstance::addToToughness(int value){
toughness+=value;
life+=value;
doDamageTest = 1;
return 1;
}
int MTGCardInstance::setToughness(int value){
toughness=value;
life=value;
doDamageTest = 1;
return 1;
}
int MTGCardInstance::canBlock(){
if (!tapped && isACreature())return 1;
return 0;
}
int MTGCardInstance::canBlock(MTGCardInstance * opponent){
if (!canBlock()) return 0;
if (!opponent) return 1;
if (!opponent->isAttacker()) return 0;
// Comprehensive rule 502.7f : If a creature with protection attacks, it can't be blocked by creatures that have the stated quality.
if (opponent->protectedAgainst(this)) return 0;
if (opponent->basicAbilities[UNBLOCKABLE]) return 0;
if (opponent->basicAbilities[FEAR] && !(hasColor(MTG_COLOR_ARTIFACT) || hasColor(MTG_COLOR_BLACK))) return 0;
if (opponent->basicAbilities[FLYING] && !( basicAbilities[FLYING] || basicAbilities[REACH])) return 0;
// If opponent has shadow and a creature does not have either shadow or reachshadow it cannot be blocked
if (opponent->basicAbilities[SHADOW] && !( basicAbilities[SHADOW] || basicAbilities[REACHSHADOW])) return 0;
// If opponent does not have shadow and a creature has shadow it cannot be blocked
if (!opponent->basicAbilities[SHADOW] && basicAbilities[SHADOW]) return 0;
if (opponent->basicAbilities[SWAMPWALK] && controller()->game->inPlay->hasType("swamp")) return 0;
if (opponent->basicAbilities[FORESTWALK] && controller()->game->inPlay->hasType("forest")) return 0;
if (opponent->basicAbilities[ISLANDWALK] && controller()->game->inPlay->hasType("island")) return 0;
if (opponent->basicAbilities[MOUNTAINWALK] && controller()->game->inPlay->hasType("mountain")) return 0;
if (opponent->basicAbilities[PLAINSWALK] && controller()->game->inPlay->hasType("plains")) return 0;
return 1;
}
MTGCardInstance * MTGCardInstance::getNextPartner(){
MTGInPlay * inplay = controller()->game->inPlay;
MTGCardInstance * bandingPartner = inplay->getNextAttacker(banding);
while (bandingPartner){
if (basicAbilities[BANDING] || bandingPartner->basicAbilities[BANDING]) return bandingPartner;
bandingPartner = inplay->getNextAttacker(bandingPartner);
}
return NULL;
}
void MTGCardInstance::unband(){
if (!banding) return;
MTGCardInstance * _banding = banding;
banding = NULL;
MTGCardInstance * newbanding = NULL;
MTGInPlay * inplay = controller()->game->inPlay;
int nbpartners = inplay->nbPartners(this);
MTGCardInstance * card = inplay->getNextAttacker(NULL);
while(card){
if (card != this){
if (card->banding == _banding){
if (nbpartners == 1){
card->banding = NULL;
return;
}else{
if (!newbanding) newbanding = card;
card->banding = newbanding;
}
}
}
card = inplay->getNextAttacker(card);
}
return ;
}
int MTGCardInstance::toggleAttacker(){
//TODO more controls ?
if (canAttack()){
if (!attacker){
attacker = 1;
tapped = 1;
return 1;
}else{
MTGCardInstance * bandingPartner = getNextPartner();
if (bandingPartner){
if (banding) unband();
if (!bandingPartner->banding) bandingPartner->banding = bandingPartner;
banding = bandingPartner->banding;
return 1;
}else{
attacker = 0;
tapped = 0;
return 1;
}
}
}
return 0;
}
int MTGCardInstance::isAttacker(){
return attacker;
}
MTGCardInstance * MTGCardInstance::isDefenser(){
return defenser;
}
int MTGCardInstance::nbOpponents(){
int result= 0;
MTGCardInstance* opponent = getNextOpponent();
while (opponent){
result++;
opponent = getNextOpponent(opponent);
}
return result;
}
//Returns opponents to this card for this turn. This * should * take into account banding
MTGCardInstance * MTGCardInstance::getNextOpponent(MTGCardInstance * previous){
GameObserver * game = GameObserver::GetInstance();
int foundprevious = 0;
if (!previous) foundprevious = 1;
if (attacker && game->currentPlayer->game->inPlay->hasCard(this)){
MTGInPlay * inPlay = game->opponent()->game->inPlay;
for (int i = 0; i < inPlay->nb_cards; i ++){
MTGCardInstance * current = inPlay->cards[i];
if (current == previous){
foundprevious = 1;
}else if (foundprevious){
MTGCardInstance * defensersOpponent = current->isDefenser();
if (defensersOpponent && (defensersOpponent == this || (banding && defensersOpponent->banding == banding))){
return current;
}
}
}
}else if (defenser && game->opponent()->game->inPlay->hasCard(this)){
MTGInPlay * inPlay = game->currentPlayer->game->inPlay;
for (int i = 0; i < inPlay->nb_cards; i ++){
MTGCardInstance * current = inPlay->cards[i];
if (current == previous){
foundprevious = 1;
}else if (foundprevious){
if (defenser == current || (current->banding && defenser->banding == current->banding)){
return current;
}
}
}
}
return NULL;
}
int MTGCardInstance::toggleDefenser(MTGCardInstance * opponent){
if (canBlock()){
if (canBlock(opponent)){
defenser = opponent;
return 1;
}
}
return 0;
}
int MTGCardInstance::addProtection(CardDescriptor * cd){
protections[nbprotections] = cd;
nbprotections++;
return nbprotections;
}
int MTGCardInstance::removeProtection(CardDescriptor * cd, int erase){
for (int i = 0; i < nbprotections ; i++){
if (protections[i] == cd){
if (erase) delete (protections[i]);
protections[i] = protections[nbprotections -1];
protections[nbprotections -1] = NULL;
nbprotections--;
return 1;
}
}
return 0;
}
int MTGCardInstance::protectedAgainst(MTGCardInstance * card){
for (int i = 0; i < nbprotections ; i++){
if (protections[i]->match(card)) return 1;
}
return 0;
}
/*---------------------------------------------
Card Instance
Instance of a given MTGCard in the game
Although there is only one MTGCard of each type, there can be as much Instances of it as needed in the game
--------------------------------------------
*/
#include "../include/debug.h"
#include "../include/MTGCardInstance.h"
#include "../include/CardDescriptor.h"
#include "../include/Counters.h"
MTGCardInstance::MTGCardInstance(): MTGCard(), Damageable(0){
LOG("==Creating MTGCardInstance==");
initMTGCI();
LOG("==Creating MTGCardInstance Successful==");
}
MTGCardInstance::MTGCardInstance(MTGCard * card, MTGPlayerCards * _belongs_to): MTGCard(card), Damageable(card->getToughness()){
LOG("==Creating MTGCardInstance==");
initMTGCI();
model = card;
lifeOrig = life;
belongs_to=_belongs_to;
initAttackersDefensers();
life=toughness;
LOG("==Creating MTGCardInstance Successful==");
}
MTGCardInstance::~MTGCardInstance(){
LOG("==Deleting MTGCardInstance==");
SAFE_DELETE(blockers);
SAFE_DELETE(counters);
LOG("==Deleting MTGCardInstance Succesfull==");
}
void MTGCardInstance::initMTGCI(){
model=NULL;
lifeOrig = 0;
doDamageTest = 0;
belongs_to=NULL;
tapped = 0;
blockers = NEW Blockers();
untapping = 0;
summoningSickness = 0;
target = NULL;
nbprotections = 0;
type_as_damageable = DAMAGEABLE_MTGCARDINSTANCE;
banding = NULL;
owner = NULL;
changedZoneRecently = 0;
counters = NEW Counters(this);
}
void MTGCardInstance::addType(int type){
types[nb_types] = type;
nb_types++;
}
Blockers * MTGCardInstance::getBlockers(){
return blockers;
}
int MTGCardInstance::isInPlay(){
GameObserver * game = GameObserver::GetInstance();
for (int i = 0 ; i < 2 ; i++){
MTGGameZone * zone = game->players[i]->game->inPlay;
if (zone->hasCard(this)) return 1;
}
return 0;
}
int MTGCardInstance::afterDamage(){
if (!doDamageTest) return 0;
#if defined (WIN32) || defined (LINUX)
char buf[4096], *p = buf;
sprintf(buf,"After Damage Test, life is %i for %s \n",life,model->getName());
OutputDebugString(buf);
#endif
doDamageTest = 0;
if (life <=0 && isInPlay()){
GameObserver * game = GameObserver::GetInstance();
game->mLayers->stackLayer()->addPutInGraveyard(this);
return 1;
}
return 0;
}
MTGGameZone * MTGCardInstance::getCurrentZone(){
GameObserver * game = GameObserver::GetInstance();
for (int i = 0; i < 2; i++){
MTGPlayerCards * g = game->players[i]->game;
MTGGameZone * zones[] = {g->inPlay,g->graveyard,g->hand, g->library};
for (int k = 0; k < 4; k++){
MTGGameZone * zone = zones[k];
if (zone->hasCard(this)) return zone;
}
}
return NULL;
}
JQuad * MTGCardInstance::getIcon(){
return getThumb();
}
int MTGCardInstance::has(int basicAbility){
return basicAbilities[basicAbility];
}
//Taps the card
void MTGCardInstance::tap(){
tapped = 1;
}
void MTGCardInstance::setUntapping(){
untapping = 1;
}
int MTGCardInstance::isUntapping(){
return untapping;
}
//Untaps the card
void MTGCardInstance::untap(){
if (untapping){
tapped = 0;
untapping = 0;
}
}
//Tells if the card is tapped or not
int MTGCardInstance::isTapped(){
return tapped;
}
void MTGCardInstance::resetAllDamage(){
//for (int i=0;i<nb_damages;i++){
// delete damages[i];
//}
nb_damages = 0;
}
void MTGCardInstance::regenerate(){
tapped = 1;
life = toughness;
initAttackersDefensers();
}
int MTGCardInstance::initAttackersDefensers(){
attacker = 0;
defenser = NULL;
banding = NULL;
return 1;
}
//Function to call to remove all damages, etc to a card (generally at the end of the turn)
int MTGCardInstance::cleanup(){
initAttackersDefensers();
life=toughness;
GameObserver * game = GameObserver::GetInstance();
if (!game || game->currentPlayer == controller()) summoningSickness = 0;
return 1;
}
/* Summoning Sickness
* 212.3f A creature<72>fs activated ability with the tap symbol or the untap symbol in its activation cost
* can<61>ft be played unless the creature has been under its controller<65>fs control since the start of his or
* her most recent turn. A creature can<61>ft attack unless it has been under its controller<65>fs control
* since the start of his or her most recent turn. This rule is informally called the <20>gsummoning
* sickness<73>h rule. Ignore this rule for creatures with haste (see rule 502.5).
*/
int MTGCardInstance::hasSummoningSickness(){
if (!summoningSickness) return 0;
if (basicAbilities[HASTE]) return 0;
if (!isACreature()) return 0;
return 1;
}
int MTGCardInstance::changeController(Player * newController){
Player * originalOwner = controller();
if (originalOwner == newController) return 0;
originalOwner->game->inPlay->removeCard(this);
newController->game->inPlay->addCard(this);
summoningSickness = 1;
return 1;
}
//Reset the card parameters
int MTGCardInstance::reset(){
cleanup();
tapped=0;
SAFE_DELETE(counters);
counters = NEW Counters(this);
return 1;
}
Player * MTGCardInstance::controller(){
GameObserver * game = GameObserver::GetInstance();
if (!game) return NULL;
for (int i = 0; i < 2; i++){
if (game->players[i]->game->inPlay->hasCard(this)) return game->players[i];
if (game->players[i]->game->stack->hasCard(this)) return game->players[i];
if (game->players[i]->game->graveyard->hasCard(this)) return game->players[i];
}
return NULL;
}
int MTGCardInstance::canAttack(){
if (!hasSummoningSickness() && !tapped && isACreature() && basicAbilities[DEFENSER] !=1)
return 1;
return 0;
}
int MTGCardInstance::addToToughness(int value){
toughness+=value;
life+=value;
doDamageTest = 1;
return 1;
}
int MTGCardInstance::setToughness(int value){
toughness=value;
life=value;
doDamageTest = 1;
return 1;
}
int MTGCardInstance::canBlock(){
if (!tapped && isACreature())return 1;
return 0;
}
int MTGCardInstance::canBlock(MTGCardInstance * opponent){
if (!canBlock()) return 0;
if (!opponent) return 1;
if (!opponent->isAttacker()) return 0;
// Comprehensive rule 502.7f : If a creature with protection attacks, it can't be blocked by creatures that have the stated quality.
if (opponent->protectedAgainst(this)) return 0;
if (opponent->basicAbilities[UNBLOCKABLE]) return 0;
if (opponent->basicAbilities[FEAR] && !(hasColor(MTG_COLOR_ARTIFACT) || hasColor(MTG_COLOR_BLACK))) return 0;
if (opponent->basicAbilities[FLYING] && !( basicAbilities[FLYING] || basicAbilities[REACH])) return 0;
// If opponent has shadow and a creature does not have either shadow or reachshadow it cannot be blocked
if (opponent->basicAbilities[SHADOW] && !( basicAbilities[SHADOW] || basicAbilities[REACHSHADOW])) return 0;
// If opponent does not have shadow and a creature has shadow it cannot be blocked
if (!opponent->basicAbilities[SHADOW] && basicAbilities[SHADOW]) return 0;
if (opponent->basicAbilities[SWAMPWALK] && controller()->game->inPlay->hasType("swamp")) return 0;
if (opponent->basicAbilities[FORESTWALK] && controller()->game->inPlay->hasType("forest")) return 0;
if (opponent->basicAbilities[ISLANDWALK] && controller()->game->inPlay->hasType("island")) return 0;
if (opponent->basicAbilities[MOUNTAINWALK] && controller()->game->inPlay->hasType("mountain")) return 0;
if (opponent->basicAbilities[PLAINSWALK] && controller()->game->inPlay->hasType("plains")) return 0;
return 1;
}
MTGCardInstance * MTGCardInstance::getNextPartner(){
MTGInPlay * inplay = controller()->game->inPlay;
MTGCardInstance * bandingPartner = inplay->getNextAttacker(banding);
while (bandingPartner){
if (basicAbilities[BANDING] || bandingPartner->basicAbilities[BANDING]) return bandingPartner;
bandingPartner = inplay->getNextAttacker(bandingPartner);
}
return NULL;
}
void MTGCardInstance::unband(){
if (!banding) return;
MTGCardInstance * _banding = banding;
banding = NULL;
MTGCardInstance * newbanding = NULL;
MTGInPlay * inplay = controller()->game->inPlay;
int nbpartners = inplay->nbPartners(this);
MTGCardInstance * card = inplay->getNextAttacker(NULL);
while(card){
if (card != this){
if (card->banding == _banding){
if (nbpartners == 1){
card->banding = NULL;
return;
}else{
if (!newbanding) newbanding = card;
card->banding = newbanding;
}
}
}
card = inplay->getNextAttacker(card);
}
return ;
}
int MTGCardInstance::toggleAttacker(){
//TODO more controls ?
if (canAttack()){
if (!attacker){
attacker = 1;
tapped = 1;
return 1;
}else{
MTGCardInstance * bandingPartner = getNextPartner();
if (bandingPartner){
if (banding) unband();
if (!bandingPartner->banding) bandingPartner->banding = bandingPartner;
banding = bandingPartner->banding;
return 1;
}else{
attacker = 0;
tapped = 0;
return 1;
}
}
}
return 0;
}
int MTGCardInstance::isAttacker(){
return attacker;
}
MTGCardInstance * MTGCardInstance::isDefenser(){
return defenser;
}
int MTGCardInstance::nbOpponents(){
int result= 0;
MTGCardInstance* opponent = getNextOpponent();
while (opponent){
result++;
opponent = getNextOpponent(opponent);
}
return result;
}
//Returns opponents to this card for this turn. This * should * take into account banding
MTGCardInstance * MTGCardInstance::getNextOpponent(MTGCardInstance * previous){
GameObserver * game = GameObserver::GetInstance();
int foundprevious = 0;
if (!previous) foundprevious = 1;
if (attacker && game->currentPlayer->game->inPlay->hasCard(this)){
MTGInPlay * inPlay = game->opponent()->game->inPlay;
for (int i = 0; i < inPlay->nb_cards; i ++){
MTGCardInstance * current = inPlay->cards[i];
if (current == previous){
foundprevious = 1;
}else if (foundprevious){
MTGCardInstance * defensersOpponent = current->isDefenser();
if (defensersOpponent && (defensersOpponent == this || (banding && defensersOpponent->banding == banding))){
return current;
}
}
}
}else if (defenser && game->opponent()->game->inPlay->hasCard(this)){
MTGInPlay * inPlay = game->currentPlayer->game->inPlay;
for (int i = 0; i < inPlay->nb_cards; i ++){
MTGCardInstance * current = inPlay->cards[i];
if (current == previous){
foundprevious = 1;
}else if (foundprevious){
if (defenser == current || (current->banding && defenser->banding == current->banding)){
return current;
}
}
}
}
return NULL;
}
int MTGCardInstance::toggleDefenser(MTGCardInstance * opponent){
if (canBlock()){
if (canBlock(opponent)){
defenser = opponent;
return 1;
}
}
return 0;
}
int MTGCardInstance::addProtection(CardDescriptor * cd){
protections[nbprotections] = cd;
nbprotections++;
return nbprotections;
}
int MTGCardInstance::removeProtection(CardDescriptor * cd, int erase){
for (int i = 0; i < nbprotections ; i++){
if (protections[i] == cd){
if (erase) delete (protections[i]);
protections[i] = protections[nbprotections -1];
protections[nbprotections -1] = NULL;
nbprotections--;
return 1;
}
}
return 0;
}
int MTGCardInstance::protectedAgainst(MTGCardInstance * card){
for (int i = 0; i < nbprotections ; i++){
if (protections[i]->match(card)) return 1;
}
return 0;
}

770
projects/mtg/src/MTGDeck.cpp
View File

@@ -1,385 +1,385 @@
#include "../include/debug.h"
#include "../include/MTGDeck.h"
#include "../include/utils.h"
#include <algorithm>
#include <string>
using std::string;
#include <JGE.h>
#if defined (WIN32) || defined (LINUX)
#include <time.h>
#endif
MtgSets * MtgSets::SetsList = NEW MtgSets();
MtgSets::MtgSets(){
nb_items = 0;
}
int MtgSets::Add(const char * name){
string value = name;
values[nb_items] = value;
nb_items++;
return nb_items - 1;
}
int MTGAllCards::processConfLine(char *buffer, MTGCard *card){
string s = buffer;
unsigned int i = s.find_first_of("=");
if (i == string::npos) return 0;
string key = s.substr(0,i);
string value = s.substr(i+1);
if(key.compare( "auto")==0){
card->addMagicText(value);
}
else if(key.compare( "alias")==0){
card->alias=atoi(value.c_str());
}
else if(key.compare( "target")==0){
std::transform( value.begin(), value.end(), value.begin(),::tolower );
card->spellTargetType=value;
}
else if(key.compare( "text")==0){
card->setText(value);
}else if (key.compare("abilities")==0){
//Specific Abilities
std::transform( value.begin(), value.end(), value.begin(),::tolower );
for (int j = 0; j < NB_BASIC_ABILITIES; j++){
unsigned int found = value.find(MTGBasicAbilities[j]);
if (found != string::npos){
card->basicAbilities[j] = 1;
}
}
}else if(key.compare("id")==0){
card->setMTGId(atoi(value.c_str()));
}else if(key.compare("name")==0){
card->setName(value);
}else if(key.compare("rarity")==0){
card->setRarity (value.c_str()[0]);
}else if(key.compare("mana")==0){
std::transform( value.begin(), value.end(), value.begin(),::tolower );
card->setManaCost(value);
}else if(key.compare("type")==0){
switch(value.c_str()[0]){
case 'C':
card->setType( "Creature");
break;
case 'A':
card->setType( "Artifact");
card->setColor(MTG_COLOR_ARTIFACT);
if (value.c_str()[8] == ' ' && value.c_str()[9] == 'C')
card->setSubtype("Creature");
break;
case 'E':
card->setType( "Enchantment");
break;
case 'S':
card->setType( "Sorcery");
break;
case 'B'://Basic Land
card->setColor(MTG_COLOR_LAND);
card->setType("Land");
break;
case 'L':
card->setColor(MTG_COLOR_LAND);
card->setType( "Land");
break;
case 'I':
card->setType( "Instant");
break;
default:
card->setType( "Error");
break;
}
}else if(key.compare("power")==0){
card->setPower (atoi(value.c_str()));
}else if(key.compare("subtype")==0){
card->setSubtype(value);
}else if(key.compare("toughness")==0){
card->setToughness(atoi(value.c_str()));
}else{
}
return i;
}
void MTGAllCards::initCounters(){
for (int i=0; i< MTG_NB_COLORS; i++){
colorsCount[i] = NULL;
}
}
void MTGAllCards::init(){
mCache = NULL;
total_cards = 0;
initCounters();
srand(time(0)); // initialize random
}
int MTGAllCards::load(const char * config_file, const char * set_name,int autoload){
conf_read_mode = 0;
int file_size = filesize(config_file);
conf_buffer = (char *) malloc(file_size);
read_cursor = 0;
// conf_fd = sceIoOpen(config_file, PSP_O_RDONLY, 0777);
read_file(config_file, conf_buffer, file_size );
int set_id = MtgSets::SetsList->Add(set_name);
if (autoload){
while(readConfLine(set_id)){};
}
return total_cards;
}
MTGAllCards::MTGAllCards(){
init();
}
MTGAllCards::~MTGAllCards(){
}
void MTGAllCards::destroyAllCards(){
for (int i= 0; i < total_cards; i++){
delete collection[i];
};
}
MTGAllCards::MTGAllCards(const char * config_file, const char * set_name){
MTGAllCards(config_file, set_name, NULL);
}
MTGAllCards::MTGAllCards(TexturesCache * cache){
init();
mCache = cache;
}
MTGAllCards::MTGAllCards(const char * config_file, const char * set_name, TexturesCache * cache){
init();
mCache = cache;
load(config_file,set_name, 0);
}
MTGCard * MTGAllCards::_(int i){
if (i < total_cards) return collection[i];
return NULL;
}
int MTGAllCards::randomCardId(){
int id = (rand() % total_cards);
return collection[id]->getMTGId();
}
int MTGAllCards::countBySet(int setId){
int result = 0;
for (int i=0; i< total_cards; i++){
if(collection[i]->setId == setId){
result++;
}
}
return result;
}
//TODO more efficient way ?
int MTGAllCards::countByType(const char * _type){
int result = 0;
for (int i=0; i< total_cards; i++){
if(collection[i]->hasType(_type)){
result++;
}
}
return result;
}
int MTGAllCards::countByColor(int color){
if (colorsCount[color] == 0){
for (int i=0; i< MTG_NB_COLORS; i++){
colorsCount[i] = 0;
}
for (int i=0; i< total_cards; i++){
int j = collection[i]->getColor();
colorsCount[j]++;
}
}
return colorsCount[color];
}
int MTGAllCards::totalCards(){
return (total_cards);
}
int MTGAllCards::readConfLine(int set_id){
char buffer[BUFSIZE];
read_cursor = readline(conf_buffer, buffer, read_cursor);
if (read_cursor){
switch(conf_read_mode) {
case 0:
conf_read_mode = 1;
collection[total_cards] = NEW MTGCard(mCache,set_id);
break;
case 1:
if (buffer[0] == '[' && buffer[1] == '/'){
conf_read_mode = 0;
total_cards++;
}else{
processConfLine(buffer, collection[total_cards]);
}
break;
default:
break;
}
}else{
free (conf_buffer);
}
return read_cursor;
}
MTGCard * MTGAllCards::getCardById(int id){
int i;
for (i=0; i<total_cards; i++){
int cardId = collection[i]->getMTGId();
if (cardId == id){
return collection[i];
}
}
return 0;
}
MTGDeck::MTGDeck(const char * config_file, TexturesCache * cache, MTGAllCards * _allcards){
mCache = cache;
total_cards = 0;
allcards = _allcards;
filename = config_file;
std::ifstream file(config_file);
std::string s;
if(file){
while(std::getline(file,s)){
int cardnb = atoi(s.c_str());
if (cardnb) add(cardnb);
}
file.close();
}else{
//TODO Error management
}
}
int MTGDeck::addRandomCards(int howmany, int setId, int rarity, const char * _subtype){
int collectionTotal = allcards->totalCards();
if (!collectionTotal) return 0;
if (setId == -1 && rarity == -1 && !_subtype){
for (int i = 0; i < howmany; i++){
int id = (rand() % collectionTotal);
add(allcards->_(id));
}
return 1;
}
char subtype[4096];
if (_subtype)
sprintf(subtype, _subtype);
int subcollection[TOTAL_NUMBER_OF_CARDS];
int subtotal = 0;
for (int i = 0; i < collectionTotal; i++){
MTGCard * card = allcards->_(i);
if ((setId == -1 || card->setId == setId) &&
(rarity == -1 || card->getRarity()==rarity) &&
(!_subtype || card->hasSubtype(subtype))
){
subcollection[subtotal] = i;
subtotal++;
}
}
if (subtotal == 0) return 0;
for (int i = 0; i < howmany; i++){
int id = (rand() % subtotal);
add(allcards->_(subcollection[id]));
}
return 1;
}
int MTGDeck::add(int cardid){
MTGCard * card = allcards->getCardById(cardid);
add(card);
return total_cards;
}
int MTGDeck::add(MTGCard * card){
if (!card) return 0;
collection[total_cards] = card;
++total_cards;
initCounters();
return total_cards;
}
int MTGDeck::removeAll(){
total_cards = 0;
initCounters();
return 1;
}
int MTGDeck::remove(int cardid){
MTGCard * card = getCardById(cardid);
return remove(card);
}
int MTGDeck::remove(MTGCard * card){
for (int i = 0; i<total_cards; i++){
if (collection[i] == card){
collection[i] = collection[total_cards - 1];
total_cards--;
initCounters();
return 1;
}
}
return 0;
}
int MTGDeck::save(){
std::ofstream file(filename.c_str());
char writer[10];
if (file){
#if defined (WIN32) || defined (LINUX)
OutputDebugString("saving");
#endif
for (int i = 0; i<total_cards; i++){
sprintf(writer,"%i\n", collection[i]->getMTGId());
file<<writer;
}
file.close();
}
return 1;
}
#include "../include/debug.h"
#include "../include/MTGDeck.h"
#include "../include/utils.h"
#include <algorithm>
#include <string>
using std::string;
#include <JGE.h>
#if defined (WIN32) || defined (LINUX)
#include <time.h>
#endif
MtgSets * MtgSets::SetsList = NEW MtgSets();
MtgSets::MtgSets(){
nb_items = 0;
}
int MtgSets::Add(const char * name){
string value = name;
values[nb_items] = value;
nb_items++;
return nb_items - 1;
}
int MTGAllCards::processConfLine(char *buffer, MTGCard *card){
string s = buffer;
unsigned int i = s.find_first_of("=");
if (i == string::npos) return 0;
string key = s.substr(0,i);
string value = s.substr(i+1);
if(key.compare( "auto")==0){
card->addMagicText(value);
}
else if(key.compare( "alias")==0){
card->alias=atoi(value.c_str());
}
else if(key.compare( "target")==0){
std::transform( value.begin(), value.end(), value.begin(),::tolower );
card->spellTargetType=value;
}
else if(key.compare( "text")==0){
card->setText(value);
}else if (key.compare("abilities")==0){
//Specific Abilities
std::transform( value.begin(), value.end(), value.begin(),::tolower );
for (int j = 0; j < NB_BASIC_ABILITIES; j++){
unsigned int found = value.find(MTGBasicAbilities[j]);
if (found != string::npos){
card->basicAbilities[j] = 1;
}
}
}else if(key.compare("id")==0){
card->setMTGId(atoi(value.c_str()));
}else if(key.compare("name")==0){
card->setName(value);
}else if(key.compare("rarity")==0){
card->setRarity (value.c_str()[0]);
}else if(key.compare("mana")==0){
std::transform( value.begin(), value.end(), value.begin(),::tolower );
card->setManaCost(value);
}else if(key.compare("type")==0){
switch(value.c_str()[0]){
case 'C':
card->setType( "Creature");
break;
case 'A':
card->setType( "Artifact");
card->setColor(MTG_COLOR_ARTIFACT);
if (value.c_str()[8] == ' ' && value.c_str()[9] == 'C')
card->setSubtype("Creature");
break;
case 'E':
card->setType( "Enchantment");
break;
case 'S':
card->setType( "Sorcery");
break;
case 'B'://Basic Land
card->setColor(MTG_COLOR_LAND);
card->setType("Land");
break;
case 'L':
card->setColor(MTG_COLOR_LAND);
card->setType( "Land");
break;
case 'I':
card->setType( "Instant");
break;
default:
card->setType( "Error");
break;
}
}else if(key.compare("power")==0){
card->setPower (atoi(value.c_str()));
}else if(key.compare("subtype")==0){
card->setSubtype(value);
}else if(key.compare("toughness")==0){
card->setToughness(atoi(value.c_str()));
}else{
}
return i;
}
void MTGAllCards::initCounters(){
for (int i=0; i< MTG_NB_COLORS; i++){
colorsCount[i] = NULL;
}
}
void MTGAllCards::init(){
mCache = NULL;
total_cards = 0;
initCounters();
srand(time(0)); // initialize random
}
int MTGAllCards::load(const char * config_file, const char * set_name,int autoload){
conf_read_mode = 0;
int file_size = filesize(config_file);
conf_buffer = (char *) malloc(file_size);
read_cursor = 0;
// conf_fd = sceIoOpen(config_file, PSP_O_RDONLY, 0777);
read_file(config_file, conf_buffer, file_size );
int set_id = MtgSets::SetsList->Add(set_name);
if (autoload){
while(readConfLine(set_id)){};
}
return total_cards;
}
MTGAllCards::MTGAllCards(){
init();
}
MTGAllCards::~MTGAllCards(){
}
void MTGAllCards::destroyAllCards(){
for (int i= 0; i < total_cards; i++){
delete collection[i];
};
}
MTGAllCards::MTGAllCards(const char * config_file, const char * set_name){
MTGAllCards(config_file, set_name, NULL);
}
MTGAllCards::MTGAllCards(TexturesCache * cache){
init();
mCache = cache;
}
MTGAllCards::MTGAllCards(const char * config_file, const char * set_name, TexturesCache * cache){
init();
mCache = cache;
load(config_file,set_name, 0);
}
MTGCard * MTGAllCards::_(int i){
if (i < total_cards) return collection[i];
return NULL;
}
int MTGAllCards::randomCardId(){
int id = (rand() % total_cards);
return collection[id]->getMTGId();
}
int MTGAllCards::countBySet(int setId){
int result = 0;
for (int i=0; i< total_cards; i++){
if(collection[i]->setId == setId){
result++;
}
}
return result;
}
//TODO more efficient way ?
int MTGAllCards::countByType(const char * _type){
int result = 0;
for (int i=0; i< total_cards; i++){
if(collection[i]->hasType(_type)){
result++;
}
}
return result;
}
int MTGAllCards::countByColor(int color){
if (colorsCount[color] == 0){
for (int i=0; i< MTG_NB_COLORS; i++){
colorsCount[i] = 0;
}
for (int i=0; i< total_cards; i++){
int j = collection[i]->getColor();
colorsCount[j]++;
}
}
return colorsCount[color];
}
int MTGAllCards::totalCards(){
return (total_cards);
}
int MTGAllCards::readConfLine(int set_id){
char buffer[BUFSIZE];
read_cursor = readline(conf_buffer, buffer, read_cursor);
if (read_cursor){
switch(conf_read_mode) {
case 0:
conf_read_mode = 1;
collection[total_cards] = NEW MTGCard(mCache,set_id);
break;
case 1:
if (buffer[0] == '[' && buffer[1] == '/'){
conf_read_mode = 0;
total_cards++;
}else{
processConfLine(buffer, collection[total_cards]);
}
break;
default:
break;
}
}else{
free (conf_buffer);
}
return read_cursor;
}
MTGCard * MTGAllCards::getCardById(int id){
int i;
for (i=0; i<total_cards; i++){
int cardId = collection[i]->getMTGId();
if (cardId == id){
return collection[i];
}
}
return 0;
}
MTGDeck::MTGDeck(const char * config_file, TexturesCache * cache, MTGAllCards * _allcards){
mCache = cache;
total_cards = 0;
allcards = _allcards;
filename = config_file;
std::ifstream file(config_file);
std::string s;
if(file){
while(std::getline(file,s)){
int cardnb = atoi(s.c_str());
if (cardnb) add(cardnb);
}
file.close();
}else{
//TODO Error management
}
}
int MTGDeck::addRandomCards(int howmany, int setId, int rarity, const char * _subtype){
int collectionTotal = allcards->totalCards();
if (!collectionTotal) return 0;
if (setId == -1 && rarity == -1 && !_subtype){
for (int i = 0; i < howmany; i++){
int id = (rand() % collectionTotal);
add(allcards->_(id));
}
return 1;
}
char subtype[4096];
if (_subtype)
sprintf(subtype, _subtype);
int subcollection[TOTAL_NUMBER_OF_CARDS];
int subtotal = 0;
for (int i = 0; i < collectionTotal; i++){
MTGCard * card = allcards->_(i);
if ((setId == -1 || card->setId == setId) &&
(rarity == -1 || card->getRarity()==rarity) &&
(!_subtype || card->hasSubtype(subtype))
){
subcollection[subtotal] = i;
subtotal++;
}
}
if (subtotal == 0) return 0;
for (int i = 0; i < howmany; i++){
int id = (rand() % subtotal);
add(allcards->_(subcollection[id]));
}
return 1;
}
int MTGDeck::add(int cardid){
MTGCard * card = allcards->getCardById(cardid);
add(card);
return total_cards;
}
int MTGDeck::add(MTGCard * card){
if (!card) return 0;
collection[total_cards] = card;
++total_cards;
initCounters();
return total_cards;
}
int MTGDeck::removeAll(){
total_cards = 0;
initCounters();
return 1;
}
int MTGDeck::remove(int cardid){
MTGCard * card = getCardById(cardid);
return remove(card);
}
int MTGDeck::remove(MTGCard * card){
for (int i = 0; i<total_cards; i++){
if (collection[i] == card){
collection[i] = collection[total_cards - 1];
total_cards--;
initCounters();
return 1;
}
}
return 0;
}
int MTGDeck::save(){
std::ofstream file(filename.c_str());
char writer[10];
if (file){
#if defined (WIN32) || defined (LINUX)
OutputDebugString("saving");
#endif
for (int i = 0; i<total_cards; i++){
sprintf(writer,"%i\n", collection[i]->getMTGId());
file<<writer;
}
file.close();
}
return 1;
}

44
projects/mtg/src/MTGGamePhase.cpp
View File

@@ -5,7 +5,7 @@
MTGGamePhase::MTGGamePhase(int id):ActionElement(id){
animation = 0;
currentState = -1;
mFont= GameApp::CommonRes->GetJLBFont("graphics/f3");
mFont= GameApp::CommonRes->GetJLBFont("graphics/f3");
mFont->SetBase(0); // using 2nd font
}
@@ -17,39 +17,39 @@ void MTGGamePhase::Render(){
void MTGGamePhase::Update(float dt){
int newState = GameObserver::GetInstance()->getCurrentGamePhase();
if (newState != currentState){
activeState = ACTIVE;
animation = 1;
currentState = newState;
int newState = GameObserver::GetInstance()->getCurrentGamePhase();
if (newState != currentState){
activeState = ACTIVE;
animation = 1;
currentState = newState;
switch (currentState){
switch (currentState){
default: break;
}
default: break;
}
}
}
if (animation > 0){
if (animation > 0){
fprintf(stderr, "animation = %f", animation);
animation -= dt *5 ;
}else{
activeState = INACTIVE;
activeState = INACTIVE;
animation = 0;
}
}
}
void MTGGamePhase::CheckUserInput(float dt){
GameObserver * game = GameObserver::GetInstance();
if (activeState == INACTIVE){
if (mEngine->GetButtonClick(PSP_CTRL_RTRIGGER) && game->currentActionPlayer == game->currentlyActing())
{
activeState = ACTIVE;
game->userRequestNextGamePhase();
}
}
GameObserver * game = GameObserver::GetInstance();
if (activeState == INACTIVE){
if (mEngine->GetButtonClick(PSP_CTRL_RTRIGGER) && game->currentActionPlayer == game->currentlyActing())
{
activeState = ACTIVE;
game->userRequestNextGamePhase();
}
}
}

628
projects/mtg/src/MTGGameZones.cpp
View File

@@ -1,314 +1,314 @@
#include "../include/debug.h"
#include "../include/MTGGameZones.h"
#include "../include/Player.h"
#if defined (WIN32) || defined (LINUX)
#include <time.h>
#endif
//------------------------------
//Players Game
//------------------------------
MTGPlayerCards::MTGPlayerCards(MTGAllCards * _collection, int * idList, int idListSize){
init();
int i;
collection = _collection;
for (i=0;i<idListSize;i++){
MTGCard * card = collection->getCardById(idList[i]);
if (card){
MTGCardInstance * newCard = NEW MTGCardInstance(card, this);
library->addCard(newCard);
}
}
}
MTGPlayerCards::~MTGPlayerCards(){
if(library) delete library;
if(graveyard) delete graveyard;
if(hand) delete hand;
if(inPlay) delete inPlay;
if(stack) delete stack;
}
void MTGPlayerCards::setOwner(Player * player){
library->setOwner(player);
}
void MTGPlayerCards::initGame(int shuffle, int draw){
if (shuffle) library->shuffle();
if (draw){
for (int i=0;i<7;i++){
drawFromLibrary();
}
}
}
void MTGPlayerCards::drawFromLibrary(){
MTGCardInstance * drownCard = library->draw();
hand->addCard(drownCard);
}
void MTGPlayerCards::init(){
library = NEW MTGLibrary();
graveyard = NEW MTGGraveyard();
hand = NEW MTGHand();
inPlay = NEW MTGInPlay();
stack = NEW MTGStack();
}
void MTGPlayerCards::showHand(){
hand->debugPrint();
}
void MTGPlayerCards::putInPlay(MTGCardInstance * card){
hand->removeCard(card);
stack->removeCard(card); //Which one is it ???
inPlay->addCard(card);
card->summoningSickness = 1;
card->changedZoneRecently = 1.f;
}
void MTGPlayerCards::putInGraveyard(MTGCardInstance * card){
if (inPlay->hasCard(card)){
putInZone(card,inPlay, graveyard);
}else if (stack->hasCard(card)){
putInZone(card,stack, graveyard);
}else{
putInZone(card,hand, graveyard);
}
}
void MTGPlayerCards::putInZone(MTGCardInstance * card, MTGGameZone * from, MTGGameZone * to){
if (from->removeCard(card)){
to->addCard(card);
card->changedZoneRecently = 1.f;
//if (to == graveyard){
card->reset();
//}
}
}
void MTGPlayerCards::discardRandom(MTGGameZone * from){
if (!from->nb_cards)
return;
int r = rand() % (from->nb_cards);
putInZone(from->cards[r],from, graveyard);
}
int MTGPlayerCards::isInPlay(MTGCardInstance * card){
if (inPlay->hasCard(card)){
return 1;
}
return 0;
}
//--------------------------------------
// Zones specific code
//--------------------------------------
MTGGameZone::MTGGameZone(){
nb_cards= 0;
lastCardDrawn = NULL;
}
MTGGameZone::~MTGGameZone(){
for (int i=0; i<nb_cards; i++) {
delete cards[i];
}
}
void MTGGameZone::setOwner(Player * player){
for (int i=0; i<nb_cards; i++) {
cards[i]->owner = player;
}
owner = player;
}
MTGCardInstance * MTGGameZone::removeCard(MTGCardInstance * card){
int i;
cardsMap.erase(card);
for (i=0; i<(nb_cards); i++) {
if (cards[i] == card){
cards[i] = cards[nb_cards -1];
nb_cards--;
return card;
}
}
return NULL;
}
MTGCardInstance * MTGGameZone::hasCard(MTGCardInstance * card){
if (cardsMap.find(card) != cardsMap.end()) return card;
return NULL;
}
int MTGGameZone::countByType(const char * value){
int result = 0 ;
for (int i=0; i<(nb_cards); i++) {
if (cards[i]->hasType(value)){
result++;
}
}
return result;
}
int MTGGameZone::hasType(const char * value){
for (int i=0; i<(nb_cards); i++) {
if (cards[i]->hasType(value)){
return 1;
}
}
return 0;
}
void MTGGameZone::cleanupPhase(){
for (int i=0; i<(nb_cards); i++)
(cards[i])->cleanup();
}
void MTGGameZone::shuffle(){
int i;
for (i=0; i<(nb_cards); i++) {
int r = i + (rand() % (nb_cards-i)); // Random remaining position.
MTGCardInstance * temp = cards[i]; cards[i] = cards[r]; cards[r] = temp;
}
srand(time(0)); // initialize seed "randomly" TODO :improve
}
void MTGGameZone::addCard(MTGCardInstance * card){
if (!card) return;
cards[nb_cards] = card;
nb_cards++;
cardsMap[card] = 1;
}
MTGCardInstance * MTGGameZone::draw(){
if (!nb_cards) return NULL;
nb_cards--;
lastCardDrawn = cards[nb_cards];
cardsMap.erase(cards[nb_cards]);
return cards[nb_cards];
}
MTGCardInstance * MTGLibrary::draw(){
if (!nb_cards) {
GameObserver::GetInstance()->gameOver = this->owner;
}
return MTGGameZone::draw();
}
void MTGGameZone::debugPrint(){
int i;
for (i=0;i<nb_cards;i++){
MTGCard * card = cards[i]->model;
fprintf(stderr, "%s", card->getName());
}
}
//------------------------------
int MTGInPlay::nbDefensers( MTGCardInstance * attacker){
int result = 0;
MTGCardInstance * defenser = getNextDefenser(NULL, attacker);
while (defenser){
result++;
defenser = getNextDefenser(defenser, attacker);
}
return result;
}
//Return the number of creatures this card is banded with
//Number of creatures in the band is n+1 !!!
int MTGInPlay::nbPartners(MTGCardInstance * attacker){
int result = 0;
if (!attacker->banding) return 0;
for (int i = 0; i < nb_cards; i ++){
if (cards[i]->banding == attacker->banding) result++;
}
return result;
}
MTGCardInstance * MTGInPlay::getNextDefenser(MTGCardInstance * previous, MTGCardInstance * attacker){
int foundprevious = 0;
if (previous == NULL){
foundprevious = 1;
}
for (int i = 0; i < nb_cards; i ++){
MTGCardInstance * current = cards[i];
if (current == previous){
foundprevious = 1;
}else if (foundprevious && current->isDefenser() == attacker){
return current;
}
}
return NULL;
}
MTGCardInstance * MTGInPlay::getNextAttacker(MTGCardInstance * previous){
int foundprevious = 0;
if (previous == NULL){
foundprevious = 1;
}
for (int i = 0; i < nb_cards; i ++){
MTGCardInstance * current = cards[i];
if (current == previous){
foundprevious = 1;
}else if (foundprevious && current->isAttacker()){
return current;
}
}
return NULL;
}
void MTGInPlay::untapAll(){
int i;
for (i = 0; i < nb_cards; i ++){
cards[i]->setUntapping();
if (cards[i]->getBlockers()->isEmpty()){
#if defined (WIN32) || defined (LINUX)
char buf[4096];
sprintf(buf, "Can untap %s\n", cards[i]->getName());
OutputDebugString(buf);
#endif
cards[i]->untap();
}
}
}
//--------------------------
void MTGLibrary::shuffleTopToBottom(int nbcards){
if (nbcards>nb_cards) nbcards = nb_cards;
MTGCardInstance * _cards[MTG_MAX_PLAYER_CARDS];
for (int i= nb_cards-nbcards; i<(nb_cards); i++) {
int r = i + (rand() % (nbcards-i)); // Random remaining position.
MTGCardInstance * temp = cards[i]; cards[i] = cards[r]; cards[r] = temp;
}
for (int i= 0; i < nbcards; i++){
_cards[i] = cards[nb_cards - 1 - i];
}
for (int i = nbcards; i < nb_cards; i++){
_cards[i] = cards[i - nb_cards];
}
for (int i=0 ; i < nb_cards; i++){
cards[i] = _cards[i];
}
}
#include "../include/debug.h"
#include "../include/MTGGameZones.h"
#include "../include/Player.h"
#if defined (WIN32) || defined (LINUX)
#include <time.h>
#endif
//------------------------------
//Players Game
//------------------------------
MTGPlayerCards::MTGPlayerCards(MTGAllCards * _collection, int * idList, int idListSize){
init();
int i;
collection = _collection;
for (i=0;i<idListSize;i++){
MTGCard * card = collection->getCardById(idList[i]);
if (card){
MTGCardInstance * newCard = NEW MTGCardInstance(card, this);
library->addCard(newCard);
}
}
}
MTGPlayerCards::~MTGPlayerCards(){
if(library) delete library;
if(graveyard) delete graveyard;
if(hand) delete hand;
if(inPlay) delete inPlay;
if(stack) delete stack;
}
void MTGPlayerCards::setOwner(Player * player){
library->setOwner(player);
}
void MTGPlayerCards::initGame(int shuffle, int draw){
if (shuffle) library->shuffle();
if (draw){
for (int i=0;i<7;i++){
drawFromLibrary();
}
}
}
void MTGPlayerCards::drawFromLibrary(){
MTGCardInstance * drownCard = library->draw();
hand->addCard(drownCard);
}
void MTGPlayerCards::init(){
library = NEW MTGLibrary();
graveyard = NEW MTGGraveyard();
hand = NEW MTGHand();
inPlay = NEW MTGInPlay();
stack = NEW MTGStack();
}
void MTGPlayerCards::showHand(){
hand->debugPrint();
}
void MTGPlayerCards::putInPlay(MTGCardInstance * card){
hand->removeCard(card);
stack->removeCard(card); //Which one is it ???
inPlay->addCard(card);
card->summoningSickness = 1;
card->changedZoneRecently = 1.f;
}
void MTGPlayerCards::putInGraveyard(MTGCardInstance * card){
if (inPlay->hasCard(card)){
putInZone(card,inPlay, graveyard);
}else if (stack->hasCard(card)){
putInZone(card,stack, graveyard);
}else{
putInZone(card,hand, graveyard);
}
}
void MTGPlayerCards::putInZone(MTGCardInstance * card, MTGGameZone * from, MTGGameZone * to){
if (from->removeCard(card)){
to->addCard(card);
card->changedZoneRecently = 1.f;
//if (to == graveyard){
card->reset();
//}
}
}
void MTGPlayerCards::discardRandom(MTGGameZone * from){
if (!from->nb_cards)
return;
int r = rand() % (from->nb_cards);
putInZone(from->cards[r],from, graveyard);
}
int MTGPlayerCards::isInPlay(MTGCardInstance * card){
if (inPlay->hasCard(card)){
return 1;
}
return 0;
}
//--------------------------------------
// Zones specific code
//--------------------------------------
MTGGameZone::MTGGameZone(){
nb_cards= 0;
lastCardDrawn = NULL;
}
MTGGameZone::~MTGGameZone(){
for (int i=0; i<nb_cards; i++) {
delete cards[i];
}
}
void MTGGameZone::setOwner(Player * player){
for (int i=0; i<nb_cards; i++) {
cards[i]->owner = player;
}
owner = player;
}
MTGCardInstance * MTGGameZone::removeCard(MTGCardInstance * card){
int i;
cardsMap.erase(card);
for (i=0; i<(nb_cards); i++) {
if (cards[i] == card){
cards[i] = cards[nb_cards -1];
nb_cards--;
return card;
}
}
return NULL;
}
MTGCardInstance * MTGGameZone::hasCard(MTGCardInstance * card){
if (cardsMap.find(card) != cardsMap.end()) return card;
return NULL;
}
int MTGGameZone::countByType(const char * value){
int result = 0 ;
for (int i=0; i<(nb_cards); i++) {
if (cards[i]->hasType(value)){
result++;
}
}
return result;
}
int MTGGameZone::hasType(const char * value){
for (int i=0; i<(nb_cards); i++) {
if (cards[i]->hasType(value)){
return 1;
}
}
return 0;
}
void MTGGameZone::cleanupPhase(){
for (int i=0; i<(nb_cards); i++)
(cards[i])->cleanup();
}
void MTGGameZone::shuffle(){
int i;
for (i=0; i<(nb_cards); i++) {
int r = i + (rand() % (nb_cards-i)); // Random remaining position.
MTGCardInstance * temp = cards[i]; cards[i] = cards[r]; cards[r] = temp;
}
srand(time(0)); // initialize seed "randomly" TODO :improve
}
void MTGGameZone::addCard(MTGCardInstance * card){
if (!card) return;
cards[nb_cards] = card;
nb_cards++;
cardsMap[card] = 1;
}
MTGCardInstance * MTGGameZone::draw(){
if (!nb_cards) return NULL;
nb_cards--;
lastCardDrawn = cards[nb_cards];
cardsMap.erase(cards[nb_cards]);
return cards[nb_cards];
}
MTGCardInstance * MTGLibrary::draw(){
if (!nb_cards) {
GameObserver::GetInstance()->gameOver = this->owner;
}
return MTGGameZone::draw();
}
void MTGGameZone::debugPrint(){
int i;
for (i=0;i<nb_cards;i++){
MTGCard * card = cards[i]->model;
fprintf(stderr, "%s", card->getName());
}
}
//------------------------------
int MTGInPlay::nbDefensers( MTGCardInstance * attacker){
int result = 0;
MTGCardInstance * defenser = getNextDefenser(NULL, attacker);
while (defenser){
result++;
defenser = getNextDefenser(defenser, attacker);
}
return result;
}
//Return the number of creatures this card is banded with
//Number of creatures in the band is n+1 !!!
int MTGInPlay::nbPartners(MTGCardInstance * attacker){
int result = 0;
if (!attacker->banding) return 0;
for (int i = 0; i < nb_cards; i ++){
if (cards[i]->banding == attacker->banding) result++;
}
return result;
}
MTGCardInstance * MTGInPlay::getNextDefenser(MTGCardInstance * previous, MTGCardInstance * attacker){
int foundprevious = 0;
if (previous == NULL){
foundprevious = 1;
}
for (int i = 0; i < nb_cards; i ++){
MTGCardInstance * current = cards[i];
if (current == previous){
foundprevious = 1;
}else if (foundprevious && current->isDefenser() == attacker){
return current;
}
}
return NULL;
}
MTGCardInstance * MTGInPlay::getNextAttacker(MTGCardInstance * previous){
int foundprevious = 0;
if (previous == NULL){
foundprevious = 1;
}
for (int i = 0; i < nb_cards; i ++){
MTGCardInstance * current = cards[i];
if (current == previous){
foundprevious = 1;
}else if (foundprevious && current->isAttacker()){
return current;
}
}
return NULL;
}
void MTGInPlay::untapAll(){
int i;
for (i = 0; i < nb_cards; i ++){
cards[i]->setUntapping();
if (cards[i]->getBlockers()->isEmpty()){
#if defined (WIN32) || defined (LINUX)
char buf[4096];
sprintf(buf, "Can untap %s\n", cards[i]->getName());
OutputDebugString(buf);
#endif
cards[i]->untap();
}
}
}
//--------------------------
void MTGLibrary::shuffleTopToBottom(int nbcards){
if (nbcards>nb_cards) nbcards = nb_cards;
MTGCardInstance * _cards[MTG_MAX_PLAYER_CARDS];
for (int i= nb_cards-nbcards; i<(nb_cards); i++) {
int r = i + (rand() % (nbcards-i)); // Random remaining position.
MTGCardInstance * temp = cards[i]; cards[i] = cards[r]; cards[r] = temp;
}
for (int i= 0; i < nbcards; i++){
_cards[i] = cards[nb_cards - 1 - i];
}
for (int i = nbcards; i < nb_cards; i++){
_cards[i] = cards[i - nb_cards];
}
for (int i=0 ; i < nb_cards; i++){
cards[i] = _cards[i];
}
}

60
projects/mtg/src/MTGGuiHand.cpp
View File

@@ -7,26 +7,26 @@ MTGGuiHand::MTGGuiHand(int id, GameObserver * _game):GuiCardsController(id, _gam
mAnimState = 0;
currentPlayer = NULL;
mFont = GameApp::CommonRes->GetJLBFont("graphics/f3");
for (int i = 0; i < 2; i++){
currentId[i] = 0;
}
for (int i = 0; i < 2; i++){
currentId[i] = 0;
}
}
void MTGGuiHand::updateCards(){
Player * player = GameObserver::GetInstance()->currentlyActing();
if (player->isAI()) player = GameObserver::GetInstance()->players[0];
Player * player = GameObserver::GetInstance()->currentlyActing();
if (player->isAI()) player = GameObserver::GetInstance()->players[0];
int nb_cards = player->game->hand->nb_cards;
if (mCount != nb_cards || player != currentPlayer ){ //if the number of cards has changed, then an update occured (is this test engouh ?)
resetObjects();
if (currentId[player->getId()] >= nb_cards) currentId[player->getId()] = nb_cards - 1;
for (int i = 0;i<nb_cards; i++){
CardGui * object = NEW CardGui(i, player->game->hand->cards[i],(float)40, (float)450 - (nb_cards-i) *35, SCREEN_HEIGHT_F - mAnimState*60, i == currentId[player->getId()]);
Add(object);
if ( i == currentId[player->getId()]) mCurr = i;
}
currentPlayer = player;
resetObjects();
if (currentId[player->getId()] >= nb_cards) currentId[player->getId()] = nb_cards - 1;
for (int i = 0;i<nb_cards; i++){
CardGui * object = NEW CardGui(i, player->game->hand->cards[i],(float)40, (float)450 - (nb_cards-i) *35, SCREEN_HEIGHT_F - mAnimState*60, i == currentId[player->getId()]);
Add(object);
if ( i == currentId[player->getId()]) mCurr = i;
}
currentPlayer = player;
}
@@ -35,14 +35,14 @@ void MTGGuiHand::updateCards(){
void MTGGuiHand::Update(float dt){
updateCards();
for (int i=0;i<mCount;i++){
for (int i=0;i<mCount;i++){
if (mObjects[i]!=NULL){
((CardGui *)mObjects[i])->y= SCREEN_HEIGHT - mAnimState*60;
}
}
}
GuiCardsController::Update(dt);
currentId[game->currentlyActing()->getId()] = mCurr;
currentId[game->currentlyActing()->getId()] = mCurr;
}
@@ -72,7 +72,7 @@ void MTGGuiHand::CheckUserInput(float dt){
mShowHand = HAND_HIDE;
}
}
if (mShowHand == HAND_HIDE || currentPlayer->isAI()){
modal = 0;
}else{
@@ -85,17 +85,17 @@ void MTGGuiHand::CheckUserInput(float dt){
void MTGGuiHand::Render(){
if (mShowHand != HAND_HIDE){
// if (currentPlayer && !currentPlayer->isAI()){
RenderMessageBackground(440-mCount * 35 , SCREEN_HEIGHT - mAnimState*60 - 10, mCount * 35 + 20, 70);
for (int i=0;i<mCount;i++){
if (mObjects[i]!=NULL && i!=mCurr){
mObjects[i]->Render();
}
}
if (mCount && mObjects[mCurr] != NULL){
mObjects[mCurr]->Render();
if (showBigCards) ((CardGui *)mObjects[mCurr])->RenderBig(10);
}
}
if (mShowHand != HAND_HIDE){
// if (currentPlayer && !currentPlayer->isAI()){
RenderMessageBackground(440-mCount * 35 , SCREEN_HEIGHT - mAnimState*60 - 10, mCount * 35 + 20, 70);
for (int i=0;i<mCount;i++){
if (mObjects[i]!=NULL && i!=mCurr){
mObjects[i]->Render();
}
}
if (mCount && mObjects[mCurr] != NULL){
mObjects[mCurr]->Render();
if (showBigCards) ((CardGui *)mObjects[mCurr])->RenderBig(10);
}
}
}

810
projects/mtg/src/MTGGuiPlay.cpp
View File

@@ -1,405 +1,405 @@
/* This class handles the display on the main game screen :
cards in play, graveyard, library, games phases, Players avatars
*/
#include "../include/debug.h"
#include "../include/MTGGuiPlay.h"
#include "../include/MTGCardInstance.h"
#include "../include/CardGui.h"
#include "../include/CardDisplay.h"
#define ZX_MAIN 100
#define ZY_MAIN 22
#define ZH_CREATURES 50
#define Z_CARDWIDTH 30
#define Z_CARDHEIGHT 40
#define Z_MAIN_NBCARDS 7
#define Z_SPELLS_NBCARDS 3
#define ZX_SPELL 450
#define ZY_SPELL 22
MTGGuiPlay::MTGGuiPlay(int id, GameObserver * _game):PlayGuiObjectController(id, _game){
currentPlayer = NULL;
offset = 0;
mPhaseBarTexture = JRenderer::GetInstance()->LoadTexture("graphics/phasebar.png", TEX_TYPE_USE_VRAM);
for (int i=0; i < 12; i++){
phaseIcons[2*i] = NEW JQuad(mPhaseBarTexture, i*28, 0, 28, 28);
phaseIcons[2*i + 1] = NEW JQuad(mPhaseBarTexture, i*28, 28, 28, 28);
}
mGlitter = NEW JQuad(mPhaseBarTexture, 392, 0, 5, 5);
mGlitter->SetHotSpot(2.5,2.5);
mGlitterAlpha = -1;
mFont= GameApp::CommonRes->GetJLBFont("graphics/f3");
mFont->SetScale(0.75);
mIconsTexture = JRenderer::GetInstance()->LoadTexture("graphics/menuicons.png", TEX_TYPE_USE_VRAM);
//load all the icon images
mIcons[MTG_COLOR_ARTIFACT] = NEW JQuad(mIconsTexture, 10 + 6*32, 32, 32, 32);
mIcons[MTG_COLOR_LAND] = NEW JQuad(mIconsTexture, 10 + 5*32, 32, 32, 32);
mIcons[MTG_COLOR_WHITE] = NEW JQuad(mIconsTexture, 10 + 4*32, 32, 32, 32);
mIcons[MTG_COLOR_RED] = NEW JQuad(mIconsTexture, 10 + 3*32, 32, 32, 32);
mIcons[MTG_COLOR_BLACK] = NEW JQuad(mIconsTexture, 10 + 2*32, 32, 32, 32);
mIcons[MTG_COLOR_BLUE] = NEW JQuad(mIconsTexture, 10 + 1*32, 32, 32, 32);
mIcons[MTG_COLOR_GREEN] = NEW JQuad(mIconsTexture, 10 + 0*32, 32, 32, 32);
for (int i=0; i < 7; i++){
mIcons[i]->SetHotSpot(16,16);
}
mBgTex = JRenderer::GetInstance()->LoadTexture("graphics/background.png", TEX_TYPE_USE_VRAM);
mBg = NEW JQuad(mBgTex, 0, 0, 480, 272);
mBgTex2 = JRenderer::GetInstance()->LoadTexture("graphics/back.jpg", TEX_TYPE_USE_VRAM);
mBg2 = NEW JQuad(mBgTex2, 0, 0, 480, 255);
for (int i= 0; i < 4; i++){
alphaBg[i] = 255;
}
alphaBg[0] = 0;
AddPlayersGuiInfo();
}
CardGui * MTGGuiPlay::getByCard(MTGCardInstance * card){
for (int i = offset; i < mCount; i++){
CardGui * cardg = (CardGui *)mObjects[i];
if(cardg && cardg->card == card){
return cardg;
}
}
return NULL;
}
void MTGGuiPlay::initCardsDisplay(){
for (int i = 0; i < SCREEN_WIDTH/5; i++){
for(int j=0; j < SCREEN_HEIGHT/5; j++){
cardsGrid[i][j] = NULL;
}
}
cards_x_limit = 12;
nb_creatures = 0;
nb_lands = 0;
nb_spells = 0;
}
void MTGGuiPlay::adjustCardPosition(CardGui * cardg){
int x5 = cardg->x / 5;
int y5 = cardg->y / 5;
while (cardsGrid[x5][y5] && x5 <SCREEN_WIDTH/5 && y5 < SCREEN_HEIGHT/5 ){
x5++;
y5++;
}
cardg->x = x5 * 5;
cardg->y = y5 * 5;
cardsGrid[x5][y5] = cardg->card;
}
void MTGGuiPlay::setCardPosition(CardGui * cardg, int player, int playerTurn, int spellMode){
MTGCardInstance * card = cardg->card;
if (card->target)
return;
if (spellMode && (card->isACreature() || card->hasType("land"))) return;
if (!spellMode && !card->isACreature() && !card->hasType("land")) return;
if (card->isACreature()){
int x_offset = nb_creatures % cards_x_limit;
int y_offset = nb_creatures / cards_x_limit;
cardg->x= ZX_MAIN + (Z_CARDWIDTH * x_offset);
cardg->y=ZY_MAIN + ZH_CREATURES + (Z_CARDHEIGHT * y_offset) + 100 * (1-player);
nb_creatures++;
if (playerTurn){
if (card->isAttacker()){
cardg->y=122 + 30 * (1-player);
}
}else{
if (card->isDefenser()){
CardGui * targetg = getByCard(card->isDefenser());
if (targetg) cardg->x = targetg->x;
cardg->y=122 + 30 * (1-player);
}
}
}else if(card->hasType("land")){
int x_offset = nb_lands % cards_x_limit;
int y_offset = nb_lands/ cards_x_limit;
cardg->x=ZX_MAIN + (Z_CARDWIDTH * x_offset);
cardg->y=ZY_MAIN + (Z_CARDHEIGHT * y_offset) + 200 * (1-player);
nb_lands++;
}else{
int y_offset = nb_spells % Z_SPELLS_NBCARDS;
int x_offset = nb_spells/ Z_SPELLS_NBCARDS;
cardg->x=ZX_SPELL - (Z_CARDWIDTH * x_offset);
cardg->y=ZY_SPELL + (Z_CARDHEIGHT * y_offset) + 125 * (1-player);
nb_spells++;
cards_x_limit = 12 - (nb_spells + 2)/ Z_SPELLS_NBCARDS;
}
adjustCardPosition(cardg);
}
void MTGGuiPlay::setTargettingCardPosition(CardGui * cardg, int player, int playerTurn){
MTGCardInstance * card = cardg->card;
MTGCardInstance * target = card->target;
if (!target)
return;
CardGui * targetg = getByCard(target);
if (targetg){
cardg->y=targetg->y + 5;
cardg->x=targetg->x + 5;
}
adjustCardPosition(cardg);
return;
}
void MTGGuiPlay::updateCards(){
GameObserver * game = GameObserver::GetInstance();
Player * player = game->players[0];
int player0Mode =(game->currentPlayer == player);
int nb_cards = player->game->inPlay->nb_cards;
MTGCardInstance * attackers[MAX_ATTACKERS];
for (int i = 0; i <MAX_ATTACKERS; i++){
attackers[i] = NULL;
}
offset = 6;
Player * opponent = game->players[1];
int opponent_cards = opponent ->game->inPlay->nb_cards;
if (mCount - offset != (nb_cards+opponent_cards) || game->currentPlayer != currentPlayer ){ //if the number of cards has changed, then an update occured (is this test engouh ?)
resetObjects();
AddPlayersGuiInfo();
offset = mCount;
bool hasFocus = player0Mode;
for (int i = 0;i<nb_cards; i++){
if (hasFocus) mCurr = mCount ;
CardGui * object = NEW CardGui(mCount, player->game->inPlay->cards[i],40, i*35 + 10, 200, hasFocus);
Add(object);
hasFocus = false;
}
hasFocus = !player0Mode;
for (int i = 0;i<opponent_cards; i++){
if (hasFocus) mCurr = mCount ;
CardGui * object = NEW CardGui(mCount, opponent->game->inPlay->cards[i],40, i*35 + 10, 10, hasFocus);
Add(object);
hasFocus = false;
}
currentPlayer = game->currentPlayer;
}
//This is just so that we display the cards of the current player first, so that blockers are correctly positionned
for (int j= 0; j < 2; j++){
initCardsDisplay();
if (j != player0Mode){
for (int i =0; i<nb_cards; i++){
CardGui * cardGui = (CardGui *)mObjects[i + offset];
setCardPosition(cardGui, 0, player0Mode, 1);
}
for (int i =0; i<nb_cards; i++){
CardGui * cardGui = (CardGui *)mObjects[i + offset];
setCardPosition(cardGui, 0, player0Mode, 0);
}
}else{
for (int i =0; i<opponent_cards; i++){
CardGui * cardGui = (CardGui *)mObjects[nb_cards + i + offset];
setCardPosition(cardGui, 1, !player0Mode,1);
}
for (int i =0; i<opponent_cards; i++){
CardGui * cardGui = (CardGui *)mObjects[nb_cards + i + offset];
setCardPosition(cardGui, 1, !player0Mode,0);
}
}
}
for (int i =0; i<nb_cards; i++){
CardGui * cardGui = (CardGui *)mObjects[i + offset ];
setTargettingCardPosition(cardGui, 0, player0Mode);
}
for (int i =0; i<opponent_cards; i++){
CardGui * cardGui = (CardGui *)mObjects[nb_cards + i + offset];
setTargettingCardPosition(cardGui, 1, !player0Mode);
}
}
void MTGGuiPlay::AddPlayersGuiInfo(){
//init with the players objects
if (mCount == 0){
Add(NEW GuiAvatar(-1,50,2,155,false, GameObserver::GetInstance()->players[0]));
Add(NEW GuiAvatar(-2,50,2,30,false,GameObserver::GetInstance()->players[1]));
Add(NEW GuiGraveyard(-3,30,40,150,false, GameObserver::GetInstance()->players[0]));
Add(NEW GuiLibrary(-4,30,40,180,false, GameObserver::GetInstance()->players[0]));
Add(NEW GuiGraveyard(-5,30,40,30,false, GameObserver::GetInstance()->players[1]));
Add(NEW GuiLibrary(-6,30,40,60,false, GameObserver::GetInstance()->players[1]));
}
}
void MTGGuiPlay::Update(float dt){
updateCards();
PlayGuiObjectController::Update(dt);
GameObserver * game = GameObserver::GetInstance();
}
void MTGGuiPlay::CheckUserInput(float dt){
for (int i = 2; i<6;i++){
GuiGameZone * zone = (GuiGameZone *)mObjects[i];
if (zone->showCards){
zone->cd->CheckUserInput(dt);
return;
}
}
PlayGuiObjectController::CheckUserInput(dt);
}
void MTGGuiPlay::RenderPlayerInfo(int playerid){
GameObserver * game = GameObserver::GetInstance();
JRenderer * r = JRenderer::GetInstance();
Player * player = GameObserver::GetInstance()->players[playerid];
int life = player->life;
//Avatar
GuiAvatar * avatar = (GuiAvatar *)mObjects[3*playerid];
avatar->Render();
//Mana
ManaCost * cost = player->getManaPool();
int nbicons = 0;
for (int j=0; j<6;j++){
int value = cost->getCost(j);
for (int i=0; i<value; i++){
float x = 10 + (nbicons %4) * 15;
float y = 90 + 125 * (1-playerid) + (15 * (nbicons / 4));
r->RenderQuad(mIcons[j],x,y,0,0.5, 0.5);
nbicons++;
}
}
}
void MTGGuiPlay::RenderPhaseBar(){
GameObserver * game = GameObserver::GetInstance();
JRenderer * renderer = JRenderer::GetInstance();
int currentPhase = game->getCurrentGamePhase();
for (int i=0; i < 12; i++){
int index = 2*i + 1 ;
if (i==currentPhase-1){
index-=1;
}
renderer->RenderQuad(phaseIcons[index], 200 + 14*i,0,0,0.5,0.5);
}
mFont->SetScale(0.70);
if (game->currentlyActing()->isAI()){
mFont->SetColor(ARGB(255,128,128,128));
}else{
mFont->SetColor(ARGB(255,255,255,255));
}
mFont->DrawString(MTGPhaseNames[currentPhase], 375, 0);
}
void MTGGuiPlay::Render(){
JRenderer * renderer = JRenderer::GetInstance();
//alphaBg[1] = 255;
//alphaBg[2]= 255;
//alphaBg[3] = 255;
//mBg2->SetColor(ARGB(alphaBg[0], alphaBg[1],alphaBg[2],alphaBg[3]));
renderer->RenderQuad(mBg2,0,17);
if (game->currentGamePhase >=MTG_PHASE_COMBATBEGIN && game->currentGamePhase < MTG_PHASE_COMBATEND){
if (alphaBg[0] < 50){
alphaBg[3]-=12;
alphaBg[2]-=12;
alphaBg[0]+=3;
}
alphaBg[1] = 255;
}else{
if (alphaBg[0]){
alphaBg[0]-=3;
alphaBg[3]+=12;
alphaBg[2]+=12;
}
alphaBg[1] = 255;
}
renderer->FillRect(0,0,480,272,ARGB(alphaBg[0], alphaBg[1],alphaBg[2],alphaBg[3]));
renderer->RenderQuad(mBg,0,0);
for (int i=0;i<mCount;i++){
if (mObjects[i]!=NULL && i!=mCurr){
mObjects[i]->Render();
}
}
RenderPhaseBar();
RenderPlayerInfo(0);
RenderPlayerInfo(1);
if (mCount && mObjects[mCurr] != NULL){
mObjects[mCurr]->Render();
if (hasFocus && mCurr >= offset && showBigCards)
((CardGui *)mObjects[mCurr])->RenderBig();
}
if (mGlitterAlpha < 0){
mGlitterAlpha = 510;
int position = rand() % 2;
if (position){
mGlitterX = 65 + rand() % (420);
mGlitterY = 17 + rand() % (5);
}else{
mGlitterX = 65 + rand() % (5);
mGlitterY = 15 + rand() % (250);
}
}
mGlitter->SetColor(ARGB((255-abs(255-mGlitterAlpha)),240,240,255));
renderer->RenderQuad(mGlitter,mGlitterX,mGlitterY, (float)(mGlitterAlpha)/(float)255, 1.2*float(mGlitterAlpha)/float(255),1.2*float(mGlitterAlpha)/float(255));
mGlitterAlpha-=10;
}
MTGGuiPlay::~MTGGuiPlay(){
LOG("==Destroying MTGGuiPlay==");
delete mBg;
delete mBgTex;
for (int i=0; i < 7; i++){
delete mIcons[i];
}
delete mIconsTexture;
delete mGlitter;
for (int i=0; i < 12; i++){
delete phaseIcons[2*i] ;
delete phaseIcons[2*i + 1];
}
delete mPhaseBarTexture;
SAFE_DELETE(mBg2);
SAFE_DELETE(mBgTex2);
LOG("==Destroying MTGGuiPlay Successful==");
}
/* This class handles the display on the main game screen :
cards in play, graveyard, library, games phases, Players avatars
*/
#include "../include/debug.h"
#include "../include/MTGGuiPlay.h"
#include "../include/MTGCardInstance.h"
#include "../include/CardGui.h"
#include "../include/CardDisplay.h"
#define ZX_MAIN 100
#define ZY_MAIN 22
#define ZH_CREATURES 50
#define Z_CARDWIDTH 30
#define Z_CARDHEIGHT 40
#define Z_MAIN_NBCARDS 7
#define Z_SPELLS_NBCARDS 3
#define ZX_SPELL 450
#define ZY_SPELL 22
MTGGuiPlay::MTGGuiPlay(int id, GameObserver * _game):PlayGuiObjectController(id, _game){
currentPlayer = NULL;
offset = 0;
mPhaseBarTexture = JRenderer::GetInstance()->LoadTexture("graphics/phasebar.png", TEX_TYPE_USE_VRAM);
for (int i=0; i < 12; i++){
phaseIcons[2*i] = NEW JQuad(mPhaseBarTexture, i*28, 0, 28, 28);
phaseIcons[2*i + 1] = NEW JQuad(mPhaseBarTexture, i*28, 28, 28, 28);
}
mGlitter = NEW JQuad(mPhaseBarTexture, 392, 0, 5, 5);
mGlitter->SetHotSpot(2.5,2.5);
mGlitterAlpha = -1;
mFont= GameApp::CommonRes->GetJLBFont("graphics/f3");
mFont->SetScale(0.75);
mIconsTexture = JRenderer::GetInstance()->LoadTexture("graphics/menuicons.png", TEX_TYPE_USE_VRAM);
//load all the icon images
mIcons[MTG_COLOR_ARTIFACT] = NEW JQuad(mIconsTexture, 10 + 6*32, 32, 32, 32);
mIcons[MTG_COLOR_LAND] = NEW JQuad(mIconsTexture, 10 + 5*32, 32, 32, 32);
mIcons[MTG_COLOR_WHITE] = NEW JQuad(mIconsTexture, 10 + 4*32, 32, 32, 32);
mIcons[MTG_COLOR_RED] = NEW JQuad(mIconsTexture, 10 + 3*32, 32, 32, 32);
mIcons[MTG_COLOR_BLACK] = NEW JQuad(mIconsTexture, 10 + 2*32, 32, 32, 32);
mIcons[MTG_COLOR_BLUE] = NEW JQuad(mIconsTexture, 10 + 1*32, 32, 32, 32);
mIcons[MTG_COLOR_GREEN] = NEW JQuad(mIconsTexture, 10 + 0*32, 32, 32, 32);
for (int i=0; i < 7; i++){
mIcons[i]->SetHotSpot(16,16);
}
mBgTex = JRenderer::GetInstance()->LoadTexture("graphics/background.png", TEX_TYPE_USE_VRAM);
mBg = NEW JQuad(mBgTex, 0, 0, 480, 272);
mBgTex2 = JRenderer::GetInstance()->LoadTexture("graphics/back.jpg", TEX_TYPE_USE_VRAM);
mBg2 = NEW JQuad(mBgTex2, 0, 0, 480, 255);
for (int i= 0; i < 4; i++){
alphaBg[i] = 255;
}
alphaBg[0] = 0;
AddPlayersGuiInfo();
}
CardGui * MTGGuiPlay::getByCard(MTGCardInstance * card){
for (int i = offset; i < mCount; i++){
CardGui * cardg = (CardGui *)mObjects[i];
if(cardg && cardg->card == card){
return cardg;
}
}
return NULL;
}
void MTGGuiPlay::initCardsDisplay(){
for (int i = 0; i < SCREEN_WIDTH/5; i++){
for(int j=0; j < SCREEN_HEIGHT/5; j++){
cardsGrid[i][j] = NULL;
}
}
cards_x_limit = 12;
nb_creatures = 0;
nb_lands = 0;
nb_spells = 0;
}
void MTGGuiPlay::adjustCardPosition(CardGui * cardg){
int x5 = cardg->x / 5;
int y5 = cardg->y / 5;
while (cardsGrid[x5][y5] && x5 <SCREEN_WIDTH/5 && y5 < SCREEN_HEIGHT/5 ){
x5++;
y5++;
}
cardg->x = x5 * 5;
cardg->y = y5 * 5;
cardsGrid[x5][y5] = cardg->card;
}
void MTGGuiPlay::setCardPosition(CardGui * cardg, int player, int playerTurn, int spellMode){
MTGCardInstance * card = cardg->card;
if (card->target)
return;
if (spellMode && (card->isACreature() || card->hasType("land"))) return;
if (!spellMode && !card->isACreature() && !card->hasType("land")) return;
if (card->isACreature()){
int x_offset = nb_creatures % cards_x_limit;
int y_offset = nb_creatures / cards_x_limit;
cardg->x= ZX_MAIN + (Z_CARDWIDTH * x_offset);
cardg->y=ZY_MAIN + ZH_CREATURES + (Z_CARDHEIGHT * y_offset) + 100 * (1-player);
nb_creatures++;
if (playerTurn){
if (card->isAttacker()){
cardg->y=122 + 30 * (1-player);
}
}else{
if (card->isDefenser()){
CardGui * targetg = getByCard(card->isDefenser());
if (targetg) cardg->x = targetg->x;
cardg->y=122 + 30 * (1-player);
}
}
}else if(card->hasType("land")){
int x_offset = nb_lands % cards_x_limit;
int y_offset = nb_lands/ cards_x_limit;
cardg->x=ZX_MAIN + (Z_CARDWIDTH * x_offset);
cardg->y=ZY_MAIN + (Z_CARDHEIGHT * y_offset) + 200 * (1-player);
nb_lands++;
}else{
int y_offset = nb_spells % Z_SPELLS_NBCARDS;
int x_offset = nb_spells/ Z_SPELLS_NBCARDS;
cardg->x=ZX_SPELL - (Z_CARDWIDTH * x_offset);
cardg->y=ZY_SPELL + (Z_CARDHEIGHT * y_offset) + 125 * (1-player);
nb_spells++;
cards_x_limit = 12 - (nb_spells + 2)/ Z_SPELLS_NBCARDS;
}
adjustCardPosition(cardg);
}
void MTGGuiPlay::setTargettingCardPosition(CardGui * cardg, int player, int playerTurn){
MTGCardInstance * card = cardg->card;
MTGCardInstance * target = card->target;
if (!target)
return;
CardGui * targetg = getByCard(target);
if (targetg){
cardg->y=targetg->y + 5;
cardg->x=targetg->x + 5;
}
adjustCardPosition(cardg);
return;
}
void MTGGuiPlay::updateCards(){
GameObserver * game = GameObserver::GetInstance();
Player * player = game->players[0];
int player0Mode =(game->currentPlayer == player);
int nb_cards = player->game->inPlay->nb_cards;
MTGCardInstance * attackers[MAX_ATTACKERS];
for (int i = 0; i <MAX_ATTACKERS; i++){
attackers[i] = NULL;
}
offset = 6;
Player * opponent = game->players[1];
int opponent_cards = opponent ->game->inPlay->nb_cards;
if (mCount - offset != (nb_cards+opponent_cards) || game->currentPlayer != currentPlayer ){ //if the number of cards has changed, then an update occured (is this test engouh ?)
resetObjects();
AddPlayersGuiInfo();
offset = mCount;
bool hasFocus = player0Mode;
for (int i = 0;i<nb_cards; i++){
if (hasFocus) mCurr = mCount ;
CardGui * object = NEW CardGui(mCount, player->game->inPlay->cards[i],40, i*35 + 10, 200, hasFocus);
Add(object);
hasFocus = false;
}
hasFocus = !player0Mode;
for (int i = 0;i<opponent_cards; i++){
if (hasFocus) mCurr = mCount ;
CardGui * object = NEW CardGui(mCount, opponent->game->inPlay->cards[i],40, i*35 + 10, 10, hasFocus);
Add(object);
hasFocus = false;
}
currentPlayer = game->currentPlayer;
}
//This is just so that we display the cards of the current player first, so that blockers are correctly positionned
for (int j= 0; j < 2; j++){
initCardsDisplay();
if (j != player0Mode){
for (int i =0; i<nb_cards; i++){
CardGui * cardGui = (CardGui *)mObjects[i + offset];
setCardPosition(cardGui, 0, player0Mode, 1);
}
for (int i =0; i<nb_cards; i++){
CardGui * cardGui = (CardGui *)mObjects[i + offset];
setCardPosition(cardGui, 0, player0Mode, 0);
}
}else{
for (int i =0; i<opponent_cards; i++){
CardGui * cardGui = (CardGui *)mObjects[nb_cards + i + offset];
setCardPosition(cardGui, 1, !player0Mode,1);
}
for (int i =0; i<opponent_cards; i++){
CardGui * cardGui = (CardGui *)mObjects[nb_cards + i + offset];
setCardPosition(cardGui, 1, !player0Mode,0);
}
}
}
for (int i =0; i<nb_cards; i++){
CardGui * cardGui = (CardGui *)mObjects[i + offset ];
setTargettingCardPosition(cardGui, 0, player0Mode);
}
for (int i =0; i<opponent_cards; i++){
CardGui * cardGui = (CardGui *)mObjects[nb_cards + i + offset];
setTargettingCardPosition(cardGui, 1, !player0Mode);
}
}
void MTGGuiPlay::AddPlayersGuiInfo(){
//init with the players objects
if (mCount == 0){
Add(NEW GuiAvatar(-1,50,2,155,false, GameObserver::GetInstance()->players[0]));
Add(NEW GuiAvatar(-2,50,2,30,false,GameObserver::GetInstance()->players[1]));
Add(NEW GuiGraveyard(-3,30,40,150,false, GameObserver::GetInstance()->players[0]));
Add(NEW GuiLibrary(-4,30,40,180,false, GameObserver::GetInstance()->players[0]));
Add(NEW GuiGraveyard(-5,30,40,30,false, GameObserver::GetInstance()->players[1]));
Add(NEW GuiLibrary(-6,30,40,60,false, GameObserver::GetInstance()->players[1]));
}
}
void MTGGuiPlay::Update(float dt){
updateCards();
PlayGuiObjectController::Update(dt);
GameObserver * game = GameObserver::GetInstance();
}
void MTGGuiPlay::CheckUserInput(float dt){
for (int i = 2; i<6;i++){
GuiGameZone * zone = (GuiGameZone *)mObjects[i];
if (zone->showCards){
zone->cd->CheckUserInput(dt);
return;
}
}
PlayGuiObjectController::CheckUserInput(dt);
}
void MTGGuiPlay::RenderPlayerInfo(int playerid){
GameObserver * game = GameObserver::GetInstance();
JRenderer * r = JRenderer::GetInstance();
Player * player = GameObserver::GetInstance()->players[playerid];
int life = player->life;
//Avatar
GuiAvatar * avatar = (GuiAvatar *)mObjects[3*playerid];
avatar->Render();
//Mana
ManaCost * cost = player->getManaPool();
int nbicons = 0;
for (int j=0; j<6;j++){
int value = cost->getCost(j);
for (int i=0; i<value; i++){
float x = 10 + (nbicons %4) * 15;
float y = 90 + 125 * (1-playerid) + (15 * (nbicons / 4));
r->RenderQuad(mIcons[j],x,y,0,0.5, 0.5);
nbicons++;
}
}
}
void MTGGuiPlay::RenderPhaseBar(){
GameObserver * game = GameObserver::GetInstance();
JRenderer * renderer = JRenderer::GetInstance();
int currentPhase = game->getCurrentGamePhase();
for (int i=0; i < 12; i++){
int index = 2*i + 1 ;
if (i==currentPhase-1){
index-=1;
}
renderer->RenderQuad(phaseIcons[index], 200 + 14*i,0,0,0.5,0.5);
}
mFont->SetScale(0.70);
if (game->currentlyActing()->isAI()){
mFont->SetColor(ARGB(255,128,128,128));
}else{
mFont->SetColor(ARGB(255,255,255,255));
}
mFont->DrawString(MTGPhaseNames[currentPhase], 375, 0);
}
void MTGGuiPlay::Render(){
JRenderer * renderer = JRenderer::GetInstance();
//alphaBg[1] = 255;
//alphaBg[2]= 255;
//alphaBg[3] = 255;
//mBg2->SetColor(ARGB(alphaBg[0], alphaBg[1],alphaBg[2],alphaBg[3]));
renderer->RenderQuad(mBg2,0,17);
if (game->currentGamePhase >=MTG_PHASE_COMBATBEGIN && game->currentGamePhase < MTG_PHASE_COMBATEND){
if (alphaBg[0] < 50){
alphaBg[3]-=12;
alphaBg[2]-=12;
alphaBg[0]+=3;
}
alphaBg[1] = 255;
}else{
if (alphaBg[0]){
alphaBg[0]-=3;
alphaBg[3]+=12;
alphaBg[2]+=12;
}
alphaBg[1] = 255;
}
renderer->FillRect(0,0,480,272,ARGB(alphaBg[0], alphaBg[1],alphaBg[2],alphaBg[3]));
renderer->RenderQuad(mBg,0,0);
for (int i=0;i<mCount;i++){
if (mObjects[i]!=NULL && i!=mCurr){
mObjects[i]->Render();
}
}
RenderPhaseBar();
RenderPlayerInfo(0);
RenderPlayerInfo(1);
if (mCount && mObjects[mCurr] != NULL){
mObjects[mCurr]->Render();
if (hasFocus && mCurr >= offset && showBigCards)
((CardGui *)mObjects[mCurr])->RenderBig();
}
if (mGlitterAlpha < 0){
mGlitterAlpha = 510;
int position = rand() % 2;
if (position){
mGlitterX = 65 + rand() % (420);
mGlitterY = 17 + rand() % (5);
}else{
mGlitterX = 65 + rand() % (5);
mGlitterY = 15 + rand() % (250);
}
}
mGlitter->SetColor(ARGB((255-abs(255-mGlitterAlpha)),240,240,255));
renderer->RenderQuad(mGlitter,mGlitterX,mGlitterY, (float)(mGlitterAlpha)/(float)255, 1.2*float(mGlitterAlpha)/float(255),1.2*float(mGlitterAlpha)/float(255));
mGlitterAlpha-=10;
}
MTGGuiPlay::~MTGGuiPlay(){
LOG("==Destroying MTGGuiPlay==");
delete mBg;
delete mBgTex;
for (int i=0; i < 7; i++){
delete mIcons[i];
}
delete mIconsTexture;
delete mGlitter;
for (int i=0; i < 12; i++){
delete phaseIcons[2*i] ;
delete phaseIcons[2*i + 1];
}
delete mPhaseBarTexture;
SAFE_DELETE(mBg2);
SAFE_DELETE(mBgTex2);
LOG("==Destroying MTGGuiPlay Successful==");
}

120
projects/mtg/src/MTGRules.cpp
View File

@@ -1,60 +1,60 @@
#include "../include/debug.h"
#include "../include/MTGRules.h"
MTGAttackRule::MTGAttackRule(int _id):MTGAbility(_id,NULL){
}
int MTGAttackRule::isReactingToClick(MTGCardInstance * card){
if (currentPhase == MTG_PHASE_COMBATATTACKERS && card->controller() == game->currentPlayer && !card->isAttacker()){
if (card->canAttack()) return 1;
}
return 0;
}
int MTGAttackRule::reactToClick(MTGCardInstance * card){
if (!isReactingToClick(card)) return 0;
card->attacker = 1;
if (!card->basicAbilities[VIGILANCE]) card->tapped = 1;
return 1;
}
//The Attack rule is never destroyed
int MTGAttackRule::testDestroy(){
return 0;
}
MTGBlockRule::MTGBlockRule(int _id):MTGAbility(_id,NULL){
}
int MTGBlockRule::isReactingToClick(MTGCardInstance * card){
if (currentPhase == MTG_PHASE_COMBATBLOCKERS && !game->isInterrupting && card->controller() == game->opponent()){
if (card->canBlock()) return 1;
}
return 0;
}
int MTGBlockRule::reactToClick(MTGCardInstance * card){
if (!isReactingToClick(card)) return 0;
MTGCardInstance * currentOpponent = card->isDefenser();
bool result = false;
int candefend = 0;
while (!result){
currentOpponent = game->currentPlayer->game->inPlay->getNextAttacker(currentOpponent);
#if defined (WIN32) || defined (LINUX)
char buf[4096];
sprintf(buf,"Defenser Toggle %s \n" ,card->model->getName());
OutputDebugString(buf);
#endif
candefend = card->toggleDefenser(currentOpponent);
result = (candefend || currentOpponent == NULL);
}
return 1;
}
//The Block rule is never destroyed
int MTGBlockRule::testDestroy(){
return 0;
}
#include "../include/debug.h"
#include "../include/MTGRules.h"
MTGAttackRule::MTGAttackRule(int _id):MTGAbility(_id,NULL){
}
int MTGAttackRule::isReactingToClick(MTGCardInstance * card){
if (currentPhase == MTG_PHASE_COMBATATTACKERS && card->controller() == game->currentPlayer && !card->isAttacker()){
if (card->canAttack()) return 1;
}
return 0;
}
int MTGAttackRule::reactToClick(MTGCardInstance * card){
if (!isReactingToClick(card)) return 0;
card->attacker = 1;
if (!card->basicAbilities[VIGILANCE]) card->tapped = 1;
return 1;
}
//The Attack rule is never destroyed
int MTGAttackRule::testDestroy(){
return 0;
}
MTGBlockRule::MTGBlockRule(int _id):MTGAbility(_id,NULL){
}
int MTGBlockRule::isReactingToClick(MTGCardInstance * card){
if (currentPhase == MTG_PHASE_COMBATBLOCKERS && !game->isInterrupting && card->controller() == game->opponent()){
if (card->canBlock()) return 1;
}
return 0;
}
int MTGBlockRule::reactToClick(MTGCardInstance * card){
if (!isReactingToClick(card)) return 0;
MTGCardInstance * currentOpponent = card->isDefenser();
bool result = false;
int candefend = 0;
while (!result){
currentOpponent = game->currentPlayer->game->inPlay->getNextAttacker(currentOpponent);
#if defined (WIN32) || defined (LINUX)
char buf[4096];
sprintf(buf,"Defenser Toggle %s \n" ,card->model->getName());
OutputDebugString(buf);
#endif
candefend = card->toggleDefenser(currentOpponent);
result = (candefend || currentOpponent == NULL);
}
return 1;
}
//The Block rule is never destroyed
int MTGBlockRule::testDestroy(){
return 0;
}

2
projects/mtg/src/MTGSpellStack.cpp
View File

@@ -10,7 +10,7 @@ void MTGSpellStack::addSpell(Ability * ability){
}
int MTGSpellStack::resolve(){
if (cursor < 0)
if (cursor < 0)
return 0;
int result = cursor;
cursor--;

640
projects/mtg/src/ManaCost.cpp
View File

@@ -1,320 +1,320 @@
#include "../include/debug.h"
#include "../include/Logger.h"
#include "../include/ManaCost.h"
#include "../include/ManaCostHybrid.h"
#if defined (WIN32)
#include <windows.h>
#endif
ManaCost * ManaCost::parseManaCost(string s, ManaCost * _manaCost){
#if defined (WIN32) || defined (LINUX)
char buf[4096];
#endif
ManaCost * manaCost;
if (_manaCost){
manaCost = _manaCost;
}else{
manaCost = NEW ManaCost();
}
int state = 0;
unsigned int start = 0;
unsigned int end = 0;
while (!s.empty() && state != -1){
switch(state){
case 0:
start = s.find_first_of("{");
if (start == string::npos){
return manaCost;
}else{
state = 1;
}
break;
case 1:
end = s.find_first_of("}");
if (end == string::npos){
state = -1;
}else{
string value = s.substr(start+1, end - 1 - start);
if (value == "u"){
manaCost->add(MTG_COLOR_BLUE, 1);
}else if (value == "b"){
manaCost->add(MTG_COLOR_BLACK, 1);
}else if (value == "w"){
manaCost->add(MTG_COLOR_WHITE, 1);
}else if (value == "g"){
manaCost->add(MTG_COLOR_GREEN, 1);
}else if (value == "r"){
manaCost->add(MTG_COLOR_RED, 1);
}else if (value == "x"){
manaCost->x();
}else if (value == "t"){
}else{
int intvalue = atoi(value.c_str());
int colors[2];
int values[2];
if (!intvalue && value.size() > 1){
#if defined (WIN32) || defined (LINUX)
OutputDebugString("Hybrid Mana ???\n");
#endif
for (int i = 0; i < 2; i++){
char c = value[i];
if (c >='0' && c <='9'){
colors[i] = MTG_COLOR_ARTIFACT;
values[i] = c - '0';
}else{
for (int j = 0; j < MTG_NB_COLORS; j++){
if (c == MTGColorChars[j]){
colors[i] = j;
values[i] = 1;
}
}
}
}
manaCost->addHybrid(colors[0], values[0], colors[1], values[1]);
}else{
manaCost->add(MTG_COLOR_ARTIFACT, intvalue);
}
}
s = s.substr(end + 1);
state = 0;
}
break;
default:
break;
}
}
return manaCost;
}
ManaCost::ManaCost(){
init();
}
ManaCost::ManaCost(int _cost[], int nb_elems){
init();
int i;
int total = nb_elems;
#if defined (WIN32) || defined (LINUX)
char buf[4096];
sprintf(buf, "Create New MAnaCost, total Colors : %i\n", total);
OutputDebugString(buf);
#endif
for (i = 0; i < total; i++){
cost[_cost[i*2]] = _cost[i*2 + 1];
}
}
ManaCost::ManaCost(ManaCost * _manaCost){
init();
int i;
for (i=0; i<= MTG_NB_COLORS; i++){
cost[i] = _manaCost->getCost(i);
}
}
ManaCost::~ManaCost(){
LOG("==Deleting ManaCost==");
for (int i = 0; i < nbhybrids ; i++){
SAFE_DELETE(hybrids[i]);
}
}
void ManaCost::x(){
cost[MTG_NB_COLORS] = 1;
}
void ManaCost::init(){
int i;
for (i=0; i<= MTG_NB_COLORS; i++){
cost[i] = 0;
}
nbhybrids = 0;
}
void ManaCost::copy(ManaCost * _manaCost){
for (int i=0; i<= MTG_NB_COLORS; i++){
cost[i] = _manaCost->getCost(i);
}
for (int i=0; i< _manaCost->nbhybrids; i++){
hybrids[i] = NEW ManaCostHybrid((*_manaCost->hybrids[i]));
}
nbhybrids = _manaCost->nbhybrids;
}
int ManaCost::getCost(int color){
return cost[color];
}
int ManaCost::getMainColor(){
for (int i=0; i< MTG_NB_COLORS; i++){
if (cost[i]) return i;
}
return 0;
}
int ManaCost::hasColor(int color){
if (cost[color]) return 1;
for (int i = 0; i < nbhybrids; i++){
if (hybrids[i]->hasColor(color)) return 1;
}
return 0;
}
int ManaCost::getConvertedCost(){
int result = 0;
for (int i=0; i< MTG_NB_COLORS; i++){
result += cost[i];
}
for (int i = 0; i < nbhybrids; i++){
result+= hybrids[i]->getConvertedCost();
}
return result;
}
int ManaCost::remove(int color, int value){
cost[color] -= value;
return 1;
}
int ManaCost::add(int color, int value){
cost[color] += value;
return 1;
}
int ManaCost::add(ManaCost * _cost){
for (int i=0; i< MTG_NB_COLORS; i++){
cost[i]+= _cost->getCost(i);
}
for (int i=0; i< _cost->nbhybrids; i++){
hybrids[nbhybrids] = NEW ManaCostHybrid((*_cost->hybrids[i]));
nbhybrids++;
}
return 1;
}
string ManaCost::toString(){
return "ManaCost - Todo";
}
int ManaCost::addHybrid(int c1, int v1, int c2, int v2){
ManaCostHybrid * h = NEW ManaCostHybrid(c1,v1,c2,v2);
hybrids[nbhybrids] = h;
nbhybrids++;
return nbhybrids;
}
int ManaCost::pay(ManaCost * _cost){
ManaCost * diff = Diff(_cost);
for (int i=0; i < MTG_NB_COLORS; i++){
cost[i] = diff->getCost(i);
}
delete diff;
return 1;
//TODO return 0 if can't afford the cost!
}
//return 1 if _cost can be paid with current data
int ManaCost::canAfford(ManaCost * _cost){
ManaCost * diff = Diff(_cost);
int positive = diff->isPositive();
delete diff;
if (positive){
#if defined (WIN32) || defined (LINUX)
OutputDebugString("can afford\n");
#endif
return 1;
}
return 0;
}
int ManaCost::isPositive(){
for (int i=0; i < MTG_NB_COLORS; i++){
if (cost[i] < 0){
return 0;
}
}
return 1;
}
void ManaCost::randomDiffHybrids(ManaCost * _cost, int diff[]){
int _nbhybrids = _cost->nbhybrids;
for (int i = 0; i < _nbhybrids; i++){
ManaCostHybrid * h = _cost->hybrids[i];
diff[h->color1 * 2 +1]-= h->value1;
}
}
int ManaCost::tryToPayHybrids(ManaCostHybrid * _hybrids[], int _nbhybrids, int diff[]){
if (!_nbhybrids) return 1;
int result = 0;
ManaCostHybrid * h = _hybrids[_nbhybrids -1];
if (diff[h->color1 * 2 +1] >= h->value1){
diff[h->color1 * 2 +1]-= h->value1;
result = tryToPayHybrids(_hybrids,_nbhybrids -1, diff);
if (result) return 1;
diff[h->color1 * 2 +1]+= h->value1;
}
if (diff[h->color2 * 2 +1] >= h->value2){
diff[h->color2 * 2 +1]-= h->value2;
result = tryToPayHybrids(_hybrids,_nbhybrids -1, diff);
if (result) return 1;
diff[h->color2 * 2 +1]+= h->value2;
}
return 0;
}
//compute the difference between two mana costs
ManaCost * ManaCost::Diff(ManaCost * _cost){
int diff[(MTG_NB_COLORS + 1 )* 2];
diff[MTG_NB_COLORS * 2] = MTG_NB_COLORS;
for (int i=0; i < MTG_NB_COLORS; i++){
diff[i*2] = i;
diff[i*2 +1] = cost[i] - _cost->getCost(i);
}
int hybridResult = tryToPayHybrids(_cost->hybrids, _cost->nbhybrids, diff);
if (!hybridResult) randomDiffHybrids(_cost,diff);
//Colorless mana, special case
int colorless_idx = MTG_COLOR_ARTIFACT * 2 + 1;
if (diff[colorless_idx] < 0){
#if defined (WIN32) || defined (LINUX)
//char buf[4096], *p = buf;
//sprintf(buf, "--Diff color TEST %i : %i\n", i, cost[i]);
OutputDebugString("Colorless mana not enough\n");
#endif
for (int i=0; i < MTG_NB_COLORS; i++){
if (diff[i*2 + 1] > 0){
if (diff[i*2 + 1] + diff[colorless_idx] > 0){
diff[i*2 + 1] += diff[colorless_idx];
diff[colorless_idx] = 0;
break;
}else{
diff[colorless_idx] += diff[i*2 + 1];
diff[i*2 + 1] = 0;
}
}
}
}
//Cost X
if (_cost->getCost(MTG_NB_COLORS)){
diff[MTG_NB_COLORS * 2 + 1] = 0;
for (int i=0; i < MTG_NB_COLORS; i++){
if (diff[i*2 + 1] > 0){
diff[MTG_NB_COLORS * 2 + 1] += diff[i*2 + 1];
diff[i*2 + 1] = 0;
}
}
}
ManaCost * result = NEW ManaCost(diff, MTG_NB_COLORS +1);
return result;
}
#include "../include/debug.h"
#include "../include/Logger.h"
#include "../include/ManaCost.h"
#include "../include/ManaCostHybrid.h"
#if defined (WIN32)
#include <windows.h>
#endif
ManaCost * ManaCost::parseManaCost(string s, ManaCost * _manaCost){
#if defined (WIN32) || defined (LINUX)
char buf[4096];
#endif
ManaCost * manaCost;
if (_manaCost){
manaCost = _manaCost;
}else{
manaCost = NEW ManaCost();
}
int state = 0;
unsigned int start = 0;
unsigned int end = 0;
while (!s.empty() && state != -1){
switch(state){
case 0:
start = s.find_first_of("{");
if (start == string::npos){
return manaCost;
}else{
state = 1;
}
break;
case 1:
end = s.find_first_of("}");
if (end == string::npos){
state = -1;
}else{
string value = s.substr(start+1, end - 1 - start);
if (value == "u"){
manaCost->add(MTG_COLOR_BLUE, 1);
}else if (value == "b"){
manaCost->add(MTG_COLOR_BLACK, 1);
}else if (value == "w"){
manaCost->add(MTG_COLOR_WHITE, 1);
}else if (value == "g"){
manaCost->add(MTG_COLOR_GREEN, 1);
}else if (value == "r"){
manaCost->add(MTG_COLOR_RED, 1);
}else if (value == "x"){
manaCost->x();
}else if (value == "t"){
}else{
int intvalue = atoi(value.c_str());
int colors[2];
int values[2];
if (!intvalue && value.size() > 1){
#if defined (WIN32) || defined (LINUX)
OutputDebugString("Hybrid Mana ???\n");
#endif
for (int i = 0; i < 2; i++){
char c = value[i];
if (c >='0' && c <='9'){
colors[i] = MTG_COLOR_ARTIFACT;
values[i] = c - '0';
}else{
for (int j = 0; j < MTG_NB_COLORS; j++){
if (c == MTGColorChars[j]){
colors[i] = j;
values[i] = 1;
}
}
}
}
manaCost->addHybrid(colors[0], values[0], colors[1], values[1]);
}else{
manaCost->add(MTG_COLOR_ARTIFACT, intvalue);
}
}
s = s.substr(end + 1);
state = 0;
}
break;
default:
break;
}
}
return manaCost;
}
ManaCost::ManaCost(){
init();
}
ManaCost::ManaCost(int _cost[], int nb_elems){
init();
int i;
int total = nb_elems;
#if defined (WIN32) || defined (LINUX)
char buf[4096];
sprintf(buf, "Create New MAnaCost, total Colors : %i\n", total);
OutputDebugString(buf);
#endif
for (i = 0; i < total; i++){
cost[_cost[i*2]] = _cost[i*2 + 1];
}
}
ManaCost::ManaCost(ManaCost * _manaCost){
init();
int i;
for (i=0; i<= MTG_NB_COLORS; i++){
cost[i] = _manaCost->getCost(i);
}
}
ManaCost::~ManaCost(){
LOG("==Deleting ManaCost==");
for (int i = 0; i < nbhybrids ; i++){
SAFE_DELETE(hybrids[i]);
}
}
void ManaCost::x(){
cost[MTG_NB_COLORS] = 1;
}
void ManaCost::init(){
int i;
for (i=0; i<= MTG_NB_COLORS; i++){
cost[i] = 0;
}
nbhybrids = 0;
}
void ManaCost::copy(ManaCost * _manaCost){
for (int i=0; i<= MTG_NB_COLORS; i++){
cost[i] = _manaCost->getCost(i);
}
for (int i=0; i< _manaCost->nbhybrids; i++){
hybrids[i] = NEW ManaCostHybrid((*_manaCost->hybrids[i]));
}
nbhybrids = _manaCost->nbhybrids;
}
int ManaCost::getCost(int color){
return cost[color];
}
int ManaCost::getMainColor(){
for (int i=0; i< MTG_NB_COLORS; i++){
if (cost[i]) return i;
}
return 0;
}
int ManaCost::hasColor(int color){
if (cost[color]) return 1;
for (int i = 0; i < nbhybrids; i++){
if (hybrids[i]->hasColor(color)) return 1;
}
return 0;
}
int ManaCost::getConvertedCost(){
int result = 0;
for (int i=0; i< MTG_NB_COLORS; i++){
result += cost[i];
}
for (int i = 0; i < nbhybrids; i++){
result+= hybrids[i]->getConvertedCost();
}
return result;
}
int ManaCost::remove(int color, int value){
cost[color] -= value;
return 1;
}
int ManaCost::add(int color, int value){
cost[color] += value;
return 1;
}
int ManaCost::add(ManaCost * _cost){
for (int i=0; i< MTG_NB_COLORS; i++){
cost[i]+= _cost->getCost(i);
}
for (int i=0; i< _cost->nbhybrids; i++){
hybrids[nbhybrids] = NEW ManaCostHybrid((*_cost->hybrids[i]));
nbhybrids++;
}
return 1;
}
string ManaCost::toString(){
return "ManaCost - Todo";
}
int ManaCost::addHybrid(int c1, int v1, int c2, int v2){
ManaCostHybrid * h = NEW ManaCostHybrid(c1,v1,c2,v2);
hybrids[nbhybrids] = h;
nbhybrids++;
return nbhybrids;
}
int ManaCost::pay(ManaCost * _cost){
ManaCost * diff = Diff(_cost);
for (int i=0; i < MTG_NB_COLORS; i++){
cost[i] = diff->getCost(i);
}
delete diff;
return 1;
//TODO return 0 if can't afford the cost!
}
//return 1 if _cost can be paid with current data
int ManaCost::canAfford(ManaCost * _cost){
ManaCost * diff = Diff(_cost);
int positive = diff->isPositive();
delete diff;
if (positive){
#if defined (WIN32) || defined (LINUX)
OutputDebugString("can afford\n");
#endif
return 1;
}
return 0;
}
int ManaCost::isPositive(){
for (int i=0; i < MTG_NB_COLORS; i++){
if (cost[i] < 0){
return 0;
}
}
return 1;
}
void ManaCost::randomDiffHybrids(ManaCost * _cost, int diff[]){
int _nbhybrids = _cost->nbhybrids;
for (int i = 0; i < _nbhybrids; i++){
ManaCostHybrid * h = _cost->hybrids[i];
diff[h->color1 * 2 +1]-= h->value1;
}
}
int ManaCost::tryToPayHybrids(ManaCostHybrid * _hybrids[], int _nbhybrids, int diff[]){
if (!_nbhybrids) return 1;
int result = 0;
ManaCostHybrid * h = _hybrids[_nbhybrids -1];
if (diff[h->color1 * 2 +1] >= h->value1){
diff[h->color1 * 2 +1]-= h->value1;
result = tryToPayHybrids(_hybrids,_nbhybrids -1, diff);
if (result) return 1;
diff[h->color1 * 2 +1]+= h->value1;
}
if (diff[h->color2 * 2 +1] >= h->value2){
diff[h->color2 * 2 +1]-= h->value2;
result = tryToPayHybrids(_hybrids,_nbhybrids -1, diff);
if (result) return 1;
diff[h->color2 * 2 +1]+= h->value2;
}
return 0;
}
//compute the difference between two mana costs
ManaCost * ManaCost::Diff(ManaCost * _cost){
int diff[(MTG_NB_COLORS + 1 )* 2];
diff[MTG_NB_COLORS * 2] = MTG_NB_COLORS;
for (int i=0; i < MTG_NB_COLORS; i++){
diff[i*2] = i;
diff[i*2 +1] = cost[i] - _cost->getCost(i);
}
int hybridResult = tryToPayHybrids(_cost->hybrids, _cost->nbhybrids, diff);
if (!hybridResult) randomDiffHybrids(_cost,diff);
//Colorless mana, special case
int colorless_idx = MTG_COLOR_ARTIFACT * 2 + 1;
if (diff[colorless_idx] < 0){
#if defined (WIN32) || defined (LINUX)
//char buf[4096], *p = buf;
//sprintf(buf, "--Diff color TEST %i : %i\n", i, cost[i]);
OutputDebugString("Colorless mana not enough\n");
#endif
for (int i=0; i < MTG_NB_COLORS; i++){
if (diff[i*2 + 1] > 0){
if (diff[i*2 + 1] + diff[colorless_idx] > 0){
diff[i*2 + 1] += diff[colorless_idx];
diff[colorless_idx] = 0;
break;
}else{
diff[colorless_idx] += diff[i*2 + 1];
diff[i*2 + 1] = 0;
}
}
}
}
//Cost X
if (_cost->getCost(MTG_NB_COLORS)){
diff[MTG_NB_COLORS * 2 + 1] = 0;
for (int i=0; i < MTG_NB_COLORS; i++){
if (diff[i*2 + 1] > 0){
diff[MTG_NB_COLORS * 2 + 1] += diff[i*2 + 1];
diff[i*2 + 1] = 0;
}
}
}
ManaCost * result = NEW ManaCost(diff, MTG_NB_COLORS +1);
return result;
}

52
projects/mtg/src/ManaCostHybrid.cpp
View File

@@ -1,26 +1,26 @@
#include "../include/ManaCostHybrid.h"
ManaCostHybrid::ManaCostHybrid(){
init(0,0,0,0);
}
ManaCostHybrid::ManaCostHybrid(int c1,int v1,int c2,int v2){
init(c1,v1,c2,v2);
}
void ManaCostHybrid::init(int c1,int v1,int c2,int v2){
color1 = c1;
color2 = c2;
value1 = v1;
value2 = v2;
}
int ManaCostHybrid::getConvertedCost(){
if (value2 > value1) return value2;
return value1;
}
int ManaCostHybrid::hasColor(int color){
if (((color1 == color) && value1) || ((color2 == color) && value2)) return 1;
return 0;
}
#include "../include/ManaCostHybrid.h"
ManaCostHybrid::ManaCostHybrid(){
init(0,0,0,0);
}
ManaCostHybrid::ManaCostHybrid(int c1,int v1,int c2,int v2){
init(c1,v1,c2,v2);
}
void ManaCostHybrid::init(int c1,int v1,int c2,int v2){
color1 = c1;
color2 = c2;
value1 = v1;
value2 = v2;
}
int ManaCostHybrid::getConvertedCost(){
if (value2 > value1) return value2;
return value1;
}
int ManaCostHybrid::hasColor(int color){
if (((color1 == color) && value1) || ((color2 == color) && value2)) return 1;
return 0;
}

226
projects/mtg/src/MenuItem.cpp
View File

@@ -1,113 +1,113 @@
#include "../include/debug.h"
#include "../include/MenuItem.h"
MenuItem::MenuItem(int id, JLBFont *font, const char* text, int x, int y, JQuad * _off, JQuad * _on, const char * particle, JQuad * particleTex, bool hasFocus): JGuiObject(id), mFont(font), mText(text), mX(x), mY(y)
{
updatedSinceLastRender = 1;
mParticleSys = NEW hgeParticleSystem(particle, particleTex);
mParticleSys->MoveTo(mX, mY);
mHasFocus = hasFocus;
lastDt = 0.001f;
mScale = 1.0f;
mTargetScale = 1.0f;
onQuad = _on;
offQuad = _off;
if (hasFocus)
Entering();
mFont->SetScale(1.2f);
}
void MenuItem::Render()
{
JRenderer * renderer = JRenderer::GetInstance();
if (mHasFocus)
{
if (!updatedSinceLastRender){
mParticleSys->Update(lastDt);
}
// set additive blending
renderer->SetTexBlend(BLEND_SRC_ALPHA, BLEND_ONE);
mParticleSys->Render();
// set normal blending
renderer->SetTexBlend(BLEND_SRC_ALPHA, BLEND_ONE_MINUS_SRC_ALPHA);
mFont->SetColor(ARGB(255,255,255,255));
onQuad->SetColor(ARGB(70,255,255,255));
renderer->RenderQuad(onQuad, SCREEN_WIDTH , SCREEN_HEIGHT/2 , 0,8,8);
onQuad->SetColor(ARGB(255,255,255,255));
mFont->DrawString(mText, SCREEN_WIDTH/2, 3*SCREEN_HEIGHT/4, JGETEXT_CENTER);
renderer->RenderQuad(onQuad, mX , mY , 0,mScale,mScale);
}
else
{
renderer->RenderQuad(offQuad, mX , mY , 0,mScale,mScale);
}
updatedSinceLastRender= 0;
}
void MenuItem::Update(float dt)
{
updatedSinceLastRender = 1;
lastDt = dt;
if (mScale < mTargetScale)
{
mScale += 8.0f*dt;
if (mScale > mTargetScale)
mScale = mTargetScale;
}
else if (mScale > mTargetScale)
{
mScale -= 8.0f*dt;
if (mScale < mTargetScale)
mScale = mTargetScale;
}
if (mHasFocus){
mParticleSys->Update(dt);
}
}
void MenuItem::Entering()
{
mParticleSys->Fire();
mHasFocus = true;
mTargetScale = 1.3f;
}
bool MenuItem::Leaving(u32 key)
{
mParticleSys->Stop(true);
mHasFocus = false;
mTargetScale = 1.0f;
return true;
}
bool MenuItem::ButtonPressed()
{
return true;
}
MenuItem::~MenuItem(){
if (mParticleSys) delete mParticleSys;
}
#include "../include/debug.h"
#include "../include/MenuItem.h"
MenuItem::MenuItem(int id, JLBFont *font, const char* text, int x, int y, JQuad * _off, JQuad * _on, const char * particle, JQuad * particleTex, bool hasFocus): JGuiObject(id), mFont(font), mText(text), mX(x), mY(y)
{
updatedSinceLastRender = 1;
mParticleSys = NEW hgeParticleSystem(particle, particleTex);
mParticleSys->MoveTo(mX, mY);
mHasFocus = hasFocus;
lastDt = 0.001f;
mScale = 1.0f;
mTargetScale = 1.0f;
onQuad = _on;
offQuad = _off;
if (hasFocus)
Entering();
mFont->SetScale(1.2f);
}
void MenuItem::Render()
{
JRenderer * renderer = JRenderer::GetInstance();
if (mHasFocus)
{
if (!updatedSinceLastRender){
mParticleSys->Update(lastDt);
}
// set additive blending
renderer->SetTexBlend(BLEND_SRC_ALPHA, BLEND_ONE);
mParticleSys->Render();
// set normal blending
renderer->SetTexBlend(BLEND_SRC_ALPHA, BLEND_ONE_MINUS_SRC_ALPHA);
mFont->SetColor(ARGB(255,255,255,255));
onQuad->SetColor(ARGB(70,255,255,255));
renderer->RenderQuad(onQuad, SCREEN_WIDTH , SCREEN_HEIGHT/2 , 0,8,8);
onQuad->SetColor(ARGB(255,255,255,255));
mFont->DrawString(mText, SCREEN_WIDTH/2, 3*SCREEN_HEIGHT/4, JGETEXT_CENTER);
renderer->RenderQuad(onQuad, mX , mY , 0,mScale,mScale);
}
else
{
renderer->RenderQuad(offQuad, mX , mY , 0,mScale,mScale);
}
updatedSinceLastRender= 0;
}
void MenuItem::Update(float dt)
{
updatedSinceLastRender = 1;
lastDt = dt;
if (mScale < mTargetScale)
{
mScale += 8.0f*dt;
if (mScale > mTargetScale)
mScale = mTargetScale;
}
else if (mScale > mTargetScale)
{
mScale -= 8.0f*dt;
if (mScale < mTargetScale)
mScale = mTargetScale;
}
if (mHasFocus){
mParticleSys->Update(dt);
}
}
void MenuItem::Entering()
{
mParticleSys->Fire();
mHasFocus = true;
mTargetScale = 1.3f;
}
bool MenuItem::Leaving(u32 key)
{
mParticleSys->Stop(true);
mHasFocus = false;
mTargetScale = 1.0f;
return true;
}
bool MenuItem::ButtonPressed()
{
return true;
}
MenuItem::~MenuItem(){
if (mParticleSys) delete mParticleSys;
}

240
projects/mtg/src/OptionItem.cpp
View File

@@ -1,120 +1,120 @@
#include "../include/OptionItem.h"
#include "../include/GameApp.h"
#include <JGE.h>
#include "../include/GameOptions.h"
OptionItem::OptionItem(int _id, string _displayValue, int _maxValue, int _increment):JGuiObject(0){
id = _id;
maxValue = _maxValue;
increment = _increment;
displayValue = _displayValue;
value = GameOptions::GetInstance()->values[id];
hasFocus = 0;
x = 0;
y = 0;
}
OptionItem::~OptionItem(){
//TODO
}
void OptionItem::setData(){
GameOptions::GetInstance()->values[id] = value;
}
void OptionItem::Render(){
JLBFont * mFont = GameApp::CommonRes->GetJLBFont("graphics/f3");
if (hasFocus){
mFont->SetColor(ARGB(255,255,255,0));
}else{
mFont->SetColor(ARGB(255,255,255,255));
}
JRenderer * renderer = JRenderer::GetInstance();
mFont->DrawString(displayValue.c_str(),x,y);
char buf[512];
sprintf(buf, "%i", value);
mFont->DrawString(buf,SCREEN_WIDTH -10 ,y,JGETEXT_RIGHT);
}
void OptionItem::Update(float dt){
JGE * mEngine = JGE::GetInstance();
if (hasFocus){
if (mEngine->GetButtonClick(PSP_CTRL_CIRCLE)) updateValue();
}
}
void OptionItem::Entering(){
hasFocus = true;
}
bool OptionItem::Leaving(){
hasFocus = false;
return true;
}
OptionItem * options[20];
int nbitems;
OptionsList::OptionsList(){
nbitems = 0;
current = -1;
}
OptionsList::~OptionsList(){
for (int i = 0 ; i < nbitems; i++){
SAFE_DELETE(options[i]);
}
}
void OptionsList::Add(OptionItem * item){
if (nbitems < 20){
options[nbitems] = item;
item->x = 10;
item->y = 20 + 30*nbitems;
nbitems++;
if (current < 0){
current = 0;
options[0]->Entering();
}
}
}
void OptionsList::Render(){
if (!nbitems){
JLBFont * mFont = GameApp::CommonRes->GetJLBFont("graphics/f3");
mFont->DrawString("NO OPTIONS AVAILABLE",SCREEN_WIDTH/2, 5, JGETEXT_RIGHT);
}
for (int i = 0 ; i < nbitems; i++){
options[i]->Render();
}
}
void OptionsList::save(){
for (int i = 0; i < nbitems; i++){
options[i]->setData();
}
GameOptions::GetInstance()->save();
}
void OptionsList::Update(float dt){
JGE * mEngine = JGE::GetInstance();
if (mEngine->GetButtonClick(PSP_CTRL_UP))
{
if (current > 0){
options[current]->Leaving();
current--;
options[current]->Entering();
}
}
else if (mEngine->GetButtonClick(PSP_CTRL_DOWN))
{
if (current < nbitems -1){
options[current]->Leaving();
current++;
options[current]->Entering();
}
}
for (int i = 0 ; i < nbitems; i++){
options[i]->Update(dt);
}
}
#include "../include/OptionItem.h"
#include "../include/GameApp.h"
#include <JGE.h>
#include "../include/GameOptions.h"
OptionItem::OptionItem(int _id, string _displayValue, int _maxValue, int _increment):JGuiObject(0){
id = _id;
maxValue = _maxValue;
increment = _increment;
displayValue = _displayValue;
value = GameOptions::GetInstance()->values[id];
hasFocus = 0;
x = 0;
y = 0;
}
OptionItem::~OptionItem(){
//TODO
}
void OptionItem::setData(){
GameOptions::GetInstance()->values[id] = value;
}
void OptionItem::Render(){
JLBFont * mFont = GameApp::CommonRes->GetJLBFont("graphics/f3");
if (hasFocus){
mFont->SetColor(ARGB(255,255,255,0));
}else{
mFont->SetColor(ARGB(255,255,255,255));
}
JRenderer * renderer = JRenderer::GetInstance();
mFont->DrawString(displayValue.c_str(),x,y);
char buf[512];
sprintf(buf, "%i", value);
mFont->DrawString(buf,SCREEN_WIDTH -10 ,y,JGETEXT_RIGHT);
}
void OptionItem::Update(float dt){
JGE * mEngine = JGE::GetInstance();
if (hasFocus){
if (mEngine->GetButtonClick(PSP_CTRL_CIRCLE)) updateValue();
}
}
void OptionItem::Entering(){
hasFocus = true;
}
bool OptionItem::Leaving(){
hasFocus = false;
return true;
}
OptionItem * options[20];
int nbitems;
OptionsList::OptionsList(){
nbitems = 0;
current = -1;
}
OptionsList::~OptionsList(){
for (int i = 0 ; i < nbitems; i++){
SAFE_DELETE(options[i]);
}
}
void OptionsList::Add(OptionItem * item){
if (nbitems < 20){
options[nbitems] = item;
item->x = 10;
item->y = 20 + 30*nbitems;
nbitems++;
if (current < 0){
current = 0;
options[0]->Entering();
}
}
}
void OptionsList::Render(){
if (!nbitems){
JLBFont * mFont = GameApp::CommonRes->GetJLBFont("graphics/f3");
mFont->DrawString("NO OPTIONS AVAILABLE",SCREEN_WIDTH/2, 5, JGETEXT_RIGHT);
}
for (int i = 0 ; i < nbitems; i++){
options[i]->Render();
}
}
void OptionsList::save(){
for (int i = 0; i < nbitems; i++){
options[i]->setData();
}
GameOptions::GetInstance()->save();
}
void OptionsList::Update(float dt){
JGE * mEngine = JGE::GetInstance();
if (mEngine->GetButtonClick(PSP_CTRL_UP))
{
if (current > 0){
options[current]->Leaving();
current--;
options[current]->Entering();
}
}
else if (mEngine->GetButtonClick(PSP_CTRL_DOWN))
{
if (current < nbitems -1){
options[current]->Leaving();
current++;
options[current]->Entering();
}
}
for (int i = 0 ; i < nbitems; i++){
options[i]->Update(dt);
}
}

170
projects/mtg/src/PhaseRing.cpp
View File

@@ -1,85 +1,85 @@
#include "../include/PhaseRing.h"
#include "../include/MTGDefinitions.h"
#include "../include/Player.h"
#include "../include/debug.h"
/* Creates a new phase ring with the default rules */
PhaseRing::PhaseRing(Player* players[], int nbPlayers){
for (int i = 0; i < nbPlayers; i++){
for (int j = 0; j <NB_MTG_PHASES; j++){
Phase * phase = NEW Phase(j,players[i]);
addPhase(phase);
}
}
current = ring.begin();
}
PhaseRing::~PhaseRing(){
list<Phase *>::iterator it;
for (it = ring.begin(); it != ring.end(); it++){
Phase * currentPhase = *it;
delete(currentPhase);
}
}
Phase * PhaseRing::getCurrentPhase(){
if (current == ring.end()){
current = ring.begin();
}
return *current;
}
Phase * PhaseRing::forward(){
if (current != ring.end()) current++;
if (current == ring.end()) current = ring.begin();
return *current;
}
Phase * PhaseRing::goToPhase(int id, Player * player){
Phase * currentPhase = *current;
while(currentPhase->id !=id || currentPhase->player !=player){ //Dangerous, risk for inifinte loop !
#ifdef WIN32
OutputDebugString("goto");
#endif
currentPhase = forward();
}
return currentPhase;
}
int PhaseRing::addPhase(Phase * phase){
ring.push_back(phase);
return 1;
}
int PhaseRing::addPhaseBefore(int id, Player* player,int after_id, Player * after_player, int allOccurences){
int result = 0;
list<Phase *>::iterator it;
for (it = ring.begin(); it != ring.end(); it++){
Phase * currentPhase = *it;
if (currentPhase->id == after_id && currentPhase->player == after_player){
result++;
ring.insert(it,NEW Phase(id,player));
if (!allOccurences) return 1;
}
}
return result;
}
int PhaseRing::removePhase (int id, Player * player, int allOccurences){
int result = 0;
list<Phase *>::iterator it = ring.begin();
while (it != ring.end()){
Phase * currentPhase = *it;
if (currentPhase->id == id && currentPhase->player == player){
if (current == it) current++; //Avoid our cursor to get invalidated
it = ring.erase(it);
delete(currentPhase);
result++;
if (!allOccurences) return 1;
}else{
it++;
}
}
return result;
}
#include "../include/PhaseRing.h"
#include "../include/MTGDefinitions.h"
#include "../include/Player.h"
#include "../include/debug.h"
/* Creates a new phase ring with the default rules */
PhaseRing::PhaseRing(Player* players[], int nbPlayers){
for (int i = 0; i < nbPlayers; i++){
for (int j = 0; j <NB_MTG_PHASES; j++){
Phase * phase = NEW Phase(j,players[i]);
addPhase(phase);
}
}
current = ring.begin();
}
PhaseRing::~PhaseRing(){
list<Phase *>::iterator it;
for (it = ring.begin(); it != ring.end(); it++){
Phase * currentPhase = *it;
delete(currentPhase);
}
}
Phase * PhaseRing::getCurrentPhase(){
if (current == ring.end()){
current = ring.begin();
}
return *current;
}
Phase * PhaseRing::forward(){
if (current != ring.end()) current++;
if (current == ring.end()) current = ring.begin();
return *current;
}
Phase * PhaseRing::goToPhase(int id, Player * player){
Phase * currentPhase = *current;
while(currentPhase->id !=id || currentPhase->player !=player){ //Dangerous, risk for inifinte loop !
#ifdef WIN32
OutputDebugString("goto");
#endif
currentPhase = forward();
}
return currentPhase;
}
int PhaseRing::addPhase(Phase * phase){
ring.push_back(phase);
return 1;
}
int PhaseRing::addPhaseBefore(int id, Player* player,int after_id, Player * after_player, int allOccurences){
int result = 0;
list<Phase *>::iterator it;
for (it = ring.begin(); it != ring.end(); it++){
Phase * currentPhase = *it;
if (currentPhase->id == after_id && currentPhase->player == after_player){
result++;
ring.insert(it,NEW Phase(id,player));
if (!allOccurences) return 1;
}
}
return result;
}
int PhaseRing::removePhase (int id, Player * player, int allOccurences){
int result = 0;
list<Phase *>::iterator it = ring.begin();
while (it != ring.end()){
Phase * currentPhase = *it;
if (currentPhase->id == id && currentPhase->player == player){
if (current == it) current++; //Avoid our cursor to get invalidated
it = ring.erase(it);
delete(currentPhase);
result++;
if (!allOccurences) return 1;
}else{
it++;
}
}
return result;
}

230
projects/mtg/src/PlayGuiObject.cpp
View File

@@ -1,21 +1,21 @@
#include "../include/debug.h"
#include "../include/PlayGuiObject.h"
#include "../include/Player.h"
#include "../include/MTGGameZones.h"
#include "../include/CardDisplay.h"
#include "../include/debug.h"
#include "../include/PlayGuiObject.h"
#include "../include/Player.h"
#include "../include/MTGGameZones.h"
#include "../include/CardDisplay.h"
PlayGuiObject::PlayGuiObject(int id, float desiredHeight,float _x, float _y, bool hasFocus): JGuiObject(id){
defaultHeight = desiredHeight;
mHeight = desiredHeight;
x = _x;
y = _y;
mHasFocus = hasFocus;
type = 0;
wave = 0;
type = 0;
wave = 0;
}
void PlayGuiObject::Update(float dt){
if (mHasFocus && mHeight < defaultHeight * 1.2)
{
@@ -31,122 +31,122 @@ void PlayGuiObject::Update(float dt){
if (mHeight < defaultHeight)
mHeight = defaultHeight;
}
wave = (wave +2) % 255;
wave = (wave +2) % 255;
}
GuiAvatar::GuiAvatar(int id, float desiredHeight,float _x, float _y, bool hasFocus, Player * _player): PlayGuiObject(id, desiredHeight, _x, _y, hasFocus){
player= _player;
avatarRed = 255;
currentLife = player->life;
type = GUI_AVATAR;
player= _player;
avatarRed = 255;
currentLife = player->life;
type = GUI_AVATAR;
}
void GuiAvatar::Render(){
GameObserver * game = GameObserver::GetInstance();
JRenderer * r = JRenderer::GetInstance();
int life = player->life;
JLBFont * mFont = GameApp::CommonRes->GetJLBFont(MAIN_FONT);
mFont->SetScale(0.75);
//Avatar
int lifeDiff = life - currentLife;
if (lifeDiff < 0 && currentLife >0 ){
avatarRed = 192 + (3* 255 * lifeDiff)/ currentLife / 4;
if (avatarRed<0)
avatarRed = 0;
}
currentLife= life;
GameObserver * game = GameObserver::GetInstance();
JRenderer * r = JRenderer::GetInstance();
int life = player->life;
JLBFont * mFont = GameApp::CommonRes->GetJLBFont(MAIN_FONT);
mFont->SetScale(0.75);
JQuad * quad = player->mAvatar;
if(quad){
quad->SetColor(ARGB(255,255,avatarRed,avatarRed));
r->RenderQuad(quad,x,y);
if (mHasFocus){
r->FillRect(x,y,quad->mWidth,quad->mHeight,ARGB(abs(wave-128), 255,255,255));
}
}
//Avatar
int lifeDiff = life - currentLife;
if (lifeDiff < 0 && currentLife >0 ){
avatarRed = 192 + (3* 255 * lifeDiff)/ currentLife / 4;
if (avatarRed<0)
avatarRed = 0;
}
currentLife= life;
if (avatarRed < 255){
avatarRed+=3;
if (avatarRed >255)
avatarRed = 255;
}
if(game->currentPlayer == player){
r->DrawRect(x-1,y-1 ,37,52,ARGB(255,0,255,0));
}else if (game->currentActionPlayer == player){
r->DrawRect(x,y,35,50,ARGB(255,0,0,255));
}
if(game->isInterrupting == player){
r->DrawRect(x,y ,35,50,ARGB(255,255,0,0));
}
JQuad * quad = player->mAvatar;
if(quad){
quad->SetColor(ARGB(255,255,avatarRed,avatarRed));
r->RenderQuad(quad,x,y);
if (mHasFocus){
r->FillRect(x,y,quad->mWidth,quad->mHeight,ARGB(abs(wave-128), 255,255,255));
}
}
//Life
char buffer[5];
sprintf(buffer, "%i",life);
mFont->SetColor(ARGB(128,0,0,0));
mFont->DrawString(buffer, x+3,y+40);
mFont->SetColor(ARGB(255,255,255,255));
mFont->DrawString(buffer, x+1,y+38);
if (avatarRed < 255){
avatarRed+=3;
if (avatarRed >255)
avatarRed = 255;
}
if(game->currentPlayer == player){
r->DrawRect(x-1,y-1 ,37,52,ARGB(255,0,255,0));
}else if (game->currentActionPlayer == player){
r->DrawRect(x,y,35,50,ARGB(255,0,0,255));
}
if(game->isInterrupting == player){
r->DrawRect(x,y ,35,50,ARGB(255,255,0,0));
}
//Life
char buffer[5];
sprintf(buffer, "%i",life);
mFont->SetColor(ARGB(128,0,0,0));
mFont->DrawString(buffer, x+3,y+40);
mFont->SetColor(ARGB(255,255,255,255));
mFont->DrawString(buffer, x+1,y+38);
}
void GuiGameZone::toggleDisplay(){
if (showCards){
showCards = 0;
}else{
showCards = 1;
cd->init(zone);
}
if (showCards){
showCards = 0;
}else{
showCards = 1;
cd->init(zone);
}
}
void GuiGameZone::Render(){
//Texture
JQuad * quad = GameApp::CommonRes->GetQuad("back_thumb");
float scale = defaultHeight / quad->mHeight;
quad->SetColor(ARGB(255,255,255,255));
JRenderer::GetInstance()->RenderQuad(quad,x,y,0.0,scale, scale);
if (mHasFocus){
JRenderer::GetInstance()->FillRect(x,y,quad->mWidth*scale,quad->mHeight*scale,ARGB(abs(wave-128), 255,255,255));
}
//Number of cards
JLBFont * mFont = GameApp::CommonRes->GetJLBFont(MAIN_FONT);
char buffer[512];
sprintf(buffer,"%i", zone->nb_cards);
mFont->SetScale(0.75);
mFont->SetColor(ARGB(128,0,0,0));
mFont->DrawString(buffer, x+2, y+2);
mFont->SetColor(ARGB(255,255,255,255));
mFont->DrawString(buffer, x, y);
if (showCards) cd->Render();
}
void GuiGameZone::ButtonPressed(int controllerId, int controlId){
toggleDisplay();
}
void GuiGameZone::Update(float dt){
if (showCards) cd->Update(dt);
PlayGuiObject::Update(dt);
}
GuiGameZone::GuiGameZone(int id, float desiredHeight,float _x, float _y, bool hasFocus,MTGGameZone * _zone): PlayGuiObject(id, desiredHeight, _x, _y, hasFocus), zone(_zone){
cd = NEW CardDisplay(id, GameObserver::GetInstance(), _x, _y, this);
showCards = 0;
}
GuiGameZone::~GuiGameZone(){
if(cd) delete cd;
}
GuiGraveyard::GuiGraveyard(int id, float desiredHeight,float _x, float _y, bool hasFocus,Player * player):GuiGameZone(id, desiredHeight, _x, _y, hasFocus,player->game->graveyard){
type= GUI_GRAVEYARD;
}
GuiLibrary::GuiLibrary(int id, float desiredHeight,float _x, float _y, bool hasFocus,Player * player):GuiGameZone(id, desiredHeight, _x, _y, hasFocus,player->game->library){
type = GUI_LIBRARY;
}
void GuiGameZone::Render(){
//Texture
JQuad * quad = GameApp::CommonRes->GetQuad("back_thumb");
float scale = defaultHeight / quad->mHeight;
quad->SetColor(ARGB(255,255,255,255));
JRenderer::GetInstance()->RenderQuad(quad,x,y,0.0,scale, scale);
if (mHasFocus){
JRenderer::GetInstance()->FillRect(x,y,quad->mWidth*scale,quad->mHeight*scale,ARGB(abs(wave-128), 255,255,255));
}
//Number of cards
JLBFont * mFont = GameApp::CommonRes->GetJLBFont(MAIN_FONT);
char buffer[512];
sprintf(buffer,"%i", zone->nb_cards);
mFont->SetScale(0.75);
mFont->SetColor(ARGB(128,0,0,0));
mFont->DrawString(buffer, x+2, y+2);
mFont->SetColor(ARGB(255,255,255,255));
mFont->DrawString(buffer, x, y);
if (showCards) cd->Render();
}
void GuiGameZone::ButtonPressed(int controllerId, int controlId){
toggleDisplay();
}
void GuiGameZone::Update(float dt){
if (showCards) cd->Update(dt);
PlayGuiObject::Update(dt);
}
GuiGameZone::GuiGameZone(int id, float desiredHeight,float _x, float _y, bool hasFocus,MTGGameZone * _zone): PlayGuiObject(id, desiredHeight, _x, _y, hasFocus), zone(_zone){
cd = NEW CardDisplay(id, GameObserver::GetInstance(), _x, _y, this);
showCards = 0;
}
GuiGameZone::~GuiGameZone(){
if(cd) delete cd;
}
GuiGraveyard::GuiGraveyard(int id, float desiredHeight,float _x, float _y, bool hasFocus,Player * player):GuiGameZone(id, desiredHeight, _x, _y, hasFocus,player->game->graveyard){
type= GUI_GRAVEYARD;
}
GuiLibrary::GuiLibrary(int id, float desiredHeight,float _x, float _y, bool hasFocus,Player * player):GuiGameZone(id, desiredHeight, _x, _y, hasFocus,player->game->library){
type = GUI_LIBRARY;
}

378
projects/mtg/src/PlayGuiObjectController.cpp
View File

@@ -1,11 +1,11 @@
#include "../include/debug.h"
#include "../include/PlayGuiObjectController.h"
#include "../include/debug.h"
#include "../include/PlayGuiObjectController.h"
#include "../include/PlayGuiObject.h"
#include "../include/GameObserver.h"
bool PlayGuiObjectController::showBigCards = true;
#include "../include/GameObserver.h"
bool PlayGuiObjectController::showBigCards = true;
int PlayGuiObjectController::getClosestItem(int direction){
return getClosestItem(direction, 35);
}
@@ -19,153 +19,153 @@ int PlayGuiObjectController::getClosestItem(int direction, float tolerance){
return mCurr;
}
float maxDist = SCREEN_WIDTH * SCREEN_WIDTH;
float maxDist = SCREEN_WIDTH * SCREEN_WIDTH;
PlayGuiObject * current = (PlayGuiObject *)mObjects[mCurr];
int closest_match = -1;
int available = 0;
float x0, y0, x1, y1;
x0 = current->x;
y0 = current->y;
int closest_match = -1;
int available = 0;
float x0, y0, x1, y1;
x0 = current->x;
y0 = current->y;
for (int i=0;i<mCount;i++){
if (i == mCurr) continue;
PlayGuiObject * other = (PlayGuiObject *) mObjects[i];
x1 = other->x;
y1 = other->y;
float dist = (x0-x1)*(x0-x1) + (y0-y1)*(y0-y1);
if (dist>=maxDist) continue;
//Potential match !
int ok = 0;
switch(direction){
case DIR_DOWN:
if (y1 > y0){
available = 1;
if (fabs(x0-x1) < tolerance ) ok = 1;
}
break;
case DIR_UP:
if (y1 < y0){
available = 1;
if (fabs(x0-x1) < tolerance ) ok = 1;
}
break;
case DIR_LEFT:
if (x1 < x0){
available = 1;
if (fabs(y0-y1) < tolerance ) ok = 1;
}
break;
case DIR_RIGHT:
if (x1 > x0){
available = 1;
if (fabs(y0-y1) < tolerance ) ok = 1;
}
break;
}
if (ok){
closest_match = i;
maxDist = dist;
}
}
if (closest_match == -1){
if (available) return getClosestItem(direction,tolerance+5);
return mCurr;
}
return closest_match;
if (i == mCurr) continue;
PlayGuiObject * other = (PlayGuiObject *) mObjects[i];
x1 = other->x;
y1 = other->y;
float dist = (x0-x1)*(x0-x1) + (y0-y1)*(y0-y1);
if (dist>=maxDist) continue;
//Potential match !
int ok = 0;
switch(direction){
case DIR_DOWN:
if (y1 > y0){
available = 1;
if (fabs(x0-x1) < tolerance ) ok = 1;
}
break;
case DIR_UP:
if (y1 < y0){
available = 1;
if (fabs(x0-x1) < tolerance ) ok = 1;
}
break;
case DIR_LEFT:
if (x1 < x0){
available = 1;
if (fabs(y0-y1) < tolerance ) ok = 1;
}
break;
case DIR_RIGHT:
if (x1 > x0){
available = 1;
if (fabs(y0-y1) < tolerance ) ok = 1;
}
break;
}
if (ok){
closest_match = i;
maxDist = dist;
}
}
if (closest_match == -1){
if (available) return getClosestItem(direction,tolerance+5);
return mCurr;
}
return closest_match;
}
/*
int PlayGuiObjectController::getClosestItem(int direction, float tolerance){
int PlayGuiObjectController::getClosestItem(int direction, float tolerance){
if (mCount == 0){
return -1;
return -1;
}
if (mCount == 1){
return mCurr;
return mCurr;
}
float MaxTolerance = SCREEN_HEIGHT;
float MaxTolerance = SCREEN_HEIGHT;
PlayGuiObject * current = (PlayGuiObject *)mObjects[mCurr];
int found = 0;
int closest_match_id = -1;
for (int i=0;i<mCount;i++){
fprintf(stderr, "distance STEP 3-%i\n", i);
if (i != mCurr){ //Don't wanna return the same object as currently selected
if (closest_match_id == -1){
closest_match_id = i;
}
if (mObjects[i]!=NULL){
float x0, y0, x1, y1,closest;
PlayGuiObject * closest_match = (PlayGuiObject *)mObjects[closest_match_id];
PlayGuiObject * other = (PlayGuiObject *) mObjects[i];
fprintf(stderr, "distance STEP 4-%i\n", i);
switch(direction){
case DIR_DOWN:
x0 = current->x;
y0 = current->y;
x1 = other->x;
y1 = other->y;
closest = closest_match->y - y0;
break;
case DIR_UP:
x0 = current->x;
y0 = other->y;
x1 = other->x;
y1 = current->y;
closest = y1 - closest_match->y;
break;
case DIR_LEFT:
MaxTolerance = SCREEN_WIDTH;
x0 = current->y;
y1 = current->x;
x1 = other->y;
y0 = other->x;
closest = y1 - closest_match->x;
break;
case DIR_RIGHT:
MaxTolerance = SCREEN_WIDTH;
x0 = current->y;
fprintf(stderr, "distance STEP 401\n");
y0 = current->x;
fprintf(stderr, "distance STEP 402\n");
x1 = other->y;
fprintf(stderr, "distance STEP 403\n");
y1 = other->x;
fprintf(stderr, "distance STEP 404\n");
closest = closest_match->x - y0;
fprintf(stderr, "distance STEP 405\n");
break;
}
fprintf(stderr, "distance STEP 5\n");
float distance = y1-y0;
float lateral_distance = fabs(x1-x0);
fprintf(stderr, "distance STEP 6 \n");
if (lateral_distance < tolerance){
fprintf(stderr, "distance STEP 7\n");
if (distance > 0 && (!found || (distance < closest && closest > 0 ))){
fprintf(stderr, "distance STEP 3-%i\n", i);
if (i != mCurr){ //Don't wanna return the same object as currently selected
if (closest_match_id == -1){
closest_match_id = i;
}
if (mObjects[i]!=NULL){
float x0, y0, x1, y1,closest;
PlayGuiObject * closest_match = (PlayGuiObject *)mObjects[closest_match_id];
PlayGuiObject * other = (PlayGuiObject *) mObjects[i];
fprintf(stderr, "distance STEP 4-%i\n", i);
switch(direction){
case DIR_DOWN:
x0 = current->x;
y0 = current->y;
x1 = other->x;
y1 = other->y;
closest = closest_match->y - y0;
break;
case DIR_UP:
x0 = current->x;
y0 = other->y;
x1 = other->x;
y1 = current->y;
closest = y1 - closest_match->y;
break;
case DIR_LEFT:
MaxTolerance = SCREEN_WIDTH;
x0 = current->y;
y1 = current->x;
x1 = other->y;
y0 = other->x;
closest = y1 - closest_match->x;
break;
case DIR_RIGHT:
MaxTolerance = SCREEN_WIDTH;
x0 = current->y;
fprintf(stderr, "distance STEP 401\n");
found = 1;
closest_match_id = i;
fprintf(stderr, "distance STEP 8\n");
}
}
}// if (mObjects[i]!=NULL)
}
y0 = current->x;
fprintf(stderr, "distance STEP 402\n");
x1 = other->y;
fprintf(stderr, "distance STEP 403\n");
y1 = other->x;
fprintf(stderr, "distance STEP 404\n");
closest = closest_match->x - y0;
fprintf(stderr, "distance STEP 405\n");
break;
}
fprintf(stderr, "distance STEP 5\n");
float distance = y1-y0;
float lateral_distance = fabs(x1-x0);
fprintf(stderr, "distance STEP 6 \n");
if (lateral_distance < tolerance){
fprintf(stderr, "distance STEP 7\n");
if (distance > 0 && (!found || (distance < closest && closest > 0 ))){
found = 1;
closest_match_id = i;
fprintf(stderr, "distance STEP 8\n");
}
}
}// if (mObjects[i]!=NULL)
}
}
if (!found){
fprintf(stderr, "NOT FOUND !\n");
if (tolerance < MaxTolerance){
fprintf(stderr, "distance STEP 9\n");
return getClosestItem(direction, tolerance + 5);
}else{
fprintf(stderr, "Closest Match ID: %i\n", mCurr);
return mCurr;
}
if (tolerance < MaxTolerance){
fprintf(stderr, "distance STEP 9\n");
return getClosestItem(direction, tolerance + 5);
}else{
fprintf(stderr, "Closest Match ID: %i\n", mCurr);
return mCurr;
}
}
fprintf(stderr, "Closest Match ID: %i\n", closest_match_id);
return closest_match_id;
}
}
*/
void PlayGuiObjectController::Update(float dt){
for (int i=0;i<mCount;i++){
@@ -177,74 +177,74 @@ void PlayGuiObjectController::Update(float dt){
void PlayGuiObjectController::CheckUserInput(float dt){
if (!mCount)
return;
if (game != NULL){
if (mEngine->GetButtonClick(mActionButton)){
if (mObjects[mCurr] != NULL && mObjects[mCurr]->ButtonPressed()){
game->ButtonPressed(mId, (PlayGuiObject *)mObjects[mCurr]);
return;
}
}
if (mEngine->GetButtonClick(PSP_CTRL_CROSS)){
game->cancelCurrentAction();
}
}
if (!mCount)
return;
if (game != NULL){
if (mEngine->GetButtonClick(mActionButton)){
if (mObjects[mCurr] != NULL && mObjects[mCurr]->ButtonPressed()){
game->ButtonPressed(mId, (PlayGuiObject *)mObjects[mCurr]);
return;
}
}
if (mEngine->GetButtonClick(PSP_CTRL_CROSS)){
game->cancelCurrentAction();
}
}
if (mEngine->GetButtonState(PSP_CTRL_LEFT))
if (mEngine->GetButtonState(PSP_CTRL_LEFT))
{
if (KeyRepeated(PSP_CTRL_LEFT, dt))
{
if (KeyRepeated(PSP_CTRL_LEFT, dt))
{
int n = getClosestItem(DIR_LEFT);
if (n != mCurr && mObjects[mCurr] != NULL && mObjects[mCurr]->Leaving(PSP_CTRL_LEFT))
{
mCurr = n;
mObjects[mCurr]->Entering();
}
}
int n = getClosestItem(DIR_LEFT);
if (n != mCurr && mObjects[mCurr] != NULL && mObjects[mCurr]->Leaving(PSP_CTRL_LEFT))
{
mCurr = n;
mObjects[mCurr]->Entering();
}
}
else if (mEngine->GetButtonState(PSP_CTRL_RIGHT))
}
else if (mEngine->GetButtonState(PSP_CTRL_RIGHT))
{
if (KeyRepeated(PSP_CTRL_RIGHT, dt))
{
if (KeyRepeated(PSP_CTRL_RIGHT, dt))
{
int n = getClosestItem(DIR_RIGHT);
if (n != mCurr && mObjects[mCurr] != NULL && mObjects[mCurr]->Leaving(PSP_CTRL_RIGHT))
{
mCurr = n;
mObjects[mCurr]->Entering();
}
}
int n = getClosestItem(DIR_RIGHT);
if (n != mCurr && mObjects[mCurr] != NULL && mObjects[mCurr]->Leaving(PSP_CTRL_RIGHT))
{
mCurr = n;
mObjects[mCurr]->Entering();
}
}
else if (mEngine->GetButtonState(PSP_CTRL_UP))
}
else if (mEngine->GetButtonState(PSP_CTRL_UP))
{
if (KeyRepeated(PSP_CTRL_UP, dt))
{
if (KeyRepeated(PSP_CTRL_UP, dt))
{
int n = getClosestItem(DIR_UP);
if (n != mCurr && mObjects[mCurr] != NULL && mObjects[mCurr]->Leaving(PSP_CTRL_UP))
{
mCurr = n;
mObjects[mCurr]->Entering();
}
}
int n = getClosestItem(DIR_UP);
if (n != mCurr && mObjects[mCurr] != NULL && mObjects[mCurr]->Leaving(PSP_CTRL_UP))
{
mCurr = n;
mObjects[mCurr]->Entering();
}
}
else if (mEngine->GetButtonState(PSP_CTRL_DOWN))
}
else if (mEngine->GetButtonState(PSP_CTRL_DOWN))
{
if (KeyRepeated(PSP_CTRL_DOWN, dt))
{
if (KeyRepeated(PSP_CTRL_DOWN, dt))
{
int n = getClosestItem(DIR_DOWN);
if (n != mCurr && mObjects[mCurr] != NULL && mObjects[mCurr]->Leaving(PSP_CTRL_DOWN))
{
mCurr = n;
mObjects[mCurr]->Entering();
}
}
}else if (mEngine->GetButtonClick(PSP_CTRL_TRIANGLE)){
showBigCards = !showBigCards;
int n = getClosestItem(DIR_DOWN);
if (n != mCurr && mObjects[mCurr] != NULL && mObjects[mCurr]->Leaving(PSP_CTRL_DOWN))
{
mCurr = n;
mObjects[mCurr]->Entering();
}
}
}else if (mEngine->GetButtonClick(PSP_CTRL_TRIANGLE)){
showBigCards = !showBigCards;
}
else{
mLastKey = 0;
}
else{
mLastKey = 0;
}

170
projects/mtg/src/Player.cpp
View File

@@ -1,85 +1,85 @@
#include "../include/debug.h"
#include "../include/Player.h"
#include "../include/GameObserver.h"
Player::Player(MTGPlayerCards * _deck, string file): Damageable(20){
deckFile = file;
game = _deck;
game->setOwner(this);
manaPool = NEW ManaCost();
canPutLandsIntoPlay = 1;
mAvatar = NULL;
type_as_damageable = DAMAGEABLE_PLAYER;
}
Player::~Player(){
if (manaPool) delete manaPool;
if (mAvatarTex) delete mAvatarTex;
if (mAvatar) delete mAvatar;
}
MTGInPlay * Player::inPlay(){
return game->inPlay;
}
int Player::getId(){
GameObserver * game = GameObserver::GetInstance();
for (int i= 0; i < 2; i++){
if (game->players[i] == this) return i;
}
return -1;
}
JQuad * Player::getIcon(){
return mAvatar;
}
Player * Player::opponent(){
GameObserver * game = GameObserver::GetInstance();
for (int i= 0; i < 2; i++){
if (game->players[i] != this) return game->players[i];
}
return NULL;
}
HumanPlayer::HumanPlayer(MTGPlayerCards * _deck, char * file):Player(_deck, file){
mAvatarTex = JRenderer::GetInstance()->LoadTexture("player/avatar.jpg", TEX_TYPE_USE_VRAM);
if (mAvatarTex)
mAvatar = NEW JQuad(mAvatarTex, 0, 0, 35, 50);
}
ManaCost * Player::getManaPool(){
return manaPool;
}
int Player::manaBurn(){
int burn = manaPool->getConvertedCost();
life -= burn;
manaPool->init();
return burn;
}
int Player::testLife(){
if (life <=0){
#if defined (WIN32) || defined (LINUX)
//char buf[4096], *p = buf;
//sprintf(buf, "--Diff color TEST %i : %i\n", i, cost[i]);
OutputDebugString("GAME OVER\n");
#endif
//return GameObserver::GetInstance()->endOfGame();
}
return life;
}
int Player::afterDamage(){
return testLife();
}
//Cleanup phase at the end of a turn
void Player::cleanupPhase(){
game->inPlay->cleanupPhase();
game->graveyard->cleanupPhase();
}
#include "../include/debug.h"
#include "../include/Player.h"
#include "../include/GameObserver.h"
Player::Player(MTGPlayerCards * _deck, string file): Damageable(20){
deckFile = file;
game = _deck;
game->setOwner(this);
manaPool = NEW ManaCost();
canPutLandsIntoPlay = 1;
mAvatar = NULL;
type_as_damageable = DAMAGEABLE_PLAYER;
}
Player::~Player(){
if (manaPool) delete manaPool;
if (mAvatarTex) delete mAvatarTex;
if (mAvatar) delete mAvatar;
}
MTGInPlay * Player::inPlay(){
return game->inPlay;
}
int Player::getId(){
GameObserver * game = GameObserver::GetInstance();
for (int i= 0; i < 2; i++){
if (game->players[i] == this) return i;
}
return -1;
}
JQuad * Player::getIcon(){
return mAvatar;
}
Player * Player::opponent(){
GameObserver * game = GameObserver::GetInstance();
for (int i= 0; i < 2; i++){
if (game->players[i] != this) return game->players[i];
}
return NULL;
}
HumanPlayer::HumanPlayer(MTGPlayerCards * _deck, char * file):Player(_deck, file){
mAvatarTex = JRenderer::GetInstance()->LoadTexture("player/avatar.jpg", TEX_TYPE_USE_VRAM);
if (mAvatarTex)
mAvatar = NEW JQuad(mAvatarTex, 0, 0, 35, 50);
}
ManaCost * Player::getManaPool(){
return manaPool;
}
int Player::manaBurn(){
int burn = manaPool->getConvertedCost();
life -= burn;
manaPool->init();
return burn;
}
int Player::testLife(){
if (life <=0){
#if defined (WIN32) || defined (LINUX)
//char buf[4096], *p = buf;
//sprintf(buf, "--Diff color TEST %i : %i\n", i, cost[i]);
OutputDebugString("GAME OVER\n");
#endif
//return GameObserver::GetInstance()->endOfGame();
}
return life;
}
int Player::afterDamage(){
return testLife();
}
//Cleanup phase at the end of a turn
void Player::cleanupPhase(){
game->inPlay->cleanupPhase();
game->graveyard->cleanupPhase();
}

74
projects/mtg/src/PlayerData.cpp
View File

@@ -1,40 +1,40 @@
#include "../include/debug.h"
#include "../include/PlayerData.h"
#include <string.h>
#include <stdio.h>
PlayerData::PlayerData(MTGAllCards * allcards){
//CREDITS
credits = 3000; //Default value
std::ifstream file(PLAYER_SAVEFILE);
std::string s;
if(file){
if(std::getline(file,s)){
credits = atoi(s.c_str());
}else{
//TODO error management
}
file.close();
}
//COLLECTION
collection = NEW MTGDeck("Res/player/collection.dat", allcards->mCache , allcards);
}
int PlayerData::save(){
std::ofstream file(PLAYER_SAVEFILE);
char writer[10];
if (file){
sprintf(writer,"%i\n", credits);
file<<writer;
file.close();
}
collection->save();
return 1;
#include "../include/debug.h"
#include "../include/PlayerData.h"
#include <string.h>
#include <stdio.h>
PlayerData::PlayerData(MTGAllCards * allcards){
//CREDITS
credits = 3000; //Default value
std::ifstream file(PLAYER_SAVEFILE);
std::string s;
if(file){
if(std::getline(file,s)){
credits = atoi(s.c_str());
}else{
//TODO error management
}
file.close();
}
//COLLECTION
collection = NEW MTGDeck("Res/player/collection.dat", allcards->mCache , allcards);
}
int PlayerData::save(){
std::ofstream file(PLAYER_SAVEFILE);
char writer[10];
if (file){
sprintf(writer,"%i\n", credits);
file<<writer;
file.close();
}
collection->save();
return 1;
}
PlayerData::~PlayerData(){
SAFE_DELETE(collection);
}
SAFE_DELETE(collection);
}

176
projects/mtg/src/PriceList.cpp
View File

@@ -1,88 +1,88 @@
#include "../include/debug.h"
#include "../include/PriceList.h"
Price::Price(int _cardid, int _price): cardid(_cardid),price(_price){
}
PriceList::PriceList(const char * _filename, MTGAllCards * _collection):collection(_collection){
nbprices = 0;
filename = _filename;
std::ifstream file(_filename);
std::string cardid;
std::string price;
if(file){
while(std::getline(file,cardid)){
std::getline(file,price);
prices[nbprices]= NEW Price(atoi(cardid.c_str()), atoi(price.c_str()));
nbprices++;
}
file.close();
}
}
PriceList::~PriceList(){
for (int i = 0; i < nbprices; i++){
delete (prices[i]);
}
nbprices = 0;
}
int PriceList::save(){
std::ofstream file(filename.c_str());
char writer[20];
if (file){
for (int i = 0; i<nbprices; i++){
sprintf(writer,"%i\n%i\n", prices[i]->cardid, prices[i]->price);
file<<writer;
}
file.close();
}
return 1;
}
int PriceList::getPrice(int cardId){
for(int i = 0; i < nbprices; i++){
if (prices[i]->cardid == cardId){
return prices[i]->price;
}
}
char rarity = collection->getCardById(cardId)->getRarity();
switch(rarity){
case RARITY_M:
return 3000;
break;
case RARITY_R:
return 500;
break;
case RARITY_U:
return 100;
break;
case RARITY_C:
return 20;
break;
case RARITY_L:
return 5;
break;
default:
return 20;
break;
}
}
int PriceList::setPrice(int cardId, int price){
for(int i = 0; i < nbprices; i++){
if (prices[i]->cardid == cardId){
prices[i]->price = price;
return prices[i]->price;
}
}
prices[nbprices] = NEW Price(cardId, price);
nbprices++;
return prices[nbprices-1]->price;
}
#include "../include/debug.h"
#include "../include/PriceList.h"
Price::Price(int _cardid, int _price): cardid(_cardid),price(_price){
}
PriceList::PriceList(const char * _filename, MTGAllCards * _collection):collection(_collection){
nbprices = 0;
filename = _filename;
std::ifstream file(_filename);
std::string cardid;
std::string price;
if(file){
while(std::getline(file,cardid)){
std::getline(file,price);
prices[nbprices]= NEW Price(atoi(cardid.c_str()), atoi(price.c_str()));
nbprices++;
}
file.close();
}
}
PriceList::~PriceList(){
for (int i = 0; i < nbprices; i++){
delete (prices[i]);
}
nbprices = 0;
}
int PriceList::save(){
std::ofstream file(filename.c_str());
char writer[20];
if (file){
for (int i = 0; i<nbprices; i++){
sprintf(writer,"%i\n%i\n", prices[i]->cardid, prices[i]->price);
file<<writer;
}
file.close();
}
return 1;
}
int PriceList::getPrice(int cardId){
for(int i = 0; i < nbprices; i++){
if (prices[i]->cardid == cardId){
return prices[i]->price;
}
}
char rarity = collection->getCardById(cardId)->getRarity();
switch(rarity){
case RARITY_M:
return 3000;
break;
case RARITY_R:
return 500;
break;
case RARITY_U:
return 100;
break;
case RARITY_C:
return 20;
break;
case RARITY_L:
return 5;
break;
default:
return 20;
break;
}
}
int PriceList::setPrice(int cardId, int price){
for(int i = 0; i < nbprices; i++){
if (prices[i]->cardid == cardId){
prices[i]->price = price;
return prices[i]->price;
}
}
prices[nbprices] = NEW Price(cardId, price);
nbprices++;
return prices[nbprices-1]->price;
}

576
projects/mtg/src/ShopItem.cpp
View File

@@ -1,288 +1,288 @@
#include "../include/debug.h"
#include "../include/ShopItem.h"
#include "../include/CardGui.h"
ShopItem::ShopItem(int id, JLBFont *font, char* text, JQuad * _quad,JQuad * _thumb, int x, int y, bool hasFocus, int _price): JGuiObject(id), mFont(font), mText(text), mX(x), mY(y), quad(_quad), thumb(_thumb), price(_price)
{
quantity = 10;
card = NULL;
mHasFocus = hasFocus;
mScale = 1.0f;
mTargetScale = 1.0f;
if (hasFocus)
Entering();
mFont->SetScale(1.2f);
}
ShopItem::ShopItem(int id, JLBFont *font, int _cardid, int x, int y, bool hasFocus, MTGAllCards * collection, int _price): JGuiObject(id), mFont(font), mX(x), mY(y), price(_price){
mHasFocus = hasFocus;
mScale = 1.0f;
mTargetScale = 1.0f;
if (hasFocus)
Entering();
mFont->SetScale(1.2f);
card = collection->getCardById(_cardid);
quantity = 1;
if (card->getRarity() == RARITY_L) quantity = 50;
quad = NULL;
thumb = NULL;
}
ShopItem::~ShopItem(){
}
const char * ShopItem::getText(){
return mText.c_str();
}
void ShopItem::Render(){
JRenderer * renderer = JRenderer::GetInstance();
renderer->FillRect(mX-5, mY-5,230,35, ARGB(128,0,0,0));
if (card){
thumb = card->getThumb();
mText= card->name;
}
if (thumb){
renderer->RenderQuad(thumb,mX,mY,0,mScale * 0.45,mScale * 0.45);
}else{
//NOTHING
}
if (mHasFocus){
if (card){
quad = card->getQuad();
}
if (quad){
renderer->RenderQuad(quad,mX + SCREEN_WIDTH/2 + 20,5,0, 0.9f,0.9f);
}else{
if (card) CardGui::alternateRender(card,mFont,NULL,mX + SCREEN_WIDTH/2 + 100 + 20,133,0, 0.9f);
//TODO
}
mFont->SetColor(ARGB(255,255,255,0));
}else{
mFont->SetColor(ARGB(255,255,255,255));
}
if (!quantity){
mFont->SetColor(ARGB(255,128,128,128));
}
mFont->SetScale(mScale);
mFont->DrawString(mText.c_str(),mX + 30,mY);
}
void ShopItem::Update(float dt)
{
if (mScale < mTargetScale)
{
mScale += 8.0f*dt;
if (mScale > mTargetScale)
mScale = mTargetScale;
}
else if (mScale > mTargetScale)
{
mScale -= 8.0f*dt;
if (mScale < mTargetScale)
mScale = mTargetScale;
}
}
void ShopItem::Entering()
{
mHasFocus = true;
mTargetScale = 1.2f;
}
bool ShopItem::Leaving(u32 key)
{
mHasFocus = false;
mTargetScale = 1.0f;
return true;
}
bool ShopItem::ButtonPressed()
{
return (quantity >0);
}
ShopItems::ShopItems(int id, JGuiListener* listener, JLBFont* font, int x, int y, MTGAllCards * _collection, int _setId): JGuiController(id, listener), mX(x), mY(y), mFont(font), collection(_collection), setId(_setId){
mHeight = 0;
showPriceDialog = -1;
dialog = NULL;
pricelist = NEW PriceList("Res/settings/prices.dat",_collection);
playerdata = NEW PlayerData(_collection);
display = NULL;
}
void ShopItems::Add(int cardid){
int rnd = (rand() % 20);
int price = pricelist->getPrice(cardid);
price = price + price * (rnd -10)/100;
JGuiController::Add(NEW ShopItem(mCount, mFont, cardid, mX + 10, mY + 10 + mHeight, (mCount == 0),collection, price));
mHeight += 40;
}
void ShopItems::Add(char * text, JQuad * quad,JQuad * thumb, int price){
JGuiController::Add(NEW ShopItem(mCount, mFont, text, quad, thumb, mX + 10, mY + 10 + mHeight, (mCount == 0), price));
mHeight += 40;
}
void ShopItems::Update(float dt){
if (display){
display->CheckUserInput(dt);
if (display) display->Update(dt);
}else{
if (showPriceDialog!=-1){
ShopItem * item = ((ShopItem *)mObjects[showPriceDialog]);
int price = item->price;
char buffer[4096];
sprintf(buffer,"%s : %i credits",item->getText(),price);
if(!dialog){
dialog = NEW SimpleMenu(1,this,mFont,SCREEN_WIDTH-300,SCREEN_HEIGHT/2,270,buffer);
dialog->Add(1,"Yes");
dialog->Add(2,"No");
}
else{
dialog->Update(dt);
}
}else{
SAFE_DELETE(dialog);
JGuiController::Update(dt);
}
}
}
void ShopItems::Render(){
JGuiController::Render();
if (showPriceDialog==-1){
}else{
if(dialog){
dialog->Render();
}
}
char credits[512];
sprintf(credits,"credits: %i", playerdata->credits);
mFont->SetScale(1.2);
mFont->SetColor(ARGB(200,0,0,0));
mFont->DrawString(credits,SCREEN_WIDTH-148, SCREEN_HEIGHT - 13);
mFont->SetColor(ARGB(255,255,255,255));
mFont->DrawString(credits,SCREEN_WIDTH-150, SCREEN_HEIGHT - 15);
if (display) display->Render();
}
void ShopItems::pricedialog(int id, int mode){
if (mode){
showPriceDialog = id;
}else{
showPriceDialog = -1;
}
}
void ShopItems::ButtonPressed(int controllerId, int controlId){
if (controllerId == 12){
safeDeleteDisplay();
return;
}
ShopItem * item = ((ShopItem *)mObjects[showPriceDialog]);
int price = item->price;
switch(controlId){
case 1:
if (playerdata->credits >= price){
playerdata->credits -= price;
if (item->card){
int rnd = (rand() % 5);
price = price + (rnd * price)/100;
pricelist->setPrice(item->card->getMTGId(),price);
playerdata->collection->add(item->card);
item->quantity--;
}else{
safeDeleteDisplay();
display = new CardDisplay(12,NULL, SCREEN_WIDTH - 200, SCREEN_HEIGHT/2,this,NULL,5);
int curNbcards = playerdata->collection->totalCards();
if (showPriceDialog == 0){
//Starter Deck
playerdata->collection->addRandomCards(3,setId,RARITY_R,NULL);
playerdata->collection->addRandomCards(9, setId,RARITY_U,NULL);
playerdata->collection->addRandomCards(48, setId,RARITY_C,NULL);
}else{
//Booster
playerdata->collection->addRandomCards(1, setId,RARITY_R);
playerdata->collection->addRandomCards(3, setId,RARITY_U);
playerdata->collection->addRandomCards(11, setId,RARITY_C);
}
int newNbCards = playerdata->collection->totalCards();;
for (int i = curNbcards; i < newNbCards ; i++){
MTGCardInstance * card = NEW MTGCardInstance(playerdata->collection->_(i), NULL);
displayCards[i-curNbcards] = card;
display->AddCard(card);
}
}
//Remove(showPriceDialog);
showPriceDialog = -1;
}else{
//error not enough money
}
break;
case 2:
if (item->card){
int rnd = (rand() % 5);
price = price - (rnd * price)/100;
pricelist->setPrice(item->card->getMTGId(),price);
}
showPriceDialog = -1;
break;
}
}
void ShopItems::safeDeleteDisplay(){
if (!display) return;
for (int i = 0; i < display->mCount; i++){
delete displayCards[i];
}
SAFE_DELETE(display);
}
void ShopItems::saveAll(){
savePriceList();
playerdata->save();
}
void ShopItems::savePriceList(){
pricelist->save();
}
ShopItems::~ShopItems(){
SAFE_DELETE(pricelist);
SAFE_DELETE(playerdata);
SAFE_DELETE(dialog);
safeDeleteDisplay();
}
#include "../include/debug.h"
#include "../include/ShopItem.h"
#include "../include/CardGui.h"
ShopItem::ShopItem(int id, JLBFont *font, char* text, JQuad * _quad,JQuad * _thumb, int x, int y, bool hasFocus, int _price): JGuiObject(id), mFont(font), mText(text), mX(x), mY(y), quad(_quad), thumb(_thumb), price(_price)
{
quantity = 10;
card = NULL;
mHasFocus = hasFocus;
mScale = 1.0f;
mTargetScale = 1.0f;
if (hasFocus)
Entering();
mFont->SetScale(1.2f);
}
ShopItem::ShopItem(int id, JLBFont *font, int _cardid, int x, int y, bool hasFocus, MTGAllCards * collection, int _price): JGuiObject(id), mFont(font), mX(x), mY(y), price(_price){
mHasFocus = hasFocus;
mScale = 1.0f;
mTargetScale = 1.0f;
if (hasFocus)
Entering();
mFont->SetScale(1.2f);
card = collection->getCardById(_cardid);
quantity = 1;
if (card->getRarity() == RARITY_L) quantity = 50;
quad = NULL;
thumb = NULL;
}
ShopItem::~ShopItem(){
}
const char * ShopItem::getText(){
return mText.c_str();
}
void ShopItem::Render(){
JRenderer * renderer = JRenderer::GetInstance();
renderer->FillRect(mX-5, mY-5,230,35, ARGB(128,0,0,0));
if (card){
thumb = card->getThumb();
mText= card->name;
}
if (thumb){
renderer->RenderQuad(thumb,mX,mY,0,mScale * 0.45,mScale * 0.45);
}else{
//NOTHING
}
if (mHasFocus){
if (card){
quad = card->getQuad();
}
if (quad){
renderer->RenderQuad(quad,mX + SCREEN_WIDTH/2 + 20,5,0, 0.9f,0.9f);
}else{
if (card) CardGui::alternateRender(card,mFont,NULL,mX + SCREEN_WIDTH/2 + 100 + 20,133,0, 0.9f);
//TODO
}
mFont->SetColor(ARGB(255,255,255,0));
}else{
mFont->SetColor(ARGB(255,255,255,255));
}
if (!quantity){
mFont->SetColor(ARGB(255,128,128,128));
}
mFont->SetScale(mScale);
mFont->DrawString(mText.c_str(),mX + 30,mY);
}
void ShopItem::Update(float dt)
{
if (mScale < mTargetScale)
{
mScale += 8.0f*dt;
if (mScale > mTargetScale)
mScale = mTargetScale;
}
else if (mScale > mTargetScale)
{
mScale -= 8.0f*dt;
if (mScale < mTargetScale)
mScale = mTargetScale;
}
}
void ShopItem::Entering()
{
mHasFocus = true;
mTargetScale = 1.2f;
}
bool ShopItem::Leaving(u32 key)
{
mHasFocus = false;
mTargetScale = 1.0f;
return true;
}
bool ShopItem::ButtonPressed()
{
return (quantity >0);
}
ShopItems::ShopItems(int id, JGuiListener* listener, JLBFont* font, int x, int y, MTGAllCards * _collection, int _setId): JGuiController(id, listener), mX(x), mY(y), mFont(font), collection(_collection), setId(_setId){
mHeight = 0;
showPriceDialog = -1;
dialog = NULL;
pricelist = NEW PriceList("Res/settings/prices.dat",_collection);
playerdata = NEW PlayerData(_collection);
display = NULL;
}
void ShopItems::Add(int cardid){
int rnd = (rand() % 20);
int price = pricelist->getPrice(cardid);
price = price + price * (rnd -10)/100;
JGuiController::Add(NEW ShopItem(mCount, mFont, cardid, mX + 10, mY + 10 + mHeight, (mCount == 0),collection, price));
mHeight += 40;
}
void ShopItems::Add(char * text, JQuad * quad,JQuad * thumb, int price){
JGuiController::Add(NEW ShopItem(mCount, mFont, text, quad, thumb, mX + 10, mY + 10 + mHeight, (mCount == 0), price));
mHeight += 40;
}
void ShopItems::Update(float dt){
if (display){
display->CheckUserInput(dt);
if (display) display->Update(dt);
}else{
if (showPriceDialog!=-1){
ShopItem * item = ((ShopItem *)mObjects[showPriceDialog]);
int price = item->price;
char buffer[4096];
sprintf(buffer,"%s : %i credits",item->getText(),price);
if(!dialog){
dialog = NEW SimpleMenu(1,this,mFont,SCREEN_WIDTH-300,SCREEN_HEIGHT/2,270,buffer);
dialog->Add(1,"Yes");
dialog->Add(2,"No");
}
else{
dialog->Update(dt);
}
}else{
SAFE_DELETE(dialog);
JGuiController::Update(dt);
}
}
}
void ShopItems::Render(){
JGuiController::Render();
if (showPriceDialog==-1){
}else{
if(dialog){
dialog->Render();
}
}
char credits[512];
sprintf(credits,"credits: %i", playerdata->credits);
mFont->SetScale(1.2);
mFont->SetColor(ARGB(200,0,0,0));
mFont->DrawString(credits,SCREEN_WIDTH-148, SCREEN_HEIGHT - 13);
mFont->SetColor(ARGB(255,255,255,255));
mFont->DrawString(credits,SCREEN_WIDTH-150, SCREEN_HEIGHT - 15);
if (display) display->Render();
}
void ShopItems::pricedialog(int id, int mode){
if (mode){
showPriceDialog = id;
}else{
showPriceDialog = -1;
}
}
void ShopItems::ButtonPressed(int controllerId, int controlId){
if (controllerId == 12){
safeDeleteDisplay();
return;
}
ShopItem * item = ((ShopItem *)mObjects[showPriceDialog]);
int price = item->price;
switch(controlId){
case 1:
if (playerdata->credits >= price){
playerdata->credits -= price;
if (item->card){
int rnd = (rand() % 5);
price = price + (rnd * price)/100;
pricelist->setPrice(item->card->getMTGId(),price);
playerdata->collection->add(item->card);
item->quantity--;
}else{
safeDeleteDisplay();
display = new CardDisplay(12,NULL, SCREEN_WIDTH - 200, SCREEN_HEIGHT/2,this,NULL,5);
int curNbcards = playerdata->collection->totalCards();
if (showPriceDialog == 0){
//Starter Deck
playerdata->collection->addRandomCards(3,setId,RARITY_R,NULL);
playerdata->collection->addRandomCards(9, setId,RARITY_U,NULL);
playerdata->collection->addRandomCards(48, setId,RARITY_C,NULL);
}else{
//Booster
playerdata->collection->addRandomCards(1, setId,RARITY_R);
playerdata->collection->addRandomCards(3, setId,RARITY_U);
playerdata->collection->addRandomCards(11, setId,RARITY_C);
}
int newNbCards = playerdata->collection->totalCards();;
for (int i = curNbcards; i < newNbCards ; i++){
MTGCardInstance * card = NEW MTGCardInstance(playerdata->collection->_(i), NULL);
displayCards[i-curNbcards] = card;
display->AddCard(card);
}
}
//Remove(showPriceDialog);
showPriceDialog = -1;
}else{
//error not enough money
}
break;
case 2:
if (item->card){
int rnd = (rand() % 5);
price = price - (rnd * price)/100;
pricelist->setPrice(item->card->getMTGId(),price);
}
showPriceDialog = -1;
break;
}
}
void ShopItems::safeDeleteDisplay(){
if (!display) return;
for (int i = 0; i < display->mCount; i++){
delete displayCards[i];
}
SAFE_DELETE(display);
}
void ShopItems::saveAll(){
savePriceList();
playerdata->save();
}
void ShopItems::savePriceList(){
pricelist->save();
}
ShopItems::~ShopItems(){
SAFE_DELETE(pricelist);
SAFE_DELETE(playerdata);
SAFE_DELETE(dialog);
safeDeleteDisplay();
}

68
projects/mtg/src/SimpleMenu.cpp
View File

@@ -1,34 +1,34 @@
#include "../include/debug.h"
#include "../include/SimpleMenu.h"
#include "../include/SimpleMenuItem.h"
SimpleMenu::SimpleMenu(int id, JGuiListener* listener, JLBFont* font, int x, int y, int width, const char * _title): JGuiController(id, listener){
mHeight = 0;
mWidth = width;
mX = x;
mY = y;
mFont = font;
if (_title){
displaytitle = 1;
title = _title;
mHeight = 20;
}else{
displaytitle = 0;
}
}
void SimpleMenu::Render(){
mFont->SetColor(ARGB(255,255,255,255));
JRenderer * renderer = JRenderer::GetInstance();
renderer->FillRect(0,0,SCREEN_WIDTH,SCREEN_HEIGHT,ARGB(70,0,0,0));
renderer->FillRoundRect(mX,mY,mWidth,mHeight,10,ARGB(255,17,17,17));
renderer->FillRoundRect(mX+2,mY+2,mWidth - 4,mHeight-4,10,ARGB(255,62,62,62));
if (displaytitle)
mFont->DrawString(title.c_str(), mX+10, mY+10);
JGuiController::Render();
}
void SimpleMenu::Add(int id, const char * text){
JGuiController::Add(NEW SimpleMenuItem(id, mFont, text, mWidth/2 + mX + 10, mY + 10 + mHeight, (mCount == 0)));
mHeight += 20;
}
#include "../include/debug.h"
#include "../include/SimpleMenu.h"
#include "../include/SimpleMenuItem.h"
SimpleMenu::SimpleMenu(int id, JGuiListener* listener, JLBFont* font, int x, int y, int width, const char * _title): JGuiController(id, listener){
mHeight = 0;
mWidth = width;
mX = x;
mY = y;
mFont = font;
if (_title){
displaytitle = 1;
title = _title;
mHeight = 20;
}else{
displaytitle = 0;
}
}
void SimpleMenu::Render(){
mFont->SetColor(ARGB(255,255,255,255));
JRenderer * renderer = JRenderer::GetInstance();
renderer->FillRect(0,0,SCREEN_WIDTH,SCREEN_HEIGHT,ARGB(70,0,0,0));
renderer->FillRoundRect(mX,mY,mWidth,mHeight,10,ARGB(255,17,17,17));
renderer->FillRoundRect(mX+2,mY+2,mWidth - 4,mHeight-4,10,ARGB(255,62,62,62));
if (displaytitle)
mFont->DrawString(title.c_str(), mX+10, mY+10);
JGuiController::Render();
}
void SimpleMenu::Add(int id, const char * text){
JGuiController::Add(NEW SimpleMenuItem(id, mFont, text, mWidth/2 + mX + 10, mY + 10 + mHeight, (mCount == 0)));
mHeight += 20;
}

150
projects/mtg/src/SimpleMenuItem.cpp
View File

@@ -1,75 +1,75 @@
#include "../include/debug.h"
#include "../include/SimpleMenuItem.h"
SimpleMenuItem::SimpleMenuItem(int id, JLBFont *font, const char* text, int x, int y, bool hasFocus): JGuiObject(id), mFont(font), mText(text), mX(x), mY(y)
{
mHasFocus = hasFocus;
mScale = 1.0f;
mTargetScale = 1.0f;
if (hasFocus)
Entering();
mFont->SetScale(1.2f);
}
void SimpleMenuItem::Render()
{
mFont->SetScale(mScale);
mFont->SetColor(ARGB(255,255,255,255));
if (mHasFocus)
{
mFont->SetColor(ARGB(255,255,255,0));
}
mFont->DrawString(mText, mX, mY, JGETEXT_CENTER);
mFont->SetScale(1.0f);
}
void SimpleMenuItem::Update(float dt)
{
if (mScale < mTargetScale)
{
mScale += 8.0f*dt;
if (mScale > mTargetScale)
mScale = mTargetScale;
}
else if (mScale > mTargetScale)
{
mScale -= 8.0f*dt;
if (mScale < mTargetScale)
mScale = mTargetScale;
}
}
void SimpleMenuItem::Entering()
{
mHasFocus = true;
mTargetScale = 1.2f;
}
bool SimpleMenuItem::Leaving(u32 key)
{
mHasFocus = false;
mTargetScale = 1.0f;
return true;
}
bool SimpleMenuItem::ButtonPressed()
{
return true;
}
#include "../include/debug.h"
#include "../include/SimpleMenuItem.h"
SimpleMenuItem::SimpleMenuItem(int id, JLBFont *font, const char* text, int x, int y, bool hasFocus): JGuiObject(id), mFont(font), mText(text), mX(x), mY(y)
{
mHasFocus = hasFocus;
mScale = 1.0f;
mTargetScale = 1.0f;
if (hasFocus)
Entering();
mFont->SetScale(1.2f);
}
void SimpleMenuItem::Render()
{
mFont->SetScale(mScale);
mFont->SetColor(ARGB(255,255,255,255));
if (mHasFocus)
{
mFont->SetColor(ARGB(255,255,255,0));
}
mFont->DrawString(mText, mX, mY, JGETEXT_CENTER);
mFont->SetScale(1.0f);
}
void SimpleMenuItem::Update(float dt)
{
if (mScale < mTargetScale)
{
mScale += 8.0f*dt;
if (mScale > mTargetScale)
mScale = mTargetScale;
}
else if (mScale > mTargetScale)
{
mScale -= 8.0f*dt;
if (mScale < mTargetScale)
mScale = mTargetScale;
}
}
void SimpleMenuItem::Entering()
{
mHasFocus = true;
mTargetScale = 1.2f;
}
bool SimpleMenuItem::Leaving(u32 key)
{
mHasFocus = false;
mTargetScale = 1.0f;
return true;
}
bool SimpleMenuItem::ButtonPressed()
{
return true;
}

90
projects/mtg/src/Subtypes.cpp
View File

@@ -1,45 +1,45 @@
#include "../include/debug.h"
#include "../include/Subtypes.h"
#include <JGE.h>
#include <algorithm>
Subtypes * Subtypes::subtypesList = NEW Subtypes();
Subtypes::Subtypes(){
nb_items = 100;
}
int Subtypes::Add(string value){
int result = find(value);
if (result) return result;
#if defined (WIN32) || defined (LINUX)
char buf[4096];
sprintf(buf, "Adding new type: *%s*\n",value.c_str());
OutputDebugString(buf);
#endif
std::transform( value.begin(), value.end(), value.begin(), ::tolower );
nb_items++;
values[value] = nb_items;
return nb_items;
}
int Subtypes::Add(const char * subtype){
string value = subtype;
return Add(value);
}
int Subtypes::find(string value){
std::transform( value.begin(), value.end(), value.begin(), ::tolower );
map<string,int>::iterator it = values.find(value);
if (it != values.end()) return it->second;
return 0;
}
int Subtypes::find(const char * subtype){
string value = subtype;
return (find(value));
}
#include "../include/debug.h"
#include "../include/Subtypes.h"
#include <JGE.h>
#include <algorithm>
Subtypes * Subtypes::subtypesList = NEW Subtypes();
Subtypes::Subtypes(){
nb_items = 100;
}
int Subtypes::Add(string value){
int result = find(value);
if (result) return result;
#if defined (WIN32) || defined (LINUX)
char buf[4096];
sprintf(buf, "Adding new type: *%s*\n",value.c_str());
OutputDebugString(buf);
#endif
std::transform( value.begin(), value.end(), value.begin(), ::tolower );
nb_items++;
values[value] = nb_items;
return nb_items;
}
int Subtypes::Add(const char * subtype){
string value = subtype;
return Add(value);
}
int Subtypes::find(string value){
std::transform( value.begin(), value.end(), value.begin(), ::tolower );
map<string,int>::iterator it = values.find(value);
if (it != values.end()) return it->second;
return 0;
}
int Subtypes::find(const char * subtype){
string value = subtype;
return (find(value));
}

1194
projects/mtg/src/TargetChooser.cpp
View File

File diff suppressed because it is too large Load Diff

228
projects/mtg/src/TargetsList.cpp
View File

@@ -1,129 +1,129 @@
#include "../include/debug.h"
#include "../include/TargetsList.h"
#include "../include/Player.h"
#include "../include/MTGCardInstance.h"
#include "../include/Damage.h"
#include "../include/ActionStack.h"
TargetsList::TargetsList(){
cursor = 0;
}
TargetsList::TargetsList(Targetable * _targets[], int nbtargets){
for (int i = 0; i < nbtargets; i++){
targets[i] = _targets[i];
}
cursor = nbtargets;
}
int TargetsList::addTarget(Targetable * target){
if (!alreadyHasTarget(target)){
targets[cursor] = target;
cursor++;
return 1;
}
return 0;
}
int TargetsList::alreadyHasTarget(Targetable * target){
for (int i=0; i<cursor; i++){
if (targets[i] == target) return 1;
}
return 0;
}
int TargetsList::removeTarget(Targetable * target){
for (int i=0; i<cursor; i++){
if (targets[i] == target) {
targets[i] = targets[cursor];
targets[cursor] = NULL;
cursor--;
}
}
return 0;
}
int TargetsList::toggleTarget(Targetable * target){
if (alreadyHasTarget(target)){
return removeTarget(target);
}else{
return addTarget(target);
}
}
Targetable * TargetsList::getNextTarget(Targetable * previous, int type){
int found = 0;
if (!previous) found = 1;
for (int i = 0; i < cursor; i++){
if (found && targets[i]->typeAsTarget() == type){
return (targets[i]);
}
if (targets[i] == previous) found = 1;
}
return NULL;
}
#include "../include/debug.h"
#include "../include/TargetsList.h"
#include "../include/Player.h"
#include "../include/MTGCardInstance.h"
#include "../include/Damage.h"
#include "../include/ActionStack.h"
TargetsList::TargetsList(){
cursor = 0;
}
TargetsList::TargetsList(Targetable * _targets[], int nbtargets){
for (int i = 0; i < nbtargets; i++){
targets[i] = _targets[i];
}
cursor = nbtargets;
}
int TargetsList::addTarget(Targetable * target){
if (!alreadyHasTarget(target)){
targets[cursor] = target;
cursor++;
return 1;
}
return 0;
}
int TargetsList::alreadyHasTarget(Targetable * target){
for (int i=0; i<cursor; i++){
if (targets[i] == target) return 1;
}
return 0;
}
int TargetsList::removeTarget(Targetable * target){
for (int i=0; i<cursor; i++){
if (targets[i] == target) {
targets[i] = targets[cursor];
targets[cursor] = NULL;
cursor--;
}
}
return 0;
}
int TargetsList::toggleTarget(Targetable * target){
if (alreadyHasTarget(target)){
return removeTarget(target);
}else{
return addTarget(target);
}
}
Targetable * TargetsList::getNextTarget(Targetable * previous, int type){
int found = 0;
if (!previous) found = 1;
for (int i = 0; i < cursor; i++){
if (found && targets[i]->typeAsTarget() == type){
return (targets[i]);
}
if (targets[i] == previous) found = 1;
}
return NULL;
}
MTGCardInstance * TargetsList::getNextCardTarget(MTGCardInstance * previous){
return ((MTGCardInstance *)getNextTarget(previous, TARGET_CARD));
return ((MTGCardInstance *)getNextTarget(previous, TARGET_CARD));
}
Player * TargetsList::getNextPlayerTarget(Player * previous){
return ((Player *)getNextTarget(previous, TARGET_PLAYER));
return ((Player *)getNextTarget(previous, TARGET_PLAYER));
}
Interruptible * TargetsList::getNextInterruptible(Interruptible * previous, int type){
int found = 0;
if (!previous) found = 1;
for (int i = 0; i < cursor; i++){
if (found && targets[i]->typeAsTarget() == TARGET_STACKACTION){
Interruptible * action = (Interruptible *) targets[i];
if (action->type==type){
return action;
}
}
if (targets[i] == previous) found = 1;
}
return NULL;
}
Interruptible * TargetsList::getNextInterruptible(Interruptible * previous, int type){
int found = 0;
if (!previous) found = 1;
for (int i = 0; i < cursor; i++){
if (found && targets[i]->typeAsTarget() == TARGET_STACKACTION){
Interruptible * action = (Interruptible *) targets[i];
if (action->type==type){
return action;
}
}
if (targets[i] == previous) found = 1;
}
return NULL;
}
Spell * TargetsList::getNextSpellTarget(Spell * previous){
Spell * spell = (Spell *) getNextInterruptible(previous, ACTION_SPELL);
return spell;
Spell * spell = (Spell *) getNextInterruptible(previous, ACTION_SPELL);
return spell;
}
//How about DAMAGESTacks ??
Damage * TargetsList::getNextDamageTarget(Damage * previous){
Damage * damage = (Damage * ) getNextInterruptible(previous, ACTION_DAMAGE);
return damage;
Damage * damage = (Damage * ) getNextInterruptible(previous, ACTION_DAMAGE);
return damage;
}
Damageable * TargetsList::getNextDamageableTarget(Damageable * previous){
int found = 0;
if (!previous) found = 1;
for (int i = 0; i < cursor; i++){
int found = 0;
if (!previous) found = 1;
for (int i = 0; i < cursor; i++){
if (targets[i]->typeAsTarget() == TARGET_PLAYER){
if (found){
return ((Player *) targets[i]);
}else{
if ((Player *)targets[i] == previous) found = 1;
}
}else if(targets[i]->typeAsTarget() == TARGET_CARD){
if (found){
return ((MTGCardInstance *) targets[i]);
}else{
if ((MTGCardInstance *)targets[i] == previous) found = 1;
}
}
}
return NULL;
}
if (targets[i]->typeAsTarget() == TARGET_PLAYER){
if (found){
return ((Player *) targets[i]);
}else{
if ((Player *)targets[i] == previous) found = 1;
}
}else if(targets[i]->typeAsTarget() == TARGET_CARD){
if (found){
return ((MTGCardInstance *) targets[i]);
}else{
if ((MTGCardInstance *)targets[i] == previous) found = 1;
}
}
}
return NULL;
}

942
projects/mtg/src/TestSuiteAI.cpp
View File

@@ -1,471 +1,471 @@
#include "../include/TestSuiteAI.h"
#include "../include/debug.h"
#include <string>
using std::string;
TestSuiteAI::TestSuiteAI(MTGAllCards* collection, TestSuite * _suite, int playerId):AIPlayer(_suite->buildDeck(collection, playerId),"testsuite"){
suite = _suite;
timer= 0;
mAvatarTex = JRenderer::GetInstance()->LoadTexture("ai/baka/avatar.jpg", TEX_TYPE_USE_VRAM);
if (mAvatarTex){
mAvatar = NEW JQuad(mAvatarTex, 0, 0, 35, 50);
}
}
MTGCardInstance * TestSuite::getCardByMTGId(int mtgid){
GameObserver * g = GameObserver::GetInstance();
for (int i = 0; i < 2; i++){
Player * p = g->players[i];
MTGGameZone * zones[] = {p->game->library,p->game->hand, p->game->inPlay, p->game->graveyard};
for (int j = 0; j < 4; j++){
MTGGameZone * zone = zones[j];
for (int k = 0; k < zone->nb_cards; k++){
MTGCardInstance * card = zone->cards[k];
if (!card) OutputDebugString ("wtf ?");
if (card->getMTGId() == mtgid) return card;
}
}
}
return NULL;
}
Interruptible * TestSuite::getActionByMTGId(int mtgid){
ActionStack * as= GameObserver::GetInstance()->mLayers->stackLayer();
Interruptible * action = NULL;
while ((action = as->getNext(action,0,0,1))){
if (action->source && action->source->getMTGId() == mtgid){
return action;
}
}
return NULL;
}
int TestSuiteAI::Act(float dt){
GameObserver * g = GameObserver::GetInstance();
g->gameOver = NULL; // Prevent draw rule from losing the game
timer+= dt;
if (timer < suite->timerLimit) return 1;
timer = 0;
string action = suite->getNextAction();
if (g->mLayers->stackLayer()->askIfWishesToInterrupt == this){
if(action.compare("no") != 0 && action.compare("yes") != 0){
g->mLayers->stackLayer()->cancelInterruptOffer();
suite->currentAction--;
return 1;
}
}
if (action == ""){
//end of game
suite->assertGame();
g->gameOver = g->players[0];
return 1;
}
if (action.compare("eot")== 0){
if (g->getCurrentGamePhase() != MTG_PHASE_CLEANUP) suite->currentAction--;
g->userRequestNextGamePhase();
}
else if (action.compare("next")==0){
g->userRequestNextGamePhase();
}else if (action.compare("yes")==0){
g->mLayers->stackLayer()->setIsInterrupting(this);
}else if (action.compare("endinterruption")==0){
g->mLayers->stackLayer()->endOfInterruption();
}else if(action.compare("no")==0){
if (g->mLayers->stackLayer()->askIfWishesToInterrupt == this){
g->mLayers->stackLayer()->cancelInterruptOffer();
}
}else{
int mtgid = atoi(action.c_str());
if (mtgid){
MTGCardInstance * card = suite->getCardByMTGId(mtgid);
if (card) {
g->cardClick(card);
}else{
Interruptible * action = suite->getActionByMTGId(mtgid);
if (action){
g->stackObjectClicked(action);
}
}
}else{
return 0;
}
}
return 1;
}
TestSuiteActions::TestSuiteActions(){
nbitems = 0;
}
void TestSuiteActions::add(string s){
actions[nbitems] = s;
nbitems++;
}
TestSuitePlayerData::TestSuitePlayerData(){
life = 20;
manapool = NEW ManaCost();
}
TestSuitePlayerData::~TestSuitePlayerData(){
SAFE_DELETE(manapool);
}
TestSuitePlayerZone::TestSuitePlayerZone(){
nbitems = 0;
}
void TestSuitePlayerZone::add(int cardId){
cards[nbitems] = cardId;
nbitems++;
}
TestSuiteState::TestSuiteState(){
}
void TestSuiteState::parsePlayerState(int playerId, string s){
unsigned int limiter = s.find(":");
string areaS;
int area;
if (limiter != string::npos){
areaS = s.substr(0,limiter);
if (areaS.compare("graveyard") == 0){
area = 0;
}else if(areaS.compare("library") == 0){
area = 1;
}else if(areaS.compare("hand") == 0){
area = 2;
}else if(areaS.compare("inplay") == 0 ){
area = 3;
}else if(areaS.compare("life") == 0){
playerData[playerId].life = atoi((s.substr(limiter+1)).c_str());
return;
}else if(areaS.compare("manapool") == 0){
SAFE_DELETE(playerData[playerId].manapool);
playerData[playerId].manapool = ManaCost::parseManaCost(s.substr(limiter+1));
return;
}else{
return; // ERROR
}
s = s.substr(limiter+1);
while (s.size()){
unsigned int value;
limiter = s.find(",");
if (limiter != string::npos){
value = atoi(s.substr(0,limiter).c_str());
s = s.substr(limiter+1);
}else{
value = atoi(s.c_str());
s = "";
}
playerData[playerId].zones[area].add(value);
}
}else{
//ERROR
}
}
string TestSuite::getNextAction(){
if (actions.nbitems && currentAction < actions.nbitems){
currentAction++;
return actions.actions[currentAction-1];
}
return "";
}
MTGPlayerCards * TestSuite::buildDeck(MTGAllCards * collection, int playerId){
char buf[4096];
int list[100];
int nbcards = 0;
for (int j = 0; j < 4; j++){
for (int k = 0; k < initState.playerData[playerId].zones[j].nbitems; k++){
int cardid = initState.playerData[playerId].zones[j].cards[k];
list[nbcards] = cardid;
nbcards++;
}
}
MTGPlayerCards * deck = NEW MTGPlayerCards(collection, list, nbcards);
return deck;
}
void TestSuite::initGame(){
//The first test runs slowly, the other ones run faster.
//This way a human can see what happens when testing a specific file,
// or go faster when it comes to the whole test suite.
//Warning, putting this value too low (< 0.25) will give unexpected results
if (!timerLimit){
timerLimit = 0.3;
}else{
timerLimit = 0.26;
}
//Put the GameObserver in the initial state
GameObserver * g = GameObserver::GetInstance();
OutputDebugString("Init Game\n");
g->phaseRing->goToPhase(initState.phase, g->players[0]);
g->currentGamePhase = initState.phase;
for (int i = 0; i < 2; i++){
Player * p = g->players[i];
p->life = initState.playerData[i].life;
p->getManaPool()->copy(initState.playerData[i].manapool);
MTGGameZone * playerZones[] = {p->game->graveyard, p->game->library, p->game->hand, p->game->inPlay};
for (int j = 0; j < 4; j++){
MTGGameZone * zone = playerZones[j];
for (int k = 0; k < initState.playerData[i].zones[j].nbitems; k++){
MTGCardInstance * card = getCardByMTGId(initState.playerData[i].zones[j].cards[k]);
if (card && zone != p->game->library){
if (zone == p->game->inPlay){
p->game->putInZone(card, p->game->library, p->game->hand);
Spell * spell = NEW Spell(card);
p->game->putInZone(card, p->game->hand, p->game->stack);
spell->resolve();
card->summoningSickness = 0;
delete spell;
}else{
if (!p->game->library->hasCard(card)){
LOG ("ERROR, CARD NOT FOUND IN LIBRARY\n");
}
p->game->putInZone(card,p->game->library,zone);
}
}
}
}
}
OutputDebugString("Init Game Done !\n");
}
int TestSuite::Log(const char * text){
ofstream file ("Res/test/results.html",ios_base::app);
if (file){
file << text;
file << "\n";
file.close();
}
#if defined (WIN32) || defined (LINUX)
OutputDebugString(text);
OutputDebugString("\n");
#endif
return 1;
}
int TestSuite::assertGame(){
//compare the game state with the results
char result[4096];
sprintf(result,"<h3>%s</h3>",files[currentfile-1].c_str());
Log(result);
int error = 0;
GameObserver * g = GameObserver::GetInstance();
if (g->currentGamePhase != endState.phase){
sprintf(result, "<span class=\"error\">==phase problem. Expected %i, got %i==</span><br />",endState.phase, g->currentGamePhase);
Log(result);
error++;
}
for (int i = 0; i < 2; i++){
Player * p = g->players[i];
if (p->life != endState.playerData[i].life){
sprintf(result, "<span class=\"error\">==life problem for player %i. Expected %i, got %i==</span><br />",i,endState.playerData[i].life, p->life);
Log(result);
error++;
}
if (! p->getManaPool()->canAfford(endState.playerData[i].manapool)){
sprintf(result, "<span class=\"error\">==Mana problem. Was expecting %i but got %i for player %i==</span><br />",endState.playerData[i].manapool->getConvertedCost(),p->getManaPool()->getConvertedCost(),i);
Log(result);
error++;
}
if(! endState.playerData[i].manapool->canAfford(p->getManaPool())){
sprintf(result, "<span class=\"error\">==Mana problem. Was expecting %i but got %i for player %i==</span><br />",endState.playerData[i].manapool->getConvertedCost(),p->getManaPool()->getConvertedCost(),i);
Log(result);
error++;
}
MTGGameZone * playerZones[] = {p->game->graveyard, p->game->library, p->game->hand, p->game->inPlay};
for (int j = 0; j < 4; j++){
MTGGameZone * zone = playerZones[j];
if (zone->nb_cards != endState.playerData[i].zones[j].nbitems){
Log("<span class=\"error\">==Card number not the same==</span><br />");
error++;
return 0;
}
for (int k = 0; k < endState.playerData[i].zones[j].nbitems; k++){
int cardid = endState.playerData[i].zones[j].cards[k];
int realcardid = zone->cards[k]->getMTGId();
if ( realcardid!= cardid){
sprintf(result, "<span class=\"error\">==Card ID not the same. Expected %i, got %i==</span><br />", cardid, realcardid);
Log(result);
error++;
}
}
}
}
if (error) return 0;
Log("<span class=\"success\">==Test Succesful !==</span>");
return 1;
}
TestSuite::TestSuite(const char * filename){
timerLimit = 0;
std::ifstream file(filename);
std::string s;
nbfiles = 0;
currentfile = 0;
int comment = 0;
if(file){
while(std::getline(file,s)){
if (s[0] == '/' && s[1] == '*') comment = 1;
if (s[0] && s[0] != '#' && !comment){
files[nbfiles] = s;
nbfiles++;
}
if (s[0] == '*' && s[1] == '/') comment = 0;
}
file.close();
}
ofstream file2 ("Res/test/results.html");
if (file2){
file2 << "<html><head>";
file2 << "<meta http-equiv=\"refresh\" content=\"10\" >";
file2 << "<STYLE type='text/css'>";
file2 << ".success {color:green}\n";
file2 << ".error {color:red}\n";
file2 << "</STYLE></head><body>\n";
file2.close();
}
}
int TestSuite::loadNext(){
if (!nbfiles) return 0;
if (currentfile >= nbfiles) return 0;
load(files[currentfile].c_str());
currentfile++;
return currentfile;
}
//TODO PArses a string and gives phase numer
int TestSuite::phaseStrToInt(string s){
if (s.compare("untap") == 0) return MTG_PHASE_UNTAP;
if (s.compare("upkeep") == 0)return MTG_PHASE_UPKEEP;
if (s.compare("draw") == 0)return MTG_PHASE_DRAW;
if (s.compare("firstmain") == 0)return MTG_PHASE_FIRSTMAIN;
if (s.compare("combatbegin") == 0)return MTG_PHASE_COMBATBEGIN;
if (s.compare("combatattackers") == 0)return MTG_PHASE_COMBATATTACKERS;
if (s.compare("combatblockers") == 0)return MTG_PHASE_COMBATBLOCKERS;
if (s.compare("combatdamage") == 0)return MTG_PHASE_COMBATDAMAGE;
if (s.compare("combatend") == 0)return MTG_PHASE_COMBATEND;
if (s.compare("secondmain") == 0)return MTG_PHASE_SECONDMAIN;
if (s.compare("endofturn") == 0)return MTG_PHASE_ENDOFTURN;
if (s.compare("cleanup") == 0)return MTG_PHASE_CLEANUP;
return -1;
}
void TestSuiteActions::cleanup(){
nbitems = 0;
}
void TestSuitePlayerZone::cleanup(){
nbitems = 0;
}
void TestSuitePlayerData::cleanup(){
if (manapool) delete manapool;
manapool = NULL;
manapool = NEW ManaCost();
for (int i = 0; i < 5; i++){
zones[i].cleanup();
}
life=20;
}
void TestSuiteState::cleanup(){
for (int i = 0; i < 2; i++){
playerData[i].cleanup();
}
}
void TestSuite::cleanup(){
currentAction = 0;
initState.cleanup();
endState.cleanup();
actions.cleanup();
}
void TestSuite::load(const char * _filename){
char filename[4096];
sprintf(filename, "Res/test/%s", _filename);
std::ifstream file(filename);
std::string s;
int state = -1;
if(file){
cleanup();
while(std::getline(file,s)){
std::transform( s.begin(), s.end(), s.begin(),::tolower );
switch(state){
case -1:
if (s.compare("[init]") == 0) state++;
break;
case 0:
if (s.compare("[player1]") == 0){
state++;
}else{
initState.phase = phaseStrToInt(s);
}
break;
case 1:
if (s.compare("[player2]") == 0){
state++;
}else{
initState.parsePlayerState(0, s);
}
break;
case 2:
if (s.compare("[do]") == 0){
state++;
}else{
initState.parsePlayerState(1, s);
}
break;
case 3:
if (s.compare("[assert]") == 0){
state++;
}else{
actions.add(s);
}
break;
case 4:
if (s.compare("[player1]") == 0){
state++;
}else{
endState.phase = phaseStrToInt(s);
}
break;
case 5:
if (s.compare("[player2]") == 0){
state++;
}else{
endState.parsePlayerState(0, s);
}
break;
case 6:
if (s.compare("[end]") == 0){
state++;
}else{
endState.parsePlayerState(1, s);
}
break;
}
}
file.close();
}else{
//TODO Error management
}
}
#include "../include/TestSuiteAI.h"
#include "../include/debug.h"
#include <string>
using std::string;
TestSuiteAI::TestSuiteAI(MTGAllCards* collection, TestSuite * _suite, int playerId):AIPlayer(_suite->buildDeck(collection, playerId),"testsuite"){
suite = _suite;
timer= 0;
mAvatarTex = JRenderer::GetInstance()->LoadTexture("ai/baka/avatar.jpg", TEX_TYPE_USE_VRAM);
if (mAvatarTex){
mAvatar = NEW JQuad(mAvatarTex, 0, 0, 35, 50);
}
}
MTGCardInstance * TestSuite::getCardByMTGId(int mtgid){
GameObserver * g = GameObserver::GetInstance();
for (int i = 0; i < 2; i++){
Player * p = g->players[i];
MTGGameZone * zones[] = {p->game->library,p->game->hand, p->game->inPlay, p->game->graveyard};
for (int j = 0; j < 4; j++){
MTGGameZone * zone = zones[j];
for (int k = 0; k < zone->nb_cards; k++){
MTGCardInstance * card = zone->cards[k];
if (!card) OutputDebugString ("wtf ?");
if (card->getMTGId() == mtgid) return card;
}
}
}
return NULL;
}
Interruptible * TestSuite::getActionByMTGId(int mtgid){
ActionStack * as= GameObserver::GetInstance()->mLayers->stackLayer();
Interruptible * action = NULL;
while ((action = as->getNext(action,0,0,1))){
if (action->source && action->source->getMTGId() == mtgid){
return action;
}
}
return NULL;
}
int TestSuiteAI::Act(float dt){
GameObserver * g = GameObserver::GetInstance();
g->gameOver = NULL; // Prevent draw rule from losing the game
timer+= dt;
if (timer < suite->timerLimit) return 1;
timer = 0;
string action = suite->getNextAction();
if (g->mLayers->stackLayer()->askIfWishesToInterrupt == this){
if(action.compare("no") != 0 && action.compare("yes") != 0){
g->mLayers->stackLayer()->cancelInterruptOffer();
suite->currentAction--;
return 1;
}
}
if (action == ""){
//end of game
suite->assertGame();
g->gameOver = g->players[0];
return 1;
}
if (action.compare("eot")== 0){
if (g->getCurrentGamePhase() != MTG_PHASE_CLEANUP) suite->currentAction--;
g->userRequestNextGamePhase();
}
else if (action.compare("next")==0){
g->userRequestNextGamePhase();
}else if (action.compare("yes")==0){
g->mLayers->stackLayer()->setIsInterrupting(this);
}else if (action.compare("endinterruption")==0){
g->mLayers->stackLayer()->endOfInterruption();
}else if(action.compare("no")==0){
if (g->mLayers->stackLayer()->askIfWishesToInterrupt == this){
g->mLayers->stackLayer()->cancelInterruptOffer();
}
}else{
int mtgid = atoi(action.c_str());
if (mtgid){
MTGCardInstance * card = suite->getCardByMTGId(mtgid);
if (card) {
g->cardClick(card);
}else{
Interruptible * action = suite->getActionByMTGId(mtgid);
if (action){
g->stackObjectClicked(action);
}
}
}else{
return 0;
}
}
return 1;
}
TestSuiteActions::TestSuiteActions(){
nbitems = 0;
}
void TestSuiteActions::add(string s){
actions[nbitems] = s;
nbitems++;
}
TestSuitePlayerData::TestSuitePlayerData(){
life = 20;
manapool = NEW ManaCost();
}
TestSuitePlayerData::~TestSuitePlayerData(){
SAFE_DELETE(manapool);
}
TestSuitePlayerZone::TestSuitePlayerZone(){
nbitems = 0;
}
void TestSuitePlayerZone::add(int cardId){
cards[nbitems] = cardId;
nbitems++;
}
TestSuiteState::TestSuiteState(){
}
void TestSuiteState::parsePlayerState(int playerId, string s){
unsigned int limiter = s.find(":");
string areaS;
int area;
if (limiter != string::npos){
areaS = s.substr(0,limiter);
if (areaS.compare("graveyard") == 0){
area = 0;
}else if(areaS.compare("library") == 0){
area = 1;
}else if(areaS.compare("hand") == 0){
area = 2;
}else if(areaS.compare("inplay") == 0 ){
area = 3;
}else if(areaS.compare("life") == 0){
playerData[playerId].life = atoi((s.substr(limiter+1)).c_str());
return;
}else if(areaS.compare("manapool") == 0){
SAFE_DELETE(playerData[playerId].manapool);
playerData[playerId].manapool = ManaCost::parseManaCost(s.substr(limiter+1));
return;
}else{
return; // ERROR
}
s = s.substr(limiter+1);
while (s.size()){
unsigned int value;
limiter = s.find(",");
if (limiter != string::npos){
value = atoi(s.substr(0,limiter).c_str());
s = s.substr(limiter+1);
}else{
value = atoi(s.c_str());
s = "";
}
playerData[playerId].zones[area].add(value);
}
}else{
//ERROR
}
}
string TestSuite::getNextAction(){
if (actions.nbitems && currentAction < actions.nbitems){
currentAction++;
return actions.actions[currentAction-1];
}
return "";
}
MTGPlayerCards * TestSuite::buildDeck(MTGAllCards * collection, int playerId){
char buf[4096];
int list[100];
int nbcards = 0;
for (int j = 0; j < 4; j++){
for (int k = 0; k < initState.playerData[playerId].zones[j].nbitems; k++){
int cardid = initState.playerData[playerId].zones[j].cards[k];
list[nbcards] = cardid;
nbcards++;
}
}
MTGPlayerCards * deck = NEW MTGPlayerCards(collection, list, nbcards);
return deck;
}
void TestSuite::initGame(){
//The first test runs slowly, the other ones run faster.
//This way a human can see what happens when testing a specific file,
// or go faster when it comes to the whole test suite.
//Warning, putting this value too low (< 0.25) will give unexpected results
if (!timerLimit){
timerLimit = 0.3;
}else{
timerLimit = 0.26;
}
//Put the GameObserver in the initial state
GameObserver * g = GameObserver::GetInstance();
OutputDebugString("Init Game\n");
g->phaseRing->goToPhase(initState.phase, g->players[0]);
g->currentGamePhase = initState.phase;
for (int i = 0; i < 2; i++){
Player * p = g->players[i];
p->life = initState.playerData[i].life;
p->getManaPool()->copy(initState.playerData[i].manapool);
MTGGameZone * playerZones[] = {p->game->graveyard, p->game->library, p->game->hand, p->game->inPlay};
for (int j = 0; j < 4; j++){
MTGGameZone * zone = playerZones[j];
for (int k = 0; k < initState.playerData[i].zones[j].nbitems; k++){
MTGCardInstance * card = getCardByMTGId(initState.playerData[i].zones[j].cards[k]);
if (card && zone != p->game->library){
if (zone == p->game->inPlay){
p->game->putInZone(card, p->game->library, p->game->hand);
Spell * spell = NEW Spell(card);
p->game->putInZone(card, p->game->hand, p->game->stack);
spell->resolve();
card->summoningSickness = 0;
delete spell;
}else{
if (!p->game->library->hasCard(card)){
LOG ("ERROR, CARD NOT FOUND IN LIBRARY\n");
}
p->game->putInZone(card,p->game->library,zone);
}
}
}
}
}
OutputDebugString("Init Game Done !\n");
}
int TestSuite::Log(const char * text){
ofstream file ("Res/test/results.html",ios_base::app);
if (file){
file << text;
file << "\n";
file.close();
}
#if defined (WIN32) || defined (LINUX)
OutputDebugString(text);
OutputDebugString("\n");
#endif
return 1;
}
int TestSuite::assertGame(){
//compare the game state with the results
char result[4096];
sprintf(result,"<h3>%s</h3>",files[currentfile-1].c_str());
Log(result);
int error = 0;
GameObserver * g = GameObserver::GetInstance();
if (g->currentGamePhase != endState.phase){
sprintf(result, "<span class=\"error\">==phase problem. Expected %i, got %i==</span><br />",endState.phase, g->currentGamePhase);
Log(result);
error++;
}
for (int i = 0; i < 2; i++){
Player * p = g->players[i];
if (p->life != endState.playerData[i].life){
sprintf(result, "<span class=\"error\">==life problem for player %i. Expected %i, got %i==</span><br />",i,endState.playerData[i].life, p->life);
Log(result);
error++;
}
if (! p->getManaPool()->canAfford(endState.playerData[i].manapool)){
sprintf(result, "<span class=\"error\">==Mana problem. Was expecting %i but got %i for player %i==</span><br />",endState.playerData[i].manapool->getConvertedCost(),p->getManaPool()->getConvertedCost(),i);
Log(result);
error++;
}
if(! endState.playerData[i].manapool->canAfford(p->getManaPool())){
sprintf(result, "<span class=\"error\">==Mana problem. Was expecting %i but got %i for player %i==</span><br />",endState.playerData[i].manapool->getConvertedCost(),p->getManaPool()->getConvertedCost(),i);
Log(result);
error++;
}
MTGGameZone * playerZones[] = {p->game->graveyard, p->game->library, p->game->hand, p->game->inPlay};
for (int j = 0; j < 4; j++){
MTGGameZone * zone = playerZones[j];
if (zone->nb_cards != endState.playerData[i].zones[j].nbitems){
Log("<span class=\"error\">==Card number not the same==</span><br />");
error++;
return 0;
}
for (int k = 0; k < endState.playerData[i].zones[j].nbitems; k++){
int cardid = endState.playerData[i].zones[j].cards[k];
int realcardid = zone->cards[k]->getMTGId();
if ( realcardid!= cardid){
sprintf(result, "<span class=\"error\">==Card ID not the same. Expected %i, got %i==</span><br />", cardid, realcardid);
Log(result);
error++;
}
}
}
}
if (error) return 0;
Log("<span class=\"success\">==Test Succesful !==</span>");
return 1;
}
TestSuite::TestSuite(const char * filename){
timerLimit = 0;
std::ifstream file(filename);
std::string s;
nbfiles = 0;
currentfile = 0;
int comment = 0;
if(file){
while(std::getline(file,s)){
if (s[0] == '/' && s[1] == '*') comment = 1;
if (s[0] && s[0] != '#' && !comment){
files[nbfiles] = s;
nbfiles++;
}
if (s[0] == '*' && s[1] == '/') comment = 0;
}
file.close();
}
ofstream file2 ("Res/test/results.html");
if (file2){
file2 << "<html><head>";
file2 << "<meta http-equiv=\"refresh\" content=\"10\" >";
file2 << "<STYLE type='text/css'>";
file2 << ".success {color:green}\n";
file2 << ".error {color:red}\n";
file2 << "</STYLE></head><body>\n";
file2.close();
}
}
int TestSuite::loadNext(){
if (!nbfiles) return 0;
if (currentfile >= nbfiles) return 0;
load(files[currentfile].c_str());
currentfile++;
return currentfile;
}
//TODO PArses a string and gives phase numer
int TestSuite::phaseStrToInt(string s){
if (s.compare("untap") == 0) return MTG_PHASE_UNTAP;
if (s.compare("upkeep") == 0)return MTG_PHASE_UPKEEP;
if (s.compare("draw") == 0)return MTG_PHASE_DRAW;
if (s.compare("firstmain") == 0)return MTG_PHASE_FIRSTMAIN;
if (s.compare("combatbegin") == 0)return MTG_PHASE_COMBATBEGIN;
if (s.compare("combatattackers") == 0)return MTG_PHASE_COMBATATTACKERS;
if (s.compare("combatblockers") == 0)return MTG_PHASE_COMBATBLOCKERS;
if (s.compare("combatdamage") == 0)return MTG_PHASE_COMBATDAMAGE;
if (s.compare("combatend") == 0)return MTG_PHASE_COMBATEND;
if (s.compare("secondmain") == 0)return MTG_PHASE_SECONDMAIN;
if (s.compare("endofturn") == 0)return MTG_PHASE_ENDOFTURN;
if (s.compare("cleanup") == 0)return MTG_PHASE_CLEANUP;
return -1;
}
void TestSuiteActions::cleanup(){
nbitems = 0;
}
void TestSuitePlayerZone::cleanup(){
nbitems = 0;
}
void TestSuitePlayerData::cleanup(){
if (manapool) delete manapool;
manapool = NULL;
manapool = NEW ManaCost();
for (int i = 0; i < 5; i++){
zones[i].cleanup();
}
life=20;
}
void TestSuiteState::cleanup(){
for (int i = 0; i < 2; i++){
playerData[i].cleanup();
}
}
void TestSuite::cleanup(){
currentAction = 0;
initState.cleanup();
endState.cleanup();
actions.cleanup();
}
void TestSuite::load(const char * _filename){
char filename[4096];
sprintf(filename, "Res/test/%s", _filename);
std::ifstream file(filename);
std::string s;
int state = -1;
if(file){
cleanup();
while(std::getline(file,s)){
std::transform( s.begin(), s.end(), s.begin(),::tolower );
switch(state){
case -1:
if (s.compare("[init]") == 0) state++;
break;
case 0:
if (s.compare("[player1]") == 0){
state++;
}else{
initState.phase = phaseStrToInt(s);
}
break;
case 1:
if (s.compare("[player2]") == 0){
state++;
}else{
initState.parsePlayerState(0, s);
}
break;
case 2:
if (s.compare("[do]") == 0){
state++;
}else{
initState.parsePlayerState(1, s);
}
break;
case 3:
if (s.compare("[assert]") == 0){
state++;
}else{
actions.add(s);
}
break;
case 4:
if (s.compare("[player1]") == 0){
state++;
}else{
endState.phase = phaseStrToInt(s);
}
break;
case 5:
if (s.compare("[player2]") == 0){
state++;
}else{
endState.parsePlayerState(0, s);
}
break;
case 6:
if (s.compare("[end]") == 0){
state++;
}else{
endState.parsePlayerState(1, s);
}
break;
}
}
file.close();
}else{
//TODO Error management
}
}

108
projects/mtg/src/TexturesCache.cpp
View File

@@ -3,27 +3,27 @@
TexturesCache::TexturesCache(){
nb_textures = 0;
totalsize = 0;
totalsize = 0;
delete_previous = 0;
lastTime = 0;
for (int i=0; i<MAX_CACHE_OBJECTS;i++){
cache[i] = NULL;
}
lastTime = 0;
for (int i=0; i<MAX_CACHE_OBJECTS;i++){
cache[i] = NULL;
}
}
TexturesCache::~TexturesCache(){
LOG("==Destroying TexturesCache==");
for (int i = 0; i < nb_textures; i++){
delete cache[i];
}
LOG("==Destroying TexturesCache Successful==");
LOG("==Destroying TexturesCache==");
for (int i = 0; i < nb_textures; i++){
delete cache[i];
}
LOG("==Destroying TexturesCache Successful==");
}
int TexturesCache::isInCache(MTGCard * card, int type){
int cache_id = getCacheById(card->getId(), type);
if (cache_id == -1)
return 0;
return 1;
int cache_id = getCacheById(card->getId(), type);
if (cache_id == -1)
return 0;
return 1;
}
int TexturesCache::getCacheById(int id, int type){
@@ -37,32 +37,32 @@ int TexturesCache::getCacheById(int id, int type){
}
int TexturesCache::getOldestQuad(){
int oldest = -1;
int result = -1;
for (int i= 0; i < nb_textures; i++){
if (oldest == -1 || oldest > cache[i]->lastTime){
oldest = cache[i]->lastTime;
result = i;
}
}
return result;
int oldest = -1;
int result = -1;
for (int i= 0; i < nb_textures; i++){
if (oldest == -1 || oldest > cache[i]->lastTime){
oldest = cache[i]->lastTime;
result = i;
}
}
return result;
}
void TexturesCache::removeQuad(int id){
totalsize -= cache[id]->nbpixels;
delete cache[id];
cache[id] = cache[nb_textures - 1];
cache[nb_textures - 1] = NULL;
nb_textures--;
totalsize -= cache[id]->nbpixels;
delete cache[id];
cache[id] = cache[nb_textures - 1];
cache[nb_textures - 1] = NULL;
nb_textures--;
}
int TexturesCache::cleanup(){
while (nb_textures >= MAX_CACHE_OBJECTS - 1 || totalsize > CACHE_SIZE_PIXELS){
int i = getOldestQuad();
if (i == -1) return 0;
removeQuad(i);
}
return 1;
while (nb_textures >= MAX_CACHE_OBJECTS - 1 || totalsize > CACHE_SIZE_PIXELS){
int i = getOldestQuad();
if (i == -1) return 0;
removeQuad(i);
}
return 1;
}
JQuad * TexturesCache::getQuad(MTGCard * card, int type){
@@ -70,14 +70,14 @@ JQuad * TexturesCache::getQuad(MTGCard * card, int type){
if (cache_id == -1){
fprintf(stderr, "not found %d\n", card->getId());
//Not found in the cache, we have to load the file and put it in the cache
if (cleanup()){
cache_id = nb_textures;
cache[cache_id] = NEW CardTexture(card, type);
totalsize+= cache[cache_id]->nbpixels;
nb_textures++;
}
if (cleanup()){
cache_id = nb_textures;
cache[cache_id] = NEW CardTexture(card, type);
totalsize+= cache[cache_id]->nbpixels;
nb_textures++;
}
}
cache[cache_id]->lastTime = lastTime++;
cache[cache_id]->lastTime = lastTime++;
return cache[cache_id]->getQuad();
}
@@ -86,24 +86,24 @@ int CardTexture::getId(){
}
CardTexture::CardTexture(MTGCard * card, int _type): type(_type){
LOG("==Creating CardTexture Object");
LOG("==Creating CardTexture Object");
char filename[100];
quad = NULL;
nbpixels = 0;
lastTime = 0;
if (type == CACHE_THUMB){
sprintf(filename, "sets/%s/thumbnails/%s", card->getSetName(), card->getImageName());
}else{
sprintf(filename, "sets/%s/%s", card->getSetName(), card->getImageName());
}
nbpixels = 0;
lastTime = 0;
if (type == CACHE_THUMB){
sprintf(filename, "sets/%s/thumbnails/%s", card->getSetName(), card->getImageName());
}else{
sprintf(filename, "sets/%s/%s", card->getSetName(), card->getImageName());
}
tex = JRenderer::GetInstance()->LoadTexture(filename, false);
if (tex){
quad = NEW JQuad(tex, 0.0f, 0.0f, tex->mWidth, tex->mHeight);
nbpixels = tex->mTexHeight * tex->mTexWidth;
quad = NEW JQuad(tex, 0.0f, 0.0f, tex->mWidth, tex->mHeight);
nbpixels = tex->mTexHeight * tex->mTexWidth;
}
mtgid = card->getId();
LOG("CardTexture Object Creation succesful");
LOG("CardTexture Object Creation succesful");
}
JQuad * CardTexture::getQuad(){
@@ -111,9 +111,9 @@ JQuad * CardTexture::getQuad(){
}
CardTexture::~CardTexture(){
LOG("==Deleting CardTexture Object");
LOG("==Deleting CardTexture Object");
SAFE_DELETE(quad);
SAFE_DELETE(tex);
LOG("CardTexture Object deletion Succesful");
LOG("CardTexture Object deletion Succesful");
}

288
projects/mtg/src/utils.cpp
View File

@@ -1,144 +1,144 @@
#include "../include/debug.h"
#include "../include/utils.h"
int lowercase(string sBuffer) {
std::transform( sBuffer.begin(), sBuffer.end(), sBuffer.begin(),
::tolower );
return 1;
}
int substr_copy(char *source, char *target, int start, int len){
int i=0;
int not_over = 1;
while (not_over){
if (source[i+start] == 0 || i == len-1){
not_over = 0;
}
target[i] = source[i + start];
i++;
if (i == len){
target[i] = 0;
}
}
return i;
}
int append_str(char * s1, char * s2, char * target){
int len = substr_copy(s1,target, 0,0);
substr_copy(s2,target+len-1,0,0);
return 0;
}
int filesize(const char * filename){
int file_size = 0;
#if defined (WIN32) || defined (LINUX)
FILE * file = fopen(filename, "rb");
if (file != NULL)
{
fseek(file, 0, SEEK_END);
file_size = ftell(file);
fclose(file);
}
#else
int file = sceIoOpen(filename,PSP_O_RDONLY, 0777);
if (file > 0){
file_size = sceIoLseek(file, 0, PSP_SEEK_END);
sceIoClose(file);
}
#endif
return file_size;
}
int read_file (const char * filename, char * buffer, int file_size){
int a = 0;
#if defined (WIN32) || defined (LINUX)
FILE * file = fopen(filename, "rb");
a = fread(buffer, 1, file_size, file);
fclose(file);
#else
int file = sceIoOpen(filename,PSP_O_RDONLY, 0777);
a = sceIoRead(file, buffer, file_size);
sceIoClose(file);
#endif
fprintf(stderr, "The first string in the file is %d characters long.\n", strlen(&buffer[0]) );
return a;
}
int readline (char * in_buffer, char * out_buffer, int cursor){
char a;
int found = 0;
int i = 0;
//int read_ok = 0;
while (found == 0){
a = in_buffer[cursor];
cursor++;
if (a == '\r'){
a = in_buffer[cursor];
cursor ++;
}
if (a == 0){
found = 1;
cursor = 0;
}else{
if(a == '\n' || i==(BUFSIZE - 1)){
found = 1;
out_buffer[i] = 0;
if (a != '\n'){
int endofline = 0;
while (!endofline){
//int read;
a = in_buffer[cursor];
cursor++;
if (a == 0 || a=='\n'){
endofline = 1;
fprintf(stderr, "buffer overflow in readline %s\n", out_buffer);
}
if (a == 0 ){
cursor = 0;
}
}
}
}else{
out_buffer[i] = a;
i++;
}
}
}
out_buffer[i] = 0;
return(cursor);
}
int readfile_to_ints(const char * filename, int * out_buffer){
std::ifstream fichier(filename);
std::string s;
unsigned int count = 0;
if(fichier){
while(std::getline(fichier,s)){
int value = atoi(s.c_str());
if (value){
out_buffer[count] = value;
++count;
}
}
}
fichier.close();
return count;
}
#include "../include/debug.h"
#include "../include/utils.h"
int lowercase(string sBuffer) {
std::transform( sBuffer.begin(), sBuffer.end(), sBuffer.begin(),
::tolower );
return 1;
}
int substr_copy(char *source, char *target, int start, int len){
int i=0;
int not_over = 1;
while (not_over){
if (source[i+start] == 0 || i == len-1){
not_over = 0;
}
target[i] = source[i + start];
i++;
if (i == len){
target[i] = 0;
}
}
return i;
}
int append_str(char * s1, char * s2, char * target){
int len = substr_copy(s1,target, 0,0);
substr_copy(s2,target+len-1,0,0);
return 0;
}
int filesize(const char * filename){
int file_size = 0;
#if defined (WIN32) || defined (LINUX)
FILE * file = fopen(filename, "rb");
if (file != NULL)
{
fseek(file, 0, SEEK_END);
file_size = ftell(file);
fclose(file);
}
#else
int file = sceIoOpen(filename,PSP_O_RDONLY, 0777);
if (file > 0){
file_size = sceIoLseek(file, 0, PSP_SEEK_END);
sceIoClose(file);
}
#endif
return file_size;
}
int read_file (const char * filename, char * buffer, int file_size){
int a = 0;
#if defined (WIN32) || defined (LINUX)
FILE * file = fopen(filename, "rb");
a = fread(buffer, 1, file_size, file);
fclose(file);
#else
int file = sceIoOpen(filename,PSP_O_RDONLY, 0777);
a = sceIoRead(file, buffer, file_size);
sceIoClose(file);
#endif
fprintf(stderr, "The first string in the file is %d characters long.\n", strlen(&buffer[0]) );
return a;
}
int readline (char * in_buffer, char * out_buffer, int cursor){
char a;
int found = 0;
int i = 0;
//int read_ok = 0;
while (found == 0){
a = in_buffer[cursor];
cursor++;
if (a == '\r'){
a = in_buffer[cursor];
cursor ++;
}
if (a == 0){
found = 1;
cursor = 0;
}else{
if(a == '\n' || i==(BUFSIZE - 1)){
found = 1;
out_buffer[i] = 0;
if (a != '\n'){
int endofline = 0;
while (!endofline){
//int read;
a = in_buffer[cursor];
cursor++;
if (a == 0 || a=='\n'){
endofline = 1;
fprintf(stderr, "buffer overflow in readline %s\n", out_buffer);
}
if (a == 0 ){
cursor = 0;
}
}
}
}else{
out_buffer[i] = a;
i++;
}
}
}
out_buffer[i] = 0;
return(cursor);
}
int readfile_to_ints(const char * filename, int * out_buffer){
std::ifstream fichier(filename);
std::string s;
unsigned int count = 0;
if(fichier){
while(std::getline(fichier,s)){
int value = atoi(s.c_str());
if (value){
out_buffer[count] = value;
++count;
}
}
}
fichier.close();
return count;
}