blender/source/gameengine/GameLogic/SCA_ISensor.cpp
2011-09-01 02:12:53 +00:00

440 lines
11 KiB
C++

/*
* Abstract class for sensor logic bricks
*
* $Id$
*
* ***** BEGIN GPL LICENSE BLOCK *****
*
* 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.
*
* The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
* All rights reserved.
*
* The Original Code is: all of this file.
*
* Contributor(s): none yet.
*
* ***** END GPL LICENSE BLOCK *****
*/
/** \file gameengine/GameLogic/SCA_ISensor.cpp
* \ingroup gamelogic
*/
#include <stddef.h>
#include "SCA_ISensor.h"
#include "SCA_EventManager.h"
#include "SCA_LogicManager.h"
// needed for IsTriggered()
#include "SCA_PythonController.h"
#include <stdio.h>
/* Native functions */
void SCA_ISensor::ReParent(SCA_IObject* parent)
{
SCA_ILogicBrick::ReParent(parent);
// will be done when the sensor is activated
//m_eventmgr->RegisterSensor(this);
//this->SetActive(false);
}
SCA_ISensor::SCA_ISensor(SCA_IObject* gameobj,
class SCA_EventManager* eventmgr) :
SCA_ILogicBrick(gameobj)
{
m_links = 0;
m_suspended = false;
m_invert = false;
m_level = false;
m_tap = false;
m_reset = false;
m_pos_ticks = 0;
m_neg_ticks = 0;
m_pos_pulsemode = false;
m_neg_pulsemode = false;
m_pulse_frequency = 0;
m_state = false;
m_prev_state = false;
m_eventmgr = eventmgr;
}
SCA_ISensor::~SCA_ISensor()
{
// intentionally empty
}
void SCA_ISensor::ProcessReplica()
{
SCA_ILogicBrick::ProcessReplica();
m_linkedcontrollers.clear();
}
bool SCA_ISensor::IsPositiveTrigger() {
bool result = false;
if (m_eventval) {
result = (m_eventval->GetNumber() != 0.0);
}
if (m_invert) {
result = !result;
}
return result;
}
void SCA_ISensor::SetPulseMode(bool posmode,
bool negmode,
int freq) {
m_pos_pulsemode = posmode;
m_neg_pulsemode = negmode;
m_pulse_frequency = freq;
}
void SCA_ISensor::SetInvert(bool inv) {
m_invert = inv;
}
void SCA_ISensor::SetLevel(bool lvl) {
m_level = lvl;
}
void SCA_ISensor::SetTap(bool tap) {
m_tap = tap;
}
double SCA_ISensor::GetNumber() {
return GetState();
}
void SCA_ISensor::Suspend() {
m_suspended = true;
}
bool SCA_ISensor::IsSuspended() {
return m_suspended;
}
void SCA_ISensor::Resume() {
m_suspended = false;
}
void SCA_ISensor::Init() {
printf("Sensor %s has no init function, please report this bug to Blender.org\n", m_name.Ptr());
}
void SCA_ISensor::DecLink() {
m_links--;
if (m_links < 0)
{
printf("Warning: sensor %s has negative m_links: %d\n", m_name.Ptr(), m_links);
m_links = 0;
}
if (!m_links)
{
// sensor is detached from all controllers, remove it from manager
UnregisterToManager();
}
}
void SCA_ISensor::RegisterToManager()
{
// sensor is just activated, initialize it
Init();
m_state = false;
m_eventmgr->RegisterSensor(this);
}
void SCA_ISensor::Replace_EventManager(class SCA_LogicManager* logicmgr)
{
if(m_links) { /* true if we're used currently */
m_eventmgr->RemoveSensor(this);
m_eventmgr= logicmgr->FindEventManager(m_eventmgr->GetType());
m_eventmgr->RegisterSensor(this);
}
else {
m_eventmgr= logicmgr->FindEventManager(m_eventmgr->GetType());
}
}
void SCA_ISensor::LinkToController(SCA_IController* controller)
{
m_linkedcontrollers.push_back(controller);
}
void SCA_ISensor::UnlinkController(SCA_IController* controller)
{
std::vector<class SCA_IController*>::iterator contit;
for (contit = m_linkedcontrollers.begin();!(contit==m_linkedcontrollers.end());++contit)
{
if ((*contit) == controller)
{
*contit = m_linkedcontrollers.back();
m_linkedcontrollers.pop_back();
return;
}
}
printf("Missing link from sensor %s:%s to controller %s:%s\n",
m_gameobj->GetName().ReadPtr(), GetName().ReadPtr(),
controller->GetParent()->GetName().ReadPtr(), controller->GetName().ReadPtr());
}
void SCA_ISensor::UnlinkAllControllers()
{
std::vector<class SCA_IController*>::iterator contit;
for (contit = m_linkedcontrollers.begin();!(contit==m_linkedcontrollers.end());++contit)
{
(*contit)->UnlinkSensor(this);
}
m_linkedcontrollers.clear();
}
void SCA_ISensor::UnregisterToManager()
{
m_eventmgr->RemoveSensor(this);
m_links = 0;
}
void SCA_ISensor::ActivateControllers(class SCA_LogicManager* logicmgr)
{
for(vector<SCA_IController*>::const_iterator c= m_linkedcontrollers.begin();
c!=m_linkedcontrollers.end();++c)
{
SCA_IController* contr = *c;
if (contr->IsActive())
logicmgr->AddTriggeredController(contr, this);
}
}
void SCA_ISensor::Activate(class SCA_LogicManager* logicmgr)
{
// calculate if a __triggering__ is wanted
// don't evaluate a sensor that is not connected to any controller
if (m_links && !m_suspended) {
bool result = this->Evaluate();
// store the state for the rest of the logic system
m_prev_state = m_state;
m_state = this->IsPositiveTrigger();
if (result) {
// the sensor triggered this frame
if (m_state || !m_tap) {
ActivateControllers(logicmgr);
// reset these counters so that pulse are synchronized with transition
m_pos_ticks = 0;
m_neg_ticks = 0;
} else
{
result = false;
}
} else
{
/* First, the pulsing behaviour, if pulse mode is
* active. It seems something goes wrong if pulse mode is
* not set :( */
if (m_pos_pulsemode) {
m_pos_ticks++;
if (m_pos_ticks > m_pulse_frequency) {
if ( m_state )
{
ActivateControllers(logicmgr);
result = true;
}
m_pos_ticks = 0;
}
}
// negative pulse doesn't make sense in tap mode, skip
if (m_neg_pulsemode && !m_tap)
{
m_neg_ticks++;
if (m_neg_ticks > m_pulse_frequency) {
if (!m_state )
{
ActivateControllers(logicmgr);
result = true;
}
m_neg_ticks = 0;
}
}
}
if (m_tap)
{
// in tap mode: we send always a negative pulse immediately after a positive pulse
if (!result)
{
// the sensor did not trigger on this frame
if (m_prev_state)
{
// but it triggered on previous frame => send a negative pulse
ActivateControllers(logicmgr);
result = true;
}
// in any case, absence of trigger means sensor off
m_state = false;
}
}
if (!result && m_level)
{
// This level sensor is connected to at least one controller that was just made
// active but it did not generate an event yet, do it now to those controllers only
for(vector<SCA_IController*>::const_iterator c= m_linkedcontrollers.begin();
c!=m_linkedcontrollers.end();++c)
{
SCA_IController* contr = *c;
if (contr->IsJustActivated())
logicmgr->AddTriggeredController(contr, this);
}
}
}
}
#ifdef WITH_PYTHON
/* ----------------------------------------------- */
/* Python Functions */
/* ----------------------------------------------- */
KX_PYMETHODDEF_DOC_NOARGS(SCA_ISensor, reset,
"reset()\n"
"\tReset sensor internal state, effect depends on the type of sensor and settings.\n"
"\tThe sensor is put in its initial state as if it was just activated.\n")
{
Init();
m_prev_state = false;
Py_RETURN_NONE;
}
/* ----------------------------------------------- */
/* Python Integration Hooks */
/* ----------------------------------------------- */
PyTypeObject SCA_ISensor::Type = {
PyVarObject_HEAD_INIT(NULL, 0)
"SCA_ISensor",
sizeof(PyObjectPlus_Proxy),
0,
py_base_dealloc,
0,
0,
0,
0,
py_base_repr,
0,0,0,0,0,0,0,0,0,
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
0,0,0,0,0,0,0,
Methods,
0,
0,
&SCA_ILogicBrick::Type,
0,0,0,0,0,0,
py_base_new
};
PyMethodDef SCA_ISensor::Methods[] = {
KX_PYMETHODTABLE_NOARGS(SCA_ISensor, reset),
{NULL,NULL} //Sentinel
};
PyAttributeDef SCA_ISensor::Attributes[] = {
KX_PYATTRIBUTE_BOOL_RW("usePosPulseMode",SCA_ISensor,m_pos_pulsemode),
KX_PYATTRIBUTE_BOOL_RW("useNegPulseMode",SCA_ISensor,m_neg_pulsemode),
KX_PYATTRIBUTE_INT_RW("frequency",0,100000,true,SCA_ISensor,m_pulse_frequency),
KX_PYATTRIBUTE_BOOL_RW("invert",SCA_ISensor,m_invert),
KX_PYATTRIBUTE_BOOL_RW_CHECK("level",SCA_ISensor,m_level,pyattr_check_level),
KX_PYATTRIBUTE_BOOL_RW_CHECK("tap",SCA_ISensor,m_tap,pyattr_check_tap),
KX_PYATTRIBUTE_RO_FUNCTION("triggered", SCA_ISensor, pyattr_get_triggered),
KX_PYATTRIBUTE_RO_FUNCTION("positive", SCA_ISensor, pyattr_get_positive),
KX_PYATTRIBUTE_RO_FUNCTION("status", SCA_ISensor, pyattr_get_status),
KX_PYATTRIBUTE_RO_FUNCTION("pos_ticks", SCA_ISensor, pyattr_get_posTicks),
KX_PYATTRIBUTE_RO_FUNCTION("neg_ticks", SCA_ISensor, pyattr_get_negTicks),
{ NULL } //Sentinel
};
PyObject* SCA_ISensor::pyattr_get_triggered(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
{
SCA_ISensor* self= static_cast<SCA_ISensor*>(self_v);
int retval = 0;
if (SCA_PythonController::m_sCurrentController)
retval = SCA_PythonController::m_sCurrentController->IsTriggered(self);
return PyLong_FromSsize_t(retval);
}
PyObject* SCA_ISensor::pyattr_get_positive(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
{
SCA_ISensor* self= static_cast<SCA_ISensor*>(self_v);
return PyLong_FromSsize_t(self->GetState());
}
PyObject* SCA_ISensor::pyattr_get_status(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
{
SCA_ISensor* self= static_cast<SCA_ISensor*>(self_v);
int status = 0;
if (self->GetState())
{
if (self->GetState() == self->GetPrevState())
{
status = 2;
}
else
{
status = 1;
}
}
else if (self->GetState() != self->GetPrevState())
{
status = 3;
}
return PyLong_FromSsize_t(status);
}
PyObject* SCA_ISensor::pyattr_get_posTicks(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
{
SCA_ISensor* self= static_cast<SCA_ISensor*>(self_v);
return PyLong_FromLong(self->GetPosTicks());
}
PyObject* SCA_ISensor::pyattr_get_negTicks(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
{
SCA_ISensor* self= static_cast<SCA_ISensor*>(self_v);
return PyLong_FromLong(self->GetNegTicks());
}
int SCA_ISensor::pyattr_check_level(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
{
SCA_ISensor* self= static_cast<SCA_ISensor*>(self_v);
if (self->m_level)
self->m_tap = false;
return 0;
}
int SCA_ISensor::pyattr_check_tap(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
{
SCA_ISensor* self= static_cast<SCA_ISensor*>(self_v);
if (self->m_tap)
self->m_level = false;
return 0;
}
#endif // WITH_PYTHON
/* eof */