AIWrapper:ModularAI - Revision history

Flozi: 1cat

2013-03-20T18:05:38Z

1cat

← Older revision		Revision as of 19:05, 20 March 2013
Line 146:		Line 146:
	''' [[AIs\|<- Back to AI page]]'''		''' [[AIs\|<- Back to AI page]]'''

	~~[[Category: AI]]~~
	[[Category: AIWrapper]]		[[Category: AIWrapper]]
	~~[[Category: Development]]~~

Hoijui: added AI wrapper template, categories, link back to AI page, and fixed some typos

2010-03-03T21:53:20Z

added AI wrapper template, categories, link back to AI page, and fixed some typos

← Older revision		Revision as of 22:53, 3 March 2010
Line 1:		Line 1:
			{{AIWrapper\|ModularAI\|LoidThanead\|?\|Java\|beta\|GNU GPL v2+\|[[AIInterface:Java\|Java]]}}

	== ModularAI ==		== ModularAI ==

	The ModularAI wrapper is a wrapper ~~around~~ the [http://springrts.com/wiki/AIInterface:Java Java Interface]. It divides AI functionality up in modules. Each module is self-contained, easily customizable and can be swapped for any the module serving the same function without breaking the AI.		The ModularAI wrapper is a wrapper for the [http://springrts.com/wiki/AIInterface:Java Java AI Interface]. It divides AI functionality up in modules. Each module is self-contained, easily customizable and can be swapped for any the module serving the same function without breaking the AI.

	The design goal of the ModularAI wrapper is to provide the AI developer with easily customizable default ~~behaviour~~ as well as the ability to add his or her own, without hiding any of the full power of the Java interface underneath.		The design goal of the ModularAI wrapper is to provide the AI developer with easily customizable default behavior as well as the ability to add his or her own, without hiding any of the full power of the Java interface underneath.

	PM LoidThanead for a copy of the latest version.		PM LoidThanead for a copy of the latest version.
Line 10:		Line 12:
	=== Overview ===		=== Overview ===

	A ModularAI consists of a collection of modules. Each module is responsible for one aspect of the AI's ~~behaviour~~. The ~~behaviour~~ of a module could be to manage the AI's ~~contruction~~ queue. Another module might be used to plan and/or execute attacks.		A ModularAI consists of a collection of modules. Each module is responsible for one aspect of the AI's behavior. The behavior of a module could be to manage the AI's construction queue. Another module might be used to plan and/or execute attacks.

	The AI communicates with the modules through Messages. When an event happens in the game, all modules are notified. Modules can also communicate with one another through messages.		The AI communicates with the modules through Messages. When an event happens in the game, all modules are notified. Modules can also communicate with one another through messages.

	To simplify unit handling, the ModularAI wrapper introduces the SimpleUnit. This is a wrapper around the Unit object that provides a convenient interface for giving orders to units. It also makes the unit's properties (i.e. current/max speed, current/max health, available weapons etc) easily accessible.		To simplify unit handling, the ModularAI wrapper introduces the <code>SimpleUnit</code>. This is a wrapper around the Unit object that provides a convenient interface for giving orders to units. It also makes the unit's properties (i.e. current/max speed, current/max health, available weapons etc) easily accessible.


Line 48:		Line 50:
	As is customary, the details of creating an <code>ModularAI</code> that actually does something will be explained through an example that shows how to build a solar plant in the BA mod.		As is customary, the details of creating an <code>ModularAI</code> that actually does something will be explained through an example that shows how to build a solar plant in the BA mod.

	The <code>DefaultModularAI</code> that our AI extends has all the required modules to do the building for us. The only thing we still need to tell it is what to build and when. Therefore, we will create a module, <code>ControlModule</code>, that makes the ~~nescessary~~ decisions.		The <code>DefaultModularAI</code> that our AI extends has all the required modules to do the building for us. The only thing we still need to tell it is what to build and when. Therefore, we will create a module, <code>ControlModule</code>, that makes the necessary decisions.


Line 57:		Line 59:
	First we create the <code>ControlModule</code> class. Creating a new module is as easy as creating a class that extends AbstractAIModule. You will need to create a constructor with parameters <code>OOAICallback callback</code> and <code>int updateInterval</code>.		First we create the <code>ControlModule</code> class. Creating a new module is as easy as creating a class that extends AbstractAIModule. You will need to create a constructor with parameters <code>OOAICallback callback</code> and <code>int updateInterval</code>.

	The callback enables your module to retrieve information from the engine as well as give commands. Note that giving commands to the engine should not be ~~nescessary~~, as for most actions that require you to talk to the engine directly there are more convenient methods available that do the work for you.		The callback enables your module to retrieve information from the engine as well as give commands. Note that giving commands to the engine should not be necessary, as for most actions that require you to talk to the engine directly there are more convenient methods available that do the work for you.
	For example, units can be ordered around using the appropriate method. Moving a unit is achieved by using the method <code>moveTo()</code>, which takes the position to move to as its parameter, and will issue to appropriate move order for you.		For example, units can be ordered around using the appropriate method. Moving a unit is achieved by using the method <code>moveTo()</code>, which takes the position to move to as its parameter, and will issue to appropriate move order for you.

Line 72:		Line 74:
	</code>		</code>

	We simple delegate the work to the constructor of <code>AbstractAIModule</code>. It is often a good idea to let the AI that uses a module specify the updateInterval, rather than ~~hardcoding~~ it inside the module. This is because an AI with many light-weight modules may be able to update modules that perform heavy calculations more often, while other AI's may wish to do it the other way around.		We simple delegate the work to the constructor of <code>AbstractAIModule</code>. It is often a good idea to let the AI that uses a module specify the updateInterval, rather than hard-coding it inside the module. This is because an AI with many light-weight modules may be able to update modules that perform heavy calculations more often, while other AI's may wish to do it the other way around.


Line 78:		Line 80:
	To let our AI build a unit, we need a <code>BuildUnitCommand</code>. In its simplest form, the <code>BuildUnitCommand</code> constructor takes two arguments: a priority and an instance of <code>BuildProperties</code>.		To let our AI build a unit, we need a <code>BuildUnitCommand</code>. In its simplest form, the <code>BuildUnitCommand</code> constructor takes two arguments: a priority and an instance of <code>BuildProperties</code>.

	The priority of a <code>BuildUnitCommand</code> works much the same as the priority of a module: the lower the priority number and the earlier the position in the build order queue. The difference is that a build order with a higher priority is not ~~nescessarily~~ fulfilled first. The BuildManager keeps track of which available units can be used to fulfill which requests. When a requests prerequisites are met, it assigns the required units to the module that issued the request. When two requests can be fulfilled using the same units, the request priority comes into play: the request with higher priority is processed, while the other one will have to wait for another usable unit to become available.		The priority of a <code>BuildUnitCommand</code> works much the same as the priority of a module: the lower the priority number and the earlier the position in the build order queue. The difference is that a build order with a higher priority is not necessarily fulfilled first. The <code>BuildManager</code> keeps track of which available units can be used to fulfill which requests. When a requests prerequisites are met, it assigns the required units to the module that issued the request. When two requests can be fulfilled using the same units, the request priority comes into play: the request with higher priority is processed, while the other one will have to wait for another usable unit to become available.

	The second parameter, <code>buildProperties</code>, describes the details of the build command. The minimum information needed for a build command is the type of unit you would like to build. For all other properties (i.e. build position, number of units to build) defaults are used when they are not specified.		The second parameter, <code>buildProperties</code>, describes the details of the build command. The minimum information needed for a build command is the type of unit you would like to build. For all other properties (i.e. build position, number of units to build) defaults are used when they are not specified.
Line 141:		Line 143:

	And with this, our AI should start the game by building a solar plant.		And with this, our AI should start the game by building a solar plant.

			''' [[AIs\|<- Back to AI page]]'''

			[[Category: AI]]
			[[Category: AIWrapper]]
			[[Category: Development]]

Hoijui: typos

2009-07-23T21:04:32Z

typos

← Older revision		Revision as of 22:04, 23 July 2009
Line 48:		Line 48:
	As is customary, the details of creating an <code>ModularAI</code> that actually does something will be explained through an example that shows how to build a solar plant in the BA mod.		As is customary, the details of creating an <code>ModularAI</code> that actually does something will be explained through an example that shows how to build a solar plant in the BA mod.

	The <code>DefaultModularAI</code> that our AI extends has all the required modules to do the building for us. The only thing we still need to tell it is what to build and when. ~~Therefor~~, we will create a module, <code>ControlModule</code>, that makes the nescessary decisions.		The <code>DefaultModularAI</code> that our AI extends has all the required modules to do the building for us. The only thing we still need to tell it is what to build and when. Therefore, we will create a module, <code>ControlModule</code>, that makes the nescessary decisions.


Line 78:		Line 78:
	To let our AI build a unit, we need a <code>BuildUnitCommand</code>. In its simplest form, the <code>BuildUnitCommand</code> constructor takes two arguments: a priority and an instance of <code>BuildProperties</code>.		To let our AI build a unit, we need a <code>BuildUnitCommand</code>. In its simplest form, the <code>BuildUnitCommand</code> constructor takes two arguments: a priority and an instance of <code>BuildProperties</code>.

	The priority of a <code>BuildUnitCommand</code> works much the same as the priority of a module: the lower the priority number and the earlier the position in the build order queue. The difference is that a build order with a higher priority is not nescessarily fulfilled first. The BuildManager keeps track of which available units can be used to ~~fullfil~~ which requests. When a ~~request can completed~~ it assigns the required units to the module that issued the request. ~~The priority is used when~~ two requests can be fulfilled using the same units: the request with higher priority is ~~completed~~, the other will have to wait for another usable unit to become available.		The priority of a <code>BuildUnitCommand</code> works much the same as the priority of a module: the lower the priority number and the earlier the position in the build order queue. The difference is that a build order with a higher priority is not nescessarily fulfilled first. The BuildManager keeps track of which available units can be used to fulfill which requests. When a requests prerequisites are met, it assigns the required units to the module that issued the request. When two requests can be fulfilled using the same units, the request priority comes into play: the request with higher priority is processed, while the other one will have to wait for another usable unit to become available.

	The second parameter, <code>buildProperties</code>, describes the details of the build command. The minimum information needed for a build command is the type of unit you would like to build. For all other properties (i.e. build position, number of units to build) defaults are used when they are not specified.		The second parameter, <code>buildProperties</code>, describes the details of the build command. The minimum information needed for a build command is the type of unit you would like to build. For all other properties (i.e. build position, number of units to build) defaults are used when they are not specified.

Hoijui: typo fixed

2009-07-23T14:04:43Z

typo fixed

← Older revision		Revision as of 15:04, 23 July 2009
Line 53:		Line 53:
	==== Creating a new Module====		==== Creating a new Module====

	We require a custom module that ~~sends~~ tells our AI what to build. Technically, we could do this in the <code>MyModularAI</code> class, but this defeats the purpose of making the AI modular. Therefor, we create a new module, <code>ControlModule</code>, that tells the built-in <code>BuildManager</code> module that it has to build a solar plant.		We require a custom module that tells our AI what to build. Technically, we could do this in the <code>MyModularAI</code> class, but this defeats the purpose of making the AI modular. Therefor, we create a new module, <code>ControlModule</code>, that tells the built-in <code>BuildManager</code> module that it has to build a solar plant.

	First we create the <code>ControlModule</code> class. Creating a new module is as easy as creating a class that extends AbstractAIModule. You will need to create a constructor with parameters <code>OOAICallback callback</code> and <code>int updateInterval</code>.		First we create the <code>ControlModule</code> class. Creating a new module is as easy as creating a class that extends AbstractAIModule. You will need to create a constructor with parameters <code>OOAICallback callback</code> and <code>int updateInterval</code>.

Loidthanead at 12:45, 2 July 2009

2009-07-02T12:45:44Z

Show changes

Loidthanead at 13:28, 27 June 2009

2009-06-27T13:28:58Z

← Older revision		Revision as of 14:28, 27 June 2009
Line 31:		Line 31:

	As you can see, the super constructor has two arguments. The first is the callback, which allows modules to communicate with the game engine.		As you can see, the super constructor has two arguments. The first is the callback, which allows modules to communicate with the game engine.
	The second parameter, <code>updateInterval</code>, tells the module how often it should update. A module is updated at frame 1, and every x frames after that, where x is the update interval. So a module with an update interval of 100 is updated at frames 1, 100, 200, etc.		The second parameter, <code>updateInterval</code>, tells the module how often it should update. The choice for an interval of 6 is only an example. At 1x speed, this interval means that every component updates once per second.
	The smallest possible update interval is 1, which means that the module ~~will get updated~~ every frame. This is 6 times per second at 1x speed! Obviously, you will want to keep update intervals reasonable for modules that perform heavy calculations at updates.
			A module is updated at frame 1, and every x frames after that, where x is the update interval. So a module with an update interval of 100 is updated at frames 1, 100, 200, etc.
			The smallest possible update interval is 1, which means that the module updates every frame. This is 6 times per second at 1x speed! Obviously, you will want to keep update intervals reasonable for modules that perform heavy calculations at updates.
	If you do not want a module to update besides the first frame, set the updateInterval to 0. For suggestions about appropriate update intervals, you should consult the documentation for the module in question.		If you do not want a module to update besides the first frame, set the updateInterval to 0. For suggestions about appropriate update intervals, you should consult the documentation for the module in question.
	Most of the modules provided in <code>DefaultModularAI</code> do not require updating at all, and none require heavy computation.		Most of the modules provided in <code>DefaultModularAI</code> do not require updating at all, and none require heavy computation.

Loidthanead: Simplified the text to describe only how to build a simple ModularAI. For further information contact the author or consult the javadoc.

2009-06-27T13:26:07Z

Simplified the text to describe only how to build a simple ModularAI. For further information contact the author or consult the javadoc.

← Older revision		Revision as of 14:26, 27 June 2009
Line 19:		Line 19:
	=== Use ===		=== Use ===

	To use the ModularAI wrapper, you should first have a regular Java AI set up, as described in [[AI:Development:Lang:Java]]. Next, add the ModularAI.jar file to your project. (Make sure it is located in the ''jlib'' subdirectory of your AI's folder.) Then, instead of having <code>MyJavaAI</code> extend <code>AbstractOOAI</code>, extend <code>DefaultModularAI</code> ~~(or <code>ModularAI</code>)~~.		To use the ModularAI wrapper, you should first have a regular Java AI set up, as described in [[AI:Development:Lang:Java]]. Next, add the ModularAI.jar file to your project. (Make sure it is located in the ''jlib'' subdirectory of your AI's folder.) Then, instead of having <code>MyJavaAI</code> extend <code>AbstractOOAI</code>, extend <code>DefaultModularAI</code>.

	<code>~~ModularAI~~</code> ~~differs from <code>AbstractOOAI</code> in~~ a ~~number of small but significant ways. Firstly~~, ~~it overwrites all of <code>AbstractOOAI</code>'s methods in order~~ to ~~provide its modules with information about any event that happens~~. ~~This means you should not use the different event methods, nor~~ <code>~~init~~()~~</code> or <code>update~~()</code>.		<code>DefaultModularAI</code> has a constructor, which your AI class will need to call. Your constructor may look something like this:
	If you ~~intend to strictly use modules to build your AI (as is recommended)~~, ~~you won't need these methods~~.
	~~However~~, ~~there may be situations in~~ which ~~it is convenient to still be able to have your main AI class respond~~ to ~~these events, so ModularAI provides you~~ with ~~alternatives~~.		<code>
	~~Instead of~~ <code>~~init()~~</code> ~~and <code>~~update~~()</code>~~, ~~use <code>initAI()</code>~~ and ~~<code>updateAI()</code>. These are called immediately~~ after ~~<code>ModularAI~~.update~~()</code> and <code>ModularAI.init()</code>~~.		public MyModularAI(OOAICallback callback)
	~~Instead of the event methods~~, ~~overwrite~~ the ~~method <code>receiveMessage()</code>~~. ~~<code>ModularAI</code>'s <code>receiveMessage()</code> method works identically~~ to ~~the equally named method of~~ a module, ~~which is explained below in~~ the ~~section 'creating a new Module~~.'		{
	~~Alternatively~~, if you ~~overwrite any~~ of ~~<code>AbstractOOAI</code>'s methods yourself you can first call~~ the ~~appropiate method of~~ <code>~~ModularAI~~</code>. ~~(I.e.: call <code>super.update(frame)</code>.)~~		super(callback, 6);
			}
			</code>

			As you can see, the super constructor has two arguments. The first is the callback, which allows modules to communicate with the game engine.
			The second parameter, <code>updateInterval</code>, tells the module how often it should update. A module is updated at frame 1, and every x frames after that, where x is the update interval. So a module with an update interval of 100 is updated at frames 1, 100, 200, etc.
			The smallest possible update interval is 1, which means that the module will get updated every frame. This is 6 times per second at 1x speed! Obviously, you will want to keep update intervals reasonable for modules that perform heavy calculations at updates.
			If you do not want a module to update besides the first frame, set the updateInterval to 0. For suggestions about appropriate update intervals, you should consult the documentation for the module in question.
			Most of the modules provided in <code>DefaultModularAI</code> do not require updating at all, and none require heavy computation.

	At this point, you technically have a working ModularAI. You may want to export your code and see if there are no errors. However, to make full use of the ModularAI wrapper you will need to know how to use modules.		At this point, you technically have a working ModularAI. You may want to export your code and see if there are no errors. However, to make full use of the ModularAI wrapper you will need to know how to use modules.

			At this point, you technically have a working ModularAI. You may want to export your code and see if there are no errors when you run it. As you may see, your AI does not do anything yet. In order to have your AI do anything intelligent, you will need to add and communicate with its modules. Since you will likely want to add custom behaviour to the AI, you will need to create your own module(s).


			=== Getting your AI to Do Something ===

			As is customary, the details of creating an <code>ModularAI</code> that actually does something will be explained through an example that shows how to build a solar plant in the BA mod.


	==== Adding a module ====		==== Adding a module ====

	If you extended <code>DefaultModularAI</code>, your AI already has ~~a number of~~ modules available. ~~However~~, ~~you~~ will ~~likely want to add~~ your ~~own module(s)~~.		If you extended <code>DefaultModularAI</code>, your AI already has the required modules available. For the sake of this example, we will assume that your AI extends <code>ModularAI</code> instead.

	~~Technically, you can add modules at any time. However, for most practical purposes~~ the constructor of ~~<code>MyJavaAI</code> is the most logical place~~. The method <code>addModule()</code> is used to add a new module. This method comes in two variants. The first only takes the module that you wish to add as its argument. The second also lets you specify a priority.		Modules are best added in the constructor of your AI class.
			The method <code>addModule()</code> is used to add a new module. This method comes in two variants. The first only takes the module that you wish to add as its argument. The second also lets you specify a priority.
	This priority determines in what order modules are notified of events, as well as the sequence in which they are initialized and updated. This can be important if, for example, the initialization of a component requires another component to be already initialized.		This priority determines in what order modules are notified of events, as well as the sequence in which they are initialized and updated. This can be important if, for example, the initialization of a component requires another component to be already initialized.
	Note that a lower priority number means a higher priority. A module with priority 1 will be initialized, updated and ~~notifief~~ of events before any module with priority 2. The priority number works as an index in a list. The order in which two modules with the same priority number are handled is undefined, and may vary from moment to moment.		Note that a lower priority number means a higher priority. A module with priority 1 will be initialized, updated and notified of events before any module with priority 2. The priority number works as an index in a list. The order in which two modules with the same priority number are handled is undefined, and may vary from moment to moment.
	If no priority is specified for a module, it is given a default priority of 10.		If no priority is specified for a module, it is given a default priority of 10.

			In order to let your AI build a solar plant, you will need the module <code>BuildManager</code>. This module comes standard with the ModularAI.jar library.
			The BuildManager makes use of another module, UnitPool, which we will have to add as well. Since the BuildManager depends on UnitPool, the unitpool should have a lower priority number, to make sure it is initialized first.

			To be able to use the <code>BuildManager</code>, your AI's constructor should look like this:

			<code>
			public MyModularAI(OOAICallback callback)
			{
			super(callback, 6)
			this.addModule(5, new UnitPool(callback, 6));
			this.addModule(10, new BuildManager(callback, 6));
			}
			</code>

			A <code>UnitPool</code> is added with a priority number of 5, and a <code>BuildManager</code>

			Now that we have added the <code>BuildManager</code>, we will need to send it orders. In the next section, we will create a module to do exactly that.


	==== Creating a new Module====		==== Creating a new Module====

			In order to make use of the <code>BuildManager</code>, we need a custom module that sends it orders. Technically, we could do this in the <code>MyModularAI</code> class, but this defeats the purpose of making the AI modular. Therefor, we create a new module, <code>MyModule</code>, that tells the <code>BuildManager</code> that it has to build a solar plant.

			First we create the <code>MyModule</code> class. Creating a new module is as easy as creating a class that extends AbstractAIModule. You will need to create a constructor with parameters <code>OOAICallback callback</code> and <code>int updateInterval</code>.

			The callback enables your module to retrieve information from the engine as well as give commands. Note that giving commands to the engine should not be nescessary, as for most actions that require you to talk to the engine directly there are more convenient methods available that do the work for you.
			For example, units can be ordered around using the appropriate method. Moving a unit is achieved by using the method <code>moveTo()</code>, which takes the position to move to as its parameter, and will issue to appropriate move order for you.
			The most important method of a <code>Module</code> is <code>receiveMessage()</code>. This method takes as argument a <code>Message</code> object, which


			==== Recieving and sending messages ====

			Any internal communication in a ModularAI is done through Messages. In order to receive messages,

			As explained in [[AI:Development:Lang:Java]], the AI is informed of any events that happen inside the game. In a standard Java AI, this is done by calling an event method, such as <code>unitCreated()</code> or <code>enemyDestroyed()<code>.
			<code>ModularAI</code> instead creates a <code>Message</code> for every event

	~~==== Communicating with a module ====~~

Loidthanead at 10:31, 9 June 2009

2009-06-09T10:31:42Z

← Older revision		Revision as of 11:31, 9 June 2009
Line 35:		Line 35:
	If you extended <code>DefaultModularAI</code>, your AI already has a number of modules available. However, you will likely want to add your own module(s).		If you extended <code>DefaultModularAI</code>, your AI already has a number of modules available. However, you will likely want to add your own module(s).

	Technically, you can add modules at any time. However, for most practical purposes, the constructor of <code>MyJavaAI</code> is the most logical place. The method <code>addModule()</code> is used to add a new module. This method comes in two variants. The first only takes the module that you wish to add as its argument. The second also lets you specify a priority.		Technically, you can add modules at any time. However, for most practical purposes the constructor of <code>MyJavaAI</code> is the most logical place. The method <code>addModule()</code> is used to add a new module. This method comes in two variants. The first only takes the module that you wish to add as its argument. The second also lets you specify a priority.
	This priority determines in what order modules are notified of ~~any~~ events, as well as the sequence in which they are updated ~~and initialized~~. This can be important if for example the initialization of a component requires another component to be already initialized.		This priority determines in what order modules are notified of events, as well as the sequence in which they are initialized and updated. This can be important if, for example, the initialization of a component requires another component to be already initialized.
	Note that a priority number means a higher priority. A module with priority 1 will be ~~treated~~ before a module with priority 2. The priority number works as an index in a list. The order in which two modules with the same priority number are handled is undefined, and may vary from moment to moment.		Note that a lower priority number means a higher priority. A module with priority 1 will be initialized, updated and notifief of events before any module with priority 2. The priority number works as an index in a list. The order in which two modules with the same priority number are handled is undefined, and may vary from moment to moment.
	If no priority is specified for a module, it is given a default priority of 10.		If no priority is specified for a module, it is given a default priority of 10.

Loidthanead at 10:29, 9 June 2009

2009-06-09T10:29:30Z

← Older revision		Revision as of 11:29, 9 June 2009
Line 35:		Line 35:
	If you extended <code>DefaultModularAI</code>, your AI already has a number of modules available. However, you will likely want to add your own module(s).		If you extended <code>DefaultModularAI</code>, your AI already has a number of modules available. However, you will likely want to add your own module(s).

	~~Adding a module is straightforward~~. ~~In <code>MyJavaAI</code>~~, ~~either in~~ the constructor or <code>~~initAI()~~</code> ~~(or <code>init()</code>, if you made sure to call <code>super~~.~~init()</code>), use the~~ method <code>addModule()</code> to add a new module. This method comes in two variants. The first only takes the module that you wish to add as its argument. The second also lets you specify a priority.		Technically, you can add modules at any time. However, for most practical purposes, the constructor of <code>MyJavaAI</code> is the most logical place. The method <code>addModule()</code> is used to add a new module. This method comes in two variants. The first only takes the module that you wish to add as its argument. The second also lets you specify a priority.
	This priority determines in what order modules are notified of any events, as well as the sequence in which they are updated and initialized. This can be important if for example the initialization of a component requires another component to be already initialized.		This priority determines in what order modules are notified of any events, as well as the sequence in which they are updated and initialized. This can be important if for example the initialization of a component requires another component to be already initialized.
	Note that a priority number means a higher priority. A module with priority 1 will be treated before a module with priority 2. The priority number works as an index in a list. The order in which two modules with the same priority number are handled is undefined, and may vary from moment to moment.		Note that a priority number means a higher priority. A module with priority 1 will be treated before a module with priority 2. The priority number works as an index in a list. The order in which two modules with the same priority number are handled is undefined, and may vary from moment to moment.

Loidthanead at 10:27, 9 June 2009

2009-06-09T10:27:21Z

← Older revision		Revision as of 11:27, 9 June 2009
Line 38:		Line 38:
	This priority determines in what order modules are notified of any events, as well as the sequence in which they are updated and initialized. This can be important if for example the initialization of a component requires another component to be already initialized.		This priority determines in what order modules are notified of any events, as well as the sequence in which they are updated and initialized. This can be important if for example the initialization of a component requires another component to be already initialized.
	Note that a priority number means a higher priority. A module with priority 1 will be treated before a module with priority 2. The priority number works as an index in a list. The order in which two modules with the same priority number are handled is undefined, and may vary from moment to moment.		Note that a priority number means a higher priority. A module with priority 1 will be treated before a module with priority 2. The priority number works as an index in a list. The order in which two modules with the same priority number are handled is undefined, and may vary from moment to moment.
			If no priority is specified for a module, it is given a default priority of 10.