MABehavior.hpp

/*
 *  This file is part of the AiBO+ project
 *
 *  Copyright (C) 2005-2016 Csaba Kertész (csaba.kertesz@gmail.com)
 *
 *  AiBO+ 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.
 *
 *  AiBO+ 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., 59 Temple Street #330, Boston, MA 02111-1307, USA.
 *
 */

#pragma once

#include "core/MASignal.hpp"
#include "types/MALeg.hpp"
#include "sound/MASoundBase.hpp"

#include <boost/shared_ptr.hpp>
#include <boost/unordered_map.hpp>

#include <vector>

class MABehavior;
class MAController;
class MCTimer;

#define MABEHAVIOR_CREATE(_behavior, _master, ...) \
  MABEHAVIOR_CREATE_S(_behavior, _master, "", __VA_ARGS__)

// The pointer magic _master -> Temp -> Master is done to avoid c-type casts.
// _master can be NULL then the compiler will complain to dynamic cast NULL pointer.
// Interestingly, static_cast works, but dynamic_cast causes crash in mindaibotests.
#define MABEHAVIOR_CREATE_S(_behavior, _master, _name_suffix, ...) \
  { \
    MABehavior* _Temp = _master; \
    MABehavior* _Master = static_cast<MABehavior*>(_Temp); \
     \
    if (!MABehavior::Exists(MCGetClassName<_behavior>(nullptr, _name_suffix)) && \
        !(_Master != nullptr && \
          (_Master->GetState() == MABehavior::Failed || \
           _Master->GetState() == MABehavior::Finished))) \
    { \
      _behavior* Behavior = new _behavior(__VA_ARGS__); \
      \
      if (_Master != nullptr) \
        _Master->AddSlave(*Behavior); \
    } \
  }

#define MABEHAVIOR_GET(_behavior) \
  MABEHAVIOR_GET_S(_behavior, "")

#define MABEHAVIOR_GET_S(_behavior, _name_suffix) \
  dynamic_cast<_behavior*>(MABehavior::GetBehavior(MCGetClassName<_behavior>(nullptr, _name_suffix)));

#define MABEHAVIOR_EXISTS(_behavior) \
  MABEHAVIOR_EXISTS_S(_behavior, "")

#define MABEHAVIOR_EXISTS_S(_behavior, _name_suffix) \
  MABehavior::Exists(MCGetClassName<_behavior>(nullptr, _name_suffix))

#define MABEHAVIOR_DELETE(_behavior) \
  MABEHAVIOR_DELETE_S(_behavior, "")

#define MABEHAVIOR_DELETE_S(_behavior, _name_suffix) \
  { \
    MABehavior* Behavior = MABehavior::GetBehavior(MCGetClassName<_behavior>(nullptr, _name_suffix)); \
    \
    if (Behavior) \
    { \
      Behavior->MarkDirty(); \
    } \
  }

#define MABEHAVIOR_IS_NORMAL(_behavior) \
  MABEHAVIOR_IS_NORMAL_S(_behavior, "")

#define MABEHAVIOR_IS_NORMAL_S(_behavior, _name_suffix) \
  (MABEHAVIOR_EXISTS_S(_behavior, _name_suffix) ? \
     MABehavior::GetBehavior(MCGetClassName<_behavior>(nullptr, _name_suffix))->GetState() == MABehavior::Normal : \
     false)

#define MABEHAVIOR_IS_ACTIVATED(_behavior) \
  MABEHAVIOR_IS_ACTIVATED_S(_behavior, "")

#define MABEHAVIOR_IS_ACTIVATED_S(_behavior, _name_suffix) \
  (MABEHAVIOR_EXISTS_S(_behavior, _name_suffix) ? \
     MABehavior::GetBehavior(MCGetClassName<_behavior>(nullptr, _name_suffix))->GetState() == MABehavior::Activated : \
     false)

#define MABEHAVIOR_IS_FINISHED(_behavior) \
  MABEHAVIOR_IS_FINISHED_S(_behavior, "")

#define MABEHAVIOR_IS_FINISHED_S(_behavior, _name_suffix) \
  (MABEHAVIOR_EXISTS_S(_behavior, _name_suffix) ? \
     MABehavior::GetBehavior(MCGetClassName<_behavior>(nullptr, _name_suffix))->GetState() == MABehavior::Finished : \
     false)

#define MABEHAVIOR_IS_FAILED(_behavior) \
  MABEHAVIOR_IS_FAILED_ADNVANCED(_behavior, "")

#define MABEHAVIOR_IS_FAILED_ADNVANCED(_behavior, _name_suffix) \
  (MABEHAVIOR_EXISTS_S(_behavior, _name_suffix) ? \
     MABehavior::GetBehavior(MCGetClassName<_behavior>(nullptr, _name_suffix))->GetState() == MABehavior::Failed : \
     false)

namespace MA
{
typedef std::vector<boost::shared_ptr<MABehavior> > BehaviorList;

typedef std::vector<MABehavior*> BehaviorPtrList;

typedef boost::unordered_map<std::string, float> DesiredConnectionMap;

typedef boost::unordered_map<MABehavior*, float> ConnectionMap;

typedef boost::unordered_map<std::string, int> IncomingActivationMap;

typedef boost::unordered_multimap<MAController*, std::string> ControllerTransitionMap;

typedef boost::unordered_map<MAIntervalNum<int>*, float> EmotionWeightMap;
}

class MABehavior
{
  MA_SLOT_CLASS

  typedef MASignal<MABehavior&> BehaviorDestroyedSignalType;

  MC_DISABLE_COPY(MABehavior)
  template <typename T>
  friend void boost::checked_delete(T*);

public:
  typedef enum
  {
    NoStimulus = 0,    
    Stimulated,        
    OverStimulated,    
  } StimulusLevelType;

  typedef enum
  {
    Normal = 0,        
    Activated,         
    Finished,          
    Failed,            
  } StateType;

  MABehavior(const std::string& type_name, bool dynamic = true);
  virtual ~MABehavior();

  static const MA::BehaviorList& GetBehaviors();

  static const MA::BehaviorList& GetNewBehaviors();

  static void SetVerbose(bool new_state);

  static bool IsVerbose();

  static void ClearBehaviorStateEvents();

  static MABehavior* GetBehavior(const std::string& type_name);

  static bool Exists(const std::string& type_name, bool can_be_dying = false);

  static bool Exists(const MABehavior* behavior, bool can_be_dying = false);

  static bool IsDying(const std::string& type_name);

  static bool IsDying(const MABehavior* behavior);

  static void CalculateActivations();

  static void GarbageCollection();

  static void Cleanup();

  static void MergeNewBehaviors();

  static void DumpBehaviors();

  static bool IsMergeNeeded();

  inline const std::string& GetTypeName() const
  {
    return TypeName;
  }

  inline StateType GetState() const
  {
    return State;
  }

  inline bool IsDynamic() const
  {
    return Dynamic;
  }

  void AddSlave(MABehavior& slave);

  MABehavior* GetMaster();

  void SetMaster(MABehavior* master);

  bool HasSlave() const;

protected:

  void ResetSelfActivation();

  void SetMaxSelfActivation();

  void SetSelfActivationDuration(const int new_duration);

  int GetSelfActivationDuration() const;

public:

  void SetLifetimeExpirationTime(const unsigned int expiration_time);

  void SetActivatedStateExpirationTime(const unsigned int expiration_time);

  int GetElapsedActivatedStateTime() const;

  int GetActivationLevel();

  bool HasActivatedStateExpired() const;

  void Input();

  void SetState(StateType new_state);

  void MarkDirty();

  void StartTransition(MAController& controller, const std::string& transition_name);

  void RegisterActiveTransition(MAController& controller, const std::string& transition_name);

  int PlaySound(const std::string& name);

  int PlaySound(MA::SoundBaseSPtr sound);

private:

  void AddConnection(MABehavior& other);

  void RemoveConnection(MABehavior& other);

  virtual MABehavior::StimulusLevelType GetCurrentStimulus() = 0;

  bool AreActiveTransitionsFinished();

  bool AnyActiveTransitionFailed() const;

  void StopActiveTransitions();

  void ClearActiveTransitions();

  bool AreSoundPlaybacksFinished();

  void ClearSoundPlaybacks();

  virtual bool IsFinished();

  virtual bool IsFailed();

  virtual void ActivatingActions();

  virtual void ActivatedStateUpdate();

  virtual void FailingActions();

  virtual void FinishingActions();

  void SendOutgoingActivations();

  void ClearIncomingActivations();

  void AddIncomingActivation(int value);

  void SlaveDeleted(MABehavior& behavior);

public:
  boost::shared_ptr<BehaviorDestroyedSignalType> BehaviorDestroyedSignal;
private:
  std::string TypeName;
  StateType State;
  MABehavior* Master;
protected:
  MA::DesiredConnectionMap DesiredConnections;
private:
  MA::BehaviorPtrList SlaveBehaviors;
  MA::ConnectionMap Connections;
  /*
   * Self-activation level (scaled: 0 - neutral; 100 - maximal activation).
   * This variable is the likelihood for the behavior to be activated and it inhibits or
   * stimulates other behaviors via connections. The default time to reach the maximal
   * activation is 1000 ms.
   */
  MAIntervalNum<int> SelfActivation;
  int IncomingActivationLevel;
  bool Dynamic;
  boost::shared_ptr<MCTimer> ActivatedStateTimer;
  boost::shared_ptr<MCTimer> LifetimeTimer;
  int ActivatedStateStartTimestamp;
  MA::ControllerTransitionMap ActiveTransitions;
  int SoundPlaybackID;
  MC::StringList QueuedSounds;
  std::vector<MA::SoundBaseSPtr> QueuedInMemorySounds;
  MA::EmotionWeightMap EmotionWeights;
};

template <typename T>
MABehavior* MACreateBehavior(MABehavior* master)
{
  if (!MABehavior::Exists(MCGetClassName<T>()) &&
      !(master != nullptr &&
        (master->GetState() == MABehavior::Failed || master->GetState() == MABehavior::Finished)))
  {
    T* Behavior = new T();

    if (master)
      master->AddSlave(*Behavior);
    return Behavior;
  }
  return nullptr;
}