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
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
|
/*
* 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 <map>
#include <vector>
#include <string>
#include "game-server/being.hpp"
#include "game-server/eventlistener.hpp"
#include "defines.h"
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;
/**
* Structure containing different attack types of a monster type
*/
struct MonsterAttack
{
unsigned id;
int priority;
float damageFactor;
int element;
int type;
int preDelay;
int aftDelay;
int range;
std::string scriptFunction;
};
typedef std::vector< MonsterAttack *> MonsterAttacks;
/**
* Class describing the characteristics of a generic monster.
*/
class MonsterClass
{
public:
MonsterClass(int id):
mID(id),
mAttributes(BASE_ATTR_NB, 0),
mSpeed(1),
mSize(16),
mExp(-1),
mAggressive(false),
mTrackRange(1),
mStrollRange(0),
mMutation(0),
mAttackDistance(0),
mOptimalLevel(0),
mScript("")
{}
/**
* Returns monster type. This is the ID of the monster class.
*/
int getType() const
{ return mID; }
/**
* 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(size_t attribute, int value)
{ mAttributes.at(attribute) = value; }
/**
* Returns a being base attribute.
*/
int getAttribute(size_t attribute) const
{ return mAttributes.at(attribute); }
/** Sets movement speed in tiles per second. */
void setSpeed(float speed) { mSpeed = speed; }
/** Returns movement speed in tiles per second. */
float getSpeed() const { return mSpeed; }
/** 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 if the monster attacks without being attacked first. */
void setAggressive(bool aggressive) { mAggressive = aggressive; }
/** Returns if the monster attacks without being attacked first. */
bool isAggressive() const { return mAggressive; }
/** Sets range in tiles in which the monster searches for enemies. */
void setTrackRange(unsigned range){ mTrackRange = range; }
/**
* Returns range in tiles in which the monster searches for enemies.
*/
unsigned getTrackRange() const { return mTrackRange; }
/** Sets range in tiles in which the monster moves around when idle. */
void setStrollRange(unsigned range) { mStrollRange = range; }
/**
* Returns range in tiles in which the monster moves around when idle.
*/
unsigned getStrollRange() const { return mStrollRange; }
/** Sets mutation factor in percent. */
void setMutation(unsigned factor) { mMutation = factor; }
/** Returns mutation factor in percent. */
unsigned getMutation() const { return mMutation; }
/** Sets preferred combat distance in pixels. */
void setAttackDistance(unsigned distance)
{ mAttackDistance = distance; }
/** Returns preferred combat distance in pixels. */
unsigned getAttackDistance() const { return mAttackDistance; }
/** Adds an attack to the monsters repertoire. */
void addAttack(MonsterAttack *type) { mAttacks.push_back(type); }
/** Returns all attacks of the monster. */
const MonsterAttacks &getAttacks() const { return mAttacks; }
/** sets the script file for the monster */
void setScript(const std::string &filename) { mScript = filename; }
/** Returns script filename */
const std::string &getScript() const { return mScript; }
/**
* Randomly selects a monster drop (may return NULL).
*/
ItemClass *getRandomDrop() const;
private:
unsigned short mID;
MonsterDrops mDrops;
std::vector<int> mAttributes; /**< Base attributes of the monster. */
float mSpeed; /**< The monster class speed in tiles per second */
int mSize;
int mExp;
bool mAggressive;
int mTrackRange;
int mStrollRange;
int mMutation;
int mAttackDistance;
int mOptimalLevel;
MonsterAttacks mAttacks;
std::string mScript;
};
/**
* Structure holding possible positions relative to the target from which
* the monster can attack
*/
struct AttackPosition
{
AttackPosition(int posX, int posY, Direction dir):
x(posX),
y(posY),
direction(dir)
{};
int x;
int y;
Direction direction;
};
/**
* The class for a fightable monster with its own AI
*/
class Monster : public Being
{
public:
/** Time in game ticks until ownership of a monster can change. */
static const int KILLSTEAL_PROTECTION_TIME = 100;
/**
* Constructor.
*/
Monster(MonsterClass *);
/**
* Destructor.
*/
~Monster();
/**
* Returns monster specy.
*/
MonsterClass *getSpecy() const
{ return mSpecy; }
/**
* Performs one step of controller logic.
*/
void update();
/**
* Performs an attack, if needed.
*/
void perform();
/**
* Loads a script file for this monster
*/
void loadScript(const std::string &scriptName);
/**
*
*/
virtual int getAttackType() const
{ return mCurrentAttack->id; }
/**
* Kills the being.
*/
void died();
/**
* Alters hate for the monster
*/
void changeAnger(Actor *target, int amount);
/**
* Calls the damage function in Being and updates the aggro list
*/
virtual int damage(Actor *source, const Damage &damage);
/**
* Removes a being from the anger list.
*/
void forgetTarget(Thing *being);
/**
* Returns the way the actor is blocked by other things on the map.
*/
virtual unsigned char getWalkMask() const
{
// blocked walls, other monsters and players ( bin 1000 0011)
return 0x83;
}
protected:
/**
* Returns the way the actor blocks pathfinding for other objects.
*/
virtual Map::BlockType getBlockType() const
{ return Map::BLOCKTYPE_MONSTER; }
private:
static const int DECAY_TIME = 50;
int calculatePositionPriority(Point position, int targetPriority);
MonsterClass *mSpecy;
/**
* Stores individual script for the monster, when NULL the script
* from mSpecy is used.
*/
Script *mScript;
/** Aggression towards other beings. */
std::map<Being *, int> mAnger;
/** Listener for updating the anger list. */
EventListener mTargetListener;
/**
* Character who currently owns this monster (killsteal protection).
*/
Character *mOwner;
/** List of characters and their skills that attacked this monster. */
std::map<Character *, std::set <size_t> > mExpReceivers;
/**
* List of characters who are entitled to receive exp (killsteal
* protection).
*/
std::set<Character *> mLegalExpReceivers;
/** Attack the monster is currently performing. */
MonsterAttack *mCurrentAttack;
/**
* Set positions relative to target from which the monster can attack.
*/
std::list<AttackPosition> mAttackPositions;
friend struct MonsterTargetEventDispatch;
};
#endif // MONSTER_H
|