コード例 #1
0
  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");
  }
コード例 #2
0
ファイル: FlowWeaponNodes.cpp プロジェクト: aronarts/FireNET
	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);
	}
コード例 #3
0
	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);
	}
コード例 #4
0
	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);
	}
コード例 #5
0
  static void GetConfiguration(SFlowNodeConfig& config)
  {
    static const SInputPortConfig inputs[] = {
      InputPortConfig<bool>("ScreenFrost_Active", false),
      InputPortConfig<float>("ScreenFrost_Amount", 0.0f),
      InputPortConfig<float>("ScreenFrost_CenterAmount", 1.0f),
      {0}
    };
    static const SOutputPortConfig outputs[] = {
      {0}
    };
		config.nFlags |= EFLN_TARGET_ENTITY;
    config.pInputPorts = inputs;
    config.pOutputPorts = outputs;
    config.sDescription = _HELP("ScreenFrost");
  }
コード例 #6
0
  static void GetConfiguration(SFlowNodeConfig& config)
  {
    static const SInputPortConfig inputs[] = {
      InputPortConfig<bool> ("SunShafts_Active", false),
      InputPortConfig<int>  ("SunShafts_Type", 0),
      InputPortConfig<float>("SunShafts_Amount", 0.25),
      {0}
    };
    static const SOutputPortConfig outputs[] = {
      {0}
    };
		config.nFlags |= EFLN_TARGET_ENTITY;
    config.pInputPorts = inputs;
    config.pOutputPorts = outputs;
    config.sDescription = _HELP("SunShafts");
  }
コード例 #7
0
ファイル: FlowLogicNodes.cpp プロジェクト: aronarts/FireNET
	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);
	}
	virtual void GetConfiguration(SFlowNodeConfig& config)
	{
		static const SInputPortConfig in_config[] = 
		{
			InputPortConfig<SFlowSystemVoid>("Draw", _HELP("Trigger to draw the Cone")),
			InputPortConfig<Vec3>("Pos", _HELP("Centre position of Cone")),
			InputPortConfig<Vec3>("Dir", _HELP("Direction of Cone")),
			InputPortConfig<float>("Radius", _HELP("Radius of Cone base")),
			InputPortConfig<float>("Height", _HELP("Height of Cone")),
			InputPortConfig<Vec3>("Color", _HELP("Color of the Cone")),
			InputPortConfig<float>("Time", _HELP("Time Cone should be drawn for")),
			{0}
		};

		config.sDescription = _HELP("Draws a cone for debugging purposes");
		config.pInputPorts = in_config;
		config.SetCategory(EFLN_DEBUG);
	}
コード例 #11
0
ファイル: FlowSaveGameNode.cpp プロジェクト: joewan/pycmake
	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);
	}
コード例 #12
0
ファイル: FlowLogicNodes.cpp プロジェクト: aronarts/FireNET
	virtual void GetConfiguration( SFlowNodeConfig& config )
	{
		static const SInputPortConfig in_config[] = {
			InputPortConfig_Void("in1", _HELP("Input 1")),
			InputPortConfig_Void("in2", _HELP("Input 2")),
			InputPortConfig_Void("in3", _HELP("Input 3")),
			InputPortConfig_Void("in4", _HELP("Input 4")),
			InputPortConfig_Void("in5", _HELP("Input 5")),
			InputPortConfig_Void("in6", _HELP("Input 6")),
			InputPortConfig_Void("Reset", _HELP("Reset")),
			{0}
		};
		static const SOutputPortConfig out_config[] = {
			OutputPortConfig_Void("Out", _HELP("Output")),
			{0}
		};
		config.sDescription = _HELP("All - Triggers output when all connected inputs are triggered.");
		config.pInputPorts = in_config;
		config.pOutputPorts = out_config;
		config.nFlags |= EFLN_AISEQUENCE_SUPPORTED;
		config.SetCategory(EFLN_APPROVED);
	}
コード例 #13
0
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);
}
コード例 #14
0
ファイル: FlowCameraNodes.cpp プロジェクト: joewan/pycmake
	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);
	}
コード例 #15
0
	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);
	}
コード例 #16
0
Object *oibutton(ULONG spec, ULONG help)
{
    if (spec==IBT_Up) spec = (ULONG)"\33I[6:38]";
    else if (spec==IBT_Down) spec = (ULONG)"\33I[6:39]";
         else return NULL;

    return TextObject,
        _HELP(help),
        MUIA_CycleChain,    TRUE,
        MUIA_Font,          MUIV_Font_Button,
        MUIA_InputMode,     MUIV_InputMode_RelVerify,
        ButtonFrame,
        MUIA_Background,    MUII_ButtonBack,
        MUIA_Text_Contents, spec,
        MUIA_Text_PreParse, MUIX_C,
        MUIA_Text_SetMax,   TRUE,
    End;
}
コード例 #17
0
	virtual void GetConfiguration(SFlowNodeConfig& config)
	{
		static const SInputPortConfig inputs[] = {
			InputPortConfig_Void  ("Link", _HELP("Link the Player to Target Entity")),
			InputPortConfig_Void  ("Unlink", _HELP("Unlink the Player (from any Entity)")),
			InputPortConfig<EntityId> ("Target", _HELP("Target Entity Id") ),
			InputPortConfig<int>  ("DrawPlayer", 0, _HELP("Draw the Player (Hide=-1, NoChange=0, Show=1)"), 0, _UICONFIG("enum_int:NoChange=0,Hide=-1,Show=1")),
			InputPortConfig<bool> ("KeepTransformationOnUnlink", true, _HELP("Keep Transformation on Unlink")),
			{0}
		};
		static const SOutputPortConfig outputs[] = {
			OutputPortConfig_Void ("Linked", _HELP("Trigger if Linked")),
			OutputPortConfig_Void ("Unlinked", _HELP("Trigger if Unlinked")),
			{0}
		};
		config.pInputPorts = inputs;
		config.pOutputPorts = outputs;
		config.sDescription = _HELP("Linking the Player to an Entity (with FreeLook)");
		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<SFlowSystemVoid>("Draw", _HELP("Trigger to draw the Planar Disc")),
			InputPortConfig<Vec3>("Pos", _HELP("Centre position of Planar Disc")),
			InputPortConfig<float>("InnerRadius", _HELP("Inner radius of Planar Disc")),
			InputPortConfig<float>("OuterRadius", _HELP("Outer radius of Planar Disc")),
			InputPortConfig<Vec3>("Color", _HELP("Color of the Planar Disc")),
			InputPortConfig<float>("Time", _HELP("Time Planar Disc should be drawn for")),
			{0}
		};

		config.sDescription = _HELP("Draws a Planar Disc for debugging purposes");
		config.pInputPorts = in_config;
		config.SetCategory(EFLN_DEBUG);
	}
コード例 #20
0
ファイル: FlowPhysicsNodes.cpp プロジェクト: aronarts/FireNET
	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);
	}
コード例 #21
0
	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);
	}
コード例 #22
0
	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 in_config[] =
		{
			InputPortConfig_Void( "Succeed", _HELP("Start path ends here and succeed path begins") ),
			InputPortConfig_Void( "SucceedWait", _HELP("Optional path that can be triggered after Succeed") ),
			InputPortConfig_Void( "SucceedWaitComplete", _HELP("Triggered when SucceedWait state is complete") ),
			InputPortConfig_Void( "Abort", _HELP("Abort path begins") ),
			InputPortConfig_Void( "EndSuccess", _HELP("Action ends in success") ),
			InputPortConfig_Void( "EndFailure", _HELP("Action ends in failure") ),
			{0}
		};
		config.nFlags |= EFLN_TARGET_ENTITY;
		config.pInputPorts = in_config;
		config.pOutputPorts = NULL;
		config.sDescription = _HELP( "This node is the end point for all the paths in the Custom Action" );
		config.SetCategory(EFLN_APPROVED);
	}
コード例 #25
0
    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 );
    }
コード例 #26
0
    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 in combination with combat mode the AI is allowed to shoot at the target. If disabled it just tactically positions itself to places from where it can see/hit the target. The default state is enabled." );
        config.SetCategory( EFLN_APPROVED );
    }
コード例 #27
0
    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);
    }
コード例 #28
0
ファイル: FlowCameraNodes.cpp プロジェクト: joewan/pycmake
	virtual void GetConfiguration( SFlowNodeConfig &config )
	{
		static const SInputPortConfig in_config[] = {
			InputPortConfig<bool>( "Enable", "Enable custom view" ),
			InputPortConfig<bool>( "Disable", "Disable custom view" ),
			InputPortConfig<float>( "FOV", 60.0f, "Field of View used by the custom view" ),
			InputPortConfig<bool>( "Blend", false, "Enables FOV, Position and Rotation blending"),
			InputPortConfig<float>( "BlendFOVSpeed", 5.0f, "How fast to blend in the FOV offset"),
			InputPortConfig<float>( "BlendFOVOffset", 0.0f, "FOV offset"),
			InputPortConfig<float>( "BlendPosSpeed", 5.0f, "How fast to blend in the position offset"),
			InputPortConfig<Vec3>( "BlendPosOffset", Vec3(ZERO), "Position offset"),
			InputPortConfig<float>( "BlendRotSpeed", 10.0f, "How fast to blend in the rotation offset"),
			InputPortConfig<Vec3>( "BlendRotOffset", Vec3(ZERO), "Rotation offset"),
			{0}
		};

		config.nFlags      |= EFLN_TARGET_ENTITY;
		config.pInputPorts  = in_config;
		config.sDescription = _HELP( "Creates a custom view linked to an entity" );
		config.SetCategory(EFLN_APPROVED);
	}
コード例 #29
0
	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);
	}
コード例 #30
0
ファイル: FlowDelayNode.cpp プロジェクト: aronarts/FireNET
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);
}