d:/Cpp/RoboidControl/Thing.h

#pragma once
#include <iostream>
#include <list>
#include "LinearAlgebra/Spherical.h"
#include "LinearAlgebra/SwingTwist.h"
 
namespace RoboidControl {
 
class Participant;
class LocalParticipant;
 
#define THING_STORE_SIZE 256
// IMPORTANT: values higher than 256 will need to change the Thing::id type
// to 16-bit or higher, breaking the networking protocol!
 
#pragma region Types
 
class Thing {
 public:
  enum Type {
    Undetermined,
    // Sensor,
    Switch,
    DistanceSensor,
    DirectionalSensor,
    TemperatureSensor,
    TouchSensor,
    // Motor,
    ControlledMotor,
    UncontrolledMotor,
    Servo,
    // Other
    Roboid,
    Humanoid,
    ExternalSensor,
  };
 
// Types
#pragma endregion
 
#pragma region Init
 
  Thing(int thingType = Type::Undetermined);
  Thing(Participant* participant, Type thingType = Type::Undetermined);
  Thing(Participant* participant, int thingType);
  Thing(Participant* participant, unsigned char networkId, unsigned char thingId, Type thingType = Type::Undetermined);
 
// Init
#pragma endregion
 
#pragma region Properties
 
  Participant* owner = nullptr;
  unsigned char networkId = 0;
  unsigned char id = 0;
 
  unsigned char type = Type::Undetermined;
 
  virtual void SetParent(Thing* parent);
  Thing* GetParent();
  // void SetParent(Thing* root, const char* name);
 
 protected:
  Thing* parent = nullptr;
 
 public:
  virtual void AddChild(Thing* child);
  bool RemoveChild(Thing* child);
 
  unsigned char childCount = 0;
  Thing* GetChild(unsigned char thingId, bool recursively = false);
  // Thing* GetChildByIndex(unsigned char ix);
  Thing* FindChild(const char* name, bool recursively = true);
 
 protected:
  Thing** children = nullptr;
 
 public:
  const char* name = nullptr;
  const char* modelUrl = nullptr;
  // float modelScale = 1;
 
 public:
  void SetPosition(Spherical position);
  Spherical GetPosition();
  bool positionUpdated = false;
 
 private:
  Spherical position;
 
 public:
  void SetOrientation(SwingTwist16 orientation);
  SwingTwist16 GetOrientation();
  // float scale = 1;  // assuming uniform scale
  bool orientationUpdated = false;
 
 private:
  SwingTwist16 orientation;
 
 public:
  void SetLinearVelocity(Spherical linearVelocity);
  virtual Spherical GetLinearVelocity();
  bool linearVelocityUpdated = false;
 
 private:
  Spherical linearVelocity;
 
 public:
  virtual void SetAngularVelocity(Spherical angularVelocity);
  virtual Spherical GetAngularVelocity();
  bool angularVelocityUpdated = false;
 
 private:
  Spherical angularVelocity;
 
  // Properties
#pragma endregion
 
#pragma region Methods
 
 public:
  static unsigned long GetTimeMs(); // Move to TimeManager like in C#?
 
  void Update(bool recursively = false);
  virtual void Update(unsigned long currentTimeMs, bool recursively = false);  // { (void)currentTimeMs; };
 
  static void UpdateThings(unsigned long currentTimeMs);
 
  virtual void GenerateBinary(char* buffer, unsigned char* ix);
  virtual void ProcessBinary(char* bytes);
 
// Methods
#pragma endregion
};
 
}  // namespace RoboidControl