Глава №4. Итоговый тест

Обновл. 21 Апр 2019 |

15159

ǀ 18

В этой главе мы рассмотрели много материала. Если вы дошли до этого момента, то я вас поздравляю — вы проделали немало работы и это уже хороший шаг на пути к изучению C++ и программирования! Сейчас же давайте закрепим пройденный материал.

Теория

Блок стейтментов (или ещё «составной оператор») обрабатывается компилятором так, как если бы это был один стейтмент. Составные операторы помещаются в фигурные скобки ({ и }) и используются почти везде.

Локальные переменные создаются в точке определения и уничтожаются при выходе из блока, в котором они объявлены. Доступ к ним возможен только внутри этого же блока.

Глобальные переменные создаются, когда программа запускается, и уничтожаются, когда она завершает своё выполнение. Они могут использоваться в любом месте программы. Неконстантные глобальные переменные следует избегать, потому что это зло.

Ключевое слово static может использоваться для преобразования глобальной переменной во внутреннюю (с внутренней связью), чтобы её можно было использовать только в том файле, в котором она объявлена. Также ключевое слово static используют, чтобы указать, что локальная переменная должна иметь статическую продолжительность. А это означает, что она будет сохранять своё значение даже после выхода из своей области видимости.

Пространство имён — это область, в которой гарантируется уникальность всех имён. Отличный способ избежать конфликтов имён. Не используйте стейтменты using вне тела функций.

Неявное преобразование типов данных происходит, когда один тип данных конвертируется в другой тип без использования одного из операторов casts. Явное преобразование типа происходит, когда один тип данных конвертируется в другой с помощью одного из операторов casts. В некоторых случаях это абсолютно безопасно, в некоторых — данные могут быть потеряны. Избегайте использования C-style cast, вместо него используйте оператор static_cast.

std::string — это простой способ работы с текстовыми строками (текст помещается в двойные кавычки).

Перечисления позволяют создавать собственные типы данных. Это отличный вариант для создания категорий или рубрик. Классы enum — это те же перечисления, но надёжнее и безопаснее. Используйте их вместо обычных перечислений, если ваш компилятор поддерживает C++11.

typedef позволяет создавать псевдонимы для типов данных. Целочисленные типы данных с фиксированным размером реализованы с помощью typedef. Псевдонимы типов полезны для присваивания простых имён сложным типам данных.

И, наконец, структуры. Они позволяют сгруппировать отдельные переменные в единое целое. Доступ к членам структуры осуществляется через оператор выбора членов (.). Объектно-ориентированное программирование в значительной степени основывается именно на структурах, поэтому, если вы изучили только одну вещь из этой главы, то лучше, чтобы это были структуры.

Тест

При разработке игры мы решили, что в ней должны быть монстры, потому что всем нравится сражаться с монстрами. Объявите структуру, которая представляет вашего монстра. Монстр может быть разным: ogre, goblin, skeleton, orc и troll. Если ваш компилятор поддерживает C++11, то используйте классы enum. Если нет, то обычные перечисления.

Каждый монстр также должен иметь имя (используйте std::string) и количество здоровья, которое отображает, сколько урона он может получить, прежде чем умрёт. Напишите функцию printMonster(), которая выведет все члены структуры. Объявите монстров типа goblin и orc, инициализируйте их, используя список инициализаторов, и передайте в функцию printMonster().

Примерный результат выполнения вашей программы:

This Goblin is named John and has 170 health. This Orc is named James and has 35 health.

Ответ C++11

#include <iostream>
#include <string>
 
// Определяем класс enum с типами монстров 
enum class MonsterType
{
    OGRE,
    GOBLIN,
    SKELETON,
    ORC,
    TROLL
};
 
// Наша структура представляет одного монстра
struct Monster
{
	MonsterType type;
	std::string name;
	int health;
};
 
// Возвращаем тип монстра в виде строки
std::string getMonsterTypeString(Monster monster)
{
	if (monster.type == MonsterType::OGRE)
		return "Ogre";
	if (monster.type == MonsterType::GOBLIN)
		return "Goblin";
	if (monster.type == MonsterType::SKELETON)
		return "Skeleton";
	if (monster.type == MonsterType::ORC)
		return "Orc";
	if (monster.type == MonsterType::TROLL)
		return "Troll";
 
	return "Unknown";
}
 
// Выводим информацию о монстре
void printMonster(Monster monster)
{
	std::cout << "This " << getMonsterTypeString(monster);
	std::cout << " is named " << monster.name << " and has " << monster.health << " health.\n";
}
 
int main()
{
	Monster goblin = { MonsterType::GOBLIN, "John", 170 };
	Monster orc = { MonsterType::ORC, "James", 35 };
 
	printMonster(goblin);
	printMonster(orc);
 
	return 0;
}

#include <iostream>

#include <string>

// Определяем класс enum с типами монстров

enum class MonsterType

{

OGRE,

GOBLIN,

SKELETON,

ORC,

TROLL

};

// Наша структура представляет одного монстра

struct Monster

{

MonsterType type;

std::string name;

int health;

};

// Возвращаем тип монстра в виде строки

std::string getMonsterTypeString(Monster monster)

{

if (monster.type == MonsterType::OGRE)

return "Ogre";

if (monster.type == MonsterType::GOBLIN)

return "Goblin";

if (monster.type == MonsterType::SKELETON)

return "Skeleton";

if (monster.type == MonsterType::ORC)

return "Orc";

if (monster.type == MonsterType::TROLL)

return "Troll";

return "Unknown";

}

// Выводим информацию о монстре

void printMonster(Monster monster)

{

std::cout << "This " << getMonsterTypeString(monster);

std::cout << " is named " << monster.name << " and has " << monster.health << " health.\n";

}

int main()

{

Monster goblin = { MonsterType::GOBLIN, "John", 170 };

Monster orc = { MonsterType::ORC, "James", 35 };

printMonster(goblin);

printMonster(orc);

return 0;

}

Ответ до С++11

#include <iostream>
#include <string>
 
// Определяем перечисление с типами монстров 
enum MonsterType
{
    MONSTER_OGRE,
    MONSTER_GOBLIN,
    MONSTER_SKELETON,
    MONSTER_ORC,
    MONSTER_TROLL
};
 
// Наша структура представляет одного монстра 
struct Monster
{
	MonsterType type;
	std::string name;
	int health;
};
 
// Возвращаем тип монстра в виде строки
std::string getMonsterTypeString(Monster monster)
{
	if (monster.type == MONSTER_OGRE)
		return "Ogre";
	if (monster.type == MONSTER_GOBLIN)
		return "Goblin";
	if (monster.type == MONSTER_SKELETON)
		return "Skeleton";
	if (monster.type == MONSTER_ORC)
		return "Orc";
	if (monster.type == MONSTER_TROLL)
		return "Troll";
 
	return "Unknown";
}
 
// Выводим информацию о монстре
void printMonster(Monster monster)
{
	std::cout << "This " << getMonsterTypeString(monster);
	std::cout << " is named " << monster.name << " and has " << monster.health << " health.\n";
}
 
int main()
{
	Monster goblin = { MONSTER_GOBLIN, "John", 170};
	Monster orc = { MONSTER_ORC, "James", 35};
 
	printMonster(goblin);
	printMonster(orc);
 
	return 0;
}

#include <iostream>

#include <string>

// Определяем перечисление с типами монстров

enum MonsterType

{

MONSTER_OGRE,

MONSTER_GOBLIN,

MONSTER_SKELETON,

MONSTER_ORC,

MONSTER_TROLL

};

// Наша структура представляет одного монстра

struct Monster

{

MonsterType type;

std::string name;

int health;

};

// Возвращаем тип монстра в виде строки

std::string getMonsterTypeString(Monster monster)

{

if (monster.type == MONSTER_OGRE)

return "Ogre";

if (monster.type == MONSTER_GOBLIN)

return "Goblin";

if (monster.type == MONSTER_SKELETON)

return "Skeleton";

if (monster.type == MONSTER_ORC)

return "Orc";

if (monster.type == MONSTER_TROLL)

return "Troll";

return "Unknown";

}

// Выводим информацию о монстре

void printMonster(Monster monster)

{

std::cout << "This " << getMonsterTypeString(monster);

std::cout << " is named " << monster.name << " and has " << monster.health << " health.\n";

}

int main()

{

Monster goblin = { MONSTER_GOBLIN, "John", 170};

Monster orc = { MONSTER_ORC, "James", 35};

printMonster(goblin);

printMonster(orc);

return 0;

}

Оценить статью:

(106 оценок, среднее: 4,92 из 5)

Загрузка...

Комментариев: 18

Марат:

25 декабря 2019 в 09:08

#include <iostream>

using namespace std;

enum class MonsterType
{
    RAT,
    GOBLIN,
    SKELETON,
    ORC,
    OGRE,
    TROLL
};

struct TheMonster
{
    MonsterType monsterType;
    string name;
    short health;

};

TheMonster fillMonsterType(TheMonster monster, MonsterType monsterType);

TheMonster fillMonster(string name, MonsterType monsterType)
{
    TheMonster tempMonster;
    tempMonster.name = name;
    tempMonster.monsterType = monsterType;
    tempMonster = fillMonsterType(tempMonster, monsterType);

    return tempMonster;
}

TheMonster fillMonsterType(TheMonster monster, MonsterType monsterType)
{
    if (monsterType == MonsterType::GOBLIN)
    {
        monster.health = 10;
        monster.name+= " Goblin ";
    }
    else if (monsterType == MonsterType::SKELETON)
    {
        monster.health = 15;
        monster.name+= " Skeleton ";
    }
    else if (monsterType == MonsterType::ORC)
    {
        monster.health = 20;
        monster.name+= " Orc ";
    }
    else if (monsterType == MonsterType::OGRE)
    {
        monster.health = 30;
        monster.name+= " Ogre ";
    }
    else if (monsterType == MonsterType::TROLL)
    {
        monster.health = 70;
        monster.name+= " Troll ";
    }
    return monster;
}

void printMonster(TheMonster monster)
{
    cout << "Monster name: " << monster.name << " health: " << monster.health << endl;
}

int main()
{
    TheMonster skeletonGuard = fillMonster("Guard", MonsterType::SKELETON);
    TheMonster goblinBandit = fillMonster("Bandit", MonsterType::GOBLIN);
    TheMonster orcBerserc = fillMonster("Berserk", MonsterType::ORC);

    printMonster(skeletonGuard);
    printMonster(goblinBandit);
    printMonster(orcBerserc);

    return 0;
}

#include <iostream>

using namespace std;

enum class MonsterType

{

RAT,

GOBLIN,

SKELETON,

ORC,

OGRE,

TROLL

};

struct TheMonster

{

MonsterType monsterType;

string name;

short health;

};

TheMonster fillMonsterType(TheMonster monster, MonsterType monsterType);

TheMonster fillMonster(string name, MonsterType monsterType)

{

TheMonster tempMonster;

tempMonster.name = name;

tempMonster.monsterType = monsterType;

tempMonster = fillMonsterType(tempMonster, monsterType);

return tempMonster;

}

TheMonster fillMonsterType(TheMonster monster, MonsterType monsterType)

{

if (monsterType == MonsterType::GOBLIN)

{

monster.health = 10;

monster.name+= " Goblin ";

}

else if (monsterType == MonsterType::SKELETON)

{

monster.health = 15;

monster.name+= " Skeleton ";

}

else if (monsterType == MonsterType::ORC)

{

monster.health = 20;

monster.name+= " Orc ";

}

else if (monsterType == MonsterType::OGRE)

{

monster.health = 30;

monster.name+= " Ogre ";

}

else if (monsterType == MonsterType::TROLL)

{

monster.health = 70;

monster.name+= " Troll ";

}

return monster;

}

void printMonster(TheMonster monster)

{

cout << "Monster name: " << monster.name << " health: " << monster.health << endl;

}

int main()

{

TheMonster skeletonGuard = fillMonster("Guard", MonsterType::SKELETON);

TheMonster goblinBandit = fillMonster("Bandit", MonsterType::GOBLIN);

TheMonster orcBerserc = fillMonster("Berserk", MonsterType::ORC);

printMonster(skeletonGuard);

printMonster(goblinBandit);

printMonster(orcBerserc);

return 0;

}

Ответить

Владимир:

8 декабря 2019 в 17:03

#include<iostream>
#include<string>

using std::cout;
using std::string;

struct Monster
{
	string name;
	int helth;
};

Monster goblin = { "goblin Jon", 100 };
Monster orc = { "orc James", 60 };

void printMonster(Monster a)
{
	cout << "\n\tName of monster is " << a.name;
	cout << "\n\tActual helth of " << a.name << " is " << a.helth<<"\n\n\n";
}

int main()
{
	printMonster( goblin);
	printMonster(orc);
	return 0;
}

#include<iostream>

#include<string>

using std::cout;

using std::string;

struct Monster

{

string name;

int helth;

};

Monster goblin = { "goblin Jon", 100 };

Monster orc = { "orc James", 60 };

void printMonster(Monster a)

{

cout << "\n\tName of monster is " << a.name;

cout << "\n\tActual helth of " << a.name << " is " << a.helth<<"\n\n\n";

}

int main()

{

printMonster( goblin);

printMonster(orc);

return 0;

}

Ответить

Aur1IIad0r:

17 марта 2019 в 17:47

// Example program

#include <iostream>
#include <string>

enum class type { OGRE, GOBLIN, SKELETON, ORC, TROLL };

struct Monster
{
	type monsterType;
	std::string name;
	int hp;
};

std::string getMonsterType(type monstID);
void printMonster(Monster monst);

int main()
{
	Monster m1 = { type::GOBLIN, "John", 100 };
	Monster m2 = { type::ORC, "James", 35 };

	printMonster(m1);
	printMonster(m2);

	system("pause");

	return 0;
}

std::string getMonsterType(type monstID)
{
	if (monstID == type::OGRE) return "Ogre";
	if (monstID == type::GOBLIN) return "Goblin";
	if (monstID == type::SKELETON) return "Skeleton";
	if (monstID == type::ORC) return "Orc";
	if (monstID == type::TROLL) return "Troll";

	return "None";
}

void printMonster(Monster monst)
{
	std::cout << "This " << getMonsterType(monst.monsterType) << " is named " << monst.name << " and has " << monst.hp << " health." << std::endl;
}

#include <iostream>

#include <string>

enum class type { OGRE, GOBLIN, SKELETON, ORC, TROLL };

struct Monster

{

type monsterType;

std::string name;

int hp;

};

std::string getMonsterType(type monstID);

void printMonster(Monster monst);

int main()

{

Monster m1 = { type::GOBLIN, "John", 100 };

Monster m2 = { type::ORC, "James", 35 };

printMonster(m1);

printMonster(m2);

system("pause");

return 0;

}

std::string getMonsterType(type monstID)

{

if (monstID == type::OGRE) return "Ogre";

if (monstID == type::GOBLIN) return "Goblin";

if (monstID == type::SKELETON) return "Skeleton";

if (monstID == type::ORC) return "Orc";

if (monstID == type::TROLL) return "Troll";

return "None";

}

void printMonster(Monster monst)

{

std::cout << "This " << getMonsterType(monst.monsterType) << " is named " << monst.name << " and has " << monst.hp << " health." << std::endl;

}

Ответить

Илья:

6 марта 2019 в 17:30

Добрый день!
Знаете, если честно, я так и не понял преимущества использования enum. Я написал две программы. Принципиально с enum, чтобы разобраться с ними, и без enum, так, как на мой взгляд проще. И могу сказать, что без enum действительно получилось намного проще и, на мой взгляд, код тоже читать проще.
Вот и сижу, мучаюсь догадками. Есть три предположения=))
1) Вы плохо объяснили все преимущества перечислителей. В этом я сильно сомневаюсь, т.к. всем предыдущие уроки прошли на ура, Вы очень хорошо расписываете материал=)
2) "На вкус и цвет товарищей нет" — т.е. каждый работает по своему, у каждого свои принципы работы и каждый делает так, как ему удобно (не пренебрегая, конечно, общими правилами, чтобы други могли разобраться в коде)
3) Перечислители действительно не так уж и полезны, как утверждают некоторые кодеры=)
Очень интересно узнать Ваше мнение по этому поводу=)Заранее спасибо!
Вот те самые программы с enum и без (программа без enum была написана последней, поэтому в ней, опять же на мой взгляд, лучше подобраны имена переменных и т.п.). Без перечислителей:

// Программа для чернокнижкника, призывателя, оверлодра и т.д.=))

#include "pch.h"
#include <iostream>
#include <string>

// Объявляем структуру AllStats со несколькими характеристиками
struct AllStats
{
	std::string type;					// тип
	std::string name;					// Имя
	int hp;								// количество ХП
	int damage;							// Урон
};

// ф-ция вывода на экран всех характеристик выбранного юзером питомца

void displayCharacteristics(AllStats pet)
{
	using namespace std;
	cout << "Your own pet - " << pet.type << "!" << endl;
	cout << "Your pet's name is " << pet.name << ". He have " << pet.hp << " healthpoints and " << pet.damage << " strike power!" << endl;
}


int main()
{
	using namespace std;
	cout << "Choose your pet.\nEnter the number next to the type:\n" <<		// Юзеру предлается выбрать одного из 5 возможных питомцев
		"Orc -			1\n"
		"Goblin -		2\n"
		"Ogre -			3\n"
		"Skeleton -		4\n"
		"Troll -			5\n"
		"You selected: ";
	int choice;													// Юзер выбирает желаемого питомца		
	cin >> choice;
	AllStats orc = { "Orc", "Elgrassa", 170, 25 };				// Каждому питомцу через структуру AllStats присваиваются его характеристики
	AllStats goblin = { "Goblin", "Kli-Kli", 150, 25 };
	AllStats ogre = { "Ogre", "Hassankor", 190, 20 };
	AllStats skeleton = { "Skeleton", "DeadHead", 190, 15 };
	AllStats troll = { "Troll", "Bigmus", 200, 40 };
	if (choice == 1)											// В зависимости от выбора в Calle-функцию отправляются значения того или иного питомца
		displayCharacteristics(orc);
	else if (choice == 2)
		displayCharacteristics(goblin);
	else if (choice == 3)
		displayCharacteristics(ogre);
	else if (choice == 4)
		displayCharacteristics(skeleton);
	else if (choice == 5)
		displayCharacteristics(troll);
	else
		cout << "What do you want? Want to Play? You can't even pick the right number of pet. Game over! orevuar..." << endl;
	return 0;
}

// Программа для чернокнижкника, призывателя, оверлодра и т.д.=))

#include "pch.h"

#include <iostream>

#include <string>

// Объявляем структуру AllStats со несколькими характеристиками

struct AllStats

{

std::string type; // тип

std::string name; // Имя

int hp; // количество ХП

int damage; // Урон

};

// ф-ция вывода на экран всех характеристик выбранного юзером питомца

void displayCharacteristics(AllStats pet)

{

using namespace std;

cout << "Your own pet - " << pet.type << "!" << endl;

cout << "Your pet's name is " << pet.name << ". He have " << pet.hp << " healthpoints and " << pet.damage << " strike power!" << endl;

}

int main()

{

using namespace std;

cout << "Choose your pet.\nEnter the number next to the type:\n" << // Юзеру предлается выбрать одного из 5 возможных питомцев

"Orc - 1\n"

"Goblin - 2\n"

"Ogre - 3\n"

"Skeleton - 4\n"

"Troll - 5\n"

"You selected: ";

int choice; // Юзер выбирает желаемого питомца

cin >> choice;

AllStats orc = { "Orc", "Elgrassa", 170, 25 }; // Каждому питомцу через структуру AllStats присваиваются его характеристики

AllStats goblin = { "Goblin", "Kli-Kli", 150, 25 };

AllStats ogre = { "Ogre", "Hassankor", 190, 20 };

AllStats skeleton = { "Skeleton", "DeadHead", 190, 15 };

AllStats troll = { "Troll", "Bigmus", 200, 40 };

if (choice == 1) // В зависимости от выбора в Calle-функцию отправляются значения того или иного питомца

displayCharacteristics(orc);

else if (choice == 2)

displayCharacteristics(goblin);

else if (choice == 3)

displayCharacteristics(ogre);

else if (choice == 4)

displayCharacteristics(skeleton);

else if (choice == 5)

displayCharacteristics(troll);

else

cout << "What do you want? Want to Play? You can't even pick the right number of pet. Game over! orevuar..." << endl;

return 0;

}

____________________________________
Вариант с enum:

#include "pch.h"
#include <iostream>
#include <string>

enum class Monsters
{
	ORC = 1,
	GOBLIN,
	OGRE,
	SKELETON,
	TROLL,
};

struct AllStats
{
	Monsters type;
	std::string name;
	int hp;
	int strPower;
};

std::string printType(AllStats stats)
{
	if (stats.type == Monsters::ORC)
		return "ORC";
	if (stats.type == Monsters::GOBLIN)
		return "GOBLIN";
	if (stats.type == Monsters::OGRE)
		return "OGRE";
	if (stats.type == Monsters::SKELETON)
		return "SKELETON";
	if (stats.type == Monsters::TROLL)
		return "TROLL";
	else
		return "Unknown";
}

void writeCharacteristics(AllStats stats)
{
	using namespace std;
	cout << "Your own pet - " << printType(stats) << "!" << endl;
	cout << "Your pet's name is " << stats.name << ". He have " << stats.hp << " healthpoints and " << stats.strPower << " strike power!" << endl;
}

int main()
{
	using namespace std;
	cout << "Choose your character.\nEnter the number next to the type:\n" <<
		"Orc - 1\nGoblin - 2\nOgre - 3\nSkeleton - 4\nTroll - 5\nYou selected: ";
	int choice;
	cin >> choice;
	AllStats orcStats = { Monsters::ORC, "Engrassa", 170, 25 };
	AllStats goblinStats = { Monsters::GOBLIN, "Kli-Kli", 150, 25 };
	AllStats ogreStats = { Monsters::OGRE, "Hassankor", 190, 20 };
	AllStats skeletonStats = { Monsters::SKELETON, "DeadHead", 190, 15 };
	AllStats trollStats = { Monsters::TROLL, "Bigmus", 200, 40 };
	if (choice == 1)
		writeCharacteristics(orcStats);
	else if (choice == 2)
		writeCharacteristics(goblinStats);
	else if (choice == 3)
		writeCharacteristics(ogreStats);
	else if (choice == 4)
		writeCharacteristics(skeletonStats);
	else if (choice == 5)
		writeCharacteristics(trollStats);
	else
		cout << "What are you playing? You can't even pick the right character. More shortly, Game over! orevuar..." << endl;
	return 0;

#include "pch.h"

#include <iostream>

#include <string>

enum class Monsters

{

ORC = 1,

GOBLIN,

OGRE,

SKELETON,

TROLL,

};

struct AllStats

{

Monsters type;

std::string name;

int hp;

int strPower;

};

std::string printType(AllStats stats)

{

if (stats.type == Monsters::ORC)

return "ORC";

if (stats.type == Monsters::GOBLIN)

return "GOBLIN";

if (stats.type == Monsters::OGRE)

return "OGRE";

if (stats.type == Monsters::SKELETON)

return "SKELETON";

if (stats.type == Monsters::TROLL)

return "TROLL";

else

return "Unknown";

}

void writeCharacteristics(AllStats stats)

{

using namespace std;

cout << "Your own pet - " << printType(stats) << "!" << endl;

cout << "Your pet's name is " << stats.name << ". He have " << stats.hp << " healthpoints and " << stats.strPower << " strike power!" << endl;

}

int main()

{

using namespace std;

cout << "Choose your character.\nEnter the number next to the type:\n" <<

"Orc - 1\nGoblin - 2\nOgre - 3\nSkeleton - 4\nTroll - 5\nYou selected: ";

int choice;

cin >> choice;

AllStats orcStats = { Monsters::ORC, "Engrassa", 170, 25 };

AllStats goblinStats = { Monsters::GOBLIN, "Kli-Kli", 150, 25 };

AllStats ogreStats = { Monsters::OGRE, "Hassankor", 190, 20 };

AllStats skeletonStats = { Monsters::SKELETON, "DeadHead", 190, 15 };

AllStats trollStats = { Monsters::TROLL, "Bigmus", 200, 40 };

if (choice == 1)

writeCharacteristics(orcStats);

else if (choice == 2)

writeCharacteristics(goblinStats);

else if (choice == 3)

writeCharacteristics(ogreStats);

else if (choice == 4)

writeCharacteristics(skeletonStats);

else if (choice == 5)

writeCharacteristics(trollStats);

else

cout << "What are you playing? You can't even pick the right character. More shortly, Game over! orevuar..." << endl;

return 0;

Ответить

Алексей:

11 мая 2019 в 00:29

Возможно, экономия памяти. Если к примеру известно что переменная может хранить значение только "Самолёт взлетел", "Самолёт летит" и "Самолёт приземлился", "Самолёт разбился",то для этого можно использовать перечисление. Тогда переменная будет иметь объём 4 байта (на моём компиляторе, VS 2019 Windows 10 x64, на другом может быть будет по-другому). Причём даже не важно, будут строки эти длиннее или короче, чем мною приведённые. А если использовать для этого строки, то понадобится не меньше 20 байт. Но это опять таки только догадка, возможно, у перечислений есть ещё какие-то преимущества.

PS. В универе нам тоже не объяснили накой перечисления сдались. Зато во всю заставляли использовать)))))

Ответить

Alexey:

6 февраля 2019 в 19:02

Игра против компьютера…

#include "pch.h"
#include <iostream>
#include <iomanip>
#include <string>
#include <cstdlib>
#include <ctime>
#include <windows.h>


enum class MonsterType {
	Orc,
	Ogre,
	Troll,
	Skeleton,
	Goblin,
};

struct Monsters {
	std::string name{};
	MonsterType type;
	int strong{};
	int evasion{};
	int health{};
	int crit{};
};

enum class AttackDirection {
	Head,
	Body,
	Legs,
};

enum class DefenseDirection {
	Head,
	Body,
	Legs,
};


/* Рандомное значение в % Игрока 1*/
bool randomValuePlayer1(int value) { // 10%, 20%, 25%, 50%, 75%
	std::srand(time(NULL) + 15);
	int randomValue = std::rand();
	switch (value)
	{
	case 10:
		if (randomValue % 10 == 0) {
			return true;
			break;
		}
		else return false;
	case 20:
		if (randomValue % 10 == 0 || randomValue % 10 == 1) {
			return true;
			break;
		}
		else return false;
	case 30:
		if (randomValue % 10 == 0 || randomValue % 10 == 1 || randomValue % 10 == 2) {
			return true;
			break;
		}
		else return false;
	case 40:
		if (randomValue % 10 == 0 || randomValue % 10 == 1 || randomValue % 10 == 2 || randomValue % 10 == 3) {
			return true;
			break;
		}
		else return false;
	default:
		return false;
		break;
	}
}

/* Рандомное значение в % Игрока 2*/
bool randomValuePlayer2(int value) { // 10%, 20%, 25%, 50%, 75%
	std::srand(time(NULL));
	int randomValue = std::rand();
	switch (value)
	{
	case 10:
		if (randomValue % 10 == 0) {
			return true;
			break;
		}
		else return false;
	case 20:
		if (randomValue % 10 == 0 || randomValue % 10 == 1) {
			return true;
			break;
		}
		else return false;
	case 30:
		if (randomValue % 10 == 0 || randomValue % 10 == 1 || randomValue % 10 == 2) {
			return true;
			break;
		}
		else return false;
	case 40:
		if (randomValue % 10 == 0 || randomValue % 10 == 1 || randomValue % 10 == 2 || randomValue % 10 == 3) {
			return true;
			break;
		}
		else return false;
	default:
		return false;
		break;
	}
}



/* Пользовательский ввод имени персонажа */
std::string userInputName() {
	std::cout << "Введите имя игрока: " << "\n";
	std::string userName{};
	getline(std::cin, userName);
	return userName;
}

/* Рандомный выбор персонажа */
MonsterType randomMonsterType() {
	srand(time(NULL));
	int randomChoise = (rand() % 5) + 1;
	if (randomChoise == 1) return MonsterType::Orc;
	if (randomChoise == 2) return MonsterType::Ogre;
	if (randomChoise == 3) return MonsterType::Troll;
	if (randomChoise == 4) return MonsterType::Skeleton;
	if (randomChoise == 5) return MonsterType::Goblin;
}

/* Пользовательский выбор персонажа */
MonsterType userInputMonsterType() {
metka1:
	std::cout << "Выберите персонажа: " << "\n"
		<< "1) Орк \n"
		<< "2) Огр \n"
		<< "3) Троль \n"
		<< "4) Скелетон \n"
		<< "5) Гоблин \n"
		<< "6) случайно \n";
	std::string choise{};
	std::cin >> choise;
	std::cin.ignore(32767, '\n');
	if (choise == "1" || choise == "orc" || choise == "Orc" || choise == "Орк" || choise == "орк") return MonsterType::Orc;
	else if (choise == "2" || choise == "ogre" || choise == "Ogre" || choise == "Огр" || choise == "огр") return MonsterType::Ogre;
	else if (choise == "3" || choise == "troll" || choise == "Troll" || choise == "Троль" || choise == "троль") return MonsterType::Troll;
	else if (choise == "4" || choise == "skeleton" || choise == "Skeleton" || choise == "Скелетон" || choise == "скелетон") return MonsterType::Skeleton;
	else if (choise == "5" || choise == "goblin" || choise == "Goblin" || choise == "Гоблин" || choise == "гоблин") return MonsterType::Goblin;
	else if (choise == "6" || choise == "random" || choise == "случайно") return randomMonsterType();
	else {
		std::cout << "Вы ввели недоступное значение, попробуйте еще раз \n";
		goto metka1;
	}

}


/* Возвращаем тип монстра строкой */
std::string getMonsterType(MonsterType monster) {
	switch (monster)
	{
	case MonsterType::Orc:
		return "Orc";
		break;
	case MonsterType::Ogre:
		return "Ogre";
		break;
	case MonsterType::Troll:
		return "Troll";
		break;
	case MonsterType::Skeleton:
		return "Skeleton";
		break;
	case MonsterType::Goblin:
		return "Goblin";
		break;
	default:
		break;
	}
}

/* Возвращает строку с названием атаки */
std::string getAttackDirection(AttackDirection value) {
	switch (value)
	{
	case AttackDirection::Head:
		return "голову";
		break;
	case AttackDirection::Body:
		return "тело";
		break;
	case AttackDirection::Legs:
		return "ноги";
		break;
	default:
		break;
	}
}

/* Возвращает строку с названием защиты */
std::string getDefenseDirection(DefenseDirection value) {
	switch (value)
	{
	case DefenseDirection::Head:
		return "головы";
		break;
	case DefenseDirection::Body:
		return "тела";
		break;
	case DefenseDirection::Legs:
		return "ног";
		break;
	default:
		break;
	}
}

/* Создаем персонаж */
Monsters playerCreate(std::string name, MonsterType monsters) {
	switch (monsters)
	{
	case MonsterType::Orc:
		return { name, MonsterType::Orc, 15, 30, 200, 40 };
		break;
	case MonsterType::Ogre:
		return { name, MonsterType::Ogre, 20, 20, 220, 30 };
		break;
	case MonsterType::Troll:
		return { name, MonsterType::Troll, 25, 10, 300, 20 };
		break;
	case MonsterType::Skeleton:
		return { name, MonsterType::Skeleton, 10, 30, 180, 20 };
		break;
	case MonsterType::Goblin:
		return { name, MonsterType::Goblin, 10, 40, 140, 40 };
		break;
	default:
		break;
	}
}

void printMonstersData(Monsters monster){
	std::cout << getMonsterType(monster.type) << "\n"
		<< "Здоровье - " << monster.health << "\n"
		<< "Атака - " << monster.strong << "\n"
		<< "Уклонение - " << monster.evasion << "\n"
		<< "Шанс крита - " << monster.crit << "\n";
}

AttackDirection randomAttackDirection() {
	std::srand(time(NULL));
	int randomChoise = (std::rand() % 3) + 1;
	if (randomChoise == 1) return AttackDirection::Head;
	if (randomChoise == 2) return AttackDirection::Body;
	if (randomChoise == 3) return AttackDirection::Legs;
}

DefenseDirection randomDefenseDirection() {
	srand(time(NULL));
	int randomChoise = (std::rand() % 3) + 1;
	if (randomChoise == 1) return DefenseDirection::Head;
	if (randomChoise == 2) return DefenseDirection::Body;
	if (randomChoise == 3) return DefenseDirection::Legs;
}

AttackDirection randomAttackDirectionPlayer2() {
	std::srand(time(NULL) + 5);
	int randomChoise = (std::rand() % 3) + 1;
	if (randomChoise == 1) return AttackDirection::Head;
	if (randomChoise == 2) return AttackDirection::Body;
	if (randomChoise == 3) return AttackDirection::Legs;
}

DefenseDirection randomDefenseDirectionPlayer2() {
	srand(time(NULL) + 7);
	int randomChoise = (std::rand() % 3) + 1;
	if (randomChoise == 1) return DefenseDirection::Head;
	if (randomChoise == 2) return DefenseDirection::Body;
	if (randomChoise == 3) return DefenseDirection::Legs;
}

AttackDirection choseAttackDirection() {
	metka2:
	std::cout << "Выберите направление атаки: \n"
		<< "1) Голова \n"
		<< "2) Тело \n"
		<< "3) Ноги \n"
		<< "4) Случайно \n";
	std::string chose{};
	std::cin >> chose;
	if (chose == "1" || chose == "Head" || chose == "head" || chose == "Голова" || chose == "голова") return AttackDirection::Head;
	if (chose == "2" || chose == "Body" || chose == "body" || chose == "Тело" || chose == "тело") return AttackDirection::Body;
	if (chose == "3" || chose == "Legs" || chose == "legs" || chose == "Ноги" || chose == "ноги") return AttackDirection::Legs;
	if (chose == "4" || chose == "Random" || chose == "random" || chose == "Случайно" || chose == "случайно") return randomAttackDirection();
	else {
		std::cout << "Вы ввели недоступное значение, попробуйте еще раз \n";
		goto metka2;
	}
}

DefenseDirection choseDefenseDirection() {
metka3:
	std::cout << "Выберите направление защиты: \n"
		<< "1) Голова \n"
		<< "2) Тело \n"
		<< "3) Ноги \n"
		<< "4) Случайно \n";
	std::string chose{};
	std::cin >> chose;
	if (chose == "1" || chose == "Head" || chose == "head" || chose == "Голова" || chose == "голова") return DefenseDirection::Head;
	if (chose == "2" || chose == "Body" || chose == "body" || chose == "Тело" || chose == "тело") return DefenseDirection::Body;
	if (chose == "3" || chose == "Legs" || chose == "legs" || chose == "Ноги" || chose == "ноги") return DefenseDirection::Legs;
	if (chose == "4" || chose == "Random" || chose == "random" || chose == "Случайно" || chose == "случайно") return randomDefenseDirection();
	else {
		std::cout << "Вы ввели недоступное значение, попробуйте еще раз \n";
		goto metka3;
	}
}

void battleRun(Monsters player1, Monsters player2) {
	int round{1};
	while (player1.health > 0 || player2.health > 0) {
		std::cout << "Раунд " << round << "\n";
		std::cout << "Уровень жизни игрока " << player1.name << " - " << player1.health << "\n"
			<< "Уровень жизни игрока " << player2.name << " - " << player2.health << "\n";
		AttackDirection player1Attack = choseAttackDirection();
		DefenseDirection player1Defense = choseDefenseDirection();
		AttackDirection player2Attack = randomAttackDirectionPlayer2();
		DefenseDirection player2Defense = randomDefenseDirectionPlayer2();

		bool player1Evasion = !randomValuePlayer1(player1.evasion);
		bool player2Evasion = !randomValuePlayer2(player2.evasion);
		bool player1Crit = randomValuePlayer1(player1.crit);
		bool player2Crit = randomValuePlayer2(player2.crit);


		if (player1Evasion) {
			if (static_cast<int>(player2Attack) != static_cast<int>(player1Defense)) {
				if (player2Crit) {
					std::cout << "Игрок " << player2.name << " нанес критический удар в " << getAttackDirection(player2Attack) << " игроку " << player1.name << ".\n"
						<< "Здоровье игрока " << player1.name << " уменьшено на " << player2.strong * 2 << ".\n";
					player1.health -= (player2.strong * 2);
					if (player1.health <= 0) {
						std::cout << "Игрок " << player2.name << " победил! \n";
						break;
					}
				}
				else {
					std::cout << "Игрок " << player2.name << " нанес удар в " << getAttackDirection(player2Attack) << " игроку " << player1.name << ".\n"
						<< "Здоровье игрока " << player1.name << " уменьшено на " << player2.strong << ".\n";
					player1.health -= (player2.strong);
					if (player1.health <= 0) {
						std::cout << "Игрок " << player2.name << " победил! \n";
						break;
					}
				}
			}
			else {
				std::cout << "Игрок " << player1.name << " выставил блок " << getDefenseDirection(player1Defense) << ", урон 0 \n";
			}
		}
		else {
			std::cout << "Игрок " << player1.name << " Уклонился от атаки " << player2.name << ", урон 0 \n";
		}

		if (player2Evasion) {
			if (static_cast<int>(player1Attack) != static_cast<int>(player2Defense)) {
				if (player1Crit) {
					std::cout << "Игрок " << player1.name << " нанес критический удар в " << getAttackDirection(player1Attack) << " игроку " << player2.name << ".\n"
						<< "Здоровье игрока " << player2.name << " уменьшено на " << player1.strong * 2 << ".\n";
					player2.health -= (player1.strong * 2);
					if (player2.health <= 0) {
						std::cout << "Игрок " << player1.name << " победил! \n";
						break;
					}
				}
				else {
					std::cout << "Игрок " << player1.name << " нанес удар в " << getAttackDirection(player1Attack) << " игроку " << player2.name << ".\n"
						<< "Здоровье игрока " << player2.name << " уменьшено на " << player1.strong << ".\n";
					player2.health -= (player1.strong);
					if (player2.health <= 0) {
						std::cout << "Игрок " << player1.name << " победил! \n";
						break;
					}
				}
			}
			else {
				std::cout << "Игрок " << player2.name << " выставил блок " << getDefenseDirection(player2Defense) << ", урон 0 \n";
			}
		}
		else {
			std::cout << "Игрок " << player2.name << " Уклонился от атаки " << player1.name << ", урон 0 \n";
		}
		round++;
	}
}

int main() {
	SetConsoleCP(1251);
	SetConsoleOutputCP(1251);
	Monsters player1 = playerCreate(userInputName(), userInputMonsterType());  // Создали персонаж игрока
	std::cout << "\n";
	std::cout << "Вы создали персонажа - " << player1.name << "\n";
	printMonstersData(player1);
	std::cout << "\n";
	Monsters player2 = playerCreate("Computer", randomMonsterType()); //Создали персонаж компьютера
	std::cout << "Компьютер создал персонажа - " << player2.name << "\n";
	printMonstersData(player2);
	battleRun(player1, player2);
	return 0;
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

405

406

407

408

409

410

411

412

413

#include "pch.h"

#include <iostream>

#include <iomanip>

#include <string>

#include <cstdlib>

#include <ctime>

#include <windows.h>

enum class MonsterType {

Orc,

Ogre,

Troll,

Skeleton,

Goblin,

};

struct Monsters {

std::string name{};

MonsterType type;

int strong{};

int evasion{};

int health{};

int crit{};

};

enum class AttackDirection {

Head,

Body,

Legs,

};

enum class DefenseDirection {

Head,

Body,

Legs,

};

/* Рандомное значение в % Игрока 1*/

bool randomValuePlayer1(int value) { // 10%, 20%, 25%, 50%, 75%

std::srand(time(NULL) + 15);

int randomValue = std::rand();

switch (value)

{

case 10:

if (randomValue % 10 == 0) {

return true;

break;

}

else return false;

case 20:

if (randomValue % 10 == 0 || randomValue % 10 == 1) {

return true;

break;

}

else return false;

case 30:

if (randomValue % 10 == 0 || randomValue % 10 == 1 || randomValue % 10 == 2) {

return true;

break;

}

else return false;

case 40:

if (randomValue % 10 == 0 || randomValue % 10 == 1 || randomValue % 10 == 2 || randomValue % 10 == 3) {

return true;

break;

}

else return false;

default:

return false;

break;

}

/* Рандомное значение в % Игрока 2*/

bool randomValuePlayer2(int value) { // 10%, 20%, 25%, 50%, 75%

std::srand(time(NULL));

int randomValue = std::rand();

switch (value)

{

case 10:

if (randomValue % 10 == 0) {

return true;

break;

}

else return false;

case 20:

if (randomValue % 10 == 0 || randomValue % 10 == 1) {

return true;

break;

}

else return false;

case 30:

if (randomValue % 10 == 0 || randomValue % 10 == 1 || randomValue % 10 == 2) {

return true;

break;

}

else return false;

case 40:

if (randomValue % 10 == 0 || randomValue % 10 == 1 || randomValue % 10 == 2 || randomValue % 10 == 3) {

return true;

break;

}

else return false;

default:

return false;

break;

}

/* Пользовательский ввод имени персонажа */

std::string userInputName() {

std::cout << "Введите имя игрока: " << "\n";

std::string userName{};

getline(std::cin, userName);

return userName;

}

/* Рандомный выбор персонажа */

MonsterType randomMonsterType() {

srand(time(NULL));

int randomChoise = (rand() % 5) + 1;

if (randomChoise == 1) return MonsterType::Orc;

if (randomChoise == 2) return MonsterType::Ogre;

if (randomChoise == 3) return MonsterType::Troll;

if (randomChoise == 4) return MonsterType::Skeleton;

if (randomChoise == 5) return MonsterType::Goblin;

}

/* Пользовательский выбор персонажа */

MonsterType userInputMonsterType() {

metka1:

std::cout << "Выберите персонажа: " << "\n"

<< "1) Орк \n"

<< "2) Огр \n"

<< "3) Троль \n"

<< "4) Скелетон \n"

<< "5) Гоблин \n"

<< "6) случайно \n";

std::string choise{};

std::cin >> choise;

std::cin.ignore(32767, '\n');

if (choise == "1" || choise == "orc" || choise == "Orc" || choise == "Орк" || choise == "орк") return MonsterType::Orc;

else if (choise == "2" || choise == "ogre" || choise == "Ogre" || choise == "Огр" || choise == "огр") return MonsterType::Ogre;

else if (choise == "3" || choise == "troll" || choise == "Troll" || choise == "Троль" || choise == "троль") return MonsterType::Troll;

else if (choise == "4" || choise == "skeleton" || choise == "Skeleton" || choise == "Скелетон" || choise == "скелетон") return MonsterType::Skeleton;

else if (choise == "5" || choise == "goblin" || choise == "Goblin" || choise == "Гоблин" || choise == "гоблин") return MonsterType::Goblin;

else if (choise == "6" || choise == "random" || choise == "случайно") return randomMonsterType();

else {

std::cout << "Вы ввели недоступное значение, попробуйте еще раз \n";

goto metka1;

}

/* Возвращаем тип монстра строкой */

std::string getMonsterType(MonsterType monster) {

switch (monster)

{

case MonsterType::Orc:

return "Orc";

break;

case MonsterType::Ogre:

return "Ogre";

break;

case MonsterType::Troll:

return "Troll";

break;

case MonsterType::Skeleton:

return "Skeleton";

break;

case MonsterType::Goblin:

return "Goblin";

break;

default:

break;

}

/* Возвращает строку с названием атаки */

std::string getAttackDirection(AttackDirection value) {

switch (value)

{

case AttackDirection::Head:

return "голову";

break;

case AttackDirection::Body:

return "тело";

break;

case AttackDirection::Legs:

return "ноги";

break;

default:

break;

}

/* Возвращает строку с названием защиты */

std::string getDefenseDirection(DefenseDirection value) {

switch (value)

{

case DefenseDirection::Head:

return "головы";

break;

case DefenseDirection::Body:

return "тела";

break;

case DefenseDirection::Legs:

return "ног";

break;

default:

break;

}

/* Создаем персонаж */

Monsters playerCreate(std::string name, MonsterType monsters) {

switch (monsters)

{

case MonsterType::Orc:

return { name, MonsterType::Orc, 15, 30, 200, 40 };

break;

case MonsterType::Ogre:

return { name, MonsterType::Ogre, 20, 20, 220, 30 };

break;

case MonsterType::Troll:

return { name, MonsterType::Troll, 25, 10, 300, 20 };

break;

case MonsterType::Skeleton:

return { name, MonsterType::Skeleton, 10, 30, 180, 20 };

break;

case MonsterType::Goblin:

return { name, MonsterType::Goblin, 10, 40, 140, 40 };

break;

default:

break;

}

void printMonstersData(Monsters monster){

std::cout << getMonsterType(monster.type) << "\n"

<< "Здоровье - " << monster.health << "\n"

<< "Атака - " << monster.strong << "\n"

<< "Уклонение - " << monster.evasion << "\n"

<< "Шанс крита - " << monster.crit << "\n";

}

AttackDirection randomAttackDirection() {

std::srand(time(NULL));

int randomChoise = (std::rand() % 3) + 1;

if (randomChoise == 1) return AttackDirection::Head;

if (randomChoise == 2) return AttackDirection::Body;

if (randomChoise == 3) return AttackDirection::Legs;

}

DefenseDirection randomDefenseDirection() {

srand(time(NULL));

int randomChoise = (std::rand() % 3) + 1;

if (randomChoise == 1) return DefenseDirection::Head;

if (randomChoise == 2) return DefenseDirection::Body;

if (randomChoise == 3) return DefenseDirection::Legs;

}

AttackDirection randomAttackDirectionPlayer2() {

std::srand(time(NULL) + 5);

int randomChoise = (std::rand() % 3) + 1;

if (randomChoise == 1) return AttackDirection::Head;

if (randomChoise == 2) return AttackDirection::Body;

if (randomChoise == 3) return AttackDirection::Legs;

}

DefenseDirection randomDefenseDirectionPlayer2() {

srand(time(NULL) + 7);

int randomChoise = (std::rand() % 3) + 1;

if (randomChoise == 1) return DefenseDirection::Head;

if (randomChoise == 2) return DefenseDirection::Body;

if (randomChoise == 3) return DefenseDirection::Legs;

}

AttackDirection choseAttackDirection() {

metka2:

std::cout << "Выберите направление атаки: \n"

<< "1) Голова \n"

<< "2) Тело \n"

<< "3) Ноги \n"

<< "4) Случайно \n";

std::string chose{};

std::cin >> chose;

if (chose == "1" || chose == "Head" || chose == "head" || chose == "Голова" || chose == "голова") return AttackDirection::Head;

if (chose == "2" || chose == "Body" || chose == "body" || chose == "Тело" || chose == "тело") return AttackDirection::Body;

if (chose == "3" || chose == "Legs" || chose == "legs" || chose == "Ноги" || chose == "ноги") return AttackDirection::Legs;

if (chose == "4" || chose == "Random" || chose == "random" || chose == "Случайно" || chose == "случайно") return randomAttackDirection();

else {

std::cout << "Вы ввели недоступное значение, попробуйте еще раз \n";

goto metka2;

}

DefenseDirection choseDefenseDirection() {

metka3:

std::cout << "Выберите направление защиты: \n"

<< "1) Голова \n"

<< "2) Тело \n"

<< "3) Ноги \n"

<< "4) Случайно \n";

std::string chose{};

std::cin >> chose;

if (chose == "1" || chose == "Head" || chose == "head" || chose == "Голова" || chose == "голова") return DefenseDirection::Head;

if (chose == "2" || chose == "Body" || chose == "body" || chose == "Тело" || chose == "тело") return DefenseDirection::Body;

if (chose == "3" || chose == "Legs" || chose == "legs" || chose == "Ноги" || chose == "ноги") return DefenseDirection::Legs;

if (chose == "4" || chose == "Random" || chose == "random" || chose == "Случайно" || chose == "случайно") return randomDefenseDirection();

else {

std::cout << "Вы ввели недоступное значение, попробуйте еще раз \n";

goto metka3;

}

void battleRun(Monsters player1, Monsters player2) {

int round{1};

while (player1.health > 0 || player2.health > 0) {

std::cout << "Раунд " << round << "\n";

std::cout << "Уровень жизни игрока " << player1.name << " - " << player1.health << "\n"

<< "Уровень жизни игрока " << player2.name << " - " << player2.health << "\n";

AttackDirection player1Attack = choseAttackDirection();

DefenseDirection player1Defense = choseDefenseDirection();

AttackDirection player2Attack = randomAttackDirectionPlayer2();

DefenseDirection player2Defense = randomDefenseDirectionPlayer2();

bool player1Evasion = !randomValuePlayer1(player1.evasion);

bool player2Evasion = !randomValuePlayer2(player2.evasion);

bool player1Crit = randomValuePlayer1(player1.crit);

bool player2Crit = randomValuePlayer2(player2.crit);

if (player1Evasion) {

if (static_cast<int>(player2Attack) != static_cast<int>(player1Defense)) {

if (player2Crit) {

std::cout << "Игрок " << player2.name << " нанес критический удар в " << getAttackDirection(player2Attack) << " игроку " << player1.name << ".\n"

<< "Здоровье игрока " << player1.name << " уменьшено на " << player2.strong * 2 << ".\n";

player1.health -= (player2.strong * 2);

if (player1.health <= 0) {

std::cout << "Игрок " << player2.name << " победил! \n";

break;

}

else {

std::cout << "Игрок " << player2.name << " нанес удар в " << getAttackDirection(player2Attack) << " игроку " << player1.name << ".\n"

<< "Здоровье игрока " << player1.name << " уменьшено на " << player2.strong << ".\n";

player1.health -= (player2.strong);

if (player1.health <= 0) {

std::cout << "Игрок " << player2.name << " победил! \n";

break;

}

else {

std::cout << "Игрок " << player1.name << " выставил блок " << getDefenseDirection(player1Defense) << ", урон 0 \n";

}

else {

std::cout << "Игрок " << player1.name << " Уклонился от атаки " << player2.name << ", урон 0 \n";

}

if (player2Evasion) {

if (static_cast<int>(player1Attack) != static_cast<int>(player2Defense)) {

if (player1Crit) {

std::cout << "Игрок " << player1.name << " нанес критический удар в " << getAttackDirection(player1Attack) << " игроку " << player2.name << ".\n"

<< "Здоровье игрока " << player2.name << " уменьшено на " << player1.strong * 2 << ".\n";

player2.health -= (player1.strong * 2);

if (player2.health <= 0) {

std::cout << "Игрок " << player1.name << " победил! \n";

break;

}

else {

std::cout << "Игрок " << player1.name << " нанес удар в " << getAttackDirection(player1Attack) << " игроку " << player2.name << ".\n"

<< "Здоровье игрока " << player2.name << " уменьшено на " << player1.strong << ".\n";

player2.health -= (player1.strong);

if (player2.health <= 0) {

std::cout << "Игрок " << player1.name << " победил! \n";

break;

}

else {

std::cout << "Игрок " << player2.name << " выставил блок " << getDefenseDirection(player2Defense) << ", урон 0 \n";

}

else {

std::cout << "Игрок " << player2.name << " Уклонился от атаки " << player1.name << ", урон 0 \n";

}

round++;

}

int main() {

SetConsoleCP(1251);

SetConsoleOutputCP(1251);

Monsters player1 = playerCreate(userInputName(), userInputMonsterType()); // Создали персонаж игрока

std::cout << "\n";

std::cout << "Вы создали персонажа - " << player1.name << "\n";

printMonstersData(player1);

std::cout << "\n";

Monsters player2 = playerCreate("Computer", randomMonsterType()); //Создали персонаж компьютера

std::cout << "Компьютер создал персонажа - " << player2.name << "\n";

printMonstersData(player2);

battleRun(player1, player2);

return 0;

}

Ответить

Владимир:

29 ноября 2018 в 15:56

#include <stdint.h>
#include <iostream>
#include <string>

struct Monsters{                                 //Класс "Монстр"
	enum class MonstersType{
		OGRE, GOBLIN, SKELETON, ORC, THROLL
	}typeOfMonster;                              //Тип монстра(OGRE, GOBLIN, SKELETON, ORC, THROLL)
	std::string name;                            //Имя монстра
	uint32_t healthPoints;                       //Количество здоровья монстра
};

void printMonster(Monsters monster)
{
	using std::cout;
	switch (monster.typeOfMonster)               //"Переключатель", аналог if для целочисленных констант
	{
		case Monsters::MonstersType::GOBLIN:   cout << "This goblin's name's ";   break;   //Если тип монстра "Гоблин"
		case Monsters::MonstersType::OGRE:     cout << "This ogre's name's ";     break;   //Если тип монстра "Огр"
		case Monsters::MonstersType::SKELETON: cout << "This skeleton's name's "; break;   //Если тип монстра "Скелет"
		case Monsters::MonstersType::ORC:      cout << "This orc's name's ";      break;   //Если тип монстра "Орк"
		case Monsters::MonstersType::THROLL:   cout << "This throll's name's ";   break;   //Если тип монстра "Тролль"
			default: cout << "Can't identify this monster but his\her name's ";   break;   //Аналог else
	}
	cout << monster.name << " .He/she have " << monster.healthPoints << " HP\n";
}

int main()
{
	Monsters dashaTheGoblin{ Monsters::MonstersType::GOBLIN, "Dasha", 200 };   //Гоблин Даша, 200 хп
	Monsters ivanTheOgre{ Monsters::MonstersType::OGRE, "Ivan", 500 };         //Огр Ваня, 500 хп

	printMonster(dashaTheGoblin);                //Смотрим характеристики Даши...
	printMonster(ivanTheOgre);                   //Смотрим характеристики Вани...

	return 0;
}

#include <stdint.h>

#include <iostream>

#include <string>

struct Monsters{ //Класс "Монстр"

enum class MonstersType{

OGRE, GOBLIN, SKELETON, ORC, THROLL

}typeOfMonster; //Тип монстра(OGRE, GOBLIN, SKELETON, ORC, THROLL)

std::string name; //Имя монстра

uint32_t healthPoints; //Количество здоровья монстра

};

void printMonster(Monsters monster)

{

using std::cout;

switch (monster.typeOfMonster) //"Переключатель", аналог if для целочисленных констант

{

case Monsters::MonstersType::GOBLIN: cout << "This goblin's name's "; break; //Если тип монстра "Гоблин"

case Monsters::MonstersType::OGRE: cout << "This ogre's name's "; break; //Если тип монстра "Огр"

case Monsters::MonstersType::SKELETON: cout << "This skeleton's name's "; break; //Если тип монстра "Скелет"

case Monsters::MonstersType::ORC: cout << "This orc's name's "; break; //Если тип монстра "Орк"

case Monsters::MonstersType::THROLL: cout << "This throll's name's "; break; //Если тип монстра "Тролль"

default: cout << "Can't identify this monster but his\her name's "; break; //Аналог else

}

cout << monster.name << " .He/she have " << monster.healthPoints << " HP\n";

}

int main()

{

Monsters dashaTheGoblin{ Monsters::MonstersType::GOBLIN, "Dasha", 200 }; //Гоблин Даша, 200 хп

Monsters ivanTheOgre{ Monsters::MonstersType::OGRE, "Ivan", 500 }; //Огр Ваня, 500 хп

printMonster(dashaTheGoblin); //Смотрим характеристики Даши...

printMonster(ivanTheOgre); //Смотрим характеристики Вани...

return 0;

}

Ответить

Дмитрий:

22 ноября 2018 в 17:22

Так же решил создать мини игру, на основании изученного с данного сайта материала.
Комментировал на сколько мог, надеюсь кому то пригодится для разбора.
Спасибо автору сайта, за предоставленную возможность.
П.С. Циклы просматривал до этого, с другого сайта (но мельком). 🙂

#include <iostream>
#include <string>
#include <ctime>


using namespace std;


//Характеристики монстров
struct Monster
{
	int damage;
	int health;
};
//Типы монстров
struct Monsters_type
{
	Monster type;
	string Ogre = "Ogre";
	string Troll = "Troll";
	string Goblin = "Goblin";
	string Skeleton = "Skeleton";
};
//Функции случайного урона
int Ogre_Damage ()
{
	srand(time(NULL));
	int mtype = rand() % 7 + 2;
	return mtype;
}
int Troll_Damage ()
{	
	srand(time(NULL));
	int mtype = rand() % 6 + 1;
	return mtype;
}
int Goblin_Damage ()
{	
	srand(time(NULL));
	int mtype = rand() % 4 + 3;
	return mtype;
}
int Skeleton_Damage ()
{
	srand(time(NULL));
	int mtype = rand() % 3 + 3;
	return mtype;
}
//Функции здоровья монстров
int Ogre_Heal ()
{
	int a = 200;
	return a;
}
int Troll_Heal ()
{
	int a = 230;
	return a;
}
int Goblin_Heal ()
{
	int a = 150;
	return a;
};
int Skeleton_Heal ()
{
	int a = 175;
	return a;
}

//Имя игрока
string NameUser()
{
	string name;
	getline(cin, name);
	return name;
}
//Выбор монстра
int MenuMonsters ()
{
	Monster monstr;
	cout << "\nВыберите монстра: \n\n";
	cout << "\n1.Ogre     - Великан людоед";
	cout << "\nХарактеристики: Здоровье - 200, Урон - 2-8\n";
	cout << "\n2.Troll    - Троль";
	cout << "\nХарактеристики: Здоровье - 230, Урон - 1-7\n";
	cout << "\n3.Goblin   - Гоблин";
	cout << "\nХарактеристики: Здоровье - 150, Урон - 3-6\n";
	cout << "\n4.Skeleton - Скелет";
	cout << "\nХарактеристики: Здоровье - 180, Урон - 3-5\n";
	cout << "\n\n";
	cout << "Ваш выбор монстра ?: ";
	int a;
	cin >> a;
	cin.ignore(32767, '\n');

	if (a == 1)
	a = 1;
	if (a == 2)
	a = 2;
	if (a == 3)
	a = 3;
	if (a == 4)
	a = 4;
	system("cls");
	return a;
}
//Основные действия программы
void MBattle ()
{
	Monster Type_Monsters1, Type_Monsters2;										//Создаём структуры для Type_Monsters1 и Type_Monsters2
	string MN1, MN2;												                       //Инициализируем переменные под имена игроков
	int MDamage1, MDamage2, MHeal1, MHeal2;								       //Инициализируем переменные под параметры монстров
	cout << "\nВведите имя первого игрока: ";
	string name1 = NameUser();											               //Инициализируем и приравниваем значение функции к пременной name1
 	int a = MenuMonsters();												               //Инициализируем и приравниваем значение функции к пременной a
 	system("cls");
	if (a == 1)													                       //Сравниваем с выбором игрока
	{														                               //И на основании данного выбора
	MN1 = "Огр";													                       //Приравниваем
 	MDamage1 = Ogre_Damage();											       //Урон и
 	MHeal1 = Ogre_Heal();												               //Здоровье монстра к переменным
 	Type_Monsters1 = {MDamage1, MHeal1};									       //Создаем массив из структуры 
	Type_Monsters1.health = Ogre_Heal ();										       //Приравниваем переменной из структуры значение функции
	}
 	if (a == 2)
	{
	MN1 = "Троль";
	MDamage1 = Ogre_Damage();
	MHeal1 = Ogre_Heal();
	Type_Monsters1 = {MDamage1, MHeal1};
	Type_Monsters1.health = Troll_Heal ();
	}
	if (a == 3)
	{
	MN1 = "Гоблин";
	MDamage1 = Ogre_Damage();
	MHeal1 = Ogre_Heal();
	Type_Monsters1 = {MDamage1, MHeal1};
	Type_Monsters1.health = Goblin_Heal ();
	}
	if (a == 4)
	{
	MN1 = "Скелет";
	MDamage1 = Ogre_Damage();
	MHeal1 = Ogre_Heal();
	Type_Monsters1 = {MDamage1, MHeal1};
	Type_Monsters1.health = Skeleton_Heal ();
	}
	
	cout << "\nВведите имя второго игрока: ";
	string name2 = NameUser();											                              //Инициализируем и приравниваем значение функции к переменной name2
 	int b = MenuMonsters();												                              //Инициализируем и приравниваем значение функции к переменной b
 	system("cls");
	if (b == 1)
	{
	MN2 = "Огр";
	MDamage2 = Ogre_Damage();
	MHeal2 = Ogre_Heal();
	Type_Monsters2 = {MDamage2, MHeal2};
	Type_Monsters2.health = Ogre_Heal ();
	}
	if (b == 2)
	{
	MN2 = "Троль";
	MDamage2 = Ogre_Damage();
	MHeal2 = Ogre_Heal();
	Type_Monsters2 = {MDamage2, MHeal2};
	Type_Monsters2.health = Troll_Heal ();
	}
	if (b == 3)
	{
	MN2 = "Гоблин";
	MDamage2 = Ogre_Damage();
	MHeal2 = Ogre_Heal();
	Type_Monsters2 = {MDamage2, MHeal2};
	Type_Monsters2.health = Goblin_Heal ();
	}
	if (b == 4)
	{
	MN2 = "Скелет";
	MDamage2 = Ogre_Damage();
	MHeal2 = Ogre_Heal();
	Type_Monsters2 = {MDamage2, MHeal2};
	Type_Monsters2.health = Skeleton_Heal ();
	}
	
	cout << "\nИгроки выбрали тех кто будет представлять их в бою !\n";
	cout << "\nИгрок " << name1 << " выбрал: " << MN1;
	cout << "\nИгрок " << name2 << " выбрал: " << MN2;
	cout << "\n\nДа начнётся битва !!!\n";
	system ("pause");
	
	Type_Monsters1 = {Type_Monsters1.damage, Type_Monsters1.health};
	Type_Monsters2 = {Type_Monsters2.damage, Type_Monsters2.health};
	
	for (int i = 0; i < 100; i++)
	{
		if (Type_Monsters1.health <= 0)
		{
			cout << name2 << " Ваш " << MN2 <<" победил --- УРА!!!!!!";
			i = 100;
		}
		else
		{
			if (a == 1)											                                               //Делаем это в цикле для обновления значения функции
			{												                                                       //Так как урон рандомный, заданный в определенном диапазоне
				Type_Monsters1.damage = Ogre_Damage ();							                       //Приравниваем к переменной в структуре, значение функции
			}																			
 			if (a == 2)
			{
				Type_Monsters1.damage = Troll_Damage ();
			}
			if (a == 3)
			{
				Type_Monsters1.damage = Goblin_Damage ();
			}
			if (a == 4)
			{
				Type_Monsters1.damage = Skeleton_Damage ();
			}
			
			if (b == 1)
			{
				Type_Monsters2.damage = Ogre_Damage ();
			}
			if (b == 2)
			{
				Type_Monsters2.damage = Troll_Damage ();
			}
			if (b == 3)
			{
				Type_Monsters2.damage = Goblin_Damage ();
			}
			if (b == 4)
			{
				Type_Monsters2.damage = Skeleton_Damage ();
			}
			
			Type_Monsters1.health -= Type_Monsters2.damage;
			Type_Monsters2.health -= Type_Monsters1.damage;
			
			cout << "\n" << "Вы " << MN1 << "  Вам нанесен урон: " << Type_Monsters2.damage << "  У Вас осталось здоровья: " << Type_Monsters1.health << "\n\n";
			cout << "\n" << "Вы " << MN2 << "  Вам нанесен урон: " << Type_Monsters1.damage << "  У Вас осталось здоровья: " << Type_Monsters2.health << "\n\n";
			system("pause");
			cout << "\nСледующий раунд: \n\n";
			
		
			if (Type_Monsters2.health <= 0)
			{
				cout << name1 << " Ваш " << MN1 <<" победил --- УРА!!!!!!";
				i = 100;
			}
		}
	}
	
}
//Меню запуска программы
int Menu ()
{
	cout << "\n\n\t\t\tДобро пожаловать в мини-игру\n";
	cout << "\t\t\t\tБитва Монстров !\n\n\n";
	cout << " 1: Начать игру.\n\n";
	cout << " 2: Выход из программы.\n\n";
	cout << "\nВаш выбор ? : ";
	int s;
	if (s == 1)
	s = 1;
	if (s == 2)
	s = 2;
	return s;
}

//основная программа
int main (int argc, char* argv[])
{
	setlocale (LC_ALL, "RUS");
	while (true){
	int s = Menu();
	cin >> s;
	cin.ignore(32767, '\n');
	if (s == 1)
	MBattle();
	if (s == 2){
	system ("cls");
	return 0;}}
	
    return 0;
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

#include <iostream>

#include <string>

#include <ctime>

using namespace std;

//Характеристики монстров

struct Monster

{

int damage;

int health;

};

//Типы монстров

struct Monsters_type

{

Monster type;

string Ogre = "Ogre";

string Troll = "Troll";

string Goblin = "Goblin";

string Skeleton = "Skeleton";

};

//Функции случайного урона

int Ogre_Damage ()

{

srand(time(NULL));

int mtype = rand() % 7 + 2;

return mtype;

}

int Troll_Damage ()

{

srand(time(NULL));

int mtype = rand() % 6 + 1;

return mtype;

}

int Goblin_Damage ()

{

srand(time(NULL));

int mtype = rand() % 4 + 3;

return mtype;

}

int Skeleton_Damage ()

{

srand(time(NULL));

int mtype = rand() % 3 + 3;

return mtype;

}

//Функции здоровья монстров

int Ogre_Heal ()

{

int a = 200;

return a;

}

int Troll_Heal ()

{

int a = 230;

return a;

}

int Goblin_Heal ()

{

int a = 150;

return a;

};

int Skeleton_Heal ()

{

int a = 175;

return a;

}

//Имя игрока

string NameUser()

{

string name;

getline(cin, name);

return name;

}

//Выбор монстра

int MenuMonsters ()

{

Monster monstr;

cout << "\nВыберите монстра: \n\n";

cout << "\n1.Ogre - Великан людоед";

cout << "\nХарактеристики: Здоровье - 200, Урон - 2-8\n";

cout << "\n2.Troll - Троль";

cout << "\nХарактеристики: Здоровье - 230, Урон - 1-7\n";

cout << "\n3.Goblin - Гоблин";

cout << "\nХарактеристики: Здоровье - 150, Урон - 3-6\n";

cout << "\n4.Skeleton - Скелет";

cout << "\nХарактеристики: Здоровье - 180, Урон - 3-5\n";

cout << "\n\n";

cout << "Ваш выбор монстра ?: ";

int a;

cin >> a;

cin.ignore(32767, '\n');

if (a == 1)

a = 1;

if (a == 2)

a = 2;

if (a == 3)

a = 3;

if (a == 4)

a = 4;

system("cls");

return a;

}

//Основные действия программы

void MBattle ()

{

Monster Type_Monsters1, Type_Monsters2; //Создаём структуры для Type_Monsters1 и Type_Monsters2

string MN1, MN2; //Инициализируем переменные под имена игроков

int MDamage1, MDamage2, MHeal1, MHeal2; //Инициализируем переменные под параметры монстров

cout << "\nВведите имя первого игрока: ";

string name1 = NameUser(); //Инициализируем и приравниваем значение функции к пременной name1

int a = MenuMonsters(); //Инициализируем и приравниваем значение функции к пременной a

system("cls");

if (a == 1) //Сравниваем с выбором игрока

{ //И на основании данного выбора

MN1 = "Огр"; //Приравниваем

MDamage1 = Ogre_Damage(); //Урон и

MHeal1 = Ogre_Heal(); //Здоровье монстра к переменным

Type_Monsters1 = {MDamage1, MHeal1}; //Создаем массив из структуры

Type_Monsters1.health = Ogre_Heal (); //Приравниваем переменной из структуры значение функции

}

if (a == 2)

{

MN1 = "Троль";

MDamage1 = Ogre_Damage();

MHeal1 = Ogre_Heal();

Type_Monsters1 = {MDamage1, MHeal1};

Type_Monsters1.health = Troll_Heal ();

}

if (a == 3)

{

MN1 = "Гоблин";

MDamage1 = Ogre_Damage();

MHeal1 = Ogre_Heal();

Type_Monsters1 = {MDamage1, MHeal1};

Type_Monsters1.health = Goblin_Heal ();

}

if (a == 4)

{

MN1 = "Скелет";

MDamage1 = Ogre_Damage();

MHeal1 = Ogre_Heal();

Type_Monsters1 = {MDamage1, MHeal1};

Type_Monsters1.health = Skeleton_Heal ();

}

cout << "\nВведите имя второго игрока: ";

string name2 = NameUser(); //Инициализируем и приравниваем значение функции к переменной name2

int b = MenuMonsters(); //Инициализируем и приравниваем значение функции к переменной b

system("cls");

if (b == 1)

{

MN2 = "Огр";

MDamage2 = Ogre_Damage();

MHeal2 = Ogre_Heal();

Type_Monsters2 = {MDamage2, MHeal2};

Type_Monsters2.health = Ogre_Heal ();

}

if (b == 2)

{

MN2 = "Троль";

MDamage2 = Ogre_Damage();

MHeal2 = Ogre_Heal();

Type_Monsters2 = {MDamage2, MHeal2};

Type_Monsters2.health = Troll_Heal ();

}

if (b == 3)

{

MN2 = "Гоблин";

MDamage2 = Ogre_Damage();

MHeal2 = Ogre_Heal();

Type_Monsters2 = {MDamage2, MHeal2};

Type_Monsters2.health = Goblin_Heal ();

}

if (b == 4)

{

MN2 = "Скелет";

MDamage2 = Ogre_Damage();

MHeal2 = Ogre_Heal();

Type_Monsters2 = {MDamage2, MHeal2};

Type_Monsters2.health = Skeleton_Heal ();

}

cout << "\nИгроки выбрали тех кто будет представлять их в бою !\n";

cout << "\nИгрок " << name1 << " выбрал: " << MN1;

cout << "\nИгрок " << name2 << " выбрал: " << MN2;

cout << "\n\nДа начнётся битва !!!\n";

system ("pause");

Type_Monsters1 = {Type_Monsters1.damage, Type_Monsters1.health};

Type_Monsters2 = {Type_Monsters2.damage, Type_Monsters2.health};

for (int i = 0; i < 100; i++)

{

if (Type_Monsters1.health <= 0)

{

cout << name2 << " Ваш " << MN2 <<" победил --- УРА!!!!!!";

i = 100;

}

else

{

if (a == 1) //Делаем это в цикле для обновления значения функции

{ //Так как урон рандомный, заданный в определенном диапазоне

Type_Monsters1.damage = Ogre_Damage (); //Приравниваем к переменной в структуре, значение функции

}

if (a == 2)

{

Type_Monsters1.damage = Troll_Damage ();

}

if (a == 3)

{

Type_Monsters1.damage = Goblin_Damage ();

}

if (a == 4)

{

Type_Monsters1.damage = Skeleton_Damage ();

}

if (b == 1)

{

Type_Monsters2.damage = Ogre_Damage ();

}

if (b == 2)

{

Type_Monsters2.damage = Troll_Damage ();

}

if (b == 3)

{

Type_Monsters2.damage = Goblin_Damage ();

}

if (b == 4)

{

Type_Monsters2.damage = Skeleton_Damage ();

}

Type_Monsters1.health -= Type_Monsters2.damage;

Type_Monsters2.health -= Type_Monsters1.damage;

cout << "\n" << "Вы " << MN1 << " Вам нанесен урон: " << Type_Monsters2.damage << " У Вас осталось здоровья: " << Type_Monsters1.health << "\n\n";

cout << "\n" << "Вы " << MN2 << " Вам нанесен урон: " << Type_Monsters1.damage << " У Вас осталось здоровья: " << Type_Monsters2.health << "\n\n";

system("pause");

cout << "\nСледующий раунд: \n\n";

if (Type_Monsters2.health <= 0)

{

cout << name1 << " Ваш " << MN1 <<" победил --- УРА!!!!!!";

i = 100;

}

//Меню запуска программы

int Menu ()

{

cout << "\n\n\t\t\tДобро пожаловать в мини-игру\n";

cout << "\t\t\t\tБитва Монстров !\n\n\n";

cout << " 1: Начать игру.\n\n";

cout << " 2: Выход из программы.\n\n";

cout << "\nВаш выбор ? : ";

int s;

if (s == 1)

s = 1;

if (s == 2)

s = 2;

return s;

}

//основная программа

int main (int argc, char* argv[])

{

setlocale (LC_ALL, "RUS");

while (true){

int s = Menu();

cin >> s;

cin.ignore(32767, '\n');

if (s == 1)

MBattle();

if (s == 2){

system ("cls");

return 0;}}

return 0;

}

Ответить

zvezdonom:

8 апреля 2019 в 15:28

В строке

cout << "\nХарактеристики: Здоровье - 230, Урон - 1-7\n";

1

cout << "\nХарактеристики: Здоровье - 230, Урон - 1-7\n";

опечатка/ошибка.
Должно быть

cout << "\nХарактеристики: Здоровье - 230, Урон - 1-6\n";

1

cout << "\nХарактеристики: Здоровье - 230, Урон - 1-6\n";

Ответить

rpa4:

24 мая 2018 в 20:56

Вот, исходя из всех уроков 4-й главы, сделал такую вот игру с монстрами. Прошу прощения за длинный код.

#include "stdafx.h"
#include <iostream>
#include <iomanip>
#include <string>

using Word = std::string;

enum class Monsters
{
	OGRE,	// Великан-людоед	= 0	Здоровье	= 200	Атака	= 35	Оборона	= 1
	GOBLIN,	// Гоблин	= 1	Здоровье	= 150	Атака	= 20	Оборона	= 8
	SKELETON,	// Скелет	= 2	Здоровье	= 110	Атака	= 45	Оборона	= 10
	ORC,	// Орк	= 3	Здоровье	= 180	Атака	= 30	Оборона	= 5
	TROLL	// Троль	= 4	Здоровье	= 140	Атака	= 25	Оборона	= 6
};

struct ParamMonster
{
	int healthMonster;	// Здоровье монстра
	int attackMonster;	// Атака монстра
	int defenseMonster;	// Оборона монстра
};

Word getName()	// Вводим имена игроков
{
	Word nameUser;
	std::getline(std::cin, nameUser);
	std::cin.ignore(32767, '\n');
	return nameUser;
}

int getMonsters()	// Выбираем монстров по их именам и возвращаем в целых числах
{
	int outputMonster;
	Word inputMonster;
	std::cin >> inputMonster;
	std::cin.ignore(32767, '\n');
	if (inputMonster == "Orge" || inputMonster == "orge")
		return outputMonster = 0;
	else
	{
		if (inputMonster == "Goblin" || inputMonster == "goblin")
			return outputMonster = 1;
		else
		{
			if (inputMonster == "Skeleton" || inputMonster == "skeleton")
				return outputMonster = 2;
			else
			{
				if (inputMonster == "Orc" || inputMonster == "orc")
					return outputMonster = 3;
				else
				{
					if (inputMonster == "Troll" || inputMonster == "troll")
						return outputMonster = 4;
				}
			}
		}
	}
	return outputMonster = 1;
}
void fight(Word firstNameString, Word oneMonster, ParamMonster paramOneMonster, Word secondNameString, Word twoMonster, ParamMonster paramTwoMonster)
{
	int healthOneMonster = paramOneMonster.healthMonster;	//	Начинаем бой
	int healthTwoMonster = paramTwoMonster.healthMonster;

	std::cout << "The first one starts " << firstNameString << "(" << oneMonster << "), since his name is longer." << "\n" << std::endl;
	std::cout << "\nFirst round:\t" << oneMonster << "\tvs " << twoMonster << std::endl;
	system("pause");

	healthTwoMonster = healthTwoMonster + paramTwoMonster.defenseMonster - paramOneMonster.attackMonster;	// Первый раунд, отнимаем здоровье у первого монстра
	std::cout << oneMonster << " strikes. Attack " << paramOneMonster.attackMonster << " =>\t\t" <<
		twoMonster << " defends. Defense " << paramTwoMonster.defenseMonster << std::endl;
	std::cout << "Total: " << twoMonster << " — health = " << healthTwoMonster << std::endl;
	system("pause");

	healthOneMonster = healthOneMonster + paramOneMonster.defenseMonster - paramTwoMonster.attackMonster;	// Отнимаем здоровье у второго монстра
	std::cout << twoMonster << " strikes. Attack " << paramTwoMonster.attackMonster << " =>\t\t" <<
		oneMonster << " defends. Defense " << paramOneMonster.defenseMonster << std::endl;
	std::cout << "Total: " << oneMonster << " — health = " << healthOneMonster << std::endl;
	system("pause");

	for (int i = 0; i < 100; i++)
	{
		if (healthOneMonster < 0)	// Зацикливаем бой до тех пор, пока, у одного и монстров очки здоровья станут меньше 0
		{
			std::cout << "Won " << secondNameString << ": Monster — " << twoMonster << ", Health — " << healthTwoMonster << std::endl;
			i = 100;
		}
		else
		{
			std::cout << "\nNext round:\t" << oneMonster << "\tvs " << twoMonster << std::endl;
			system("pause");
			healthTwoMonster = healthTwoMonster + paramTwoMonster.defenseMonster - paramOneMonster.attackMonster;
			std::cout << oneMonster << " strikes. Attack " << paramOneMonster.attackMonster << " =>\t\t" <<
				twoMonster << " defends. Defense " << paramTwoMonster.defenseMonster << std::endl;
			std::cout << "Total: " << twoMonster << " — health = " << healthTwoMonster << std::endl;
			system("pause");
		}
		if (healthTwoMonster < 0)
		{
			std::cout << "Won " << firstNameString << ": Monster — " << oneMonster << ", Health — " << healthOneMonster << std::endl;
			i = 100;
		}
		else
		{
			if (healthOneMonster > 0)
			{
				healthOneMonster = healthOneMonster + paramOneMonster.defenseMonster - paramTwoMonster.attackMonster;
				std::cout << twoMonster << " strikes. Attack " << paramTwoMonster.attackMonster << " =>\t\t" <<
					oneMonster << " defends. Defense " << paramOneMonster.defenseMonster << std::endl;
				std::cout << "Total: " << oneMonster << " — health = " << healthOneMonster << std::endl;
				system("pause");
			}
		}

	}

}

void ad(Word firstNameString, int firstPlayerMonster, Word secondNameString, int secondPlayerMonster)
{
	Monsters firstMonster = static_cast<Monsters>(firstPlayerMonster);
	Monsters secondMonster = static_cast<Monsters>(secondPlayerMonster);
	Word oneMonster;
	Word twoMonster;
	ParamMonster paramOneMonster;
	ParamMonster paramTwoMonster;

	if (firstMonster == Monsters::OGRE)	// Сравниваем монстра со списком enum и присваиваем монстра к игроку с его параметрами
	{
		oneMonster = "Orge";
		paramOneMonster = { 200,35,1 };
	}
	else
	{
		if (firstMonster == Monsters::GOBLIN)
		{
			oneMonster = "Goblin";
			paramOneMonster = { 150,20,8 };
		}
		else
		{
			if (firstMonster == Monsters::SKELETON)
			{
				oneMonster = "Skeleton";
				paramOneMonster = { 110,45,10 };
			}
			else
			{
				if (firstMonster == Monsters::ORC)
				{
					oneMonster = "Orc";
					paramOneMonster = { 180,30,5 };
				}
				else
				{
					if (firstMonster == Monsters::TROLL)
					{
						oneMonster = "Troll";
						paramOneMonster = { 140,25,6 };
					}
				}
			}
		}
	}
	if (secondMonster == Monsters::OGRE)
	{
		twoMonster = "Orge";
		paramTwoMonster = { 200,35,1 };
	}
	else
	{
		if (secondMonster == Monsters::GOBLIN)
		{
			twoMonster = "Goblin";
			paramTwoMonster = { 150,20,8 };
		}
		else
		{
			if (secondMonster == Monsters::SKELETON)
			{
				twoMonster = "Skeleton";
				paramTwoMonster = { 110,45,10 };
			}
			else
			{
				if (secondMonster == Monsters::ORC)
				{
					twoMonster = "Orc";
					paramTwoMonster = { 180,30,5 };
				}
				else
				{
					if (secondMonster == Monsters::TROLL)
					{
						twoMonster = "Troll";
						paramTwoMonster = { 140,25,6 };
					}
				}
			}
		}
	}
	std::cout << "Player " << firstNameString << " choice " << oneMonster << ": Health = " << paramOneMonster.healthMonster <<
		"; Attack = " << paramOneMonster.attackMonster << "; Defense = " << paramOneMonster.defenseMonster << "\n" << std::endl;
	std::cout << "Player " << secondNameString << " choice " << twoMonster << ": Health = " << paramTwoMonster.healthMonster <<
		"; Attack = " << paramTwoMonster.attackMonster << "; Defense = " << paramTwoMonster.defenseMonster << "\n" << std::endl;

	int firstNameInteger = firstNameString.length();
	int secondNameInteger = secondNameString.length();
	if (firstNameInteger < secondNameInteger)	// Первый удар будет за игроком чьё имя длинее
		fight(secondNameString, twoMonster, paramTwoMonster, firstNameString, oneMonster, paramOneMonster);
	else
	{
		fight(firstNameString, oneMonster, paramOneMonster, secondNameString, twoMonster, paramTwoMonster);
	}
}

int main()
{
	using namespace std;
	cout << "Enter the name of the first player: ";
	string firstNameString = getName();
	cout << "Choose a monster for the first player (Orge, Goblin, Skeleton, Orc, Troll): ";
	int firstPlayerMonster = getMonsters();

	cout << "Enter the name of the second player: ";
	string secondNameString = getName();
	cout << "Choose a monster for the second player (Orge, Goblin, Skeleton, Orc, Troll): ";
	int secondPlayerMonster = getMonsters();

	ad(firstNameString, firstPlayerMonster, secondNameString, secondPlayerMonster);

	return 0;
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

#include "stdafx.h"

#include <iostream>

#include <iomanip>

#include <string>

using Word = std::string;

enum class Monsters

{

OGRE, // Великан-людоед = 0 Здоровье = 200 Атака = 35 Оборона = 1

GOBLIN, // Гоблин = 1 Здоровье = 150 Атака = 20 Оборона = 8

SKELETON, // Скелет = 2 Здоровье = 110 Атака = 45 Оборона = 10

ORC, // Орк = 3 Здоровье = 180 Атака = 30 Оборона = 5

TROLL // Троль = 4 Здоровье = 140 Атака = 25 Оборона = 6

};

struct ParamMonster

{

int healthMonster; // Здоровье монстра

int attackMonster; // Атака монстра

int defenseMonster; // Оборона монстра

};

Word getName() // Вводим имена игроков

{

Word nameUser;

std::getline(std::cin, nameUser);

std::cin.ignore(32767, '\n');

return nameUser;

}

int getMonsters() // Выбираем монстров по их именам и возвращаем в целых числах

{

int outputMonster;

Word inputMonster;

std::cin >> inputMonster;

std::cin.ignore(32767, '\n');

if (inputMonster == "Orge" || inputMonster == "orge")

return outputMonster = 0;

else

{

if (inputMonster == "Goblin" || inputMonster == "goblin")

return outputMonster = 1;

else

{

if (inputMonster == "Skeleton" || inputMonster == "skeleton")

return outputMonster = 2;

else

{

if (inputMonster == "Orc" || inputMonster == "orc")

return outputMonster = 3;

else

{

if (inputMonster == "Troll" || inputMonster == "troll")

return outputMonster = 4;

}

return outputMonster = 1;

}

void fight(Word firstNameString, Word oneMonster, ParamMonster paramOneMonster, Word secondNameString, Word twoMonster, ParamMonster paramTwoMonster)

{

int healthOneMonster = paramOneMonster.healthMonster; // Начинаем бой

int healthTwoMonster = paramTwoMonster.healthMonster;

std::cout << "The first one starts " << firstNameString << "(" << oneMonster << "), since his name is longer." << "\n" << std::endl;

std::cout << "\nFirst round:\t" << oneMonster << "\tvs " << twoMonster << std::endl;

system("pause");

healthTwoMonster = healthTwoMonster + paramTwoMonster.defenseMonster - paramOneMonster.attackMonster; // Первый раунд, отнимаем здоровье у первого монстра

std::cout << oneMonster << " strikes. Attack " << paramOneMonster.attackMonster << " =>\t\t" <<

twoMonster << " defends. Defense " << paramTwoMonster.defenseMonster << std::endl;

std::cout << "Total: " << twoMonster << " — health = " << healthTwoMonster << std::endl;

system("pause");

healthOneMonster = healthOneMonster + paramOneMonster.defenseMonster - paramTwoMonster.attackMonster; // Отнимаем здоровье у второго монстра

std::cout << twoMonster << " strikes. Attack " << paramTwoMonster.attackMonster << " =>\t\t" <<

oneMonster << " defends. Defense " << paramOneMonster.defenseMonster << std::endl;

std::cout << "Total: " << oneMonster << " — health = " << healthOneMonster << std::endl;

system("pause");

for (int i = 0; i < 100; i++)

{

if (healthOneMonster < 0) // Зацикливаем бой до тех пор, пока, у одного и монстров очки здоровья станут меньше 0

{

std::cout << "Won " << secondNameString << ": Monster — " << twoMonster << ", Health — " << healthTwoMonster << std::endl;

i = 100;

}

else

{

std::cout << "\nNext round:\t" << oneMonster << "\tvs " << twoMonster << std::endl;

system("pause");

healthTwoMonster = healthTwoMonster + paramTwoMonster.defenseMonster - paramOneMonster.attackMonster;

std::cout << oneMonster << " strikes. Attack " << paramOneMonster.attackMonster << " =>\t\t" <<

twoMonster << " defends. Defense " << paramTwoMonster.defenseMonster << std::endl;

std::cout << "Total: " << twoMonster << " — health = " << healthTwoMonster << std::endl;

system("pause");

}

if (healthTwoMonster < 0)

{

std::cout << "Won " << firstNameString << ": Monster — " << oneMonster << ", Health — " << healthOneMonster << std::endl;

i = 100;

}

else

{

if (healthOneMonster > 0)

{

healthOneMonster = healthOneMonster + paramOneMonster.defenseMonster - paramTwoMonster.attackMonster;

std::cout << twoMonster << " strikes. Attack " << paramTwoMonster.attackMonster << " =>\t\t" <<

oneMonster << " defends. Defense " << paramOneMonster.defenseMonster << std::endl;

std::cout << "Total: " << oneMonster << " — health = " << healthOneMonster << std::endl;

system("pause");

}

void ad(Word firstNameString, int firstPlayerMonster, Word secondNameString, int secondPlayerMonster)

{

Monsters firstMonster = static_cast<Monsters>(firstPlayerMonster);

Monsters secondMonster = static_cast<Monsters>(secondPlayerMonster);

Word oneMonster;

Word twoMonster;

ParamMonster paramOneMonster;

ParamMonster paramTwoMonster;

if (firstMonster == Monsters::OGRE) // Сравниваем монстра со списком enum и присваиваем монстра к игроку с его параметрами

{

oneMonster = "Orge";

paramOneMonster = { 200,35,1 };

}

else

{

if (firstMonster == Monsters::GOBLIN)

{

oneMonster = "Goblin";

paramOneMonster = { 150,20,8 };

}

else

{

if (firstMonster == Monsters::SKELETON)

{

oneMonster = "Skeleton";

paramOneMonster = { 110,45,10 };

}

else

{

if (firstMonster == Monsters::ORC)

{

oneMonster = "Orc";

paramOneMonster = { 180,30,5 };

}

else

{

if (firstMonster == Monsters::TROLL)

{

oneMonster = "Troll";

paramOneMonster = { 140,25,6 };

}

if (secondMonster == Monsters::OGRE)

{

twoMonster = "Orge";

paramTwoMonster = { 200,35,1 };

}

else

{

if (secondMonster == Monsters::GOBLIN)

{

twoMonster = "Goblin";

paramTwoMonster = { 150,20,8 };

}

else

{

if (secondMonster == Monsters::SKELETON)

{

twoMonster = "Skeleton";

paramTwoMonster = { 110,45,10 };

}

else

{

if (secondMonster == Monsters::ORC)

{

twoMonster = "Orc";

paramTwoMonster = { 180,30,5 };

}

else

{

if (secondMonster == Monsters::TROLL)

{

twoMonster = "Troll";

paramTwoMonster = { 140,25,6 };

}

std::cout << "Player " << firstNameString << " choice " << oneMonster << ": Health = " << paramOneMonster.healthMonster <<

"; Attack = " << paramOneMonster.attackMonster << "; Defense = " << paramOneMonster.defenseMonster << "\n" << std::endl;

std::cout << "Player " << secondNameString << " choice " << twoMonster << ": Health = " << paramTwoMonster.healthMonster <<

"; Attack = " << paramTwoMonster.attackMonster << "; Defense = " << paramTwoMonster.defenseMonster << "\n" << std::endl;

int firstNameInteger = firstNameString.length();

int secondNameInteger = secondNameString.length();

if (firstNameInteger < secondNameInteger) // Первый удар будет за игроком чьё имя длинее

fight(secondNameString, twoMonster, paramTwoMonster, firstNameString, oneMonster, paramOneMonster);

else

{

fight(firstNameString, oneMonster, paramOneMonster, secondNameString, twoMonster, paramTwoMonster);

}

int main()

{

using namespace std;

cout << "Enter the name of the first player: ";

string firstNameString = getName();

cout << "Choose a monster for the first player (Orge, Goblin, Skeleton, Orc, Troll): ";

int firstPlayerMonster = getMonsters();

cout << "Enter the name of the second player: ";

string secondNameString = getName();

cout << "Choose a monster for the second player (Orge, Goblin, Skeleton, Orc, Troll): ";

int secondPlayerMonster = getMonsters();

ad(firstNameString, firstPlayerMonster, secondNameString, secondPlayerMonster);

return 0;

}

Ответить

Юрий:

26 мая 2018 в 00:51

Реально прикольно получилось 🙂 Долго делал?

Ответить

rpa4:

26 мая 2018 в 13:32

Ну где-то часик 🙂

Ответить

Юрий:

27 мая 2018 в 12:05

Нормально.

Константин:

20 декабря 2018 в 22:42

Уважаемый rpa4! Подскажите мне, пожалуйста, как Вы кодите предложение, в котором тип монстра задаётся буквами, а не как у меня — числом:

#include <Windows.h>
#include <iostream>
#include <string>
double enNum() {    std::cout<<" Stick here: "; double x{0}; std::cin>>x; return x; }

enum class MonsterType {  OGRE = 1, GOBLIN, ORC, TROLL, SKELETON,  };

struct Monster {  MonsterType type; std::string nameOfMonster; int evil; double health;  };
std::string getMonsterTypeString(Monster anyMonster){if(anyMonster.type == MonsterType::OGRE) return "Ogre";
                                                   if(anyMonster.type == MonsterType::GOBLIN) return "Goblin";
	                                               if(anyMonster.type == MonsterType::SKELETON)return "Skeleton";
	                                               if(anyMonster.type == MonsterType::ORC)return "Orc";
	                                               if(anyMonster.type == MonsterType::TROLL)return "Troll";}
void printanyMonster(Monster anyMonster)
{
    std::cout<<" Тип выбранного монстра: "<<getMonsterTypeString(anyMonster)<<std::endl;
    std::cout<<" Звать красавца - "<<anyMonster.nameOfMonster<<std::endl;
    std::cout<<" А злобности в ём "<<anyMonster.evil<<std::endl;
    std::cout<<" И здоровья немало "<<anyMonster.health<<"% "<<std::endl;
}
int main()
{
    SetConsoleCP(1251);
    SetConsoleOutputCP(1251);
    using namespace std;
    Monster ogre = {MonsterType::OGRE, " Joe ", 13, 55.55};
    Monster goblin = {MonsterType::GOBLIN, " Joshua ", 6, 33.33};
    Monster orc = {MonsterType::ORC, " John ", 11, 44.44};
    Monster troll = {MonsterType::TROLL, " James ", 0, 11.11};
    Monster skeleton = {MonsterType::SKELETON, " Jay ", 666, 99.99};
    cout<<" В программе типы монстров имеют следующие номера: "<<endl;
    cout<<"OGRE..."<<static_cast<int>(ogre.type)<<endl;
    cout<<"GOBLIN..."<<static_cast<int>(goblin.type)<<endl;
    cout<<"ORC..."<<static_cast<int>(orc.type)<<endl;
    cout<<"TROLL..."<<static_cast<int>(troll.type)<<endl;
    cout<<"SKELETON..."<<static_cast<int>(skeleton.type)<<endl;
    cout<<" Выберите чудовище, с которым Вы хотели бы иметь дело \n";
    int changeMonster{enNum()};
    if(changeMonster == static_cast<int>(ogre.type)) printanyMonster(ogre);
    if(changeMonster == static_cast<int>(goblin.type)) printanyMonster(goblin);
    if(changeMonster == static_cast<int>(orc.type)) printanyMonster(orc);
    if(changeMonster == static_cast<int>(troll.type)) printanyMonster(troll);
    if(changeMonster == static_cast<int>(skeleton.type)) printanyMonster(skeleton);
    else cout<< " Вариант выбора не заявленного монстра "<<endl;
    return 0;
}

#include <Windows.h>

#include <iostream>

#include <string>

double enNum() { std::cout<<" Stick here: "; double x{0}; std::cin>>x; return x; }

enum class MonsterType { OGRE = 1, GOBLIN, ORC, TROLL, SKELETON, };

struct Monster { MonsterType type; std::string nameOfMonster; int evil; double health; };

std::string getMonsterTypeString(Monster anyMonster){if(anyMonster.type == MonsterType::OGRE) return "Ogre";

if(anyMonster.type == MonsterType::GOBLIN) return "Goblin";

if(anyMonster.type == MonsterType::SKELETON)return "Skeleton";

if(anyMonster.type == MonsterType::ORC)return "Orc";

if(anyMonster.type == MonsterType::TROLL)return "Troll";}

void printanyMonster(Monster anyMonster)

{

std::cout<<" Тип выбранного монстра: "<<getMonsterTypeString(anyMonster)<<std::endl;

std::cout<<" Звать красавца - "<<anyMonster.nameOfMonster<<std::endl;

std::cout<<" А злобности в ём "<<anyMonster.evil<<std::endl;

std::cout<<" И здоровья немало "<<anyMonster.health<<"% "<<std::endl;

}

int main()

{

SetConsoleCP(1251);

SetConsoleOutputCP(1251);

using namespace std;

Monster ogre = {MonsterType::OGRE, " Joe ", 13, 55.55};

Monster goblin = {MonsterType::GOBLIN, " Joshua ", 6, 33.33};

Monster orc = {MonsterType::ORC, " John ", 11, 44.44};

Monster troll = {MonsterType::TROLL, " James ", 0, 11.11};

Monster skeleton = {MonsterType::SKELETON, " Jay ", 666, 99.99};

cout<<" В программе типы монстров имеют следующие номера: "<<endl;

cout<<"OGRE..."<<static_cast<int>(ogre.type)<<endl;

cout<<"GOBLIN..."<<static_cast<int>(goblin.type)<<endl;

cout<<"ORC..."<<static_cast<int>(orc.type)<<endl;

cout<<"TROLL..."<<static_cast<int>(troll.type)<<endl;

cout<<"SKELETON..."<<static_cast<int>(skeleton.type)<<endl;

cout<<" Выберите чудовище, с которым Вы хотели бы иметь дело \n";

int changeMonster{enNum()};

if(changeMonster == static_cast<int>(ogre.type)) printanyMonster(ogre);

if(changeMonster == static_cast<int>(goblin.type)) printanyMonster(goblin);

if(changeMonster == static_cast<int>(orc.type)) printanyMonster(orc);

if(changeMonster == static_cast<int>(troll.type)) printanyMonster(troll);

if(changeMonster == static_cast<int>(skeleton.type)) printanyMonster(skeleton);

else cout<< " Вариант выбора не заявленного монстра "<<endl;

return 0;

}

Игорь:

18 июля 2018 в 23:01

Тоже была такая же идея) Но я что-то не пойму, я что, где-то пропустил циклы в предыдущих уроках?

Ответить

Герман:

26 января 2018 в 22:03

Уважаемый автор, какой смысл функцией getMonsterTypeString(Monster monster) проверять логические условия, если типы "монстров" и так объявлены в enum class MonsterType?
Заранее спасибо!

Ответить
1. Юрий:
  
  26 января 2018 в 22:50
  
  В getMonsterTypeString мы присваиваем значения для MonsterType::GOBLIN и MonsterType::ORC — Goblin и Ork соответственно. Если бы мы не использовали getMonsterTypeString, то вместо MonsterType::GOBLIN выводилось бы 1, а вместо MonsterType::ORC — 3. Функция getMonsterTypeString — это инициализация элементов структуры и заодно проверка.
  
  Ответить
  1. Герман:
    
    26 января 2018 в 23:52
    
    Про инициализацию элементов структуры я не сообразил. Спасибо!
    
    Ответить

Глава №4. Итоговый тест

Теория

Тест

Комментариев: 18

Добавить комментарий Отменить ответ