static void GetConfiguration(SFlowNodeConfig& config)
  {
    static const SInputPortConfig inputs[] = {
      InputPortConfig<bool>("Glow_Active", false),
      InputPortConfig<float>("Glow_Scale", 0.5f),
      {0}
    };
    static const SOutputPortConfig outputs[] = {
      {0}
    };
		config.nFlags |= EFLN_TARGET_ENTITY;
    config.pInputPorts = inputs;
    config.pOutputPorts = outputs;
    config.sDescription = _HELP("Glow");
  }

	void GetConfiguration( SFlowNodeConfig& config )
	{
		static const SInputPortConfig inputs[] = 
		{ 
			InputPortConfig_Void( "Enable",  _HELP("Enable Listener")),
			InputPortConfig_Void( "Disable", _HELP("Disable Listener")),
			InputPortConfig<EntityId>( "WeaponId", _HELP("Listener will be set on this weapon if active")),
			InputPortConfig<string>( "WeaponClass", _HELP("Use this if you want to specify the players weapon by name"), 0, _UICONFIG("enum_global:weapon")),
			InputPortConfig<int> ( "Ammo", _HELP("Number of times the listener can be triggered. 0 means infinite"), _HELP("ShootCount") ),
			{0}
		};
		static const SOutputPortConfig outputs[] = 
		{
			OutputPortConfig_Void("OnShoot", _HELP("OnShoot")),
			OutputPortConfig<int>("AmmoLeft", _HELP("Shoots left"), _HELP("ShootsLeft")),
			OutputPortConfig_Void("OnMelee", _HELP("Triggered on melee attack")),
			OutputPortConfig<string>("OnDropped", _HELP("Triggered when weapon was dropped.")),
			{0}
		};  
		config.sDescription = "Listens on [WeaponId] (or players [WeaponClass], or as fallback current players weapon) and triggers OnShoot when shot.";
		config.pInputPorts = inputs;
		config.pOutputPorts = outputs;
		config.SetCategory(EFLN_APPROVED);
	}

	virtual void GetConfiguration(SFlowNodeConfig& config)
	{
		static const SInputPortConfig inputs[] = {
			InputPortConfig_Void  ("Enable"       , _HELP("")),
			InputPortConfig_Void  ("Disable"      , _HELP("")),
			InputPortConfig<float>("MinDamping"   ,  50.f, _HELP("Minimum Damping of walk speed")),
			InputPortConfig<float>("MaxDamping"   ,  75.f, _HELP("Maximum Damping of walk speed")),
			InputPortConfig<float>("PeriodicTime" ,   4.f, _HELP("Time in seconds for one stumble")),
			InputPortConfig<float>("StrengthX"    , 100.f, _HELP("Stumble strength in X direction")),
      InputPortConfig<float>("StrengthY"    , 100.f, _HELP("Stumble strength in Y direction") ),
      InputPortConfig<float>("Randomness"   ,   0.f, _HELP("Value in [0,2]. Higher value means more variation.") ),
			{0}
		};
		static const SOutputPortConfig outputs[] = {
			{0}
		};
		config.pInputPorts = inputs;
		config.pOutputPorts = outputs;
		config.sDescription = _HELP("Activates the player beeing like drunken.");
		config.SetCategory(EFLN_APPROVED);
	}

	virtual void GetConfiguration(SFlowNodeConfig& config)
	{
		static const SInputPortConfig inputs[] = {
			InputPortConfig_Void  ("Trigger", _HELP("Trigger")),
			InputPortConfig<Vec3> ("ViewLimitDir", _HELP("ViewLimitDir")),
			InputPortConfig<bool> ("InLocalSpace", true, _HELP("ViewLimit Vector is in Local Space or World Space")),
			InputPortConfig<float>("ViewLimitYaw", _HELP("ViewLimitYaw (0.0=FreeLook, 0.001=Lock)")),
			InputPortConfig<float>("ViewLimitPitch", _HELP("ViewLimitPitch (0.0=Freelook, 0.001=Lock)")),
			InputPortConfig<bool> ("LockPlayer", false, _HELP("Lock the player's position")),
			InputPortConfig<int>( "TryStance", -1, _HELP("Try to set Stance on Locking [works only if Player was linked beforehand]"), 0, _UICONFIG("enum_int:<ignore>=-1,Stand=0,Crouch=1,Prone=2,Relaxed=3,Stealth=4,Swim=5,ZeroG=6")),
			{0}
		};
		static const SOutputPortConfig outputs[] = {
			OutputPortConfig_Void ("Done", _HELP("Trigger for Chaining")),
			{0}
		};
		config.pInputPorts = inputs;
		config.pOutputPorts = outputs;
		config.sDescription = _HELP("Staging of the Player - ViewLimits and Position Lock");
		config.SetCategory(EFLN_APPROVED);
	}

	virtual void GetConfiguration( SFlowNodeConfig &config )
	{
		static const SInputPortConfig in_config[] = {
			InputPortConfig<bool>("in"),
			{0}
		};
		static const SOutputPortConfig out_config[] = {
			OutputPortConfig<bool>("out"),
			{0}
		};
		config.sDescription = _HELP( "Only send [in] value into the [out] when it is different from the previous value" );
		config.pInputPorts = in_config;
		config.pOutputPorts = out_config;
		config.nFlags |= EFLN_AISEQUENCE_SUPPORTED;
		config.SetCategory(EFLN_APPROVED);
	}

	virtual void GetConfiguration( SFlowNodeConfig &config )
	{
		static const SInputPortConfig in_config[] =
		{
			{0}
		};
		static const SOutputPortConfig out_config[] =
		{
			OutputPortConfig< EntityId >( "ObjectId", "Entity ID of the object on which the action is executing" ),
			{0}
		};
		config.pInputPorts = 0; // in_config;
		config.pOutputPorts = out_config;
		config.sDescription = _HELP( "This node is the succeed path of the Custom Action" );
		config.SetCategory(EFLN_APPROVED);
	}

	virtual void GetConfiguration(SFlowNodeConfig& config)
	{
		static const SInputPortConfig in_config[] = 
		{
			InputPortConfig<SFlowSystemVoid>("Draw", _HELP("Trigger to draw the Line")),
			InputPortConfig<Vec3>("Pos1", _HELP("Start position of Line")),
			InputPortConfig<Vec3>("Pos2", _HELP("End position of Line")),
			InputPortConfig<Vec3>("Dir", _HELP("Direction of Line")),
			InputPortConfig<float>("Length", _HELP("Length of Line")),
			InputPortConfig<Vec3>("Color", _HELP("Color of the Line")),
			InputPortConfig<float>("Time", _HELP("Time Line should be drawn for")),
			{0}
		};

		config.sDescription = _HELP("Draws a line for debugging purposes. Use either Pos1, Dir and Length or Pos1 and Pos2");
		config.pInputPorts = in_config;
		config.SetCategory(EFLN_DEBUG);
	}

	void GetConfiguration( SFlowNodeConfig &config )
	{
		static const SInputPortConfig in_config[] =
		{
			InputPortConfig_Void("LoadLastCheckpoint", _HELP("Load the last checkpoint which was saved during the current session.")),
			InputPortConfig<EntityId>("SaveLoadEntity1", _HELP("Save and load this entity when a checkpoint is triggered.")),
			InputPortConfig<EntityId>("SaveLoadEntity2", _HELP("Save and load this entity when a checkpoint is triggered.")),
			InputPortConfig<EntityId>("SaveLoadEntity3", _HELP("Save and load this entity when a checkpoint is triggered.")),
			InputPortConfig<EntityId>("SaveLoadEntity4", _HELP("Save and load this entity when a checkpoint is triggered.")),
			InputPortConfig<EntityId>("SaveLoadEntity5", _HELP("Save and load this entity when a checkpoint is triggered.")),
			{0}
		};
		static const SOutputPortConfig out_config[] = {
			OutputPortConfig<int> ("SaveDone", _HELP("Triggered when saved")),
			OutputPortConfig<int> ("LoadDone", _HELP("Triggered when loaded")),
			{0}
		};
		config.sDescription = _HELP("Checkpoint System Output");
		config.pInputPorts  = in_config;
		config.pOutputPorts = out_config;
		config.SetCategory(EFLN_APPROVED);
	}

void HoldPositionAssignmentFlowNode::GetConfiguration( SFlowNodeConfig& config )
{
	static const SInputPortConfig inputPortConfig[] = 
	{
		InputPortConfig_Void("Set"),
		InputPortConfig<Vec3>("Position"),
		InputPortConfig<int>("Radius", 3),
		InputPortConfig<Vec3>("Direction"),
		InputPortConfig<bool>("UseCover", true),
		{0}
	};

	config.pInputPorts = inputPortConfig;
	config.sDescription = _HELP("Assigns the entity/wave to stay in a specific position. Usable by: Human, Grunt, Heavy");
	config.nFlags |= EFLN_TARGET_ENTITY;
	config.SetCategory(EFLN_APPROVED);
}

	virtual void GetConfiguration( SFlowNodeConfig &config )
	{
		static const SInputPortConfig  in_config[] = {
			InputPortConfig_Void( "Get", "Returns the Pos/Dir of the camera" ),
			{0}
		};
		static const SOutputPortConfig out_config[] = {
			OutputPortConfig<Vec3>( "Pos", "Position of the camera" ),
			OutputPortConfig<Vec3>( "Dir", "ViewDir of the camera" ),
			{0}
		};

		config.pInputPorts  = in_config;
		config.pOutputPorts = out_config;
		config.sDescription = _HELP( "Returns the transform for the playercamera" );
		config.SetCategory(EFLN_APPROVED);
	}

	virtual void GetConfiguration(SFlowNodeConfig& config)
	{
		static const SInputPortConfig inputs[] = {
			InputPortConfig_AnyType("Capture", _HELP("Begins Capturing a Clip")),
			InputPortConfig<float> ("DurationBefore", 20.0f, _HELP("Record that many seconds before the Capture input is triggered")),
			InputPortConfig<float> ("DurationAftere", 10.0f, _HELP("Record that many seconds after the Capture input is triggered")),
			InputPortConfig<string>("ClipName", _HELP("In XboxOne: MagicMoment ID used to look up the description string entered throuhg the Xbox Developr Portal")),
			InputPortConfig<string>("LocalizedClipName", _HELP("In XboxOne: Clip's Name shown during the Toast pop up")),
			InputPortConfig<string>("Metadata", _HELP("Optional. Use it for instance to tag clips")),
			{0}
		};

		static const SOutputPortConfig outputs[] = {
			OutputPortConfig_Void("BeganCapture", _HELP("The clip's capture has begun")),
			OutputPortConfig_Void("Error", _HELP("An error happened during the capturing process")),
			{0}
		};

		config.pInputPorts = inputs;
		config.pOutputPorts = outputs;
		config.sDescription = _HELP("Allows capturing clips while the game is running and (in XboxOne) save them locally or in the cloud");
		config.SetCategory(EFLN_APPROVED);
	}

	void GetConfiguration( SFlowNodeConfig& config )
	{
		static const SInputPortConfig in_config[] = {
			InputPortConfig_Void("Get", _HELP("Get the current Latitude/Longitude")),
			InputPortConfig_Void("Set", _HELP("Set the Latitude/Longitude")),
			InputPortConfig<float>("Latitude",  0.0f, _HELP("Latitude to be set")),
			InputPortConfig<float>("Longitude", 35.0f, _HELP("Longitude to be set")),
			InputPortConfig<bool>("ForceUpdate", false, _HELP("Force Immediate Update of Sky if true. USE ONLY IN SPECIAL CASES, is heavy on performance!") ),
			{0}
		};
		static const SOutputPortConfig out_config[] = {
			OutputPortConfig<float>("Latitude", _HELP("Current Latitude")),
			OutputPortConfig<float>("Longitude", _HELP("Current Longitude")),
			{0}
		};
		config.pInputPorts = in_config;
		config.pOutputPorts = out_config;
		config.sDescription = _HELP("Set the 3DEngine's Moon Direction");
		config.SetCategory(EFLN_APPROVED);
	}

	virtual void GetConfiguration( SFlowNodeConfig& config )
	{
		static const SInputPortConfig in_config[] = {
			InputPortConfig_Void( "activate", _HELP("Trigger the impulse") ),
			InputPortConfig<Vec3>( "impulse", Vec3(0,0,0), _HELP("Impulse vector") ),
			InputPortConfig<Vec3>( "angImpulse", Vec3(0,0,0), _HELP("The angular impulse") ),
			InputPortConfig<Vec3>( "Point", Vec3(0,0,0), _HELP("Point of application (optional)") ),
			InputPortConfig<int>( "partIndex", 0, _HELP("Index of the part that will receive the impulse (optional, 1-based, 0=unspecified)") ),
			InputPortConfig<int> ( "CoordSys", 1, _HELP("Defines which coordinate system is used for the inputs values"), _HELP("CoordSys"), _UICONFIG("enum_int:Parent=0,World=1,Local=2") ),
			{0}
		};
		config.nFlags |= EFLN_TARGET_ENTITY|EFLN_AISEQUENCE_SUPPORTED;
		config.pInputPorts = in_config;
		config.pOutputPorts = 0;
		config.sDescription = _HELP("Applies an impulse on an entity");
		config.SetCategory(EFLN_APPROVED);
	}

	virtual void GetConfiguration(SFlowNodeConfig& config)
	{
		static const SInputPortConfig inputs[] = {
			InputPortConfig_Void  ("Trigger", _HELP("Trigger to get current NanoSuit values")),
			{0}
		};
		static const SOutputPortConfig outputs[] = {
			OutputPortConfig_Void  ("Cloak", _HELP("Triggered on Cloak Mode")),
			OutputPortConfig_Void  ("Strength", _HELP("Triggered on Strength Mode")),
			OutputPortConfig_Void  ("Defense", _HELP("Triggered on Defense Mode")),
			OutputPortConfig_Void  ("Speed", _HELP("Triggered on Speed Mode")),
			OutputPortConfig<float>("Energy", _HELP("Current Energy")),
			OutputPortConfig<int>  ("CloakLevel", _HELP("Current cloak level [1-3]")),
			{0}
		};
		config.nFlags |= EFLN_TARGET_ENTITY;
		config.pInputPorts = inputs;
		config.pOutputPorts = outputs;
		config.sDescription = _HELP("NanoSuitGet Node");
		config.SetCategory(EFLN_WIP);
	}

	virtual void GetConfiguration( SFlowNodeConfig& config )
	{
		// declare input ports
		static const SOutputPortConfig out_ports[] = 
		{
			OutputPortConfig_Void("StateChanged", "Fires when a mission's state is changed"),
			OutputPortConfig<string>("Name", "Mission name specified in Objectives.xml"),
			OutputPortConfig<string>("Description", "Mission description specified in Objectives.xml"),
			OutputPortConfig<int>("Status", "0=deactivated, 1=completed, 2=failed, 3=activated"),
			OutputPortConfig<bool>("IsSecondary", "0=primary, 1=secondary"),
			{0}
		};
		
		// we set pointers in "config" here to specify which input and output ports the node contains
		config.sDescription = _HELP("Fires whenever a mission's state has been changed");
		config.pInputPorts = 0;
		config.pOutputPorts = out_ports;
		config.SetCategory(EFLN_APPROVED);
	}

    virtual void GetConfiguration( SFlowNodeConfig &config )
    {
        static const SInputPortConfig in_config[] = {
            InputPortConfig_AnyType( "start",_HELP("Triggers the start of the counter. If it is counting already, it resets it. Also, wathever was input here, will be output as 'finished' when the counting is done") ),
            InputPortConfig_AnyType( "stop",_HELP("Stops counting") ),
            InputPortConfig_AnyType( "continue",_HELP("Continues counting") ),
            InputPortConfig<float>( "period", 1.f, _HELP("Tick period in seconds") ),
            InputPortConfig<int>( "limit",_HELP("How many ticks the counter will do before finish") ),
            {0}
        };
        static const SOutputPortConfig out_config[] = {
            OutputPortConfig_AnyType("finished", _HELP("triggered when the counting is done. The value will be the same than the 'start' input")),
            OutputPortConfig<int>("count", _HELP("outputs the tick counter value")),
            {0}
        };

        config.sDescription = _HELP( "counts a number of ticks specified by 'limit', and then outputs 'finished' with the value the input 'start' had when it was triggered" );
        config.pInputPorts = in_config;
        config.pOutputPorts = out_config;
        config.SetCategory(EFLN_APPROVED);
    }

    virtual void GetConfiguration( SFlowNodeConfig& config )
    {
        static const SInputPortConfig inPorts[] =
        {
            InputPortConfig_Void( "Enable" ),
            InputPortConfig_Void( "Disable" ),
            { 0 }
        };

        static const SOutputPortConfig outPorts[] =
        {
            { 0 }
        };

        config.pInputPorts = inPorts;
        config.pOutputPorts = outPorts;
        config.nFlags |= EFLN_TARGET_ENTITY;
        config.sDescription = _HELP( "When enabled, combat mode changes the behaviour from trying to strictly follow paths to trying to find the best position in the path from where to engage the target. The default state is disabled." );
        config.SetCategory( EFLN_APPROVED );
    }

    virtual void GetConfiguration(SFlowNodeConfig& config)
    {
        static const SInputPortConfig inputs[] = {
            InputPortConfig_Void("Cast", _HELP("Cast test ray")),
            InputPortConfig<Vec3>("Pos", _HELP("Ray pos")),
            InputPortConfig<Vec3>("Dir", _HELP("Ray Dir")),
            InputPortConfig<string>("FunctionName", _HELP("This function will be called in ActionScript (signature: myFunc = function(int, int))")),
            InputPortConfig<EntityId>("SkipEntity", _HELP("Optional: Entity to skip")),
            {0}
        };

        static const SOutputPortConfig outputs[] = {
            OutputPortConfig_Void     ("Success",  _HELP("Triggers if succeeded")),
            OutputPortConfig_Void     ("Failed",  _HELP("Triggers if something went wrong(no hit or wrong entity)")),
            {0}
        };

        config.pInputPorts = inputs;
        config.pOutputPorts = outputs;
        config.sDescription = _HELP("Casts a ray, finds the hitposition in flash space and calls a function");
        config.SetCategory(EFLN_ADVANCED);
    }

	virtual void GetConfiguration( SFlowNodeConfig &config )
	{
		static const SInputPortConfig  in_config[] = {
			InputPortConfig<Vec3>( "Speed",_HELP("Speed (degrees/sec)")),
			InputPortConfig<bool>( "Paused",_HELP("Pause the motion when true")),
			InputPortConfig<int> ( "Ref", 0, _HELP("RotationAxis in World or Local Space"), _HELP("CoordSys"), _UICONFIG("enum_int:World=0,Local=1")),
			{0}
		};
		static const SOutputPortConfig out_config[] = {
			OutputPortConfig<Vec3>("Current",_HELP("Current Rotation in Degrees")),
			OutputPortConfig<Vec3>("CurrentRad",_HELP("Current Rotation in Radian")),
			{0}
		};
		config.sDescription = _HELP( "Rotate at a defined speed" );
		config.nFlags      |= EFLN_TARGET_ENTITY | EFLN_AISEQUENCE_SUPPORTED;
		config.pInputPorts  = in_config;
		config.pOutputPorts = out_config;
		config.SetCategory(EFLN_APPROVED);
	}

void CFlowDelayNode::GetConfiguration( SFlowNodeConfig& config )
{
	static const SInputPortConfig inputs[] = {
		InputPortConfig_AnyType("in",_HELP("Value to be passed after [Delay] time"), _HELP("In")),
		InputPortConfig<float>("delay", 1.0f,_HELP("Delay time in seconds"), _HELP("Delay")),
		InputPortConfig<bool>("resetOnInput", false,_HELP("When true, the node is reseted with each input (delay counter is reseted to 0, and previous inputs are forgotten)") ),
		{0}
	};

	static const SOutputPortConfig outputs[] = {
		OutputPortConfig_AnyType("out", _HELP("Out")),
		{0}
	};

	config.sDescription = _HELP("This node will delay passing the signal from [In] to [Out] for the specified number of seconds in [Delay]");
	config.pInputPorts = inputs;
	config.pOutputPorts = outputs;
	config.SetCategory(EFLN_APPROVED);
}