Signal - Revision history

Sandman at 11:23, 21 July 2008

Sandman — Mon, 21 Jul 2008 11:23:24 GMT

←Older revision		Revision as of 11:23, 21 July 2008
Line 33:		Line 33:
	For a process to send a signal to itself, the [[local variable]] [[id]] can be used.		For a process to send a signal to itself, the [[local variable]] [[id]] can be used.
	The parameter signal is passed by way of a set of [[signals]] which denote the signal which is to be sent.		The parameter signal is passed by way of a set of [[signals]] which denote the signal which is to be sent.
		+
		+	To kill all processes at once, except the calling one, use [[let_me_alone]]().

	== Example ==		== Example ==

Sandman at 16:11, 1 March 2008

Sandman — Sat, 01 Mar 2008 16:11:32 GMT

←Older revision		Revision as of 16:11, 1 March 2008
Line 3:		Line 3:

	== Definition ==		== Definition ==
-	'''INT''' ~~Signal~~ ( <'''INT''' processID\|processTypeID> , <'''INT''' signal> )	+	'''INT''' signal ( <'''INT''' processID\|processTypeID> , <'''INT''' signal> )

-	Allows a [[process]] or a range of processes of certain [[processType]] to be controlled in a limited number of ways, by sending [[signals]].	+	Allows a [[process]]/[[function]] or a range of processes/functions of certain [[processType]] to be controlled in a limited number of ways, by sending [[signals]].

	== Parameters ==		== Parameters ==
Line 32:		Line 32:
	To obtain the processType of a function, the operator [[Type]] can be used.		To obtain the processType of a function, the operator [[Type]] can be used.
	For a process to send a signal to itself, the [[local variable]] [[id]] can be used.		For a process to send a signal to itself, the [[local variable]] [[id]] can be used.
-	The parameter signal is passed by way of a set of [[~~constants\|~~signals]] which denote the signal which is to be sent.	+	The parameter signal is passed by way of a set of [[signals]] which denote the signal which is to be sent.

	== Example ==		== Example ==
	<pre>		<pre>
-	~~Signal~~( get_id(type enemy) , s_kill ); // Kills a process of type enemy	+	signal( get_id(type enemy) , s_kill ); // Kills a process of type enemy
-	~~Signal~~( id , s_kill_tree ); // Kills the process that calls it, and all of its descendants	+	signal( id , s_kill_tree ); // Kills the process that calls it, and all of its descendants
-	~~Signal~~( Type player , s_freeze ); // Freezes all processes of type player so that they are	+	signal( Type player , s_freeze ); // Freezes all processes of type player so that they are
	// still displayed, but do not execute any code.		// still displayed, but do not execute any code.
	</pre>		</pre>

Sandman at 11:46, 25 December 2007

Sandman — Tue, 25 Dec 2007 11:46:19 GMT

←Older revision		Revision as of 11:46, 25 December 2007
Line 41:		Line 41:
	// still displayed, but do not execute any code.		// still displayed, but do not execute any code.
	</pre>		</pre>
		+
		+	{{Funcbox
		+	\| category = Processinteraction
		+	}}

Sandman at 01:26, 31 October 2007

Sandman — Wed, 31 Oct 2007 01:26:13 GMT

←Older revision		Revision as of 01:26, 31 October 2007
Line 15:		Line 15:

	== Returns ==		== Returns ==
-	'''INT''' : ~~Successrate~~	+	'''INT''' :
	{\|		{\|
-	\| [[false]] \|\| - ~~There~~ was ~~an error~~.	+	\| [[false]] \|\| - The specified processID<nowiki>\|</nowiki>processTypeID was 0 or a [[processTypeID]].
	\|-		\|-
-	\| [[true]] \|\| - ~~Sending~~ was ~~successful~~.	+	\| [[true]] \|\| - The specified processID<nowiki>\|</nowiki>processTypeID was a [[processID]].
	\|}		\|}

	== Errors ==		== Errors ==
	{\|		{\|
-	\| Invalid signal \|\| - The specified signal is invalid.	+	\| Invalid processID \|\| - The [[process]] with specified processID is not alive. ''(Pre [[0.90.2]] only)''
		+	\|-
		+	\| Invalid signal \|\| - The specified [[signals\|signal]] is invalid.
	\|}		\|}

Sandman at 13:29, 4 May 2007

Sandman — Fri, 04 May 2007 13:29:10 GMT

←Older revision		Revision as of 13:29, 4 May 2007
Line 30:		Line 30:
	To obtain the processType of a function, the operator [[Type]] can be used.		To obtain the processType of a function, the operator [[Type]] can be used.
	For a process to send a signal to itself, the [[local variable]] [[id]] can be used.		For a process to send a signal to itself, the [[local variable]] [[id]] can be used.
-	The parameter <signal> is passed by way of a set of [[~~predefined~~ constants]] which denote the signal which is to be sent~~. These are listed [[signals\|here]]~~.	+	The parameter signal is passed by way of a set of [[constants\|signals]] which denote the signal which is to be sent.

	== Example ==		== Example ==

Sandman: /* Notes */

Sandman — Wed, 02 May 2007 00:46:15 GMT

Notes

←Older revision		Revision as of 00:46, 2 May 2007
Line 28:		Line 28:

	== Notes ==		== Notes ==
-	To obtain the processType of a function, the operator "Type" can be used.	+	To obtain the processType of a function, the operator [[Type]] can be used.
	For a process to send a signal to itself, the [[local variable]] [[id]] can be used.		For a process to send a signal to itself, the [[local variable]] [[id]] can be used.
	The parameter <signal> is passed by way of a set of [[predefined constants]] which denote the signal which is to be sent. These are listed [[signals\|here]].		The parameter <signal> is passed by way of a set of [[predefined constants]] which denote the signal which is to be sent. These are listed [[signals\|here]].

Sandman at 00:45, 2 May 2007

Sandman — Wed, 02 May 2007 00:45:58 GMT

←Older revision		Revision as of 00:45, 2 May 2007
Line 5:		Line 5:
	'''INT''' Signal ( <'''INT''' processID\|processTypeID> , <'''INT''' signal> )		'''INT''' Signal ( <'''INT''' processID\|processTypeID> , <'''INT''' signal> )

-	Allows ~~one~~ [[process]] ~~to control another~~ [[~~process~~]] in a limited number of ways, by sending [[signals]].	+	Allows a [[process]] or a range of processes of certain [[processType]] to be controlled in a limited number of ways, by sending [[signals]].
-		+
-	~~== Returns ==~~	+
-	~~'''INT''' - Nothing~~	+

	== Parameters ==		== Parameters ==
Line 14:		Line 11:
	\| '''INT''' processID<nowiki>\|</nowiki>processTypeID \|\| - The [[ProcessID]] of the process or the [[ProcessTypeID]] of the type of processes to which the signal is to be sent.		\| '''INT''' processID<nowiki>\|</nowiki>processTypeID \|\| - The [[ProcessID]] of the process or the [[ProcessTypeID]] of the type of processes to which the signal is to be sent.
	\|-		\|-
-	\| '''INT''' signal \|\| - The code of the signal that is to be sent to the target process.	+	\| '''INT''' signal \|\| - The code of the [[signals\|signal]] that is to be sent to the target process.
		+	\|}
		+
		+	== Returns ==
		+	'''INT''' : Successrate
		+	{\|
		+	\| [[false]] \|\| - There was an error.
		+	\|-
		+	\| [[true]] \|\| - Sending was successful.
		+	\|}
		+
		+	== Errors ==
		+	{\|
		+	\| Invalid signal \|\| - The specified signal is invalid.
	\|}		\|}

Sandman: processTypeID

Sandman — Wed, 02 May 2007 00:27:37 GMT

processTypeID

←Older revision		Revision as of 00:27, 2 May 2007
Line 3:		Line 3:

	== Definition ==		== Definition ==
-	'''INT''' Signal ( <'''INT''' processID\|~~processType~~> , <'''INT''' signal> )	+	'''INT''' Signal ( <'''INT''' processID\|processTypeID> , <'''INT''' signal> )

	Allows one [[process]] to control another [[process]] in a limited number of ways, by sending [[signals]].		Allows one [[process]] to control another [[process]] in a limited number of ways, by sending [[signals]].
Line 12:		Line 12:
	== Parameters ==		== Parameters ==
	{\|		{\|
-	\| '''INT''' processID ~~or processType~~ \|\| - The [[ProcessID]] of the process or the [[~~ProcessType~~]] of the type of processes to which the signal is to be sent.	+	\| '''INT''' processID<nowiki>\|</nowiki>processTypeID \|\| - The [[ProcessID]] of the process or the [[ProcessTypeID]] of the type of processes to which the signal is to be sent.
	\|-		\|-
	\| '''INT''' signal \|\| - The code of the signal that is to be sent to the target process.		\| '''INT''' signal \|\| - The code of the signal that is to be sent to the target process.

Sandman at 11:14, 18 April 2007

Sandman — Wed, 18 Apr 2007 11:14:43 GMT

←Older revision		Revision as of 11:14, 18 April 2007
Line 11:		Line 11:

	== Parameters ==		== Parameters ==
-	'''INT''' processID\|processType: The [[ProcessID]] of the process or the [[ProcessType]] of the type of processes to which the signal is to be sent~~. For a process to send a signal to itself, the [[local variable]] [[id]] can be used~~.	+	{\|
-		+	\| '''INT''' processID or processType \|\| - The [[ProcessID]] of the process or the [[ProcessType]] of the type of processes to which the signal is to be sent.
-	'''INT''' signal: The code of the signal that is to be sent to the target process. ~~This parameter is passed by way of a set of [[predefined constants]] which denote the signal which is to be sent. These are listed [[signals~~\|~~here]].~~	+	\|-
		+	\| '''INT''' signal \|\| - The code of the signal that is to be sent to the target process.
		+	\|}

	== Notes ==		== Notes ==
	To obtain the processType of a function, the operator "Type" can be used.		To obtain the processType of a function, the operator "Type" can be used.
		+	For a process to send a signal to itself, the [[local variable]] [[id]] can be used.
		+	The parameter <signal> is passed by way of a set of [[predefined constants]] which denote the signal which is to be sent. These are listed [[signals\|here]].

	== Example ==		== Example ==
	<pre>		<pre>
-	Signal( get_id(type enemy) , s_kill ); //~~kills~~ a process of type enemy	+	Signal( get_id(type enemy) , s_kill ); // Kills a process of type enemy
-	Signal( id , s_kill_tree ); //~~kills~~ the process that calls it, and all of its ~~sons, their sons, etc.~~	+	Signal( id , s_kill_tree ); // Kills the process that calls it, and all of its descendants
-	Signal( Type player , s_freeze ); //~~freezes~~ all processes of type player so that they are still displayed, but do not execute any code.	+	Signal( Type player , s_freeze ); // Freezes all processes of type player so that they are
		+	// still displayed, but do not execute any code.
	</pre>		</pre>

Sandman at 10:57, 18 April 2007

Sandman — Wed, 18 Apr 2007 10:57:50 GMT

←Older revision		Revision as of 10:57, 18 April 2007
Line 1:		Line 1:
	[[Category:functions]]		[[Category:functions]]
-		+	[[Category:processinteraction]]
-	~~Signal() is an in-built~~ [[~~function~~]] ~~that allows one [[process]] to controll another [[process]] in a limited number of ways.~~	+
-		+

	== Definition ==		== Definition ==
		+	'''INT''' Signal ( <'''INT''' processID\|processType> , <'''INT''' signal> )

-	~~SIGNAL ( '''INT''' processID~~ , ~~'''INT''' signal )~~	+	Allows one [[process]] to control another [[process]] in a limited number of ways, by sending [[signals]].
-		+
-	or	+
-		+
-	~~SIGNAL ( '''TYPE''' processName , '''INT''' signal )~~	+
-		+

	== Returns ==		== Returns ==
-		+	'''INT''' - Nothing
-	~~...~~	+
-		+

	== Parameters ==		== Parameters ==
		+	'''INT''' processID\|processType: The [[ProcessID]] of the process or the [[ProcessType]] of the type of processes to which the signal is to be sent. For a process to send a signal to itself, the [[local variable]] [[id]] can be used.

-	~~'''INT''' processID: The [[ProcessID]] of the process to which the signal is to be sent, for a process to send a signal to itself, the [[local variable]] [[id]] can be used.~~	+	'''INT''' signal: The code of the signal that is to be sent to the target process. This parameter is passed by way of a set of [[predefined constants]] which denote the signal which is to be sent. These are listed [[signals\|here]].
-		+
-	~~'''TYPE''' processName: The [[ProcessName]] of the process type to which the signal is to be sent, for example, if the signal is to be sent to all Enemy() processes, [[processName]] would be "enemy".~~	+
-		+
-	'''INT''' signal: The code of the signal that is to be sent to the target process~~, this perameter~~ is passed by way of a set of [[predefined constants]] which denote the signal which is to be sent. These are listed ~~below.~~	+
-		+
-		+
-	~~== Signals ==~~	+
-		+
-	~~The following signals can be sent from one process to another (these are~~ [[~~predefined constants]] that can be passed as the "signal" parameter):~~	+
-	* [[s_kill]] - Order to kill the process. The process will not appear in the following [[frame]]s of the game any longer.	+
-	* [[s_sleep]] - Order to make the process dormant. The process will remain paralysed, without executing its code and without being displayed on screen (nor being detected by other processes), as if it had been killed. But the porcess will continue to exist in the computer's memory.	+
-	* [[s_freeze]] - Order to freeze the process. The process will remain motionless without running its code. But it will continue to be displayed on screen and it will be possible to detect it (in the collisions) by the rest of the processes. The process will continue to exist in the computers memory even if its code is not executed.	+
-	* [[s_wakeup]] - Order to wake up the process. It returns a slept or frozen process to its normal state. The process will be executed and displayed again from the moment that it recieves theis signal normally. A process that has been killed cannot be returned to its normal state by this method (or at all).	+
-		+
-	~~In addition to these there are the following~~ signals ~~that have the same effect, but affect a range of processes, not just a single process:~~	+
-		+
-	* [[s_kill_tree]]	+
-	* [[s_sleep_tree]]	+
-	* [[s_freeze_tree]]	+
-	* [[s_wakeup_tree]]	+
-		+
-	These will have the effect of their non-tree counterparts, but will affect the process indicated by the "processID" or "processName" parameter and all of the processes created by those processes, either directly, or indirectly. So if an [[s_kill_tree]] signal is sent to a process, that process will die, all of the processes that it created will die, and all of the processes that they created will die, and so on. The exception to this is where there is an [[orphan process]], that is a process to whose [[father]] is already dead.	+

		+	== Notes ==
		+	To obtain the processType of a function, the operator "Type" can be used.

	== Example ==		== Example ==
-	<pre>~~signal~~( get_id(type enemy) , s_kill ); //kills a process of type enemy	+	<pre>
-	~~signal~~( id , s_kill_tree ); //kills the process that calls it, and all of its sons, their sons, etc.	+	Signal( get_id(type enemy) , s_kill ); //kills a process of type enemy
-	~~signal~~( ~~type~~ player , s_freeze ); //freezes all processes of type player so that they are still displayed, but do not execute any code.</pre>	+	Signal( id , s_kill_tree ); //kills the process that calls it, and all of its sons, their sons, etc.
		+	Signal( Type player , s_freeze ); //freezes all processes of type player so that they are still displayed, but do not execute any code.
		+	</pre>