My Dynamic Memory is affecting my non-dy

Forum

Forum
General C++ Programming
My Dynamic Memory is affecting my non-dy

My Dynamic Memory is affecting my non-dynamic values.

[tt]Okay, so i'm implementing a playerclass for a game.. in the game there are multiple player types, weapons ect.. i just wanted to turn my players weapons into a dynamically allocated c_str. once i added my: Destructor, Copy Constructor and Overloaded Assignment Operator. My initial values became corrupted and i cannot fix them.. any suggestions?

Player2.cpp

#include <string.h>
#include <iostream>
#include <cstdlib>
#include <iostream>
#include "player2.h"
#include "dice.h"
#include "gamespace.h"

using namespace std;

PlayerClass::PlayerClass(){
    string name = "DEFAULT";
    SetSpider(name);
    weaponName = NULL;    
    return;}

PlayerClass::~PlayerClass()
{
    delete[] weaponName;
}
PlayerClass::PlayerClass(string player_name, char kind = 'S'){
    int i = 0;    
    if((player_name.length() > 20) || (player_name.length() < 1)) 
    player_name = "DEFAULT";    
    while(isspace(player_name.at(i)))
    i++;    
    player_name = player_name.substr(i,player_name.length());
      
    while(isspace(player_name[player_name.length()-1]))
    player_name.erase(player_name.length()-1);
 

    return;
}

bool PlayerClass::Active(){
    active = false;
    if(health>0)
    active = true;
    return active;}
bool PlayerClass::InActive(){
    active = false;    
    return active;}
bool PlayerClass::Dead(){
    health = 0;
    willpower = 0;
    active = false;
    return true;
}
bool PlayerClass::Heal(){
    if(active)    {
    health += 10;
    if(health>maxHealth)
        health = maxHealth;
    currentSpeed = maxSpeed;   }
    return active;
}
int PlayerClass::ResetMomentum(){
    momentum = currentSpeed;
    return momentum;}
int PlayerClass::UseMomentum(int num){
    if((momentum - num)<0){
    num = momentum;
    momentum = 0;  }
    else
    momentum -= num;
    return num;}

string PlayerClass::Name() const
{
    return name;
}
char PlayerClass::Type() const
{
    char returnChar;
}
int PlayerClass::Health() const
{
    return health;
}
int PlayerClass::WillPower() const
{
    return willpower;
}
int PlayerClass::MaxSpeed() const
{
    return maxSpeed;
}
int PlayerClass::CurrentSpeed() const
{
    return currentSpeed;
}
int PlayerClass::Power() const
{
    return power;
}
int PlayerClass::Armor() const
{
    return defArmorValue;
}
int PlayerClass::Momentum() const
{
    return momentum;
}
bool PlayerClass::IsAlive() const
{
    return (health>0);
}
bool PlayerClass::IsDead() const
{
    return (health<=0);
}
bool PlayerClass::IsActive() const
{
    return active;
}

PlayerClass::PlayerClass(const PlayerClass& p){
    weaponName = new char;
}

PlayerClass& PlayerClass::operator= (const PlayerClass& p){
    if(this != &p){
        delete[] weaponName;
        weaponName = NULL;
        if(p.weaponName != NULL){
            weaponName = new char[strlen(p.weaponName)+1];
            strcpy(weaponName, p.weaponName);
        }
    }
    return *this;
}


bool PlayerClass::operator == (const PlayerClass& p)//COMPLETE
{
    string first, second;
    
    for(int i=0;i<name.length();i++)
    first += tolower(name[i]);
    
    for(int i=0;i<p.name.length();i++)
    second += tolower(p.name[i]);
    
    return first == second;
}
bool PlayerClass::operator != (const PlayerClass& p)//COMPLETE
{
    string first, second;
    
    for(int i=0;i<name.length();i++)
    first += tolower(name[i]);
    
    for(int i=0;i<p.name.length();i++)
    second += tolower(p.name[i]);
    
    return first != second;
}
bool PlayerClass::operator < (const PlayerClass& p)
{
    string first, second;
    
    for(int i=0;i<name.length();i++)
    first += tolower(name[i]);
    
    for(int i=0;i<p.name.length();i++)
    second += tolower(p.name[i]);
    
    return first < second;
}
bool PlayerClass::operator > (const PlayerClass& p)
{
    string first, second;
    
    for(int i=0;i<name.length();i++)
    first += tolower(name[i]);
    
    for(int i=0;i<p.name.length();i++)
    second += tolower(p.name[i]);
    
    return first > second;
}
bool PlayerClass::operator <= (const PlayerClass& p)
{
    string first, second;
    
    for(int i=0;i<name.length();i++)
    first += tolower(name[i]);
    
    for(int i=0;i<p.name.length();i++)
    second += tolower(p.name[i]);
    
    return first <= second;
}
bool PlayerClass::operator >= (const PlayerClass& p)
{
    string first, second;
    
    for(int i=0;i<name.length();i++)
    first += tolower(name[i]);
    
    for(int i=0;i<p.name.length();i++)
    second += tolower(p.name[i]);
    
    return first >= second;
}


void PlayerClass::SetWarrior(string str){
    health = 81;
    maxHealth = 81;
    willpower = 9;
    maxSpeed = 5;
    currentSpeed = 5;
    momentum = 0;
    power = 9;
    physicalDiceNumber = 3;
    physicalDiceSides = 6;
    defArmorValue = 8;
    weaponSkill = 5;
    isHuman = true;
    active = false;
    weapon = ASSAULTRIFLE;
    wepName = "Assault Rifle";
    weaponName = new char[(wepName.length() + 1)];
    strcpy(weaponName, wepName.c_str());
    type = WARRIOR;
    name = str;
    SetCell(0,0);
}
void PlayerClass::SetExplorer(string str) 
    health = 42;
    maxHealth = 42;
    willpower = 7;
    maxSpeed = 8;
    currentSpeed = 8;
    momentum = 0;
    power = 6;
    physicalDiceNumber = 1;
    physicalDiceSides = 6;
    defArmorValue = 0;
    weaponSkill = 10;
    isHuman = true;
    active = false;
    weapon = PISTOL;
    wepName = "Pistol";
    weaponName = new char[(wepName.length() + 1)];
    strcpy(weaponName, wepName.c_str());
    type = EXPLORER;
    name = str;
    SetCell(0,0);       
}

int PlayerClass::SlowDown(int hazard) //COMPLETE
{
    currentSpeed = currentSpeed - hazard;
    
    if(currentSpeed <= 0)
        currentSpeed = 0;
    if(momentum > currentSpeed)
        momentum = currentSpeed;
    
    return currentSpeed;
}

int PlayerClass::Wounded(int damage) //COMPLETE{
    int Health = health - damage;
    if(Health <= 0 || willpower <=0){
        Health = 0;
        Dead();
    } else {
        health = Health;    }
    
    return Health;}

int PlayerClass::Damage() //COMPLETE
{
    int damage = 0;
    if(damage < 1){ //weaponName != NULL){
        damage = WPNDAM + weaponSkill;
        cout << endl << endl << "WEAPON DAMAGE DEALT: ";  //for testing purposes ONLY!!!!!
    } else {
        cout << endl << endl << "PHYSICAL DAMAGE DEALT: "; //for testing purposes ONLY!!!!!
        damage = Dice::Roll(name, IMPACT, physicalDiceNumber, physicalDiceSides);
    }
    return damage;
}

const int PlayerClass::WeaponSkill() //COMPLETE
{
    int skill = 0;
    
    if(isHuman)
        skill = weaponSkill;
        
    return skill;
}
const bool PlayerClass::HasWeapon(){
    bool hasWeapon = false;    
    if(weaponName != NULL)
        hasWeapon = true;    
    return hasWeapon;}
int PlayerClass::Impact() //COMPLETE{
    int impact = 0;
    int diceRoll = Dice::Roll(name, IMPACT, physicalDiceNumber, physicalDiceSides);
    int tmpPower = power;
    if(active = true)    {
        if( power > 1)        {
            if(HasWeapon())
                tmpPower = WPNPOW;
            if(0 < diceRoll || diceRoll <= 12){
                impact = IMPACT_TABLE[tmpPower][diceRoll];
                cout << endl << endl << "Impact: ";  //for testing purposes ONLY!!!!!
                if( 10 < impact < 0)
                    impact = -1;    }        }        }
    return impact;
}

bool PlayerClass::CriticalWound() //COMPLETE
{    
    if(health > 10){
        int diceRoll = Dice::Roll(name, WOUND, physicalDiceNumber, physicalDiceSides);
            int critical = WOUND_TABLE[WPNPOW][diceRoll];
            
    return IsAlive();
}
//*******************************************\\

bool PlayerClass::DropWeapon() //COMPLETE
{
    delete[] weaponName;
    weaponName = NULL;
    return isHuman;
}
bool PlayerClass::GrabWeapon(string weapon, int skill)
{
    bool weaponGrabbed = false;
    if(IsActive() & isHuman & skill > 0)
        DropWeapon();
        if((weapon.length()) > 0){
            weaponName = new char[(weapon.length() + 1)];
            strcpy(weaponName, weapon.c_str());
            weaponGrabbed = true;}
    return weaponGrabbed;
}

xxsammyxx (7)

#ifndef PLAYER_2_H
#define PLAYER_2_H

#include <iostream>
#include <string>

using namespace std;

enum PlayerTypeT{EXPLORER, WARRIOR, HORNET, KILLERANT, SPIDER}; //The type of the player
enum WeaponT{PISTOL, ASSAULTRIFLE, GRENADE, HEAVYWEAPON, NULLWEAPON}; //The weapons that// players can use

static const int WPNDAM = 6; //Temporary
static const int WPNPOW = 5; //Temporary

static const int IMPACT_TABLE[13][13] = {
/*Power:      0  1  2  3  4  5  6  7  8  9  10 11 12 */
/*Roll: 0*/ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
/*Roll: 1*/ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
/*Roll: 2*/ { 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10},
/*Roll: 3*/ { 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,-1},
/*Roll: 4*/ { 0, 0, 2, 3, 4, 5, 6, 7, 8, 9,10,-1,-1},
/*Roll: 5*/ { 0, 0, 3, 4, 5, 6, 7, 8, 9,10,-1,-1,-1},
/*Roll: 6*/ { 0, 0, 4, 5, 6, 7, 8, 9,10,-1,-1,-1,-1},
/*Roll: 7*/ { 0, 0, 5, 6, 7, 8, 9,10,-1,-1,-1,-1,-1},
/*Roll: 8*/ { 0, 0, 6, 7, 8, 9,10,-1,-1,-1,-1,-1,-1},
/*Roll: 9*/ { 0, 0, 7, 8, 9,10,-1,-1,-1,-1,-1,-1,-1},
/*Roll:10*/ { 0, 0, 8, 9,10,-1,-1,-1,-1,-1,-1,-1,-1},
/*Roll:11*/ { 0, 0, 9,10,-1,-1,-1,-1,-1,-1,-1,-1,-1},
/*Roll:12*/ { 0, 0,10,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1}
}; //(note:  -1 = wound)
 
 
static const int WOUND_TABLE[13][13] = {
/*WP Rating:  0  1  2  3  4  5  6  7  8  9  10 11 12 */
/*Roll: 0*/ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
/*Roll: 1*/ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
/*Roll: 2*/ { 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,-1},
/*Roll: 3*/ { 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1,-1,-1},
/*Roll: 4*/ { 0, 0, 1, 1, 1, 1, 1, 1, 1, 1,-1,-1,-1},
/*Roll: 5*/ { 0, 0, 1, 1, 1, 1, 1, 1, 1,-1,-1,-1,-1},
/*Roll: 6*/ { 0, 0, 1, 1, 1, 1, 1, 1,-1,-1,-1,-1,-1},
/*Roll: 7*/ { 0, 0, 1, 1, 1, 1, 1,-1,-1,-1,-1,-1,-1},
/*Roll: 8*/ { 0, 0, 1, 1, 1, 1,-1,-1,-1,-1,-1,-1,-1},
/*Roll: 9*/ { 0, 0, 1, 1, 1,-1,-1,-1,-1,-1,-1,-1,-1},
/*Roll:10*/ { 0, 0, 1, 1,-1,-1,-1,-1,-1,-1,-1,-1,-1},
/*Roll:11*/ { 0, 0, 1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1},
/*Roll:12*/ { 0, 0,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1}
}; //(note: 1 = kill)

struct CellT{int col; int row;}; //Used to store where the player is on the game board

class PlayerClass{

    public:
	PlayerClass(string player_name, char kind); //Constructor; sets stats to those of the type and the name to str
		
	~PlayerClass();//Destructor, Removes all dynamic portions of the class
				
	PlayerClass(const PlayerClass& p);
	
	PlayerClass& operator = (const PlayerClass& p);
	
	bool Active(); //Sets the player to active, but only if they are alive
		    
	bool InActive(); //Sets the player to inactive
			
	bool Dead(); //Sets a players health and willpower to 0 and sets them to inactive
		
	bool Heal(); //Raises a players health by 10. If the new health would exceed max health, health is set to max health
		
	int ResetMomentum(); //Sets a player's momentum equal to their current speed
			
	int UseMomentum(int num); //Adjusts a player's momentum after an action is completed
			
	bool SetCell(int newRow, int newCol); //Places a player at a valid coordinate on the board
		    
	int Row() const;//Observer for the current row of the player
		
	int Col() const;//Observer for the current column of the player
		
	string Name() const;//Observer for the name of the player
			
	char Type() const;//Observer for the type of the player; returns a corresponding capital letter to their type
			
	int Health() const;//Observer for the health of the player
		
	int WillPower() const;//Observer for the willpower of the player
		
	int MaxSpeed() const;//Observer for the maximum speed of the player
		
	int CurrentSpeed() const;//Observer for the current speed of the player

	int Power() const;//Observer for the power of the player

	int Armor() const;//Observer for the armor of the player

	int Momentum() const;//Observer for the momentum of the player

	bool IsAlive() const;//Observer for the player's condition; returns true if alive, false if dead

	bool IsDead() const;//Observer for the player's condition; returns true if dead, false if alive
	
	bool IsActive() const;//Observer for the player's activity; returns true if active, false if inactive
	
	bool IsMyEnemy(PlayerClass *p);//Form of comparing players; true if one player is human and the other is a bug or if
			//both players are bugs & they are different types of bugs

	int SlowDown(int hazard);//Reduces the players current speed by the hazard
currentspeed=momentum
	int ResetCurrentSpeed();//Sets players currentspeed to MaxSpeed
		
	int Wounded(int damage);//Removes the damage from the players health if possible
	int Damage();//Determines the amount of damage dealt by a player
		
	int Impact();//Determines the impact of a critical wound done on a player

	const int WeaponSkill();//Returns the value of a players WeaponSkill
	
	const string WeaponName();//Returns the name of the weapon currently being held
			
	const bool HasWeapon();//Verifies if the player is holding a weapon or not
			
	bool CriticalWound();//If a critical wound is hit, this applies the results 
			
	bool DropWeapon();//Drops the weapon if the player has one
			
	bool GrabWeapon(string weapon, int skill);//Grabs a weapon if the player is elidgable
			
	

//    private:
    PlayerClass(); //Default Constructor; sets stats to Spider with name "Default"
	void CopyPlayer(PlayerClass* to, const PlayerClass* from); //Copy Constructor for this class.
		
	string wepName;
	string name;
	int health;
	int maxHealth;
	int willpower;
	int maxSpeed;
	int currentSpeed;
	int momentum;
	int power;
	int physicalDiceNumber
	int physicalDiceSides;
	int defArmorValue;
	int weaponSkill;
	char * weaponName;
	bool isHuman;					
	bool active;					
	WeaponT weapon;					
	PlayerTypeT type;				
	void SetWarrior(string str);//Sets the players stats to those of a warrior with name of str
	void SetExplorer(string str);//Sets the players stats to those of a explorer with name of str
	void SetKillerAnt(string str);//Sets the players stats to those of a killerant with name of str
	void SetSpider(string str);//Sets the players stats to those of a spider with name of str
	void SetHornet(string str);//Sets the players stats to those of a hornet with name of str
	
};

#endif

TestDriver.C

#include "player2.h"
#include "gamespace.h"
#include <iostream>
using namespace GameSpace;
using namespace std;
void Display(PlayerClass p, string Change){
        cout << endl << "Testing: " << Change << endl << endl;
        cout << "Name: " <<  p.name  << endl;
        cout << "Health: " << p.health << endl;
        cout << "Max Health: " << p.maxHealth << endl;
        cout << "Max Speed: " <<  p.maxSpeed << endl;
        cout << "Current Speed: " <<p.currentSpeed << endl;
        cout << "Power: " << p.power << endl;
        cout << "Willpower: " <<  p.willpower << endl;
        cout << "Active: "  <<p.active << endl;
        cout << "Momentum: " << p.momentum << endl;
//      cout << "Player Has Weapon: " << p.HasWeapon() << endl;
        cout << "Weapon Skill: " << p.weaponSkill << endl;
//      if(p.HasWeapon())
//              cout << "Weapon Name: " << p.weaponName << endl;
        cout << endl << endl << endl;

        return;
}


int main(){

        PlayerClass WARRIOR = PlayerClass("Warrior", 'W');
        WARRIOR.name = "SAMMY";
        Display(WARRIOR, "STATS");

Topic archived. No new replies allowed.

C++

Forum

My Dynamic Memory is affecting my non-dynamic values.