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
|
// Cyphesis Online RPG Server and AI Engine
// Copyright (C) 2000,2001 Alistair Riddoch
//
// This program 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
// (at your option) any later version.
//
// This program 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 this program; if not, write to the Free Software Foundation,
// Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
// $Id: Entity.h,v 1.102 2008-03-26 01:34:16 alriddoch Exp $
#ifndef RULESETS_ENTITY_H
#define RULESETS_ENTITY_H
#include "attributes.h"
#include "LocatedEntity.h"
#include "modules/Location.h"
#include "common/BaseWorld.h"
#include <iostream>
class Motion;
/// \brief Classes that model in world entities
///
/// These classes are used to model all in world entities or objects.
/// \defgroup EntityClasses In World Entity Classes
/// \brief This is the base class from which all in-game objects inherit.
///
/// This class should not normally be instantiated directly.
/// This class provides hard-coded attributes which are common to most
/// in game objects, the dynamic attributes map, and a means to access both
/// transparantly without needing to know which are which.
/// This is now also intended to be the base for in-game persistance.
/// It implements the basic types required for persistance.
/// \ingroup EntityClasses
class Entity : public LocatedEntity {
private:
/// Flag indicating that this entity has been destroyed
bool m_destroyed;
protected:
/// Motion behavoir of this entity
Motion * m_motion;
/// Map of operation handlers
HandlerMap m_operationHandlers;
/// Is this perceptive
bool m_perceptive;
public:
/// Flags indicating changes to attributes
unsigned int m_update_flags;
explicit Entity(const std::string & id, long intId);
virtual ~Entity();
/// \brief Check if this entity is flagged as destroyed
bool isDestroyed() const {
return m_destroyed;
}
/// \brief Accessor for pointer to motion object
Motion * motion() const {
return m_motion;
}
/// \brief Send an operation to the world for dispatch.
///
/// sendWorld() bipasses serialno assignment, so you must ensure
/// that serialno is sorted. This allows client serialnos to get
/// in, so that client gets correct usefull refnos back.
void sendWorld(const Operation & op) {
BaseWorld::instance().message(op, *this);
}
/// \brief Accessor for update flags
const int getUpdateFlags() const { return m_update_flags; }
/// \brief Check if this entity is flagged as perceptive
const bool isPerceptive() const { return m_perceptive; }
/// \brief Reset the update flags
void clearUpdateFlags() { m_update_flags = 0; }
virtual void setAttr(const std::string & name,
const Atlas::Message::Element &);
void setProperty(const std::string & name, PropertyBase * prop);
void installHandler(int, Handler);
void destroy();
virtual void addToMessage(Atlas::Message::MapType &) const;
virtual void addToEntity(const Atlas::Objects::Entity::RootEntity &) const;
virtual void ActuateOperation(const Operation &, OpVector &);
virtual void AppearanceOperation(const Operation &, OpVector &);
virtual void AttackOperation(const Operation &, OpVector &);
virtual void CombineOperation(const Operation &, OpVector &);
virtual void CreateOperation(const Operation &, OpVector &);
virtual void DeleteOperation(const Operation &, OpVector &);
virtual void DisappearanceOperation(const Operation &, OpVector &);
virtual void DivideOperation(const Operation &, OpVector &);
virtual void EatOperation(const Operation &, OpVector &);
virtual void ImaginaryOperation(const Operation &, OpVector &);
virtual void LookOperation(const Operation &, OpVector &);
virtual void MoveOperation(const Operation &, OpVector &);
virtual void NourishOperation(const Operation &, OpVector &);
virtual void SetOperation(const Operation &, OpVector &);
virtual void SetupOperation(const Operation &, OpVector &);
virtual void SightOperation(const Operation &, OpVector &);
virtual void SoundOperation(const Operation &, OpVector &);
virtual void TalkOperation(const Operation &, OpVector &);
virtual void TickOperation(const Operation &, OpVector &);
virtual void TouchOperation(const Operation &, OpVector &);
virtual void UpdateOperation(const Operation &, OpVector &);
virtual void WieldOperation(const Operation &, OpVector &);
virtual void externalOperation(const Operation & op);
virtual void operation(const Operation &, OpVector &);
void callOperation(const Operation &, OpVector &);
virtual void onContainered();
/// Signal indicating that this entity has been changed
sigc::signal<void> updated;
/// Single shot signal indicating that this entity has changed its LOC
sigc::signal<void> containered;
/// \brief Signal emitted when this entity is removed from the server
///
/// Note that this is usually well before the object is actually deleted
/// and marks the conceptual destruction of the concept this entity
/// represents, not the destruction of this object.
sigc::signal<void> destroyed;
};
inline std::ostream & operator<<(std::ostream& s, Location& v)
{
return s << "{" << v.m_loc->getId() << "," << v.pos() << ","
<< v.m_velocity << "}";
}
#endif // RULESETS_ENTITY_H
|
