FIFE  2008.0
 All Classes Namespaces Functions Variables Enumerations Enumerator Pages
instance.h
1 /***************************************************************************
2  * Copyright (C) 2005-2011 by the FIFE team *
3  * http://www.fifengine.net *
4  * This file is part of FIFE. *
5  * *
6  * FIFE is free software; you can redistribute it and/or *
7  * modify it under the terms of the GNU Lesser General Public *
8  * License as published by the Free Software Foundation; either *
9  * version 2.1 of the License, or (at your option) any later version. *
10  * *
11  * This library is distributed in the hope that it will be useful, *
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of *
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU *
14  * Lesser General Public License for more details. *
15  * *
16  * You should have received a copy of the GNU Lesser General Public *
17  * License along with this library; if not, write to the *
18  * Free Software Foundation, Inc., *
19  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA *
20  ***************************************************************************/
21 
22 #ifndef FIFE_INSTANCE_H
23 #define FIFE_INSTANCE_H
24 
25 // Standard C++ library includes
26 #include <vector>
27 
28 // 3rd party library includes
29 
30 // FIFE includes
31 // These includes are split up in two parts, separated by one empty line
32 // First block: files included from the FIFE root src directory
33 // Second block: files included from the same folder
34 #include "util/base/fifeclass.h"
35 
36 #include "model/metamodel/object.h"
37 #include "model/metamodel/ivisual.h"
38 
39 #include "location.h"
40 
41 
42 namespace FIFE {
43 
44  class Layer;
45  class Action;
46  class Instance;
47  class ActionInfo;
48  class SayInfo;
49  class TimeProvider;
50 
51  class InstanceActionListener {
52  public:
53  virtual ~InstanceActionListener() {};
54  virtual void onInstanceActionFinished(Instance* instance, Action* action) = 0;
55  virtual void onInstanceActionFrame(Instance* instance, Action* action, int32_t frame) = 0;
56  };
57 
58  enum InstanceChangeType {
59  ICHANGE_NO_CHANGES = 0x0000,
60  ICHANGE_LOC = 0x0001,
61  ICHANGE_FACING_LOC = 0x0002,
62  ICHANGE_SPEED = 0x0004,
63  ICHANGE_ACTION = 0x0008,
64  ICHANGE_TIME_MULTIPLIER = 0x0010,
65  ICHANGE_SAYTEXT = 0x0020,
66  ICHANGE_ROTATION = 0x0040,
67  ICHANGE_BLOCK = 0x0080,
68  ICHANGE_CELL = 0x0100
69  };
70  typedef uint32_t InstanceChangeInfo;
71 
72  class InstanceChangeListener {
73  public:
74  virtual ~InstanceChangeListener() {};
75  virtual void onInstanceChanged(Instance* instance, InstanceChangeInfo info) = 0;
76  };
77 
78 
79  class InstanceDeleteListener {
80  public:
81  virtual ~InstanceDeleteListener() {};
82  virtual void onInstanceDeleted(Instance* instance) =0;
83  };
84 
88  class Instance : public FifeClass, public InstanceDeleteListener {
89  public:
90 
95  Instance(Object* object, const Location& location, const std::string& identifier="");
96 
99  virtual ~Instance();
100 
103  const std::string& getId() { return m_id; }
104 
107  void setId(const std::string& identifier="");
108 
111  Object* getObject() { return m_object; }
112 
116  void setLocation(const Location& loc);
117 
122  Location getLocation() const { return m_location; }
123 
127  Location& getLocationRef() { return m_location; }
128 
135  Location getTargetLocation() const;
136 
140  void setFacingLocation(const Location& loc);
141 
146  Location getFacingLocation();
147 
150  void setRotation(int32_t rotation);
151 
154  int32_t getRotation() const { return m_rotation; }
155 
162  Location& getFacingLocationRef();
163 
166  void setBlocking(bool blocking);
167 
170  bool isBlocking() const;
171 
174  void setOverrideBlocking(bool overblock) { m_override_blocking = overblock; }
175 
178  bool isOverrideBlocking() const { return m_override_blocking; }
179 
184  void callOnActionFrame(Action* action, int32_t frame);
185 
189  void addActionListener(InstanceActionListener* listener);
190 
194  void removeActionListener(InstanceActionListener* listener);
195 
199  void addChangeListener(InstanceChangeListener* listener);
200 
204  void removeChangeListener(InstanceChangeListener* listener);
205 
209  void addDeleteListener(InstanceDeleteListener* listener);
210 
214  void removeDeleteListener(InstanceDeleteListener* listener);
215 
220  Action* getCurrentAction() const;
221 
226  double getMovementSpeed() const;
227 
232  uint32_t getActionRuntime();
233 
239  void setActionRuntime(uint32_t time_offset);
240 
247  void move(const std::string& action_name, const Location& target, const double speed);
248 
254  void act(const std::string& action_name, const Location& direction, bool repeating=false);
255 
260  void say(const std::string& text, uint32_t duration=0);
261 
268  void follow(const std::string& action_name, Instance* leader, const double speed);
269 
272  const std::string* getSayText() const;
273 
279  InstanceChangeInfo update();
280 
283  bool isActive() const;
284 
287  void setVisual(IVisual* visual) { m_visual = visual; }
288 
291  template<typename T> T* getVisual() const { return reinterpret_cast<T*>(m_visual); }
292 
295  void setTimeMultiplier(float multip);
296 
299  float getTimeMultiplier();
300 
303  float getTotalTimeMultiplier();
304 
308  uint32_t getRuntime();
309 
313  void refresh();
314 
317  inline InstanceChangeInfo getChangeInfo();
318 
321  void onInstanceDeleted(Instance* instance);
322 
323  private:
324  std::string m_id;
325 
326  // The rotation offset of this instance. This is in addition to possible camera rotation and
327  // intended for setting, for example, a rotation of a tile.
328  int32_t m_rotation;
329 
338  class InstanceActivity {
339  public:
340  InstanceActivity(Instance& source);
341  ~InstanceActivity();
342 
343  // ----- Fields related to change tracking -----
344  // updates cached variables, marks changes
345  void update(Instance& source);
346  // location on previous round
347  Location m_location;
348  // rotation on previous round
349  int32_t m_rotation;
350  // facing location on previous round
351  Location m_facinglocation;
352  // action on previous round. @NOTE: might become invalid, only used for address comparison
353  Action* m_action;
354  // speed on previous round
355  double m_speed;
356  // time multiplier on previous round
357  float m_timemultiplier;
358  // say text on previous round
359  std::string m_saytxt;
360  // listeners for changes
361  std::vector<InstanceChangeListener*> m_changelisteners;
362 
363  // ----- Fields related to generic activity -----
364  // listeners for action related events
365  std::vector<InstanceActionListener*> m_actionlisteners;
366  // action information, allocated when actions are bind
367  ActionInfo* m_actioninfo;
368  // text to say + duration, allocated when something is said
369  SayInfo* m_sayinfo;
370  // time scaler for this instance
371  TimeProvider* m_timeprovider;
372  // blocking status on previous round
373  bool m_blocking;
374  };
375  InstanceActivity* m_activity;
376  // bitmask stating current changes
377  InstanceChangeInfo m_changeinfo;
378  // listeners for deletion of the instance
379  std::vector<InstanceDeleteListener*> m_deletelisteners;
380 
381  // object where instantiated from
382  Object* m_object;
383  // current location
384  Location m_location;
385  // current facing location. Just a pointer to save space e.g. on tiles
386  Location* m_facinglocation;
387  // instance visualization
388  IVisual* m_visual;
389  // instance blocking info
390  bool m_blocking;
391  // allow to override the blocking property
392  bool m_override_blocking;
393 
394  Instance(const Instance&);
395  Instance& operator=(const Instance&);
396  // Finalize current action
397  void finalizeAction();
398  // Initialize action for use
399  void initializeAction(const std::string& action_name);
400  // Moves instance. Returns true if finished
401  bool process_movement();
402  // Calculates movement based current location and speed
403  void calcMovement();
404  // rebinds time provider based on new location
405  void bindTimeProvider();
406  // called when instance has been changed. Causes instance to create InstanceActivity
407  void initializeChanges();
408  };
409 
410  inline InstanceChangeInfo Instance::getChangeInfo() {
411  if (m_activity) {
412  return m_changeinfo;
413  }
414  return ICHANGE_NO_CHANGES;
415  }
416 } // FIFE
417 
418 #endif
Instance(Object *object, const Location &location, const std::string &identifier="")
Definition: instance.cpp:185
void addActionListener(InstanceActionListener *listener)
Definition: instance.cpp:282
void setId(const std::string &identifier="")
Definition: instance.cpp:268
void addDeleteListener(InstanceDeleteListener *listener)
Definition: instance.cpp:636
void callOnActionFrame(Action *action, int32_t frame)
Definition: instance.cpp:307
bool isActive() const
Definition: instance.cpp:227
bool isBlocking() const
Definition: instance.cpp:278
const std::string & getId()
Definition: instance.h:103
void setFacingLocation(const Location &loc)
Definition: instance.cpp:401
Location getTargetLocation() const
Definition: instance.cpp:528
void act(const std::string &action_name, const Location &direction, bool repeating=false)
Definition: instance.cpp:376
InstanceChangeInfo getChangeInfo()
Definition: instance.h:410
T * getVisual() const
Definition: instance.h:291
uint32_t getActionRuntime()
Definition: instance.cpp:555
void setVisual(IVisual *visual)
Definition: instance.h:287
void setActionRuntime(uint32_t time_offset)
Definition: instance.cpp:564
Action * getCurrentAction() const
Definition: instance.cpp:521
void follow(const std::string &action_name, Instance *leader, const double speed)
Definition: instance.cpp:365
Location & getFacingLocationRef()
Definition: instance.cpp:546
const std::string * getSayText() const
Definition: instance.cpp:394
void removeDeleteListener(InstanceDeleteListener *listener)
Definition: instance.cpp:640
void addChangeListener(InstanceChangeListener *listener)
Definition: instance.cpp:302
void setOverrideBlocking(bool overblock)
Definition: instance.h:174
int32_t getRotation() const
Definition: instance.h:154
Location getFacingLocation()
Definition: instance.cpp:542
void setTimeMultiplier(float multip)
Definition: instance.cpp:593
Location & getLocationRef()
Definition: instance.h:127
Location getLocation() const
Definition: instance.h:122
void removeChangeListener(InstanceChangeListener *listener)
Definition: instance.cpp:321
void onInstanceDeleted(Instance *instance)
Definition: instance.cpp:655
void setBlocking(bool blocking)
Definition: instance.cpp:272
double getMovementSpeed() const
Definition: instance.cpp:535
float getTotalTimeMultiplier()
Definition: instance.cpp:608
bool isOverrideBlocking() const
Definition: instance.h:178
float getTimeMultiplier()
Definition: instance.cpp:601
void move(const std::string &action_name, const Location &target, const double speed)
Definition: instance.cpp:356
InstanceChangeInfo update()
Definition: instance.cpp:436
void setRotation(int32_t rotation)
Definition: instance.cpp:256
void removeActionListener(InstanceActionListener *listener)
Definition: instance.cpp:287
virtual ~Instance()
Definition: instance.cpp:198
uint32_t getRuntime()
Definition: instance.cpp:621
void refresh()
Definition: instance.cpp:588
Object * getObject()
Definition: instance.h:111
void setLocation(const Location &loc)
Definition: instance.cpp:231
void say(const std::string &text, uint32_t duration=0)
Definition: instance.cpp:383