C++ OutputPortConfig_Void函数代码示例

	void GetConfiguration( SFlowNodeConfig& config )
	{
		static const SInputPortConfig in_ports[] = 
		{
			InputPortConfig_Void( "check", _HELP("Connect event here to check the inventory for the item" ), _HELP("Check") ),
			InputPortConfig<string>( "item", _HELP("The item to add to the inventory" ), _HELP("Item"), _UICONFIG("enum_global_ref:item%s:ItemType")),
			InputPortConfig<string>( "ItemType", "", _HELP("Select from which items to choose"), 0, _UICONFIG("enum_string:All=,Givable=_givable,Selectable=_selectable")),
			{0}
		};

		static const SOutputPortConfig out_ports[] = 
		{
			OutputPortConfig<bool>("out", _HELP("True if the player has the item, false otherwise" ), _HELP("Out") ),
			OutputPortConfig_Void("False", _HELP("Triggered if player does not have the item" )),
			OutputPortConfig_Void("True",  _HELP("Triggered if player has the item" )),
			OutputPortConfig<EntityId>("ItemId", _HELP("Outputs the item's entity id" )),
			{0}
		};

		config.sDescription = _HELP("Check inventory to see if an item is present.");
		config.nFlags |= EFLN_TARGET_ENTITY;
		config.pInputPorts = in_ports;
		config.pOutputPorts = out_ports;
		config.SetCategory(EFLN_APPROVED);
	}

	virtual void GetConfiguration(SFlowNodeConfig& config)
	{
		static const SInputPortConfig inputs[] = {
			InputPortConfig_Void("Play", _HELP("Play the fragment")),
			InputPortConfig<string>("Fragment", _HELP("Fragment name")),
			InputPortConfig<string>("Tags", _HELP("Tags, seperate by + sign")),
			InputPortConfig<int>("Priority", _HELP("Priority, higher number = higher priority")),
			InputPortConfig_Void("Pause", _HELP("Pauses the actionController")),
			InputPortConfig_Void("Resume", _HELP("Resumes this entity's actionController")),
			InputPortConfig_Void("ForceFinishLastQueued", _HELP("Finish the last queued action")),
			{0}
		};

		static const SOutputPortConfig outputs[] = {
			OutputPortConfig_Void     ("Success",  _HELP("Triggers if succeeded to pass the command")),
			OutputPortConfig_Void		("Failed", _HELP("Triggers if anything went wrong")),
			{0}
		};

		config.nFlags |= EFLN_TARGET_ENTITY;
		config.pInputPorts = inputs;
		config.pOutputPorts = outputs;
		config.sDescription = _HELP("Play a Mannequin Fragment on a given entity with given Tags");
		config.SetCategory(EFLN_ADVANCED);
	}

	virtual void GetConfiguration( SFlowNodeConfig &config )
	{
		static const SInputPortConfig inp_config[] = 
		{
			InputPortConfig<int>("FilterAI", 0, _HELP("Filter which AIs are used for the alertness value."), _HELP("FilterAI"),_UICONFIG("enum_int:All=0,Enemies=1,Friends=2,Faction=3")),
			InputPortConfig<string>("Faction", "", _HELP("Only used when 'FilterAI' input is set to 'Faction'. )."), 0, "enum_global:Faction"),
			InputPortConfig<bool>("Enabled", true, _HELP("To enable/disable the node.")),
			InputPortConfig_Void("Check", _HELP("instant check.")),
			{0}
		};

		static const SOutputPortConfig out_config[] = 
		{
			OutputPortConfig<int>("alertness", "0 - green\n1 - orange\n2 - red"),
			OutputPortConfig_Void("green"),
			OutputPortConfig_Void("orange"),
			OutputPortConfig_Void("red"),
			{0}
		};

		config.sDescription = _HELP( "The highest level of alertness of the specified AIs" );
		config.pInputPorts = inp_config;
		config.pOutputPorts = out_config;
		config.SetCategory(EFLN_APPROVED);
	}

void CFlashUIGotoAndPlayBaseNode::GetConfiguration( SFlowNodeConfig &config )
{
	static const SInputPortConfig in_config[] = {
		CreateMovieClipsPort(),
		CreateInstanceIdPort(),
		InputPortConfig_Void( "GotoAndPlay", "GotoAndPlay to frame" ),
		InputPortConfig_Void( "GotoAndStop", "GotoAndStop to frame" ),
		InputPortConfig<int>( "FrameId", -1, "Frame Number, -1 = use FrameName"),
		InputPortConfig<string>( "FrameName", "FrameName, only used if FrameId is set to -1" ),
		InputPortConfig_Void( 0 ),
		{0}
	};

	static const SInputPortConfig in_config_tmpl[] = {
		CreateMovieClipsForTmplPort(),
		CreateInstanceIdPort(),
		CreateTmplInstanceNamePort(),
		InputPortConfig_Void( "GotoAndPlay", "GotoAndPlay to frame" ),
		InputPortConfig_Void( "GotoAndStop", "GotoAndStop to frame" ),
		InputPortConfig<int>( "FrameId", -1, "Frame Number, -1 = use FrameName"),
		InputPortConfig<string>( "FrameName", "FrameName, only used if FrameId is set to -1" ),
		InputPortConfig_Void( 0 ),
	};

	static const SOutputPortConfig out_config[] = {
		OutputPortConfig_Void( "OnGotoAndPlay", "On GotoAndPlay" ),
		OutputPortConfig_Void( "OnGotoAndStop", "On GotoAndStop" ),
		{0}
	};

	config.pInputPorts  =  IsTemplate() ? in_config_tmpl : in_config;
	config.pOutputPorts = out_config;
	config.sDescription = "Access to MovieClips";
	config.SetCategory(EFLN_APPROVED);
}

	virtual void GetConfiguration(SFlowNodeConfig& config)
	{
		static const SInputPortConfig inputs[] = {
			InputPortConfig<int> ("FadeGroup", 0, _HELP("Fade Group [0-3]"), 0, _UICONFIG("enum_int:0=0,1=1,2=2,3=3")),
			InputPortConfig_Void("FadeIn", _HELP("Fade back from the specified color back to normal screen")),
			InputPortConfig_Void("FadeOut", _HELP("Fade the screen to the specified color")),
			InputPortConfig<bool> ("UseCurColor", true, _HELP("If checked, use the current color as Source color. Otherwise use [FadeColor] as Source color and Target color.")),
			InputPortConfig<float>("FadeInTime", 2.0f, _HELP("Duration of fade in")),
			InputPortConfig<float>("FadeOutTime", 2.0f, _HELP("Duration of fade out")),
			InputPortConfig<Vec3> ("color_FadeColor", _HELP("Target Color to fade to")),
			InputPortConfig<string> ("tex_TextureName", _HELP("Texture Name")),
			InputPortConfig<bool> ("UpdateAlways", false, _HELP("If checked, the Fader will be updated always, otherwise only if game is not paused.")),
			{0}
		};
		static const SOutputPortConfig outputs[] = {
			OutputPortConfig_Void("FadedIn", _HELP("FadedIn")),
			OutputPortConfig_Void("FadedOut", _HELP("FadedOut")),
			OutputPortConfig<Vec3> ("CurColor", _HELP("Current Faded Color")),
			{0}
		};
		config.pInputPorts = inputs;
		config.pOutputPorts = outputs;
		config.sDescription = _HELP("Controls Screen Fading.");
		config.SetCategory(EFLN_ADVANCED);
	}

void CD6PlayerCreditRangeNode::GetConfiguration(SFlowNodeConfig& config)
{
    // Input ports
    static const SInputPortConfig inputs[] =
    {
        InputPortConfig_Void("Trigger", _HELP("Run the test")),
        InputPortConfig<unsigned int>("MinAmount", 0.0f, _HELP("Minimum amount to check for"), _HELP("Minimum Amount")),
        InputPortConfig<unsigned int>("MaxAmount", 0.0f, _HELP("Maximum amount to check for"), _HELP("Maximum Amount")),
        {0},
    };

    // Output ports
    static const SOutputPortConfig outputs[] =
    {
        OutputPortConfig_Void("Passed", _HELP("Triggered if test passes (in range)")),
        OutputPortConfig_Void("Failed", _HELP("Triggered if test fails (not in range)")),
        {0},
    };

    // Set up config
    config.nFlags |= EFLN_TARGET_ENTITY;
    config.pInputPorts = inputs;
    config.pOutputPorts = outputs;
    config.sDescription = _HELP("Determines if player's credits are in given range");
    config.SetCategory(EFLN_APPROVED);
}

	virtual void GetConfiguration(SFlowNodeConfig& config)
	{
		static const SInputPortConfig inputs[] = {
			InputPortConfig_Void  ("Cloak", _HELP("Trigger to select Cloak Mode")),
			InputPortConfig_Void  ("Strength", _HELP("Trigger to select Strength Mode")),
			InputPortConfig_Void  ("Defense", _HELP("Trigger to select Defense Mode")),
			InputPortConfig_Void  ("Speed", _HELP("Trigger to select Speed Mode")),
			InputPortConfig<float>("Energy", 0.0f, _HELP("Set Energy")),
			InputPortConfig<int>  ("CloakLevel", 1, _HELP("Set cloak level [1-3]")),
			InputPortConfig_Void  ("BreakHUD", _HELP("Trigger to break the HUD, causing it to disappear")),
			InputPortConfig_Void  ("RebootHUD", _HELP("Trigger to reboot the HUD, causing it to appear")),
			{0}
		};
		static const SOutputPortConfig outputs[] = {
			OutputPortConfig_Void  ("Cloak", _HELP("Triggered on Default 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 [set when Cloak mode is active]")),
			// OutputPortConfig_Void  ("BreakHUD", "Triggered on breaking the HUD"),
			// OutputPortConfig_Void  ("RebootHUD", "Triggered on rebooting the HUD"),
			{0}
		};
		config.nFlags |= EFLN_TARGET_ENTITY;
		config.pInputPorts = inputs;
		config.pOutputPorts = outputs;
		config.sDescription = _HELP("NanoSuit Node");
		config.SetCategory(EFLN_WIP);
	}

	virtual void GetConfiguration(SFlowNodeConfig& config)
	{
		// Define input ports here, in same order as EInputPorts
		static const SInputPortConfig inputs[] =
		{
			InputPortConfig_Void("Enable", _HELP("Enable receiving signals")),
			InputPortConfig_Void("Disable", _HELP("Disable receiving signals")),
			InputPortConfig<int>("Port", 1234, _HELP("Port number"), 0,0),
			InputPortConfig<string>("Multicast", "225.1.1.2", _HELP("UDP Multicast address (between 225.0.0.1 and 239.255.255.255)"), 0,0),
			{0}
		};

		// Define output ports here, in same oreder as EOutputPorts
		static const SOutputPortConfig outputs[] =
		{
			OutputPortConfig<bool>("Success", _HELP("UDP socket successfully opened for listening")), 
			OutputPortConfig<bool>("Fail", _HELP("UDP socket failed to open")), 
			OutputPortConfig<bool>("Received", _HELP("New data")), 
			OutputPortConfig_Void("Value", _HELP("Value")),
			OutputPortConfig_Void("Error", _HELP("Error generated by UDP Listener")),
			{0}
		};

		// Fill in configuration
		config.pInputPorts = inputs;
		config.pOutputPorts = outputs;
		config.sDescription = _HELP("Opens a Multicast UDP listener");
		//config.SetCategory(EFLN_ADVANCED);
	}

void CFlowNode_SimulateInput::GetConfiguration(SFlowNodeConfig &config)
{
	static const SInputPortConfig in_ports[] =
	{
		InputPortConfig<string>("ActionInput", _HELP("Action input to trigger"), _HELP("Action"), _UICONFIG("enum_global:input_actions")),
		InputPortConfig_Void("Press", _HELP("Simulate press")),
		InputPortConfig_Void("Hold", _HELP("Simulate hold event")),
		InputPortConfig_Void("Release", _HELP("Simulate relase")),
		InputPortConfig<float>("Value", 0.0f, _HELP("Value between 0 and 1")),
		{0}
	};

	static const SOutputPortConfig out_ports[] =
	{
		OutputPortConfig_Void("Pressed", _HELP("Pressed")),
		OutputPortConfig_Void("Held", _HELP("Held")),
		OutputPortConfig_Void("Released", _HELP("Released")),
		{0}
	};

	config.sDescription = _HELP("Simulate player actions input");
	config.pInputPorts = in_ports;
	config.pOutputPorts = out_ports;
	config.SetCategory(EFLN_DEBUG);
}

	virtual void GetConfiguration( SFlowNodeConfig& config )
	{
		// declare input ports
		static const SInputPortConfig in_ports[] = 
		{
			InputPortConfig<bool>("MissionOnly", "Only trigger on events involving mission tracked entities"),
			InputPortConfig<string>("Class", "AllClasses", "Class you want to filter on. For custom classes, use CustomClasses input", 0,  _UICONFIG("enum_global:entity_classes") ),
			InputPortConfig<string>("CustomClasses", "Optional: Add classes you want to filter the entities on (comma separated)"),
			{0}
		};

		// declare output ports
		static const SOutputPortConfig out_ports[] = 
		{
			OutputPortConfig_Void("EntityAdded", "Fires when a entity is added to the radar from the Mission"),
			OutputPortConfig_Void("EntityRemoved", "Fires when a entity is removed from the radar by a Mission"),
			OutputPortConfig<EntityId>("Entity", "The entity that needs adding"),
			{0}
		};

		// we set pointers in "config" here to specify which input and output ports the node contains
		config.sDescription = _HELP("Fires when entities are added or removed to the radar from a mission");
		config.pInputPorts = in_ports;
		config.pOutputPorts = out_ports;
		config.SetCategory(EFLN_APPROVED);
	}

void CFlashUIActionNode::GetConfiguration( SFlowNodeConfig &config )
{
	static const SInputPortConfig in_config[] = {
		InputPortConfig<string>( "uiActions_UIAction", "Name of UI action", _HELP("UIAction") ),
		InputPortConfig<bool>( "Strict", false, "If true this node will log an error if the UIAction does not exist, otherwise it can be used in a more loose way." ),
		InputPortConfig_Void( "Start", "Start UI action" ),
		InputPortConfig<string>( "Args", "Comma separated argument string" ),
		{0}
	};

	static const SOutputPortConfig out_config[] = {
		OutputPortConfig_Void( "OnStart", "Triggered if this node starts the action" ),
		OutputPortConfig_Void( "OnEnd", "Triggered if action is stopped and was started by this node" ),
		OutputPortConfig_Void( "OnStartAll", "Always triggered if the action started" ),
		OutputPortConfig_Void( "OnEndAll", "Always triggered if action is stopped" ),
		OutputPortConfig<string>( "Args", "Comma separated argument string" ),
		{0}
	};


	config.pInputPorts = in_config;
	config.pOutputPorts = out_config;
	config.sDescription = "Controls an UI Action";
	config.SetCategory(EFLN_APPROVED);
}

	virtual void GetConfiguration(SFlowNodeConfig& config)
	{
		// Define input ports here, in same order as EInputPorts
		static const SInputPortConfig inputs[] =
		{
			InputPortConfig_Void("Enable", _HELP("Enable receiving signals")),
			InputPortConfig_Void("Disable", _HELP("Disable receiving signals")),
			InputPortConfig<int>("Port", 1234, _HELP("Port number"), 0,0),
			{0},
		};

		// Define output ports here, in same oreder as EOutputPorts
		static const SOutputPortConfig outputs[] =
		{
			OutputPortConfig<bool>("Success", _HELP("UDP socket successfully opened for listening")), 
			OutputPortConfig<bool>("Fail", _HELP("UDP socket failed to open")), 
			OutputPortConfig<bool>("Received", _HELP("New data")), 
			OutputPortConfig_Void("CVAR", _HELP("Value")),
			OutputPortConfig_Void("Value", _HELP("Value")),
			{0},
		};

		// Fill in configuration
		config.pInputPorts = inputs;
		config.pOutputPorts = outputs;
		config.sDescription = _HELP("Opens a UDP listener");
		//config.SetCategory(EFLN_ADVANCED);
	}

	virtual void GetConfiguration(SFlowNodeConfig& config)
	{
		static const SInputPortConfig inputs[] = {
			InputPortConfig_Void    ("Play", _HELP("Display USMPlayer and start playback")),
			InputPortConfig_Void    ("Stop", _HELP("Stop playback and hide USMPlayer")),
			InputPortConfig_Void    ("Pause", _HELP("Pause playback")),
			InputPortConfig_Void    ("Resume", _HELP("Resume playback")),
			InputPortConfig<int>    ("InstanceID", -1, _HELP("Instance ID of USMPlayer (e.g. to use USMPlayer on dynamic textures)")),
			InputPortConfig<string> ("VideoFile", _HELP("Name of usm file, file should be placed in Libs/UI/ or subfolder")),
			InputPortConfig<bool>   ("Transparent", false, _HELP("If player background is transparent or not")),
			InputPortConfig<bool>   ("Loop", false, _HELP("If true, video playback loops")),
			InputPortConfig<bool>   ("Skipable", true, _HELP("If true, player can skip video by pressing on of the skip keys (see ActionMap)")),
			InputPortConfig<int>    ("AudioChannel", 0, _HELP("Audio channel")),
			InputPortConfig<int>    ("SubtitleChannel", 0, _HELP("Subtitle channel")),
			InputPortConfig_Null()
		};

		static const SOutputPortConfig outputs[] = {
			OutputPortConfig_Void  ("OnPlay",	_HELP("Triggered once the video started")),
			OutputPortConfig<bool> ("OnStop",	_HELP("Triggered once the video stopped. True if the video was finished, flase if skiped")),
			OutputPortConfig_Void  ("OnPause",	_HELP("Triggered once the video is paused")),
			OutputPortConfig_Void  ("OnResume",	_HELP("Triggered once the video resumes")),
			OutputPortConfig_Void  ("OnLooped",	_HELP("Triggered once the video looped and start again")),
			OutputPortConfig_Void  ("OnVideoNotFound",	_HELP("Triggered on Video was not found")),
			OutputPortConfig_Null()
		};

		config.pInputPorts = inputs;
		config.pOutputPorts = outputs;
		config.sDescription = _HELP( "Video player node that is using USMPlayer UIElement" );
		config.SetCategory( EFLN_ADVANCED );
	}

	virtual void GetConfiguration( SFlowNodeConfig &config )
	{
		static const SInputPortConfig in_config[] = 
		{
			InputPortConfig<Vec3>( "Destination",_HELP("Destination") ),
			InputPortConfig<bool>( "DynamicUpdate", true, _HELP("If dynamic update of Destination [follow-during-movement] is allowed or not"), _HELP("DynamicUpdate") ),
			InputPortConfig<int>( "ValueType", 0, _HELP("Defines if the 'Value' input will be interpreted as speed or as time (duration)."), _HELP("ValueType"), _UICONFIG("enum_int:speed=0,time=1") ),
			InputPortConfig<float>( "Speed", 0.f, _HELP("Speed (m/sec) or time (duration in secs), depending on 'ValueType' input."), _HELP("Value")),
			InputPortConfig<float>( "EaseDistance", 0.f, _HELP("Distance from destination at which the moving entity starts slowing down (0=no slowing down)"), _HELP("EaseInDistance") ),
			InputPortConfig<float>( "EaseOutDistance", 0.f, _HELP("Distance from destination at which the moving entity starts slowing down (0=no slowing down)") ),
			InputPortConfig<int> ( "CoordSys", 0, _HELP("Destination in world, local or parent space"), _HELP("CoordSys"), _UICONFIG("enum_int:Parent=0,World=1,Local=2") ),
			InputPortConfig_Void( "Start", _HELP("Trigger this port to start the movement") ),
			InputPortConfig_Void( "Stop",  _HELP("Trigger this port to stop the movement") ),
			{0}
		};
		static const SOutputPortConfig out_config[] = 
		{
			OutputPortConfig<Vec3>("Current",_HELP("Current position")),
			OutputPortConfig_Void("Start", _HELP("Triggered when start input is triggered")),
			OutputPortConfig_Void("Stop", _HELP("Triggered when stop input is triggered")),
			OutputPortConfig_Void("Finish", _HELP("Triggered when destination is reached")),
			OutputPortConfig_Void("DoneTrigger", _HELP("Triggered when destination is reached or stop input is triggered"), 	_HELP("Done")),
			{0}
		};
		config.sDescription = _HELP( "Move an entity to a destination position at a defined speed or in a defined interval of time" );
		config.nFlags |= EFLN_TARGET_ENTITY|EFLN_AISEQUENCE_SUPPORTED;
		config.pInputPorts = in_config;
		config.pOutputPorts = out_config;
		config.SetCategory(EFLN_APPROVED);
	}

    virtual void GetConfiguration( SFlowNodeConfig& config )
    {
        static const SInputPortConfig inPorts[] =
        {
            InputPortConfig_Void( "Start" ),
            InputPortConfig_Void( "Stop" ),
            InputPortConfig< string >( "PathName" ),
            InputPortConfig< bool >( "LoopPath", false ),
            InputPortConfig< float >( "Speed", 30 ),
            { 0 }
        };

        static const SOutputPortConfig outPorts[] =
        {
            OutputPortConfig_Void( "ArrivedAtEnd" ),
            OutputPortConfig_Void( "ArrivedNearToEnd" ),
            OutputPortConfig_Void( "Stopped" ),
            { 0 }
        };

        config.pInputPorts = inPorts;
        config.pOutputPorts = outPorts;
        config.nFlags |= EFLN_TARGET_ENTITY;
        config.sDescription = _HELP( "Set the path the AI should follow. When not in combat mode it will follow as accurately as possible from start to end. When in combat mode it represents the path along where the AI is allowed to position itself/patrol." );
        config.SetCategory( EFLN_APPROVED );
    }