70d239ef7d
General ======= - Removal of Damp option in motion actuator (replaced by Servo control motion). - No PyDoc at present, will be added soon. Generalization of the Lvl option ================================ A sensor with the Lvl option selected will always produce an event at the start of the game or when entering a state or at object creation. The event will be positive or negative depending of the sensor condition. A negative pulse makes sense when used with a NAND controller: it will be converted into an actuator activation. Servo control motion ==================== A new variant of the motion actuator allows to control speed with force. The control if of type "PID" (Propotional, Integral, Derivate): the force is automatically adapted to achieve the target speed. All the parameters of the servo controller are configurable. The result is a great variety of motion style: anysotropic friction, flying, sliding, pseudo Dloc... This actuator should be used in preference to Dloc and LinV as it produces more fluid movements and avoids the collision problem with Dloc. LinV : target speed as (X,Y,Z) vector in local or world coordinates (mostly useful in local coordinates). Limit: the force can be limited along each axis (in the same coordinates of LinV). No limitation means that the force will grow as large as necessary to achieve the target speed along that axis. Set a max value to limit the accelaration along an axis (slow start) and set a min value (negative) to limit the brake force. P: Proportional coefficient of servo controller, don't set directly unless you know what you're doing. I: Integral coefficient of servo controller. Use low value (<0.1) for slow reaction (sliding), high values (>0.5) for hard control. The P coefficient will be automatically set to 60 times the I coefficient (a reasonable value). D: Derivate coefficient. Leave to 0 unless you know what you're doing. High values create instability. Notes: - This actuator works perfectly in zero friction environment: the PID controller will simulate friction by applying force as needed. - This actuator is compatible with simple Drot motion actuator but not with LinV and Dloc motion. - (0,0,0) is a valid target speed. - All parameters are accessible through Python. Distance constraint actuator ============================ A new variant of the constraint actuator allows to set the distance and orientation relative to a surface. The controller uses a ray to detect the surface (or any object) and adapt the distance and orientation parallel to the surface. Damp: Time constant (in nb of frames) of distance and orientation control. Dist: Select to enable distance control and set target distance. The object will be position at the given distance of surface along the ray direction. Direction: chose a local axis as the ray direction. Range: length of ray. Objecgt within this distance will be detected. N : Select to enable orientation control. The actuator will change the orientation and the location of the object so that it is parallel to the surface at the vertical of the point of contact of the ray. M/P : Select to enable material detection. Default is property detection. Property/Material: name of property/material that the target of ray must have to be detected. If not set, property/ material filter is disabled and any collisioning object within range will be detected. PER : Select to enable persistent operation. Normally the actuator disables itself automatically if the ray does not reach a valid target. time : Maximum activation time of actuator. 0 : unlimited. >0: number of frames before automatic deactivation. rotDamp: Time constant (in nb of frame) of orientation control. 0 : use Damp parameter. >0: use a different time constant for orientation. Notes: - If neither N nor Dist options are set, the actuator does not change the position and orientation of the object; it works as a ray sensor. - The ray has no "X-ray" capability: if the first object hit does not have the required property/material, it returns no hit and the actuator disables itself unless PER option is enabled. - This actuator changes the position and orientation but not the speed of the object. This has an important implication in a gravity environment: the gravity will cause the speed to increase although the object seems to stay still (it is repositioned at each frame). The gravity must be compensated in one way or another. the new servo control motion actuator is the simplest way: set the target speed along the ray axis to 0 and the servo control will automatically compensate the gravity. - This actuator changes the orientation of the object and will conflict with Drot motion unless it is placed BEFORE the Drot motion actuator (the order of actuator is important) - All parameters are accessible through Python. Orientation constraint ====================== A new variant of the constraint actuator allows to align an object axis along a global direction. Damp : Time constant (in nb of frames) of orientation control. X,Y,Z: Global coordinates of reference direction. time : Maximum activation time of actuator. 0 : unlimited. >0: number of frames before automatic deactivation. Notes: - (X,Y,Z) = (0,0,0) is not a valid direction - This actuator changes the orientation of the object and will conflict with Drot motion unless it is placed BEFORE the Drot motion actuator (the order of actuator is important). - This actuator doesn't change the location and speed. It is compatible with gravity. - All parameters are accessible through Python. Actuator sensor =============== This sensor detects the activation and deactivation of actuators of the same object. The sensor generates a positive pulse when the corresponding sensor is activated and a negative pulse when it is deactivated (the contrary if the Inv option is selected). This is mostly useful to chain actions and to detect the loss of contact of the distance motion actuator. Notes: - Actuators are disabled at the start of the game; if you want to detect the On-Off transition of an actuator after it has been activated at least once, unselect the Lvl and Inv options and use a NAND controller. - Some actuators deactivates themselves immediately after being activated. The sensor detects this situation as an On-Off transition. - The actuator name can be set through Python.
152 lines
4.2 KiB
C++
152 lines
4.2 KiB
C++
/**
|
|
* $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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, 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 *****
|
|
* Interface Class for all logic Sensors. Implements
|
|
* pulsemode and pulsefrequency, and event suppression.
|
|
*/
|
|
|
|
#ifndef __SCA_ISENSOR
|
|
#define __SCA_ISENSOR
|
|
|
|
#include "SCA_ILogicBrick.h"
|
|
|
|
/**
|
|
* Interface Class for all logic Sensors. Implements
|
|
* pulsemode,pulsefrequency */
|
|
class SCA_ISensor : public SCA_ILogicBrick
|
|
{
|
|
Py_Header;
|
|
class SCA_EventManager* m_eventmgr;
|
|
bool m_triggered;
|
|
|
|
/** Pulse positive pulses? */
|
|
bool m_pos_pulsemode;
|
|
|
|
/** Pulse negative pulses? */
|
|
bool m_neg_pulsemode;
|
|
|
|
/** Repeat frequency in pulse mode. */
|
|
int m_pulse_frequency;
|
|
|
|
/** Number of ticks since the last positive pulse. */
|
|
int m_pos_ticks;
|
|
|
|
/** Number of ticks since the last negative pulse. */
|
|
int m_neg_ticks;
|
|
|
|
/** invert the output signal*/
|
|
bool m_invert;
|
|
|
|
/** detect level instead of edge*/
|
|
bool m_level;
|
|
|
|
/** sensor has been reset */
|
|
bool m_reset;
|
|
|
|
/** Sensor must ignore updates? */
|
|
bool m_suspended;
|
|
|
|
/** number of connections to controller */
|
|
int m_links;
|
|
|
|
/** Pass the activation on to the logic manager.*/
|
|
void SignalActivation(class SCA_LogicManager* logicmgr);
|
|
|
|
public:
|
|
SCA_ISensor(SCA_IObject* gameobj,
|
|
class SCA_EventManager* eventmgr,
|
|
PyTypeObject* T );;
|
|
~SCA_ISensor();
|
|
virtual void ReParent(SCA_IObject* parent);
|
|
|
|
/** Because we want sensors to share some behaviour, the Activate has */
|
|
/* an implementation on this level. It requires an evaluate on the lower */
|
|
/* level of individual sensors. Mapping the old activate()s is easy. */
|
|
/* The IsPosTrig() also has to change, to keep things consistent. */
|
|
void Activate(class SCA_LogicManager* logicmgr,CValue* event);
|
|
virtual bool Evaluate(CValue* event) = 0;
|
|
virtual bool IsPositiveTrigger();
|
|
virtual void Init();
|
|
|
|
virtual PyObject* _getattr(const STR_String& attr);
|
|
virtual CValue* GetReplica()=0;
|
|
|
|
/** Set parameters for the pulsing behaviour.
|
|
* @param posmode Trigger positive pulses?
|
|
* @param negmode Trigger negative pulses?
|
|
* @param freq Frequency to use when doing pulsing.
|
|
*/
|
|
void SetPulseMode(bool posmode,
|
|
bool negmode,
|
|
int freq);
|
|
|
|
/** Release sensor
|
|
* For property sensor, it is used to release the pre-calculated expression
|
|
* so that self references are removed before the sensor itself is released
|
|
*/
|
|
virtual void Delete() { Release(); }
|
|
/** Set inversion of pulses on or off. */
|
|
void SetInvert(bool inv);
|
|
/** set the level detection on or off */
|
|
void SetLevel(bool lvl);
|
|
|
|
void RegisterToManager();
|
|
virtual float GetNumber();
|
|
|
|
/** Stop sensing for a while. */
|
|
void Suspend();
|
|
|
|
/** Is this sensor switched off? */
|
|
bool IsSuspended();
|
|
|
|
/** Resume sensing. */
|
|
void Resume();
|
|
|
|
void IncLink()
|
|
{ m_links++; }
|
|
void DecLink();
|
|
bool IsNoLink() const
|
|
{ return !m_links; }
|
|
|
|
/* Python functions: */
|
|
KX_PYMETHOD_DOC(SCA_ISensor,IsPositive);
|
|
KX_PYMETHOD_DOC(SCA_ISensor,GetUsePosPulseMode);
|
|
KX_PYMETHOD_DOC(SCA_ISensor,SetUsePosPulseMode);
|
|
KX_PYMETHOD_DOC(SCA_ISensor,GetFrequency);
|
|
KX_PYMETHOD_DOC(SCA_ISensor,SetFrequency);
|
|
KX_PYMETHOD_DOC(SCA_ISensor,GetUseNegPulseMode);
|
|
KX_PYMETHOD_DOC(SCA_ISensor,SetUseNegPulseMode);
|
|
KX_PYMETHOD_DOC(SCA_ISensor,GetInvert);
|
|
KX_PYMETHOD_DOC(SCA_ISensor,SetInvert);
|
|
KX_PYMETHOD_DOC(SCA_ISensor,GetLevel);
|
|
KX_PYMETHOD_DOC(SCA_ISensor,SetLevel);
|
|
|
|
};
|
|
|
|
#endif //__SCA_ISENSOR
|
|
|