C/C++ 전직

전직 및 전투시스템

// Actor.h

#pragma once
#include <iostream>
#include <string>

class Actor
{
protected:
    Actor(std::string jobname, int level, int hp, int mp, int atk, int def, int speed)
        : jobname(jobname), Level(level), HP(hp), MP(mp), ATK(atk), DEF(def), Speed(speed)
    {
    }

public:
    virtual void attack(Actor& target) = 0;
    virtual ~Actor() {}

    std::string getjobname();
    int getLevel();
    int getHP();
    int getMP();
    int getATK();
    int getDEF();
    int getSpeed();

    void setHP(int HP);
    void setMP(int MP);
    void setATK(int ATK);
    void setDEF(int DEF);
    void setSpeed(int Speed);

protected:
    std::string jobname;
    int Level;
    int HP;
    int MP;
    int ATK;
    int DEF;
    int Speed;

 

// Actor.cpp

#include "Actor.h"

std::string Actor::getjobname()
{
	return jobname;
}
int Actor::getLevel()
{
	return Level;
}
int Actor::getHP()
{
	return HP;
}
int Actor::getMP()
{
	return MP;
}
int Actor::getATK()
{
	return ATK;
}
int Actor::getDEF()
{
	return DEF;
}
int Actor::getSpeed()
{
	return Speed;
}

void Actor::setHP(int HP)
{
	this->HP = HP;
}
void Actor::setMP(int MP)
{
	this->MP = MP;
}
void Actor::setATK(int ATK)
{
	this->ATK = ATK;
}
void Actor::setDEF(int DEF)
{
	this->DEF = DEF;
}
void Actor::setSpeed(int Speed)
{
	this->Speed = Speed;
}

• Actor 클래스로 모든 살아있는 생명체의 뼈대
• Actor 클래스로 Player와 Monster로부터 파생된 모든 클래스의 부모 클래스

Actor 후손 Player 클래스

// Player.h

#pragma once
#include "Actor.h"
#include <iostream>
#include <string>

class Player : public Actor
{
protected:
    Player(std::string nickname,
        std::string job,
        int hp,
        int mp,
        int atk,
        int def,
        int acc,
        int speed)
        : Actor(job, 1, hp, mp, atk, def, speed),
        nickname(nickname),
        ACC(acc)
    {
    }

public:
    virtual void attack(Actor& target) = 0;
    virtual ~Player() {}
    void PlayerStatus();

    std::string getnickname();
    int getACC();

    void setnickname(std::string nickname);
    void setACC(int ACC);

protected:
    std::string nickname;
    int ACC;
};

 

// Player.cpp

#include "Player.h"
using namespace std;

std::string Player::getnickname()
{
    return nickname;
}

int Player::getACC()
{
    return ACC;
}

void Player::setnickname(std::string nickname)
{
    this->nickname = nickname;
}

void Player::setACC(int ACC)
{
    this->ACC = ACC;
}

void Player::PlayerStatus()
{
    std::cout << "==================================" << std::endl;
    std::cout << "닉네임 : " << nickname << std::endl;
    std::cout << "직업 : " << jobname << std::endl;
    std::cout << "레벨 : " << Level << std::endl;
    std::cout << "HP : " << HP << std::endl;
    std::cout << "MP : " << MP << std::endl;
    std::cout << "ATK : " << ATK << std::endl;
    std::cout << "DEF : " << DEF << std::endl;
    std::cout << "ACC : " << ACC << std::endl;
    std::cout << "Speed : " << Speed << std::endl;
    std::cout << "==================================" << std::endl;
}

• 대부분의 필요한 DNA들은 유전받고 추가적인 부분만 변이 파생해서 추가됨
• Actor 에서 받아온 기본 정보를 토대로 필요한 정보를 추가한 클래스

// Warrior.h

#pragma once
#include "Player.h"
class Warrior :
    public Player
{
public:
    Warrior(std::string nickname);

    virtual void attack(Actor& target) override;
};
-----------------------------------------------------
// Archer.h

#pragma once
#include "Player.h"
class Archer :
    public Player
{
public:
    Archer(std::string nickname);

    virtual void attack(Actor& target);
};
-----------------------------------------------------
// Magician.h

#pragma once
#include "Player.h"
class Magician :
    public Player
{
public:
    Magician(std::string nickname);

    virtual void attack(Actor& target) override;
};
-----------------------------------------------------
// Thief.h

#pragma once
#include "Player.h"
class Thief :
    public Player
{
public:
    Thief(std::string nickname);

    virtual void attack(Actor& target) override;
};

// Warrior.cpp

#include "Warrior.h"

Warrior::Warrior(std::string nickname)
	: Player(nickname, "전사", 2000, 200, 400, 10, 100, 100)
{
}

void Warrior::attack(Actor& target)
{
	int damage = this->ATK - target.getDEF();
	if (damage <= 0)
	{
		damage = 1;
	}
	int hp = target.getHP() - damage;
	target.setHP(hp);
	
	std::cout << "\n" << nickname << "님이 검을 휘둘러 공격하였습니다.\n" << std::endl;
}
-----------------------------------------
// Archer.cpp

#include "Archer.h"

Archer::Archer(std::string nickname)
	: Player(nickname, "궁수", 1200, 1000, 500, 1, 300, 200)
{
}

void Archer::attack(Actor& target)
{
	int damage = this->ATK - target.getDEF();
	if (damage <= 0)
	{
		damage = 1;
	}
	int hp = target.getHP() - damage;
	target.setHP(hp);
	std::cout << "\n" << nickname << "님이 활 시위를 당겻습니다.\n" << std::endl;
}
-----------------------------------------
// Magician.cpp

#include "Magician.h"

Magician::Magician(std::string nickname)
	: Player(nickname, "마법사", 200, 2000, 600, 1, 200, 100)
{
}

void Magician::attack(Actor& target)
{
	int damage = this->ATK - target.getDEF();
	if (damage <= 0)
	{
		damage = 1;
	}
	int hp = target.getHP() - damage;
	target.setHP(hp);
	std::cout << "\n" << nickname << "님이 파이어볼 주문을 외웠습니다..\n" << std::endl;
}
-----------------------------------------
// Thief.cpp

#include "Thief.h"

Thief::Thief(std::string nickname) 
	: Player(nickname, "도적", 1200, 1000, 450, 2, 200, 200)
{
}

void Thief::attack(Actor& target)
{
	int damage = this->ATK - target.getDEF();
	if (damage <= 0)
	{
		damage = 1;
	}
	int hp = target.getHP() - damage;
	target.setHP(hp);
	std::cout << "\n" << nickname << "님이 표창을 던졋습니다.\n" << std::endl;
}

• Actor 할아버지의 DNA를 이어받은 Player 의 DNA를 이어받은 생명체들이다.
• Actor -> Player -> Warrior , Archer .... 등등 클래스이다.

// Monster.h

#pragma once
#include "Actor.h"
#include <iostream>
#include <string>

class Monster : public Actor
{
protected:
    Monster(std::string name,
        std::string jobname,
        int level,
        int hp,
        int mp,
        int atk,
        int def,
        int speed)
        : Actor(jobname, level, hp, mp, atk, def, speed),
        name(name)
    {
    }

public:
    virtual ~Monster() {}
    void MonsterStatus();

    std::string getname();
    void setname(std::string name);

protected:
    std::string name;
};

// Monster.cpp

#include "Monster.h"

using namespace std;

std::string Monster::getname()
{
	return name;
}


void Monster::setname(std::string name)
{
	this->name = name;
}


void Monster::MonsterStatus()
{
	std::cout << "==================================" << std::endl;
	std::cout << "종족 : " << name << std::endl;
	std::cout << "직업 : " << jobname << std::endl;
	std::cout << "레벨 : " << Level << std::endl;
	std::cout << "HP : " << HP << std::endl;
	std::cout << "MP : " << MP << std::endl;
	std::cout << "ATK : " << ATK << std::endl;
	std::cout << "DEF : " << DEF << std::endl;
	std::cout << "Speed : " << Speed << std::endl;
	std::cout << "==================================" << std::endl;
}

• Actor로 부터 파생된 클래스로 Player 와는 다른 Monster 클래스

// Ork.h

#pragma once
#include "Monster.h"

class Ork :
    public Monster
{
public:
    Ork();

    virtual void attack(Actor& target) override;
};

// Ork.cpp

#include "ork.h"

Ork::Ork()
	: Monster("오크", "오크 전사", 13, 5000, 0, 20, 60, 50)
{
}

void Ork::attack(Actor& target)
{
	int damage = this->ATK - target.getDEF();
	if (damage <= 0)
	{
		damage = 1;
	}
	int hp = target.getHP() - damage;
	target.setHP(hp);
	std::cout << "\n오크 전사의 몽둥이 휘두르기 강타!\n" << std::endl;

}

• Monster 클래스로부터 DNA를 이어받아 형체가 완성된 Ork 클래스
• Actor -> Monster -> Ork 구조

• 이런식으로 반복 턴제가 되겠다.

개선 및 배운점과 느낀점

• include <ctime> , rend() 100% 를 사용해 회피를 구현했다.
• 처음 Player 와 Monster 가 부모 클래스 없이 개별 클래스라 어떻게 서로 공격하고 피해를 받나 햇다가 방법을 모르겟어서 그냥 부모 클래스를 만들어버렷다.
• 부모 클래스 추가 후 자꾸 attack()가 이상한데 연결되길래 구글링을 통해 해결법을 찾다보니 부모클래스에 있는 내용이 자식클래스에 같이 있어서 문제가 생긴거라는걸 배웠다.
• 다음에 만들땐 첫 설계구간에서 큰틀을 정해두고 시작해야겟다