Programmiermethoden_und_-werkzeuge
/
2022-2-WS_group_project_projekt__1
5
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

refactoring: changed Character to Player in all Files

remotes/origin/nextcycle
Kai Kehres 2 years ago
parent
17a4c08436
commit
64be330664
9 changed files with 352 additions and 352 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 262
      src/c/character.c
  2. 88
      src/c/character.h
  3. 62
      src/c/encounter.c
  4. 16
      src/c/encounter.h
  5. 18
      src/c/spell.c
  6. 10
      src/c/spell.h
  7. 152
      test/c/test_character.c
  8. 44
      test/c/test_encounter.c
  9. 52
      test/c/test_spell.c

262
src/c/character.c
View File

@ -5,106 +5,106 @@
#include "character.h" #include "character.h"
#include "spell.h" #include "spell.h"
Character character;
Player player;
void setCharacterHealthPoints (Character *character, int newHealthPoints){
character->healthPoints = newHealthPoints;
void setPlayerHealthPoints (Player *player, int newHealthPoints){
player->healthPoints = newHealthPoints;
} }
int getCharacterHealthPoints (Character *character) {
return character->healthPoints;
int getPlayerHealthPoints (Player *player) {
return player->healthPoints;
} }
void setCharacterStrength (Character *character, int newStrength) {
character->strength = newStrength;
void setPlayerStrength (Player *player, int newStrength) {
player->strength = newStrength;
} }
int getCharacterStrength (Character *character) {
return character->strength;
int getPlayerStrength (Player *player) {
return player->strength;
} }
void setCharacterDexterity (Character *character, int newDexterity) {
character->dexterity = newDexterity;
void setPlayerDexterity (Player *player, int newDexterity) {
player->dexterity = newDexterity;
} }
int getCharacterDexterity (Character *character) {
return character->dexterity;
int getPlayerDexterity (Player *player) {
return player->dexterity;
} }
void setCharacterIntelligence (Character *character, int newIntelligence) {
character->intelligence = newIntelligence;
void setPlayerIntelligence (Player *player, int newIntelligence) {
player->intelligence = newIntelligence;
} }
int getCharacterIntelligence (Character *character) {
return character->intelligence;
int getPlayerIntelligence (Player *player) {
return player->intelligence;
} }
void setCharacterLevel (Character *character, int newLevel) {
character->level = newLevel;
void setPlayerLevel (Player *player, int newLevel) {
player->level = newLevel;
} }
int getCharacterLevel (Character *character) {
return character->level;
int getPlayerLevel (Player *player) {
return player->level;
} }
void setCharacterExp (Character *character, int newExp) {
character->exp = newExp;
void setPlayerExp (Player *player, int newExp) {
player->exp = newExp;
} }
int getCharacterExp (Character *character) {
return character->exp;
int getPlayerExp (Player *player) {
return player->exp;
} }
void setCharacterMaxExp (Character *character, int newMaxExp) {
character->maxExp = newMaxExp;
void setPlayerMaxExp (Player *player, int newMaxExp) {
player->maxExp = newMaxExp;
} }
int getCharacterMaxExp (Character *character) {
return character->maxExp;
int getPlayerMaxExp (Player *player) {
return player->maxExp;
} }
int calculateStatIncrease (Character *character, int amount) {
return character->level*amount;
int calculateStatIncrease (Player *player, int amount) {
return player->level*amount;
} }
void setCharacterMaxHealthPoints (Character *character, int newMaxHealthPoints){
character->maxHealthPoints = newMaxHealthPoints;
void setPlayerMaxHealthPoints (Player *player, int newMaxHealthPoints){
player->maxHealthPoints = newMaxHealthPoints;
} }
int getCharacterMaxHealthPoints (Character *character){
return character->maxHealthPoints;
int getPlayerMaxHealthPoints (Player *player){
return player->maxHealthPoints;
} }
void setCharacterAttack (Character *character, int newAttack){
character->attack = newAttack;
void setPlayerAttack (Player *player, int newAttack){
player->attack = newAttack;
} }
int getCharacterAttack (Character *character){
return character->attack;
int getPlayerAttack (Player *player){
return player->attack;
} }
void setCharacterArmor (Character *character, int newArmor){
character->armor = newArmor;
void setPlayerArmor (Player *player, int newArmor){
player->armor = newArmor;
} }
int getCharacterArmor (Character *character){
return character->armor;
int getPlayerArmor (Player *player){
return player->armor;
} }
void setCharacterGold (Character *character, int newGold){
character->gold = newGold;
void setPlayerGold (Player *player, int newGold){
player->gold = newGold;
} }
int getCharacterGold (Character *character){
return character->gold;
int getPlayerGold (Player *player){
return player->gold;
} }
void setCharacterName (Character *character, char *newName) {
strcpy(character->name,newName);
void setPlayerName (Player *player, char *newName) {
strcpy(player->name,newName);
} }
char* getCharacterName (Character *character) {
return character->name;
char* getPlayerName (Player *player) {
return player->name;
} }
int getWeaponAttack (Weapon *weapon) { int getWeaponAttack (Weapon *weapon) {
@ -123,81 +123,81 @@ int setWeaponDurability (Weapon *weapon, int newDurability) {
weapon->durability = newDurability; weapon->durability = newDurability;
} }
void setCharacterWeaponClass (Character* character, int weaponClass) {
character->weaponClass = weaponClass;
void setPlayerWeaponClass (Player* player, int weaponClass) {
player->weaponClass = weaponClass;
} }
int getCharacterWeaponClass (Character* character) {
return character->weaponClass;
int getPlayerWeaponClass (Player* player) {
return player->weaponClass;
} }
void increaseStat (Character *character, int stat, int amount) {
void increaseStat (Player *player, int stat, int amount) {
switch (stat) switch (stat)
{ {
case 1: case 1:
character->strength += amount;break;
player->strength += amount;break;
case 2: case 2:
character->dexterity += amount;break;
player->dexterity += amount;break;
case 3: case 3:
character->intelligence += amount;break;
player->intelligence += amount;break;
case 4: case 4:
character->healthPoints += amount;break;
player->healthPoints += amount;break;
case 5: case 5:
character->manaPoints += amount;break;
player->manaPoints += amount;break;
case 6: case 6:
character->level += amount;break;
player->level += amount;break;
case 7: case 7:
character->exp += amount;break;
player->exp += amount;break;
case 8: case 8:
character->maxExp += amount;break;
player->maxExp += amount;break;
default: default:
break; break;
} }
} }
void levelUp (Character *character) {
if (getCharacterExp(character) > getCharacterMaxExp(character)) {
increaseStat(character,LEVEL,1);
setCharacterExp(character,getCharacterExp(character)-getCharacterMaxExp(character));
void levelUp (Player *player) {
if (getPlayerExp(player) > getPlayerMaxExp(player)) {
increaseStat(player,LEVEL,1);
setPlayerExp(player,getPlayerExp(player)-getPlayerMaxExp(player));
} }
} }
int calculateDamage (Character *character,Weapon *weapon) {
switch (character->weaponClass)
int calculateDamage (Player *player,Weapon *weapon) {
switch (player->weaponClass)
{ {
case 1: case 1:
return character->strength*weapon->attack;
return player->strength*weapon->attack;
case 2: case 2:
return character->dexterity*weapon->attack;
return player->dexterity*weapon->attack;
case 3: case 3:
return character->intelligence*weapon->attack;
return player->intelligence*weapon->attack;
default: default:
return 1; return 1;
} }
} }
void setCharacterStatPoints (Character* character, int newStatPoints) {
character->statPoints = newStatPoints;
void setPlayerStatPoints (Player* player, int newStatPoints) {
player->statPoints = newStatPoints;
} }
int getCharacterStatPoints (Character* character) {
return character->statPoints;
int getPlayerStatPoints (Player* player) {
return player->statPoints;
} }
void initializeCharacter (Character *character,int weaponClass) {
setCharacterHealthPoints(character,100);
setCharacterStrength(character,10);
setCharacterDexterity(character,10);
setCharacterIntelligence(character,10);
setCharacterLevel(character,1);
setCharacterExp(character,0);
setCharacterMaxExp(character,100);
setCharacterMaxHealthPoints(character,100);
setCharacterAttack(character,10);
setCharacterArmor(character,0);
setCharacterGold(character,0);
setCharacterName(character,"Player");
setCharacterWeaponClass(character,weaponClass);
setCharacterStatPoints(character,0);
void initializePlayer (Player *player,int weaponClass) {
setPlayerHealthPoints(player,100);
setPlayerStrength(player,10);
setPlayerDexterity(player,10);
setPlayerIntelligence(player,10);
setPlayerLevel(player,1);
setPlayerExp(player,0);
setPlayerMaxExp(player,100);
setPlayerMaxHealthPoints(player,100);
setPlayerAttack(player,10);
setPlayerArmor(player,0);
setPlayerGold(player,0);
setPlayerName(player,"Player");
setPlayerWeaponClass(player,weaponClass);
setPlayerStatPoints(player,0);
} }
void setItemID (Item *item, int newID) { void setItemID (Item *item, int newID) {
@ -248,97 +248,97 @@ char* getItemName (Item *item) {
return item->name; return item->name;
} }
void setCharacterStatus (Character *character, int newStatus) {
character->status = newStatus;
void setPlayerStatus (Player *player, int newStatus) {
player->status = newStatus;
} }
int getCharacterStatus (Character *character) {
return character->status;
int getPlayerStatus (Player *player) {
return player->status;
} }
void setCharacterStatusDuration (Character *character, int newStatusDuration) {
character->statusDuration = newStatusDuration;
void setPlayerStatusDuration (Player *player, int newStatusDuration) {
player->statusDuration = newStatusDuration;
} }
int getCharacterStatusDuration (Character *character) {
return character->statusDuration;
int getPlayerStatusDuration (Player *player) {
return player->statusDuration;
} }
void initializeInventory (Character *character) {
void initializeInventory (Player *player) {
for (int i = 0; i < 10; i++) for (int i = 0; i < 10; i++)
{ {
character->inventory[i] = NULL;
player->inventory[i] = NULL;
} }
} }
void putItemInInventory (Character *character, Item *item,int inventorySlot) {
void putItemInInventory (Player *player, Item *item,int inventorySlot) {
if(inventorySlot > 9) { if(inventorySlot > 9) {
printf("Inventory slot is out of range (0-9)\n"); printf("Inventory slot is out of range (0-9)\n");
} else if (inventorySlot < 0) { } else if (inventorySlot < 0) {
printf("Inventory slot is out of range (0-9)\n"); printf("Inventory slot is out of range (0-9)\n");
} else if (character->inventory[inventorySlot] == NULL) {
} else if (player->inventory[inventorySlot] == NULL) {
printf("Inventory slot is already occupied\n"); printf("Inventory slot is already occupied\n");
} else { } else {
character->inventory[inventorySlot] = item;
player->inventory[inventorySlot] = item;
} }
} }
Item * getItemInInventory (Character *character, int inventorySlot) {
Item * getItemInInventory (Player *player, int inventorySlot) {
if(inventorySlot > 9) { if(inventorySlot > 9) {
printf("Inventory slot is out of range (0-9)\n"); printf("Inventory slot is out of range (0-9)\n");
return NULL; return NULL;
} else if (inventorySlot < 0) { } else if (inventorySlot < 0) {
printf("Inventory slot is out of range (0-9)\n"); printf("Inventory slot is out of range (0-9)\n");
return NULL; return NULL;
} else if (character->inventory[inventorySlot] == NULL) {
} else if (player->inventory[inventorySlot] == NULL) {
printf("Inventory slot is empty\n"); printf("Inventory slot is empty\n");
return NULL; return NULL;
} else { } else {
return character->inventory[inventorySlot];
return player->inventory[inventorySlot];
} }
} }
int checkStatus (Character *character) {
switch (character->status)
int checkStatus (Player *player) {
switch (player->status)
{ {
case SPELL_EFFECT_NONE: case SPELL_EFFECT_NONE:
break; break;
case SPELL_EFFECT_BURN: case SPELL_EFFECT_BURN:
setCharacterStatusDuration(character,getCharacterStatusDuration(character)-1);
if (getCharacterStatusDuration == 0) {
setCharacterStatus(character,SPELL_EFFECT_NONE);
setPlayerStatusDuration(player,getPlayerStatusDuration(player)-1);
if (getPlayerStatusDuration == 0) {
setPlayerStatus(player,SPELL_EFFECT_NONE);
} }
return getCharacterStatus(character);
return getPlayerStatus(player);
break; break;
case SPELL_EFFECT_FREEZE: case SPELL_EFFECT_FREEZE:
setCharacterStatusDuration(character,getCharacterStatusDuration(character)-1);
if (getCharacterStatusDuration == 0) {
setCharacterStatus(character,SPELL_EFFECT_NONE);
setPlayerStatusDuration(player,getPlayerStatusDuration(player)-1);
if (getPlayerStatusDuration == 0) {
setPlayerStatus(player,SPELL_EFFECT_NONE);
} }
return getCharacterStatus(character);
return getPlayerStatus(player);
break; break;
case SPELL_EFFECT_STUN: case SPELL_EFFECT_STUN:
setCharacterStatusDuration(character,getCharacterStatusDuration(character)-1);
if (getCharacterStatusDuration == 0) {
setCharacterStatus(character,SPELL_EFFECT_NONE);
setPlayerStatusDuration(player,getPlayerStatusDuration(player)-1);
if (getPlayerStatusDuration == 0) {
setPlayerStatus(player,SPELL_EFFECT_NONE);
} }
return getCharacterStatus(character);
return getPlayerStatus(player);
break; break;
case SPELL_EFFECT_REGENERATION: case SPELL_EFFECT_REGENERATION:
setCharacterStatusDuration(character,getCharacterStatusDuration(character)-1);
if (getCharacterStatusDuration == 0) {
setCharacterStatus(character,SPELL_EFFECT_NONE);
setPlayerStatusDuration(player,getPlayerStatusDuration(player)-1);
if (getPlayerStatusDuration == 0) {
setPlayerStatus(player,SPELL_EFFECT_NONE);
} }
return getCharacterStatus(character);
return getPlayerStatus(player);
break; break;
default: default:
return getCharacterStatus(character);
return getPlayerStatus(player);
break; break;
} }
} }
void setCharacterManaPoints (Character *character, int newManaPoints) {
character->manaPoints = newManaPoints;
void setPlayerManaPoints (Player *player, int newManaPoints) {
player->manaPoints = newManaPoints;
} }
int getCharacterManaPoints (Character *character) {
return character->manaPoints;
int getPlayerManaPoints (Player *player) {
return player->manaPoints;
} }

88
src/c/character.h
View File

@ -10,7 +10,7 @@ typedef struct {
int attack,armor,maxHealthPoints,gold,weaponClass,statPoints,status,statusDuration; int attack,armor,maxHealthPoints,gold,weaponClass,statPoints,status,statusDuration;
char name [50]; char name [50];
Item *inventory[10]; Item *inventory[10];
} Character;
} Player;
typedef struct { typedef struct {
int attack,durability; int attack,durability;
char name [50]; char name [50];
@ -23,63 +23,63 @@ enum {
STRENGTH = 1, DEXTERITY = 2, INTELLIGENCE = 3, HEALTHPOINTS = 4, MANAPOINTS = 5, LEVEL = 6, EXP = 7, MAXEXP = 8 STRENGTH = 1, DEXTERITY = 2, INTELLIGENCE = 3, HEALTHPOINTS = 4, MANAPOINTS = 5, LEVEL = 6, EXP = 7, MAXEXP = 8
}; };
void setCharacterHealthPoints (Character *character, int newHealthPoints);
void setPlayerHealthPoints (Player *player, int newHealthPoints);
int getCharacterHealthPoints (Character *character);
int getPlayerHealthPoints (Player *player);
void setCharacterStrength (Character *character, int newStrength);
void setPlayerStrength (Player *player, int newStrength);
int getCharacterStrength (Character *character);
int getPlayerStrength (Player *player);
void setCharacterDexterity (Character *character, int newDexterity);
void setPlayerDexterity (Player *player, int newDexterity);
int getCharacterDexterity (Character *character);
int getPlayerDexterity (Player *player);
void setCharacterIntelligence (Character *character, int newIntelligence);
void setPlayerIntelligence (Player *player, int newIntelligence);
int getCharacterIntelligence (Character *character);
int getPlayerIntelligence (Player *player);
void setCharacterLevel (Character *character, int newLevel);
void setPlayerLevel (Player *player, int newLevel);
int getCharacterLevel (Character *character);
int getPlayerLevel (Player *player);
void setCharacterExp (Character *character, int newExp);
void setPlayerExp (Player *player, int newExp);
int getCharacterExp (Character *character);
int getPlayerExp (Player *player);
void setCharacterMaxExp (Character *character, int newMaxExp);
void setPlayerMaxExp (Player *player, int newMaxExp);
int getCharacterMaxExp (Character *character);
int getPlayerMaxExp (Player *player);
void increaseStat (Character *character, int stat, int amount);
void increaseStat (Player *player, int stat, int amount);
int calculateStatIncrease (Character *character, int amount);
int calculateStatIncrease (Player *player, int amount);
void setCharacterMaxHealthPoints (Character *character, int newMaxHealthPoints);
void setPlayerMaxHealthPoints (Player *player, int newMaxHealthPoints);
int getCharacterMaxHealthPoints (Character *character);
int getPlayerMaxHealthPoints (Player *player);
void setCharacterAttack (Character *character, int newAttack);
void setPlayerAttack (Player *player, int newAttack);
int getCharacterAttack (Character *character);
int getPlayerAttack (Player *player);
void setCharacterArmor (Character *character, int newArmor);
void setPlayerArmor (Player *player, int newArmor);
int getCharacterArmor (Character *character);
int getPlayerArmor (Player *player);
void setCharacterGold (Character *character, int newGold);
void setPlayerGold (Player *player, int newGold);
int getCharacterGold (Character *character);
int getPlayerGold (Player *player);
void levelUp (Character *character);
void levelUp (Player *player);
void setCharacterName (Character *character, char newName[]);
void setPlayerName (Player *player, char newName[]);
char* getCharacterName (Character *character);
char* getPlayerName (Player *player);
void setCharacterWeaponClass (Character *character, int newWeaponClass);
void setPlayerWeaponClass (Player *player, int newWeaponClass);
int getCharacterWeaponClass (Character *character);
int getPlayerWeaponClass (Player *player);
int getWeaponAttack (Weapon *weapon); int getWeaponAttack (Weapon *weapon);
@ -89,13 +89,13 @@ int getWeaponDurability (Weapon *weapon);
int setWeaponDurability (Weapon *weapon, int newDurability); int setWeaponDurability (Weapon *weapon, int newDurability);
int calculateDamage (Character *character,Weapon *weapon);
int calculateDamage (Player *player,Weapon *weapon);
void setCharacterStatPoints (Character *character, int newStatPoints);
void setPlayerStatPoints (Player *player, int newStatPoints);
int getCharacterStatPoints (Character *character);
int getPlayerStatPoints (Player *player);
void initializeCharacter (Character *character,int weaponClass);
void initializePlayer (Player *player,int weaponClass);
void setItemID (Item *item, int newID); void setItemID (Item *item, int newID);
@ -121,23 +121,23 @@ void setItemName (Item *item, char newName[]);
char* getItemName (Item *item); char* getItemName (Item *item);
void putItemInInventory (Character *character, Item *item, int inventorySlot);
void putItemInInventory (Player *player, Item *item, int inventorySlot);
void initializeInventory (Character *character);
void initializeInventory (Player *player);
Item * getItemInInventory (Character *character, int inventorySlot);
Item * getItemInInventory (Player *player, int inventorySlot);
void setCharacterStatus (Character *character, int newStatus);
void setPlayerStatus (Player *player, int newStatus);
int getCharacterStatus (Character *character);
int getPlayerStatus (Player *player);
void setCharacterStatusDuration (Character *character, int newStatusDuration);
void setPlayerStatusDuration (Player *player, int newStatusDuration);
int getCharacterStatusDuration (Character *character);
int getPlayerStatusDuration (Player *player);
int checkStatus (Character *character);
int checkStatus (Player *player);
void setCharacterManaPoints (Character *character, int newManaPoints);
void setPlayerManaPoints (Player *player, int newManaPoints);
int getCharacterManaPoints (Character *character);
int getPlayerManaPoints (Player *player);
#endif #endif

62
src/c/encounter.c
View File

@ -18,9 +18,9 @@ humanoide gegner haben heiltränke mit denen sie sich ggf heilen.
heilung erfolgt dann, wenn bestimmte hp (50%) unterschritten wird. wird allerdings gewürfelt, heilung erfolgt dann, wenn bestimmte hp (50%) unterschritten wird. wird allerdings gewürfelt,
je niedriger die hp%, desto höher die chance. */ je niedriger die hp%, desto höher die chance. */
bool playerAlive(Character *character)
bool playerAlive(Player *player)
{ {
if (getCharacterHealthPoints(character) > 0)
if (getPlayerHealthPoints(player) > 0)
{ {
return true; return true;
} }
@ -30,24 +30,24 @@ bool playerAlive(Character *character)
} }
} }
int playerHeal(Character* character, int amount)
int playerHeal(Player* player, int amount)
{ {
setCharacterHealthPoints(character, getCharacterHealthPoints(character)+ amount);
if (getCharacterHealthPoints(character) > getCharacterMaxHealthPoints(character))
setPlayerHealthPoints(player, getPlayerHealthPoints(player)+ amount);
if (getPlayerHealthPoints(player) > getPlayerMaxHealthPoints(player))
{ {
setCharacterHealthPoints(character, getCharacterMaxHealthPoints(character));
setPlayerHealthPoints(player, getPlayerMaxHealthPoints(player));
} }
return getCharacterHealthPoints(character);
return getPlayerHealthPoints(player);
} }
int playerDamaged(enemy* enemy, Character* character)
int playerDamaged(enemy* enemy, Player* player)
{ {
int damagedealt = getEnemyDamage(enemy) - getCharacterArmor(character);
int damagedealt = getEnemyDamage(enemy) - getPlayerArmor(player);
if (damagedealt < 1) if (damagedealt < 1)
{ {
damagedealt = 1; damagedealt = 1;
} }
return getCharacterHealthPoints(character) - damagedealt;
return getPlayerHealthPoints(player) - damagedealt;
} }
void enemyHeal(enemy *enemy, int healAmount) void enemyHeal(enemy *enemy, int healAmount)
@ -59,9 +59,9 @@ void enemyHeal(enemy *enemy, int healAmount)
setEnemyHealth(enemy, getEnemyHealth(enemy) + healAmount); setEnemyHealth(enemy, getEnemyHealth(enemy) + healAmount);
} }
void enemyDamaged(enemy *enemy,Character* character)
void enemyDamaged(enemy *enemy,Player* player)
{ {
int damagedealt = getCharacterAttack(character) - getEnemyArmor(enemy);
int damagedealt = getPlayerAttack(player) - getEnemyArmor(enemy);
if (damagedealt < 1) if (damagedealt < 1)
{ {
damagedealt = 1; damagedealt = 1;
@ -77,23 +77,23 @@ int switchTurns(int currentTurn)
return currentTurn; return currentTurn;
} }
int fight(Character *character, enemy* enemy)
int fight(Player *player, enemy* enemy)
{ {
int playerH = 0; int playerH = 0;
int currentTurn = 2; int currentTurn = 2;
char decision; char decision;
while (playerAlive(character) && getEnemyHealth(enemy) > 0)
while (playerAlive(player) && getEnemyHealth(enemy) > 0)
{ {
if (currentTurn != 1) if (currentTurn != 1)
{ {
decision = playerInputChar(); decision = playerInputChar();
switch(decision){ switch(decision){
case 'a': case 'a':
enemyDamaged(enemy, character);
enemyDamaged(enemy, player);
break; break;
case 'h': case 'h':
playerH = playerHeal(character,10);
setCharacterHealthPoints(character, playerH);
playerH = playerHeal(player,10);
setPlayerHealthPoints(player, playerH);
break; break;
case 'f': case 'f':
return 2; return 2;
@ -108,16 +108,16 @@ int fight(Character *character, enemy* enemy)
} }
else else
{ {
playerH = playerDamaged(enemy, character);
setCharacterHealthPoints(character, playerH);
playerH = playerDamaged(enemy, player);
setPlayerHealthPoints(player, playerH);
} }
} }
currentTurn = switchTurns(currentTurn); currentTurn = switchTurns(currentTurn);
} }
if (playerAlive(character))
if (playerAlive(player))
{ {
setCharacterExp(character, getCharacterExp(character) + getEnemyExp(enemy));
setCharacterGold(character, getCharacterGold(character) + getEnemyGold(enemy));
setPlayerExp(player, getPlayerExp(player) + getEnemyExp(enemy));
setPlayerGold(player, getPlayerGold(player) + getEnemyGold(enemy));
return 1; return 1;
} }
else else
@ -126,8 +126,8 @@ int fight(Character *character, enemy* enemy)
} }
} }
int rollInitiative (Character *character) {
return randomIntRange(1,20) + character->dexterity;
int rollInitiative (Player *player) {
return randomIntRange(1,20) + player->dexterity;
} }
bool enemyChoosesHeal(enemy* enemy) bool enemyChoosesHeal(enemy* enemy)
@ -240,17 +240,17 @@ int createRandomEnemy(enemy* enemy)
return enemyType; return enemyType;
} }
bool dodge (Character *character, enemy* enemy) {
if (randomIntRange(1,20) + character->dexterity > 15)
bool dodge (Player *player, enemy* enemy) {
if (randomIntRange(1,20) + player->dexterity > 15)
{ {
return true; return true;
} }
return false; return false;
} }
void rest(Character *character) {
setCharacterHealthPoints(character, getCharacterMaxHealthPoints(character));
setCharacterManaPoints(character, 10);
setCharacterStatus(character, SPELL_EFFECT_NONE);
setCharacterStatusDuration(character, 0);
void rest(Player *player) {
setPlayerHealthPoints(player, getPlayerMaxHealthPoints(player));
setPlayerManaPoints(player, 10);
setPlayerStatus(player, SPELL_EFFECT_NONE);
setPlayerStatusDuration(player, 0);
} }

16
src/c/encounter.h
View File

@ -14,17 +14,17 @@ typedef struct enemy{
} enemy; } enemy;
bool playerAlive(Character *character);
int playerHeal(Character* character,int amount);
int playerDamaged(enemy* enemy, Character* character);
int rollInitiative (Character *character);
bool playerAlive(Player *player);
int playerHeal(Player* player,int amount);
int playerDamaged(enemy* enemy, Player* player);
int rollInitiative (Player *player);
void enemyHeal(enemy *enemy, int healAmount); void enemyHeal(enemy *enemy, int healAmount);
void enemyDamaged(enemy* enemy, Character* character);
void enemyDamaged(enemy* enemy, Player* player);
bool enemyChoosesHeal(enemy* enemy); bool enemyChoosesHeal(enemy* enemy);
int switchTurns(int currentTurn); int switchTurns(int currentTurn);
int fight(Character *character, enemy* enemy);
bool dodge (Character *character, enemy* enemy);
void rest(Character *character);
int fight(Player *player, enemy* enemy);
bool dodge (Player *player, enemy* enemy);
void rest(Player *player);

18
src/c/spell.c
View File

@ -5,10 +5,10 @@
#include "character.h" #include "character.h"
#include "spell.h" #include "spell.h"
SpellEffect spellFireball(Character *character) {
SpellEffect spellFireball(Player *player) {
SpellEffect fireball; SpellEffect fireball;
fireball.id = 0; fireball.id = 0;
fireball.damage = 10 + (getCharacterIntelligence(character) / 2);
fireball.damage = 10 + (getPlayerIntelligence(player) / 2);
fireball.healing = 0; fireball.healing = 0;
fireball.manaCost = 10; fireball.manaCost = 10;
fireball.effect = SPELL_EFFECT_NONE; fireball.effect = SPELL_EFFECT_NONE;
@ -16,21 +16,21 @@ SpellEffect spellFireball(Character *character) {
return fireball; return fireball;
} }
SpellEffect spellHeal(Character *character) {
SpellEffect spellHeal(Player *player) {
SpellEffect heal; SpellEffect heal;
heal.id = 1; heal.id = 1;
heal.damage = 0; heal.damage = 0;
heal.healing = 10 + (getCharacterIntelligence(character) / 3);
heal.healing = 10 + (getPlayerIntelligence(player) / 3);
heal.manaCost = 10; heal.manaCost = 10;
heal.effect = SPELL_EFFECT_NONE; heal.effect = SPELL_EFFECT_NONE;
heal.effectDuration = 0; heal.effectDuration = 0;
return heal; return heal;
} }
SpellEffect spellLightning(Character *character) {
SpellEffect spellLightning(Player *player) {
SpellEffect lightning; SpellEffect lightning;
lightning.id = 2; lightning.id = 2;
lightning.damage = 10 + (getCharacterIntelligence(character) / 2);
lightning.damage = 10 + (getPlayerIntelligence(player) / 2);
lightning.healing = 0; lightning.healing = 0;
lightning.manaCost = 10; lightning.manaCost = 10;
lightning.effect = SPELL_EFFECT_STUN; lightning.effect = SPELL_EFFECT_STUN;
@ -38,18 +38,18 @@ SpellEffect spellLightning(Character *character) {
return lightning; return lightning;
} }
SpellEffect spellRegeneration (Character *character) {
SpellEffect spellRegeneration (Player *player) {
SpellEffect regeneration; SpellEffect regeneration;
regeneration.id = 3; regeneration.id = 3;
regeneration.damage = 0; regeneration.damage = 0;
regeneration.healing = 5 + (getCharacterIntelligence(character) / 4);
regeneration.healing = 5 + (getPlayerIntelligence(player) / 4);
regeneration.manaCost = 10; regeneration.manaCost = 10;
regeneration.effect = SPELL_EFFECT_REGENERATION; regeneration.effect = SPELL_EFFECT_REGENERATION;
regeneration.effectDuration = 2; regeneration.effectDuration = 2;
return regeneration; return regeneration;
} }
SpellEffect spellFreeze(Character *character) {
SpellEffect spellFreeze(Player *player) {
SpellEffect freeze; SpellEffect freeze;
freeze.id = 4; freeze.id = 4;
freeze.damage = 0; freeze.damage = 0;

10
src/c/spell.h
View File

@ -11,11 +11,11 @@ enum {
}; };
SpellEffect spellFireball(Character *character);
SpellEffect spellHeal(Character *character);
SpellEffect spellLightning(Character *character);
SpellEffect spellRegeneration (Character *character);
SpellEffect spellFreeze(Character *character);
SpellEffect spellFireball(Player *player);
SpellEffect spellHeal(Player *player);
SpellEffect spellLightning(Player *player);
SpellEffect spellRegeneration (Player *player);
SpellEffect spellFreeze(Player *player);
#endif #endif

152
test/c/test_character.c
View File

@ -1,28 +1,28 @@
#ifdef TEST #ifdef TEST
#include "unity.h" #include "unity.h"
#include "character.h" #include "character.h"
Character testCharacter;
Character testCharacter2;
Player testPlayer;
Player testPlayer2;
Weapon testWeapon; Weapon testWeapon;
void setUp(void) void setUp(void)
{ {
testCharacter.healthPoints = 0;
testCharacter2.healthPoints = 15;
testCharacter.strength = 0;
testCharacter2.strength = 5;
testCharacter.dexterity = 0;
testCharacter2.dexterity = 5;
testCharacter.intelligence = 0;
testCharacter2.intelligence = 7;
testCharacter.level = 0;
testCharacter2.level = 5;
testCharacter.exp = 50;
testCharacter2.exp = 110;
testCharacter.maxExp = 100;
testCharacter2.maxExp = 100;
testCharacter.attack = 5;
testCharacter2.weaponClass = SWORD;
testPlayer.healthPoints = 0;
testPlayer2.healthPoints = 15;
testPlayer.strength = 0;
testPlayer2.strength = 5;
testPlayer.dexterity = 0;
testPlayer2.dexterity = 5;
testPlayer.intelligence = 0;
testPlayer2.intelligence = 7;
testPlayer.level = 0;
testPlayer2.level = 5;
testPlayer.exp = 50;
testPlayer2.exp = 110;
testPlayer.maxExp = 100;
testPlayer2.maxExp = 100;
testPlayer.attack = 5;
testPlayer2.weaponClass = SWORD;
testWeapon.attack = 5; testWeapon.attack = 5;
testWeapon.durability = 100; testWeapon.durability = 100;
@ -32,112 +32,112 @@ void tearDown(void)
{ {
} }
void test_setCharacterHealthPoints(void)
void test_setPlayerHealthPoints(void)
{ {
TEST_ASSERT_EQUAL_INT(0,testCharacter.healthPoints);
setCharacterHealthPoints(&testCharacter,50);
TEST_ASSERT_EQUAL_INT(50,testCharacter.healthPoints);
TEST_ASSERT_EQUAL_INT(0,testPlayer.healthPoints);
setPlayerHealthPoints(&testPlayer,50);
TEST_ASSERT_EQUAL_INT(50,testPlayer.healthPoints);
} }
void test_getCharacterHealthPoints (void) {
TEST_ASSERT_EQUAL_INT(15,getCharacterHealthPoints(&testCharacter2));
void test_getPlayerHealthPoints (void) {
TEST_ASSERT_EQUAL_INT(15,getPlayerHealthPoints(&testPlayer2));
} }
void test_setCharacterStrenght(void) {
TEST_ASSERT_EQUAL_INT(0,testCharacter.strength);
setCharacterStrength(&testCharacter,50);
TEST_ASSERT_EQUAL_INT(50,testCharacter.strength);
void test_setPlayerStrenght(void) {
TEST_ASSERT_EQUAL_INT(0,testPlayer.strength);
setPlayerStrength(&testPlayer,50);
TEST_ASSERT_EQUAL_INT(50,testPlayer.strength);
} }
void test_getCharacterStrength(void) {
TEST_ASSERT_EQUAL_INT(5,getCharacterStrength(&testCharacter2));
void test_getPlayerStrength(void) {
TEST_ASSERT_EQUAL_INT(5,getPlayerStrength(&testPlayer2));
} }
void test_setCharacterDexterity(void) {
TEST_ASSERT_EQUAL_INT(0,testCharacter.dexterity);
setCharacterDexterity(&testCharacter,50);
TEST_ASSERT_EQUAL_INT(50,testCharacter.dexterity);
void test_setPlayerDexterity(void) {
TEST_ASSERT_EQUAL_INT(0,testPlayer.dexterity);
setPlayerDexterity(&testPlayer,50);
TEST_ASSERT_EQUAL_INT(50,testPlayer.dexterity);
} }
void test_getCharacterDexterity(void) {
TEST_ASSERT_EQUAL_INT(5,getCharacterDexterity(&testCharacter2));
void test_getPlayerDexterity(void) {
TEST_ASSERT_EQUAL_INT(5,getPlayerDexterity(&testPlayer2));
} }
void test_setCharacterIntelligence(void) {
TEST_ASSERT_EQUAL_INT(0,testCharacter.intelligence);
setCharacterIntelligence(&testCharacter,45);
TEST_ASSERT_EQUAL_INT(45,testCharacter.intelligence);
void test_setPlayerIntelligence(void) {
TEST_ASSERT_EQUAL_INT(0,testPlayer.intelligence);
setPlayerIntelligence(&testPlayer,45);
TEST_ASSERT_EQUAL_INT(45,testPlayer.intelligence);
} }
void test_getCharacterIntelligence(void) {
TEST_ASSERT_EQUAL_INT(7,getCharacterIntelligence(&testCharacter2));
void test_getPlayerIntelligence(void) {
TEST_ASSERT_EQUAL_INT(7,getPlayerIntelligence(&testPlayer2));
} }
void test_setCharacterLevel(void) {
TEST_ASSERT_EQUAL_INT(0,testCharacter.level);
setCharacterLevel(&testCharacter,1);
TEST_ASSERT_EQUAL_INT(1,testCharacter.level);
void test_setPlayerLevel(void) {
TEST_ASSERT_EQUAL_INT(0,testPlayer.level);
setPlayerLevel(&testPlayer,1);
TEST_ASSERT_EQUAL_INT(1,testPlayer.level);
} }
void test_getCharacterLevel(void) {
TEST_ASSERT_EQUAL_INT(5,getCharacterLevel(&testCharacter2));
void test_getPlayerLevel(void) {
TEST_ASSERT_EQUAL_INT(5,getPlayerLevel(&testPlayer2));
} }
void test_increaseStat(void) { void test_increaseStat(void) {
increaseStat(&testCharacter2,STRENGTH,15);
TEST_ASSERT_EQUAL_INT(20,testCharacter2.strength);
increaseStat(&testCharacter2,INTELLIGENCE,15);
TEST_ASSERT_EQUAL_INT(22,testCharacter2.intelligence);
increaseStat(&testCharacter2,LEVEL,15);
TEST_ASSERT_EQUAL_INT(20,testCharacter2.level);
increaseStat(&testPlayer2,STRENGTH,15);
TEST_ASSERT_EQUAL_INT(20,testPlayer2.strength);
increaseStat(&testPlayer2,INTELLIGENCE,15);
TEST_ASSERT_EQUAL_INT(22,testPlayer2.intelligence);
increaseStat(&testPlayer2,LEVEL,15);
TEST_ASSERT_EQUAL_INT(20,testPlayer2.level);
} }
void test_calculateStatIncrease(void) { void test_calculateStatIncrease(void) {
TEST_ASSERT_EQUAL_INT(5,testCharacter2.level);
TEST_ASSERT_EQUAL_INT(25,calculateStatIncrease(&testCharacter2,5));
TEST_ASSERT_EQUAL_INT(5,testPlayer2.level);
TEST_ASSERT_EQUAL_INT(25,calculateStatIncrease(&testPlayer2,5));
} }
void test_levelUp_enoughExp (void) { void test_levelUp_enoughExp (void) {
TEST_ASSERT_EQUAL_INT(5,testCharacter2.level);
levelUp(&testCharacter2);
TEST_ASSERT_EQUAL_INT(6,testCharacter2.level);
TEST_ASSERT_EQUAL_INT(5,testPlayer2.level);
levelUp(&testPlayer2);
TEST_ASSERT_EQUAL_INT(6,testPlayer2.level);
} }
void test_levelUp_enoughExp_loseExp (void) { void test_levelUp_enoughExp_loseExp (void) {
TEST_ASSERT_EQUAL_INT(110,testCharacter2.exp);
TEST_ASSERT_EQUAL_INT(100,testCharacter2.maxExp);
levelUp(&testCharacter2);
TEST_ASSERT_EQUAL_INT(10,testCharacter2.exp);
TEST_ASSERT_EQUAL_INT(110,testPlayer2.exp);
TEST_ASSERT_EQUAL_INT(100,testPlayer2.maxExp);
levelUp(&testPlayer2);
TEST_ASSERT_EQUAL_INT(10,testPlayer2.exp);
} }
void test_levelUp_notEnoughExp (void) { void test_levelUp_notEnoughExp (void) {
TEST_ASSERT_EQUAL_INT(0,testCharacter.level);
levelUp(&testCharacter);
TEST_ASSERT_EQUAL_INT(0,testCharacter.level);
TEST_ASSERT_EQUAL_INT(0,testPlayer.level);
levelUp(&testPlayer);
TEST_ASSERT_EQUAL_INT(0,testPlayer.level);
} }
void test_levelUp_notEnoughExp_loseExp (void) { void test_levelUp_notEnoughExp_loseExp (void) {
TEST_ASSERT_EQUAL_INT(50,testCharacter.exp);
TEST_ASSERT_EQUAL_INT(100,testCharacter.maxExp);
levelUp(&testCharacter);
TEST_ASSERT_EQUAL_INT(50,testCharacter.exp);
TEST_ASSERT_EQUAL_INT(50,testPlayer.exp);
TEST_ASSERT_EQUAL_INT(100,testPlayer.maxExp);
levelUp(&testPlayer);
TEST_ASSERT_EQUAL_INT(50,testPlayer.exp);
} }
void test_calculateDamage_Sword (void) { void test_calculateDamage_Sword (void) {
setCharacterWeaponClass(&testCharacter2,SWORD);
setPlayerWeaponClass(&testPlayer2,SWORD);
TEST_ASSERT_EQUAL_INT(25,calculateDamage(&testCharacter2,&testWeapon));
TEST_ASSERT_EQUAL_INT(25,calculateDamage(&testPlayer2,&testWeapon));
} }
void test_calculateDamage_Bow (void) { void test_calculateDamage_Bow (void) {
setCharacterWeaponClass(&testCharacter2,BOW);
setPlayerWeaponClass(&testPlayer2,BOW);
TEST_ASSERT_EQUAL_INT(25,calculateDamage(&testCharacter2,&testWeapon));
TEST_ASSERT_EQUAL_INT(25,calculateDamage(&testPlayer2,&testWeapon));
} }
void test_calculateDamage_Staff (void) { void test_calculateDamage_Staff (void) {
setCharacterWeaponClass(&testCharacter2,STAFF);
setPlayerWeaponClass(&testPlayer2,STAFF);
TEST_ASSERT_EQUAL_INT(35,calculateDamage(&testCharacter2,&testWeapon));
TEST_ASSERT_EQUAL_INT(35,calculateDamage(&testPlayer2,&testWeapon));
} }
#endif // TEST #endif // TEST

44
test/c/test_encounter.c
View File

@ -9,14 +9,14 @@
#include "mock_helper.h" #include "mock_helper.h"
#include "utils.h" #include "utils.h"
Character testcharacter;
Player testplayer;
enemy testenemy; enemy testenemy;
void setUp(void) void setUp(void)
{ {
testcharacter.dexterity = 5;
testcharacter.healthPoints = 100;
testcharacter.maxHealthPoints = 100;
testcharacter.attack = 10;
testplayer.dexterity = 5;
testplayer.healthPoints = 100;
testplayer.maxHealthPoints = 100;
testplayer.attack = 10;
testenemy.damage = 10; testenemy.damage = 10;
testenemy.health = 50; testenemy.health = 50;
@ -33,7 +33,7 @@ void test_isPlayerAlive_healthGreaterZero(void)
int health = 100; int health = 100;
bool result; bool result;
// act // act
result = playerAlive(&testcharacter);
result = playerAlive(&testplayer);
// assert // assert
TEST_ASSERT_TRUE(result); TEST_ASSERT_TRUE(result);
} }
@ -41,10 +41,10 @@ void test_isPlayerAlive_healthGreaterZero(void)
void test_isPlayerAlive_healthLowerZero(void) void test_isPlayerAlive_healthLowerZero(void)
{ {
// arrange // arrange
setCharacterHealthPoints(&testcharacter, -1);
setPlayerHealthPoints(&testplayer, -1);
bool result; bool result;
// act // act
result = playerAlive(&testcharacter);
result = playerAlive(&testplayer);
// assert // assert
TEST_ASSERT_FALSE(result); TEST_ASSERT_FALSE(result);
@ -55,7 +55,7 @@ void test_playerIsDamaged(void)
// arrange // arrange
int expectedHealth = 90; int expectedHealth = 90;
// act // act
int result = playerDamaged(&testenemy, &testcharacter);
int result = playerDamaged(&testenemy, &testplayer);
// assert // assert
TEST_ASSERT_EQUAL(expectedHealth, result); TEST_ASSERT_EQUAL(expectedHealth, result);
} }
@ -63,12 +63,12 @@ void test_playerIsDamaged(void)
void test_playerIsNotOverhealed(void) void test_playerIsNotOverhealed(void)
{ {
// arrange // arrange
setCharacterHealthPoints(&testcharacter, 95);
setPlayerHealthPoints(&testplayer, 95);
int heal = 10; int heal = 10;
// act // act
int result = playerHeal(&testcharacter, heal);
int result = playerHeal(&testplayer, heal);
// assert // assert
TEST_ASSERT_EQUAL(getCharacterMaxHealthPoints(&testcharacter), result);
TEST_ASSERT_EQUAL(getPlayerMaxHealthPoints(&testplayer), result);
} }
void test_setEnemyHealth(void) void test_setEnemyHealth(void)
@ -136,7 +136,7 @@ void test_PlayerAttacksEnemy_DoesDamage(void)
// health - (damage - armor) // health - (damage - armor)
int expectedEnemyHealth = 44; int expectedEnemyHealth = 44;
// act // act
enemyDamaged(&testenemy, &testcharacter);
enemyDamaged(&testenemy, &testplayer);
// assert // assert
TEST_ASSERT_EQUAL(expectedEnemyHealth, getEnemyHealth(&testenemy)); TEST_ASSERT_EQUAL(expectedEnemyHealth, getEnemyHealth(&testenemy));
} }
@ -147,7 +147,7 @@ void test_PlayerAttacksEnemy_DoesMinDamage(void)
// health - (damage - armor) // health - (damage - armor)
int expectedEnemyHealth = 49; int expectedEnemyHealth = 49;
// act // act
enemyDamaged(&testenemy,&testcharacter);
enemyDamaged(&testenemy,&testplayer);
// assert // assert
TEST_ASSERT_EQUAL(expectedEnemyHealth, getEnemyHealth(&testenemy)); TEST_ASSERT_EQUAL(expectedEnemyHealth, getEnemyHealth(&testenemy));
} }
@ -188,7 +188,7 @@ void test_FightPlayerWins(void)
int result; int result;
// act // act
//strength,dexterity,intelligence,healthPoints,manaPoints,level,exp,maxExp,attack,armor,maxHealthPoints; //strength,dexterity,intelligence,healthPoints,manaPoints,level,exp,maxExp,attack,armor,maxHealthPoints;
Character testChar = {10,10,10,playerHealth,100,1,0,100,playerDamage,playerArmor,playerMaxHealth};
Player testChar = {10,10,10,playerHealth,100,1,0,100,playerDamage,playerArmor,playerMaxHealth};
playerInputChar_ExpectAndReturn('a'); playerInputChar_ExpectAndReturn('a');
enemy test = {enemyHealth, enemyDamage, enemyArmor, enemyMaxHealth}; enemy test = {enemyHealth, enemyDamage, enemyArmor, enemyMaxHealth};
result = fight(&testChar, &test); result = fight(&testChar, &test);
@ -203,7 +203,7 @@ void test_FightEnemyWins(void)
int enemyHealth = 100, enemyDamage = 4, enemyArmor = 4, enemyMaxHealth = 100; int enemyHealth = 100, enemyDamage = 4, enemyArmor = 4, enemyMaxHealth = 100;
int result; int result;
// act // act
Character testChar = {10,10,10,playerHealth,100,1,0,100,playerDamage,playerArmor,playerMaxHealth};
Player testChar = {10,10,10,playerHealth,100,1,0,100,playerDamage,playerArmor,playerMaxHealth};
playerInputChar_ExpectAndReturn('a'); playerInputChar_ExpectAndReturn('a');
randomInt_ExpectAndReturn(1); randomInt_ExpectAndReturn(1);
enemy test = {enemyHealth, enemyDamage, enemyArmor, enemyMaxHealth}; enemy test = {enemyHealth, enemyDamage, enemyArmor, enemyMaxHealth};
@ -219,7 +219,7 @@ void test_FightPlayerChoosesAttack(void)
int enemyHealth = 6, enemyDamage = 4, enemyArmor = 4, enemyMaxHealth = 100; int enemyHealth = 6, enemyDamage = 4, enemyArmor = 4, enemyMaxHealth = 100;
int result; int result;
// act // act
Character testChar = {10,10,10,playerHealth,100,1,0,100,playerDamage,playerArmor,playerMaxHealth};
Player testChar = {10,10,10,playerHealth,100,1,0,100,playerDamage,playerArmor,playerMaxHealth};
playerInputChar_ExpectAndReturn('a'); playerInputChar_ExpectAndReturn('a');
enemy test = {enemyHealth, enemyDamage, enemyArmor, enemyMaxHealth}; enemy test = {enemyHealth, enemyDamage, enemyArmor, enemyMaxHealth};
fight(&testChar, &test); fight(&testChar, &test);
@ -235,7 +235,7 @@ void test_FightPlayerHeals_thenAttacks_Wins(void)
int enemyHealth = 11, enemyDamage = 4, enemyArmor = 4, enemyMaxHealth = 100; int enemyHealth = 11, enemyDamage = 4, enemyArmor = 4, enemyMaxHealth = 100;
int result; int result;
// act // act
Character testChar = {10,10,10,playerHealth,100,1,0,100,playerDamage,playerArmor,playerMaxHealth};
Player testChar = {10,10,10,playerHealth,100,1,0,100,playerDamage,playerArmor,playerMaxHealth};
enemy test = {enemyHealth, enemyDamage, enemyArmor, enemyMaxHealth}; enemy test = {enemyHealth, enemyDamage, enemyArmor, enemyMaxHealth};
playerInputChar_ExpectAndReturn('h'); playerInputChar_ExpectAndReturn('h');
randomInt_ExpectAndReturn(1); randomInt_ExpectAndReturn(1);
@ -254,7 +254,7 @@ void test_FightPlayerFlees(void)
int enemyHealth = 11, enemyDamage = 4, enemyArmor = 4, enemyMaxHealth = 100; int enemyHealth = 11, enemyDamage = 4, enemyArmor = 4, enemyMaxHealth = 100;
int result; int result;
// act // act
Character testChar = {10,10,10,playerHealth,100,1,0,100,playerDamage,playerArmor,playerMaxHealth};
Player testChar = {10,10,10,playerHealth,100,1,0,100,playerDamage,playerArmor,playerMaxHealth};
enemy test = {enemyHealth, enemyDamage, enemyArmor, enemyMaxHealth}; enemy test = {enemyHealth, enemyDamage, enemyArmor, enemyMaxHealth};
playerInputChar_ExpectAndReturn('f'); playerInputChar_ExpectAndReturn('f');
result = fight(&testChar, &test); result = fight(&testChar, &test);
@ -368,7 +368,7 @@ void test_enemyChoosesHeal_ThenAttackWins(void)
int playerHealth = 10, playerDamage = 10, playerArmor = 0, playerMaxHealth = 10; int playerHealth = 10, playerDamage = 10, playerArmor = 0, playerMaxHealth = 10;
enemy test = {enemyHealth, enemyDamage, enemyArmor, enemyMaxHealth,1 }; enemy test = {enemyHealth, enemyDamage, enemyArmor, enemyMaxHealth,1 };
//act //act
Character testChar = {10,10,10,playerHealth,100,1,0,100,playerDamage,playerArmor,playerMaxHealth};
Player testChar = {10,10,10,playerHealth,100,1,0,100,playerDamage,playerArmor,playerMaxHealth};
playerInputChar_ExpectAndReturn('a'); playerInputChar_ExpectAndReturn('a');
randomInt_ExpectAndReturn(39); //39%20 = 19 , 19 + 1 = 20 randomInt_ExpectAndReturn(39); //39%20 = 19 , 19 + 1 = 20
playerInputChar_ExpectAndReturn('a'); playerInputChar_ExpectAndReturn('a');
@ -392,8 +392,8 @@ void test_enemyHealsNoPotion(void)
int test_rollInitiative (void) { int test_rollInitiative (void) {
int initiative = rollInitiative(&testcharacter);
int initiative = rollInitiative(&testplayer);
TEST_ASSERT(testcharacter.dexterity + 1 <= initiative && testcharacter.dexterity + 20 >= initiative);
TEST_ASSERT(testplayer.dexterity + 1 <= initiative && testplayer.dexterity + 20 >= initiative);
} }
#endif // TEST #endif // TEST

52
test/c/test_spell.c
View File

@ -3,27 +3,27 @@
#include "character.h" #include "character.h"
#include "spell.h" #include "spell.h"
Character testCharacter;
Character testCharacter2;
Player testPlayer;
Player testPlayer2;
void setUp(void) void setUp(void)
{ {
testCharacter.healthPoints = 0;
testCharacter2.healthPoints = 15;
testCharacter.strength = 0;
testCharacter2.strength = 5;
testCharacter.dexterity = 0;
testCharacter2.dexterity = 5;
testCharacter.intelligence = 0;
testCharacter2.intelligence = 7;
testCharacter.level = 0;
testCharacter2.level = 5;
testCharacter.exp = 50;
testCharacter2.exp = 110;
testCharacter.maxExp = 100;
testCharacter2.maxExp = 100;
testCharacter.attack = 5;
testCharacter2.weaponClass = SWORD;
testPlayer.healthPoints = 0;
testPlayer2.healthPoints = 15;
testPlayer.strength = 0;
testPlayer2.strength = 5;
testPlayer.dexterity = 0;
testPlayer2.dexterity = 5;
testPlayer.intelligence = 0;
testPlayer2.intelligence = 7;
testPlayer.level = 0;
testPlayer2.level = 5;
testPlayer.exp = 50;
testPlayer2.exp = 110;
testPlayer.maxExp = 100;
testPlayer2.maxExp = 100;
testPlayer.attack = 5;
testPlayer2.weaponClass = SWORD;
} }
void tearDown(void) void tearDown(void)
@ -32,34 +32,34 @@ void tearDown(void)
void test_spellFireball(void) void test_spellFireball(void)
{ {
SpellEffect result = spellFireball(&testCharacter);
SpellEffect result = spellFireball(&testPlayer);
TEST_ASSERT_EQUAL_INT(10,result.damage); TEST_ASSERT_EQUAL_INT(10,result.damage);
result = spellFireball(&testCharacter2);
result = spellFireball(&testPlayer2);
TEST_ASSERT_EQUAL_INT(13,result.damage); TEST_ASSERT_EQUAL_INT(13,result.damage);
} }
void test_spellHeal(void) void test_spellHeal(void)
{ {
int result = spellHeal(&testCharacter).healing;
int result = spellHeal(&testPlayer).healing;
TEST_ASSERT_EQUAL_INT(10,result); TEST_ASSERT_EQUAL_INT(10,result);
result = spellHeal(&testCharacter2).healing;
result = spellHeal(&testPlayer2).healing;
TEST_ASSERT_EQUAL_INT(12,result); TEST_ASSERT_EQUAL_INT(12,result);
} }
void test_spellLightning(void) void test_spellLightning(void)
{ {
int result = spellLightning(&testCharacter).damage;
int result = spellLightning(&testPlayer).damage;
TEST_ASSERT_EQUAL_INT(10,result); TEST_ASSERT_EQUAL_INT(10,result);
result = spellLightning(&testCharacter2).damage;
result = spellLightning(&testPlayer2).damage;
TEST_ASSERT_EQUAL_INT(13,result); TEST_ASSERT_EQUAL_INT(13,result);
} }
void test_spellRegeneration(void) void test_spellRegeneration(void)
{ {
int result = spellRegeneration(&testCharacter).healing;
int result = spellRegeneration(&testPlayer).healing;
TEST_ASSERT_EQUAL_INT(5,result); TEST_ASSERT_EQUAL_INT(5,result);
result = spellRegeneration(&testCharacter2).healing;
result = spellRegeneration(&testPlayer2).healing;
TEST_ASSERT_EQUAL_INT(6,result); TEST_ASSERT_EQUAL_INT(6,result);
} }
#endif // TEST #endif // TEST
Write Preview
Loading…
Cancel
Save