/* -*-c++-*-
  * testGameActorLibrary - This source file (.h & .cpp) - Using 'The MIT License'
  * Copyright (C) 2006-2008, Alion Science and Technology Corporation
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
  * in the Software without restriction, including without limitation the rights
  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  * copies of the Software, and to permit persons to whom the Software is
  * furnished to do so, subject to the following conditions:
  *
  * The above copyright notice and this permission notice shall be included in
  * all copies or substantial portions of the Software.
  *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  * THE SOFTWARE.
  *
  * This software was developed by Alion Science and Technology Corporation under
  * circumstances in which the U. S. Government may have rights in the software.
  *
  * William E. Johnson II
  */
  include <iostream>
  include <testgameactor.h>
  include <dtCore/scene.h>
  include <dtDAL/enginepropertytypes.h>
  include <dtUtil/datastream.h>
  include <dtGame/messageparameter.h>
  include <dtGame/messagetype.h>
  include <dtGame/invokable.h>
  
  
//////////////////////////////////////////////////////////////


  // Actor Component Code
  
//////////////////////////////////////////////////////////////


  
  const dtGame::ActorComponent::ACType TestActorComponent1::TYPE("TestActorComponent1");
  
  TestActorComponent1::TestActorComponent1()
  : dtGame::ActorComponent(TYPE)
  , mWasAdded(false)
  , mWasRemoved(false)
  {
  }
  
  void TestActorComponent1::OnAddedToActor(dtGame::GameActor& actor)
  {
     mWasAdded = true;
  }
  
  void TestActorComponent1::OnRemovedFromActor(dtGame::GameActor& actor)
  {
     mWasRemoved = true;
  }
  
  const dtGame::ActorComponent::ACType TestActorComponent2::TYPE("TestActorComponent2");
  
  TestActorComponent2::TestActorComponent2()
  : dtGame::ActorComponent(TYPE)
  , mWasAdded(false)
  , mWasRemoved(false)
  {
  }
  
  void TestActorComponent2::OnAddedToActor(dtGame::GameActor& actor)
  {
     mWasAdded = true;
  }
  
  void TestActorComponent2::OnRemovedFromActor(dtGame::GameActor& actor)
  {
     mWasRemoved = true;
  }
  
//////////////////////////////////////////////////////////////


  // Proxy Code
  
//////////////////////////////////////////////////////////////


  TestGameActorProxy1::TestGameActorProxy1():ticksEnabled(false)
  {
     SetClassName("TestGameActor1");
  }
  
  TestGameActorProxy1::~TestGameActorProxy1()
  {
  
  }
  
  void TestGameActorProxy1::BuildPropertyMap()
  {
     dtGame::GameActorProxy::BuildPropertyMap();
  
     TestGameActor1* actor = NULL;
     GetActor(actor);
  
     static const dtUtil::RefString PROPERTY_HAS_FIRED("Has Fired");
     static const dtUtil::RefString PROPERTY_HAS_FIRED_LABEL("Has this actor fired");
     static const dtUtil::RefString PROPERTY_HAS_FIRED_DESC("Sets/Gets if this actor has fired.");
     AddProperty(new dtDAL::BooleanActorProperty(PROPERTY_HAS_FIRED, PROPERTY_HAS_FIRED_LABEL,
        dtDAL::BooleanActorProperty::SetFuncType(actor, &TestGameActor1::SetOneIsFired),
        dtDAL::BooleanActorProperty::GetFuncType(actor, &TestGameActor1::OneIsFired),
        PROPERTY_HAS_FIRED_DESC, ""));
  
     static const dtUtil::RefString PROPERTY_LOCAL_TICK_COUNT("Local Tick Count");
     static const dtUtil::RefString PROPERTY_LOCAL_TICK_COUNT_LABEL("The number of local tick messages received");
     static const dtUtil::RefString PROPERTY_LOCAL_TICK_COUNT_DESC("Sets/Gets the number of remote tick messages counted.");
     AddProperty(new dtDAL::IntActorProperty(PROPERTY_LOCAL_TICK_COUNT, PROPERTY_LOCAL_TICK_COUNT_LABEL,
        dtDAL::IntActorProperty::SetFuncType(actor, &TestGameActor1::SetTickLocals),
        dtDAL::IntActorProperty::GetFuncType(actor, &TestGameActor1::GetTickLocals),
        PROPERTY_LOCAL_TICK_COUNT_DESC, ""));
  
     static const dtUtil::RefString PROPERTY_REMOTE_TICK_COUNT("Remote Tick Count");
     static const dtUtil::RefString PROPERTY_REMOTE_TICK_COUNT_LABEL("The number of remote tick messages received");
     static const dtUtil::RefString PROPERTY_REMOTE_TICK_COUNT_DESC("Sets/Gets the number of remote tick messages counted.");
     AddProperty(new dtDAL::IntActorProperty(PROPERTY_REMOTE_TICK_COUNT, PROPERTY_REMOTE_TICK_COUNT_LABEL,
        dtDAL::IntActorProperty::SetFuncType(actor, &TestGameActor1::SetTickRemotes),
        dtDAL::IntActorProperty::GetFuncType(actor, &TestGameActor1::GetTickRemotes),
        PROPERTY_REMOTE_TICK_COUNT_DESC, ""));
  
     static const dtUtil::RefString PROPERTY_TEST_ACTOR_ID("Test_Actor_Id");
     static const dtUtil::RefString PROPERTY_TEST_ACTOR_ID_LABEL("Test Actor Id");
     static const dtUtil::RefString PROPERTY_TEST_ACTOR_ID_DESC("An example linked actor property");
     AddProperty(new dtDAL::ActorIDActorProperty(*this, PROPERTY_TEST_ACTOR_ID, PROPERTY_TEST_ACTOR_ID_LABEL,
        dtDAL::ActorIDActorProperty::SetFuncType(actor, &TestGameActor1::SetTestActorId),
        dtDAL::ActorIDActorProperty::GetFuncType(actor, &TestGameActor1::GetTestActorId),
        "dtCore::Transformable",
        PROPERTY_TEST_ACTOR_ID_DESC, ""));
  
     //add these to the accept filter so the tests can check them
     AddPropertyToLocalUpdateAcceptFilter(PROPERTY_HAS_FIRED);
     AddPropertyToLocalUpdateAcceptFilter(PROPERTY_REMOTE_TICK_COUNT);
  
     // Add and remove a property so the tests can verify this works.
     AddPropertyToLocalUpdateAcceptFilter(PROPERTY_LOCAL_TICK_COUNT);
     RemovePropertyFromLocalUpdateAcceptFilter(PROPERTY_LOCAL_TICK_COUNT);
  }
  
  void TestGameActorProxy1::BuildInvokables()
  {
     dtGame::GameActorProxy::BuildInvokables();
  
     TestGameActor1* actor = NULL;
     GetActor(actor);
  
     AddInvokable(*new dtGame::Invokable("Fire One",
        dtUtil::MakeFunctor(&TestGameActor1::FireOne, actor)));
  
     AddInvokable(*new dtGame::Invokable("Reset",
        dtUtil::MakeFunctor(&TestGameActor1::Reset, actor)));
  
     AddInvokable(*new dtGame::Invokable("Toggle Ticks",
        dtUtil::MakeFunctor(&TestGameActorProxy1::ToggleTicks, this)));
  
     //register local tick handles.
     //This is just to test local handler registration.  If you want to
     //register to receive tick messages, you would override OnEnteredWorld()
     //and add code like GetGameManager()->RegisterForMessages(dtGame::MessageType::TICK_LOCAL, *this, "Tick Local")
     RegisterForMessagesAboutSelf(dtGame::MessageType::TICK_LOCAL, dtGame::GameActorProxy::TICK_LOCAL_INVOKABLE);
     RegisterForMessagesAboutSelf(dtGame::MessageType::TICK_REMOTE, dtGame::GameActorProxy::TICK_REMOTE_INVOKABLE);
     //RegisterMessageHandler(dtGame::MessageType::TICK_LOCAL, "Tick Local");
     //RegisterMessageHandler(dtGame::MessageType::TICK_REMOTE, "Tick Remote");
     ticksEnabled = true;
  }
  
  void TestGameActorProxy1::CreateActor()
  {
     SetActor(*new TestGameActor1(*this));
  }
  
  void TestGameActorProxy1::ToggleTicks(const dtGame::Message& message)
  {
     if (ticksEnabled)
     {
        UnregisterForMessagesAboutSelf(dtGame::MessageType::TICK_LOCAL,
           dtGame::GameActorProxy::TICK_LOCAL_INVOKABLE);
        UnregisterForMessagesAboutSelf(dtGame::MessageType::TICK_REMOTE,
           dtGame::GameActorProxy::TICK_REMOTE_INVOKABLE);
        ticksEnabled = false;
     }
     else
     {
        RegisterForMessagesAboutSelf(dtGame::MessageType::TICK_LOCAL,
           dtGame::GameActorProxy::TICK_LOCAL_INVOKABLE);
        RegisterForMessagesAboutSelf(dtGame::MessageType::TICK_REMOTE,
           dtGame::GameActorProxy::TICK_REMOTE_INVOKABLE);
        ticksEnabled = true;
     }
  }
  
//////////////////////////////////////////////////////////////


  // Actor Code
  
//////////////////////////////////////////////////////////////


  TestGameActor1::TestGameActor1(dtGame::GameActorProxy& proxy): dtGame::GameActor(proxy), fired(false), tickLocals(0), tickRemotes(0)
  {
  }
  
  TestGameActor1::~TestGameActor1()
  {
  
  }
  
  void TestGameActor1::FireOne(const dtGame::Message& message)
  {
     fired = true;
  }
  
  void TestGameActor1::Reset(const dtGame::Message& message)
  {
     fired = false;
  }
  
  void TestGameActor1::OnTickLocal(const dtGame::TickMessage& tickMessage)
  {
     tickLocals++;
  }
  
  void TestGameActor1::OnTickRemote(const dtGame::TickMessage& tickMessage)
  {
     tickRemotes++;
  }