1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
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
|
/*
* The Mana Server
* Copyright (C) 2004-2010 The Mana World Development Team
*
* This file is part of The Mana Server.
*
* The Mana Server is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* any later version.
*
* The Mana Server is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with The Mana Server. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef MONSTER_H
#define MONSTER_H
#include "game-server/abilitymanager.h"
#include "game-server/being.h"
#include "common/defines.h"
#include "scripting/script.h"
#include "utils/string.h"
#include <map>
#include <set>
#include <string>
#include <vector>
#include <sigc++/connection.h>
class CharacterComponent;
class ItemClass;
class Script;
/**
* Structure containing an item class and its probability to be dropped
* (unit: 1/10000).
*/
struct MonsterDrop
{
ItemClass *item;
int probability;
};
typedef std::vector< MonsterDrop > MonsterDrops;
typedef std::map<Element, double> Vulnerabilities;
/**
* Class describing the characteristics of a generic monster.
*/
class MonsterClass
{
public:
MonsterClass(int id):
mId(id),
mName("unnamed"),
mGender(GENDER_UNSPECIFIED),
mSpeed(1),
mSize(16),
mExp(-1),
mMutation(0),
mOptimalLevel(0)
{}
/**
* Returns monster type. This is the Id of the monster class.
*/
int getId() const
{ return mId; }
/**
* Returns the name of the monster type
*/
const std::string &getName() const
{ return mName; }
/**
* Sets the name of the monster type
*/
void setName(const std::string &name)
{ mName = name; }
void setGender(BeingGender gender)
{ mGender = gender; }
BeingGender getGender() const
{ return mGender; }
/**
* Sets monster drops. These are the items the monster drops when it
* dies.
*/
void setDrops(const MonsterDrops &v)
{ mDrops = v; }
/**
* Sets a being base attribute.
*/
void setAttribute(int attribute, double value)
{ mAttributes[attribute] = value; }
/**
* Returns a being base attribute.
*/
double getAttribute(int attribute) const
{ return mAttributes.at(attribute); }
/**
* Returns whether the monster has got the attribute.
*/
bool hasAttribute(int attribute) const
{ return (mAttributes.find(attribute) != mAttributes.end()); }
const std::map<int, double> &getAttributes() const
{ return mAttributes; }
/** Sets collision circle radius. */
void setSize(int size) { mSize = size; }
/** Returns collision circle radius. */
int getSize() const { return mSize; }
/** Sets experience reward for killing the monster. */
void setExp(int exp) { mExp = exp; }
/** Returns experience reward for killing the monster. */
int getExp() const { return mExp; }
/** Gets maximum skill level after which exp reward is reduced */
void setOptimalLevel(int level) { mOptimalLevel = level; }
/** Sets maximum skill level after which exp reward is reduced. */
int getOptimalLevel() const { return mOptimalLevel; }
/** Sets mutation factor in percent. */
void setMutation(unsigned factor) { mMutation = factor; }
/** Returns mutation factor in percent. */
unsigned getMutation() const { return mMutation; }
void addAbility(AbilityManager::AbilityInfo *info);
const std::set<AbilityManager::AbilityInfo *> &getAbilities() const;
void setUpdateCallback(Script *script)
{ script->assignCallback(mUpdateCallback); }
Script::Ref getUpdateCallback() const
{ return mUpdateCallback; }
private:
unsigned short mId;
std::string mName;
BeingGender mGender;
MonsterDrops mDrops;
std::map<int, double> mAttributes; /**< Base attributes of the monster. */
std::set<AbilityManager::AbilityInfo *> mAbilities;
float mSpeed; /**< The monster class speed in tiles per second */
int mSize;
int mExp;
int mMutation;
int mOptimalLevel;
/**
* A reference to the script function that is called each update.
*/
Script::Ref mUpdateCallback;
friend class MonsterManager;
friend class MonsterComponent;
};
/**
* The component for a fightable monster with its own AI
*/
class MonsterComponent : public Component
{
public:
static const ComponentType type = CT_Monster;
MonsterComponent(Entity &entity, MonsterClass *);
/**
* Returns monster specy.
*/
MonsterClass *getSpecy() const
{ return mSpecy; }
/**
* Performs one step of controller logic.
*/
void update(Entity &entity);
/**
* Signal handler
*/
void monsterDied(Entity *monster);
private:
static const int DECAY_TIME = 50;
MonsterClass *mSpecy;
/** Time until dead monster is removed */
Timeout mDecayTimeout;
};
inline void MonsterClass::addAbility(AbilityManager::AbilityInfo *info)
{
mAbilities.insert(info);
}
inline const std::set<AbilityManager::AbilityInfo *>
&MonsterClass::getAbilities() const
{
return mAbilities;
}
#endif // MONSTER_H
|
