Multi Theft Auto: Wiki - User contributions [en]

IsObjectInACLGroup

2024-05-13T20:48:49Z

Citizen: Updated both examples to look nicer (didn't change what they do) and not display bad practices (like global variables) so new devs can learn with good code

__NOTOC__
{{Server function}}
{{Important Note|You must '''NOT''' to use this function to limit features to users that belong to specific groups. Instead you '''MUST''' use [[hasObjectPermissionTo]]. Using this function forces the server owner to name their group a certain way, whereas using hasObjectPermissionTo allows the owner to give permission for whatever features you restrict to whatever groups they have set up in their ACL.}}
This function is used to determine if an object is in a group.

==Syntax==
<syntaxhighlight lang="lua">
bool isObjectInACLGroup ( string theObjectName, aclgroup theGroup )
</syntaxhighlight>
{{New feature/item|3.0141|1.4.0|6994|{{OOP||[[aclgroup]]:doesContainObject||}}}}
===Required Arguments===
*'''theObjectName:''' the name of the object to check. Examples: "resource.ctf", "user.Jim".
*'''theGroup:''' the [[AclGroup|ACL group]] pointer of the group from which the object should be found.

===Returns===
Returns ''true'' if the object is in the specified group, ''false'' otherwise.

==Example==
''' Example 1:''' This example adds a ''jetpack'' command that is only available to admins. When entering the command, it will toggle the player's jetpack.
<syntaxhighlight lang="lua">
addCommandHandler ( "jetpack", function ( thePlayer )
if doesPedHaveJetPack ( thePlayer ) then -- If the player have a jetpack already, remove it
removePedJetPack ( thePlayer ) -- Remove the jetpack
return -- And stop the function here
end

-- Otherwise, give him one if he has access

local accName = getAccountName ( getPlayerAccount ( thePlayer ) ) -- get his account name
if isObjectInACLGroup ("user."..accName, aclGetGroup ( "Admin" ) ) then -- Does he have access to Admin functions?
if not doesPedHaveJetPack ( thePlayer ) then -- If the player doesn't have a jetpack give it.
givePedJetPack ( thePlayer ) -- Give the jetpack
end
end
end)
</syntaxhighlight>

'''Example 2:''' This example displays a list of all the online admins in the chat box (assuming your administrator's group in your ACL is called 'Admin'):
<syntaxhighlight lang="lua">
local admins = ""
local players = getElementsByType("player")
for k, v in ipairs(players) do
if not isGuestAccount(getPlayerAccount(v)) then
local accountName = getAccountName(getPlayerAccount(v))
if isObjectInACLGroup("user." .. accountName, aclGetGroup("Admin")) then
if admins == "" then
admins = getPlayerName(v)
else
admins = admins .. ", " .. getPlayerName(v)
end
end
end
end
outputChatBox("Online Admins:", getRootElement(), 255, 255, 0)
outputChatBox(" " .. admins, getRootElement(), 255, 255, 0)
</syntaxhighlight>

==See Also==
{{ACL_functions}}
[[zh-cn:IsObjectInACLGroup]]

FetchRemote

2020-11-18T15:30:23Z

Citizen: Fixed linked to mailgun's doc

__NOTOC__
{{Server client function}}
This function allows you to post and receive data from HTTP servers. The calls are asynchronous so you do not get an immediate result from the call, instead a callback function you specify is called when the download completes.

In the case when the call fails, a string containing "ERROR" followed by an integer containing the error reason will be passed to the callback function. The reason for failure will be similar to errors found with websites - file not found, server not found and timeouts.

If you are using fetchRemote to connect to a PHP script, you can use ''file_get_contents("php://input")'' to read the '''postData''' sent from this function.
{{Note|Client side function only works with the server the player is connected to unless the domain has been accepted with [[requestBrowserDomains]]}}
{{ Warning| function won't trigger inside another fetchRemote function }}
==Syntax==
<syntaxhighlight lang="lua">
bool fetchRemote ( string URL, [ string queueName = "default" ], [ int connectionAttempts = 10, int connectTimeout = 10000 ], function callbackFunction, [ string postData = "", bool postIsBinary = false ], [ arguments... ] )
</syntaxhighlight>

===Required Arguments===
*'''URL:''' A full URL in the format ''<nowiki>http://hostname/path/file.ext</nowiki>''. A port can be specified with a colon followed by a port number appended to the hostname.
*'''callbackFunction:''' This is the function that should receive the data returned from the remote server. The callback argument list should be:
**'''''responseData''''' - A string containing the remote response or "ERROR" if there was a problem
**'''''error''''' - A number containing the error number or zero if there was no error. A list of possible error values are:
{{Error_codes_for_callRemote_and_fetchRemote}}
<div style="padding-left:19px;">
*'''''arguments...''''' - The arguments that were passed into fetchRemote
</div>

===Optional Arguments===
{{New items|4.0153|1.5.3-9.11270|
*'''queueName:''' Name of the queue to use. Any name can be used. If not set, the queue name is "default". Requests in the same queue are processed in order, one at a time.
}}
*'''connectionAttempts:''' Number of times to retry if the remote host does not respond. ''In the case of a non-responding remote server, each connection attempt will timeout after 10 seconds. Therefore, the default setting of 10 connection attempts means it will be 100 seconds before your script gets a callback about the error. Reducing this value to 2 for example, will decrease that period to 20 seconds''
*'''connectTimeout:''' Number of milliseconds each connection attempt will take before timing out
*'''postData:''' A string specifying any data you want to send to the remote HTTP server.
*'''postIsBinary :''' A boolean specifying if the data is text, or binary.
*'''arguments:''' Any arguments you may want to pass to the callback.

{{New items|5.0154|1.5.4-9.11342|
==Syntax==
<syntaxhighlight lang="lua">
bool fetchRemote ( string URL[, table options ], callback callbackFunction[, table callbackArguments ] )
</syntaxhighlight>

===Required Arguments===
*'''URL:''' A full URL in the format ''<nowiki>http://hostname/path/file.ext</nowiki>''. A port can be specified with a colon followed by a port number appended to the hostname.
*'''callbackFunction:''' This is the function that should receive the data returned from the remote server. The callback argument list should be:
**'''''responseData''''' - A string containing the remote response
**'''''responseInfo''''' - A table containing:
***'''''success''''' - A boolean indicating if the request was successful.
***'''''statusCode''''' - An integer status/error code
***'''''headers''''' - A table containing the HTTP response headers
**'''''arguments...''''' - The arguments that were passed into fetchRemote

===Optional Arguments===
*'''options:''' A table containing any request options:
**'''queueName:''' Name of the queue to use. Any name can be used. If not set, the queue name is "default". Requests in the same queue are processed in order, one at a time.
**'''connectionAttempts:''' Number of times to retry if the remote host does not respond. ''(Defaults to 10)''
**'''connectTimeout:''' Number of milliseconds each connection attempt will take before timing out. ''(Defaults to 10000)''
**'''postData:''' A string specifying any data you want to send to the remote HTTP server.
**'''postIsBinary :''' A boolean specifying if the data is text, or binary. ''(Defaults to false)''
**'''method:''' A string specifying the request method. ''(Defaults to GET or POST)''
**'''headers:''' A table containing HTTP request headers. ''e.g.{ Pragma="no-cache" }''
**'''maxRedirects:''' An integer limiting the number of HTTP redirections to automatically follow. ''(Defaults to 8)''
**'''username:''' A string specifying the username for protected pages.
**'''password:''' A string specifying the password for protected pages.
{{New items|5.0154|1.5.4-9.11413|
**'''formFields:''' A table containing form items to submit. (for POST method only) ''e.g.{ name="bob", email="bob@example.com" }''
}}
*'''arguments:''' A table containing arguments you may want to pass to the callback.
}}

===Returns===
{{New items|5.0154|1.5.7-9.20307|
Returns a '''''request''''' value which can be used with [[GetRemoteRequestInfo|getRemoteRequestInfo]] or [[AbortRemoteRequest|abortRemoteRequest]]
}}

==Example==
This example shows you how you can fetch an image from a web page, and transfer it to a particular client:
<section name="Server" class="server" show="true">
<syntaxhighlight lang="lua">

function startImageDownload( playerToReceive )
fetchRemote ( "http://www.example.com/image.jpg", myCallback, "", false, playerToReceive )
end

function myCallback( responseData, error, playerToReceive )
if error == 0 then
triggerClientEvent( playerToReceive, "onClientGotImage", resourceRoot, responseData )
end
end
</syntaxhighlight>
</section>
<section name="Client" class="client" show="true">
<syntaxhighlight lang="lua">
addEvent( "onClientGotImage", true )
addEventHandler( "onClientGotImage", resourceRoot,
function( pixels )
if myTexture then
destroyElement( myTexture )
end
myTexture = dxCreateTexture( pixels )
end
)

addEventHandler("onClientRender", root,
function()
if myTexture then
local w,h = dxGetMaterialSize( myTexture )
dxDrawImage( 200, 100, w, h, myTexture )
end
end
)
</syntaxhighlight>
</section>
<br/>
{{New items|5.0154|1.5.4-9.11413|
Example sending email via a web service (adopted from examples on https://documentation.mailgun.com/en/latest/user_manual.html)
<section name="Server" class="server" show="true">
<syntaxhighlight lang="lua">
sendOptions = {
queueName = "My Mailgun queue",
connectionAttempts = 3,
connectTimeout = 5000,
formFields = {
from="Excited User <excited@samples.mailgun.org>",
to="devs@mailgun.net",
subject="Hello",
text="Testing some Mailgun awesomness!",
},
username="api",
password="key-3ax6xnjp29jd6fds4gc373sgvjxteol0",
}
fetchRemote( "https://api.mailgun.net/v3/samples.mailgun.org/messages", sendOptions, mailgunCompleteCallback )

function mailgunCompleteCallback(data, info)
outputDebugString( "mailgunComplete"
.. " success:" .. tostring(info.success)
.. " statusCode:" .. tostring(info.statusCode)
.. " data:" .. tostring(data)
)
end
</syntaxhighlight>
</section>

Changing post content on IPS forum.
<section name="Server" class="server" show="true">
<syntaxhighlight lang="lua">
local apiKey = "12345678123456781234567812345678" -- key from ips admin panel
local forumAddress = "https://yourForum.com"
function setPostContent(postID,content)
local sendOptions = {
queueName = "updatePost",
connectionAttempts = 1,
connectTimeout = 50,
formFields = {
post = content,
},
}
fetchRemote( forumAddress.."/api/forums/posts/"..postID.."?key="..apiKey, sendOptions, function()end)
end

setPostContent(1, "this is a first post on this forum")
</syntaxhighlight>
</section>
}}

==Requirements==
{{Requirements|1.3.0-9.03739|1.3.2|}}

==Changelog==
{{ChangelogHeader}}
{{ChangelogItem|1.3.1-9.04605|Added connectionAttempts argument}}
{{ChangelogItem|1.3.2|Added client side}}
{{ChangelogItem|1.5.3-9.11270|Added queueName argument}}
{{ChangelogItem|1.5.4-9.11342|Added alternative syntax}}
{{ChangelogItem|1.5.4-9.11413|Added formFields}}

==See Also==
{{Resource_functions}}

Changes in 1.5.8

2020-10-11T20:11:33Z

Citizen:

<pageclass class="#39dd57" subcaption="Current release"></pageclass>
{{Changelogs}}
__NOTOC__
* GitHub commit log: https://github.com/multitheftauto/mtasa-blue/compare/1.5.7...master
* GitHub milestone: https://github.com/multitheftauto/mtasa-blue/milestone/2
* So far https://github.com/multitheftauto/mtasa-blue/compare/6941e0b...master

'''This changelog is partial and needs updating.'''

== Main Additions / Changes ==
<section show="true">
* Add [[dxDrawPrimitive3D]] and [[dxDrawMaterialPrimitive3D]] ([https://github.com/multitheftauto/mtasa-blue/pull/760 #760] by '''CrosRoad95''')
* Add functions to modify dynamic objects' behaviour ([https://github.com/multitheftauto/mtasa-blue/pull/784 #784] by '''forkerer''')
* Add dynamic ped ID allocating using [[engineRequestModel]] and [[engineFreeModel]] ([https://github.com/multitheftauto/mtasa-blue/commit/475544f1753ce1af24c4cdff7f0d0be48ede709b #349] by '''lopezloo''' + '''Neproify''' + '''Arran''' + '''qaisjp''')
* Add functions to manipulate colshapes parameters ([https://github.com/multitheftauto/mtasa-blue/pull/1215 #1215] by '''StrixG''')
* Add element data subscription functionality ([https://github.com/multitheftauto/mtasa-blue/pull/1055 #1055] by '''tederis''')
* Add [[engineGetModelTextures]] function ([https://github.com/multitheftauto/mtasa-blue/pull/1058 #1058] by '''Lpsd''')
* Improve trailer sync ([https://github.com/multitheftauto/mtasa-blue/pull/1247 #1247] by '''tederis''')
</section>
* Added wheel scaling functions ([https://github.com/multitheftauto/mtasa-blue/pull/1641 #1641], [https://github.com/multitheftauto/mtasa-blue/pull/1644 #1644], and [https://github.com/multitheftauto/mtasa-blue/pull/1648 #1648] by '''AlexTMjugador''')

== Statistics ==
<section show="true">
These are some statistics since the [[Changes in 1.5.7|previous release]].
* This is the '''25<sup>th</sup>''' 1.x.x release
* '''{{date difference|2019|8|31}}''' days
* '''1''' deprecation
* '''5''' announced backwards incompatible changes
* '''37''' new functions
* '''61+''' bug fixes and changes
* '''463''' commits ([https://github.com/multitheftauto/mtasa-blue/compare/1.5.7...master see comparison])
* '''196''' new open GitHub issues ([https://github.com/multitheftauto/mtasa-blue/issues?utf8=%E2%9C%93&q=is%3Aopen+is%3Aissue+created%3A%3E%3D2019-08-31 see list])
* '''102''' resolved GitHub issues ([https://github.com/multitheftauto/mtasa-blue/issues?utf8=%E2%9C%93&q=is%3Aclosed+is%3Aissue+milestone%3A1.5.8 see list])
* '''108''' closed GitHub issues ([https://github.com/multitheftauto/mtasa-blue/issues?utf8=%E2%9C%93&q=is%3Aclosed+is%3Aissue+closed%3A%3E%3D2019-08-31+no%3Amilestone see list])
* '''47''' new open GitHub pull requests ([https://github.com/multitheftauto/mtasa-blue/pulls?utf8=%E2%9C%93&q=is%3Aopen+is%3Apr+created%3A%3E%3D2019-08-31 see list])
* '''192''' merged GitHub pull requests ([https://github.com/multitheftauto/mtasa-blue/pulls?q=is%3Apr+milestone%3A1.5.8+is%3Amerged see list])
* '''36''' closed GitHub pull requests ([https://github.com/multitheftauto/mtasa-blue/pulls?utf8=%E2%9C%93&q=is%3Apr+is%3Aunmerged+closed%3A%3E%3D2019-08-31 see list])
* '''37''' contributors of which '''27''' are new ([https://github.com/multitheftauto/mtasa-blue/graphs/contributors?from=2019-08-31&to=2020-08-31&type=c see list])
* '''98+''' total contributors ([https://github.com/multitheftauto/mtasa-blue/graphs/contributors see list])
* '''4''' vendor updates


<sub>'''Note:''' Last update to these statistics was made
{{#ifeq: {{date difference|2020|8|8}} | 0 | today |
{{#ifeq: {{date difference|2020|8|8}} | 1 | yesterday |
{{date difference|2020|8|8}} days ago
}}
}}.</sub>
</section>

== Scripting ==
<section show="true">
=== 5 Backwards Incompatible Changes ===
These changes will take effect in 1.6:
* [[callRemote]] callbacks currently set the error code to '''nil''' when there is no error. In 1.6, to be consistent with [[fetchRemote]], the error code reported will be '''0'''. See [https://github.com/multitheftauto/mtasa-blue/issues/294 GitHub #294].
* Since July 2016 if you provide an invalid string like '''"randomstring"''' when a function expects a number, the string will be treated as '''0''' and raise a script warning. In 1.6 this will be an error. You will still be able to provide strings containing numbers (e.g. '''"100"''' and '''"12.34"'''), this change only affects invalid strings. See [https://github.com/multitheftauto/mtasa-blue/issues/1043 GitHub #1043].
* When providing a width and height of (0, 0) to [[createBrowser]] or [[guiCreateBrowser]] you will encounter a script error instead of a warning. The warning was introduced Feb 2019. See [https://github.com/multitheftauto/mtasa-blue/issues/1069 GitHub #1069].
* Some functions expect only unsigned integers (positive numbers), and since Jan 2016 providing negative numbers would be a warning. This will now be an error. See [https://github.com/multitheftauto/mtasa-blue/issues/1070 GitHub #1070].
* Since Aug 2015, we replaced the custom '''mtalocal://''' URL scheme with '''http://mta/resourceName/blah.html'''. This '''mtalocal://''' URL scheme will now be removed. See [https://github.com/multitheftauto/mtasa-blue/issues/1071 GitHub #1071].

This list is inconclusive and we may introduce more changes later.
</section>

== Client ==
<section show="true">
=== 21 New Functions ===
* Add [[setPedFightingStyle]] (previously available server-side only) ([https://github.com/multitheftauto/mtasa-blue/pull/810 #810] by '''StrixG''')
* Add [[setPedArmor]] (previously available server-side only) ([https://github.com/multitheftauto/mtasa-blue/pull/811 #811] by '''StrixG''')
* Add [[areVehicleLightsOn]] ([https://github.com/multitheftauto/mtasa-blue/pull/938 #938] by '''StrixG''')
* Add [[dxDrawPrimitive3D]] and [[dxDrawMaterialPrimitive3D]] ([https://github.com/multitheftauto/mtasa-blue/pull/760 #760] by '''CrosRoad95''')
* Add functions to modify dynamic objects' behaviour ([https://github.com/multitheftauto/mtasa-blue/pull/784 #784] by '''forkerer''')
** [[engineGetModelPhysicalPropertiesGroup]]
** [[engineRestoreModelPhysicalPropertiesGroup]]
** [[engineSetModelPhysicalPropertiesGroup]]
** [[engineGetObjectGroupPhysicalProperty]]
** [[engineRestoreObjectGroupPhysicalProperties]]
** [[engineSetObjectGroupPhysicalProperty]]
* Add dynamic ped ID allocating using [[engineRequestModel]] and [[engineFreeModel]] ([https://github.com/multitheftauto/mtasa-blue/commit/475544f1753ce1af24c4cdff7f0d0be48ede709b #349] by '''lopezloo''' + '''Neproify''' + '''Arran''' + '''qaisjp''')
* Add [[engineResetModelLODDistance]] function ([https://github.com/multitheftauto/mtasa-blue/pull/971 #971] by '''Lpsd''')
* Add [[engineGetModelTextures]] function ([https://github.com/multitheftauto/mtasa-blue/pull/1058 #1058] by '''Lpsd''')
* Add [[resetBlurLevel]] function ([https://github.com/multitheftauto/mtasa-blue/pull/1266 #1266] by '''Luxy.c''')
* Add [[dxGetTextSize]] function ([https://github.com/multitheftauto/mtasa-blue/pull/935 #935] by '''StrixG''')
* Add functions to modify vehicle wheels, visibly and in collision by ([https://github.com/multitheftauto/mtasa-blue/pull/1641 #1641], [https://github.com/multitheftauto/mtasa-blue/pull/1644 #1644], and [https://github.com/multitheftauto/mtasa-blue/pull/1648 #1648] by '''AlexTMjugador''')
** [[getVehicleWheelScale]]
** [[getVehicleModelWheelSize]]
** [[setVehicleWheelScale]]
** [[setVehicleModelWheelSize]]

=== 45 Bug Fixes & Changes ===
* Add new client setting to toggle external sounds ([https://github.com/multitheftauto/mtasa-blue/pull/834 #834] by '''patrikjuvonen''')
* Fix crash when attempting to stream out a sound that's not streamed in (See commit [https://github.com/multitheftauto/mtasa-blue/commit/e1b7c730448d12a5eeb452239e8053e86924294f e1b7c73] by '''sbx320''')
* Fix [[dxDrawCircle]] ''segments'' argument being wrongly offset by one ([https://github.com/multitheftauto/mtasa-blue/pull/1079 #1079] by '''ApeLsiN4eG''')
* Fix potential crash when moving objects (See commit [https://github.com/multitheftauto/mtasa-blue/commit/90895c221549893501f5f717af3ca56878e29b5d 90895c2] by '''botder''')
* Update credits (See commit [https://github.com/multitheftauto/mtasa-blue/commit/39227d795efafe940dc6c317c20b0162b1bd0bb3 39227d7] by '''qaisjp''')
* Don't apply damage to peds without a game entity (See commit [https://github.com/multitheftauto/mtasa-blue/commit/632130e36a96071290593fc3c677a536f7b19e1f 632130e] by '''botder''')
* Fix doors state with setElementModel ([https://github.com/multitheftauto/mtasa-blue/pull/599 #599] by '''FileEX''')
* Add CVAR _beta_qc_rightclick_command allowing you to reconnect by right clicking the "Quick Connect" button on the main menu (See commit [https://github.com/multitheftauto/mtasa-blue/commit/d1c60675fc0f0f62b69707ae81a82e6bbdf36042 d1c60675] by '''qaisjp''')
* Add more data to [[getPedAnimation]] ([https://github.com/multitheftauto/mtasa-blue/pull/892 #892] by '''Dezash''')
* Add missing destroy method to DxFont ([https://github.com/multitheftauto/mtasa-blue/pull/1259 #1259] by '''MegadreamsBE''')
* Increase [[setPedAnimationSpeed]] limit (See commit [https://github.com/multitheftauto/mtasa-blue/commit/4c36d37056d2a1496904f394bf96303dd0f2b4c5 4c36d37] by '''qaisjp''')
* Fix "ancient" weapon fire crash ([https://github.com/multitheftauto/mtasa-blue/pull/1109 #1109] by '''saml1er''')
* Fix [[bitExtract]] (See commit [https://github.com/multitheftauto/mtasa-blue/commit/aa2df39d3e40e5b446ffea376ef96df89916a9d0 aa2df39d] by '''ccw808''')
* Fix texture blending ([https://github.com/multitheftauto/mtasa-blue/pull/1098 #1098] by '''StrixG''')
* Add client setting to toggle internet sound streams ([https://github.com/multitheftauto/mtasa-blue/pull/834 #834] by '''patrikjuvonen''')
* Implement "remember this option" checkbox to NVidia Optimus dialog ([https://github.com/multitheftauto/mtasa-blue/pull/1177 #1177] by '''Lpsd''')
* Fix inability to crouch when player has 1 HP ([https://github.com/multitheftauto/mtasa-blue/pull/1138 #1138] by '''CrosRoad95''')
* Improve trailer sync ([https://github.com/multitheftauto/mtasa-blue/pull/1247 #1247] by '''tederis''')
* Fix driveby for peds ([https://github.com/multitheftauto/mtasa-blue/pull/1290 #1290] by '''Zangomangu''')
* Add "SettingHighDetailPeds" to [[dxGetStatus]] ([https://github.com/multitheftauto/mtasa-blue/pull/1384 #1384] by '''Patrick''')
* Add feature to remove server from the "Recent" tab in server browser ([https://github.com/multitheftauto/mtasa-blue/pull/1381 #1381] by '''ecastro98''')
* Fix [[warpPedIntoVehicle]] failure when there are too many vehicles streamed in ([https://github.com/multitheftauto/mtasa-blue/pull/1431 #1431] by '''saml1er''')
* Fix issue with [[engineReplaceModel]] kicking the player out of the vehicle ([https://github.com/multitheftauto/mtasa-blue/pull/1433 #1433] by '''saml1er''')
* Moved exe patching to loader ([https://github.com/multitheftauto/mtasa-blue/pull/1520 #1520] by '''ccw808''')
* Fix various return values when using OOP (e.g: [https://github.com/multitheftauto/mtasa-blue/commit/5110559b7a7f2d258f01be1dce18fe63d8bca400 5110559b], [https://github.com/multitheftauto/mtasa-blue/commit/88379b8ded766b2d35e171b6d11ef33cb2663b96 88379b8d] by '''qaisjp''')
* Fixed incorrect VRAM detection ([https://github.com/multitheftauto/mtasa-blue/pull/1589 #1589] by '''TheNormalnij''')
* Add ability to play sounds from raw data to playSound(3D) ([https://github.com/multitheftauto/mtasa-blue/pull/1234 #1234] by '''Dezash''')
* Allow downloading of files from other resources ([https://github.com/multitheftauto/mtasa-blue/pull/945 #945] by '''TheNormalnij''') - this affects:
** [[downloadFile]]
** [[onClientFileDownloadComplete]]
* Add ability to get raw controller analog value ([https://github.com/multitheftauto/mtasa-blue/pull/1165 #1165] by '''Addlibs''')
* Add user agent workaround for YouTube TV ([https://github.com/multitheftauto/mtasa-blue/pull/1243 #1243] by '''qaisjp''')
* Add missing destroy method to DxFont ([https://github.com/multitheftauto/mtasa-blue/pull/1259 #1259] by '''MegadreamsBE''')
* Fix engineReplaceModel memory leak ([https://github.com/multitheftauto/mtasa-blue/pull/1265 #1265] by '''saml1er''')
* Fix vehicle model memory leaks (See commit [https://github.com/multitheftauto/mtasa-blue/commit/46dbbe7dd2c4621d7564cf272e8a432cf9f57300 46dbbe7] by '''saml1er''')
* Fix texture memory leak (See commit [https://github.com/multitheftauto/mtasa-blue/commit/d5722d5ac5c0ed0210849bf03c263ec88ea98c2a d5722d5] by '''saml1er''')
* Enable enter_exit for peds to fix alternative attack ([https://github.com/multitheftauto/mtasa-blue/pull/1295 #1295] by '''Zangomangu''')
* Fix "Select device" hides under other program without MTA icon on a taskbar (See commit [https://github.com/multitheftauto/mtasa-blue/commit/2c5251a42a640ccc9ffa928cb2844c9295f47c6c 2c5251a] by '''ccw808''')
* Fix primitive colors are always white ([https://github.com/multitheftauto/mtasa-blue/pull/1312 #1312] by '''StrixG''')
* Add analog control sync for accelerate and brake_reverse ([https://github.com/multitheftauto/mtasa-blue/pull/1164 #1164] by '''Addlibs''')
* Fix resetting dummies in vehicles with replaced models ([https://github.com/multitheftauto/mtasa-blue/pull/1059 #1059] by '''forkerer''' and '''saml1er''')
* Return vector3 instead of number at ped's target ([https://github.com/multitheftauto/mtasa-blue/pull/1379 #1379] by '''ecastro98''')
* Fix replaced weapon_crouch anim does not play if retainPedState is true ([https://github.com/multitheftauto/mtasa-blue/pull/1414 #1414] by '''saml1er''')
* Fix nametags are interiorless ([https://github.com/multitheftauto/mtasa-blue/commit/3df58bd435b3c4052fa5e7fe57d534bdca7e0d2b 3df58bd] by '''qaisjp''')
* Remove amx from the installer (See commit [https://github.com/multitheftauto/mtasa-blue/commit/7d4091fac6e41e6d9e199cd0a03c927dc48aac79 7d4091f] by '''qaisjp''')
* Potential fix for vehicle dummies crash ([https://github.com/multitheftauto/mtasa-blue/pull/1524 #1524] by '''saml1er''')
* Add projectiles support for [[getElementModel]] ([https://github.com/multitheftauto/mtasa-blue/pull/1550 #1550] by '''StrixG''')

=== 2 Vendor Updates ===
* Update BASS libraries ([https://github.com/multitheftauto/mtasa-blue/pull/1551 #1551] by '''Dutchman101''')
* Update CEF from 76.1.13+gf19c584 (Chromium 76.0.3809.132) to 81.3.10+gb223419 ([https://chromereleases.googleblog.com/2020/05/stable-channel-update-for-desktop.html Chromium 81.0.4044.138]) (See commit [https://github.com/multitheftauto/mtasa-blue/commit/8d2d0fb20fb094119e86e348340f5cb90e30dc16 8d2d0fb] by '''qaisjp''')
</section>

== Server ==
<section show="true">
=== 3 New Functions ===
* Add [[setPlayerScriptDebugLevel]] and [[getPlayerScriptDebugLevel]] ([https://github.com/multitheftauto/mtasa-blue/pull/826 #826] by '''knitz12''')
* Add [[isResourceProtected]] function ([https://github.com/multitheftauto/mtasa-blue/pull/1254 #1254] by '''StrixG''')



=== 9 Bug Fixes & Changes ===
* Fix [[iprint]] to be able to read and output nil arguments properly ([https://github.com/multitheftauto/mtasa-blue/pull/1064 #1064] by '''TheNormalnij''')
* Accept team & table of players in [[outputChatBox]] ([https://github.com/multitheftauto/mtasa-blue/pull/1213 #1213] by '''StrixG''')
* Fix /msg command duplicating when sent by Server Console ([https://github.com/multitheftauto/mtasa-blue/pull/1411 #1411] by '''Dezash''')
* Make colshapes cloneable ([https://github.com/multitheftauto/mtasa-blue/pull/1214 #1214] by '''StrixG''')
* Fix double chat messages if player is in team ([https://github.com/multitheftauto/mtasa-blue/pull/1241 #1241] by '''StrixG''' and '''Luxy.c''')
* Don't queue a resource restart if resource is stopping ([https://github.com/multitheftauto/mtasa-blue/pull/960 #960] by '''StrixG''')
* Add support for more map attributes ([https://github.com/multitheftauto/mtasa-blue/pull/263 #263] by '''patrikjuvonen''')
* Fix server-client inconsistency for isElementAttached failure return ([https://github.com/multitheftauto/mtasa-blue/commit/866506d3f6ebe4a0d4d39664cc4e7d7c0cef1a7c 866506d] by '''qaisjp''')
* Make [[kickPlayer]] accept the Console element as responsiblePlayer ([https://github.com/multitheftauto/mtasa-blue/pull/1427 #1427] by '''qaisjp''')

=== 1 Vendor Update ===
* Update sqlite from 3.31.1 to 3.32.3 ([https://github.com/multitheftauto/mtasa-blue/pull/1561 #1561] by '''patrikjuvonen''')
</section>

== Shared (''Client & Server side'') ==
<section show="true">
=== 17 New Functions ===
* Add [[xmlLoadString]] ([https://github.com/multitheftauto/mtasa-blue/pull/809 #809] by '''Lpsd''')
* Add request info & abort functions for [[fetchRemote]]/[[callRemote]] ([https://github.com/multitheftauto/mtasa-blue/pull/660 #660] by '''Luxy.c''')
** [[getRemoteRequests]]
** [[getRemoteRequestInfo]]
** [[abortRemoteRequest]]
* Add functions to manipulate colshapes parameters ([https://github.com/multitheftauto/mtasa-blue/pull/1215 #1215] by '''StrixG''')
** [[getColShapeRadius]]
** [[setColShapeRadius]]
** [[getColShapeSize]]
** [[setColShapeSize]]
** [[getColPolygonPoints]]
** [[getColPolygonPointPosition]]
** [[setColPolygonPointPosition]]
** [[addColPolygonPoint]]
** [[removeColPolygonPoint]]
* Add [[hasElementData]] function ([https://github.com/multitheftauto/mtasa-blue/pull/1163 #1163] by '''Simi2''')
* Add element data subscription functionality ([https://github.com/multitheftauto/mtasa-blue/pull/1055 #1055] by '''tederis''') - includes 3 new functions:
** [[addElementDataSubscriber]]
** [[removeElementDataSubscriber]]
** [[hasElementDataSubscriber]]
** Adds 1 additional parameter to [[setElementData]]

=== 1 Deprecation ===
* Add deprecation message to [[passwordHash]] when using custom salts ([https://github.com/multitheftauto/mtasa-blue/pull/1208 #1208] by '''Luxy.c''')

=== 7 Bug Fixes & Changes ===
* Add async [[encodeString]]/[[decodeString]] ([https://github.com/multitheftauto/mtasa-blue/pull/1226 #1226] by '''StrixG''')
* Fix colshape and marker hit detection when attaching ([https://github.com/multitheftauto/mtasa-blue/pull/1327 #1327] by '''Lpsd''')
* Fix driveby aiming being inverted in some cases ([https://github.com/multitheftauto/mtasa-blue/pull/1442 #1442] by '''Zangomangu''')
* Add bIncludeWorldSeaLevel and bIncludeOutsideWorldLevel parameters to [[setWaterLevel]] ([https://github.com/multitheftauto/mtasa-blue/pull/1342 #1342] by '''TheNormalnij''')
* Add [[outputDebugString]] level 4 to omit certain debug info ([https://github.com/multitheftauto/mtasa-blue/pull/1167 #1167] by '''Addlibs''')
* Fix incorrect hash capitalisation ([https://github.com/multitheftauto/mtasa-blue/pull/1527 #1527] by '''qaisjp''')
* Trim [[teaEncode]] trailing zeroes ([https://github.com/multitheftauto/mtasa-blue/pull/1534 #1534] by '''Pirulax''')

=== 1 Vendor Update ===
* Update curl from 7.68.0 to 7.69.1 ([https://github.com/multitheftauto/mtasa-blue/pull/1302 #1302] by '''patrikjuvonen''' and '''qaisjp''')
</section>

<section show="true">
== Extra information ==
''More detailed information available on our GitHub repositories:
:* [https://github.com/multitheftauto/mtasa-blue MTA:SA Blue]
:* [https://github.com/multitheftauto/mtasa-resources MTA:SA Official Resources]
</section>

[[Category:Changelog]]
[[Category:Incomplete]]

Changes in 1.5.8

2020-10-11T20:10:54Z

Citizen: making the kickPlayer update info less ambiguous

<pageclass class="#39dd57" subcaption="Current release"></pageclass>
{{Changelogs}}
__NOTOC__
* GitHub commit log: https://github.com/multitheftauto/mtasa-blue/compare/1.5.7...master
* GitHub milestone: https://github.com/multitheftauto/mtasa-blue/milestone/2
* So far https://github.com/multitheftauto/mtasa-blue/compare/6941e0b...master

'''This changelog is partial and needs updating.'''

== Main Additions / Changes ==
<section show="true">
* Add [[dxDrawPrimitive3D]] and [[dxDrawMaterialPrimitive3D]] ([https://github.com/multitheftauto/mtasa-blue/pull/760 #760] by '''CrosRoad95''')
* Add functions to modify dynamic objects' behaviour ([https://github.com/multitheftauto/mtasa-blue/pull/784 #784] by '''forkerer''')
* Add dynamic ped ID allocating using [[engineRequestModel]] and [[engineFreeModel]] ([https://github.com/multitheftauto/mtasa-blue/commit/475544f1753ce1af24c4cdff7f0d0be48ede709b #349] by '''lopezloo''' + '''Neproify''' + '''Arran''' + '''qaisjp''')
* Add functions to manipulate colshapes parameters ([https://github.com/multitheftauto/mtasa-blue/pull/1215 #1215] by '''StrixG''')
* Add element data subscription functionality ([https://github.com/multitheftauto/mtasa-blue/pull/1055 #1055] by '''tederis''')
* Add [[engineGetModelTextures]] function ([https://github.com/multitheftauto/mtasa-blue/pull/1058 #1058] by '''Lpsd''')
* Improve trailer sync ([https://github.com/multitheftauto/mtasa-blue/pull/1247 #1247] by '''tederis''')
</section>
* Added wheel scaling functions ([https://github.com/multitheftauto/mtasa-blue/pull/1641 #1641], [https://github.com/multitheftauto/mtasa-blue/pull/1644 #1644], and [https://github.com/multitheftauto/mtasa-blue/pull/1648 #1648] by '''AlexTMjugador''')

== Statistics ==
<section show="true">
These are some statistics since the [[Changes in 1.5.7|previous release]].
* This is the '''25<sup>th</sup>''' 1.x.x release
* '''{{date difference|2019|8|31}}''' days
* '''1''' deprecation
* '''5''' announced backwards incompatible changes
* '''37''' new functions
* '''61+''' bug fixes and changes
* '''463''' commits ([https://github.com/multitheftauto/mtasa-blue/compare/1.5.7...master see comparison])
* '''196''' new open GitHub issues ([https://github.com/multitheftauto/mtasa-blue/issues?utf8=%E2%9C%93&q=is%3Aopen+is%3Aissue+created%3A%3E%3D2019-08-31 see list])
* '''102''' resolved GitHub issues ([https://github.com/multitheftauto/mtasa-blue/issues?utf8=%E2%9C%93&q=is%3Aclosed+is%3Aissue+milestone%3A1.5.8 see list])
* '''108''' closed GitHub issues ([https://github.com/multitheftauto/mtasa-blue/issues?utf8=%E2%9C%93&q=is%3Aclosed+is%3Aissue+closed%3A%3E%3D2019-08-31+no%3Amilestone see list])
* '''47''' new open GitHub pull requests ([https://github.com/multitheftauto/mtasa-blue/pulls?utf8=%E2%9C%93&q=is%3Aopen+is%3Apr+created%3A%3E%3D2019-08-31 see list])
* '''192''' merged GitHub pull requests ([https://github.com/multitheftauto/mtasa-blue/pulls?q=is%3Apr+milestone%3A1.5.8+is%3Amerged see list])
* '''36''' closed GitHub pull requests ([https://github.com/multitheftauto/mtasa-blue/pulls?utf8=%E2%9C%93&q=is%3Apr+is%3Aunmerged+closed%3A%3E%3D2019-08-31 see list])
* '''37''' contributors of which '''27''' are new ([https://github.com/multitheftauto/mtasa-blue/graphs/contributors?from=2019-08-31&to=2020-08-31&type=c see list])
* '''98+''' total contributors ([https://github.com/multitheftauto/mtasa-blue/graphs/contributors see list])
* '''4''' vendor updates


<sub>'''Note:''' Last update to these statistics was made
{{#ifeq: {{date difference|2020|8|8}} | 0 | today |
{{#ifeq: {{date difference|2020|8|8}} | 1 | yesterday |
{{date difference|2020|8|8}} days ago
}}
}}.</sub>
</section>

== Scripting ==
<section show="true">
=== 5 Backwards Incompatible Changes ===
These changes will take effect in 1.6:
* [[callRemote]] callbacks currently set the error code to '''nil''' when there is no error. In 1.6, to be consistent with [[fetchRemote]], the error code reported will be '''0'''. See [https://github.com/multitheftauto/mtasa-blue/issues/294 GitHub #294].
* Since July 2016 if you provide an invalid string like '''"randomstring"''' when a function expects a number, the string will be treated as '''0''' and raise a script warning. In 1.6 this will be an error. You will still be able to provide strings containing numbers (e.g. '''"100"''' and '''"12.34"'''), this change only affects invalid strings. See [https://github.com/multitheftauto/mtasa-blue/issues/1043 GitHub #1043].
* When providing a width and height of (0, 0) to [[createBrowser]] or [[guiCreateBrowser]] you will encounter a script error instead of a warning. The warning was introduced Feb 2019. See [https://github.com/multitheftauto/mtasa-blue/issues/1069 GitHub #1069].
* Some functions expect only unsigned integers (positive numbers), and since Jan 2016 providing negative numbers would be a warning. This will now be an error. See [https://github.com/multitheftauto/mtasa-blue/issues/1070 GitHub #1070].
* Since Aug 2015, we replaced the custom '''mtalocal://''' URL scheme with '''http://mta/resourceName/blah.html'''. This '''mtalocal://''' URL scheme will now be removed. See [https://github.com/multitheftauto/mtasa-blue/issues/1071 GitHub #1071].

This list is inconclusive and we may introduce more changes later.
</section>

== Client ==
<section show="true">
=== 21 New Functions ===
* Add [[setPedFightingStyle]] (previously available server-side only) ([https://github.com/multitheftauto/mtasa-blue/pull/810 #810] by '''StrixG''')
* Add [[setPedArmor]] (previously available server-side only) ([https://github.com/multitheftauto/mtasa-blue/pull/811 #811] by '''StrixG''')
* Add [[areVehicleLightsOn]] ([https://github.com/multitheftauto/mtasa-blue/pull/938 #938] by '''StrixG''')
* Add [[dxDrawPrimitive3D]] and [[dxDrawMaterialPrimitive3D]] ([https://github.com/multitheftauto/mtasa-blue/pull/760 #760] by '''CrosRoad95''')
* Add functions to modify dynamic objects' behaviour ([https://github.com/multitheftauto/mtasa-blue/pull/784 #784] by '''forkerer''')
** [[engineGetModelPhysicalPropertiesGroup]]
** [[engineRestoreModelPhysicalPropertiesGroup]]
** [[engineSetModelPhysicalPropertiesGroup]]
** [[engineGetObjectGroupPhysicalProperty]]
** [[engineRestoreObjectGroupPhysicalProperties]]
** [[engineSetObjectGroupPhysicalProperty]]
* Add dynamic ped ID allocating using [[engineRequestModel]] and [[engineFreeModel]] ([https://github.com/multitheftauto/mtasa-blue/commit/475544f1753ce1af24c4cdff7f0d0be48ede709b #349] by '''lopezloo''' + '''Neproify''' + '''Arran''' + '''qaisjp''')
* Add [[engineResetModelLODDistance]] function ([https://github.com/multitheftauto/mtasa-blue/pull/971 #971] by '''Lpsd''')
* Add [[engineGetModelTextures]] function ([https://github.com/multitheftauto/mtasa-blue/pull/1058 #1058] by '''Lpsd''')
* Add [[resetBlurLevel]] function ([https://github.com/multitheftauto/mtasa-blue/pull/1266 #1266] by '''Luxy.c''')
* Add [[dxGetTextSize]] function ([https://github.com/multitheftauto/mtasa-blue/pull/935 #935] by '''StrixG''')
* Add functions to modify vehicle wheels, visibly and in collision by ([https://github.com/multitheftauto/mtasa-blue/pull/1641 #1641], [https://github.com/multitheftauto/mtasa-blue/pull/1644 #1644], and [https://github.com/multitheftauto/mtasa-blue/pull/1648 #1648] by '''AlexTMjugador''')
** [[getVehicleWheelScale]]
** [[getVehicleModelWheelSize]]
** [[setVehicleWheelScale]]
** [[setVehicleModelWheelSize]]

=== 45 Bug Fixes & Changes ===
* Add new client setting to toggle external sounds ([https://github.com/multitheftauto/mtasa-blue/pull/834 #834] by '''patrikjuvonen''')
* Fix crash when attempting to stream out a sound that's not streamed in (See commit [https://github.com/multitheftauto/mtasa-blue/commit/e1b7c730448d12a5eeb452239e8053e86924294f e1b7c73] by '''sbx320''')
* Fix [[dxDrawCircle]] ''segments'' argument being wrongly offset by one ([https://github.com/multitheftauto/mtasa-blue/pull/1079 #1079] by '''ApeLsiN4eG''')
* Fix potential crash when moving objects (See commit [https://github.com/multitheftauto/mtasa-blue/commit/90895c221549893501f5f717af3ca56878e29b5d 90895c2] by '''botder''')
* Update credits (See commit [https://github.com/multitheftauto/mtasa-blue/commit/39227d795efafe940dc6c317c20b0162b1bd0bb3 39227d7] by '''qaisjp''')
* Don't apply damage to peds without a game entity (See commit [https://github.com/multitheftauto/mtasa-blue/commit/632130e36a96071290593fc3c677a536f7b19e1f 632130e] by '''botder''')
* Fix doors state with setElementModel ([https://github.com/multitheftauto/mtasa-blue/pull/599 #599] by '''FileEX''')
* Add CVAR _beta_qc_rightclick_command allowing you to reconnect by right clicking the "Quick Connect" button on the main menu (See commit [https://github.com/multitheftauto/mtasa-blue/commit/d1c60675fc0f0f62b69707ae81a82e6bbdf36042 d1c60675] by '''qaisjp''')
* Add more data to [[getPedAnimation]] ([https://github.com/multitheftauto/mtasa-blue/pull/892 #892] by '''Dezash''')
* Add missing destroy method to DxFont ([https://github.com/multitheftauto/mtasa-blue/pull/1259 #1259] by '''MegadreamsBE''')
* Increase [[setPedAnimationSpeed]] limit (See commit [https://github.com/multitheftauto/mtasa-blue/commit/4c36d37056d2a1496904f394bf96303dd0f2b4c5 4c36d37] by '''qaisjp''')
* Fix "ancient" weapon fire crash ([https://github.com/multitheftauto/mtasa-blue/pull/1109 #1109] by '''saml1er''')
* Fix [[bitExtract]] (See commit [https://github.com/multitheftauto/mtasa-blue/commit/aa2df39d3e40e5b446ffea376ef96df89916a9d0 aa2df39d] by '''ccw808''')
* Fix texture blending ([https://github.com/multitheftauto/mtasa-blue/pull/1098 #1098] by '''StrixG''')
* Add client setting to toggle internet sound streams ([https://github.com/multitheftauto/mtasa-blue/pull/834 #834] by '''patrikjuvonen''')
* Implement "remember this option" checkbox to NVidia Optimus dialog ([https://github.com/multitheftauto/mtasa-blue/pull/1177 #1177] by '''Lpsd''')
* Fix inability to crouch when player has 1 HP ([https://github.com/multitheftauto/mtasa-blue/pull/1138 #1138] by '''CrosRoad95''')
* Improve trailer sync ([https://github.com/multitheftauto/mtasa-blue/pull/1247 #1247] by '''tederis''')
* Fix driveby for peds ([https://github.com/multitheftauto/mtasa-blue/pull/1290 #1290] by '''Zangomangu''')
* Add "SettingHighDetailPeds" to [[dxGetStatus]] ([https://github.com/multitheftauto/mtasa-blue/pull/1384 #1384] by '''Patrick''')
* Add feature to remove server from the "Recent" tab in server browser ([https://github.com/multitheftauto/mtasa-blue/pull/1381 #1381] by '''ecastro98''')
* Fix [[warpPedIntoVehicle]] failure when there are too many vehicles streamed in ([https://github.com/multitheftauto/mtasa-blue/pull/1431 #1431] by '''saml1er''')
* Fix issue with [[engineReplaceModel]] kicking the player out of the vehicle ([https://github.com/multitheftauto/mtasa-blue/pull/1433 #1433] by '''saml1er''')
* Moved exe patching to loader ([https://github.com/multitheftauto/mtasa-blue/pull/1520 #1520] by '''ccw808''')
* Fix various return values when using OOP (e.g: [https://github.com/multitheftauto/mtasa-blue/commit/5110559b7a7f2d258f01be1dce18fe63d8bca400 5110559b], [https://github.com/multitheftauto/mtasa-blue/commit/88379b8ded766b2d35e171b6d11ef33cb2663b96 88379b8d] by '''qaisjp''')
* Fixed incorrect VRAM detection ([https://github.com/multitheftauto/mtasa-blue/pull/1589 #1589] by '''TheNormalnij''')
* Add ability to play sounds from raw data to playSound(3D) ([https://github.com/multitheftauto/mtasa-blue/pull/1234 #1234] by '''Dezash''')
* Allow downloading of files from other resources ([https://github.com/multitheftauto/mtasa-blue/pull/945 #945] by '''TheNormalnij''') - this affects:
** [[downloadFile]]
** [[onClientFileDownloadComplete]]
* Add ability to get raw controller analog value ([https://github.com/multitheftauto/mtasa-blue/pull/1165 #1165] by '''Addlibs''')
* Add user agent workaround for YouTube TV ([https://github.com/multitheftauto/mtasa-blue/pull/1243 #1243] by '''qaisjp''')
* Add missing destroy method to DxFont ([https://github.com/multitheftauto/mtasa-blue/pull/1259 #1259] by '''MegadreamsBE''')
* Fix engineReplaceModel memory leak ([https://github.com/multitheftauto/mtasa-blue/pull/1265 #1265] by '''saml1er''')
* Fix vehicle model memory leaks (See commit [https://github.com/multitheftauto/mtasa-blue/commit/46dbbe7dd2c4621d7564cf272e8a432cf9f57300 46dbbe7] by '''saml1er''')
* Fix texture memory leak (See commit [https://github.com/multitheftauto/mtasa-blue/commit/d5722d5ac5c0ed0210849bf03c263ec88ea98c2a d5722d5] by '''saml1er''')
* Enable enter_exit for peds to fix alternative attack ([https://github.com/multitheftauto/mtasa-blue/pull/1295 #1295] by '''Zangomangu''')
* Fix "Select device" hides under other program without MTA icon on a taskbar (See commit [https://github.com/multitheftauto/mtasa-blue/commit/2c5251a42a640ccc9ffa928cb2844c9295f47c6c 2c5251a] by '''ccw808''')
* Fix primitive colors are always white ([https://github.com/multitheftauto/mtasa-blue/pull/1312 #1312] by '''StrixG''')
* Add analog control sync for accelerate and brake_reverse ([https://github.com/multitheftauto/mtasa-blue/pull/1164 #1164] by '''Addlibs''')
* Fix resetting dummies in vehicles with replaced models ([https://github.com/multitheftauto/mtasa-blue/pull/1059 #1059] by '''forkerer''' and '''saml1er''')
* Return vector3 instead of number at ped's target ([https://github.com/multitheftauto/mtasa-blue/pull/1379 #1379] by '''ecastro98''')
* Fix replaced weapon_crouch anim does not play if retainPedState is true ([https://github.com/multitheftauto/mtasa-blue/pull/1414 #1414] by '''saml1er''')
* Fix nametags are interiorless ([https://github.com/multitheftauto/mtasa-blue/commit/3df58bd435b3c4052fa5e7fe57d534bdca7e0d2b 3df58bd] by '''qaisjp''')
* Remove amx from the installer (See commit [https://github.com/multitheftauto/mtasa-blue/commit/7d4091fac6e41e6d9e199cd0a03c927dc48aac79 7d4091f] by '''qaisjp''')
* Potential fix for vehicle dummies crash ([https://github.com/multitheftauto/mtasa-blue/pull/1524 #1524] by '''saml1er''')
* Add projectiles support for [[getElementModel]] ([https://github.com/multitheftauto/mtasa-blue/pull/1550 #1550] by '''StrixG''')

=== 2 Vendor Updates ===
* Update BASS libraries ([https://github.com/multitheftauto/mtasa-blue/pull/1551 #1551] by '''Dutchman101''')
* Update CEF from 76.1.13+gf19c584 (Chromium 76.0.3809.132) to 81.3.10+gb223419 ([https://chromereleases.googleblog.com/2020/05/stable-channel-update-for-desktop.html Chromium 81.0.4044.138]) (See commit [https://github.com/multitheftauto/mtasa-blue/commit/8d2d0fb20fb094119e86e348340f5cb90e30dc16 8d2d0fb] by '''qaisjp''')
</section>

== Server ==
<section show="true">
=== 3 New Functions ===
* Add [[setPlayerScriptDebugLevel]] and [[getPlayerScriptDebugLevel]] ([https://github.com/multitheftauto/mtasa-blue/pull/826 #826] by '''knitz12''')
* Add [[isResourceProtected]] function ([https://github.com/multitheftauto/mtasa-blue/pull/1254 #1254] by '''StrixG''')



=== 9 Bug Fixes & Changes ===
* Fix [[iprint]] to be able to read and output nil arguments properly ([https://github.com/multitheftauto/mtasa-blue/pull/1064 #1064] by '''TheNormalnij''')
* Accept team & table of players in [[outputChatBox]] ([https://github.com/multitheftauto/mtasa-blue/pull/1213 #1213] by '''StrixG''')
* Fix /msg command duplicating when sent by Server Console ([https://github.com/multitheftauto/mtasa-blue/pull/1411 #1411] by '''Dezash''')
* Make colshapes cloneable ([https://github.com/multitheftauto/mtasa-blue/pull/1214 #1214] by '''StrixG''')
* Fix double chat messages if player is in team ([https://github.com/multitheftauto/mtasa-blue/pull/1241 #1241] by '''StrixG''' and '''Luxy.c''')
* Don't queue a resource restart if resource is stopping ([https://github.com/multitheftauto/mtasa-blue/pull/960 #960] by '''StrixG''')
* Add support for more map attributes ([https://github.com/multitheftauto/mtasa-blue/pull/263 #263] by '''patrikjuvonen''')
* Fix server-client inconsistency for isElementAttached failure return ([https://github.com/multitheftauto/mtasa-blue/commit/866506d3f6ebe4a0d4d39664cc4e7d7c0cef1a7c 866506d] by '''qaisjp''')
* Make [[kickPlayer]] accept the Console element as responsiblePlayer([https://github.com/multitheftauto/mtasa-blue/pull/1427 #1427] by '''qaisjp''')

=== 1 Vendor Update ===
* Update sqlite from 3.31.1 to 3.32.3 ([https://github.com/multitheftauto/mtasa-blue/pull/1561 #1561] by '''patrikjuvonen''')
</section>

== Shared (''Client & Server side'') ==
<section show="true">
=== 17 New Functions ===
* Add [[xmlLoadString]] ([https://github.com/multitheftauto/mtasa-blue/pull/809 #809] by '''Lpsd''')
* Add request info & abort functions for [[fetchRemote]]/[[callRemote]] ([https://github.com/multitheftauto/mtasa-blue/pull/660 #660] by '''Luxy.c''')
** [[getRemoteRequests]]
** [[getRemoteRequestInfo]]
** [[abortRemoteRequest]]
* Add functions to manipulate colshapes parameters ([https://github.com/multitheftauto/mtasa-blue/pull/1215 #1215] by '''StrixG''')
** [[getColShapeRadius]]
** [[setColShapeRadius]]
** [[getColShapeSize]]
** [[setColShapeSize]]
** [[getColPolygonPoints]]
** [[getColPolygonPointPosition]]
** [[setColPolygonPointPosition]]
** [[addColPolygonPoint]]
** [[removeColPolygonPoint]]
* Add [[hasElementData]] function ([https://github.com/multitheftauto/mtasa-blue/pull/1163 #1163] by '''Simi2''')
* Add element data subscription functionality ([https://github.com/multitheftauto/mtasa-blue/pull/1055 #1055] by '''tederis''') - includes 3 new functions:
** [[addElementDataSubscriber]]
** [[removeElementDataSubscriber]]
** [[hasElementDataSubscriber]]
** Adds 1 additional parameter to [[setElementData]]

=== 1 Deprecation ===
* Add deprecation message to [[passwordHash]] when using custom salts ([https://github.com/multitheftauto/mtasa-blue/pull/1208 #1208] by '''Luxy.c''')

=== 7 Bug Fixes & Changes ===
* Add async [[encodeString]]/[[decodeString]] ([https://github.com/multitheftauto/mtasa-blue/pull/1226 #1226] by '''StrixG''')
* Fix colshape and marker hit detection when attaching ([https://github.com/multitheftauto/mtasa-blue/pull/1327 #1327] by '''Lpsd''')
* Fix driveby aiming being inverted in some cases ([https://github.com/multitheftauto/mtasa-blue/pull/1442 #1442] by '''Zangomangu''')
* Add bIncludeWorldSeaLevel and bIncludeOutsideWorldLevel parameters to [[setWaterLevel]] ([https://github.com/multitheftauto/mtasa-blue/pull/1342 #1342] by '''TheNormalnij''')
* Add [[outputDebugString]] level 4 to omit certain debug info ([https://github.com/multitheftauto/mtasa-blue/pull/1167 #1167] by '''Addlibs''')
* Fix incorrect hash capitalisation ([https://github.com/multitheftauto/mtasa-blue/pull/1527 #1527] by '''qaisjp''')
* Trim [[teaEncode]] trailing zeroes ([https://github.com/multitheftauto/mtasa-blue/pull/1534 #1534] by '''Pirulax''')

=== 1 Vendor Update ===
* Update curl from 7.68.0 to 7.69.1 ([https://github.com/multitheftauto/mtasa-blue/pull/1302 #1302] by '''patrikjuvonen''' and '''qaisjp''')
</section>

<section show="true">
== Extra information ==
''More detailed information available on our GitHub repositories:
:* [https://github.com/multitheftauto/mtasa-blue MTA:SA Blue]
:* [https://github.com/multitheftauto/mtasa-resources MTA:SA Official Resources]
</section>

[[Category:Changelog]]
[[Category:Incomplete]]

DxGetTextWidth

2020-04-05T14:27:19Z

Citizen: Preventing scripters to think it returns the width in relative because of the Note

__NOTOC__
{{Client function}}
This function retrieves the theoretical width (in pixels) of a certain piece of text, if it were to be drawn using [[dxDrawText]].

'''NOTE:''' This function already takes the client's screen resolution into account.

==Syntax==
<syntaxhighlight lang="lua">
float dxGetTextWidth ( string text, [float scale=1, mixed font="default", bool bColorCoded=false] )
</syntaxhighlight>
{{New feature/item|3.0141|1.4.1|6942|{{OOP|This syntax requires you to ignore the font argument above| [[Element/DX font|font]]:getTextWidth}}}}
===Required Arguments===
* '''text:''' A string representing the text for which you wish to retrieve with width for.

==Optional Arguments==
{{OptionalArg}}
* '''scale:''' The size of the text.
* '''font:''' Either a custom [[DX font]] element or the name of a built-in dx font:
{{DxFonts}}
* '''bColorCoded:''' Should we exclude color codes from the width? (false will include the hex in the length)

===Returns===
Returns the float of the width of the text (in pixels).

==Example==
<section name="Example" class="client" show="true">
This will show you the width of a message in a normal chatbox sent by a player
<syntaxhighlight lang="lua">
function dxwidth(msg)
chatbox = getChatboxLayout()
local length = dxGetTextWidth(msg,chatbox["chat_scale"][1])
outputChatBox(tostring(length))
end
addEventHandler("onClientChatMessage",root,dxwidth)
</syntaxhighlight>
</section>

==See Also==
{{Drawing_functions}}

[[hu:dxGetTextWidth]]

SetTimer

2020-04-04T23:15:02Z

Citizen: We expect the wiki to say "performance issues" instead of death. Added onClientPreRender to recommended event.

__NOTOC__
{{Server client function}}{{Important Note|The speed at which a client side timer runs can be completely unreliable if a client is maliciously modifying their operating system speed, timers could run much faster or slower.}}
{{Important Note|Writing the following code can cause performance issues. Use [[onClientRender]] or [[onClientPreRender]] instead. <syntaxhighlight lang="lua">setTimer(theFunction, 0, 0)</syntaxhighlight>}}
This function allows you to trigger a function after a number of milliseconds have elapsed. You can call one of your own functions or a built-in function. For example, you could set a timer to spawn a player after a number of seconds have elapsed.

Once a timer has finished repeating, it no longer exists.

The minimum accepted interval is 0ms.

Multi Theft Auto guarantees that the timer will be triggered after ''at least'' the interval you specify. The resolution of the timer is tied to the frame rate (server side and client-side). All the overdue timers are triggered at a single point each frame. This means that if, for example, the player is running at 30 frames per second, then two timers specified to occur after 100ms and 110ms would more than likely occur during the same frame, as the difference in time between the two timers (10ms) is less than half the length of the frame (33ms). As with most timers provided by other languages, you shouldn't rely on the timer triggering at an exact point in the future.

==Syntax==
<syntaxhighlight lang="lua">
timer setTimer ( function theFunction, int timeInterval, int timesToExecute [, var arguments... ] )
</syntaxhighlight>
{{OOP||[[Timer]]}}
===Required Arguments===
*'''theFunction:''' The function you wish the timer to call.
{{Note|The hidden global variable '''sourceTimer''' contains the currently executing timer userdata}}
*'''timeInterval:''' The number of milliseconds that should elapse before the function is called. (the minimum is 50 (0 on 1.5.6 r16715); 1000 milliseconds = 1 second)
*'''timesToExecute:''' The number of times you want the timer to execute, or 0 for infinite repetitions.

===Optional Arguments===
{{OptionalArg}}
*'''arguments:''' Any arguments you wish to pass to the function can be listed after the ''timesToExecute'' argument. Note that any tables you want to pass will get cloned, whereas metatables and functions/function references in that passed table will get lost. Also changes you make in the original table before the function gets called won't get transferred.

===Returns===
Returns a [[timer]] pointer if the timer was set successfully, ''false'' if the arguments are invalid or the timer could not be set.

==Examples==
This example will output some text after a small delay.

<syntaxhighlight lang="lua">
-- define function to be called
function delayedChat ( text )
outputChatBox ( "Delayed text: " .. text )
end

-- set a timer so the function is called after 1 second
setTimer ( delayedChat, 1000, 1, "Hello, World!" )
</syntaxhighlight>

1 second after the line above has been executed, the text ''Delayed text: Hello, World!'' will be displayed in the chat box.

This example will nest a whole function within a timer. This is nice for things like setting variables without having to call a function outside of your code block.

<syntaxhighlight lang="lua">
function mainFunction()
outputChatBox ("Instant text!")
setTimer ( function()
outputChatBox ( "5 second delay text!" )
end, 5000, 1 )
end

mainFunction() --call function
</syntaxhighlight>

This example outputs some random text to the chat every 300000 milliseconds (5 minutes).
<syntaxhighlight lang="lua">
setTimer(function()
outputChatBox("Text " .. math.random(1,4))
end, 300000, 0)
</syntaxhighlight>

<section name="Yet another example" class="server" show="false">
This example should send a global message about the death of a player on a random time. I used [https://wiki.multitheftauto.com/wiki/Math.round math.round] in this example to give a nicer output.
<syntaxhighlight lang="lua">
function math.round(number, decimals, method) -- math.round, useful function taken from the wiki: https://wiki.multitheftauto.com/wiki/Math.round
decimals = decimals or 0
local factor = 10 ^ decimals
if (method == "ceil" or method == "floor") then return math[method](number * factor) / factor
else return tonumber(("%."..decimals.."f"):format(number)) end
end

function onWasted()
local delay = math.random(500, 5000) -- 0.5s to 5s of delay
setTimer(function(thePlayer) -- Starts the Timer
local whoDied = "Someone" -- In case the name can't be read, Someone will appear
if isElement(thePlayer) then -- This checks if thePlayer's element still exists (which means thePlayer hasnt disconnected yet)
whoDied = getPlayerName(thePlayer) -- Changes Someone to thePlayer's name
end
outputChatBox(whoDied.." #FFFFFFhas #FF0000died #FFFFFF"..math.round(delay/1000, 1).." seconds ago.", root, 255, 175, 0, true) -- This will output to everyone on the server that thePlayer (or Someone) died X seconds ago.
end
delay, 1, source) -- The source at the end is an argument for the function we made before, you can't use the source directly because it won't be readed
end
addEventHandler("onPlayerWasted", root, onWasted) -- Executed every time someone dies
</syntaxhighlight>
</section>

==See Also==
{{Utility functions}}

OOP client

2018-12-28T21:54:22Z

Citizen: Updated Element section with getPosition, setRotation and getRotation

{{Needs Checking|This page is partially outdated.}}
The new OOP in MTA allows for better code organization and readability. This is a list of [[Client_Scripting_Functions|client-side functions]].

''See also: [[OOP]]''

==Element==

areCollisionsEnabled (function: [[getElementCollisionsEnabled]])
attach (function: [[attachElements]])
clearVisibleTo (function: [[clearElementVisibleTo]])
clone (function: [[cloneElement]])
create (function: [[createElement]])
destroy (function: [[destroyElement]])
detach (function: [[detachElements]])
getAllByType (function: [[getElementsByType]])
getAlpha (function: [[getElementAlpha]])
getAttachedElements (function: [[getAttachedElements]])
getAttachedOffsets (function: [[getElementAttachedOffsets]])
getAttachedTo (function: [[getElementAttachedTo]])
getBoundingBox (function: [[getElementBoundingBox]])
getByID (function: [[getElementByID]])
getByType (function: [[getElementsByType]])
getChild (function: [[getElementChild]])
getChildren (function: [[getElementChildren]])
getChildrenCount (function: [[getElementChildrenCount]])
getColShape (function: [[getElementColShape]])
getData (function: [[getElementData]])
getDimension (function: [[getElementDimension]])
getDistanceFromCentreOfMassToBaseOfModel (function: [[GetElementDistanceFromCentreOfMassToBaseOfModel]])
getHealth (function: [[getElementHealth]])
getID (function: [[getElementID]])
getInterior (function: [[getElementInterior]])
getLowLOD (function: [[getLowLODElement]])
getModel (function: [[getElementModel]])
getParent (function: [[getElementParent]])
getPosition (function: [[getElementPosition]], variable: position)
getRotation (function: [[getElementRotation]], variable: rotation)
getSyncer (function: [[getElementSyncer]])
getType (function: [[getElementType]])
getVelocity (function: [[getElementVelocity]])
getWithinColShape (function: [[getElementsWithinColShape]])
getZoneName (function: [[getElementZoneName]])
isAttached (function: [[isElementAttached]])
isCallPropagationEnabled (function: [[isElementCallPropagationEnabled]])
isDoubleSided (function: [[isElementDoubleSided]])
isFrozen (function: [[isElementFrozen]])
isInWater (function: [[isElementInWater]])
isLowLOD (function: [[isElementLowLOD]])
isVisibleTo (function: [[isElementVisibleTo]])
isWithinColShape (function: [[isElementWithinColShape]])
isWithinMarker (function: [[isElementWithinMarker]])
removeData (function: [[removeElementData]])
setAlpha (function: [[setElementAlpha]])
setAttachedOffsets (function: [[setElementAttachedOffsets]])
setCallPropagationEnabled (function: [[setElementCallPropagationEnabled]])
setCollisionsEnabled (function: [[setElementCollisionsEnabled]])
setData (function: [[setElementData]])
setDimension (function: [[setElementDimension]])
setDoubleSided (function: [[setElementDoubleSided]])
setFrozen (function: [[setElementFrozen]])
setHealth (function: [[setElementHealth]])
setID (function: [[setElementID]])
setInterior (function: [[setElementInterior]])
setLowLOD (function: [[setLowLODElement]])
setMatrix (function: [[setElementMatrix]])
setModel (function: [[setElementModel]])
setParent (function: [[setElementParent]])
setPosition (function: [[setElementPosition]])
setRotation (function: [[setElementRotation]])
setVelocity (function: [[setElementVelocity]])
setVisibleTo (function: [[setElementVisibleTo]])

==Vehicle==
''Inherited from [[#Element|Element]]''

addUpgrade (function: [[addVehicleUpgrade]])
attachTrailer (function: [[attachTrailerToVehicle]])
blow (function: [[blowVehicle]])
create (function: [[createVehicle]])
detachTrailer (function: [[detachTrailerFromVehicle]])
fix (function: [[fixVehicle]])
getAdjustableProperty (function: [[getVehicleAdjustableProperty]])
getColor (function: [[getVehicleColor]])
getCompatibleUpgrades (function: [[getVehicleCompatibleUpgrades]])
getComponentPosition (function: [[getVehicleComponentPosition]])
getComponentRotation (function: [[getVehicleComponentRotation]])
getComponents (function: [[getVehicleComponents]])
getComponentVisible (function: [[getVehicleComponentVisible]])
getController (function: [[getVehicleController]])
getDoorOpenRatio (function: [[getVehicleDoorOpenRatio]])
getDoorState (function: [[getVehicleDoorState]])
getEngineState (function: [[getVehicleEngineState]])
getGear (function: [[getVehicleCurrentGear]])
getGravity (function: [[getVehicleGravity]])
getHandling (function: [[getVehicleHandling]])
getHeadLightColor (function: [[getVehicleHeadLightColor]])
getHelicopterRotorSpeed (function: [[getHelicopterRotorSpeed]])
getLandingGearDown (function: [[getVehicleLandingGearDown]])
getLightState (function: [[getVehicleLightState]])
getMaxPassengers (function: [[getVehicleMaxPassengers]])
getName (function: [[getVehicleName]])
getNitroCount (function: [[getVehicleNitroCount]])
getNitroLevel (function: [[getVehicleNitroLevel]])
getOccupant (function: [[getVehicleOccupant]])
getOccupants (function: [[getVehicleOccupants]])
getOverrideLights (function: [[getVehicleOverrideLights]])
getPaintjob (function: [[getVehiclePaintjob]])
getPanelState (function: [[getVehiclePanelState]])
getPlateText (function: [[getVehiclePlateText]])
getSirens (function: [[getVehicleSirens]])
getSirensOn (function: [[getVehicleSirensOn]])
getTowedByVehicle (function: [[getVehicleTowedByVehicle]])
getTowingVehicle (function: [[getVehicleTowingVehicle]])
getTrainDirection (function: [[getTrainDirection]])
getTrainSpeed (function: [[getTrainSpeed]])
getTurnVelocity (function: [[getVehicleTurnVelocity]])
getTurretPosition (function: [[getVehicleTurretPosition]])
getUpgrades (function: [[getVehicleUpgrades]])
getUpgradeSlotName (function: [[getVehicleUpgradeSlotName]])
getVariant (function: [[getVehicleVariant]])
getVehicleType (function: [[getVehicleType]])
getWheelStates (function: [[getVehicleWheelStates]])
isBlown (function: [[isVehicleBlown]])
isDamageProof (function: [[isVehicleDamageProof]])
isFuelTankExplodable (function: [[isVehicleFuelTankExplodable]])
isLocked (function: [[isVehicleLocked]])
isNitroActivated (function: [[isVehicleNitroActivated]])
isNitroRecharging (function: [[isVehicleNitroRecharging]])
isOnGround (function: [[isVehicleOnGround]])
isTaxiLightOn (function: [[isVehicleTaxiLightOn]])
isTrainDerailable (function: [[setTrainDerailable]])
isTrainDerailed (function: [[isTrainDerailed]])
isWheelCollided (function: [[isVehicleWheelCollided]])
removeUpgrade (function: [[removeVehicleUpgrade]])
resetComponentPosition (function: [[resetVehicleComponentPosition]])
resetComponentRotation (function: [[resetVehicleComponentRotation]])
setAdjustableProperty (function: [[setVehicleAdjustableProperty]])
setColor (function: [[setVehicleColor]])
setComponentPosition (function: [[setVehicleComponentPosition]])
setComponentRotation (function: [[setVehicleComponentRotation]])
setComponentVisible (function: [[setVehicleComponentVisible]])
setDamageProof (function: [[setVehicleDamageProof]])
setDirtLevel (function: [[setVehicleDirtLevel]])
setDoorOpenRatio (function: [[setVehicleDoorOpenRatio]])
setDoorState (function: [[setVehicleDoorState]])
setDoorsUndamageable (function: [[setVehicleDoorsUndamageable]])
setEngineState (function: [[setVehicleEngineState]])
setFuelTankExplodable (function: [[setVehicleFuelTankExplodable]])
setGravity (function: [[setVehicleGravity]])
setHeadLightColor (function: [[setVehicleHeadLightColor]])
setHelicopterRotorSpeed (function: [[setHelicopterRotorSpeed]])
setLandingGearDown (function: [[setVehicleLandingGearDown]])
setLightState (function: [[setVehicleLightState]])
setLocked (function: [[setVehicleLocked]])
setNitroActivated (function: [[setVehicleNitroActivated]])
setNitroCount (function: [[setVehicleNitroCount]])
setNitroLevel (function: [[setVehicleNitroLevel]])
setOverrideLights (function: [[setVehicleOverrideLights]])
setPaintjob (function: [[setVehiclePaintjob]])
setPanelState (function: [[setVehiclePanelState]])
setSirens (function: [[setVehicleSirens]])
setSirensOn (function: [[setVehicleSirensOn]])
setTaxiLightOn (function: [[setVehicleTaxiLightOn]])
setTrainDerailable (function: [[setTrainDerailable]])
setTrainDerailed (function: [[setTrainDerailed]])
setTrainDirection (function: [[setTrainDirection]])
setTrainSpeed (function: [[setTrainSpeed]])
setTurnVelocity (function: [[setVehicleTurnVelocity]])
setTurretPosition (function: [[setVehicleTurretPosition]])
setVariant (function: [[setVehicleVariant]])
setWheelStates (function: [[setVehicleWheelStates]])

==Ped==
''Inherited from [[#Element|Element]]''

addClothes (function: [[addPedClothes]])
canBeKnockedOffBike (function: [[canPedBeKnockedOffBike]])
create (function: [[createPed]])
doesHaveJetPack (function: [[doesPedHaveJetPack]])
getAmmoInClip (function: [[getPedAmmoInClip]])
getAnalogControlState (function: [[getPedAnalogControlState]])
getAnimation (function: [[getPedAnimation]])
getAnimationData (function: [[getPedAnimationData]])
getArmor (function: [[getPedArmor]])
getBodyPartName (function: [[getBodyPartName]])
getBonePosition (function: [[getPedBonePosition]])
getCameraRotation (function: [[getPedCameraRotation]])
getClothes (function: [[getPedClothes]])
getClothesByTypeIndex (function: [[getClothesByTypeIndex]])
getClothesTypeName (function: [[getClothesTypeName]])
getContactElement (function: [[getPedContactElement]])
getControlState (function: [[getPedControlState]])
getMoveState (function: [[getPedMoveState]])
getOccupiedVehicle (function: [[GetPedOccupiedVehicle]])
getOxygenLevel (function: [[getPedOxygenLevel]])
getSimplestTask (function: [[getPedSimplestTask]])
getStat (function: [[getPedStat]])
getTarget (function: [[getPedTarget]])
getTargetCollision (function: [[getPedTargetCollision]])
getTargetEnd (function: [[getPedTargetEnd]])
getTargetStart (function: [[getPedTargetStart]])
getTask (function: [[getPedTask]])
getTotalAmmo (function: [[getPedTotalAmmo]])
getTypeIndexFromClothes (function: [[getTypeIndexFromClothes]])
getValidModels (function: [[getValidPedModels]])
getVoice (function: [[getPedVoice]])
getWalkingStyle (function: [[getPedWalkingStyle]])
getWeapon (function: [[getPedWeapon]])
getWeaponMuzzlePosition (function: [[getPedWeaponMuzzlePosition]])
isChocking (function: [[isPedChoking]])
isDoingGangDriveby (function: [[isPedDoingGangDriveby]])
isDoingTask (function: [[isPedDoingTask]])
isDucked (function: [[isPedDucked]])
isHeadless (function: [[isPedHeadless]])
isInVehicle (function: [[isPedInVehicle]])
isOnFire (function: [[isPedOnFire]])
isOnGround (function: [[isPedOnGround]])
isReloadingWeapon (function: [[isPedReloadingWeapon]])
isTargetingMarkerEnabled (function: [[isPedTargetingMarkerEnabled]])
removeClothes (function: [[removePedClothes]])
removeFromVehicle (function: [[removePedFromVehicle]])
setAimTarget (function: [[setPedAimTarget]])
setAnalogControlState (function: [[setPedAnalogControlState]])
setAnimation (function: [[setPedAnimation]])
setAnimationProgress (function: [[setPedAnimationProgress]])
setCameraRotation (function: [[setPedCameraRotation]])
setCanBeKnockedOffBike (function: [[setPedCanBeKnockedOffBike]])
setControlState (function: [[setPedControlState]])
setDoingGangDriveby (function: [[setPedDoingGangDriveby]])
setFootBloodEnabled (function: [[setPedFootBloodEnabled]])
setHeadless (function: [[setPedHeadless]])
setLookAt (function: [[setPedLookAt]])
setOnFire (function: [[setPedOnFire]])
setOxygenLevel (function: [[setPedOxygenLevel]])
setTargetingMarkerEnabled (function: [[setPedTargetingMarkerEnabled]])
setVoice (function: [[setPedVoice]])
setWalkingStyle (function: [[setPedWalkingStyle]])
setWeaponSlot (function: [[setPedWeaponSlot]])
warpIntoVehicle (function: [[warpPedIntoVehicle]])

==Player==
''Inherited from [[#Ped|Ped]]''

create (function: [[getPlayerFromName]])
getBlurLevel (function: [[getPlayerBlurLevel]])
getMapBoundingBox (function: [[getPlayerMapBoundingBox]])
getMoney (function: [[getPlayerMoney]])
getName (function: [[getPlayerName]])
getNametagColor (function: [[getPlayerNametagColor]])
getNametagText (function: [[getPlayerNametagText]])
getPing (function: [[getPlayerPing]])
getSerial (function: [[getPlayerSerial]])
getTeam (function: [[getPlayerTeam]])
getWantedLevel (function: [[getPlayerWantedLevel]])
giveMoney (function: [[givePlayerMoney]])
isHudComponentVisible (function: [[isPlayerHudComponentVisible]])
isMapForced (function: [[isPlayerMapForced]])
isMapVisible (function: [[isPlayerMapVisible]])
isNametagShowing (function: [[isPlayerNametagShowing]])
setBlurLevel (function: [[setPlayerBlurLevel]])
setMoney (function: [[setPlayerMoney]])
setNametagColor (function: [[setPlayerNametagColor]])
setNametagShowing (function: [[setPlayerNametagShowing]])
setNametagText (function: [[setPlayerNametagText]])
showHudComponent (function: [[showPlayerHudComponent]])
takeMoney (function: [[takePlayerMoney]])

==Object==
''Inherited from [[#Element|Element]]''

break (function: [[breakObject]])
create (function: [[createObject]])
getMass (function: [[getObjectMass]])
getScale (function: [[getObjectScale]])
isBreakable (function: [[isObjectBreakable]])
move (function: [[moveObject]])
respawn (function: [[respawnObject]])
setBreakable (function: [[setObjectBreakable]])
setMass (function: [[setObjectMass]])
setScale (function: [[setObjectScale]])
stop (function: [[stopObject]])
toggleObjectRespawn (function: [[toggleObjectRespawn]])

==Marker==
''Inherited from [[#Element|Element]]''

create (function: [[createMarker]])
getColor (function: [[getMarkerColor]])
getCount (function: [[getMarkerCount]])
getIcon (function: [[getMarkerIcon]])
getSize (function: [[getMarkerSize]])
getTarget (function: [[getMarkerTarget]])
getType (function: [[getMarkerType]])
setColor (function: [[setMarkerColor]])
setIcon (function: [[setMarkerIcon]])
setSize (function: [[setMarkerSize]])
setTarget (function: [[setMarkerTarget]])
setType (function: [[setMarkerType]])

==Blip==
''Inherited from [[#Element|Element]]''

create (function: [[createBlip]])
createAttachedTo (function: [[createBlipAttachedTo]])
getColor (function: [[getBlipColor]])
getIcon (function: [[getBlipIcon]])
getOrdering (function: [[getBlipOrdering]])
getSize (function: [[getBlipSize]])
getVisibleDistance (function: [[getBlipVisibleDistance]])
setColor (function: [[setBlipColor]])
setIcon (function: [[setBlipIcon]])
setOrdering (function: [[setBlipOrdering]])
setSize (function: [[setBlipSize]])
setVisibleDistance (function: [[setBlipVisibleDistance]])

==Pickup==
''Inherited from [[#Element|Element]]''

create (function: [[createPickup]])
getAmmo (function: [[getPickupAmmo]])
getAmount (function: [[getPickupAmount]])
getType (function: [[getPickupType]])
getWeapon (function: [[getPickupWeapon]])
setType (function: [[setPickupType]])

==ColShape==
''Inherited from [[#Element|Element]]''

Circle (function: [[createColCircle]])
Cuboid (function: [[createColCuboid]])
getElementsWithin (function: [[getElementsWithinColShape]])
getShapeType (function: [[getColShapeType]])
isElementWithin (function: [[isElementWithinColShape]])
Polygon (function: [[createColPolygon]])
Rectangle (function: [[createColRectangle]])
Sphere (function: [[createColSphere]])
Tube (function: [[createColTube]])

==Projectile==
''Inherited from [[#Element|Element]]''

create (function: [[createProjectile]])
getCounter (function: [[getProjectileCounter]])
getCreator (function: [[getProjectileCreator]])
getForce (function: [[getProjectileForce]])
getTarget (function: [[getProjectileTarget]])
getType (function: [[getProjectileType]])
setCounter (function: [[setProjectileCounter]])

==RadarArea==
''Inherited from [[#Element|Element]]''

create (function: [[createRadarArea]])
getColor (function: [[getRadarAreaColor]])
getSize (function: [[getRadarAreaSize]])
isFlashing (function: [[isRadarAreaFlashing]])
isInside (function: [[isInsideRadarArea]])
setColor (function: [[setRadarAreaColor]])
setFlashing (function: [[setRadarAreaFlashing]])
setSize (function: [[setRadarAreaSize]])

==Team==
''Inherited from [[#Element|Element]]''

countPlayers (function: [[countPlayersInTeam]])
create (function: [[getTeamFromName]])
getColor (function: [[getTeamColor]])
getFriendlyFire (function: [[getTeamFriendlyFire]])
getFromName (function: [[getTeamFromName]])
getName (function: [[getTeamName]])

==Water==
''Inherited from [[#Element|Element]]''

create (function: [[createWater]])
getColor (function: [[getWaterColor]])
getLevel (function: [[getWaterLevel]])
getVertexPosition (function: [[getWaterVertexPosition]])
getWaveHeight (function: [[getWaveHeight]])
isDrawnLast (function: [[isWaterDrawnLast]])
resetColor (function: [[resetWaterColor]])
resetLevel (function: [[resetWaterLevel]])
setColor (function: [[setWaterColor]])
setDrawnLast (function: [[setWaterDrawnLast]])
setLevel (function: [[setWaterLevel]])
setVertexPosition (function: [[setWaterVertexPosition]])
setWaveHeight (function: [[setWaveHeight]])
testLineAgainst (function: [[testLineAgainstWater]])

==Sound==
''Inherited from [[#Element|Element]]''

create (function: [[playSound]])
getBPM (function: [[getSoundBPM]])
getEffects (function: [[getSoundEffects]])
getFFTData (function: [[getSoundFFTData]])
getLength (function: [[getSoundLength]])
getLevelData (function: [[getSoundLevelData]])
getMetaTags (function: [[getSoundMetaTags]])
getPan (function: [[getSoundPan]])
getPlaybackPosition (function: [[getSoundPosition]])
getProperties (function: [[getSoundProperties]])
getSpeed (function: [[getSoundSpeed]])
getVolume (function: [[getSoundVolume]])
getWaveData (function: [[getSoundWaveData]])
isPaused (function: [[isSoundPaused]])
setEffectEnabled (function: [[setSoundEffectEnabled]])
setPan (function: [[setSoundPan]])
setPaused (function: [[setSoundPaused]])
setPlaybackPosition (function: [[setSoundPosition]])
setProperties (function: [[setSoundProperties]])
setSpeed (function: [[setSoundSpeed]])
setVolume (function: [[setSoundVolume]])
stop (function: [[stopSound]])

==Sound3D==
''Inherited from [[#Sound|Sound]]''

create (function: [[playSound3D]])
getMaxDistance (function: [[getSoundMaxDistance]])
getMinDistance (function: [[getSoundMinDistance]])
setMaxDistance (function: [[setSoundMaxDistance]])
setMinDistance (function: [[setSoundMinDistance]])

==Weapon==
''Inherited from [[#Element|Element]]''

create (function: [[createWeapon]])
fire (function: [[fireWeapon]])
getAmmo (function: [[getWeaponAmmo]])
getClipAmmo (function: [[getWeaponClipAmmo]])
getFiringRate (function: [[getWeaponFiringRate]])
getFlags (function: [[getWeaponFlags]])
getOwner (function: [[getWeaponOwner]])
getProperty (function: [[setWeaponProperty]])
getState (function: [[getWeaponState]])
getTarget (function: [[getWeaponTarget]])
resetFiringRate (function: [[resetWeaponFiringRate]])
setAmmo (function: [[setWeaponAmmo]])
setClipAmmo (function: [[setWeaponClipAmmo]])
setFiringRate (function: [[setWeaponFiringRate]])
setFlags (function: [[setWeaponFlags]])
setOwner (function: [[setWeaponOwner]])
setProperty (function: [[setWeaponProperty]])
setState (function: [[setWeaponState]])
setTarget (function: [[setWeaponTarget]])

==Effect==
''Inherited from [[#Element|Element]]''

addBlood (function: [[fxAddBlood]])
addBulletImpact (function: [[fxAddBulletImpact]])
addBulletSplash (function: [[fxAddBulletSplash]])
addDebris (function: [[fxAddDebris]])
addFootSplash (function: [[fxAddFootSplash]])
addGlass (function: [[fxAddGlass]])
addGunshot (function: [[fxAddGunshot]])
addPunchImpact (function: [[fxAddPunchImpact]])
addSparks (function: [[fxAddSparks]])
addTankFire (function: [[fxAddTankFire]])
addTyreBurst (function: [[fxAddTyreBurst]])
addWaterHydrant (function: [[fxAddWaterHydrant]])
addWaterSplash (function: [[fxAddWaterSplash]])
addWood (function: [[fxAddWood]])
create (function: [[createEffect]])
getDensity (function: [[getEffectDensity]])
getSpeed (function: [[getEffectSpeed]])
setDensity (function: [[setEffectDensity]])
setSpeed (function: [[setEffectSpeed]])

==GuiElement==
''Inherited from [[#Element|Element]]''

bringToFront (function: [[guiBringToFront]])
moveToBack (function: [[guiMoveToBack]])
isChatBoxInputActive (function: [[isChatBoxInputActive]])
isConsoleActive (function: [[isConsoleActive]])
isDebugViewActive (function: [[isDebugViewActive]])
isMainMenuActive (function: [[isMainMenuActive]])
isMTAWindowActive (function: [[isMTAWindowActive]])
isTransferBoxActive (function: [[isTransferBoxActive]])
isInputEnabled (function: [[guiGetInputEnabled]])
getInputMode (function: [[guiGetInputMode]])
getScreenSize (function: [[guiGetScreenSize]])
getProperties (function: [[guiGetProperties]])
getAlpha (function: [[guiGetAlpha]])
getFont (function: [[guiGetFont]])
getEnabled (function: [[guiGetEnabled]])
getVisible (function: [[guiGetVisible]])
getText (function: [[guiGetText]])
getPosition (function: [[guiGetPosition]])
getSize (function: [[guiGetSize]])
getProperty (function: [[guiGetProperty]])
setInputEnabled (function: [[guiSetInputEnabled]])
setAlpha (function: [[guiSetAlpha]])
setEnabled (function: [[guiSetEnabled]])
setFont (function: [[guiSetFont]])
setVisible (function: [[guiSetVisible]])
setText (function: [[guiSetText]])
setInputMode (function: [[guiSetInputMode]])
setProperty (function: [[guiSetProperty]])
setPosition (function: [[guiSetPosition]])
setSize (function: [[guiSetSize]])
==GuiWindow==
''Inherited from [[#GuiElement|GuiElement]]''

create (function: [[guiCreateWindow]])
setMovable (function: [[guiWindowSetMovable]])
setSizable (function: [[guiWindowSetSizable]])
==GuiButton==
''Inherited from [[#GuiElement|GuiElement]]''

create (function: [[guiCreateButton]])
==GuiEdit==
''Inherited from [[#GuiElement|GuiElement]]''

create (function: [[guiCreateEdit]])
getCaretIndex (function: [[guiEditGetCaretIndex]])
setCaretIndex (function: [[guiEditSetCaretIndex]])
setReadOnly (function: [[guiEditSetReadOnly]])
setMasked (function: [[guiEditSetMasked]])
setMaxLength (function: [[guiEditSetMaxLength]])
==GuiLabel==
''Inherited from [[#GuiElement|GuiElement]]''

create (function: [[guiCreateLabel]])
getFontHeight (function: [[guiLabelGetFontHeight]])
getTextExtent (function: [[guiLabelGetTextExtent]])
getColor (function: [[guiLabelGetColor]])
setColor (function: [[guiLabelSetColor]])
setHorizontalAlign (function: [[guiLabelSetHorizontalAlign]])
setVerticalAlign (function: [[guiLabelSetVerticalAlign]])
==GuiMemo==
''Inherited from [[#GuiElement|GuiElement]]''

create (function: [[guiCreateMemo]])
getCaretIndex (function: [[guiMemoGetCaretIndex]])
setCaretIndex (function: [[guiMemoSetCaretIndex]])
setReadOnly (function: [[guiMemoSetReadOnly]])
==GuiStaticImage==
''Inherited from [[#GuiElement|GuiElement]]''

create (function: [[guiCreateStaticImage]])
loadImage (function: [[guiStaticImageLoadImage]])
==GuiComboBox==
''Inherited from [[#GuiElement|GuiElement]]''

create (function: [[guiCreateComboBox]])
addItem (function: [[guiComboBoxAddItem]])
clear (function: [[guiComboBoxClear]])
removeItem (function: [[guiComboBoxRemoveItem]])
getSelected (function: [[guiComboBoxGetSelected]])
getItemText (function: [[guiComboBoxGetItemText]])
setItemText (function: [[guiComboBoxSetItemText]])
setSelected (function: [[guiComboBoxSetSelected]])
==GuiCheckBox==
''Inherited from [[#GuiElement|GuiElement]]''

create (function: [[guiCreateCheckBox]])
getSelected (function: [[guiCheckBoxGetSelected]])
setSelected (function: [[guiCheckBoxSetSelected]])
==GuiRadioButton==
''Inherited from [[#GuiElement|GuiElement]]''

create (function: [[guiCreateRadioButton]])
getSelected (function: [[guiRadioButtonGetSelected]])
setSelected (function: [[guiRadioButtonSetSelected]])
==GuiScrollPane==
''Inherited from [[#GuiElement|GuiElement]]''

create (function: [[guiCreateScrollPane]])
getHorizontalScrollPosition (function: [[guiScrollPaneGetHorizontalScrollPosition]])
getVerticalScrollPosition (function: [[guiScrollPaneGetVerticalScrollPosition]])
setHorizontalScrollPosition (function: [[guiScrollPaneSetHorizontalScrollPosition]])
setScrollBars (function: [[guiScrollPaneSetScrollBars]])
setVerticalScrollPosition (function: [[guiScrollPaneSetVerticalScrollPosition]])
==GuiScrollBar==
''Inherited from [[#GuiElement|GuiElement]]''

create (function: [[guiCreateScrollBar]])
getScrollPosition (function: [[guiScrollBarGetScrollPosition]])
setScrollPosition (function: [[guiScrollBarSetScrollPosition]])
==GuiProgressBar==
''Inherited from [[#GuiElement|GuiElement]]''

create (function: [[guiCreateProgressBar]])
getProgress (function: [[guiProgressBarGetProgress]])
setProgress (function: [[guiProgressBarSetProgress]])
==GuiGridList==
''Inherited from [[#GuiElement|GuiElement]]''

create (function: [[guiCreateGridList]])
addColumn (function: [[guiGridListAddColumn]])
addRow (function: [[guiGridListAddRow]])
autoSizeColumn (function: [[guiGridListAutoSizeColumn]])
clear (function: [[guiGridListClear]])
insertRowAfter (function: [[guiGridListInsertRowAfter]])
removeColumn (function: [[guiGridListRemoveColumn]])
removeRow (function: [[guiGridListRemoveRow]])
getItemData (function: [[guiGridListGetItemData]])
getItemText (function: [[guiGridListGetItemText]])
getRowCount (function: [[guiGridListGetRowCount]])
getSelectedItem (function: [[guiGridListGetSelectedItem]])
getItemColor (function: [[guiGridListGetItemColor]])
getColumnTitle (function: [[guiGridListGetColumnTitle]])
getHorizontalScrollPosition (function: [[guiGridListGetHorizontalScrollPosition]])
getVerticalScrollPosition (function: [[guiGridListGetVerticalScrollPosition]])
getSelectedCount (function: [[guiGridListGetSelectedCount]])
getSelectedItems (function: [[guiGridListGetSelectedItems]])
getColumnCount (function: [[guiGridListGetColumnCount]])
setItemData (function: [[guiGridListSetItemData]])
setItemText (function: [[guiGridListSetItemText]])
setScrollBars (function: [[guiGridListSetScrollBars]])
setSelectedItem (function: [[guiGridListSetSelectedItem]])
setSelectionMode (function: [[guiGridListSetSelectionMode]])
setSortingEnabled (function: [[guiGridListSetSortingEnabled]])
setColumnWidth (function: [[guiGridListSetColumnWidth]])
setItemColor (function: [[guiGridListSetItemColor]])
setColumnTitle (function: [[guiGridListSetColumnTitle]])
setHorizontalScrollPosition (function: [[guiGridListSetHorizontalScrollPosition]])
setVerticalScrollPosition (function: [[guiGridListSetVerticalScrollPosition]])

==GuiTabPanel==
''Inherited from [[#GuiElement|GuiElement]]''

create (function: [[guiCreateTabPanel]])
getSelectedTab (function: [[guiGetSelectedTab]])
setSelectedTab (function: [[guiSetSelectedTab]])
==GuiTab==
''Inherited from [[#GuiElement|GuiElement]]''

create (function: [[guiCreateTab]])
delete (function: [[guiDeleteTab]])
==GuiFont==
''Inherited from [[#Element|Element]]''

create (function: [[guiCreateFont]])
==Resource==
create (function: [[getResourceFromName]])
fromName (function: [[getResourceFromName]])
getGuiElement (function: [[getResourceGUIElement]])
getRootElement (function: [[getResourceRootElement]])
getName (function: [[getResourceName]])
getThis (function: [[getThisResource]])
getConfig (function: [[getResourceConfig]])
getConfig (function: [[getResourceConfig]])
getDynamicElementRoot (function: [[getResourceDynamicElementRoot]])
getExportedFunctions (function: [[getResourceExportedFunctions]])
getState (function: [[getResourceState]])
==Timer==
create (function: [[setTimer]])
destroy (function: [[killTimer]])
reset (function: [[resetTimer]])
isValid (function: [[isTimer]])
getDetails (function: [[getTimerDetails]])
==File==
create (function: [[fileOpen]])
destroy (function: [[fileClose]])
close (function: [[fileClose]])
new (function: [[fileCreate]])
delete (function: [[fileDelete]])
exists (function: [[fileExists]])
flush (function: [[fileFlush]])
getPos (function: [[fileGetPos]])
getSize (function: [[fileGetSize]])
isEOF (function: [[fileIsEOF]])
read (function: [[fileRead]])
rename (function: [[fileRename]])
setPos (function: [[fileSetPos]])
write (function: [[fileWrite]])
copy (function: [[fileCopy]])
==XML==
load (function: [[xmlLoadFile]])
unload (function: [[xmlUnloadFile]])
copy (function: [[xmlCopyFile]])
create (function: [[xmlCreateFile]])
destroy (function: [[xmlDestroyNode]])
setValue (function: [[xmlNodeGetValue]])
setAttribute (function: [[xmlNodeSetAttribute]])
setValue (function: [[xmlNodeSetValue]])
saveFile (function: [[xmlSaveFile]])
createChild (function: [[xmlCreateChild]])
findChild (function: [[xmlFindChild]])
getAttributes (function: [[xmlNodeGetAttributes]])
getChildren (function: [[xmlNodeGetChildren]])
getName (function: [[xmlNodeGetName]])
getParent (function: [[xmlNodeGetParent]])
getAttribute (function: [[xmlNodeGetAttribute]])
setName (function: [[xmlNodeSetName]])
==Camera==
fade (function: [[fadeCamera]])
getTarget (function: [[getCameraTarget]])
getInterior (function: [[getCameraInterior]])
getViewMode (function: [[getCameraViewMode]])
getGoggleEffect (function: [[getCameraGoggleEffect]])
setInterior (function: [[setCameraInterior]])
setTarget (function: [[setCameraTarget]])
setViewMode (function: [[setCameraViewMode]])
setGoggleEffect (function: [[setCameraGoggleEffect]])
setClip (function: [[setCameraClip]])
==Engine==
restoreCOL (function: [[engineRestoreCOL]])
restoreModel (function: [[engineRestoreModel]])
setAsynchronousLoading (function: [[engineSetAsynchronousLoading]])
setModelLODDistance (function: [[engineSetModelLODDistance]])
getVisibleTextureName (function: [[engineGetVisibleTextureNames]])
getModelLODDistance (function: [[engineGetModelLODDistance]])
getModelTextureNames (function: [[engineGetModelTextureNames]])
getModelIDFromName (function: [[engineGetModelIDFromName]])
getModelNameFromID (function: [[engineGetModelNameFromID]])
==EngineCOL==
''Inherited from [[#Element|Element]]''

create (function: [[engineLoadCOL]])
replace (function: [[engineReplaceCOL]])
==EngineTXD==
''Inherited from [[#Element|Element]]''

create (function: [[engineLoadTXD]])
import (function: [[engineImportTXD]])
==EngineDFF==
''Inherited from [[#Element|Element]]''

create (function: [[engineLoadDFF]])
replace (function: [[engineReplaceModel]])
==DxMaterial==
''Inherited from [[#Element|Element]]''

getSize (function: [[dxGetMaterialSize]])
==DxTexture==
''Inherited from [[#DxMaterial|DxMaterial]]''

create (function: [[dxCreateTexture]])
setEdge (function: [[dxSetTextureEdge]])
setPixels (function: [[dxSetTexturePixels]])
getPixels (function: [[dxGetTexturePixels]])
==DxFont==
create (function: [[dxCreateFont]])
getHeight (function: [[dxGetFontHeight]])
getTextWidth (function: [[dxGetTextWidth]])
==DxShader==
''Inherited from [[#DxMaterial|DxMaterial]]''

create (function: [[dxCreateShader]])
setValue (function: [[dxSetShaderValue]])
setTessellation (function: [[dxSetShaderTessellation]])
setTransform (function: [[dxSetShaderTransform]])
value (function: [[dxGetFontHeight]])
==DxScreenSource==
create (function: [[dxCreateScreenSource]])
update (function: [[dxUpdateScreenSource]])
==DxRenderTarget==
create (function: [[dxCreateRenderTarget]])
setAsTarget (function: [[dxSetRenderTarget]])

[[Category:OOP]]

SetPlayerName

2018-07-22T01:02:08Z

Citizen: Making it clear spaces aren't allowed. Can not hurt and saves time.

{{Server function}}
__NOTOC__
This function changes the specified [[player]]'s name. Note that any change made to a players name with this function is not saved in their settings so the name change only lasts till they disconnect.

==Syntax==
<syntaxhighlight lang="lua">
bool setPlayerName ( player thePlayer, string newName )
</syntaxhighlight>

{{OOP||[[player]]:setName|name|getPlayerName}}

===Required Arguments===
*'''thePlayer:''' the [[player]] that will have its name set.
*'''newName:''' the new name to set for the player.

===Returns===
Returns ''true'' if the player name was changed succesfully, ''false'' if invalid arguments are specified.

===Limits===
* Only ASCII characters between 33 and 126 are allowed (basic latin, no spaces):
<nowiki>!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~</nowiki>
* Minimal player name length is 1 character.
* Maximum player name length is 22 characters.
* Player names are case-insensitive. It is not possible to have two clients with same name but different character case.

==Example==
<section name="Server" class="server" show="true">
This example adds a tag before a player's nickname via a /changetag command
<syntaxhighlight lang="lua">

-- Define the function for this command (/changetag, as defined below)
-- source = the player that triggered this command
-- command = the command passed into the function (changetag)
-- thePlayer = the player that you wish to add a tag to
-- tag = the tag to add to the players nickname
function tagPlayer ( source, command, thePlayer, tag )
-- Attempt to grab the element id for the player from the parsed name.
local sPlayerElement = getPlayerFromName ( thePlayer )
-- Check to see if the player were changing the tag for exists.
if ( sPlayerElement ) then
-- make sure that the element type of thePlayer is acctually pointing to a player element
if getElementType ( sPlayerElement ) == "player" then
-- we store the player's current name,
local oldName = getPlayerName ( sPlayerElement )
-- append the tag passed to this function before it
local taggedName = tag .. oldName
-- then set it as his new name
setPlayerName ( sPlayerElement, taggedName )
-- Tell the player who triggerd the command that the tag has been applied
outputChatBox ( "Player " .. thePlayer .. "'s tag changed to " .. taggedName, source )
end
else
-- Tell the player who triggerd the command that the player could not be found
outputChatBox ( "Unable to change player tag: Player " .. thePlayer .. " not found", source )
end
end
-- Add a command handler for either the console or / chat commands
-- Example: /changetag <playername> <tag>
addCommandHandler ( "changetag", tagPlayer )
</syntaxhighlight>
</section>

==See Also==
{{Player functions}}
[[ru:setPlayerName]]

FR/Introduction Programmation

2018-07-19T18:37:39Z

Citizen: Typos again

Les ressources sont les parties clées de MTA. Une ressource est un dossier ou un .zip qui contient plusieurs fichiers, ainsi qu'une meta qui dit au serveur comment la resource doit-elle être chargée. Une ressource peut être comparée comme un programme qu'on peut lancer ou arrêter, il est possible de lancer plusieurs ressources en même temps.

Tout ce qui a un rapport avec la programmation se passe dans les ressources, se que fait la ressource, définie si c'est un gamemode, une map or quelque chose d'autre. MTA s'installe avec des ressources que vous pouvez facultativement utiliser dans vos gamemodes, comme la ressource "maplimits" pour garder les joueurs dans une certaine zone ou encore "deathpickups" pour créer des pickups pour ramasser une arme.

'''La première chose à faire avant de pouvoir programmer en Lua, c'est de se procurer un éditeur de texte qui supporte le Lua. Il vous sera beaucoup plus facile que de le faire avec le bloc-note de Windows. Nous vous recommandons donc [https://code.visualstudio.com/ Visual Studio Code] ou [http://notepad-plus.sourceforge.net/uk/site.htm Notepad++]. Il y a aussi un logiciel non officiel [[MTASE|MTA Script Editor]] (malheureusement l'auteur ne travail plus dessus) que vous pouvez tester.'''

Pour '''Visual Studio Code''', il est également recommandé d'installer [https://marketplace.visualstudio.com/items?itemName=subtixx.mtasa-lua ce plugin] qui permettra à l'éditeur de reconnaître les fonctions MTA, proposer de l'auto-complétion ainsi que la documentation associée.

==Créer un script qui fonctionne==
Nous allons voir tout d'abord comment créer un simple script étapes par étapes qui permettra aux joueurs de se déplacer dans la ville. Dans ce tutoriel, on utilisera notepad++.
===Où sont tous les scripts ?===
Laissez moi d'abord vous présenter comment s’organise une ressource. Allez dans votre dossier '''MTA San Andreas''' et et suivez le chemin suivant:

/server/mods/deathmatch/resources/

Vous y verrez de nombreux fichier avec l'extension .zip, se sont des ressources avec à l'intérieur des exemples de scripts . Toutes les ressources chargées sont dézippées par le serveur afin de pouvoir les exécuter (les .zip ne sont pas obligatoires, vous pouvez aussi laissez votre ressource en tant que dossier). Pour créer votre propre ressource, créez simplement un nouveau dossier et nommez le comme vous voulez (Ne pas utiliser d'espace, utilisez plutôt un _) . Nommez le "myserveur" pour ce tutoriel.

Maintenant entrez dans votre dossier. Le chemin devrait donc être

/server/mods/deathmatch/resources/myserveur/

===Identifier votre ressource===
Pour que le serveur puisse savoir ce que contient votre ressource, un fichier ''meta.xml'' doit être créé afin d'établir une liste du contenu du dossier. Cette 'meta.xml' doit être à la racine de votre ressource ( et non pas dans un autre sous-dossier ), donc dans le dossier "myserveur" dans notre cas. Donc ouvrez notepadd++, créer un nouveau fichier (Ctrl+N), puis faite "Enregistrez sous ..." (Ctrl+Alt+S), dans "Nom:" vous écrivez "meta" et dans "Type:", sélectionnez "*.xml" ( avant-dernier de la liste ), sauvegardez le dans votre dossier "myserveur".

Maintenant, écrivez le code suivant dans votre ''meta.xml'':
<syntaxhighlight lang="xml">
<meta>
<info author="Votre Nom" type="gamemode" name="Mon serveur" description="Mon premier serveur MTA" />
<script src="script.lua" />
</meta>
</syntaxhighlight>
Dans la balise ''<info />'', il y a le champ "type" qui indique si la ressource est un ''gamemode'' ou une ''map'', on y reviendra plus tard. Un gamemode est ce dont vous avez besoin pour que votre serveur est une base.

La balise ''<script />'' indique les scripts qui sont dans la ressource, que l'on va maintenant créer.
===Créer un script simple===
Notez que dans la balise ''<script />'', le fichier .lua n'est pas dans un autre sous-dossier. Donc on va créer notre script.lua au même endroit que notre meta.xml ( Reproduisez la même opération mais "Nom:" écrivez 'script' et pour "Type:" choisissez 'Lua(*.lua)' ) puis copier-coller le code suivant:
<syntaxhighlight lang="lua">
function joinHandler()
local x = 1959.55
local y = -1714.46
local z = 10
spawnPlayer(source, x, y, z)
fadeCamera(source, true)
setCameraTarget(source, source)
outputChatBox("Bienvenue sur mon serveur", source)
end
addEventHandler("onPlayerJoin", getRootElement(), joinHandler)
</syntaxhighlight>
Ce script va fous faire apparaître aux coordonnées (x, y, z) spécifié dans le code, lorsque vous connecterez au serveur. La fonction ''fadeCamera'' sinon l'écran restera noir. Vous devez aussi dire à la camera de suivre le joueur grâce à la fonction 'setCameraTarget' (sinon il verra une mer bleu).

La variable '''source''' indique qui 'déclenche' la fonction. Le fonction se 'déclenche' lorsqu'un joueur rejoins le serveur, vous utiliserez cette variable pour voir qui à rejoins le serveur. Donc lorsque un joueur( "la source" ) rejoindra notre serveur, on le fera apparaître aux coordonnées indiquées .

Focalisons-nous sur [[addEventHandler]], vous pouvez voir 3 choses: 'onPlayerJoin', qui indique quand exécuter la fonction X. getRootElement(), qui indique qui/quoi peut être déclencher la fonction (getRootElement() veut dire toutes les choses et tous les joueurs). Et enfin la fonction X à exécuter (ici joinHandler). Pour les autres détails, nous verrons plus tard dans d'autres exemples mais tout d'abord testons notre premier gamemode!

===Lancer le gamemode===
Pour lancer le serveur, lancer simplement le 'MTA Server.exe' qui se trouve dans votre dossier 'MTA San Andreas > server'. Une liste d'info concernant le serveur apparaîtra en premier; notez le port du serveur ( 22003 par défaut ), vous en aurez besoin pour rejoindre le serveur. Après, le serveur charge toutes les ressources du dossier 'resource', et enfin "ready to accept connections!"

Avant de pouvoir vous connecter, vous devez lancer votre gamemode. Tapez "start myserveur" et appuyer sur Entrer. Le serveur va alors lancer le gamemode que nous avons créé, et nous affichera aussi les erreurs s'il y en a. Maintenant, vous pouvez lancer MTA, cliquez sur "Quick Connect" et écrivez ceci: Dans Host: le1er champ: 127.0.0.1 ou localhost ( cela signifie que vous vous connectez au serveur du pc actuel ) et le 2ème champ: le port ( ici 22003 ) et cliquez sur 'Connect'. Si tout se passe bien, après quelques secondes, vous devriez apparaître et pouvoir allez où vous voulez.

Ensuite nous allons créer une commande que les joueurs pourront utiliser pour faire apparaître une voiture à coté d'eux.

==Créer une commande==
Revenons à l'intérieur de notre ''script.lua''. Tout d'abord, nous devons créer une fonction qu'on pourra appeler/exécuter grâce à notre commande et la fonction 'addCommandHandler' afin de créer la commande que les joueurs pourront taper dans le chat( T ) ou la console( F8 ).

<syntaxhighlight lang="lua">
-- On crée la fonction qui sera appelée par notre commande avec les arguments: thePlayer, command, vehicleModel
function createVehicleForPlayer(thePlayer, commandName, vehicleModel)
-- Ici on crée le véhicule
end
-- on crée la commande et on l'attache à notre fonction
addCommandHandler("createVehicle", createVehicleForPlayer)
</syntaxhighlight>
''Note: Grâce au wiki, vous pouvez cliquer sur le nom des fonctions et cela vous redirigera sur la documentation de cette fonction.''

====A propos du addCommandHandler====
Le premier argument du [[addCommandHandler]] est le nom de la commande the player will be able to enter, le second le nom de la fonction à appeler, dans notre cas, ''createVehicleForPlayer''.

Si vous avez déjà de l'expérience dans le codage, vous savez qu'un fonction s'appelle comme ceci:
<syntaxhighlight lang="lua">
nomDeLaFonction(argument1, argument2, argument3, ..)
</syntaxhighlight>
Si l'on regarde bien l'exemple ci-dessus, nous pouvons voir que l'argument1 est thePlayer and argument2 le commandName. thePlayer est celui qui à tapé la commande et commandName contient le nom de la commande qu'il à tapé. Donc si un joueur tape "/greet", cet argument va contenir "greet". argument3 c'est ce que le joueur à tapé en plus de la commande, vous allez apprendre ceci dans le tutoriel. N'oubliez jamais que les deux premiers arguments sont les arguments standards, mais vous pouvez les renommé si vous voulez, seul l'ordre est important.

Par exemple: Un joueur tape "createVehicle 468" pour faire apparaître une Sanchez, la fonction addCommandHandler va appeler notre fonction '''createVehicleForPlayer''', comme ceci:
<syntaxhighlight lang="lua">
createVehicleForPlayer(thePlayer,"createVehicle","468") -- thePlayer est l’élément joueur qui a tapé la commande
</syntaxhighlight>
Comme nous pouvons le voir, il fournit plusieurs paramètres: le joueur qui a tapé la commande, la commande qu'il a tapé, et n'importe quelle texte qu'il a mis après, dans notre cas, "468" comme id de la Sanchez. Les deux premiers paramètres sont les même pour tous les addCommandHandler qu'on peut retrouver sur la page du [[addEventHandler]]. Vous devez toujours définir au moins ces deux paramètres pour utiliser les arguments après eux (par exemple pour traiter le texte qui a été entré après la commande, comme dans notre exemple le modèle du véhicule).

''Note: Vous devez créer la commande APRÈS la fonction que vous allez utiliser pour cette commande, sinon il ne trouvera pas la fonction.''

====Ecrire la fonction====
Pour remplir notre fonction d'instructions, nous devons d'abord pensez à ce que nous devons faire:
* Récupérer la position du joueur, donc on connaîtra la position où faire apparaître le véhicule (on veut le faire apparaître à droite du joueur)
* Calculer la position où faire apparaître le véhicule (nous ne voulons pas que le véhicule apparaisse dans le joueur)
* Faire apparaître les véhicule
* Vérifier si le véhicule a bien apparus, ou afficher un message d'erreur.

Pour ça, nous devons utiliser plusieurs fonctions. Pour trouver la fonction que nous devons utiliser, il faut aller faire un tour dans la [[Scripting Functions|La liste des fonctions serveur]]. D'abord nous avons besoin d'une fonction pour obtenir la position du joueur. Puisque les joueurs sont des éléments, nous devons allez dans la rubrique '''Element functions''' où l'on pourra trouver la fonction [[getElementPosition]]. En cliquant sur le nom de la fonction, le wiki va vous afficher sa description. On peut y voir la syntaxe, qu'est-ce que la fonction retourne. La syntaxe nous montre les argument qu'on peut ou qu'on doit envoyer.

Pour [[getElementPosition]], la syntaxe est:
<syntaxhighlight lang="lua">
float, float, float getElementPosition ( element theElement )
</syntaxhighlight>

Les trois '''float''' devant le nom de la fonction est le type de variable que la fonction nous retourne. Dans notre cas, la fonction retourne trois nombres à virgule(x, y et z). Dans les parenthèses, on peut voir les arguments que l'on doit envoyer, dans notre cas, l’élément dont on veut récupérer la position, le joueur dans notre exemple.

<syntaxhighlight lang="lua">
function createVehicleForPlayer(thePlayer, command, vehicleModel)
-- on récupère la position x,y,z dans des variables locales
-- une variable locale n'existe que dans le "périmètre" actuel. Ici, les variable x, y et z sont des variables locales qui se détruiront à la fin de la fonction.
local x,y,z = getElementPosition(thePlayer)
end
</syntaxhighlight>

Ensuite, il faut s'assurer que le véhicule n'apparaît pas directement dans le joueur, donc on ajoute quelques unités à la variable ''x'', qui le fera apparaître plus à l'est par rapport au joueur.

<syntaxhighlight lang="lua">
function createVehicleForPlayer(thePlayer, command, vehicleModel)
local x,y,z = getElementPosition(thePlayer) -- On prent la position du joueur qui a tapé la commande
x = x + 5 -- on ajoute 5 unité sur l'axes des x
end
</syntaxhighlight>

Maintenant nous avons besoin d'une autre fonction, celle qui va faire apparaître le véhicule. Nous allons la cherché encore une fois dans la [[Scripting Functions|liste des fonctions serveur]], mais cette fois, comme nous parlons d'un véhicule, nous devons donc aller dans la catégorie'''Vehicle functions''', où l'on va trouver la fonction [[createVehicle]]. Dans la syntaxe, nous pouvons voir que cette fonction ne retourne qu'une seule variable, le véhicule ( de type élément ) que nous venons de créer. Nous pouvons aussi voir qu'il y a des arguments entre crochets [], cela veut dire que ce sont des arguments optionnels.

Nous avons déjà tous les arguments pour la fonction [[createVehicle]] dans notre fonction: La position que nous avons juste calculée dans les variables "x, y, z" et l'id du véhicule que nous avons fourni par la commande ("/createVehicle 468") et qui est stocké dans la variable ''vehicleModel''.

<syntaxhighlight lang="lua">
function createVehicleForPlayer(thePlayer, command, vehicleModel)
local x,y,z = getElementPosition(thePlayer) -- récupere la position du joueur dans les variables x, y et z
x = x + 5 -- rajoute 5 unités sur x
-- on crée le véhicule et on enregistre l'élément de type "vehicle" dans la variable ''createdVehicle''
local createdVehicle = createVehicle(tonumber(vehicleModel),x,y,z)
end
</syntaxhighlight>

Avec cette variable, on pourrait faire pas mal de choses sympa, mais ici nous allons juste vérifier si le véhicule à bien été créé ou non.
Sur le wiki de la fonction [[createVehicle]], il y a la partie nommée '''Returns''', la fonction va retourner ''false'' si la voiture n'a pas été créé. Du coups, on va regarder la valeur de la variable ''createdVehicle''.

Voilà notre code complet:
<syntaxhighlight lang="lua">
function createVehicleForPlayer(thePlayer, command, vehicleModel)
local x,y,z = getElementPosition(thePlayer) -- On prent la position du joueur qui a tapé la commande
x = x + 5 -- on ajoute 5 unités à x
local createdVehicle = createVehicle(tonumber(vehicleModel),x,y,z) -- on crée le véhicule demandé par le joueur et on récupère ce que nous retourne la fonction dans la variable createdVehicle
-- On vérifie si la valeur retournée est égal à ''false'' ( ce qui signifie que ça n'a pas marché )
if (createdVehicle == false) then
-- si c'est le cas, on affiche un message d'erreur dans la chatbox mais seulement pour le joueur.
outputChatBox("Erreur lors de la création du véhicule.",thePlayer)
end
end
addCommandHandler("createVehicle", createVehicleForPlayer)
</syntaxhighlight>

Comme vous pouvez le voir, nous avons utilisé une nouvelle fonction: [[outputChatBox]]. Vous devriez maintenant pouvoir regarder la description de cette fonction par vous même.

==Ce que vous devez savoir==
Vous avez déjà lu quelques informations sur les ressources, les commandes et trouvez des fonctions dans le wiki, mais il y a encore beaucoup à apprendre. Cette section vous donnera une vue d'ensemble plutôt courte sur certaines de ces choses, tout en regardant les pages du wiki si possible.
===Les scripts client et serveur===
Vous pouvez avoir déjà remarqué ces termes (serveur/client) quelque part sur ce wiki, le plus souvent pour les fonctions. MTA ne supporte pas seulement les scripts exécuté par le serveur et des commandes (comme celle que l'on vient de faire) ou d'autres fonctions, mais aussi les scripts exécute par le client MTA, ceux des joueurs qui se connecte au serveur. La raison est que certaines fonctions de MTA doit être du coté client comme par exemple le GUI - Graphical User Interface - ( Pour tout ce qui est fenêtres, boutons, etc ), d'autres devraient être du côté client parce qu'ils fonctionnent mieux mais d'autres sont mieux pensées pour être du côté serveur ou ne fonctionne tout simplement pas du côté client.

La plupart de vos scripts (gamemodes, maps) seront surement du côté serveur, comme celui que nous avons fait tout à l'heure. Si vous vous heurtez à quelque chose qui ne peut pas être résolu du côté serveur, vous devrez probablement le faire côté client. Pour un script client, vous devriez créer un script ordinaire (par exemple appelé ''client.lua'') et spécifié dans la meta.xml, comme ceci:
<syntaxhighlight lang="xml">
<script src="client.lua" type="client" />
</syntaxhighlight>
L'attribut ''type'' est par defaut 'server', donc nous avons juste besoin de spécifier que c'est un script client. Lorsque vous faites ceci, le fichier va être télécharger par le joueur sur son ordinateur lorsqu'il se connecte au serveur. Plus d'infos: [[Client side scripts]].

===Ressources plus complexes===
La section précédente nous a montré brièvement comment ajouter des scripts clients à la ressource. Penchons nous maintenant sur la ''meta.xml'' et ce qu'elle fait.

====Premier exemple - Un script utile====
<syntaxhighlight lang="xml">
/admin_commands
/meta.xml
/commands.lua
/client.lua
</syntaxhighlight>
<syntaxhighlight lang="xml">
<meta>
<info author="Someguy" description="admin commands" />
<script src="commands.lua" />
<script src="client.lua" type="client" />
</meta>
</syntaxhighlight>

* Le "commands.lua" fournit quelques commandes d'admin, comme le fait d'interdire un joueur, en bannissant ou quelque chose d'autre ce qui peut être utilisé par l'admin du serveur
* Le "client.lua" fournit un GUI pour être capable d'exécuter les actions mentionnées facilement

Cet exemple de script doit tourner tout le temps (peut être même démarré en même temps que le serveur) car ces commandes d'admin peuvent être appelé à n'importe quelle moment.

====Second exemple - Un gamemode====
<syntaxhighlight lang="xml">
/counterstrike
/meta.xml
/counterstrike.lua
/buymenu.lua
</syntaxhighlight>
<syntaxhighlight lang="xml">
<meta>
<info author="Quelqu'un" description="Counterstrike remake" type="gamemode" />
<script src="counterstrike.lua" />
<script src="buymenu.lua" type="client" />
</meta>
</syntaxhighlight>

* Le "counterstrike.lua" contient des caractéristiques semblables aux dispositifs suivants :
** Laisser les joueurs choisirent leur équipe et les faire apparaître
** Leur fournir des armes, des cibles et des instructions (peut-être lues d'une carte, voir ci-dessous)
** Définir les règles du jeu, par exemple. La partie se finie, ce qui se produit quand un joueur meurt
** .. et peut-être encore plus
* Le "buymenu.lua" est un script du côté client et crée un menu pour acheter des armes

Cet exemple peut s'appeler un gamemode, il modifie le gameplay, mais définit réellement les règles de celui-ci. Le "type" attribut indique que cet exemple fonctionne avec [[Map Manager]], encore une autre ressource qui a été écrite par l'équipe de MTA pour contrôler des gamemodes et le chargement de cartes. On recommande fortement que vous basiez vos gamemodes sur les techniques qu'il fournit.

Ceci signifie également que ce gamemode ne fonctionnera probablement pas sans carte. Les gamemodes devront toujours être aussi génériques que possible. Un exemple de gamemode utilisant une carte est énoncé dans le prochain exemple.

====Troisième exemple - Une carte====
<syntaxhighlight lang="xml">
/cs-airport
/meta.xml
/airport.map
/airport.lua
</syntaxhighlight>
<syntaxhighlight lang="xml">
<meta>
<info author="Quelqu'un" description="Counterstrike airport map" type="map" gamemodes="counterstrike" />
<map src="airport.map" />
<script src="airport.lua" />
</meta>
</syntaxhighlight>

* Le "airport.map" dans le fichier XML fournit des informations au sujet de la carte au gamemode, celui-ci peut inclure :
** Là où les joueurs devraient apparaître, avec quelles armes, avec quelle équipe
** Ce qui sont les cibles
** Temps, heure du monde, Limite de temps
** Fournir les véhicules
* Le ''airport.lua'' peut contenir des actions relatifs a la map comme:
** Ouvrir une certaine porte ou faire exploser quelque chose quand une autre chose de spécifique se produit
** Créer ou déplacer quelques objets faits sur commande, ou manœuvrez les objets qui sont créés dans le fichier .map
** .. toutes autre choses relatifs aux objets du .map

Comme vous pouvez le voir, l'attribut "type" a été changé en 'map', pour dire au [[Map Manager]] que cette ressource est une carte, tandis que l'attribut "gamemodes" indique pour quels gamemodes cette carte est valide, dans ce cas-ci le gamemode de l'exemple de tout à l'heure.
Ce qui peut venir comme une surprise est qu'il y a aussi un script dans la ressource de carte. Évidemment ce n'est pas nécessaire dans une carte, mais ouvre une large gamme de possibilités pour les créateurs de cartes.

Le "airport.map" pourrait être semblable à ceci :
<syntaxhighlight lang="xml">
<map mode="deathmatch" version="1.0">
<terrorists>
<spawnpoint posX="2332.23" posY="-12232.33" posZ="4.42223" skins="23-40" />
</terrorists>
<counterterrorists>
<spawnpoint posX="2334.23443" posY="-12300.233" posZ="10.2344" skins="40-50" />
</counterterrorists>

<bomb posX="23342.23" posY="" posZ="" />

<vehicle posX="" posY="" posZ="" model="602" />
<vehicle posX="" posY="" posZ="" model="603" />
</map>
</syntaxhighlight>

Quand un gamemode est commencé avec une carte, les ressources de carte est automatiquement démarrée par le mapmanager et les renseignements qu'il contient peut être lu par le gamemode. Quand la carte change, la ressource de carte actuelle est arrêtée et la ressource de carte suivante est commencée. Pour une explication plus détaillée et des exemples pour savoir comment les ressources de cartes sont utilisées dans le script principal, visitez s'il vous plaît la page [[Writing Gamemodes]].

===Événements===
MTA utilise les événements pour signaler aux scripts que des choses s'est passé dans le jeu. Par exemple quand un joueur meurt, l’événement [[onPlayerWasted]] est déclenché. Pour exécuter n'importe quelle action quand un joueur meurt, votre script doit donner le nom de sa fonction à exécuter lorsque cet événement est déclenché par MTA grâce à la fonction [[addEventHandler]]. C'est très similaire à la fonction qui permet de déclencher une fonction via une commande.

Cet exemple produira un message avec le nom du joueur qui est mort :
<syntaxhighlight lang="lua">
function playerDied(totalAmmo, killer, killerWeapon, bodypart)
outputChatBox(getPlayerName(source).." died!")
end
addEventHandler("onPlayerWasted", getRootElement(), playerDied)
</syntaxhighlight>

Au lieu de lister les arguments qui sont nécessaires, la page de documentation pour un événement indique quels paramètres sont passés à la fonction que vous attachez à cet événement. Un autre point important est la variable "source", qui existe dans les fonction d’événement. Il ne doit pas être ajoutés à la liste des paramètres de la fonction, mais elle existe quand même à l'intérieur de votre fonction. Cette variable a une valeur différente d'un événement à l'autre, pour les événements de joueurs (comme dans l'exemple au-dessus) c'est le joueur responsable de son déclenchement. Comme autre exemple, vous pouvez jeter un coup d'œil au script qui permet de faire apparaître le joueur dans la première section pour avoir une idée de comment utiliser cette variable "source".

==Où aller d'ici==
Vous devriez maintenant être familier avec les aspects les plus fondamentaux du scripting sur MTA et aussi un peu avec la documentation. Le [[Main_Page]] vous fournit des liens vers plus de renseignements, tutoriels et Références qui permettent de se plonger plus profondément dans les thèmes que vous désirez apprendre.

D'ici nous recommandons de lire les tutos sur le [[debugging]]. Les bonnes pratiques pour débuguer vos scripts sont une nécessité absolue quand vous faites des scripts.

[[ru:Scripting Introduction]]
[[it:Introduzione allo scripting]]
[[es:Introducción a la Programación]]

FR/Introduction Programmation

2018-07-19T18:36:20Z

Citizen: Added Visual Studio Code as recommended IDE and removed Lua Edit. Fixed a lot of typos too.

Les ressources sont les parties clées de MTA. Une ressource est un dossier ou un .zip qui contient plusieurs fichiers, ainsi qu'une meta qui dit au serveur comment la resource doit-elle être chargée. Une ressource peut être comparée comme un programme qu'on peut lancer ou arrêter, il est possible de lancer plusieurs ressources en même temps.

Tout ce qui a un rapport avec la programmation se passe dans les ressources, se que fait la ressource, définie si c'est un gamemode, une map or quelque chose d'autre. MTA s'installe avec des ressources que vous pouvez facultativement utiliser dans vos gamemodes, comme la ressource "maplimits" pour garder les joueurs dans une certaine zone ou encore "deathpickups" pour créer des pickups pour ramasser une arme.

'''La première chose à faire avant de pouvoir programmer en Lua, c'est de se procurer un éditeur de texte qui supporte le Lua. Il vous sera beaucoup plus facile que de le faire avec le bloc-note de Windows. Nous vous recommandons donc [https://code.visualstudio.com/ Visual Studio Code] ou [http://notepad-plus.sourceforge.net/uk/site.htm Notepad++]. Il y a aussi un logiciel non officiel [[MTASE|MTA Script Editor]] (malheureusement l'auteur ne travail plus dessus) que vous pouvez tester.'''

Pour '''Visual Studio Code''', il est également recommandé d'installer [https://marketplace.visualstudio.com/items?itemName=subtixx.mtasa-lua ce plugin] qui permettra à l'éditeur de reconnaître les fonctions MTA, proposer de l'auto-complétion ainsi que la documentation associée.

==Créer un script qui fonctionne==
Nous allons voir tout d'abord comment créer un simple script étapes par étapes qui permettra aux joueurs de se déplacer dans la ville. Dans ce tutoriel, on utilisera notepad++.
===Où sont tous les scripts ?===
Laissez moi d'abord vous présenter comment s’organise une ressource. Allez dans votre dossier '''MTA San Andreas''' et et suivez le chemin suivant:

/server/mods/deathmatch/resources/

Vous y verrez de nombreux fichier avec l'extension .zip, se sont des ressources avec à l'intérieur des exemples de scripts . Toutes les ressources chargées sont dézippées par le serveur afin de pouvoir les exécuter (les .zip ne sont pas obligatoires, vous pouvez aussi laissez votre ressource en tant que dossier). Pour créer votre propre ressource, créez simplement un nouveau dossier et nommez le comme vous voulez (Ne pas utiliser d'espace, utilisez plutôt un _) . Nommez le "myserveur" pour ce tutoriel.

Maintenant entrez dans votre dossier. Le chemin devrait donc être

/server/mods/deathmatch/resources/myserveur/

===Identifier votre ressource===
Pour que le serveur puisse savoir ce que contient votre ressource, un fichier ''meta.xml'' doit être créé afin d'établir une liste du contenu du dossier. Cette 'meta.xml' doit être à la racine de votre ressource ( et non pas dans un autre sous-dossier ), donc dans le dossier "myserveur" dans notre cas. Donc ouvrez notepadd++, créer un nouveau fichier (Ctrl+N), puis faite "Enregistrez sous ..." (Ctrl+Alt+S), dans "Nom:" vous écrivez "meta" et dans "Type:", sélectionnez "*.xml" ( avant-dernier de la liste ), sauvegardez le dans votre dossier "myserveur".

Maintenant, écrivez le code suivant dans votre ''meta.xml'':
<syntaxhighlight lang="xml">
<meta>
<info author="Votre Nom" type="gamemode" name="Mon serveur" description="Mon premier serveur MTA" />
<script src="script.lua" />
</meta>
</syntaxhighlight>
Dans la balise ''<info />'', il y a le champ "type" qui indique si la ressource est un ''gamemode'' ou une ''map'', on y reviendra plus tard. Un gamemode est ce dont vous avez besoin pour que votre serveur est une base.

La balise ''<script />'' indique les scripts qui sont dans la ressource, que l'on va maintenant créer.
===Créer un script simple===
Notez que dans la balise ''<script />'', le fichier .lua n'est pas dans un autre sous-dossier. Donc on va créer notre script.lua au même endroit que notre meta.xml ( Reproduisez la même opération mais "Nom:" écrivez 'script' et pour "Type:" choisissez 'Lua(*.lua)' ) puis copier-coller le code suivant:
<syntaxhighlight lang="lua">
function joinHandler()
local x = 1959.55
local y = -1714.46
local z = 10
spawnPlayer(source, x, y, z)
fadeCamera(source, true)
setCameraTarget(source, source)
outputChatBox("Bienvenue sur mon serveur", source)
end
addEventHandler("onPlayerJoin", getRootElement(), joinHandler)
</syntaxhighlight>
Ce script va fous faire apparaître aux coordonnées (x, y, z) spécifié dans le code, lorsque vous connecterez au serveur. La fonction ''fadeCamera'' sinon l'écran restera noir. Vous devez aussi dire à la camera de suivre le joueur grâce à la fonction 'setCameraTarget' (sinon il verra une mer bleu).

La variable '''source''' indique qui 'déclenche' la fonction. Le fonction se 'déclenche' lorsqu'un joueur rejoins le serveur, vous utiliserez cette variable pour voir qui à rejoins le serveur. Donc lorsque un joueur( "la source" ) rejoindra notre serveur, on le fera apparaître aux coordonnées indiquées .

Focalisons-nous sur [[addEventHandler]], vous pouvez voir 3 choses: 'onPlayerJoin', qui indique quand exécuter la fonction X. getRootElement(), qui indique qui/quoi peut être déclencher la fonction (getRootElement() veut dire toutes les choses et tous les joueurs). Et enfin la fonction X à exécuter (ici joinHandler). Pour les autres détails, nous verrons plus tard dans d'autres exemples mais tout d'abord testons notre premier gamemode!

===Lancer le gamemode===
Pour lancer le serveur, lancer simplement le 'MTA Server.exe' qui se trouve dans votre dossier 'MTA San Andreas > server'. Une liste d'info concernant le serveur apparaîtra en premier; notez le port du serveur ( 22003 par défaut ), vous en aurez besoin pour rejoindre le serveur. Après, le serveur charge toutes les ressources du dossier 'resource', et enfin "ready to accept connections!"

Avant de pouvoir vous connecter, vous devez lancer votre gamemode. Tapez "start myserveur" et appuyer sur Entrer. Le serveur va alors lancer le gamemode que nous avons créé, et nous affichera aussi les erreurs s'il y en a. Maintenant, vous pouvez lancer MTA, cliquez sur "Quick Connect" et écrivez ceci: Dans Host: le1er champ: 127.0.0.1 ou localhost ( cela signifie que vous vous connectez au serveur du pc actuel ) et le 2ème champ: le port ( ici 22003 ) et cliquez sur 'Connect'. Si tout se passe bien, après quelques secondes, vous devriez apparaître et pouvoir allez où vous voulez.

Ensuite nous allons créer une commande que les joueurs pourront utiliser pour faire apparaître une voiture à coté d'eux.

==Créer une commande==
Revenons à l'intérieur de notre ''script.lua''. Tout d'abord, nous devons créer une fonction qu'on pourra appeler/exécuter grâce à notre commande et la fonction 'addCommandHandler' afin de créer la commande que les joueurs pourront taper dans le chat( T ) ou la console( F8 ).

<syntaxhighlight lang="lua">
-- On crée la fonction qui sera appelée par notre commande avec les arguments: thePlayer, command, vehicleModel
function createVehicleForPlayer(thePlayer, commandName, vehicleModel)
-- Ici on crée le véhicule
end
-- on crée la commande et on l'attache à notre fonction
addCommandHandler("createVehicle", createVehicleForPlayer)
</syntaxhighlight>
''Note: Grâce au wiki, vous pouvez cliquer sur le nom des fonctions et cela vous redirigera sur la documentation de cette fonction.''

====A propos du addCommandHandler====
Le premier argument du [[addCommandHandler]] est le nom de la commande the player will be able to enter, le second le nom de la fonction à appeler, dans notre cas, ''createVehicleForPlayer''.

Si vous avez déjà de l'expérience dans le codage, vous savez qu'un fonction s'appelle comme ceci:
<syntaxhighlight lang="lua">
nomDeLaFonction(argument1, argument2, argument3, ..)
</syntaxhighlight>
Si l'on regarde bien l'exemple ci-dessus, nous pouvons voir que l'argument1 est thePlayer and argument2 le commandName. thePlayer est celui qui à tapé la commande et commandName contient le nom de la commande qu'il à tapé. Donc si un joueur tape "/greet", cet argument va contenir "greet". argument3 c'est ce que le joueur à tapé en plus de la commande, vous allez apprendre ceci dans le tutoriel. N'oubliez jamais que les deux premiers arguments sont les arguments standards, mais vous pouvez les renommé si vous voulez, seul l'ordre est important.

Par exemple: Un joueur tape "createVehicle 468" pour faire apparaître une Sanchez, la fonction addCommandHandler va appeler notre fonction '''createVehicleForPlayer''', comme ceci:
<syntaxhighlight lang="lua">
createVehicleForPlayer(thePlayer,"createVehicle","468") -- thePlayer est l’élément joueur qui a tapé la commande
</syntaxhighlight>
Comme nous pouvons le voir, il fournit plusieurs paramètres: le joueur qui a tapé la commande, la commande qu'il a tapé, et n'importe quelle texte qu'il a mis après, dans notre cas, "468" comme id de la Sanchez. Les deux premiers paramètres sont les même pour tous les addCommandHandler qu'on peut retrouver sur la page du [[addEventHandler]]. Vous devez toujours définir au moins ces deux paramètres pour utiliser les arguments après eux (par exemple pour traiter le texte qui a été entré après la commande, comme dans notre exemple le modèle du véhicule).

''Note: Vous devez créer la commande APRÈS la fonction que vous allez utiliser pour cette commande, sinon il ne trouvera pas la fonction.''

====Ecrire la fonction====
Pour remplir notre fonction d'instructions, nous devons d'abord pensez à ce que nous devons faire:
* Récupérer la position du joueur, donc on connaîtra la position où faire apparaître le véhicule (on veut le faire apparaître à droite du joueur)
* Calculer la position où faire apparaître le véhicule (nous ne voulons pas que le véhicule apparaisse dans le joueur)
* Faire apparaître les véhicule
* Vérifier si le véhicule a bien apparus, ou afficher un message d'erreur.

Pour ça, nous devons utiliser plusieurs fonctions. Pour trouver la fonction que nous devons utiliser, il faut aller faire un tour dans la [[Scripting Functions|La liste des fonctions serveur]]. D'abord nous avons besoin d'une fonction pour obtenir la position du joueur. Puisque les joueurs sont des éléments, nous devons allez dans la rubrique '''Element functions''' où l'on pourra trouver la fonction [[getElementPosition]]. En cliquant sur le nom de la fonction, le wiki va vous afficher sa description. On peut y voir la syntaxe, qu'est-ce que la fonction retourne. La syntaxe nous montre les argument qu'on peut ou qu'on doit envoyer.

Pour [[getElementPosition]], la syntaxe est:
<syntaxhighlight lang="lua">
float, float, float getElementPosition ( element theElement )
</syntaxhighlight>

Les trois '''float''' devant le nom de la fonction est le type de variable que la fonction nous retourne. Dans notre cas, la fonction retourne trois nombres à virgule(x, y et z). Dans les parenthèses, on peut voir les arguments que l'on doit envoyer, dans notre cas, l’élément dont on veut récupérer la position, le joueur dans notre exemple.

<syntaxhighlight lang="lua">
function createVehicleForPlayer(thePlayer, command, vehicleModel)
-- on récupère la position x,y,z dans des variables locales
-- une variable locale n'existe que dans le "périmètre" actuel. Ici, les variable x, y et z sont des variables locales qui se détruiront à la fin de la fonction.
local x,y,z = getElementPosition(thePlayer)
end
</syntaxhighlight>

Ensuite, il faut s'assurer que le véhicule n'apparaît pas directement dans le joueur, donc on ajoute quelques unités à la variable ''x'', qui le fera apparaître plus à l'est par rapport au joueur.

<syntaxhighlight lang="lua">
function createVehicleForPlayer(thePlayer, command, vehicleModel)
local x,y,z = getElementPosition(thePlayer) -- On prent la position du joueur qui a tapé la commande
x = x + 5 -- on ajoute 5 unité sur l'axes des x
end
</syntaxhighlight>

Maintenant nous avons besoin d'une autre fonction, celle qui va faire apparaître le véhicule. Nous allons la cherché encore une fois dans la [[Scripting Functions|liste des fonctions serveur]], mais cette fois, comme nous parlons d'un véhicule, nous devons donc aller dans la catégorie'''Vehicle functions''', où l'on va trouver la fonction [[createVehicle]]. Dans la syntaxe, nous pouvons voir que cette fonction ne retourne qu'une seule variable, le véhicule ( de type élément ) que nous venons de créer. Nous pouvons aussi voir qu'il y a des arguments entre crochets [], cela veut dire que ce sont des arguments optionnels.

Nous avons déjà tous les arguments pour la fonction [[createVehicle]] dans notre fonction: La position que nous avons juste calculée dans les variables "x, y, z" et l'id du véhicule que nous avons fourni par la commande ("/createVehicle 468") et qui est stocké dans la variable ''vehicleModel''.

<syntaxhighlight lang="lua">
function createVehicleForPlayer(thePlayer, command, vehicleModel)
local x,y,z = getElementPosition(thePlayer) -- récupere la position du joueur dans les variables x, y et z
x = x + 5 -- rajoute 5 unités sur x
-- on crée le véhicule et on enregistre l'élément de type "vehicle" dans la variable ''createdVehicle''
local createdVehicle = createVehicle(tonumber(vehicleModel),x,y,z)
end
</syntaxhighlight>

Avec cette variable, on pourrait faire pas mal de choses sympa, mais ici nous allons juste vérifier si le véhicule à bien été créé ou non.
Sur le wiki de la fonction [[createVehicle]], il y a la partie nommée '''Returns''', la fonction va retourner ''false'' si la voiture n'a pas été créé. Du coups, on va regarder la valeur de la variable ''createdVehicle''.

Voilà notre code complet:
<syntaxhighlight lang="lua">
function createVehicleForPlayer(thePlayer, command, vehicleModel)
local x,y,z = getElementPosition(thePlayer) -- On prent la position du joueur qui a tapé la commande
x = x + 5 -- on ajoute 5 unités à x
local createdVehicle = createVehicle(tonumber(vehicleModel),x,y,z) -- on crée le véhicule demandé par le joueur et on récupère ce que nous retourne la fonction dans la variable createdVehicle
-- On vérifie si la valeur retournée est égal à ''false'' ( ce qui signifie que ça n'a pas marché )
if (createdVehicle == false) then
-- si c'est le cas, on affiche un message d'erreur dans la chatbox mais seulement pour le joueur.
outputChatBox("Erreur lors de la création du véhicule.",thePlayer)
end
end
addCommandHandler("createVehicle", createVehicleForPlayer)
</syntaxhighlight>

Comme vous pouvez le voir, nous avons utilisé une nouvelle fonction: [[outputChatBox]]. Vous devriez maintenant pouvoir regarder la description de cette fonction par vous même.

==Ce que vous devez savoir==
Vous avez déjà lu quelques informations sur les ressources, les commandes et trouvez des fonctions dans le wiki, mais il y a encore beaucoup à apprendre. Cette section vous donnera une vue d'ensemble plutôt courte sur certaines de ces choses, tout en regardant les pages du wiki si possible.
===Les scripts client et serveur===
Vous pouvez avoir déjà remarqué ces termes (serveur/client) quelque part sur ce wiki, le plus souvent pour les fonctions. MTA ne supporte pas seulement les scripts exécuté par le serveur et des commandes (comme celle que l'on vient de faire) ou d'autres fonctions, mais aussi les scripts exécute par le client MTA, ceux des joueurs qui se connecte au serveur. La raison est que certaines fonctions de MTA doit être du coté client comme par exemple le GUI - Graphical User Interface - ( Pour tout ce qui est fenêtres, boutons, etc ), d'autres devraient être du côté client parce qu'ils fonctionnent mieux mais d'autres sont mieux pensées pour être du côté serveur ou ne fonctionne tout simplement pas du côté client.

La plupart de vos scripts (gamemodes, maps) seront surement du côté serveur, comme celui que nous avons fait tout à l'heure. Si vous vous heurtez à quelque chose qui ne peut pas être résolu du côté serveur, vous devrez probablement le faire côté client. Pour un script client, vous devriez créer un script ordinaire (par exemple appelé ''client.lua'') et spécifié dans la meta.xml, comme ceci:
<syntaxhighlight lang="xml">
<script src="client.lua" type="client" />
</syntaxhighlight>
L'attribut ''type'' est par defaut 'server', donc nous avons juste besoin de spécifier que c'est un script client. Lorsque vous faites ceci, le fichier va être télécharger par le joueur sur son ordinateur lorsqu'il se connecte au serveur. Plus d'infos: [[Client side scripts]].

===Ressources plus complexes===
La section précédente nous a montré brièvement comment ajouter des scripts clients à la ressource. Penchons nous maintenant sur la ''meta.xml'' et ce qu'elle fait.

====Premier example - Un script utile====
<syntaxhighlight lang="xml">
/admin_commands
/meta.xml
/commands.lua
/client.lua
</syntaxhighlight>
<syntaxhighlight lang="xml">
<meta>
<info author="Someguy" description="admin commands" />
<script src="commands.lua" />
<script src="client.lua" type="client" />
</meta>
</syntaxhighlight>

* Le "commands.lua" fournit quelques commandes d'admin, comme le fait d'interdire un joueur, en bannissant ou quelque chose d'autre ce qui peut être utilisé par l'admin du serveur
* Le "client.lua" fournit un GUI pour être capable d'exécuter les actions mentionnées facilement

Cet exemple de script doit tourner tout le temps (peut être même démarré en même temps que le serveur) car ces commandes d'admin peuvent être appelé à n'importe quelle moment.

====Second example - Un gamemode====
<syntaxhighlight lang="xml">
/counterstrike
/meta.xml
/counterstrike.lua
/buymenu.lua
</syntaxhighlight>
<syntaxhighlight lang="xml">
<meta>
<info author="Quelqu'un" description="Counterstrike remake" type="gamemode" />
<script src="counterstrike.lua" />
<script src="buymenu.lua" type="client" />
</meta>
</syntaxhighlight>

* Le "counterstrike.lua" contient des caractéristiques semblables aux dispositifs suivants :
** Laisser les joueurs choisirent leur équipe et les faire apparaître
** Leur fournir des armes, des cibles et des instructions (peut-être lues d'une carte, voir ci-dessous)
** Définir les règles du jeu, par exemple. La partie se finie, ce qui se produit quand un joueur meurt
** .. et peut-être encore plus
* Le "buymenu.lua" est un script du côté client et crée un menu pour acheter des armes

Cet exemple peut s'appeler un gamemode, il modifie le gameplay, mais définit réellement les règles de celui-ci. Le "type" attribut indique que cet exemple fonctionne avec [[Map Manager]], encore une autre ressource qui a été écrite par l'équipe de MTA pour contrôler des gamemodes et le chargement de cartes. On recommande fortement que vous basiez vos gamemodes sur les techniques qu'il fournit.

Ceci signifie également que ce gamemode ne fonctionnera probablement pas sans carte. Les gamemodes devront toujours être aussi génériques que possible. Un exemple de gamemode utilisant une carte est énoncé dans le prochain exemple.

====Troisième exemple - Une carte====
<syntaxhighlight lang="xml">
/cs-airport
/meta.xml
/airport.map
/airport.lua
</syntaxhighlight>
<syntaxhighlight lang="xml">
<meta>
<info author="Quelqu'un" description="Counterstrike airport map" type="map" gamemodes="counterstrike" />
<map src="airport.map" />
<script src="airport.lua" />
</meta>
</syntaxhighlight>

* Le "airport.map" dans le fichier XML fournit des informations au sujet de la carte au gamemode, celui-ci peut inclure :
** Là où les joueurs devraient apparaître, avec quelles armes, avec quelle équipe
** Ce qui sont les cibles
** Temps, heure du monde, Limite de temps
** Fournir les véhicules
* Le ''airport.lua'' peut contenir des actions relatifs a la map comme:
** Ouvrir une certaine porte ou faire exploser quelque chose quand une autre chose de spécifique se produit
** Créer ou déplacer quelques objets faits sur commande, ou manœuvrez les objets qui sont créés dans le fichier .map
** .. toutes autre choses relatifs aux objets du .map

Comme vous pouvez le voir, l'attribut "type" a été changé en 'map', pour dire au [[Map Manager]] que cette ressource est une carte, tandis que l'attribut "gamemodes" indique pour quels gamemodes cette carte est valide, dans ce cas-ci le gamemode de l'exemple de tout à l'heure.
Ce qui peut venir comme une surprise est qu'il y a aussi un script dans la ressource de carte. Évidemment ce n'est pas nécessaire dans une carte, mais ouvre une large gamme de possibilités pour les créateurs de cartes.

Le "airport.map" pourrait être semblable à ceci :
<syntaxhighlight lang="xml">
<map mode="deathmatch" version="1.0">
<terrorists>
<spawnpoint posX="2332.23" posY="-12232.33" posZ="4.42223" skins="23-40" />
</terrorists>
<counterterrorists>
<spawnpoint posX="2334.23443" posY="-12300.233" posZ="10.2344" skins="40-50" />
</counterterrorists>

<bomb posX="23342.23" posY="" posZ="" />

<vehicle posX="" posY="" posZ="" model="602" />
<vehicle posX="" posY="" posZ="" model="603" />
</map>
</syntaxhighlight>

Quand un gamemode est commencé avec une carte, les ressources de carte est automatiquement démarrée par le mapmanager et les renseignements qu'il contient peut être lu par le gamemode. Quand la carte change, la ressource de carte actuelle est arrêtée et la ressource de carte suivante est commencée. Pour une explication plus détaillée et des exemples pour savoir comment les ressources de cartes sont utilisées dans le script principal, visitez s'il vous plaît la page [[Writing Gamemodes]].

===Événements===
MTA utilise les événements pour signaler aux scripts que des choses s'est passé dans le jeu. Par exemple quand un joueur meurt, l’événement [[onPlayerWasted]] est déclenché. Pour exécuter n'importe quelle action quand un joueur meurt, votre script doit donner le nom de sa fonction à exécuter lorsque cet événement est déclenché par MTA grâce à la fonction [[addEventHandler]]. C'est très similaire à la fonction qui permet de déclencher une fonction via une commande.

Cet exemple produira un message avec le nom du joueur qui est mort :
<syntaxhighlight lang="lua">
function playerDied(totalAmmo, killer, killerWeapon, bodypart)
outputChatBox(getPlayerName(source).." died!")
end
addEventHandler("onPlayerWasted", getRootElement(), playerDied)
</syntaxhighlight>

Au lieu de lister les arguments qui sont nécessaires, la page de documentation pour un événement indique quels paramètres sont passés à la fonction que vous attachez à cet événement. Un autre point important est la variable "source", qui existe dans les fonction d’événement. Il ne doit pas être ajoutés à la liste des paramètres de la fonction, mais elle existe quand même à l'intérieur de votre fonction. Cette variable a une valeur différente d'un événement à l'autre, pour les événements de joueurs (comme dans l'exemple au-dessus) c'est le joueur responsable de son déclenchement. Comme autre exemple, vous pouvez jeter un coup d'œil au script qui permet de faire apparaître le joueur dans la première section pour avoir une idée de comment utiliser cette variable "source".

==Où aller d'ici==
Vous devriez maintenant être familier avec les aspects les plus fondamentaux du scripting sur MTA et aussi un peu avec la documentation. Le [[Main_Page]] vous fournit des liens vers plus de renseignements, tutoriels et Références qui permettent de se plonger plus profondément dans les thèmes que vous désirez apprendre.

D'ici nous recommandons de lire les tutos sur le [[debugging]]. Les bonnes pratiques pour débuguer vos scripts sont une nécessité absolue quand vous faites des scripts.

[[ru:Scripting Introduction]]
[[it:Introduzione allo scripting]]
[[es:Introducción a la Programación]]

Database

2017-07-09T17:12:49Z

Citizen: Fixed typo

MTA uses a database system based on files. This system is sqlite, an embedded relational database management system.
==Files==
There are two main database files for storing data:
*'''internal.db:''' this contains user account data (usernames, passwords and account data stored by using the [[setAccountData]] and [[getAccountData]] functions.
*'''registry.db:''' this is the main database file, all the executeSQL* scripting functions work with this file.

==Functions==
{{SQL_functions}}

TeaEncode

2017-03-15T15:59:17Z

Citizen: Fixed syntaxhighlight tags for script examples

__NOTOC__
{{Server_client function}}

{{New feature/item|3.0135|1.3.5|6056|
This functions performs the [https://en.wikipedia.org/wiki/Tiny_Encryption_Algorithm Tiny Encryption Algorithm] on the given string and returns the [https://en.wikipedia.org/wiki/Base64 base64] representation of the encrypted string.
}}

==Syntax==
<syntaxhighlight lang="lua">string teaEncode ( string text , string key )</syntaxhighlight>

===Required Arguments===
*'''text:''' The string you want to encrypt. (See second example if you want to encode binary data)
*'''key:''' The key that should be used for encryption (Only first 16 characters are used)

===Returns===
Returns the [https://en.wikipedia.org/wiki/Base64 base64] representation of the encrypted string if the encryption process was successfully completed, ''false'' otherwise.

==Example==
<section name="Client" class="client" show="true">
This example creates a /teaencrypt command, which performs the TEA on a given string with the specified key, if any.
<syntaxhighlight lang="lua">
function encryptString( cmd, theString, theKey )
if ( theString ) then
if ( not theKey ) then
theKey = string.rep( string.char( math.random( string.byte( "a" ), string.byte( "Z" ) ) ), 10 ) -- Generate a random key of 10 characters if no key was passed in as an argument
end
local encodedString = teaEncode( theString, theKey ) -- Encode the string with the key
outputChatBox( "The encoded string is: " .. tostring( encodedString ) .. " (used key: " .. theKey .. ")" )
else
outputChatBox( "Syntax: /" .. cmd .. " [string] <[key]>" )
end
end
addCommandHandler( "teaencrypt", encryptString )
</syntaxhighlight>

This shows how to use teaEncode/teaDecode with binary data:
<syntaxhighlight lang="lua">
function teaEncodeBinary( data, key )
return teaEncode( base64Encode( data ), key )
end

function teaDecodeBinary( data, key )
return base64Decode( teaDecode( data, key ) )
end
</syntaxhighlight>
</section>

==See Also==
{{Utility functions}}

User talk:JHXP

2017-01-01T19:35:50Z

Citizen:

Thanks, got a notification about the vandalism on the french sub-wiki I follow. Just came home to see you already reverted it. Thanks for the fast reaction. Best, regards, --[[User:Citizen|Citizen]] ([[User talk:Citizen|talk]]) (French Forum Moderator) 20:35, 1 January 2017 (UTC)

Thanks for banning those a$$holes. --[[User:GabWas|GabWas]] ([[User talk:GabWas|talk]]) 18:58, 1 January 2017 (UTC)

FR/A propos des Map

2016-12-30T13:54:08Z

Citizen: Removed "Needs Checking" flag

Le "Map manager" est une ressource inclue dans la suite serveur de MTA DM. Elle offre des commandes, fonctions et événements pour les modes de jeu afin de dynamiser vos maps. Par exemple, quand un serveur doit charger plusieurs routes pour plusieurs maps, au lieu d'avoir le tout dans un seul script principal, ces routes peuvent êtres stockée dans plusieurs ressources et chargée simplement grâce à la fonction "changeGamemodeMap" quand une map démarre.

Plus spécifiquement, le "Map manager" liste les modes de jeux et maps chargés sur le serveur. Il inclut un listing sur l'interface web, il rafraîchit cette liste fréquemment et met en gras les ressources et/ou maps actuellement entrain d'être utilisées.

== Un Simple Tutoriel ==
Dans cette section nous allons poursuivre le travail commencé dans [[FR/Introduction_Programmation|Introduction to Scripting]]. Nous allons ajouter une ressource qui enregistre l'endroit de spawn des joueurs sur la map, le chargement de ce script se fera depuis le script principal.

Premièrement, créez un dossier dans /Your MTA Server/mods/deathmatch/resources/, nommez-le "mymap". Ensuite dans ce dossier, créez un fichier texte et nommez-le "meta.xml", ce fichier est présent dans chaque scripts.

Ecrivez les lignes suivantes dans le fichier ''meta.xml'' :
<syntaxhighlight lang="xml">
<meta>
<info type="map" gamemodes="myserver"/>
<map src="mymap.map"/>
</meta>
</syntaxhighlight>
Prenez garde car ce fichier est "lié" avec le ''gamemodes=""'' choisit, qui contient le nom de la ressource principale qu'utilise ce mode. le paramètre ''map'', indique le nom de la map qui sera afficher sur le serveur.

Maintenant créez un nouveau fichier texte dans /mymap/ et nommez le "mymap.map", écrivez y les lignes suivantes:
<syntaxhighlight lang="xml">
<map>
<spawnpoint id="spawnpoint1" posX="1959.5487060547" posY="-1714.4613037109" posZ="18" rot="63.350006103516" model="0"/>
</map>
</syntaxhighlight>
Notez que "spawnpoint" est le type de l'élément utilisé dans la fonction [[getElementsByType]], "id" est utilisée dans la fonction [[getElementByID]]

Pour charger la map, le script principal doit pouvoir accéder aux maps par lui même. Quelques modifications sont à apportées dans script.lua situé dans "myserver". Entrez les lignes suivantes :

<syntaxhighlight lang="lua">
function loadMap(startedMap)
mapRoot = getResourceRootElement(startedMap)
end

addEventHandler("onGamemodeMapStart", getRootElement(), loadMap)
</syntaxhighlight>
Par défaut, l'evênement "onGamemodeMapStart" nous donne le "handle"(?) de la map ("startedMap"), lequel nous avons utilisé pour le "handle"(?) de la ressource contenant la map ("mapRoot").

Avec la ressource "handle"(?), nous pouvons extraire les informations relatives au spawnpoint. Jetez un œil à la fonction joinHandler() dans script.lua, à la place de x, y and z, nous pouvons utiliser les informations de la map comme suit :
<syntaxhighlight lang="lua">
function joinHandler()
local spawn = getElementsByType("spawnpoint", mapRoot)
local x,y,z,r
for key, value in pairs(spawn) do
x = getElementData(value, "posX")
y = getElementData(value, "posY")
z = getElementData(value, "posZ")
r = getElementData(value, "rot")
end
spawnPlayer(source, x, y, z)
fadeCamera(source, true)
end
</syntaxhighlight>
Lancez maintenant votre gamemode avec la commande suivante via la console:

'''gamemode myserver mymap'''

==Utilisation==
Pour utiliser le map manager, vos ressources doivent d'abord être reconnues en tant que gamemodes ou maps.

Vous devez remplir quelques informations pour votre fichier de configuration du '''gamemode resource''' :
<syntaxhighlight lang="xml"><info description="Votre Gamemode" type="gamemode" /></syntaxhighlight>

'''Map resources''' Les maps ont aussi besoin d'information dans le meta.xml, ''type="map"'' et un ou plusieurs ''gamemodes''. Une map peut en effet être compatible avec plusieurs mode de jeu pour se faire il faudra séparer les modes par une virgule ''sans espaces''.
<syntaxhighlight lang="xml"><info description="A gamemode map" type="map" gamemodes="ctv,koth" /></syntaxhighlight>

Il ne peut y avoir qu’un mode de jeu 'Gamemode' Actif ou une map chargée à la fois.

==Paramètres Supplémentaires==
Ces paramètres sont aussi à ajouter dans meta.xml.

'''name:''' Entrez ici un message sympa qui sera afficher lors du démarrage de la ressource. C'est en quelques sorte un alias au cas ou le nom de votre ressource ne vous correspond pas.

==Commandes==
'''changemap newmap [gamemode]''' (changer le 'Gamemode' d'une map)

'''changemode newgamemode [map]''' (lancer un mode de jeu 'Gamemode' et démarrez une map)

'''gamemode newgamemode [map]''' (idem que la précédente)

'''stopmode''' (Arrête le mode de jeu et la map en cours)

'''stopmap''' (Arrête la map en cours)

'''maps [gamemode]''' (liste toutes les maps sur le serveurs, ajoutez en option le mode pour lequel vous voulez connaître les maps)

'''gamemodes''' (Liste tout les mode de jeu)

==Paramètres==
'''*mapmanager.color''' [string couleur hex] (change la couleur de sortie des message du mapmanager) (Par défaut : #E1AA5A)

'''*mapmanager.messages''' [boolean] (si les changements de map/gm sont activés) (Par défaut : true)

'''*mapmanager.ASE''' [boolean] (si le manager doit charger en mode ASE) (Par défaut : true)

==Autres fonctions==
<syntaxhighlight lang="lua">bool changeGamemode ( resource newGamemode, [ resource mapToLoadWith ] )</syntaxhighlight>
Changement de mode de jeu, on peut aussi lui donner une map initial à charger.
<syntaxhighlight lang="lua">bool changeGamemodeMap ( resource newMap, [ resource gamemodeToChangeTo ] )</syntaxhighlight>
Change le mode de jeu d'une map pour un nouveau, on peut choisir un mode de jeu à charger une fois cette map rechargée.
<syntaxhighlight lang="lua">table getGamemodes ( )</syntaxhighlight>
Renvoie une table des tout les modes de jeu et leur pointeurs.
<syntaxhighlight lang="lua">table getGamemodesCompatibleWithMap ( resource theMap )</syntaxhighlight>
Retourne une table de tout les modes de jeu compatibles.
<syntaxhighlight lang="lua">table getMaps ( )</syntaxhighlight>
Reourne une table de toutes les ressources en rapport avec la map.
<syntaxhighlight lang="lua">table getMapsCompatibleWithGamemode ( [ resource theGamemode ] )</syntaxhighlight>
Retourne une table de tout les modes de jeu compatibles. Si l'argument "theGamemode" est inexistant, ça retourne toutes les maps qui n'ont aucun mode de jeu compatible..
<syntaxhighlight lang="lua">resource getRunningGamemode ( )</syntaxhighlight>
Renvoie le mode de jeu actif.
<syntaxhighlight lang="lua">resource getRunningGamemodeMap ( )</syntaxhighlight>
Renvoie le mode de jeu de la map en cours.
<syntaxhighlight lang="lua">bool isGamemode ( resource theGamemode )</syntaxhighlight>
Déterminie si une ressources est un mode de jeu ou pas.
<syntaxhighlight lang="lua">bool isGamemodeCompatibleWithMap ( resource theGamemode, resource theMap )</syntaxhighlight>
Déterminie si une map est compatible avec un mode de jeu ou pas.
<syntaxhighlight lang="lua">bool isMap ( resource theMap )</syntaxhighlight>
Détermine si ressources est une map ou pas.
<syntaxhighlight lang="lua">bool isMapCompatibleWithGamemode ( resource theMap, resource theGamemode )</syntaxhighlight>
Déterminie si une map est compatible avec un gamemode ou pas.
<syntaxhighlight lang="lua">bool stopGamemode ( )</syntaxhighlight>
Arrêter le mode de jeux actif ainsi que la map chargée.
<syntaxhighlight lang="lua">bool stopGamemodeMap ( )</syntaxhighlight>
Arrêter la map active.

==Evênement Appelés==
''(Pour tous ces évênements, "source" est la ressource racine des élément.)''
<syntaxhighlight lang="lua">onGamemodeStart ( resource startedGamemode )</syntaxhighlight>
Appelé lors du démarrage d'un mode de jeu.
<syntaxhighlight lang="lua">onGamemodeStop ( resource stoppedGamemode )</syntaxhighlight>
Appelé quand on arrête un mode de jeu.
<syntaxhighlight lang="lua">onGamemodeMapStart ( resource startedMap )</syntaxhighlight>
Appelé quand la map d'un mode de jeu démarre.
<syntaxhighlight lang="lua">onGamemodeMapStop ( resource stoppedMap )</syntaxhighlight>
Appelé quand la map de mode de jeu est stoppée.

==Paramètres d'une Map==
Les paramètres suivants [[settings system|registry]] sont appliqué par le "Map Manager" quand une map est démarée :
<br>'''gamespeed''' [nombre]: la vitesse du jeu sur la map.
<br>'''gravity''' [nombre]: la gravité de la map.
<br>'''time''' [Sous la forme suivante '''hh:mm''']: l'heure du jeu avec cette map.
<br>'''weather''' [nombre]: la météo de la map.
<br>'''waveheight''' [nombre]: la hauteur de l'eau pour cette map.
<br>'''locked_time''' [boolean]: décide si le temps est verouillé ou non.
<br>'''minplayers''' [nombre]: décide du nombre minimum de joueurs pour démarrer la map.
<br>'''maxplayers''' [nombre]: décide du nombre maximum de joueurs que peut accepter la map.

[[it:Map manager]]
[[ru:Resource:Mapmanager]]

FR/Introduction Programmation

2016-08-07T23:10:38Z

Citizen: Real french instead of gogol translate ;)

Les ressources sont les parties clées de MTA. Une ressource est un dossier ou un .zip qui contient plusieurs fichiers, ainsi qu'une meta qui dit au serveur comment la resource doit-elle être chargée. Une ressource peut être comparée comme un programme qu'on peut lancer ou arrêter, il est possible de lancer plusieurs ressources en même temps.

Tout ce qui a un rapport avec la programmation se passe dans les ressources, se que fait la ressource, définie si c'est un gamemode, une map or quelquechose d'autre. MTA s'installe avec des resources que vous pouvez facultativement utiliser dans vos gamemodes, comme la ressource "maplimits" pour garder les joueurs dans une certaine zone ou encore "deathpickups" pour créer des pickups pour ramasser une arme.

'''La première chose à faire avant de pouvoir programmer en lua, c'est de se procurer un editeur de texte qui supporte le lua. Il vous sera beaucoups plus facile que de le faire avec le bloc-note de Windows. Nous vous recommendons donc [http://notepad-plus.sourceforge.net/uk/site.htm Notepad++] ou [http://luaedit.sourceforge.net/ LuaEdit]. Il y a aussi un logiciel non officiel [[MTASE|MTA Script Editor]] ( malheureusement l'auteur ne travail plus dessus ) que vous pouvez tester.'''

==Créer un script qui fonctionne==
Nous allons voir tout d'abord comment créer un simple script étapes par étapes qui permetra aux joueurs de se deplacer dans la ville. Dans ce tutoriel, on utilisera notepadd++.
===Où sont tous les scripts ?===
Laissez moi d'abord vous présenter comment s'oranise une ressource. Allez dans votre dossier MTA San et et suivez le chemin suivant:

/serveur/mods/deathmatch/resources/

Vous y verez de nombreux fichier avec l'extension .zip, se sont des ressources avec à l'intérieur des exemples de scripts . Toutes les ressources chargées sont dézippé par le serveur afin de pouvoir les exécuter ( les .zip ne sont pas obligatiores, vous pouvez aussi laissez votre ressource en tant que dossier ). Pour créer votre propre ressource, créez simplement un nouveau dossier et nommez le comme vous voulez ( Ne pas utiliser d'espace, utilisez plutôt un _ ) . Nommez le "myserveur" pour ce tutoriel.

Maintenant entrez dans votre dossier. Le chemain devrait donc être

/serveur/mods/deathmatch/resources/myserveur/

===Identifier votre ressource===
Pour que le serveur puisse savoir ce que contient votre ressource, un fichier ''meta.xml'' doit être créé afin d'établir une liste du contenu du dossier. Cette 'meta.xml' doit être à la racine de votre ressource ( et non pas dans un autre sous-dossier ), donc dans le dossier "myserveur" dans notre cas. Donc ouvrez notepadd++, créer un nouveau fichier (Ctrl+N), puis faite "Enregistrez sous ..." (Ctrl+Alt+S), dans "Nom:" vous écrivez "meta" et dans "Type:", sélectionnez "*.xml" ( avant-dernier de la liste ), sauvegardez le dans votre dossier "myserveur".

Maintenant, ecrivez le code suivant dans votre ''meta.xml'':
<syntaxhighlight lang="xml">
<meta>
<info author="Votre Nom" type="gamemode" name="Mon serveur" description="Mon premier serveur MTA" />
<script src="script.lua" />
</meta>
</syntaxhighlight>
Dans la balise ''<info />'', il y a le champ "type" qui indique si la ressource est un ''gamemode'' ou une ''map'', on y reviendra plus tard. Un gamemode est ce dont vous avez besoin pour que votre serveur est une base.

La balise ''<script />'' indique les scripts qui sont dans la ressource, que l'on va maintenant créer.
===Créer un script simple===
Notez que dans la balise ''<script />'', le fichier .lua n'est pas dans un autre sous-dossier. Donc on va créer notre script.lua au même endroit que notre meta.xml ( Reproduisez la même opération mais "Nom:" écrivez 'script' et pour "Type:" choisissez 'Lua(*.lua)' ) puis copier-coller le code suivant:
<syntaxhighlight lang="lua">
function joinHandler()
local x = 1959.55
local y = -1714.46
local z = 10
spawnPlayer(source, x, y, z)
fadeCamera(source, true)
setCameraTarget(source, source)
outputChatBox("Bienvenue sur mon serveur", source)
end
addEventHandler("onPlayerJoin", getRootElement(), joinHandler)
</syntaxhighlight>
Ce script va fous faire apparître aux coordonnées (x, y, z) spécifié dans le code, lorsque vous connecterez au serveur. La fonction ''fadeCamera'' sinon l'écran restera noir. Vous devez aussi dire à la camera de suivre le joueur grâce à la fonction 'setCameraTarget' (sinon il vera une mer bleu).

La variable '''source''' indique qui 'déclenche' la fonction. Le fonction se 'déclenche' lorsqu'un joueur rejoind le serveur, vous utiliserez cette variable pour voir qui à rejoind le serveur. Donc lorsque un joueur( "la source" ) rejoindra notre serveur, on le fera apparaître aux coordonnées indiquées .

Focalisons-nous sur [[addEventHandler]], vous pouvez voir 3 choses: 'onPlayerJoin', qui indique quand éxécuter la fonction X. getRootElement(), qui indique qui/quoi peut être déclencher la fonction (getRootElement() veut dire toutes les choses et tous les joueurs). Et enfin la fonction X à éxecuter ( ici joinHandler ). Pour les autres details, nous verrons plus tard dans d'autres exemples mais tout d'abord testons notre premier gamemode!

===Lancer le gamemode===
Pour lancer le serveur, lancer simplement le 'MTA Server.exe' qui se trouve dans votre dossier 'MTA San et\server'. Une liste d'info concernant le serveur apparaîtra en premier; notez le port du serveur ( 22003 par défaut ), vous en aurez besoin pour rejoindre le serveur. Après, le serveur charge toutes les ressources du dossier 'resource', et enfin "ready to accept connections!"

Avant de pouvoir vous connecter, vous devez lancer votre gamemode. Tapez "start myserver" et appuyer sur Entrer. Le serveur va alors lancer le gamemode que nous avons créé, et nous affichera aussi les erreurs s'il y en a. Maintenant, vous pouvez lancer MTA, cliquez sur "Quick Connect" et ecrivez ceci: Dans Host: le1er champ: 127.0.0.1 ou localhost ( cela signifie que vous vous connectez au serveur du pc actuel ) et le 2ème champ: le port ( ici 22003 ) et cliquez sur 'Connect'. Si tout se passe bien, après quelques secondes, vous devriez apparaître et pouvoir allez où vous voulez.

Ensuite nous allons créer une commande que les joueurs pourront utiliser pour faire apparître une voiture à coté d'eux.

==Créer une commande==
Revenons à l'intérieur de notre ''script.lua''. Tout d'abord, nous devons créer une fonction qu'on pourra appeler/éxécuter grâce à notre commande et la fonction 'addCommandHandler' afin de créer la commande que les joueurs pourront taper dans le chat( T ) ou la console( F8 ).

<syntaxhighlight lang="lua">
-- On crée la fonction qui sera appelée par notre commande avec les arguments: thePlayer, command, vehicleModel
function createVehicleForPlayer(thePlayer, commandName, vehicleModel)
-- Ici on crée le véhicule
end
-- on crée la commande et on l'attache à notre fonction
addCommandHandler("createVehicle", createVehicleForPlayer)
</syntaxhighlight>
''Note: Grâce au wiki, vous pouvez cliquer sur le nom des fonctions et cela vous redirigera sur la documentation de cette fonction.''

====A propos du addCommandHandler====
Le premier argument du [[addCommandHandler]] est le nom de la commande the player will be able to enter, le second le nom de la fonction à appeler, dans notre cas, ''createVehicleForPlayer''.

Si vous avez déjà de l'expérience dans le codage, vous savez qu'un fonction s'appelle comme ceci:
<syntaxhighlight lang="lua">
nomDeLaFonction(argument1, argument2, argument3, ..)
</syntaxhighlight>
Si l'on regarde bien l'exemple ci-dessus, nous pouvons voir que l'argument1 est thePlayer and argument2 le commandName. thePlayer est celui qui à tapé la commande et commandName contient le nom de la commande qu'il à tapé. Donc si un joueur tape "/greet", cet argument va contenir "greet". Argument3 c'est ce que le joueur à tapé en plus de la commande, vous allez apprendre ceci dans le tutoriel. N'oubliez jamais que les deux premiers arguments sont les arguments standards, mais vous pouvez les renommé si vous voulez, seul l'ordre est important.

Par exemple: Un joueur tape "createVehicle 468" pour faire aparaître une Sanchez, la fonction addCommandHandler va appeller notre fonction createVehicleForPlayer, comme ceci:
<syntaxhighlight lang="lua">
createVehicleForPlayer(thePlayer,"createVehicle","468") -- thePlayer est l'élement joueur qui a tapé la commande
</syntaxhighlight>
Comme nous pouvons le voir, ll fournit plusieurs paramètres: le joueur qui a tapé la commande, la commande qu'il a tapé, et n'importe quelle texte qu'il a mis après, dans notre cas, "468" comme id de la Sanchez. Les deux premiers paramètres sont les même pour tous les addCommandHandler qu'on peut retrouver sur la page du [[addEventHandler]]. Vous devez toujours définir au moins ces deux paramètres pour utiliser les arguments après eux (par exemple pour traiter le texte qui a été entré après la commande, comme dans notre exemple le modèle du véhicule).

''Note: Vous devez créer la commande APRES la fonction que vous allez utiliser pour cette commande, sinon il ne trouvera pas la fonction.''

====Ecrire la fonction====
Pour remplir notre fonction d'instructions, nous devons d'abord pensez à ce que nous devons faire:
* Récupérer la position du joueur, donc on connaitra la position où faire apparaître le véhicule (on veut le faire apparaître à droite du joueur)
* Calculer la position où faire apparître le véhicule (nous ne voulons pas que le véhicule apparaisse dans le joueur)
* Faire apparître les véhicule
* Vérifier si le véhicule a bien apparus, ou aficher un message d'erreur.

Pour ça, nous devons utiliser plusieurs fonctions. Pour trouver la fonction que nous devons utiliser, il faut aller faire un tour dans la [[Scripting Functions|La liste des fonctions serveur]]. D'abord nous avons besoin d'une fonction pour obtenir la position du joueur. Puisque les joueurs sont des éléments, nous devons allez dans la rubrique '''Element functions''' où l'on pourra trouver la fonction [[getElementPosition]]. En cliquant sur le nom de la fonction, le wiki va vous afficher sa description. On peut y voir la syntaxe, qu'est-ce que la fonction retourne. La syntaxe nous montre les argument qu'on peut ou qu'on doit envoyer.

Pour [[getElementPosition]], la syntaxe est:
<syntaxhighlight lang="lua">
float, float, float getElementPosition ( element theElement )
</syntaxhighlight>

Les trois float devant le nom de la fonction est le type de variable que la fonction nous retourne. Dans notre cas, la fonction retourne trois nombres à virgule(x, y et z). Dans les parenthèses, on peut voir les arguments que l'on doit envoyer, dans notre cas, l'element dont on veut récupérer la position, le joueur dans notre exemple.

<syntaxhighlight lang="lua">
function createVehicleForPlayer(thePlayer, command, vehicleModel)
-- on récupère la position x,y,z dans des variables locales
-- une variable locale n'existe que dans le "périmètre" actuel. Ici, les variable x, y et z sont des variables locales qui se détruiront à la fin de la fonction.
local x,y,z = getElementPosition(thePlayer)
end
</syntaxhighlight>

Ensuite, il faut s'assurer que le véhicule n'apparaît pas directement dans le joueur, donc on ajoute quelques unités à la variable ''x'', qui le fera apparaître plus à l'est par rapport au joueur.

<syntaxhighlight lang="lua">
function createVehicleForPlayer(thePlayer, command, vehicleModel)
local x,y,z = getElementPosition(thePlayer) -- On prent la position du joueur qui a tapé la commande
x = x + 5 -- on ajoute 5 unité sur l'axes des x
end
</syntaxhighlight>

Maintenant nous avons besoin d'une autre fonction, celle qui va faire apparaître le véhicule. Nous allons la cherché encore une fois dans la [[Scripting Functions|liste des fonctions serveur]], mais cette fois, comme nous parlons d'un véhicule, nous devons donc aller dans la catégorie'''Vehicle functions''', où l'on va trouver la fonction [[createVehicle]]. Dans la syntaxe, nous pouvons voir que cette fonction ne retourne qu'une seule variable, le véhicule ( de type élément ) que nous venons de créer. Nous pouvons aussi voir qu'il y a des arguments entre crochets [], cela veut dire que ce sont des arguments optionels.

Nous avons déjà tous les arguments pour la fonction [[createVehicle]] dans notre fonction: La position que nous avons juste calculée dans les variables "x, y, z" et l'id du véhicule que nous avons fourni par la commande ("/createVehicle 468") et qui est stocké dans la variable ''vehicleModel''.

<syntaxhighlight lang="lua">
function createVehicleForPlayer(thePlayer, command, vehicleModel)
local x,y,z = getElementPosition(thePlayer) -- récupere la position du joueur dans les variables x, y et z
x = x + 5 -- rajoute 5 unités sur x
-- on crée le véhicule et on enregistre l'élément de type "vehicle" dans la variable ''createdVehicle''
local createdVehicle = createVehicle(tonumber(vehicleModel),x,y,z)
end
</syntaxhighlight>

Avec cette variable, on pourrait faire pas mal de choses sympa, mais ici nous allons juste vérifier si le véhicule à bien été créé ou non.
Sur le wiki de la fonction [[createVehicle]], il y a la partie nomée '''Returns''', la fonction va retourner ''false'' si la voiture n'a pas été créé. Ducoups, on va regarder la valeur de la variable ''createdVehicle''.

Voilà notre code complet:
<syntaxhighlight lang="lua">
function createVehicleForPlayer(thePlayer, command, vehicleModel)
local x,y,z = getElementPosition(thePlayer) -- On prent la position du joueur qui a tapé la commande
x = x + 5 -- on ajoute 5 unités à x
local createdVehicle = createVehicle(tonumber(vehicleModel),x,y,z) -- on crée le véhicule demandé par le joueur et on récupère ce que nous retourne la fonction dans la variable createdVehicle
-- On vérifie si la valeur retournée est égal à ''false'' ( ce qui signifie que ça n'a pas marché )
if (createdVehicle == false) then
-- si c'est le cas, on affiche un message d'erreur dans la chatbox mais seulement pour le joueur.
outputChatBox("Erreur lors de la création du véhicule.",thePlayer)
end
end
addCommandHandler("createVehicle", createVehicleForPlayer)
</syntaxhighlight>

Comme vous pouvez le voir, nous avons utilisé une nouvelle fonction: [[outputChatBox]]. Vous devriez maintenant pouvoir regarder la description de cette fonction par vous même.

==Ce que vous devez savoir==
Vous avez déjà lu quelques informations sur les ressources, les commandes et trouvez des fonctions dans le wiki, mais il y a encore beaucoup à apprendre. Cette section vous donnera une vue d'ensemble plutôt courte sur certaines de ces choses, tout en regardant les pages du wiki si possible.
===Les scripts client et serveur===
Vous pouvez avoir déjà remarqué ces termes (serveur/client) quelque part sur ce wiki, le plus souvent pour les fonctions. MTA ne supporte pas seulement les scripts exécuté par le serveur et des commandes (comme celle qu'on vien de faire) ou d'autres fonctions, mais aussi les scripts éxécuté par le client MTA, ceux des joueurs qui se connecte au serveur. La raison est que certaines fonctions de MTA doit être du coté client comme par exemple le GUI - Graphical User Interface - ( Pour tout ce qui est fenêtres, boutons, etc ), d'autres devraient être du côté client parce qu'ils fonctionnent mieux mais d'autres sont mieux pensées pour être du côté serveur ou ne fonctionne tout simplement pas du côté client.

La plupart de vos scripts (gamemodes, maps) seront surement du côté serveur, comme celui que nous avons fait tout à l'heure. Si vous vous heurtez à quelque chose qui ne peut pas être résolu du côté serveur, vous devrez probablement le faire côté client. Pour un script client, vous devriez créer un script ordinaire (par exemple appelé ''client.lua'') et spécifié dans la meta.xml, comme ceci:
<syntaxhighlight lang="xml">
<script src="client.lua" type="client" />
</syntaxhighlight>
L'attribut ''type'' est par defaut 'server', donc nous avons juste besoin de spécifier que c'est un script client. Lorsque vous faites ceci, le fichier va être télecharger par le joueur sur son ordinateur lorsqu'il se connecte au serveur. Plus d'infos: [[Client side scripts]].

===Ressources plus complexes===
La section précédente nous a montré brièvement comment ajouter des scripts clients à la ressource. Penchons nous maintenant sur la ''meta.xml'' et ce qu'elle fait.

====Premier example - Un script utile====
<syntaxhighlight lang="xml">
/admin_commands
/meta.xml
/commands.lua
/client.lua
</syntaxhighlight>
<syntaxhighlight lang="xml">
<meta>
<info author="Someguy" description="admin commands" />
<script src="commands.lua" />
<script src="client.lua" type="client" />
</meta>
</syntaxhighlight>

* Le "commands.lua" fournit quelques commandes d'admin, comme le fait d'interdire un joueur, en banissant ou quelque chose d'autre ce qui peut être utilisé par l'admin du serveur
* Le "client.lua" fournit un GUI pour être capable d'exécuter les actions mentionnées facilement

Cet exemple de script doit tourner tout le temps (peut être même démarré en même temps que le serveur) car ces commandes d'admin peuvent être appelé à n'importe quelle moment.

====Second example - Un gamemode====
<syntaxhighlight lang="xml">
/counterstrike
/meta.xml
/counterstrike.lua
/buymenu.lua
</syntaxhighlight>
<syntaxhighlight lang="xml">
<meta>
<info author="Quelqu'un" description="Counterstrike remake" type="gamemode" />
<script src="counterstrike.lua" />
<script src="buymenu.lua" type="client" />
</meta>
</syntaxhighlight>

* Le "counterstrike.lua" contient des caractéristiques semblables aux dispositifs suivants :
** Laisser les joueurs choisirent leur équipe et les faire apparaître
** Leur fournir des armes, des cibles et des instructions (peut-être lues d'une carte, voir ci-dessous)
** Définir les règles du jeu, par exemple. La partie se finie, ce qui se produit quand un joueur meurt
** .. et peut-être encore plus
* Le "buymenu.lua" est un script du côté client et crée un menu pour acheter des armes

Cet exemple peut s'appeler un gamemode, il modifie le gameplay, mais définit réellement les règles de celui-ci. Le "type" attribut indique que cet exemple fonctionne avec [[Map Manager]], encore une autre ressource qui a été écrite par l'équipe de MTA pour contrôler des gamemodes et le chargement de cartes. On recommande fortement que vous basiez vos gamemodes sur les techniques qu'il fournit.

Ceci signifie également que ce gamemode ne fonctionnera probablement pas sans carte. Les gamemodes devront toujours être aussi génériques que possible. Un exemple de gamemode utilisant une carte est énoncé dans le prochain exemple.

====Troisième exemple - Une carte====
<syntaxhighlight lang="xml">
/cs-airport
/meta.xml
/airport.map
/airport.lua
</syntaxhighlight>
<syntaxhighlight lang="xml">
<meta>
<info author="Quelqu'un" description="Counterstrike airport map" type="map" gamemodes="counterstrike" />
<map src="airport.map" />
<script src="airport.lua" />
</meta>
</syntaxhighlight>

* Le "airport.map" dans le fichier XML fournit des informations au sujet de la carte au gamemode, ceului-ci peut inclure :
** Là où les joueurs devraient apparaitre, avec quelles armes, avec quelle équipe
** Ce qui sont les cibles
** Temps, heure du monde, Limite de temps
** Fournir les véhicules
* Le ''airport.lua'' peut contenir des actions relatifs a la map comme:
** Ouvrir une certaine porte ou faire éxploser quelque chose quand une autre chose de spécifique se produit
** Créer ou déplacer quelques objets faits sur commande, ou manoeuvrez les objets qui sont créés dans le fichier .map
** .. toutes autre choses relatifs aux ojets du .map

Comme vous pouvez le voir, l'attribut "type" a été changé en 'map', pour dire au [[Map Manager]] que cette ressource est une carte, tandis que l'attribut "gamemodes" indique pour quels gamemodes cette carte est valide, dans ce cas-ci le gamemode de l'exemple de tout à l'heure.
Ce qui peut venir comme une surprise est qu'il y a aussi un script dans la ressource de carte. Évidemment ce n'est pas nécessaire dans une carte, mais ouvre une large gamme de possibilités pour les créateurs de cartes.

Le "airport.map" pourrait être semblable à ceci :
<syntaxhighlight lang="xml">
<map mode="deathmatch" version="1.0">
<terrorists>
<spawnpoint posX="2332.23" posY="-12232.33" posZ="4.42223" skins="23-40" />
</terrorists>
<counterterrorists>
<spawnpoint posX="2334.23443" posY="-12300.233" posZ="10.2344" skins="40-50" />
</counterterrorists>

<bomb posX="23342.23" posY="" posZ="" />

<vehicle posX="" posY="" posZ="" model="602" />
<vehicle posX="" posY="" posZ="" model="603" />
</map>
</syntaxhighlight>

Quand un gamemode est commencé avec une carte, les ressources de carte est automatiquement démaré par le mapmanager et les renseignements qu'il contient peut être lu par le gamemode. Quand la carte change, la ressource de carte actuelle est arrêtée et la ressource de carte suivante est commencée. Pour une explication plus détaillée et des exemples pour savoit comment les ressources de cartes sont utilisées dans le script principal, visitez s'il vous plaît la page [[Writing Gamemodes]].

===Événements===
MTA utilise les événements pour signaler aux scripts que des choses s'est passé dans le jeu. Par exemple quand un joueur meurt, l'évènement [[onPlayerWasted]] est déclenché. Pour exécuter n'importe quelle action quand un joueur meurt, votre script doit donner le nom de sa fonction à exécuter lorsque cet événement est déclenché par MTA grâce à la fonction [[addEventHandler]]. C'est très similaire à la fonction qui permet de déclencher une fonction via une commande.

Cet exemple produira un message avec le nom du joueur qui est mort :
<syntaxhighlight lang="lua">
function playerDied(totalAmmo, killer, killerWeapon, bodypart)
outputChatBox(getPlayerName(source).." died!")
end
addEventHandler("onPlayerWasted", getRootElement(), playerDied)
</syntaxhighlight>

Au lieu de lister les arguments qui sont nécessaires, la page de documentation pour un événement indique quels paramètres sont passés à la fonction que vous attachez à cet événement. Un autre point important est la variable "source", qui existe dans les fonction d'évènement. Il ne doit pas être ajoutés à la liste des paramètres de la fonction, mais elle existe quand même à l'intérieur de votre fonction. Cette variable a une valeur différente d'un événement à l'autre, pour les événements de joueurs (comme dans l'exemple au-dessus) c'est le joueur responsable de son déclenchement. Comme autre exemple, vous pouvez jeter un coup d'œil au script qui permet de faire apparaître le joueur dans la première section pour avoir une idée de comment utiliser cette variable "source".

==Où aller d'ici==
Vous devriez maintenant être familier avec les aspects les plus fondamentaux du scripting sur MTA et aussi un peu avec la documentation. Le [[Main_Page]] vous fournit des liens vers plus de renseignements, tutoriels et Références qui permettent de se plonger plus profondément dans les thèmes que vous désirez apprendre.

D'ici nous recommandons de lire les tutos sur le [[debugging]]. Les bonnes pratiques pour débuguer vos scripts sont une nécessité absolue quand vous faites des scripts.

[[ru:Scripting Introduction]]
[[it:Introduzione allo scripting]]
[[es:Introducción a la Programación]]

FR/Introduction Programmation

2016-08-07T22:19:30Z

Citizen: From google trad to real french

Les ressources sont les parties clées de MTA. Une ressource est un dossier ou un .zip qui contient plusieurs fichiers, ainsi qu'une meta qui dit au serveur comment la resource doit-elle être chargée. Une ressource peut être comparée comme un programme qu'on peut lancer ou arrêter, il est possible de lancer plusieurs ressources en même temps.

Tout ce qui a un rapport avec la programmation se passe dans les ressources, se que fait la ressource, définie si c'est un gamemode, une map or quelquechose d'autre. MTA s'installe avec des resources que vous pouvez facultativement utiliser dans vos gamemodes, comme la ressource "maplimits" pour garder les joueurs dans une certaine zone ou encore "deathpickups" pour créer des pickups pour ramasser une arme.

'''La première chose à faire avant de pouvoir programmer en lua, c'est de se procurer un editeur de texte qui supporte le lua. Il vous sera beaucoups plus facile que de le faire avec le bloc-note de Windows. Nous vous recommendons donc [http://notepad-plus.sourceforge.net/uk/site.htm Notepad++] ou [http://luaedit.sourceforge.net/ LuaEdit]. Il y a aussi un logiciel non officiel [[MTASE|MTA Script Editor]] ( malheureusement l'auteur ne travail plus dessus ) que vous pouvez tester.'''

==Créer un script qui fonctionne==
Nous allons voir tout d'abord comment créer un simple script étapes par étapes qui permetra aux joueurs de se deplacer dans la ville. Dans ce tutoriel, on utilisera notepadd++.
===Où sont tous les scripts ?===
Laissez moi d'abord vous présenter comment s'oranise une ressource. Allez dans votre dossier MTA San et et suivez le chemin suivant:

/serveur/mods/deathmatch/resources/

Vous y verez de nombreux fichier avec l'extension .zip, se sont des ressources avec à l'intérieur des exemples de scripts . Toutes les ressources chargées sont dézippé par le serveur afin de pouvoir les exécuter ( les .zip ne sont pas obligatiores, vous pouvez aussi laissez votre ressource en tant que dossier ). Pour créer votre propre ressource, créez simplement un nouveau dossier et nommez le comme vous voulez ( Ne pas utiliser d'espace, utilisez plutôt un _ ) . Nommez le "myserveur" pour ce tutoriel.

Maintenant entrez dans votre dossier. Le chemain devrait donc être

/serveur/mods/deathmatch/resources/myserveur/

===Identifier votre ressource===
Pour que le serveur puisse savoir ce que contient votre ressource, un fichier ''meta.xml'' doit être créé afin d'établir une liste du contenu du dossier. Cette 'meta.xml' doit être à la racine de votre ressource ( et non pas dans un autre sous-dossier ), donc dans le dossier "myserveur" dans notre cas. Donc ouvrez notepadd++, créer un nouveau fichier (Ctrl+N), puis faite "Enregistrez sous ..." (Ctrl+Alt+S), dans "Nom:" vous écrivez "meta" et dans "Type:", sélectionnez "*.xml" ( avant-dernier de la liste ), sauvegardez le dans votre dossier "myserveur".

Maintenant, ecrivez le code suivant dans votre ''meta.xml'':
<syntaxhighlight lang="xml">
<meta>
<info author="Votre Nom" type="gamemode" name="Mon serveur" description="Mon premier serveur MTA" />
<script src="script.lua" />
</meta>
</syntaxhighlight>
Dans la balise ''<info />'', il y a le champ "type" qui indique si la ressource est un ''gamemode'' ou une ''map'', on y reviendra plus tard. Un gamemode est ce dont vous avez besoin pour que votre serveur est une base.

La balise ''<script />'' indique les scripts qui sont dans la ressource, que l'on va maintenant créer.
===Créer un script simple===
Notez que dans la balise ''<script />'', le fichier .lua n'est pas dans un autre sous-dossier. Donc on va créer notre script.lua au même endroit que notre meta.xml ( Reproduisez la même opération mais "Nom:" écrivez 'script' et pour "Type:" choisissez 'Lua(*.lua)' ) puis copier-coller le code suivant:
<syntaxhighlight lang="lua">
function joinHandler()
local x = 1959.55
local y = -1714.46
local z = 10
spawnPlayer(source, x, y, z)
fadeCamera(source, true)
setCameraTarget(source, source)
outputChatBox("Bienvenue sur mon serveur", source)
end
addEventHandler("onPlayerJoin", getRootElement(), joinHandler)
</syntaxhighlight>
Ce script va fous faire apparître aux coordonnées (x, y, z) spécifié dans le code, lorsque vous connecterez au serveur. La fonction ''fadeCamera'' sinon l'écran restera noir. Vous devez aussi dire à la camera de suivre le joueur grâce à la fonction 'setCameraTarget' (sinon il vera une mer bleu).

La variable '''source''' indique qui 'déclenche' la fonction. Le fonction se 'déclenche' lorsqu'un joueur rejoind le serveur, vous utiliserez cette variable pour voir qui à rejoind le serveur. Donc lorsque un joueur( "la source" ) rejoindra notre serveur, on le fera apparaître aux coordonnées indiquées .

Focalisons-nous sur [[addEventHandler]], vous pouvez voir 3 choses: 'onPlayerJoin', qui indique quand éxécuter la fonction X. getRootElement(), qui indique qui/quoi peut être déclencher la fonction (getRootElement() veut dire toutes les choses et tous les joueurs). Et enfin la fonction X à éxecuter ( ici joinHandler ). Pour les autres details, nous verrons plus tard dans d'autres exemples mais tout d'abord testons notre premier gamemode!

===Lancer le gamemode===
Pour lancer le serveur, lancer simplement le 'MTA Server.exe' qui se trouve dans votre dossier 'MTA San et\server'. Une liste d'info concernant le serveur apparaîtra en premier; notez le port du serveur ( 22003 par défaut ), vous en aurez besoin pour rejoindre le serveur. Après, le serveur charge toutes les ressources du dossier 'resource', et enfin "ready to accept connections!"

Avant de pouvoir vous connecter, vous devez lancer votre gamemode. Tapez "start myserver" et appuyer sur Entrer. Le serveur va alors lancer le gamemode que nous avons créé, et nous affichera aussi les erreurs s'il y en a. Maintenant, vous pouvez lancer MTA, cliquez sur "Quick Connect" et ecrivez ceci: Dans Host: le1er champ: 127.0.0.1 ou localhost ( cela signifie que vous vous connectez au serveur du pc actuel ) et le 2ème champ: le port ( ici 22003 ) et cliquez sur 'Connect'. Si tout se passe bien, après quelques secondes, vous devriez apparaître et pouvoir allez où vous voulez.

Ensuite nous allons créer une commande que les joueurs pourront utiliser pour faire apparître une voiture à coté d'eux.

==Créer une commande==
Revenons à l'intérieur de notre ''script.lua''. Tout d'abord, nous devons créer une fonction qu'on pourra appeler/éxécuter grâce à notre commande et la fonction 'addCommandHandler' afin de créer la commande que les joueurs pourront taper dans le chat( T ) ou la console( F8 ).

<syntaxhighlight lang="lua">
-- On crée la fonction qui sera appelée par notre commande avec les arguments: thePlayer, command, vehicleModel
function createVehicleForPlayer(thePlayer, commandName, vehicleModel)
-- Ici on crée le véhicule
end
-- on crée la commande et on l'attache à notre fonction
addCommandHandler("createVehicle", createVehicleForPlayer)
</syntaxhighlight>
''Note: Grâce au wiki, vous pouvez cliquer sur le nom des fonctions et cela vous redirigera sur la documentation de cette fonction.''

====A propos du addCommandHandler====
Le premier argument du [[addCommandHandler]] est le nom de la commande the player will be able to enter, le second le nom de la fonction à appeler, dans notre cas, ''createVehicleForPlayer''.

Si vous avez déjà de l'expérience dans le codage, vous savez qu'un fonction s'appelle comme ceci:
<syntaxhighlight lang="lua">
nomDeLaFonction(argument1, argument2, argument3, ..)
</syntaxhighlight>
Si l'on regarde bien l'exemple ci-dessus, nous pouvons voir que l'argument1 est thePlayer and argument2 le commandName. thePlayer est celui qui à tapé la commande et commandName contient le nom de la commande qu'il à tapé. Donc si un joueur tape "/greet", cet argument va contenir "greet". Argument3 c'est ce que le joueur à tapé en plus de la commande, vous allez apprendre ceci dans le tutoriel. N'oubliez jamais que les deux premiers arguments sont les arguments standards, mais vous pouvez les renommé si vous voulez, seul l'ordre est important.

Par exemple: Un joueur tape "createVehicle 468" pour faire aparaître une Sanchez, la fonction addCommandHandler va appeller notre fonction createVehicleForPlayer, comme ceci:
<syntaxhighlight lang="lua">
createVehicleForPlayer(thePlayer,"createVehicle","468") -- thePlayer est l'élement joueur qui a tapé la commande
</syntaxhighlight>
Comme nous pouvons le voir, ll fournit plusieurs paramètres: le joueur qui a tapé la commande, la commande qu'il a tapé, et n'importe quelle texte qu'il a mis après, dans notre cas, "468" comme id de la Sanchez. Les deux premiers paramètres sont les même pour tous les addCommandHandler qu'on peut retrouver sur la page du [[addEventHandler]]. Vous devez toujours définir au moins ces deux paramètres pour utiliser les arguments après eux (par exemple pour traiter le texte qui a été entré après la commande, comme dans notre exemple le modèle du véhicule).

''Note: Vous devez créer la commande APRES la fonction que vous allez utiliser pour cette commande, sinon il ne trouvera pas la fonction.''

====Ecrire la fonction====
Pour remplir notre fonction d'instructions, nous devons d'abord pensez à ce que nous devons faire:
* Récupérer la position du joueur, donc on connaitra la position où faire apparaître le véhicule (on veut le faire apparaître à droite du joueur)
* Calculer la position où faire apparître le véhicule (nous ne voulons pas que le véhicule apparaisse dans le joueur)
* Faire apparître les véhicule
* Vérifier si le véhicule a bien apparus, ou aficher un message d'erreur.

Pour ça, nous devons utiliser plusieurs fonctions. Pour trouver la fonction que nous devons utiliser, il faut aller faire un tour dans la [[Scripting Functions|La liste des fonctions serveur]]. D'abord nous avons besoin d'une fonction pour obtenir la position du joueur. Puisque les joueurs sont des éléments, nous devons allez dans la rubrique '''Element functions''' où l'on pourra trouver la fonction [[getElementPosition]]. En cliquant sur le nom de la fonction, le wiki va vous afficher sa description. On peut y voir la syntaxe, qu'est-ce que la fonction retourne. La syntaxe nous montre les argument qu'on peut ou qu'on doit envoyer.

Pour [[getElementPosition]], la syntaxe est:
<syntaxhighlight lang="lua">
float, float, float getElementPosition ( element theElement )
</syntaxhighlight>

Les trois float devant le nom de la fonction est le type de variable que la fonction nous retourne. Dans notre cas, la fonction retourne trois nombres à virgule(x, y et z). Dans les parenthèses, on peut voir les arguments que l'on doit envoyer, dans notre cas, l'element dont on veut récupérer la position, le joueur dans notre exemple.

<syntaxhighlight lang="lua">
function createVehicleForPlayer(thePlayer, command, vehicleModel)
-- on récupère la position x,y,z dans des variables locales
-- une variable locale n'existe que dans le "périmètre" actuel. Ici, les variable x, y et z sont des variables locales qui se détruiront à la fin de la fonction.
local x,y,z = getElementPosition(thePlayer)
end
</syntaxhighlight>

Ensuite, il faut s'assurer que le véhicule n'apparaît pas directement dans le joueur, donc on ajoute quelques unités à la variable ''x'', qui le fera apparaître plus à l'est par rapport au joueur.

<syntaxhighlight lang="lua">
function createVehicleForPlayer(thePlayer, command, vehicleModel)
local x,y,z = getElementPosition(thePlayer) -- On prent la position du joueur qui a tapé la commande
x = x + 5 -- on ajoute 5 unité sur l'axes des x
end
</syntaxhighlight>

Maintenant nous avons besoin d'une autre fonction, celle qui va faire apparaître le véhicule. Nous allons la cherché encore une fois dans la [[Scripting Functions|liste des fonctions serveur]], mais cette fois, comme nous parlons d'un véhicule, nous devons donc aller dans la catégorie'''Vehicle functions''', où l'on va trouver la fonction [[createVehicle]]. Dans la syntaxe, nous pouvons voir que cette fonction ne retourne qu'une seule variable, le véhicule ( de type élément ) que nous venons de créer. Nous pouvons aussi voir qu'il y a des arguments entre crochets [], cela veut dire que ce sont des arguments optionels.

Nous avons déjà tous les arguments pour la fonction [[createVehicle]] dans notre fonction: La position que nous avons juste calculée dans les variables "x, y, z" et l'id du véhicule que nous avons fourni par la commande ("/createVehicle 468") et qui est stocké dans la variable ''vehicleModel''.

<syntaxhighlight lang="lua">
function createVehicleForPlayer(thePlayer, command, vehicleModel)
local x,y,z = getElementPosition(thePlayer) -- récupere la position du joueur dans les variables x, y et z
x = x + 5 -- rajoute 5 unités sur x
-- on crée le véhicule et on enregistre l'élément de type "vehicle" dans la variable ''createdVehicle''
local createdVehicle = createVehicle(tonumber(vehicleModel),x,y,z)
end
</syntaxhighlight>

Avec cette variable, on pourrait faire pas mal de choses sympa, mais ici nous allons juste vérifier si le véhicule à bien été créé ou non.
Sur le wiki de la fonction [[createVehicle]], il y a la partie nomée '''Returns''', la fonction va retourner ''false'' si la voiture n'a pas été créé. Ducoups, on va regarder la valeur de la variable ''createdVehicle''.

Voilà notre code complet:
<syntaxhighlight lang="lua">
function createVehicleForPlayer(thePlayer, command, vehicleModel)
local x,y,z = getElementPosition(thePlayer) -- On prent la position du joueur qui a tapé la commande
x = x + 5 -- on ajoute 5 unités à x
local createdVehicle = createVehicle(tonumber(vehicleModel),x,y,z) -- on crée le véhicule demandé par le joueur et on récupère ce que nous retourne la fonction dans la variable createdVehicle
-- On vérifie si la valeur retournée est égal à ''false'' ( ce qui signifie que ça n'a pas marché )
if (createdVehicle == false) then
-- si c'est le cas, on affiche un message d'erreur dans la chatbox mais seulement pour le joueur.
outputChatBox("Erreur lors de la création du véhicule.",thePlayer)
end
end
addCommandHandler("createVehicle", createVehicleForPlayer)
</syntaxhighlight>

Comme vous pouvez le voir, nous avons utilisé une nouvelle fonction: [[outputChatBox]]. Vous devriez maintenant pouvoir regarder la description de cette fonction par vous même.

==Ce que vous devez savoir==
Vous avez déjà lu quelques informations sur les ressources, les commandes et trouvez des fonctions dans le wiki, mais il y a encore beaucoup à apprendre. Cette section vous donnera une vue d'ensemble plutôt courte sur certaines de ces choses, tout en regardant les pages du wiki si possible.
===Les scripts client et serveur===
Vous pouvez avoir déjà remarqué ces termes (serveur/client) quelque part sur ce wiki, le plus souvent pour les fonctions. MTA ne supporte pas seulement les scripts exécuté par le serveur et des commandes (comme celle qu'on vien de faire) ou d'autres fonctions, mais aussi les scripts éxécuté par le client MTA, ceux des joueurs qui se connecte au serveur. La raison est que certaines fonctions de MTA doit être du coté client comme par exemple le GUI - Graphical User Interface - ( Pour tout ce qui est fenêtres, boutons, etc ), d'autres devraient être du côté client parce qu'ils fonctionnent mieux mais d'autres sont mieux pensées pour être du côté serveur ou ne fonctionne tout simplement pas du côté client.

La plupart de vos scripts (gamemodes, maps) seront surement du côté serveur, comme celui que nous avons fait tout à l'heure. Si vous vous heurtez à quelque chose qui ne peut pas être résolu du côté serveur, vous devrez probablement le faire côté client. Pour un script client, vous devriez créer un script ordinaire (par exemple appelé ''client.lua'') et spécifié dans la meta.xml, comme ceci:
<syntaxhighlight lang="xml">
<script src="client.lua" type="client" />
</syntaxhighlight>
L'attribut ''type'' est par defaut 'server', donc nous avons juste besoin de spécifier que c'est un script client. Lorsque vous faites ceci, le fichier va être télecharger par le joueur sur son ordinateur lorsqu'il se connecte au serveur. Plus d'infos: [[Client side scripts]].

===Ressources plus complexes===
La section précédente nous a montré brièvement comment ajouter des scripts clients à la ressource. Penchons nous maintenant sur la ''meta.xml'' et ce qu'elle fait.

====Premier example - Un script utile====
<syntaxhighlight lang="xml">
/admin_commands
/meta.xml
/commands.lua
/client.lua
</syntaxhighlight>
<syntaxhighlight lang="xml">
<meta>
<info author="Someguy" description="admin commands" />
<script src="commands.lua" />
<script src="client.lua" type="client" />
</meta>
</syntaxhighlight>

* Le "commands.lua" fournit quelques commandes d'admin, comme le fait d'interdire un joueur, en banissant ou quelque chose d'autre ce qui peut être utilisé par l'admin du serveur
* Le "client.lua" fournit un GUI pour être capable d'exécuter les actions mentionnées facilement

Cet exemple de script doit tourner tout le temps (peut être même démarré en même temps que le serveur) car ces commandes d'admin peuvent être appelé à n'importe quelle moment.

====Second example - Un gamemode====
<syntaxhighlight lang="xml">
/counterstrike
/meta.xml
/counterstrike.lua
/buymenu.lua
</syntaxhighlight>
<syntaxhighlight lang="xml">
<meta>
<info author="Quelqu'un" description="Counterstrike remake" type="gamemode" />
<script src="counterstrike.lua" />
<script src="buymenu.lua" type="client" />
</meta>
</syntaxhighlight>

* Le "counterstrike.lua" contient des caractéristiques semblables aux dispositifs suivants :
** Laisser les joueurs choisirent leur équipe et les faire apparaître
** Leur fournir des armes, des cibles et des instructions (peut-être lues d'une carte, voir ci-dessous)
** Définir les règles du jeu, par exemple. La partie se finie, ce qui se produit quand un joueur meurt
** .. et peut-être encore plus
* Le "buymenu.lua" est un script du côté client et crée un menu pour acheter des armes

Cet exemple peut s'appeler un gamemode, il modifie le gameplay, mais définit réellement les règles de celui-ci. Le "type" attribut indique que cet exemple fonctionne avec [[Map Manager]], encore une autre ressource qui a été écrite par l'équipe de MTA pour contrôler des gamemodes et le chargement de cartes. On recommande fortement que vous basiez vos gamemodes sur les techniques qu'il fournit.

Ceci signifie également que ce gamemode ne fonctionnera probablement pas sans carte. Les gamemodes devront toujours être aussi génériques que possible. Un exemple de gamemode utilisant une carte est énoncé dans le prochain exemple.

====Troisième exemple - Une carte====
<syntaxhighlight lang="xml">
/cs-airport
/meta.xml
/airport.map
/airport.lua
</syntaxhighlight>
<syntaxhighlight lang="xml">
<meta>
<info author="Quelqu'un" description="Counterstrike airport map" type="map" gamemodes="counterstrike" />
<map src="airport.map" />
<script src="airport.lua" />
</meta>
</syntaxhighlight>

* Le "airport.map" dans le fichier XML fournit des informations au sujet de la carte au gamemode, ceului-ci peut inclure :
** Là où les joueurs devraient apparaitre, avec quelles armes, avec quelle équipe
** Ce qui sont les cibles
** Temps, heure du monde, Limite de temps
** Fournir les véhicules
* Le ''airport.lua'' peut contenir des actions relatifs a la map comme:
** Ouvrir une certaine porte ou faire éxploser quelque chose quand une autre chose de spécifique se produit
** Créer ou déplacer quelques objets faits sur commande, ou manoeuvrez les objets qui sont créés dans le fichier .map
** .. toutes autre choses relatifs aux ojets du .map

Comme vous pouvez le voir, l'attribut "type" a été changé en 'map', pour dire au [[Map Manager]] que cette ressource est une carte, tandis que l'attribut "gamemodes" indique pour quels gamemodes cette carte est valide, dans ce cas-ci le gamemode de l'exemple de tout à l'heure.
Ce qui peut venir comme une surprise est qu'il y a aussi un script dans la ressource de carte. Évidemment ce n'est pas nécessaire dans une carte, mais ouvre une large gamme de possibilités pour les créateurs de cartes.

Le "airport.map" pourrait être semblable à ceci :
<syntaxhighlight lang="xml">
<map mode="deathmatch" version="1.0">
<terrorists>
<spawnpoint posX="2332.23" posY="-12232.33" posZ="4.42223" skins="23-40" />
</terrorists>
<counterterrorists>
<spawnpoint posX="2334.23443" posY="-12300.233" posZ="10.2344" skins="40-50" />
</counterterrorists>

<bomb posX="23342.23" posY="" posZ="" />

<vehicle posX="" posY="" posZ="" model="602" />
<vehicle posX="" posY="" posZ="" model="603" />
</map>
</syntaxhighlight>

Quand un gamemode est commencé avec une carte, les ressources de carte est automatiquement démaré par le mapmanager et les renseignements qu'il contient peut être lu par le gamemode. Quand la carte change, la ressource de carte actuelle est arrêtée et la ressource de carte suivante est commencée. Pour une explication plus détaillée et des exemples pour savoit comment les ressources de cartes sont utilisées dans le script principal, visitez s'il vous plaît la page [[Writing Gamemodes]].

===Événements===
MTA utilise les événements pour signaler aux scripts que des choses s'est passé dans le jeu. Par exemple quand un joueur meurt, l'évènement [[onPlayerWasted]] est déclenché. Pour exécuter n'importe quelle action quand un joueur meurt, votre script doit donner le nom de sa fonction à exécuter lorsque cet événement est déclenché par MTA grâce à la fonction [[addEventHandler]]. C'est très similaire à la fonction qui permet de déclencher une fonction via une commande.

Cet exemple produira un message avec le nom du joueur qui est mort :
<syntaxhighlight lang="lua">
function playerDied(totalAmmo, killer, killerWeapon, bodypart)
outputChatBox(getPlayerName(source).." died!")
end
addEventHandler("onPlayerWasted", getRootElement(), playerDied)
</syntaxhighlight>

Au lieu de lister les arguments qui sont nécessaires, la page de documentation pour un événement indique quels paramètres sont passés à la fonction que vous attachez à cet événement. Un autre point important est la variable "source", qui existe dans les fonction d'évènement. Il ne doit pas être ajoutés à la liste des paramètres de la fonction, mais elle existe quand même à l'intérieur de votre fonction. Cette variable a une valeur différente d'un événement à l'autre, pour les événements de joueurs (comme dans l'exemple au-dessus) c'est le joueur responsable de son déclenchement. Comme autre exemple, vous pouvez jeter un coup d'œil au script qui permet de faire apparaître le joueur dans la première section pour avoir une idée de comment utiliser cette variable "source".

==Où aller d'ici==
Vous devriez maintenant être familiers avec les aspects les plus fondamentaux de MTA scripting et aussi un peu avec la documentation. Le [[Main_Page]] vous fournit des liens vers plus de renseignements, Classes de travaux dirigés et Références qui permettent un coup d'oeil plus profond dans les thèmes dont vous désirez apprendre.

D'ici nous recommandons de lire le [[debugging]] la classe de travaux dirigés. De bonnes adresses déboguantes sont une nécessité absolue quand vous faites des scripts.

[[ru:Scripting Introduction]]
[[it:Introduzione allo scripting]]
[[es:Introducción a la Programación]]

Talk:Page d'accueil

2014-08-28T07:48:25Z

Citizen:

'''Splinter.Hopkins:'''
'''@Citizen''' Je suis en train de créer toutes les pages du wiki fr pour qu'il ne reste plus qu'à traduire.
I'm creating all the pages for the french wiki, then the contributors will just click on Edit to translate that page.

'''Citizen:'''
'''@Splinter.Hopkins''' Pas de soucis, je l'avais déjà fait y a un bon moment, mais des liens se sont pétés apparemment.
Par contre j'avais laissé les lien vers les pages anglaises pour tout ce qui était '''ID Listes''', '''Références''', '''Développer Multi Theft Auto''' et '''Wiki - Comment aider'''. Merci bien en tout cas. Faudrait également que je relance les personnes qui avaient commencés des traductions et qui ne les ont pas terminées.

FR/ACL

2014-07-09T22:12:12Z

Citizen:

MTA inclut une Liste de Contrôle d'Accès (ACL) qui vous permet de sécuriser et limiter l'accès aux fonctionnalités et commandes du serveur.

La clé du concept de l'ACL de MTA(et des ACLs en générale) est que l'on donne à un objet spécifique une liste de droits. Dans le cas de MTA, il y a deux types d'objets: des ressources or et des utilisateurs. Il y a de nombreux ''droits'' disponible dans MTA.

En bref, l'ACL définit quels fonctions une ressource ou un utilisateur peut effectuer. Cela peut évidemment être très utile pour par exemple empêcher tous les joueurs de votre serveur d'être en mesure de se bannir entre eux, ou d'empêcher vos nouvelles ressources non testées de faire de même.

Bien sûr, ''plus de pouvoir implique plus de responsabilité'' et il est très facile de faire buguer totalement une ressource - par exemple, désactiver la fonction '''[[spawnPlayer]]''' pour toutes les ressource serai une très mauvaise idée :). Evidemment vous pouvez vous retrouver dans un cas ou ce genre de manipulation est nécessaire - si vous voulez forcer toutes les ressources à utiliser une ressource spéciale pour faire spawn un joueur par exemple - mais c'est quand même un peu draconien.

==Comprendre l'ACL==
Il y a deux composants dans l'ACL: les groupes et les droits. Ils sont représentés comme ceci '''<group name=" ">''' et '''<acl name=" " />''' respectivement. Leurs rôles sont:<br \>
'''1.''' Donner des permissions à des joueurs pour contrôler le serveur et utiliser les commandes des ressources. Exemples:''<br \>
*N'autoriser que les admins à utiliser la fonction '''[[giveWeapon]]''' de la ressource freeroam.
*Autoriser tous les joueurs à démarrer une ressource.
'''2.''' Donner des permissions à des ressources pour avoir le droit d'utiliser des fonctions en interne et des fonctions d'autres ressources. Exemples:<br \>
*Autoriser une ressource à utiliser la fonction '''[[restartResource]]'''.
*Autoriser une ressource d'utiliser la fonction '''[[call]]''' pour utiliser les fonctions exportées d'autres ressources.

===Groupes par défaut===
MTA possède déjà des groupes avec des permissions de plus en plus élevées:
*'''Everyone''' - Groupe qui concerne tout le monde
*'''Moderator''' - Le groupe des Modérateurs
*'''SuperModerator''' - Le groupe des Super Modérateurs
*'''Admin''' - Le groupe des Admins
*'''Console''' - Contrôle les droits pour les personnes qui utiliseront la console du serveur via '''<object name="user.Console" />'''
*'''RPC''' - Remote Procedure Call. Accorde seulement l'accès à la fonction '''[[callRemote]]''' et désactive les commandes des ressources par défaut.

To explain further, I will use the Everyone group as an example. By default it looks like this:
<syntaxhighlight lang="lua"> <group name="Everyone">
<acl name="Default" />
<object name="user.*" />
<object name="resource.*" />
</group>
</syntaxhighlight>
<br \>
You will first notice the acl name inside the group. It defines what permissions the group has. Users and resources in this group will have the permissions specified on the "Default" acl name list. ''Note: You will notice this group is special, in that it includes every user and resource by using a '''wildcard (*)''' where the user or resource name would be.''

Now, scroll further down the ACL and you will see the '''<acl name="Default" />''' listing. Note I have trimmed this list dramatically due to its length.

<syntaxhighlight lang="lua"> <acl name="Default">
<right name="command.start" access="false" />
<right name="command.stop" access="false" />
<right name="command.stopall" access="false" />
...etc etc...
<right name="function.executeCommandHandler" access="false" />
<right name="function.setPlayerMuted" access="false" />
<right name="function.restartResource" access="false" />
...etc etc...
<right name="general.adminpanel" access="false" />
<right name="general.tab_players" access="false" />
<right name="general.tab_resources" access="false" />
...etc etc...
<right name="command.freeze" access="false" />
<right name="command.shout" access="false" />
<right name="command.spectate" access="false" />
...etc etc...
</acl>
</syntaxhighlight>
<br \>
*'''Function''' entries are MTA scripting functions. For example, if a resource needed to use restartResource and was only in the 'Everyone' group (with the 'Default' list), it would be denied access to restartResource and fail to work correctly.
*'''Commands''' are created when a resource uses [[addCommandHandler]]. An example would be typing '''/createvehicle [vehicle]''' in the chatbox for the freeroam resource. This controls whether users in the group using this ACL can use the command. ''Note: commands have no effect on resources within the group. Commands are only related to users.''
**''General is a custom right name group created by the admin resource but it works on the same principles. The script works with them by using [[hasObjectPermissionTo]]''

You will notice some groups such as admin have multiple '''<acl name="" />''' nodes. An example is the admin group:
<syntaxhighlight lang="lua">
<group name="Admin">
<acl name="Moderator" />
<acl name="SuperModerator" />
<acl name="Admin" />
<acl name="RPC" />
<object name="resource.admin" />
<object name="resource.webadmin" />
<object name="user.Ransom" />
</group>
</syntaxhighlight>

This gives all the permissions defined in each '''<acl name="" />''' node in order of listing. So for example, the admin group makes sure all the permissions are given to admins by using all the lists. If there are any conflicts, the lowest entry wins. For example, pretend these 2 acls were in a group in the following order:

'''1.''' '''<acl name="Default">''' sets <right name="general.ModifyOtherObjects" access="false" /> <br\>
'''2.''' '''<acl name="Admin">''' sets <right name="general.ModifyOtherObjects" access="true" /> <br\>
'''3.''' For all users and resources in group admin: <right name="general.ModifyOtherObjects" access="true" /><br\>
<br\>

=== Resource Groups and ACLs ===
You will notice there are some other groups that came with MTA. These were defined by resources that came with MTA. If a resource wants to designate specific ACL rights not provided by the default MTA groups, it can create its own ACL name and a group to use it. I will show AMX's entry as an example. AMX is designed to emulate SA-MP scripts and it needs a certain set of permissions that doesn't fit the default groups well. It is shown below:

<syntaxhighlight lang="lua">
<group name="AMX">
<acl name="AMX" />
<object name="resource.amx" />
</group>

<acl name="AMX">
<right name="general.ModifyOtherObjects" access="true" />
<right name="function.startResource" access="true" />
<right name="function.stopResource" access="true" />
<right name="general.adminpanel" access="false" />
...etc etc...
<right name="command.kick" access="false" />
<right name="command.freeze" access="false" />
<right name="command.mute" access="false" />
...etc etc...
</acl>
</syntaxhighlight>

==Modifying the ACL==
There are three ways you can modify the ACL - how you do it depends who you are.

===HTTP Interface===
You can use the [[Resource/webadmin|webadmin]] http interface to modify the ACL in your web browser. This is by far the easiest way to do so. Just make sure the ''webadmin'' resource is started on your server and visit ''<nowiki>http://ServerIP:HttpPort/</nowiki>''. You can then use the two sections - ACLs and Groups. ACLs allows you to create your Access Control Lists - lists of rights. Groups allow you to group together collections of users and assign ACLs to them. For example, the ACLs section allows you to specify that the Admin ACL has access to the ''start'' console command. You can the go to the Groups section and create an Admin ''group'' that has access to your Admin ''acl''. You can then add users to your Admin ''group''.

===XML file===
You can modify the ACL.xml file manually. This has a fairly straightforward syntax, but it can get a bit confusing at times. If you do it while the server is running, don't forget to call the scripting function [[aclReload]] ("start runcode", "run aclReload()") so the new ACL is loaded, or otherwise stop your server before modifying. This also prevents your changes from being accidentally overwritten by the server.

===Scripting functions===
You can use a large number of ACL scripting functions to modify the ACL on the fly. Of course, you can (and really should!) limit access to the ACL functions with the ACL. Note that the '''admin resource''' that comes with MTA can be used to manage the ACL from the resources tab. You must be setup as admin to use the admin panel. [http://wiki.multitheftauto.com/wiki/Admin Click here for admin setup instructions].

==See Also==
{{ACL functions}}
[[Category:Scripting Concepts]]
[[ru:Access Control List]]
[[Category:Tutorials]]

FR/ACL

2014-07-09T21:07:48Z

Citizen: Clean copy from english version, need to be translated.

MTA includes a complete Access Control List (ACL) that allows you to secure and limit access to the server, its functions and resources in any number of ways.

The key concept of MTA's ACL (and ACLs in general) is that you're giving a specific object a set of rights. In MTA's case objects are one of two things - resources or users. There are numerous ''rights'' available in MTA - these mainly focus on server-side scripting functions.

What this essentially means is that the ACL allows you to choose exactly what functions a resource or user can perform. This can obviously be invaluable - for example preventing all your server's players from being able to ban each other, or preventing your new untested resources from doing the same.

Of course, ''with great power comes great responsibility'' and it is very easily possible to completely break resources - for example, disabling [[spawnPlayer]] for all resources would be a Bad Thing. Of course, there are situations when you might want to do this - if you want to force all your resources to use a spawn manager resource for example, but even this is somewhat draconian.

==Understanding the ACL==
There are two major components to the ACL: groups and ACL lists. They appear as '''<group name="">''' nodes and '''<acl name="" />''' nodes. Their purpose is to:<br \>
'''1.''' Grant users permission to control the server and use resource commands. Examples:''<br \>
*Allowing only admins to use the giveweapon function of freeroam
*Allowing all users to start a resource
'''2.''' Grant resources permission to use script functions and functions of other resources. Examples:<br \>
*Allowing a resource to use the restartResource function
*Allowing a resource to use the call function to use exported functions from another script

===Default Groups===
MTA has provided some default groups with increasing permissions. These groups are:
*'''Everyone'''
*'''Moderator'''
*'''SuperModerator'''
*'''Admin'''
*'''Console''' - This controls permissions of people who are using the console through '''<object name="user.Console" />'''
*'''RPC''' - Remote Procedure Call. Specifically grants access to [[callRemote]] only and disables commands of default resources. Check the function for details.
<br \>

To explain further, I will use the Everyone group as an example. By default it looks like this:
<syntaxhighlight lang="lua"> <group name="Everyone">
<acl name="Default" />
<object name="user.*" />
<object name="resource.*" />
</group>
</syntaxhighlight>
<br \>
You will first notice the acl name inside the group. It defines what permissions the group has. Users and resources in this group will have the permissions specified on the "Default" acl name list. ''Note: You will notice this group is special, in that it includes every user and resource by using a '''wildcard (*)''' where the user or resource name would be.''

Now, scroll further down the ACL and you will see the '''<acl name="Default" />''' listing. Note I have trimmed this list dramatically due to its length.

<syntaxhighlight lang="lua"> <acl name="Default">
<right name="command.start" access="false" />
<right name="command.stop" access="false" />
<right name="command.stopall" access="false" />
...etc etc...
<right name="function.executeCommandHandler" access="false" />
<right name="function.setPlayerMuted" access="false" />
<right name="function.restartResource" access="false" />
...etc etc...
<right name="general.adminpanel" access="false" />
<right name="general.tab_players" access="false" />
<right name="general.tab_resources" access="false" />
...etc etc...
<right name="command.freeze" access="false" />
<right name="command.shout" access="false" />
<right name="command.spectate" access="false" />
...etc etc...
</acl>
</syntaxhighlight>
<br \>
*'''Function''' entries are MTA scripting functions. For example, if a resource needed to use restartResource and was only in the 'Everyone' group (with the 'Default' list), it would be denied access to restartResource and fail to work correctly.
*'''Commands''' are created when a resource uses [[addCommandHandler]]. An example would be typing '''/createvehicle [vehicle]''' in the chatbox for the freeroam resource. This controls whether users in the group using this ACL can use the command. ''Note: commands have no effect on resources within the group. Commands are only related to users.''
**''General is a custom right name group created by the admin resource but it works on the same principles. The script works with them by using [[hasObjectPermissionTo]]''

You will notice some groups such as admin have multiple '''<acl name="" />''' nodes. An example is the admin group:
<syntaxhighlight lang="lua">
<group name="Admin">
<acl name="Moderator" />
<acl name="SuperModerator" />
<acl name="Admin" />
<acl name="RPC" />
<object name="resource.admin" />
<object name="resource.webadmin" />
<object name="user.Ransom" />
</group>
</syntaxhighlight>

This gives all the permissions defined in each '''<acl name="" />''' node in order of listing. So for example, the admin group makes sure all the permissions are given to admins by using all the lists. If there are any conflicts, the lowest entry wins. For example, pretend these 2 acls were in a group in the following order:

'''1.''' '''<acl name="Default">''' sets <right name="general.ModifyOtherObjects" access="false" /> <br\>
'''2.''' '''<acl name="Admin">''' sets <right name="general.ModifyOtherObjects" access="true" /> <br\>
'''3.''' For all users and resources in group admin: <right name="general.ModifyOtherObjects" access="true" /><br\>
<br\>

=== Resource Groups and ACLs ===
You will notice there are some other groups that came with MTA. These were defined by resources that came with MTA. If a resource wants to designate specific ACL rights not provided by the default MTA groups, it can create its own ACL name and a group to use it. I will show AMX's entry as an example. AMX is designed to emulate SA-MP scripts and it needs a certain set of permissions that doesn't fit the default groups well. It is shown below:

<syntaxhighlight lang="lua">
<group name="AMX">
<acl name="AMX" />
<object name="resource.amx" />
</group>

<acl name="AMX">
<right name="general.ModifyOtherObjects" access="true" />
<right name="function.startResource" access="true" />
<right name="function.stopResource" access="true" />
<right name="general.adminpanel" access="false" />
...etc etc...
<right name="command.kick" access="false" />
<right name="command.freeze" access="false" />
<right name="command.mute" access="false" />
...etc etc...
</acl>
</syntaxhighlight>

==Modifying the ACL==
There are three ways you can modify the ACL - how you do it depends who you are.

===HTTP Interface===
You can use the [[Resource/webadmin|webadmin]] http interface to modify the ACL in your web browser. This is by far the easiest way to do so. Just make sure the ''webadmin'' resource is started on your server and visit ''<nowiki>http://ServerIP:HttpPort/</nowiki>''. You can then use the two sections - ACLs and Groups. ACLs allows you to create your Access Control Lists - lists of rights. Groups allow you to group together collections of users and assign ACLs to them. For example, the ACLs section allows you to specify that the Admin ACL has access to the ''start'' console command. You can the go to the Groups section and create an Admin ''group'' that has access to your Admin ''acl''. You can then add users to your Admin ''group''.

===XML file===
You can modify the ACL.xml file manually. This has a fairly straightforward syntax, but it can get a bit confusing at times. If you do it while the server is running, don't forget to call the scripting function [[aclReload]] ("start runcode", "run aclReload()") so the new ACL is loaded, or otherwise stop your server before modifying. This also prevents your changes from being accidentally overwritten by the server.

===Scripting functions===
You can use a large number of ACL scripting functions to modify the ACL on the fly. Of course, you can (and really should!) limit access to the ACL functions with the ACL. Note that the '''admin resource''' that comes with MTA can be used to manage the ACL from the resources tab. You must be setup as admin to use the admin panel. [http://wiki.multitheftauto.com/wiki/Admin Click here for admin setup instructions].

==See Also==
{{ACL functions}}
[[Category:Scripting Concepts]]
[[ru:Access Control List]]
[[Category:Tutorials]]

Page d'accueil

2014-07-09T21:04:52Z

Citizen: Typo + Links

<div style="background: #FFEEAA; padding: 5px; float:right; width: 30%;">Dernière version stable de '''Multi Theft Auto: San Andreas''' est '''{{Current Version|full}}'''. Rendez-vous sur la [http://mtasa.com/ page principale] pour la télécharger.
<p>
Vous pouvez aussi télécharger une [http://nightly.mtasa.com/ beta] pour avoir la dernière version ( non stable ).
</p>
</div>
__NOTOC__
Bienvenue sur le wiki de Multi Theft Auto. Sur ce wiki, vous trouverez toutes les informations sur Multi Theft Auto.

Il y a [[How you can help|différents moyens de nous aider]]: créer une map, un gamemode, rediger des articles sur des fonctions, écrire un exemple, écrire un tutorial ou juste jouer à MTA et nous rapportez les bugs trouvés.

<div style="clear:both;"></div>
{| width="100%" cellspacing="0" cellpadding="0"
| colspan="2" |

|-
| width="50%" style="vertical-align:top;" |
<div style="border: 1px dotted #AAAAAA;padding:4px 8px 8px 8px;margin:10px;">
====Pour commencer====

* [[FR/Manuel_Client|Manuel Client]] ( Traduction: [http://wiki.multitheftauto.com/wiki/User:DrawKiie DrawKiie] )
* [[FR/Manuel_Serveur|Manuel Serveur]] ( Traduction: [http://wiki.multitheftauto.com/wiki/User:Rouche Rouche] )
* [[FR/Problemes_connus|Problèmes connus]] ( Traduction: [http://wiki.multitheftauto.com/wiki/User:Rouche Rouche] )
* [[FR/Migrer_de_MTARace_a_MTASA_1.0.x|Migrer de MTA:Race à MTA:SA 1.0.x]] ( Traduction: [http://wiki.multitheftauto.com/wiki/User:Rouche Rouche] )
* [[FR/A propos des Map|A propos des Map]] ( Traduction: [http://wiki.multitheftauto.com/wiki/User:Rouche Rouche] )

</div>

<div style="border: 1px dotted #AAAAAA;padding:4px 8px 8px 8px;margin:10px;">

====Programmer====

* [[FR/Introduction_Programmation|Introduction: La programmation]]
* [[FR/Introduction_GUI|Introduction: Le GUI]] ( Traduction: [http://wiki.multitheftauto.com/wiki/User:FatalTeror FatalTerror] )
* [[FR/Debugage|Tutoriel: Le débugage]] - Comment trouver les erreurs dans son script
* [[FR/Ressources|Introduction: Les ressources]] (Traduction : [http://wiki.multitheftauto.com/wiki/User:Myk3L Myk3L])
** [[FR/Ressource_Acces_Web|Accès depuis le web]] - Comment créer un site à partir d'une ressource (Traduction : [http://wiki.multitheftauto.com/wiki/User:Myk3L Myk3L])
** [[:Category:Resource|Catalogue des ressources]]
** [[FR/Meta.xml|Meta.xml]] - Derrière chaque ressource se trouve une meta pour la définir
** [[FR/ACL|ACL]] - Access Control List, pour définir les autorisations
* [[FR/Ecrire_Gamemode|Créer un gamemode]] ( Traduction: [http://wiki.multitheftauto.com/wiki/User:Rouche Rouche])
* [[FR/Fonctions_Utiles|Fonctions utiles]]

</div>

<div style="border: 1px dotted #AAAAAA;padding:4px 8px 8px 8px;margin:10px;">

====Bases de données====
Cette section décrit toutes les capacités fournies par le LUA/MTA ou par les ressources.
* [[:Category:Resource|Catalogue des ressources]] - Vous devriez le lire pour réaliser un script approprié.
* [[FR/Les_scripts_clients| Les scripts clients]]
</div>
<div style="border: 1px dotted #AAAAAA;padding:4px 8px 8px 8px;margin:10px;">

====Aide générale du LUA====
Des pages conçues pour aider votre compréhension du Lua
*[http://www.lua.org/pil/index.html "Programming in Lua"]
**[http://www.lua.org/manual/5.1/#index Les fonctions Lua]
*[http://lua-users.org/wiki/TutorialDirectory wiki Lua]
*[http://nixstaller.berlios.de/manual/0.2/nixstaller_9.html Un guide général au Lua de Nixstaller]
</div>

| width="50%" style="vertical-align:top;" |
<div style="border: 1px dotted #AAAAAA;padding:4px 8px 8px 8px;margin:10px;">

====Map Editor====
*[[Resource:Editor|Manuel]]
*[[Resource:Editor/EDF|Editor Definition Format]]
*[[Resource:Editor/Plugins|Plugins]]
*[[Resource:Editor#FAQ|Questions Fréquentes]]
</div>

<div style="border: 1px dotted #AAAAAA;padding:4px 8px 8px 8px;margin:10px;">

====Développer Multi Theft Auto====
* [[FR/Compiler_MTASA|Compiler MTASA sur Windows]]
* [[FR/Compiler_MTASA_Server_sur_Mac_OS_X|Compiler MTASA sur Mac OS X]]
* [[FR/Compiler_MTASA_Server_sur_GNU_Linux|Compiler MTASA sur GNU/Linux]]
* [[FR/Directives_de_codage|Directives de codage]]
* [http://code.google.com/p/mtasa-blue Google Code SVN]
* [[FR/Roadmap|Roadmap]]
</div>

<div style="border: 1px dotted #AAAAAA;padding:4px 8px 8px 8px;margin:10px; background:#CCCCFF;">

====Références====
* [[FR/Fonctions_Clients|Fonctions Clients]]
* [[FR/Events_Clients|Events Clients]]
* [[FR/Fonctions_Serveurs|Fonctions Clients]]
* [[FR/Events_Serveurs|Events Clients]]

* [[FR/MTA Classes|MTA Classes]] - Les descriptions détaillées de tous les types personnalisés MTA
** [[FR/Element|MTA Elements]] / [[Element tree]]
</div>

<div style="border: 1px dotted #AAAAAA;padding:4px 8px 8px 8px;margin:10px;">

====[[Id|ID Listes]]====
*[[FR/Animations|Animations]]
*[[FR/Skins_Personnages|Skins Personnages]]
*[[FR/Vetements_CJ|Vêtements CJ]]
*[[FR/Garage|Garage IDs]]
*[[FR/Interieurs_IDs|Intérieurs IDs]]
*[[FR/Materiel_IDs|Matériel IDs]]
*[[FR/Projectiles|Projectiles]]
*[[FR/Radar Blips|Radar Blips]]
*[[FR/Sons|Sons]]
*[[FR/Vehicule_IDs|ID des véhicules]]
*[[FR/Vehicule_Couleurs|Couleurs véhicules]]
*[[FR/Vehicule_Upgrades|Tuning IDs]]
*[[FR/Armes|Armes]]
*[[FR/Meteos|Météos]]
</div>

|-
| colspan="2" |
|}
{{Languages list|fr}}

FR/Skins Personnages

2014-07-09T20:54:49Z

Citizen: Translated in french

Les skins utilisable en jeu.

*[[All Skins Page | Page de tous les skins]] - Non recommandé pour les connexions lentes
*[[Special Skins Page | Pages des skins spéciaux]] - Les nouveaux skins depuis MTA 1.1

'''Les pages des skins sectionnés:'''
----
*[[Skins Page 1]]: 7, 9-29
*[[Skins Page 2]]: 30-41, 43-52
*[[Skins Page 3]]: 53-64, 66-73, 75-76
*[[Skins Page 4]]: 77-85, 87-99
*[[Skins Page 5]]: 100-118, 120-122
*[[Skins Page 6]]: 123-144
*[[Skins Page 7]]: 145-148, 150-167
*[[Skins Page 8]]: 168-189
*[[Skins Page 9]]: 190-207, 209-212
*[[Skins Page 10]]: 213-234
*[[Skins Page 11]]: 235-238, 240-257
*[[Skins Page 12]]: 258-264, 274-288

==Notes:==
*12 pages: 266 total.

*Les id de 1 à 8 (sauf le 7) ne fonctionnent pas.

*Les paires d'ids suivants donnent le même skins (le 1er est utilisé dans les listes, le 2ème est désactivé).
**118:119
**148:149

*Les ids qui ne fonctionnent pas:
1-6
8
42
65
74
86
119
149
208
239
265-273

==Voir aussi==
[[id|Liste des ids]]

[[it:Skin Personaggi]]
[[ru:Character Skins]]
[[es:Skins de Personajes]]

[[Category:ID Lists]]

FR/Manuel Client

2014-07-09T20:39:08Z

Citizen:

__TOC__

==Avant de commencer==

Avant d'installer Multi Theft Auto: San Andreas, assurez-vous en premier que le jeu GTA:SA est bien installé. Dans le cas échéant, MTA:SA ne pourra démarrer. Si vous voulez garder vos mods spécifiques à la version solo du jeu (ces mods étant généralement interdits sur la plupart des serveurs MTA:SA), réinstallez GTA:SA dans un autre fichier sur votre disque dur.

Assurez-vous aussi d'être sur '''Windows XP''', '''Windows Vista''' (32 bits ou 64 bits), '''Windows 7''' (32 bits ou 64 bits) or '''Windows 8''' (32 bits ou 64 bits) et que vous êtes capable de lancer le jeu solo. Sachez que si vous arrivez à jouer au solo sur un pc dont ses caractéristiques sont vraiment au minimum requis, vous aurez sûrement du mal à faire fonctionner MTA:SA correctement.
{{Note|
* MTA:SA ne fonctionne que sur GTA:SA '''v1.0'''. Si vous venez d'acheter le jeu, il est plus que probable que vous ayez la dernière version.''' [[Known_Issues_-_FAQ#Does_MTASA_work_with_v1.01_or_v2.00_of_GTA_San_Andreas.3F| (Plus d'info)]]
* Si vous avez la version Steam de GTA: San Andreas vous devez [[Known_Issues_-_FAQ#I_have_the_Steam_version_of_GTA_San_Andreas._How_can_I_play_MTASA.3F|lire ceci d'abord]].
}}

===Exigences du système===
Les exigences du système pour faire fonctionner MTA:SA sont à peine plus élevées que celles nécessaires pour GTA:SA.
* Intel Pentium 4 ou AMD Athlon XP.
* 512MB DDR RAM.
* Une installation sans modifications du jeu GTA:SA v1.0 (Américain ou Européen).
* 3.7GB d'espace disponible sur votre disque dur (3.6GB sont minimum pour l'installation de GTA:SA).
* nVidia GeForce 4 series ou ATI Radeon 8xxx series (64MB RAM et DirectX 9.0 compatible).
* DirectX 9.0 carte son compatible.
* Clavier et souris.
* Une connexion internet haut-débit (pour faciliter les chargements).

Pour de meilleurs graphismes, une carte graphique compatible avec Pixel Shader 2.0 (nVidia GeForce FX series ou plus, ATI Radeon 9xxx series ou plus) est recommandée.

Pour une meilleure performance de chargement, une plus grande RAM est recommandée.

==Installer MTA:SA==
# Si ce n'est pas déjà fait, téléchargez MTA:SA depuis la page du site [http://mtasa.com mtasa.com].
# Lancer l'installeur, pour Windows Vista et Windows 7 il faut le lancer en tant qu'administrateur. (L'installeur le demandera.)
# Vous devez accepter la licence de MTA:SA (GPLv3).
# Une page vous permettra de sélectionner les composants désirés:
#* '''Game Client''' s'interface avec le jeu et est nécessaire.
#* '''Dedicated Server''' vous permet de créer votre propre serveur.
#** '''Core components''' et '''Game module''' sont requis par le serveur dédié.
#** '''Core resources''' comprends toutes les ressources requises par le serveur dédié.
#** '''Optional resources''' comprends des ressources additionnels (des gamemodes et des maps).
#** '''Editor''' vous permet de créer des maps (optionnel).
#* '''Development''' comprends des outils de développement.
#** '''Module SDK''' le SDK permettant de créer des modules (connaissances en C++ requises).
#* '''Start menu group''' crée un group dans le menu démarrer pour les composants précédents.
#* '''Desktop icon''' crée un raccourcis sur le bureau pour lancer MTA:SA.
# Ensuite l'istalleur vous demandera dans quel dossier installer MTA:SA. Choisissez l'emplacement que vous voulez, il n'est pas obligatoire de l'installer dans le dossier de GTA San Andreas.
# Ensuite, il vous demandera dans quel dossier ce trouve le dossier de GTA San Andreas. Par défaut il se trouve dans: '''C:\Program Files\Rockstar Games\GTA San Andreas\'''.
# Lorsque l'installation se termine, vous aurez la possibilité de démarrer MTA:SA directement. Cliquez ensuite sur '''Finish'''.
# Plus tard, vous pourrez lancer ''MTA San Andreas'' depuis le menu démarrer.

==Lancer le jeu==
# Démarrez Multi Theft Auto: San Andreas en (double-)cliquant sur son icône situé dans le menu '''Démarrer''' ou sur le bureau.
# GTA:San Andreas va alors démarrer. Une fois le chargement effectué, vous allez vous retrouver face à l'interface du menu MTA:SA. Vous avez alors le choix entre plusieurs options:

{| border="0" align="center"
| width="188" |
[[Image:MENU_QuickConnect.jpg]]
| width="380" |
<font size="-1" face="tahoma,helvetica,arial,sans-serif">'''Quick connect''' – Ceci vous permet de vous connecter rapidement à un serveur dont vous connaissez l'IP ainsi que le Port, et, si nécessaire, le Pass (Mot de passe).</font>

<br />
|-
| width="188" |
[[Image:Server_Browser.jpg|280px]]
| width="380" |
<font size="-1" face="tahoma,helvetica,arial,sans-serif">'''Browse servers''' – Ceci vous permet d'afficher la liste des serveurs en ligne.</font>

<br />
|-
| width="188" |
[[Image:Host_Game.jpg|280px]]
| width="380" |
<font size="-1" face="tahoma,helvetica,arial,sans-serif">'''Host game''' – Ceci vous permet de démarrer un serveur local (LAN et/ou Internet).</font>

<br />
|-
| width="188" |
[[Image:Menu_Settings.JPG|280px]]
| width="380" |
<font size="-1" face="tahoma,helvetica,arial,sans-serif">'''Settings '''– Ceci vous permet de changer votre pseudo, les contrôles, les options graphiques, audios, etc.</font>

<br /><br />
|-
| width="188" |
[[Image:About_Menu.jpg|280px]]
| width="380" |
<font size="-1" face="tahoma,helvetica,arial,sans-serif">'''About '''– Ceci vous permet de voir la liste des personnes ayant contribué au projet MTA:SA.</font>

<br />
|-
| width="188" |
[[Image:Map_Editor.jpg|280px]]
| width="380" |
<font size="-1" face="tahoma,helvetica,arial,sans-serif">'''Map editor '''– Ceci vous permet de créer vos propres maps (cartes) complètes. Elles peuvent par la suite être chargées sur un serveur afin d'améliorer l'expérience de jeu.</font>

<br /><br />
|-
| width="188" |
<br>
| width="380" |
<font size="-1" face="tahoma,helvetica,arial,sans-serif">'''Quit '''– Ceci permet de quitter MTA:SA et de revenir à votre précédente application.</font>

<br /><br />
|}

Le moyen le plus simple et rapide de jouer à MTA:SA est d'utiliser '''Browse servers'''. Si les serveurs n’apparaissent pas au bout de quelques secondes d'attente, appuyez sur le bouton '''Refresh''' afin que MTA:SA recharge la liste des serveurs.

* Dans la case '''Name''' apparait le nom du serveur.
* Dans la case '''Players''' apparait le nombre de joueurs connectés actuellement ainsi que le nombre de joueurs maximum, inscrits dans le format de '''[Slots Utilisés] / [Slots Maximum]'''.
* Dans la case '''Ping''' apparait votre ping (ou [http://fr.wikipedia.org/wiki/Lag_%28informatique%29 lag, latence]), entre vous et le serveur. Afin d'obtenir plus d'informations sur les lags, rendez-vous sur le lien situé auparavant.
* Dans la case '''Host''' apparait l'adresse IP du serveur. C'est grâce à celle-ci que vous pourrez, dans le futur, utiliser dans la case '''Quick connect''' du menu principal de MTA:SA afin de vous connecter rapidement à un serveur.

Cache case peut être cliqué afin de les arranger dans l'ordre croissant ou décroissant.

Pour une performance optimale, cherchez le meilleur équilibre entre joueurs et ping.

Une fois que vous avez choisi un serveur, sélectionnez-le en cliquant dessus, puis en cliquant sur le bouton '''Connect''' dans le coin en haut à droite. Si tout se passe bien, vous allez être connecté automatiquement au serveur.

==Comment jouer ?==

MTA:SA offre un système complet de script qui permet aux créateurs de cartes de modifier plusieurs éléments de jeu afin qu'ils puissent créer leurs propres modes de jeu. MTA:SA intègre autant d'éléments que possible qu'en solo, mais certains aspects sont différents.

Il n'y a pas de piétons ou de conducteurs dans les rues. Il n'y a que les joueurs actuellement connecté sur le serveur. Vous pouvez parler aux autres joueurs du serveur (par défaut si le script n'a pas modifié ceci) en appuyant sur la touche '''T''', puis en insérant votre texte. Si le serveur le propose, vous pouvez parler exclusivement à votre équipe en appuyant cette fois sur '''Y'''.

Le créateur de cartes de MTA:SA permet d'ajouter plusieurs objets sur une même carte, d'une route à un casino en passant par une planche à bois, etc. Et ceci peut-être combiné au script afin de faire bouger certains objets via une commande, une touche... Les possibilités sont presque infinies.

Vous pouvez aussi, en appuyant sur la touche '''Tabulation''', afficher le tableau des scores. Par défaut, seuls les pseudos des joueurs ainsi que leur ping s'affichent, mais ceci peut-être modifié via le script. Par exemple, pour un mode de jeu tourné vers le deathmatch (combat à mort en Français), les scripteurs peuvent afficher une colonne référençant le nombre de meurtres et/ou morts. Encore une fois, ici, les possibilités sont presque infinies.

==Contrôles==

===Touches dans le jeu===

* F8 : Affiche la console.
* F9 : Affiche l'aide.
* F11 : Affiche la carte de San Andreas, ainsi que votre position. Les touches suivantes ne fonctionnent que sur cette carte et se situent sur le pavé numérique:
**/ ou - : Zoom avant ou arrière.
**4, 8, 6, 2 : Déplace la carte respectivement vers la gauche, le haut, la droite, le bas.
**0 : Basculer entre attacher la vue sur le joueur (la carte suit l'icône du joueur) et mouvement libre (la carte reste stationnaire).
* F12 : Réaliser une capture d'écran.
* T : Chat général.
* Y : Chat de l'équipe.
* TAB : Liste des joueurs (si le serveur le permet).

==Commandes de la console==

Appuyez sur '''~ (tilde)''' ou '''F8''' pour accéder à la console, tapez ensuite la commande souhaitée avec les paramètres nécessaires (si possible) puis appuyez sur '''Entrée'''.

;'''maps''' :Affiche la liste de toutes les cartes disponibles sur le serveur.

;'''nick [pseudo]''' :Change votre pseudo en jeu par celui que vous avez entré comme paramètre.

;'''msg [pseudo] [message]''' ''ou'' '''pm [pseudo] [message]''' :Envoie un message privé à la personne dont le pseudo est spécifié en paramètre. Seule la personne à laquelle vous avez envoyé le message le verra. '''msg''' et '''pm''' ont la même fonction.

;'''quit''' ''ou'' '''exit''' :Vous déconnecte du serveur tout en vous ramenant vers votre dernière application. Le bouton '''Quit''' du menu principal a la même fonction.

;'''ver''' :Ceci affiche la dernière version et les informations sur le copyright du logiciel.

;'''sver''' :Ceci affiche la version du serveur sur lequel vous êtes actuellement connecté.

;'''time''' :Ceci affiche l'heure actuelle.

;'''disconnect''' :Ceci vous déconnecte du serveur et vous ramène au menu principal.

;'''say [texte]''' :Ceci vous permet de parler aux joueurs du serveur avec la console.

;'''ignore [pseudo]''' :Ceci vous permettra de ne plus voir le texte qu'écrit le joueur dont vous avez entré le pseudo en paramètre. Pour arrêter d'ignorer un joueur, retapez '''ignore [pseudo]'''.

{{Tip|Vous pouvez utiliser ces commandes en ajoutant un / (slash) devant le nom de ces commandes.}}

Vous pouvez retrouver cette liste en jeu en tapant '''help''' dans la console puis en appuyant sur '''Entrée'''. Le serveur sur lequel vous jouez peut aussi avoir des commandes supplémentaires qui peuvent être consultées en tapant '''commands''' dans la console.

==Codes d'erreurs et leurs significations==
'''Erreurs de téléchargement'''<br>
0: UNKNOWN_ERROR<br>
1: INVALID_FILE_DESCRIPTORS<br>
2: INVALID_MAX_FILE_DESCRIPTOR<br>
3: INVALID_SELECT_RETURN<br>
4: INVALID_INITIAL_MULTI_PERFORM<br>
5: INVALID_MULTI_PERFORM_CODE<br>
6: INVALID_MULTI_PERFORM_CODE_NEW_DOWNLOADS<br>
7: UNEXPECTED_CURL_MESSAGE<br>
8: UNABLE_TO_CONNECT<br>
9: UNABLE_TO_DOWNLOAD_FILE<br>
10: FAILED_TO_INITIALIZE_DOWNLOAD<br>

'''Erreurs fatales'''<br>
1: no local player model on ingame event<br>
2: no local player on ingame event<br>
3: server downloads disabled<br>
4: no local player model on player-list packet<br>
5: no local player on player-list packet<br>
6: invalid custom data length on entity-add packet<br>
7: invalid bitstream data on entity-add packet<br>
8: system entity on entity-add packet<br>
9: failed to create object on entity-add packet<br>
10: failed to create pickup on entity-add packet<br>
11: failed to create vehicle on entity-add packet<br>
12: invalid team-name length on entity-add packet<br>
13: invalid lua-event name length in lua-event packet<br>
14: invalid resource name length in resource-start packet<br>

''''Erreurs pour entrer dans un véhicule'''<br>
1: script cancelled<br>
2: script cancelled (jack)<br>
3: current occupier is entering/exiting<br>
4: invalid seat<br>
5: not close enough<br>
6: already in a vehicle<br>
7: already entering/exiting<br>
8: invalid vehicle (trailer)<br>

==Spécial: Jouer à MTA:SA sur Linux ?==
Si vous êtes l'un des joueurs qui ont Linux comme OS, et qui veulent pouvoir jouer à MTA:SA dessus, veuillez lire le [[Manuel_du_Client_sur_Linux|Manuel du Client sur Linux]].

FR/Manuel Client

2014-07-09T20:38:07Z

Citizen: Updated to match english version

__TOC__

==Introduction==
Multi Theft Auto: San Andreas est le dernier mod en série de modifications multijoueurs pour les jeux Grand Theft Auto (sur PC exclusivement). Pour les versions sur GTA III et GTA:VC, s'exécutant tous deux sur l'ancien système, visitez [http://www.multitheftauto.com/ http://www.multitheftauto.com]. Cette modification n'est en aucun cas approuvé et affilié à Rockstar Games ou Take 2 Interactive.

==Avant de commencer==

Avant d'installer Multi Theft Auto: San Andreas, assurez-vous en premier que le jeu GTA:SA est bien installé. Dans le cas échéant, MTA:SA ne pourra démarrer. Si vous voulez garder vos mods spécifiques à la version solo du jeu (ces mods étant généralement interdits sur la plupart des serveurs MTA:SA), réinstallez GTA:SA dans un autre fichier sur votre disque dur.

Assurez-vous aussi d'être sur '''Windows XP''', '''Windows Vista''' (32 bits ou 64 bits), '''Windows 7''' (32 bits ou 64 bits) or '''Windows 8''' (32 bits ou 64 bits) et que vous êtes capable de lancer le jeu solo. Sachez que si vous arrivez à jouer au solo sur un pc dont ses caractéristiques sont vraiment au minimum requis, vous aurez sûrement du mal à faire fonctionner MTA:SA correctement.
{{Note|
* MTA:SA ne fonctionne que sur GTA:SA '''v1.0'''. Si vous venez d'acheter le jeu, il est plus que probable que vous ayez la dernière version.''' [[Known_Issues_-_FAQ#Does_MTASA_work_with_v1.01_or_v2.00_of_GTA_San_Andreas.3F| (Plus d'info)]]
* Si vous avez la version Steam de GTA: San Andreas vous devez [[Known_Issues_-_FAQ#I_have_the_Steam_version_of_GTA_San_Andreas._How_can_I_play_MTASA.3F|lire ceci d'abord]].
}}

===Exigences du système===
Les exigences du système pour faire fonctionner MTA:SA sont à peine plus élevées que celles nécessaires pour GTA:SA.
* Intel Pentium 4 ou AMD Athlon XP.
* 512MB DDR RAM.
* Une installation sans modifications du jeu GTA:SA v1.0 (Américain ou Européen).
* 3.7GB d'espace disponible sur votre disque dur (3.6GB sont minimum pour l'installation de GTA:SA).
* nVidia GeForce 4 series ou ATI Radeon 8xxx series (64MB RAM et DirectX 9.0 compatible).
* DirectX 9.0 carte son compatible.
* Clavier et souris.
* Une connexion internet haut-débit (pour faciliter les chargements).

Pour de meilleurs graphismes, une carte graphique compatible avec Pixel Shader 2.0 (nVidia GeForce FX series ou plus, ATI Radeon 9xxx series ou plus) est recommandée.

Pour une meilleure performance de chargement, une plus grande RAM est recommandée.

==Installer MTA:SA==
# Si ce n'est pas déjà fait, téléchargez MTA:SA depuis la page du site [http://mtasa.com mtasa.com].
# Lancer l'installeur, pour Windows Vista et Windows 7 il faut le lancer en tant qu'administrateur. (L'installeur le demandera.)
# Vous devez accepter la licence de MTA:SA (GPLv3).
# Une page vous permettra de sélectionner les composants désirés:
#* '''Game Client''' s'interface avec le jeu et est nécessaire.
#* '''Dedicated Server''' vous permet de créer votre propre serveur.
#** '''Core components''' et '''Game module''' sont requis par le serveur dédié.
#** '''Core resources''' comprends toutes les ressources requises par le serveur dédié.
#** '''Optional resources''' comprends des ressources additionnels (des gamemodes et des maps).
#** '''Editor''' vous permet de créer des maps (optionnel).
#* '''Development''' comprends des outils de développement.
#** '''Module SDK''' le SDK permettant de créer des modules (connaissances en C++ requises).
#* '''Start menu group''' crée un group dans le menu démarrer pour les composants précédents.
#* '''Desktop icon''' crée un raccourcis sur le bureau pour lancer MTA:SA.
# Ensuite l'istalleur vous demandera dans quel dossier installer MTA:SA. Choisissez l'emplacement que vous voulez, il n'est pas obligatoire de l'installer dans le dossier de GTA San Andreas.
# Ensuite, il vous demandera dans quel dossier ce trouve le dossier de GTA San Andreas. Par défaut il se trouve dans: '''C:\Program Files\Rockstar Games\GTA San Andreas\'''.
# Lorsque l'installation se termine, vous aurez la possibilité de démarrer MTA:SA directement. Cliquez ensuite sur '''Finish'''.
# Plus tard, vous pourrez lancer ''MTA San Andreas'' depuis le menu démarrer.

==Lancer le jeu==
# Démarrez Multi Theft Auto: San Andreas en (double-)cliquant sur son icône situé dans le menu '''Démarrer''' ou sur le bureau.
# GTA:San Andreas va alors démarrer. Une fois le chargement effectué, vous allez vous retrouver face à l'interface du menu MTA:SA. Vous avez alors le choix entre plusieurs options:

{| border="0" align="center"
| width="188" |
[[Image:MENU_QuickConnect.jpg]]
| width="380" |
<font size="-1" face="tahoma,helvetica,arial,sans-serif">'''Quick connect''' – Ceci vous permet de vous connecter rapidement à un serveur dont vous connaissez l'IP ainsi que le Port, et, si nécessaire, le Pass (Mot de passe).</font>

<br />
|-
| width="188" |
[[Image:Server_Browser.jpg|280px]]
| width="380" |
<font size="-1" face="tahoma,helvetica,arial,sans-serif">'''Browse servers''' – Ceci vous permet d'afficher la liste des serveurs en ligne.</font>

<br />
|-
| width="188" |
[[Image:Host_Game.jpg|280px]]
| width="380" |
<font size="-1" face="tahoma,helvetica,arial,sans-serif">'''Host game''' – Ceci vous permet de démarrer un serveur local (LAN et/ou Internet).</font>

<br />
|-
| width="188" |
[[Image:Menu_Settings.JPG|280px]]
| width="380" |
<font size="-1" face="tahoma,helvetica,arial,sans-serif">'''Settings '''– Ceci vous permet de changer votre pseudo, les contrôles, les options graphiques, audios, etc.</font>

<br /><br />
|-
| width="188" |
[[Image:About_Menu.jpg|280px]]
| width="380" |
<font size="-1" face="tahoma,helvetica,arial,sans-serif">'''About '''– Ceci vous permet de voir la liste des personnes ayant contribué au projet MTA:SA.</font>

<br />
|-
| width="188" |
[[Image:Map_Editor.jpg|280px]]
| width="380" |
<font size="-1" face="tahoma,helvetica,arial,sans-serif">'''Map editor '''– Ceci vous permet de créer vos propres maps (cartes) complètes. Elles peuvent par la suite être chargées sur un serveur afin d'améliorer l'expérience de jeu.</font>

<br /><br />
|-
| width="188" |
<br>
| width="380" |
<font size="-1" face="tahoma,helvetica,arial,sans-serif">'''Quit '''– Ceci permet de quitter MTA:SA et de revenir à votre précédente application.</font>

<br /><br />
|}

Le moyen le plus simple et rapide de jouer à MTA:SA est d'utiliser '''Browse servers'''. Si les serveurs n’apparaissent pas au bout de quelques secondes d'attente, appuyez sur le bouton '''Refresh''' afin que MTA:SA recharge la liste des serveurs.

* Dans la case '''Name''' apparait le nom du serveur.
* Dans la case '''Players''' apparait le nombre de joueurs connectés actuellement ainsi que le nombre de joueurs maximum, inscrits dans le format de '''[Slots Utilisés] / [Slots Maximum]'''.
* Dans la case '''Ping''' apparait votre ping (ou [http://fr.wikipedia.org/wiki/Lag_%28informatique%29 lag, latence]), entre vous et le serveur. Afin d'obtenir plus d'informations sur les lags, rendez-vous sur le lien situé auparavant.
* Dans la case '''Host''' apparait l'adresse IP du serveur. C'est grâce à celle-ci que vous pourrez, dans le futur, utiliser dans la case '''Quick connect''' du menu principal de MTA:SA afin de vous connecter rapidement à un serveur.

Cache case peut être cliqué afin de les arranger dans l'ordre croissant ou décroissant.

Pour une performance optimale, cherchez le meilleur équilibre entre joueurs et ping.

Une fois que vous avez choisi un serveur, sélectionnez-le en cliquant dessus, puis en cliquant sur le bouton '''Connect''' dans le coin en haut à droite. Si tout se passe bien, vous allez être connecté automatiquement au serveur.

==Comment jouer ?==

MTA:SA offre un système complet de script qui permet aux créateurs de cartes de modifier plusieurs éléments de jeu afin qu'ils puissent créer leurs propres modes de jeu. MTA:SA intègre autant d'éléments que possible qu'en solo, mais certains aspects sont différents.

Il n'y a pas de piétons ou de conducteurs dans les rues. Il n'y a que les joueurs actuellement connecté sur le serveur. Vous pouvez parler aux autres joueurs du serveur (par défaut si le script n'a pas modifié ceci) en appuyant sur la touche '''T''', puis en insérant votre texte. Si le serveur le propose, vous pouvez parler exclusivement à votre équipe en appuyant cette fois sur '''Y'''.

Le créateur de cartes de MTA:SA permet d'ajouter plusieurs objets sur une même carte, d'une route à un casino en passant par une planche à bois, etc. Et ceci peut-être combiné au script afin de faire bouger certains objets via une commande, une touche... Les possibilités sont presque infinies.

Vous pouvez aussi, en appuyant sur la touche '''Tabulation''', afficher le tableau des scores. Par défaut, seuls les pseudos des joueurs ainsi que leur ping s'affichent, mais ceci peut-être modifié via le script. Par exemple, pour un mode de jeu tourné vers le deathmatch (combat à mort en Français), les scripteurs peuvent afficher une colonne référençant le nombre de meurtres et/ou morts. Encore une fois, ici, les possibilités sont presque infinies.

==Contrôles==

===Touches dans le jeu===

* F8 : Affiche la console.
* F9 : Affiche l'aide.
* F11 : Affiche la carte de San Andreas, ainsi que votre position. Les touches suivantes ne fonctionnent que sur cette carte et se situent sur le pavé numérique:
**/ ou - : Zoom avant ou arrière.
**4, 8, 6, 2 : Déplace la carte respectivement vers la gauche, le haut, la droite, le bas.
**0 : Basculer entre attacher la vue sur le joueur (la carte suit l'icône du joueur) et mouvement libre (la carte reste stationnaire).
* F12 : Réaliser une capture d'écran.
* T : Chat général.
* Y : Chat de l'équipe.
* TAB : Liste des joueurs (si le serveur le permet).

==Commandes de la console==

Appuyez sur '''~ (tilde)''' ou '''F8''' pour accéder à la console, tapez ensuite la commande souhaitée avec les paramètres nécessaires (si possible) puis appuyez sur '''Entrée'''.

;'''maps''' :Affiche la liste de toutes les cartes disponibles sur le serveur.

;'''nick [pseudo]''' :Change votre pseudo en jeu par celui que vous avez entré comme paramètre.

;'''msg [pseudo] [message]''' ''ou'' '''pm [pseudo] [message]''' :Envoie un message privé à la personne dont le pseudo est spécifié en paramètre. Seule la personne à laquelle vous avez envoyé le message le verra. '''msg''' et '''pm''' ont la même fonction.

;'''quit''' ''ou'' '''exit''' :Vous déconnecte du serveur tout en vous ramenant vers votre dernière application. Le bouton '''Quit''' du menu principal a la même fonction.

;'''ver''' :Ceci affiche la dernière version et les informations sur le copyright du logiciel.

;'''sver''' :Ceci affiche la version du serveur sur lequel vous êtes actuellement connecté.

;'''time''' :Ceci affiche l'heure actuelle.

;'''disconnect''' :Ceci vous déconnecte du serveur et vous ramène au menu principal.

;'''say [texte]''' :Ceci vous permet de parler aux joueurs du serveur avec la console.

;'''ignore [pseudo]''' :Ceci vous permettra de ne plus voir le texte qu'écrit le joueur dont vous avez entré le pseudo en paramètre. Pour arrêter d'ignorer un joueur, retapez '''ignore [pseudo]'''.

{{Tip|Vous pouvez utiliser ces commandes en ajoutant un / (slash) devant le nom de ces commandes.}}

Vous pouvez retrouver cette liste en jeu en tapant '''help''' dans la console puis en appuyant sur '''Entrée'''. Le serveur sur lequel vous jouez peut aussi avoir des commandes supplémentaires qui peuvent être consultées en tapant '''commands''' dans la console.

==Codes d'erreurs et leurs significations==
'''Erreurs de téléchargement'''<br>
0: UNKNOWN_ERROR<br>
1: INVALID_FILE_DESCRIPTORS<br>
2: INVALID_MAX_FILE_DESCRIPTOR<br>
3: INVALID_SELECT_RETURN<br>
4: INVALID_INITIAL_MULTI_PERFORM<br>
5: INVALID_MULTI_PERFORM_CODE<br>
6: INVALID_MULTI_PERFORM_CODE_NEW_DOWNLOADS<br>
7: UNEXPECTED_CURL_MESSAGE<br>
8: UNABLE_TO_CONNECT<br>
9: UNABLE_TO_DOWNLOAD_FILE<br>
10: FAILED_TO_INITIALIZE_DOWNLOAD<br>

'''Erreurs fatales'''<br>
1: no local player model on ingame event<br>
2: no local player on ingame event<br>
3: server downloads disabled<br>
4: no local player model on player-list packet<br>
5: no local player on player-list packet<br>
6: invalid custom data length on entity-add packet<br>
7: invalid bitstream data on entity-add packet<br>
8: system entity on entity-add packet<br>
9: failed to create object on entity-add packet<br>
10: failed to create pickup on entity-add packet<br>
11: failed to create vehicle on entity-add packet<br>
12: invalid team-name length on entity-add packet<br>
13: invalid lua-event name length in lua-event packet<br>
14: invalid resource name length in resource-start packet<br>

''''Erreurs pour entrer dans un véhicule'''<br>
1: script cancelled<br>
2: script cancelled (jack)<br>
3: current occupier is entering/exiting<br>
4: invalid seat<br>
5: not close enough<br>
6: already in a vehicle<br>
7: already entering/exiting<br>
8: invalid vehicle (trailer)<br>

==Spécial: Jouer à MTA:SA sur Linux ?==
Si vous êtes l'un des joueurs qui ont Linux comme OS, et qui veulent pouvoir jouer à MTA:SA dessus, veuillez lire le [[Manuel_du_Client_sur_Linux|Manuel du Client sur Linux]].

FR/Manuel Client

2014-07-09T20:36:45Z

Citizen: /* Commandes de la console */

__TOC__

==Introduction==
Multi Theft Auto: San Andreas est le dernier mod en série de modifications multijoueurs pour les jeux Grand Theft Auto (sur PC exclusivement). Pour les versions sur GTA III et GTA:VC, s'exécutant tous deux sur l'ancien système, visitez [http://www.multitheftauto.com/ http://www.multitheftauto.com]. Cette modification n'est en aucun cas approuvé et affilié à Rockstar Games ou Take 2 Interactive.

==Avant de commencer==

Avant d'installer Multi Theft Auto: San Andreas, assurez-vous en premier que le jeu GTA:SA est bien installé. Dans le cas échéant, MTA:SA ne pourra démarrer. Si vous voulez garder vos mods spécifiques à la version solo du jeu (ces mods étant généralement interdits sur la plupart des serveurs MTA:SA), réinstallez GTA:SA dans un autre fichier sur votre disque dur.

Assurez-vous aussi d'être sur '''Windows XP''', '''Windows Vista''' (32 bits ou 64 bits), '''Windows 7''' (32 bits ou 64 bits) or '''Windows 8''' (32 bits ou 64 bits) et que vous êtes capable de lancer le jeu solo. Sachez que si vous arrivez à jouer au solo sur un pc dont ses caractéristiques sont vraiment au minimum requis, vous aurez sûrement du mal à faire fonctionner MTA:SA correctement.
{{Note|
* MTA:SA ne fonctionne que sur GTA:SA '''v1.0'''. Si vous venez d'acheter le jeu, il est plus que probable que vous ayez la dernière version.''' [[Known_Issues_-_FAQ#Does_MTASA_work_with_v1.01_or_v2.00_of_GTA_San_Andreas.3F| (Plus d'info)]]
* Si vous avez la version Steam de GTA: San Andreas vous devez [[Known_Issues_-_FAQ#I_have_the_Steam_version_of_GTA_San_Andreas._How_can_I_play_MTASA.3F|lire ceci d'abord]].
}}

===Exigences du système===
Les exigences du système pour faire fonctionner MTA:SA sont à peine plus élevées que celles nécessaires pour GTA:SA.
* Intel Pentium 4 ou AMD Athlon XP.
* 512MB DDR RAM.
* Une installation sans modifications du jeu GTA:SA v1.0 (Américain ou Européen).
* 3.7GB d'espace disponible sur votre disque dur (3.6GB sont minimum pour l'installation de GTA:SA).
* nVidia GeForce 4 series ou ATI Radeon 8xxx series (64MB RAM et DirectX 9.0 compatible).
* DirectX 9.0 carte son compatible.
* Clavier et souris.
* Une connexion internet haut-débit (pour faciliter les chargements).

Pour de meilleurs graphismes, une carte graphique compatible avec Pixel Shader 2.0 (nVidia GeForce FX series ou plus, ATI Radeon 9xxx series ou plus) est recommandée.

Pour une meilleure performance de chargement, une plus grande RAM est recommandée.

==Installer MTA:SA==
# Si ce n'est pas déjà fait, téléchargez MTA:SA depuis la page du site [http://mtasa.com mtasa.com].
# Lancer l'installeur, pour Windows Vista et Windows 7 il faut le lancer en tant qu'administrateur. (L'installeur le demandera.)
# Vous devez accepter la licence de MTA:SA (GPLv3).
# Une page vous permettra de sélectionner les composants désirés:
#* '''Game Client''' s'interface avec le jeu et est nécessaire.
#* '''Dedicated Server''' vous permet de créer votre propre serveur.
#** '''Core components''' et '''Game module''' sont requis par le serveur dédié.
#** '''Core resources''' comprends toutes les ressources requises par le serveur dédié.
#** '''Optional resources''' comprends des ressources additionnels (des gamemodes et des maps).
#** '''Editor''' vous permet de créer des maps (optionnel).
#* '''Development''' comprends des outils de développement.
#** '''Module SDK''' le SDK permettant de créer des modules (connaissances en C++ requises).
#* '''Start menu group''' crée un group dans le menu démarrer pour les composants précédents.
#* '''Desktop icon''' crée un raccourcis sur le bureau pour lancer MTA:SA.
# Ensuite l'istalleur vous demandera dans quel dossier installer MTA:SA. Choisissez l'emplacement que vous voulez, il n'est pas obligatoire de l'installer dans le dossier de GTA San Andreas.
# Ensuite, il vous demandera dans quel dossier ce trouve le dossier de GTA San Andreas. Par défaut il se trouve dans: '''C:\Program Files\Rockstar Games\GTA San Andreas\'''.
# Lorsque l'installation se termine, vous aurez la possibilité de démarrer MTA:SA directement. Cliquez ensuite sur '''Finish'''.
# Plus tard, vous pourrez lancer ''MTA San Andreas'' depuis le menu démarrer.

==Lancer le jeu==
# Démarrez Multi Theft Auto: San Andreas en (double-)cliquant sur son icône situé dans le menu '''Démarrer''' ou sur le bureau.
# GTA:San Andreas va alors démarrer. Une fois le chargement effectué, vous allez vous retrouver face à l'interface du menu MTA:SA. Vous avez alors le choix entre plusieurs options:

{| border="0" align="center"
| width="188" |
[[Image:MENU_QuickConnect.jpg]]
| width="380" |
<font size="-1" face="tahoma,helvetica,arial,sans-serif">'''Quick connect''' – Ceci vous permet de vous connecter rapidement à un serveur dont vous connaissez l'IP ainsi que le Port, et, si nécessaire, le Pass (Mot de passe).</font>

<br />
|-
| width="188" |
[[Image:Server_Browser.jpg|280px]]
| width="380" |
<font size="-1" face="tahoma,helvetica,arial,sans-serif">'''Browse servers''' – Ceci vous permet d'afficher la liste des serveurs en ligne.</font>

<br />
|-
| width="188" |
[[Image:Host_Game.jpg|280px]]
| width="380" |
<font size="-1" face="tahoma,helvetica,arial,sans-serif">'''Host game''' – Ceci vous permet de démarrer un serveur local (LAN et/ou Internet).</font>

<br />
|-
| width="188" |
[[Image:Menu_Settings.JPG|280px]]
| width="380" |
<font size="-1" face="tahoma,helvetica,arial,sans-serif">'''Settings '''– Ceci vous permet de changer votre pseudo, les contrôles, les options graphiques, audios, etc.</font>

<br /><br />
|-
| width="188" |
[[Image:About_Menu.jpg|280px]]
| width="380" |
<font size="-1" face="tahoma,helvetica,arial,sans-serif">'''About '''– Ceci vous permet de voir la liste des personnes ayant contribué au projet MTA:SA.</font>

<br />
|-
| width="188" |
[[Image:Map_Editor.jpg|280px]]
| width="380" |
<font size="-1" face="tahoma,helvetica,arial,sans-serif">'''Map editor '''– Ceci vous permet de créer vos propres maps (cartes) complètes. Elles peuvent par la suite être chargées sur un serveur afin d'améliorer l'expérience de jeu.</font>

<br /><br />
|-
| width="188" |
<br>
| width="380" |
<font size="-1" face="tahoma,helvetica,arial,sans-serif">'''Quit '''– Ceci permet de quitter MTA:SA et de revenir à votre précédente application.</font>

<br /><br />
|}

Le moyen le plus simple et rapide de jouer à MTA:SA est d'utiliser '''Browse servers'''. Si les serveurs n’apparaissent pas au bout de quelques secondes d'attente, appuyez sur le bouton '''Refresh''' afin que MTA:SA recharge la liste des serveurs.

* Dans la case '''Name''' apparait le nom du serveur.
* Dans la case '''Players''' apparait le nombre de joueurs connectés actuellement ainsi que le nombre de joueurs maximum, inscrits dans le format de '''[Slots Utilisés] / [Slots Maximum]'''.
* Dans la case '''Ping''' apparait votre ping (ou [http://fr.wikipedia.org/wiki/Lag_%28informatique%29 lag, latence]), entre vous et le serveur. Afin d'obtenir plus d'informations sur les lags, rendez-vous sur le lien situé auparavant.
* Dans la case '''Host''' apparait l'adresse IP du serveur. C'est grâce à celle-ci que vous pourrez, dans le futur, utiliser dans la case '''Quick connect''' du menu principal de MTA:SA afin de vous connecter rapidement à un serveur.

Cache case peut être cliqué afin de les arranger dans l'ordre croissant ou décroissant.

Pour une performance optimale, cherchez le meilleur équilibre entre joueurs et ping.

Une fois que vous avez choisi un serveur, sélectionnez-le en cliquant dessus, puis en cliquant sur le bouton '''Connect''' dans le coin en haut à droite. Si tout se passe bien, vous allez être connecté automatiquement au serveur.

==Comment jouer ?==

MTA:SA offre un système complet de script qui permet aux créateurs de cartes de modifier plusieurs éléments de jeu afin qu'ils puissent créer leurs propres modes de jeu. MTA:SA intègre autant d'éléments que possible qu'en solo, mais certains aspects sont différents.

Il n'y a pas de piétons ou de conducteurs dans les rues. Il n'y a que les joueurs actuellement connecté sur le serveur. Vous pouvez parler aux autres joueurs du serveur (par défaut si le script n'a pas modifié ceci) en appuyant sur la touche '''T''', puis en insérant votre texte. Si le serveur le propose, vous pouvez parler exclusivement à votre équipe en appuyant cette fois sur '''Y'''.

Le créateur de cartes de MTA:SA permet d'ajouter plusieurs objets sur une même carte, d'une route à un casino en passant par une planche à bois, etc. Et ceci peut-être combiné au script afin de faire bouger certains objets via une commande, une touche... Les possibilités sont presque infinies.

Vous pouvez aussi, en appuyant sur la touche '''Tabulation''', afficher le tableau des scores. Par défaut, seuls les pseudos des joueurs ainsi que leur ping s'affichent, mais ceci peut-être modifié via le script. Par exemple, pour un mode de jeu tourné vers le deathmatch (combat à mort en Français), les scripteurs peuvent afficher une colonne référençant le nombre de meurtres et/ou morts. Encore une fois, ici, les possibilités sont presque infinies.

==Contrôles==

===Touches dans le jeu===

* F8 : Affiche la console.
* F9 : Affiche l'aide.
* F11 : Affiche la carte de San Andreas, ainsi que votre position. Les touches suivantes ne fonctionnent que sur cette carte et se situent sur le pavé numérique:
**/ ou - : Zoom avant ou arrière.
**4, 8, 6, 2 : Déplace la carte respectivement vers la gauche, le haut, la droite, le bas.
**0 : Basculer entre attacher la vue sur le joueur (la carte suit l'icône du joueur) et mouvement libre (la carte reste stationnaire).
* F12 : Réaliser une capture d'écran.
* T : Chat général.
* Y : Chat de l'équipe.
* TAB : Liste des joueurs (si le serveur le permet).

==Commandes de la console==

Appuyez sur '''~ (tilde)''' ou '''F8''' pour accéder à la console, tapez ensuite la commande souhaitée avec les paramètres nécessaires (si possible) puis appuyez sur '''Entrée'''.

;'''maps''' :Affiche la liste de toutes les cartes disponibles sur le serveur.

;'''nick [pseudo]''' :Change votre pseudo en jeu par celui que vous avez entré comme paramètre.

;'''msg [pseudo] [message]''' ''ou'' '''pm [pseudo] [message]''' :Envoie un message privé à la personne dont le pseudo est spécifié en paramètre. Seule la personne à laquelle vous avez envoyé le message le verra. '''msg''' et '''pm''' ont la même fonction.

;'''quit''' ''ou'' '''exit''' :Vous déconnecte du serveur tout en vous ramenant vers votre dernière application. Le bouton '''Quit''' du menu principal a la même fonction.

;'''ver''' :Ceci affiche la dernière version et les informations sur le copyright du logiciel.

;'''sver''' :Ceci affiche la version du serveur sur lequel vous êtes actuellement connecté.

;'''time''' :Ceci affiche l'heure actuelle.

;'''disconnect''' :Ceci vous déconnecte du serveur et vous ramène au menu principal.

;'''say [texte]''' :Ceci vous permet de parler aux joueurs du serveur avec la console.

;'''ignore [pseudo]''' :Ceci vous permettra de ne plus voir le texte qu'écrit le joueur dont vous avez entré le pseudo en paramètre. Pour arrêter d'ignorer un joueur, retapez '''ignore [pseudo]'''.

{{Tip|Vous pouvez utiliser ces commandes en ajoutant un / (slash) devant le nom de ces commandes.}}

'''Astuce:''' Vous pouvez utiliser ces commandes dans la chatbox du serveur en insérant un '''"/"''' (slash) en face d'elles.

Vous pouvez retrouver cette liste en jeu en tapant '''help''' dans la console puis en appuyant sur '''Entrée'''. Le serveur sur lequel vous jouez peut aussi avoir des commandes supplémentaires qui peuvent être consultées en tapant '''commands''' dans la console.

==Codes d'erreurs et leurs significations==
'''Erreurs de téléchargement'''<br>
0: UNKNOWN_ERROR<br>
1: INVALID_FILE_DESCRIPTORS<br>
2: INVALID_MAX_FILE_DESCRIPTOR<br>
3: INVALID_SELECT_RETURN<br>
4: INVALID_INITIAL_MULTI_PERFORM<br>
5: INVALID_MULTI_PERFORM_CODE<br>
6: INVALID_MULTI_PERFORM_CODE_NEW_DOWNLOADS<br>
7: UNEXPECTED_CURL_MESSAGE<br>
8: UNABLE_TO_CONNECT<br>
9: UNABLE_TO_DOWNLOAD_FILE<br>
10: FAILED_TO_INITIALIZE_DOWNLOAD<br>

'''Erreurs fatales'''<br>
1: no local player model on ingame event<br>
2: no local player on ingame event<br>
3: server downloads disabled<br>
4: no local player model on player-list packet<br>
5: no local player on player-list packet<br>
6: invalid custom data length on entity-add packet<br>
7: invalid bitstream data on entity-add packet<br>
8: system entity on entity-add packet<br>
9: failed to create object on entity-add packet<br>
10: failed to create pickup on entity-add packet<br>
11: failed to create vehicle on entity-add packet<br>
12: invalid team-name length on entity-add packet<br>
13: invalid lua-event name length in lua-event packet<br>
14: invalid resource name length in resource-start packet<br>

''''Erreurs pour entrer dans un véhicule'''<br>
1: script cancelled<br>
2: script cancelled (jack)<br>
3: current occupier is entering/exiting<br>
4: invalid seat<br>
5: not close enough<br>
6: already in a vehicle<br>
7: already entering/exiting<br>
8: invalid vehicle (trailer)<br>

==Spécial: Jouer à MTA:SA sur Linux ?==
Si vous êtes l'un des joueurs qui ont Linux comme OS, et qui veulent pouvoir jouer à MTA:SA dessus, veuillez lire le [[Manuel_du_Client_sur_Linux|Manuel du Client sur Linux]].

FR/Manuel Client

2014-07-09T20:35:16Z

Citizen: /* Commandes de la console */

__TOC__

==Introduction==
Multi Theft Auto: San Andreas est le dernier mod en série de modifications multijoueurs pour les jeux Grand Theft Auto (sur PC exclusivement). Pour les versions sur GTA III et GTA:VC, s'exécutant tous deux sur l'ancien système, visitez [http://www.multitheftauto.com/ http://www.multitheftauto.com]. Cette modification n'est en aucun cas approuvé et affilié à Rockstar Games ou Take 2 Interactive.

==Avant de commencer==

Avant d'installer Multi Theft Auto: San Andreas, assurez-vous en premier que le jeu GTA:SA est bien installé. Dans le cas échéant, MTA:SA ne pourra démarrer. Si vous voulez garder vos mods spécifiques à la version solo du jeu (ces mods étant généralement interdits sur la plupart des serveurs MTA:SA), réinstallez GTA:SA dans un autre fichier sur votre disque dur.

Assurez-vous aussi d'être sur '''Windows XP''', '''Windows Vista''' (32 bits ou 64 bits), '''Windows 7''' (32 bits ou 64 bits) or '''Windows 8''' (32 bits ou 64 bits) et que vous êtes capable de lancer le jeu solo. Sachez que si vous arrivez à jouer au solo sur un pc dont ses caractéristiques sont vraiment au minimum requis, vous aurez sûrement du mal à faire fonctionner MTA:SA correctement.
{{Note|
* MTA:SA ne fonctionne que sur GTA:SA '''v1.0'''. Si vous venez d'acheter le jeu, il est plus que probable que vous ayez la dernière version.''' [[Known_Issues_-_FAQ#Does_MTASA_work_with_v1.01_or_v2.00_of_GTA_San_Andreas.3F| (Plus d'info)]]
* Si vous avez la version Steam de GTA: San Andreas vous devez [[Known_Issues_-_FAQ#I_have_the_Steam_version_of_GTA_San_Andreas._How_can_I_play_MTASA.3F|lire ceci d'abord]].
}}

===Exigences du système===
Les exigences du système pour faire fonctionner MTA:SA sont à peine plus élevées que celles nécessaires pour GTA:SA.
* Intel Pentium 4 ou AMD Athlon XP.
* 512MB DDR RAM.
* Une installation sans modifications du jeu GTA:SA v1.0 (Américain ou Européen).
* 3.7GB d'espace disponible sur votre disque dur (3.6GB sont minimum pour l'installation de GTA:SA).
* nVidia GeForce 4 series ou ATI Radeon 8xxx series (64MB RAM et DirectX 9.0 compatible).
* DirectX 9.0 carte son compatible.
* Clavier et souris.
* Une connexion internet haut-débit (pour faciliter les chargements).

Pour de meilleurs graphismes, une carte graphique compatible avec Pixel Shader 2.0 (nVidia GeForce FX series ou plus, ATI Radeon 9xxx series ou plus) est recommandée.

Pour une meilleure performance de chargement, une plus grande RAM est recommandée.

==Installer MTA:SA==
# Si ce n'est pas déjà fait, téléchargez MTA:SA depuis la page du site [http://mtasa.com mtasa.com].
# Lancer l'installeur, pour Windows Vista et Windows 7 il faut le lancer en tant qu'administrateur. (L'installeur le demandera.)
# Vous devez accepter la licence de MTA:SA (GPLv3).
# Une page vous permettra de sélectionner les composants désirés:
#* '''Game Client''' s'interface avec le jeu et est nécessaire.
#* '''Dedicated Server''' vous permet de créer votre propre serveur.
#** '''Core components''' et '''Game module''' sont requis par le serveur dédié.
#** '''Core resources''' comprends toutes les ressources requises par le serveur dédié.
#** '''Optional resources''' comprends des ressources additionnels (des gamemodes et des maps).
#** '''Editor''' vous permet de créer des maps (optionnel).
#* '''Development''' comprends des outils de développement.
#** '''Module SDK''' le SDK permettant de créer des modules (connaissances en C++ requises).
#* '''Start menu group''' crée un group dans le menu démarrer pour les composants précédents.
#* '''Desktop icon''' crée un raccourcis sur le bureau pour lancer MTA:SA.
# Ensuite l'istalleur vous demandera dans quel dossier installer MTA:SA. Choisissez l'emplacement que vous voulez, il n'est pas obligatoire de l'installer dans le dossier de GTA San Andreas.
# Ensuite, il vous demandera dans quel dossier ce trouve le dossier de GTA San Andreas. Par défaut il se trouve dans: '''C:\Program Files\Rockstar Games\GTA San Andreas\'''.
# Lorsque l'installation se termine, vous aurez la possibilité de démarrer MTA:SA directement. Cliquez ensuite sur '''Finish'''.
# Plus tard, vous pourrez lancer ''MTA San Andreas'' depuis le menu démarrer.

==Lancer le jeu==
# Démarrez Multi Theft Auto: San Andreas en (double-)cliquant sur son icône situé dans le menu '''Démarrer''' ou sur le bureau.
# GTA:San Andreas va alors démarrer. Une fois le chargement effectué, vous allez vous retrouver face à l'interface du menu MTA:SA. Vous avez alors le choix entre plusieurs options:

{| border="0" align="center"
| width="188" |
[[Image:MENU_QuickConnect.jpg]]
| width="380" |
<font size="-1" face="tahoma,helvetica,arial,sans-serif">'''Quick connect''' – Ceci vous permet de vous connecter rapidement à un serveur dont vous connaissez l'IP ainsi que le Port, et, si nécessaire, le Pass (Mot de passe).</font>

<br />
|-
| width="188" |
[[Image:Server_Browser.jpg|280px]]
| width="380" |
<font size="-1" face="tahoma,helvetica,arial,sans-serif">'''Browse servers''' – Ceci vous permet d'afficher la liste des serveurs en ligne.</font>

<br />
|-
| width="188" |
[[Image:Host_Game.jpg|280px]]
| width="380" |
<font size="-1" face="tahoma,helvetica,arial,sans-serif">'''Host game''' – Ceci vous permet de démarrer un serveur local (LAN et/ou Internet).</font>

<br />
|-
| width="188" |
[[Image:Menu_Settings.JPG|280px]]
| width="380" |
<font size="-1" face="tahoma,helvetica,arial,sans-serif">'''Settings '''– Ceci vous permet de changer votre pseudo, les contrôles, les options graphiques, audios, etc.</font>

<br /><br />
|-
| width="188" |
[[Image:About_Menu.jpg|280px]]
| width="380" |
<font size="-1" face="tahoma,helvetica,arial,sans-serif">'''About '''– Ceci vous permet de voir la liste des personnes ayant contribué au projet MTA:SA.</font>

<br />
|-
| width="188" |
[[Image:Map_Editor.jpg|280px]]
| width="380" |
<font size="-1" face="tahoma,helvetica,arial,sans-serif">'''Map editor '''– Ceci vous permet de créer vos propres maps (cartes) complètes. Elles peuvent par la suite être chargées sur un serveur afin d'améliorer l'expérience de jeu.</font>

<br /><br />
|-
| width="188" |
<br>
| width="380" |
<font size="-1" face="tahoma,helvetica,arial,sans-serif">'''Quit '''– Ceci permet de quitter MTA:SA et de revenir à votre précédente application.</font>

<br /><br />
|}

Le moyen le plus simple et rapide de jouer à MTA:SA est d'utiliser '''Browse servers'''. Si les serveurs n’apparaissent pas au bout de quelques secondes d'attente, appuyez sur le bouton '''Refresh''' afin que MTA:SA recharge la liste des serveurs.

* Dans la case '''Name''' apparait le nom du serveur.
* Dans la case '''Players''' apparait le nombre de joueurs connectés actuellement ainsi que le nombre de joueurs maximum, inscrits dans le format de '''[Slots Utilisés] / [Slots Maximum]'''.
* Dans la case '''Ping''' apparait votre ping (ou [http://fr.wikipedia.org/wiki/Lag_%28informatique%29 lag, latence]), entre vous et le serveur. Afin d'obtenir plus d'informations sur les lags, rendez-vous sur le lien situé auparavant.
* Dans la case '''Host''' apparait l'adresse IP du serveur. C'est grâce à celle-ci que vous pourrez, dans le futur, utiliser dans la case '''Quick connect''' du menu principal de MTA:SA afin de vous connecter rapidement à un serveur.

Cache case peut être cliqué afin de les arranger dans l'ordre croissant ou décroissant.

Pour une performance optimale, cherchez le meilleur équilibre entre joueurs et ping.

Une fois que vous avez choisi un serveur, sélectionnez-le en cliquant dessus, puis en cliquant sur le bouton '''Connect''' dans le coin en haut à droite. Si tout se passe bien, vous allez être connecté automatiquement au serveur.

==Comment jouer ?==

MTA:SA offre un système complet de script qui permet aux créateurs de cartes de modifier plusieurs éléments de jeu afin qu'ils puissent créer leurs propres modes de jeu. MTA:SA intègre autant d'éléments que possible qu'en solo, mais certains aspects sont différents.

Il n'y a pas de piétons ou de conducteurs dans les rues. Il n'y a que les joueurs actuellement connecté sur le serveur. Vous pouvez parler aux autres joueurs du serveur (par défaut si le script n'a pas modifié ceci) en appuyant sur la touche '''T''', puis en insérant votre texte. Si le serveur le propose, vous pouvez parler exclusivement à votre équipe en appuyant cette fois sur '''Y'''.

Le créateur de cartes de MTA:SA permet d'ajouter plusieurs objets sur une même carte, d'une route à un casino en passant par une planche à bois, etc. Et ceci peut-être combiné au script afin de faire bouger certains objets via une commande, une touche... Les possibilités sont presque infinies.

Vous pouvez aussi, en appuyant sur la touche '''Tabulation''', afficher le tableau des scores. Par défaut, seuls les pseudos des joueurs ainsi que leur ping s'affichent, mais ceci peut-être modifié via le script. Par exemple, pour un mode de jeu tourné vers le deathmatch (combat à mort en Français), les scripteurs peuvent afficher une colonne référençant le nombre de meurtres et/ou morts. Encore une fois, ici, les possibilités sont presque infinies.

==Contrôles==

===Touches dans le jeu===

* F8 : Affiche la console.
* F9 : Affiche l'aide.
* F11 : Affiche la carte de San Andreas, ainsi que votre position. Les touches suivantes ne fonctionnent que sur cette carte et se situent sur le pavé numérique:
**/ ou - : Zoom avant ou arrière.
**4, 8, 6, 2 : Déplace la carte respectivement vers la gauche, le haut, la droite, le bas.
**0 : Basculer entre attacher la vue sur le joueur (la carte suit l'icône du joueur) et mouvement libre (la carte reste stationnaire).
* F12 : Réaliser une capture d'écran.
* T : Chat général.
* Y : Chat de l'équipe.
* TAB : Liste des joueurs (si le serveur le permet).

==Commandes de la console==

Appuyez sur '''~ (tilde)''' ou '''F8''' pour accéder à la console, tapez ensuite la commande souhaitée avec les paramètres nécessaires (si possible) puis appuyez sur '''Entrée'''.

;'''maps''' :Affiche la liste de toutes les cartes disponibles sur le serveur.

;'''nick [pseudo]''' :Change votre pseudo en jeu par celui que vous avez entré comme paramètre.

;'''msg [pseudo] [message]''' ''ou'' '''pm [pseudo] [message]''' :Envoie un message privé à la personne dont le pseudo est spécifié en paramètre. Seule la personne à laquelle vous avez envoyé le message le verra. '''msg''' et '''pm''' ont la même fonction.

;'''quit''' ''ou'' '''exit''' :Vous déconnecte du serveur tout en vous ramenant vers votre dernière application. Le bouton '''Quit''' du menu principal a la même fonction.

;'''ver''' :Ceci affiche la dernière version et les informations sur le copyright du logiciel.

;'''sver''' :Ceci affiche la version du serveur sur lequel vous êtes actuellement connecté.

;'''time''' :Ceci affiche l'heure actuelle.

;'''disconnect''' :Ceci vous déconnecte du serveur et vous ramène au menu principal.

;'''say [texte]''' :Ceci vous permet de parler aux joueurs du serveur avec la console.

;'''ignore [pseudo]''' :Ceci vous permettra de ne plus voir le texte qu'écrit le joueur dont vous avez entré le pseudo en paramètre. Pour arrêter d'ignorer un joueur, retapez '''ignore [pseudo]'''.
{{Tip|You can use these commands in the chatbox by putting a / (forward slash) in front of them.}}

'''Astuce:''' Vous pouvez utiliser ces commandes dans la chatbox du serveur en insérant un '''"/"''' (slash) en face d'elles.

Vous pouvez retrouver cette liste en jeu en tapant '''help''' dans la console puis en appuyant sur '''Entrée'''. Le serveur sur lequel vous jouez peut aussi avoir des commandes supplémentaires qui peuvent être consultées en tapant '''commands''' dans la console.

==Codes d'erreurs et leurs significations==
'''Erreurs de téléchargement'''<br>
0: UNKNOWN_ERROR<br>
1: INVALID_FILE_DESCRIPTORS<br>
2: INVALID_MAX_FILE_DESCRIPTOR<br>
3: INVALID_SELECT_RETURN<br>
4: INVALID_INITIAL_MULTI_PERFORM<br>
5: INVALID_MULTI_PERFORM_CODE<br>
6: INVALID_MULTI_PERFORM_CODE_NEW_DOWNLOADS<br>
7: UNEXPECTED_CURL_MESSAGE<br>
8: UNABLE_TO_CONNECT<br>
9: UNABLE_TO_DOWNLOAD_FILE<br>
10: FAILED_TO_INITIALIZE_DOWNLOAD<br>

'''Erreurs fatales'''<br>
1: no local player model on ingame event<br>
2: no local player on ingame event<br>
3: server downloads disabled<br>
4: no local player model on player-list packet<br>
5: no local player on player-list packet<br>
6: invalid custom data length on entity-add packet<br>
7: invalid bitstream data on entity-add packet<br>
8: system entity on entity-add packet<br>
9: failed to create object on entity-add packet<br>
10: failed to create pickup on entity-add packet<br>
11: failed to create vehicle on entity-add packet<br>
12: invalid team-name length on entity-add packet<br>
13: invalid lua-event name length in lua-event packet<br>
14: invalid resource name length in resource-start packet<br>

''''Erreurs pour entrer dans un véhicule'''<br>
1: script cancelled<br>
2: script cancelled (jack)<br>
3: current occupier is entering/exiting<br>
4: invalid seat<br>
5: not close enough<br>
6: already in a vehicle<br>
7: already entering/exiting<br>
8: invalid vehicle (trailer)<br>

==Spécial: Jouer à MTA:SA sur Linux ?==
Si vous êtes l'un des joueurs qui ont Linux comme OS, et qui veulent pouvoir jouer à MTA:SA dessus, veuillez lire le [[Manuel_du_Client_sur_Linux|Manuel du Client sur Linux]].

FR/Manuel Client

2014-07-09T20:29:00Z

Citizen: Updated to match english version

__TOC__

==Introduction==
Multi Theft Auto: San Andreas est le dernier mod en série de modifications multijoueurs pour les jeux Grand Theft Auto (sur PC exclusivement). Pour les versions sur GTA III et GTA:VC, s'exécutant tous deux sur l'ancien système, visitez [http://www.multitheftauto.com/ http://www.multitheftauto.com]. Cette modification n'est en aucun cas approuvé et affilié à Rockstar Games ou Take 2 Interactive.

==Avant de commencer==

Avant d'installer Multi Theft Auto: San Andreas, assurez-vous en premier que le jeu GTA:SA est bien installé. Dans le cas échéant, MTA:SA ne pourra démarrer. Si vous voulez garder vos mods spécifiques à la version solo du jeu (ces mods étant généralement interdits sur la plupart des serveurs MTA:SA), réinstallez GTA:SA dans un autre fichier sur votre disque dur.

Assurez-vous aussi d'être sur '''Windows XP''', '''Windows Vista''' (32 bits ou 64 bits), '''Windows 7''' (32 bits ou 64 bits) or '''Windows 8''' (32 bits ou 64 bits) et que vous êtes capable de lancer le jeu solo. Sachez que si vous arrivez à jouer au solo sur un pc dont ses caractéristiques sont vraiment au minimum requis, vous aurez sûrement du mal à faire fonctionner MTA:SA correctement.
{{Note|
* MTA:SA ne fonctionne que sur GTA:SA '''v1.0'''. Si vous venez d'acheter le jeu, il est plus que probable que vous ayez la dernière version.''' [[Known_Issues_-_FAQ#Does_MTASA_work_with_v1.01_or_v2.00_of_GTA_San_Andreas.3F| (Plus d'info)]]
* Si vous avez la version Steam de GTA: San Andreas vous devez [[Known_Issues_-_FAQ#I_have_the_Steam_version_of_GTA_San_Andreas._How_can_I_play_MTASA.3F|lire ceci d'abord]].
}}

===Exigences du système===
Les exigences du système pour faire fonctionner MTA:SA sont à peine plus élevées que celles nécessaires pour GTA:SA.
* Intel Pentium 4 ou AMD Athlon XP.
* 512MB DDR RAM.
* Une installation sans modifications du jeu GTA:SA v1.0 (Américain ou Européen).
* 3.7GB d'espace disponible sur votre disque dur (3.6GB sont minimum pour l'installation de GTA:SA).
* nVidia GeForce 4 series ou ATI Radeon 8xxx series (64MB RAM et DirectX 9.0 compatible).
* DirectX 9.0 carte son compatible.
* Clavier et souris.
* Une connexion internet haut-débit (pour faciliter les chargements).

Pour de meilleurs graphismes, une carte graphique compatible avec Pixel Shader 2.0 (nVidia GeForce FX series ou plus, ATI Radeon 9xxx series ou plus) est recommandée.

Pour une meilleure performance de chargement, une plus grande RAM est recommandée.

==Installer MTA:SA==
# Si ce n'est pas déjà fait, téléchargez MTA:SA depuis la page du site [http://mtasa.com mtasa.com].
# Lancer l'installeur, pour Windows Vista et Windows 7 il faut le lancer en tant qu'administrateur. (L'installeur le demandera.)
# Vous devez accepter la licence de MTA:SA (GPLv3).
# Une page vous permettra de sélectionner les composants désirés:
#* '''Game Client''' s'interface avec le jeu et est nécessaire.
#* '''Dedicated Server''' vous permet de créer votre propre serveur.
#** '''Core components''' et '''Game module''' sont requis par le serveur dédié.
#** '''Core resources''' comprends toutes les ressources requises par le serveur dédié.
#** '''Optional resources''' comprends des ressources additionnels (des gamemodes et des maps).
#** '''Editor''' vous permet de créer des maps (optionnel).
#* '''Development''' comprends des outils de développement.
#** '''Module SDK''' le SDK permettant de créer des modules (connaissances en C++ requises).
#* '''Start menu group''' crée un group dans le menu démarrer pour les composants précédents.
#* '''Desktop icon''' crée un raccourcis sur le bureau pour lancer MTA:SA.
# Ensuite l'istalleur vous demandera dans quel dossier installer MTA:SA. Choisissez l'emplacement que vous voulez, il n'est pas obligatoire de l'installer dans le dossier de GTA San Andreas.
# Ensuite, il vous demandera dans quel dossier ce trouve le dossier de GTA San Andreas. Par défaut il se trouve dans: '''C:\Program Files\Rockstar Games\GTA San Andreas\'''.
# Lorsque l'installation se termine, vous aurez la possibilité de démarrer MTA:SA directement. Cliquez ensuite sur '''Finish'''.
# Plus tard, vous pourrez lancer ''MTA San Andreas'' depuis le menu démarrer.

==Lancer le jeu==
# Démarrez Multi Theft Auto: San Andreas en (double-)cliquant sur son icône situé dans le menu '''Démarrer''' ou sur le bureau.
# GTA:San Andreas va alors démarrer. Une fois le chargement effectué, vous allez vous retrouver face à l'interface du menu MTA:SA. Vous avez alors le choix entre plusieurs options:

{| border="0" align="center"
| width="188" |
[[Image:MENU_QuickConnect.jpg]]
| width="380" |
<font size="-1" face="tahoma,helvetica,arial,sans-serif">'''Quick connect''' – Ceci vous permet de vous connecter rapidement à un serveur dont vous connaissez l'IP ainsi que le Port, et, si nécessaire, le Pass (Mot de passe).</font>

<br />
|-
| width="188" |
[[Image:Server_Browser.jpg|280px]]
| width="380" |
<font size="-1" face="tahoma,helvetica,arial,sans-serif">'''Browse servers''' – Ceci vous permet d'afficher la liste des serveurs en ligne.</font>

<br />
|-
| width="188" |
[[Image:Host_Game.jpg|280px]]
| width="380" |
<font size="-1" face="tahoma,helvetica,arial,sans-serif">'''Host game''' – Ceci vous permet de démarrer un serveur local (LAN et/ou Internet).</font>

<br />
|-
| width="188" |
[[Image:Menu_Settings.JPG|280px]]
| width="380" |
<font size="-1" face="tahoma,helvetica,arial,sans-serif">'''Settings '''– Ceci vous permet de changer votre pseudo, les contrôles, les options graphiques, audios, etc.</font>

<br /><br />
|-
| width="188" |
[[Image:About_Menu.jpg|280px]]
| width="380" |
<font size="-1" face="tahoma,helvetica,arial,sans-serif">'''About '''– Ceci vous permet de voir la liste des personnes ayant contribué au projet MTA:SA.</font>

<br />
|-
| width="188" |
[[Image:Map_Editor.jpg|280px]]
| width="380" |
<font size="-1" face="tahoma,helvetica,arial,sans-serif">'''Map editor '''– Ceci vous permet de créer vos propres maps (cartes) complètes. Elles peuvent par la suite être chargées sur un serveur afin d'améliorer l'expérience de jeu.</font>

<br /><br />
|-
| width="188" |
<br>
| width="380" |
<font size="-1" face="tahoma,helvetica,arial,sans-serif">'''Quit '''– Ceci permet de quitter MTA:SA et de revenir à votre précédente application.</font>

<br /><br />
|}

Le moyen le plus simple et rapide de jouer à MTA:SA est d'utiliser '''Browse servers'''. Si les serveurs n’apparaissent pas au bout de quelques secondes d'attente, appuyez sur le bouton '''Refresh''' afin que MTA:SA recharge la liste des serveurs.

* Dans la case '''Name''' apparait le nom du serveur.
* Dans la case '''Players''' apparait le nombre de joueurs connectés actuellement ainsi que le nombre de joueurs maximum, inscrits dans le format de '''[Slots Utilisés] / [Slots Maximum]'''.
* Dans la case '''Ping''' apparait votre ping (ou [http://fr.wikipedia.org/wiki/Lag_%28informatique%29 lag, latence]), entre vous et le serveur. Afin d'obtenir plus d'informations sur les lags, rendez-vous sur le lien situé auparavant.
* Dans la case '''Host''' apparait l'adresse IP du serveur. C'est grâce à celle-ci que vous pourrez, dans le futur, utiliser dans la case '''Quick connect''' du menu principal de MTA:SA afin de vous connecter rapidement à un serveur.

Cache case peut être cliqué afin de les arranger dans l'ordre croissant ou décroissant.

Pour une performance optimale, cherchez le meilleur équilibre entre joueurs et ping.

Une fois que vous avez choisi un serveur, sélectionnez-le en cliquant dessus, puis en cliquant sur le bouton '''Connect''' dans le coin en haut à droite. Si tout se passe bien, vous allez être connecté automatiquement au serveur.

==Comment jouer ?==

MTA:SA offre un système complet de script qui permet aux créateurs de cartes de modifier plusieurs éléments de jeu afin qu'ils puissent créer leurs propres modes de jeu. MTA:SA intègre autant d'éléments que possible qu'en solo, mais certains aspects sont différents.

Il n'y a pas de piétons ou de conducteurs dans les rues. Il n'y a que les joueurs actuellement connecté sur le serveur. Vous pouvez parler aux autres joueurs du serveur (par défaut si le script n'a pas modifié ceci) en appuyant sur la touche '''T''', puis en insérant votre texte. Si le serveur le propose, vous pouvez parler exclusivement à votre équipe en appuyant cette fois sur '''Y'''.

Le créateur de cartes de MTA:SA permet d'ajouter plusieurs objets sur une même carte, d'une route à un casino en passant par une planche à bois, etc. Et ceci peut-être combiné au script afin de faire bouger certains objets via une commande, une touche... Les possibilités sont presque infinies.

Vous pouvez aussi, en appuyant sur la touche '''Tabulation''', afficher le tableau des scores. Par défaut, seuls les pseudos des joueurs ainsi que leur ping s'affichent, mais ceci peut-être modifié via le script. Par exemple, pour un mode de jeu tourné vers le deathmatch (combat à mort en Français), les scripteurs peuvent afficher une colonne référençant le nombre de meurtres et/ou morts. Encore une fois, ici, les possibilités sont presque infinies.

==Contrôles==

===Touches dans le jeu===

* F8 : Affiche la console.
* F9 : Affiche l'aide.
* F11 : Affiche la carte de San Andreas, ainsi que votre position. Les touches suivantes ne fonctionnent que sur cette carte et se situent sur le pavé numérique:
**/ ou - : Zoom avant ou arrière.
**4, 8, 6, 2 : Déplace la carte respectivement vers la gauche, le haut, la droite, le bas.
**0 : Basculer entre attacher la vue sur le joueur (la carte suit l'icône du joueur) et mouvement libre (la carte reste stationnaire).
* F12 : Réaliser une capture d'écran.
* T : Chat général.
* Y : Chat de l'équipe.
* TAB : Liste des joueurs (si le serveur le permet).

==Commandes de la console==

Appuyez sur '''~ (tilde)''' ou '''F8''' pour accéder à la console, tapez ensuite la commande souhaitée avec les paramètres nécessaires (si possible) puis appuyez sur '''Entrée'''.

;'''maps''' :Affiche la liste de toutes les cartes disponibles sur le serveur.

;'''nick [pseudo]''' :Change votre pseudo en jeu par celui que vous avez entré comme paramètre.

;'''msg [pseudo] [message]''' ''ou'' '''pm [pseudo] [message]''' :Envoie un message privé à la personne dont le pseudo est spécifié en paramètre. Seule la personne à laquelle vous avez envoyé le message le verra. '''msg''' et '''pm''' ont la même fonction.

;'''quit''' ''ou'' '''exit''' :Vous déconnecte du serveur tout en vous ramenant vers votre dernière application. Le bouton '''Quit''' du menu principal a la même fonction.

;'''ver''' :Ceci affiche la dernière version et les informations sur le copyright du logiciel.

;'''sver''' :Ceci affiche la version du serveur sur lequel vous êtes actuellement connecté.

;'''time''' :Ceci affiche l'heure actuelle.

;'''disconnect''' :Ceci vous déconnecte du serveur et vous ramène au menu principal.

;'''say [texte]''' :Ceci vous permet de parler aux joueurs du serveur avec la console.

;'''ignore [pseudo]''' :Ceci vous permettra de ne plus voir le texte qu'écrit le joueur dont vous avez entré le pseudo en paramètre. Pour arrêter d'ignorer un joueur, retapez '''ignore [pseudo]'''.

'''Astuce:''' Vous pouvez utiliser ces commandes dans la chatbox du serveur en insérant un '''"/"''' (slash) en face d'elles.

Vous pouvez retrouver cette liste en jeu en tapant '''help''' dans la console puis en appuyant sur '''Entrée'''. Le serveur sur lequel vous jouez peut aussi avoir des commandes supplémentaires qui peuvent être consultées en tapant '''commands''' dans la console.

==Codes d'erreurs et leurs significations==
'''Erreurs de téléchargement'''<br>
0: UNKNOWN_ERROR<br>
1: INVALID_FILE_DESCRIPTORS<br>
2: INVALID_MAX_FILE_DESCRIPTOR<br>
3: INVALID_SELECT_RETURN<br>
4: INVALID_INITIAL_MULTI_PERFORM<br>
5: INVALID_MULTI_PERFORM_CODE<br>
6: INVALID_MULTI_PERFORM_CODE_NEW_DOWNLOADS<br>
7: UNEXPECTED_CURL_MESSAGE<br>
8: UNABLE_TO_CONNECT<br>
9: UNABLE_TO_DOWNLOAD_FILE<br>
10: FAILED_TO_INITIALIZE_DOWNLOAD<br>

'''Erreurs fatales'''<br>
1: no local player model on ingame event<br>
2: no local player on ingame event<br>
3: server downloads disabled<br>
4: no local player model on player-list packet<br>
5: no local player on player-list packet<br>
6: invalid custom data length on entity-add packet<br>
7: invalid bitstream data on entity-add packet<br>
8: system entity on entity-add packet<br>
9: failed to create object on entity-add packet<br>
10: failed to create pickup on entity-add packet<br>
11: failed to create vehicle on entity-add packet<br>
12: invalid team-name length on entity-add packet<br>
13: invalid lua-event name length in lua-event packet<br>
14: invalid resource name length in resource-start packet<br>

''''Erreurs pour entrer dans un véhicule'''<br>
1: script cancelled<br>
2: script cancelled (jack)<br>
3: current occupier is entering/exiting<br>
4: invalid seat<br>
5: not close enough<br>
6: already in a vehicle<br>
7: already entering/exiting<br>
8: invalid vehicle (trailer)<br>

==Spécial: Jouer à MTA:SA sur Linux ?==
Si vous êtes l'un des joueurs qui ont Linux comme OS, et qui veulent pouvoir jouer à MTA:SA dessus, veuillez lire le [[Manuel_du_Client_sur_Linux|Manuel du Client sur Linux]].

FR/Manuel Client

2014-07-09T18:46:01Z

Citizen: Update to match english version

__TOC__

==Introduction==
Multi Theft Auto: San Andreas est le dernier mod en série de modifications multijoueurs pour les jeux Grand Theft Auto (sur PC exclusivement). Pour les versions sur GTA III et GTA:VC, s'exécutant tous deux sur l'ancien système, visitez [http://www.multitheftauto.com/ http://www.multitheftauto.com]. Cette modification n'est en aucun cas approuvé et affilié à Rockstar Games ou Take 2 Interactive.

==Avant de commencer==

Avant d'installer Multi Theft Auto: San Andreas, assurez-vous en premier que le jeu GTA:SA est bien installé. Dans le cas échéant, MTA:SA ne pourra démarrer. Si vous voulez garder vos mods spécifiques à la version solo du jeu (ces mods étant généralement interdits sur la plupart des serveurs MTA:SA), réinstallez GTA:SA dans un autre fichier sur votre disque dur.

Assurez-vous aussi d'être sur '''Windows XP''', '''Windows Vista''' (32 bits ou 64 bits), '''Windows 7''' (32 bits ou 64 bits) or '''Windows 8''' (32 bits ou 64 bits) et que vous êtes capable de lancer le jeu solo. Sachez que si vous arrivez à jouer au solo sur un pc dont ses caractéristiques sont vraiment au minimum requis, vous aurez sûrement du mal à faire fonctionner MTA:SA correctement.
{{Note|
* MTA:SA ne fonctionne que sur GTA:SA '''v1.0'''. Si vous venez d'acheter le jeu, il est plus que probable que vous ayez la dernière version.''' [[Known_Issues_-_FAQ#Does_MTASA_work_with_v1.01_or_v2.00_of_GTA_San_Andreas.3F| (Plus d'info)]]
* Si vous avez la version Steam de GTA: San Andreas vous devez [[Known_Issues_-_FAQ#I_have_the_Steam_version_of_GTA_San_Andreas._How_can_I_play_MTASA.3F|lire ceci d'abord]].
}}

===Exigences du système===
Les exigences du système pour faire fonctionner MTA:SA sont à peine plus élevées que celles nécessaires pour GTA:SA.
* Intel Pentium 4 ou AMD Athlon XP.
* 512MB DDR RAM.
* Une installation sans modifications du jeu GTA:SA v1.0 (Américain ou Européen).
* 3.7GB d'espace disponible sur votre disque dur (3.6GB sont minimum pour l'installation de GTA:SA).
* nVidia GeForce 4 series ou ATI Radeon 8xxx series (64MB RAM et DirectX 9.0 compatible).
* DirectX 9.0 carte son compatible.
* Clavier et souris.
* Une connexion internet haut-débit (pour faciliter les chargements).

Pour de meilleurs graphismes, une carte graphique compatible avec Pixel Shader 2.0 (nVidia GeForce FX series ou plus, ATI Radeon 9xxx series ou plus) est recommandée.

Pour une meilleure performance de chargement, une plus grande RAM est recommandée.

==Installer MTA:SA==
Pour pouvoir installer MTA:SA, vous devez respecter un ordre précis, sans quoi il ne pourra pas se lancer.

# Si ce n'est pas déjà fait, téléchargez le dernier client de MTA:SA sur [http://www.multitheftauto.com/ http://www.multitheftauto.com].
# Lancez l'installateur. Vous allez être questionné sur les composants à installer:
#* '''Client''': Ce sont les interfaces du client, nécessitées pour pouvoir faire fonctionner MTA:SA.
#* '''MTA Server''': Vous permet de pouvoir faire héberger votre serveur MTA:SA.
#* '''MTA Server > Editor''': Utilisé pour créer des maps (cartes). Ceci n'est pas obligatoire pour faire fonctionner MTA:SA.
# Vous allez être questionné sur l'emplacement où vous voulez installer MTA:SA. Celui-ci peut-être n'importe où.
# Vous allez ensuite être questionné sur l'emplacement où le jeu GTA:SA est installé. Par défaut, le chemin d'accès est celui-ci: '''C:\Program Files\Rockstar Games\GTA San Andreas\'''.
# Une fois l'installation terminée, l'installateur va vous demander si vous voulez lancer MTA:SA. Cochez la case comme bon vous semble, puis cliquez sur '''Finish'''.
# Vous pouvez maintenant lancer MTA:SA depuis le menu '''Démarrer''' ou sur le bureau.

==Lancer le jeu==
# Démarrez Multi Theft Auto: San Andreas en (double-)cliquant sur son icône situé dans le menu '''Démarrer''' ou sur le bureau.
# GTA:San Andreas va alors démarrer. Une fois le chargement effectué, vous allez vous retrouver face à l'interface du menu MTA:SA. Vous avez alors le choix entre plusieurs options:

{| border="0" align="center"
| width="188" |
[[Image:MENU_QuickConnect.jpg]]
| width="380" |
<font size="-1" face="tahoma,helvetica,arial,sans-serif">'''Quick connect''' – Ceci vous permet de vous connecter rapidement à un serveur dont vous connaissez l'IP ainsi que le Port, et, si nécessaire, le Pass (Mot de passe).</font>

<br />
|-
| width="188" |
[[Image:Server_Browser.jpg|280px]]
| width="380" |
<font size="-1" face="tahoma,helvetica,arial,sans-serif">'''Browse servers''' – Ceci vous permet d'afficher la liste des serveurs en ligne.</font>

<br />
|-
| width="188" |
[[Image:Host_Game.jpg|280px]]
| width="380" |
<font size="-1" face="tahoma,helvetica,arial,sans-serif">'''Host game''' – Ceci vous permet de démarrer un serveur local (LAN et/ou Internet).</font>

<br />
|-
| width="188" |
[[Image:Menu_Settings.JPG|280px]]
| width="380" |
<font size="-1" face="tahoma,helvetica,arial,sans-serif">'''Settings '''– Ceci vous permet de changer votre pseudo, les contrôles, les options graphiques, audios, etc.</font>

<br /><br />
|-
| width="188" |
[[Image:About_Menu.jpg|280px]]
| width="380" |
<font size="-1" face="tahoma,helvetica,arial,sans-serif">'''About '''– Ceci vous permet de voir la liste des personnes ayant contribué au projet MTA:SA.</font>

<br />
|-
| width="188" |
[[Image:Map_Editor.jpg|280px]]
| width="380" |
<font size="-1" face="tahoma,helvetica,arial,sans-serif">'''Map editor '''– Ceci vous permet de créer vos propres maps (cartes) complètes. Elles peuvent par la suite être chargées sur un serveur afin d'améliorer l'expérience de jeu.</font>

<br /><br />
|-
| width="188" |
<br>
| width="380" |
<font size="-1" face="tahoma,helvetica,arial,sans-serif">'''Quit '''– Ceci permet de quitter MTA:SA et de revenir à votre précédente application.</font>

<br /><br />
|}

Le moyen le plus simple et rapide de jouer à MTA:SA est d'utiliser '''Browse servers'''. Si les serveurs n’apparaissent pas au bout de quelques secondes d'attente, appuyez sur le bouton '''Refresh''' afin que MTA:SA recharge la liste des serveurs.

* Dans la case '''Name''' apparait le nom du serveur.
* Dans la case '''Players''' apparait le nombre de joueurs connectés actuellement ainsi que le nombre de joueurs maximum, inscrits dans le format de '''[Slots Utilisés] / [Slots Maximum]'''.
* Dans la case '''Ping''' apparait votre ping (ou [http://fr.wikipedia.org/wiki/Lag_%28informatique%29 lag, latence]), entre vous et le serveur. Afin d'obtenir plus d'informations sur les lags, rendez-vous sur le lien situé auparavant.
* Dans la case '''Host''' apparait l'adresse IP du serveur. C'est grâce à celle-ci que vous pourrez, dans le futur, utiliser dans la case '''Quick connect''' du menu principal de MTA:SA afin de vous connecter rapidement à un serveur.

Cache case peut être cliqué afin de les arranger dans l'ordre croissant ou décroissant.

Pour une performance optimale, cherchez le meilleur équilibre entre joueurs et ping.

Une fois que vous avez choisi un serveur, sélectionnez-le en cliquant dessus, puis en cliquant sur le bouton '''Connect''' dans le coin en haut à droite. Si tout se passe bien, vous allez être connecté automatiquement au serveur.

==Comment jouer ?==

MTA:SA offre un système complet de script qui permet aux créateurs de cartes de modifier plusieurs éléments de jeu afin qu'ils puissent créer leurs propres modes de jeu. MTA:SA intègre autant d'éléments que possible qu'en solo, mais certains aspects sont différents.

Il n'y a pas de piétons ou de conducteurs dans les rues. Il n'y a que les joueurs actuellement connecté sur le serveur. Vous pouvez parler aux autres joueurs du serveur (par défaut si le script n'a pas modifié ceci) en appuyant sur la touche '''T''', puis en insérant votre texte. Si le serveur le propose, vous pouvez parler exclusivement à votre équipe en appuyant cette fois sur '''Y'''.

Le créateur de cartes de MTA:SA permet d'ajouter plusieurs objets sur une même carte, d'une route à un casino en passant par une planche à bois, etc. Et ceci peut-être combiné au script afin de faire bouger certains objets via une commande, une touche... Les possibilités sont presque infinies.

Vous pouvez aussi, en appuyant sur la touche '''Tabulation''', afficher le tableau des scores. Par défaut, seuls les pseudos des joueurs ainsi que leur ping s'affichent, mais ceci peut-être modifié via le script. Par exemple, pour un mode de jeu tourné vers le deathmatch (combat à mort en Français), les scripteurs peuvent afficher une colonne référençant le nombre de meurtres et/ou morts. Encore une fois, ici, les possibilités sont presque infinies.

==Contrôles==

===Touches dans le jeu===

* F8 : Affiche la console.
* F9 : Affiche l'aide.
* F11 : Affiche la carte de San Andreas, ainsi que votre position. Les touches suivantes ne fonctionnent que sur cette carte et se situent sur le pavé numérique:
**/ ou - : Zoom avant ou arrière.
**4, 8, 6, 2 : Déplace la carte respectivement vers la gauche, le haut, la droite, le bas.
**0 : Basculer entre attacher la vue sur le joueur (la carte suit l'icône du joueur) et mouvement libre (la carte reste stationnaire).
* F12 : Réaliser une capture d'écran.
* T : Chat général.
* Y : Chat de l'équipe.
* TAB : Liste des joueurs (si le serveur le permet).

==Commandes de la console==

Appuyez sur '''~ (tilde)''' ou '''F8''' pour accéder à la console, tapez ensuite la commande souhaitée avec les paramètres nécessaires (si possible) puis appuyez sur '''Entrée'''.

;'''maps''' :Affiche la liste de toutes les cartes disponibles sur le serveur.

;'''nick [pseudo]''' :Change votre pseudo en jeu par celui que vous avez entré comme paramètre.

;'''msg [pseudo] [message]''' ''ou'' '''pm [pseudo] [message]''' :Envoie un message privé à la personne dont le pseudo est spécifié en paramètre. Seule la personne à laquelle vous avez envoyé le message le verra. '''msg''' et '''pm''' ont la même fonction.

;'''quit''' ''ou'' '''exit''' :Vous déconnecte du serveur tout en vous ramenant vers votre dernière application. Le bouton '''Quit''' du menu principal a la même fonction.

;'''ver''' :Ceci affiche la dernière version et les informations sur le copyright du logiciel.

;'''sver''' :Ceci affiche la version du serveur sur lequel vous êtes actuellement connecté.

;'''time''' :Ceci affiche l'heure actuelle.

;'''disconnect''' :Ceci vous déconnecte du serveur et vous ramène au menu principal.

;'''say [texte]''' :Ceci vous permet de parler aux joueurs du serveur avec la console.

;'''ignore [pseudo]''' :Ceci vous permettra de ne plus voir le texte qu'écrit le joueur dont vous avez entré le pseudo en paramètre. Pour arrêter d'ignorer un joueur, retapez '''ignore [pseudo]'''.

'''Astuce:''' Vous pouvez utiliser ces commandes dans la chatbox du serveur en insérant un '''"/"''' (slash) en face d'elles.

Vous pouvez retrouver cette liste en jeu en tapant '''help''' dans la console puis en appuyant sur '''Entrée'''. Le serveur sur lequel vous jouez peut aussi avoir des commandes supplémentaires qui peuvent être consultées en tapant '''commands''' dans la console.

==Codes d'erreurs et leurs significations==
'''Erreurs de téléchargement'''<br>
0: UNKNOWN_ERROR<br>
1: INVALID_FILE_DESCRIPTORS<br>
2: INVALID_MAX_FILE_DESCRIPTOR<br>
3: INVALID_SELECT_RETURN<br>
4: INVALID_INITIAL_MULTI_PERFORM<br>
5: INVALID_MULTI_PERFORM_CODE<br>
6: INVALID_MULTI_PERFORM_CODE_NEW_DOWNLOADS<br>
7: UNEXPECTED_CURL_MESSAGE<br>
8: UNABLE_TO_CONNECT<br>
9: UNABLE_TO_DOWNLOAD_FILE<br>
10: FAILED_TO_INITIALIZE_DOWNLOAD<br>

'''Erreurs fatales'''<br>
1: no local player model on ingame event<br>
2: no local player on ingame event<br>
3: server downloads disabled<br>
4: no local player model on player-list packet<br>
5: no local player on player-list packet<br>
6: invalid custom data length on entity-add packet<br>
7: invalid bitstream data on entity-add packet<br>
8: system entity on entity-add packet<br>
9: failed to create object on entity-add packet<br>
10: failed to create pickup on entity-add packet<br>
11: failed to create vehicle on entity-add packet<br>
12: invalid team-name length on entity-add packet<br>
13: invalid lua-event name length in lua-event packet<br>
14: invalid resource name length in resource-start packet<br>

''''Erreurs pour entrer dans un véhicule'''<br>
1: script cancelled<br>
2: script cancelled (jack)<br>
3: current occupier is entering/exiting<br>
4: invalid seat<br>
5: not close enough<br>
6: already in a vehicle<br>
7: already entering/exiting<br>
8: invalid vehicle (trailer)<br>

==Spécial: Jouer à MTA:SA sur Linux ?==
Si vous êtes l'un des joueurs qui ont Linux comme OS, et qui veulent pouvoir jouer à MTA:SA dessus, veuillez lire le [[Manuel_du_Client_sur_Linux|Manuel du Client sur Linux]].

Page d'accueil

2014-04-03T21:28:24Z

Citizen: Undo revision 39226 by Gaetan Piette (talk)

<div style="background: #FFEEAA; padding: 5px; float:right; width: 30%;">Dernière version stable de '''Multi Theft Auto: San Andreas''' est '''{{Current Version|full}}'''. Rendez-vous sur la [http://mtasa.com/ page principale] pour la télécharger.
<p>
Vous pouvez aussi télécharger une [http://nightly.mtasa.com/ beta] pour avoir la dernière version ( non stable ).
</p>
</div>
__NOTOC__
Bienvenue sur le wiki de Multi Theft Auto. Sur ce wiki, vous trouverez toutes les informations sur Multi Theft Auto.

Il y a [[How you can help|différents moyens de nous aider]]: créer une map, un gamemode, rediger des articles sur des fonctions, écrire un exemple, écrire un tutorial ou juste jouer à MTA et nous rapportez les bugs trouvés.

<div style="clear:both;"></div>
{| width="100%" cellspacing="0" cellpadding="0"
| colspan="2" |

|-
| width="50%" style="vertical-align:top;" |
<div style="border: 1px dotted #AAAAAA;padding:4px 8px 8px 8px;margin:10px;">
====Pour commencer====

* [[FR/Manuel_Client|Manuel Client]] ( Traduction: [http://wiki.multitheftauto.com/wiki/User:DrawKiie DrawKiie] )
* [[FR/Manuel_Serveur|Manuel Serveur]] ( Traduction: [http://wiki.multitheftauto.com/wiki/User:Rouche Rouche] )
* [[FR/Problemes_connus|Problèmes connus]] ( Traduction: [http://wiki.multitheftauto.com/wiki/User:Rouche Rouche] )
* [[FR/Migrer_de_MTARace_a_MTASA_1.0.x|Migrer de MTA:Race à MTA:SA 1.0.x]] ( Traduction: [http://wiki.multitheftauto.com/wiki/User:Rouche Rouche] )
* [[FR/A propos des Map|A propos des Map]] ( Traduction: [http://wiki.multitheftauto.com/wiki/User:Rouche Rouche] )

</div>

<div style="border: 1px dotted #AAAAAA;padding:4px 8px 8px 8px;margin:10px;">

====Programmer====

* [[FR/Introduction_Programmation|Introduction: La programmation]]
* [[FR/Introduction_GUI|Introduction: Le GUI]] ( Traduction: [http://wiki.multitheftauto.com/wiki/User:FatalTeror FatalTerror] )
* [[FR/Debugage|Tutoriel: Le débugage]] - Comment trouver les erreurs dans son script (Traduction:[http://wiki.multitheftauto.com/wiki/User:Vincenzo Vincenzo] alias Vincentdu90)
* [[FR/Ressources|Introduction: Les ressources]] (Traduction : [http://wiki.multitheftauto.com/wiki/User:Myk3L Myk3L])
** [[FR/Ressource_Acces_Internet|Introduction: L'accès depuis internet]] - Comment créer un site à partir d'une ressource (Traduction : [http://wiki.multitheftauto.com/wiki/User:Myk3L Myk3L])
** [[:Category:Resource|Catalogue des ressources]]
** [[FR/Meta.xml|Meta.xml]] - Derière chaque ressource ce trouve une meta pour la définir
** [[FR/ACL|ACL]] - Access Control List, pour définir les autorisations
* [[FR/Ecrire_Gamemode|Créer un gamemode]]
* [[FR/Fonctions_Utiles|Fonctions Utiles]]

</div>

<div style="border: 1px dotted #AAAAAA;padding:4px 8px 8px 8px;margin:10px;">

====Bases de données====
Cette section décrit toutes les capacités fournies par le LUA/MTA ou par les ressources.
* [[:Category:Resource|Catalogue des ressources]] - Vous devriez le lire pour réaliser un script approprié.
* [[FR/Les_scripts_clients| Les scripts clients]]
</div>
<div style="border: 1px dotted #AAAAAA;padding:4px 8px 8px 8px;margin:10px;">

====Aide générale du LUA====
Des pages conçues pour aider votre compréhension du Lua
*[http://www.lua.org/pil/index.html "Programming in Lua"]
**[http://www.lua.org/manual/5.1/#index Les fonctions Lua]
*[http://lua-users.org/wiki/TutorialDirectory wiki Lua]
*[http://nixstaller.berlios.de/manual/0.2/nixstaller_9.html Un guide général au Lua de Nixstaller]
</div>

| width="50%" style="vertical-align:top;" |
<div style="border: 1px dotted #AAAAAA;padding:4px 8px 8px 8px;margin:10px;">

====Map Editor====
*[[Resource:Editor|Manuel]]
*[[Resource:Editor/EDF|Editor Definition Format]]
*[[Resource:Editor/Plugins|Plugins]]
*[[Resource:Editor#FAQ|Questions Fréquentes]]
</div>

<div style="border: 1px dotted #AAAAAA;padding:4px 8px 8px 8px;margin:10px;">

====Développer Multi Theft Auto====
* [[FR/Compiler_MTASA|Compiler MTASA sur Windows]]
* [[FR/Compiler_MTASA_Server_sur_Mac_OS_X|Compiler MTASA sur Mac OS X]]
* [[FR/Compiler_MTASA_Server_sur_GNU_Linux|Compiler MTASA sur GNU/Linux]]
* [[FR/Directives_de_codage|Directives de codage]]
* [http://code.google.com/p/mtasa-blue Google Code SVN]
* [[FR/Roadmap|Roadmap]]
</div>

<div style="border: 1px dotted #AAAAAA;padding:4px 8px 8px 8px;margin:10px; background:#CCCCFF;">

====Références====
* [[FR/Fonctions_Clients|Fonctions Clients]]
* [[FR/Events_Clients|Events Clients]]
* [[FR/Fonctions_Serveurs|Fonctions Clients]]
* [[FR/Events_Serveurs|Events Clients]]

* [[FR/MTA Classes|MTA Classes]] - Les descriptions détaillées de tous les types personnalisés MTA
** [[FR/Element|MTA Elements]] / [[Element tree]]
</div>

<div style="border: 1px dotted #AAAAAA;padding:4px 8px 8px 8px;margin:10px;">

====[[Id|ID Listes]]====
*[[FR/Animations|Animations]]
*[[FR/Skins_Personnages|Skins Personnages]]
*[[FR/Vetements_CJ|Vêtements CJ]]
*[[FR/Garage|Garage IDs]]
*[[FR/Interieurs_IDs|Intérieurs IDs]]
*[[FR/Materiel_IDs|Matériel IDs]]
*[[FR/Projectiles|Projectiles]]
*[[FR/Radar Blips|Radar Blips]]
*[[FR/Sons|Sons]]
*[[FR/Vehicule_IDs|ID des véhicules]]
*[[FR/Vehicule_Couleurs|Couleurs véhicules]]
*[[FR/Vehicule_Upgrades|Tuning IDs]]
*[[FR/Armes|Armes]]
*[[FR/Meteos|Météos]]
</div>

|-
| colspan="2" |
|}
{{Languages list|fr}}

CreateProjectile

2014-03-08T02:35:30Z

Citizen: force arg is only for throwable projectiles

__NOTOC__
{{Client function}}
This function creates a projectile of the specified type on the specified coordinates.

{{Note|'''Model''' argument is not synchronized between clients. Clients differs from local player see always standard projectile model.}}

==Syntax==
<syntaxhighlight lang="lua">
projectile createProjectile ( element creator, int weaponType [, float posX, float posY, float posZ, float force = 1.0, element target = nil, float rotX, float rotY, float rotZ, float velX, float velY, float velZ, int model ] )
</syntaxhighlight>

==Required Arguments==
*'''creator:''' The [[element]] representing creator of the projectile. In case you want the projectile to be synced for everybody creator must be the local player or his vehicle.
*'''weaponType:''' [[int]] representing the projectile weaponType (characteristics). Valid IDs are:
{{Projectiles}}

==Optional Arguments==
{{OptionalArg}}
*'''posX''','''posY''','''posZ''': [[float]] starting coordinates for the projectile. They are coordinates of creator by default.
*'''force''': [[float]] representing the starting force for throwable projectiles.
*'''target''': [[element]] target used for heat seeking rockets.
*'''rotX''','''rotY''','''rotZ''': [[float]] starting rotation for the projectile.
*'''velX''','''velY''','''velZ''': [[float]] starting velocity for the projectile.
*'''model''': Integer representing the projectile's model, uses default model for weaponType if not specified.

==Returns==
Returns a ''[[projectile]]'' element if [[projectile]] creation was succesfull. Returns ''false'' if unable to create a [[projectile]] (wrong weapon ID or projectiles limit was reached).

==Example==
This example makes a rocket minigun (minigun shooting with rockets).
<syntaxhighlight lang="lua">
-- This function gets triggered everytime player shoots.
function onClientPlayerWeaponFireFunc(weapon,ammo,ammoInClip,hitX,hitY,hitZ,hitElement)
if weapon == 38 then -- if source is a local player and he uses minigun...
x,y,z = getElementPosition(getLocalPlayer())
if not createProjectile(getLocalPlayer(),19,x,y,z,200) then -- then we either create a projectile...
outputChatBox ( "Rocket minigun overheated! Give it a rest pal!", source ) -- or if projectile limit is reached we output player a chat message
end
end
end

-- Don't forget to add the onClientPlayerWeaponFireFunc function as a handler for onClientPlayerWeaponFire.
addEventHandler("onClientPlayerWeaponFire", getLocalPlayer(), onClientPlayerWeaponFireFunc)
</syntaxhighlight>

==See also==
{{Client projectile functions}}

[[it:createProjectile]]

Talk:SetElementData

2014-02-25T15:50:19Z

Citizen: Added a question about the max key name length which is probably outdated.

Bug found, i think o,o
setElementData (weaponPickup,"norespawn",true) <<
Weaponpickup is a weapon pickup as the name says, like a AK-47
Debugscript: WARNING: ...: Bad argument @ 'setElementData'
True or False can't be a var in this case i think.
--[[User:JasperNL|Jasper.]] 18:38, 18 July 2010 (UTC)

----

The wiki says the key length can't be higher than 31 but in the source code it looks like it's now 128. Am I right ?:
https://code.google.com/p/mtasa-blue/source/browse/trunk/MTA10_Server/mods/deathmatch/logic/CCustomData.h#23
--Citizen

FR/Introduction Programmation

2012-09-20T23:27:47Z

Citizen: First to Premier

Les ressources sont les parties clées de MTA. Une ressource est un dossier ou un .zip qui contient plusieurs fichiers, ainsi qu'une meta qui dit au serveur comment la resource doit-elle être chargée. Une ressource peut être comparée comme un programme qu'on peut lancer ou arrêter, il est possible de lancer plusieurs ressources en même temps.

Tout ce qui a un rapport avec la programmation se passe dans les ressources, se que fait la ressource, définie si c'est un gamemode, une map or quelquechose d'autre. MTA s'installe avec des resources que vous pouvez facultativement utiliser dans vos gamemodes, comme la ressource "maplimits" pour garder les joueurs dans une certaine zone ou encore "deathpickups" pour créer des pickups pour ramasser une arme.

'''La première chose à faire avant de pouvoir programmer en lua, c'est de se procurer un editeur de texte qui supporte le lua. Il vous sera beaucoups plus facile que de le faire avec le bloc-note de Windows. Nous vous recommendons donc [http://notepad-plus.sourceforge.net/uk/site.htm Notepad++] ou [http://luaedit.sourceforge.net/ LuaEdit]. Il y a aussi un logiciel non officiel [[MTASE|MTA Script Editor]] ( malheureusement l'auteur ne travail plus dessus ) que vous pouvez tester.'''

==Créer un script qui fonctionne==
Nous allons voir tout d'abord comment créer un simple script étapes par étapes qui permetra aux joueurs de se deplacer dans la ville. Dans ce tutoriel, on utilisera notepadd++.
===Où sont tous les scripts ?===
Laissez moi d'abord vous présenter comment s'oranise une ressource. Allez dans votre dossier MTA San et et suivez le chemin suivant:

/serveur/mods/deathmatch/resources/

Vous y verez de nombreux fichier avec l'extension .zip, se sont des ressources avec à l'intérieur des exemples de scripts . Toutes les ressources chargées sont dézippé par le serveur afin de pouvoir les exécuter ( les .zip ne sont pas obligatiores, vous pouvez aussi laissez votre ressource en tant que dossier ). Pour créer votre propre ressource, créez simplement un nouveau dossier et nommez le comme vous voulez ( Ne pas utiliser d'espace, utilisez plutôt un _ ) . Nommez le "myserveur" pour ce tutoriel.

Maintenant entrez dans votre dossier. Le chemain devrait donc être

/serveur/mods/deathmatch/resources/myserveur/

===Identifier votre ressource===
Pour que le serveur puisse savoir ce que contient votre ressource, un fichier ''meta.xml'' doit être créé afin d'établir une liste du contenu du dossier. Cette 'meta.xml' doit être à la racine de votre ressource ( et non pas dans un autre sous-dossier ), donc dans le dossier "myserveur" dans notre cas. Donc ouvrez notepadd++, créer un nouveau fichier (Ctrl+N), puis faite "Enregistrez sous ..." (Ctrl+Alt+S), dans "Nom:" vous écrivez "meta" et dans "Type:", sélectionnez "*.xml" ( avant-dernier de la liste ), sauvegardez le dans votre dossier "myserveur".

Maintenant, ecrivez le code suivant dans votre ''meta.xml'':
<syntaxhighlight lang="xml">
<meta>
<info author="Votre Nom" type="gamemode" name="Mon serveur" description="Mon premier serveur MTA" />
<script src="script.lua" />
</meta>
</syntaxhighlight>
Dans la balise ''<info />'', il y a le champ "type" qui indique si la ressource est un ''gamemode'' ou une ''map'', on y reviendra plus tard. Un gamemode est ce dont vous avez besoin pour que votre serveur est une base.

La balise ''<script />'' indique les scripts qui sont dans la ressource, que l'on va maintenant créer.
===Créer un script simple===
Notez que dans la balise ''<script />'', le fichier .lua n'est pas dans un autre sous-dossier. Donc on va créer notre script.lua au même endroit que notre meta.xml ( Reproduisez la même opération mais "Nom:" écrivez 'script' et pour "Type:" choisissez 'Lua(*.lua)' ) puis copier-coller le code suivant:
<syntaxhighlight lang="lua">
function joinHandler()
local x = 1959.55
local y = -1714.46
local z = 10
spawnPlayer(source, x, y, z)
fadeCamera(source, true)
setCameraTarget(source, source)
outputChatBox("Bienvenue sur mon serveur", source)
end
addEventHandler("onPlayerJoin", getRootElement(), joinHandler)
</syntaxhighlight>
Ce script va fous faire apparître aux coordonnées (x, y, z) spécifié dans le code, lorsque vous connecterez au serveur. La fonction ''fadeCamera'' sinon l'écran restera noir. Vous devez aussi dire à la camera de suivre le joueur grâce à la fonction 'setCameraTarget' (sinon il vera une mer bleu).

La variable '''source''' indique qui 'déclenche' la fonction. Le fonction se 'déclenche' lorsqu'un joueur rejoind le serveur, vous utiliserez cette variable pour voir qui à rejoind le serveur. Donc lorsque un joueur( "la source" ) rejoindra notre serveur, on le fera apparaître aux coordonnées indiquées .

Focalisons-nous sur [[addEventHandler]], vous pouvez voir 3 choses: 'onPlayerJoin', qui indique quand éxécuter la fonction X. getRootElement(), qui indique qui/quoi peut être déclencher la fonction (getRootElement() veut dire toutes les choses et tous les joueurs). Et enfin la fonction X à éxecuter ( ici joinHandler ). Pour les autres details, nous verrons plus tard dans d'autres exemples mais tout d'abord testons notre premier gamemode!

===Lancer le gamemode===
Pour lancer le serveur, lancer simplement le 'MTA Server.exe' qui se trouve dans votre dossier 'MTA San et\server'. Une liste d'info concernant le serveur apparaîtra en premier; notez le port du serveur ( 22003 par défaut ), vous en aurez besoin pour rejoindre le serveur. Après, le serveur charge toutes les ressources du dossier 'resource', et enfin "ready to accept connections!"

Avant de pouvoir vous connecter, vous devez lancer votre gamemode. Tapez "start myserver" et appuyer sur Entrer. Le serveur va alors lancer le gamemode que nous avons créé, et nous affichera aussi les erreurs s'il y en a. Maintenant, vous pouvez maintenant lancer MTA, cliquez sur "Quick Connect" et ecrivez ceci: Dans Host: le1er champ: 127.0.0.1 ou localhost ( cela signifie que vous vous connectez au serveur du pc actuel ) et le 2ème champ: le port ( ici 22003 ) et cliquez sur 'Connect'. Si tout se passe bien, après quelques secondes, vous devriez apparaître et pouvoir allez où vous voulez.

Ensuite nous allons créer une commande que les joueurs pourront utiliser pour faire apparître une voiture à coté d'eux.

==Créer une commande==
Revenons à l'intérieur de notre ''script.lua''. Tout d'abord, nous devons créer une fonction qu'on pourra appeler/éxécuter grâce à notre commande et la fonction 'addCommandHandler' afin de créer la commande que les joueurs pourront taper dans le chat( T ) ou la console( F8 ).

<syntaxhighlight lang="lua">
-- On crée la fonction qui sera appelée par notre commande avec les arguments: thePlayer, command, vehicleModel
function createVehicleForPlayer(thePlayer, commandName, vehicleModel)
-- Ici on crée le véhicule
end
-- on crée la commande et on l'attache à notre fonction
addCommandHandler("createVehicle", createVehicleForPlayer)
</syntaxhighlight>
''Note: Grâce au wiki, vous pouvez cliquer sur le nom des fonctions et cela vous redirigera sur la documentation de cette fonction.''

====A propos du addCommandHandler====
Le premier argument du [[addCommandHandler]] est le nom de la commande the player will be able to enter, le second le nom de la fonction à appeler, dans notre cas, ''createVehicleForPlayer''.

Si vous avez déjà de l'expérience dans le codage, vous savez qu'un fonction s'appelle comme ceci:
<syntaxhighlight lang="lua">
nomDeLaFonction(argument1, argument2, argument3, ..)
</syntaxhighlight>
Si l'on regarde bien l'exemple ci-dessus, nous pouvons voir que l'argument1 est thePlayer and argument2 le commandName. thePlayer est celui qui à tapé la commande et commandName contient le nom de la commande qu'il à tapé. Donc si un joueur tape "/greet", cet argument va contenir "greet". Argument3 c'est ce que le joueur à tapé en plus de la commande, vous allez apprendre ceci dans le tutoriel. N'oubliez jamais que les deux premiers arguments sont les arguments standards, mais vous pouvez les renommé si vous voulez, seul l'ordre est important.

Par exemple: Un joueur tape "createVehicle 468" pour faire aparaître une Sanchez, la fonction addCommandHandler va appeller notre fonction createVehicleForPlayer, comme ceci:
<syntaxhighlight lang="lua">
createVehicleForPlayer(thePlayer,"createVehicle","468") -- thePlayer est l'élement joueur qui a tapé la commande
</syntaxhighlight>
Comme nous pouvons le voir, ll fournit plusieurs paramètres: le joueur qui a tapé la commande, la commande qu'il a tapé, et n'importe quelle texte qu'il a mis après, dans notre cas, "468" comme id de la Sanchez. Les deux premiers paramètres sont les même pour tous les addCommandHandler qu'on peut retrouver sur la page du [[addEventHandler]]. Vous devez toujours définir au moins ces deux paramètres pour utiliser les arguments après eux (par exemple pour traiter le texte qui a été entré après la commande, comme dans notre exemple le modèle du véhicule).

''Note: Vous devez créer la commande APRES la fonction que vous allez utiliser pour cette commande, sinon il ne trouvera pas la fonction.''

====Ecrire la fonction====
Pour remplir notre fonction d'instructions, nous devons d'abord pensez à ce que nous devons faire:
* Récupérer la position du joueur, donc on connaitra la position où faire apparaître le véhicule (on veut le faire apparaître à droite du joueur)
* Calculer la position où faire apparître le véhicule (nous ne voulons pas que le véhicule apparaisse dans le joueur)
* Faire apparître les véhicule
* Vérifier si le véhicule a bien apparus, ou aficher un message d'erreur.

Pour ça, nous devons utiliser plusieurs fonctions. Pour trouver la fonction que nous devons utiliser, il faut aller faire un tour dans la [[Scripting Functions|La liste des fonctions serveur]]. D'abord nous avons besoin d'une fonction pour obtenir la position du joueur. Puisque les joueurs sont des éléments, nous devons allez dans la rubrique '''Element functions''' où l'on pourra trouver la fonction [[getElementPosition]]. En cliquant sur le nom de la fonction, le wiki va vous afficher sa description. On peut y voir la syntaxe, qu'est-ce que la fonction retourne. La syntaxe nous montre les argument qu'on peut ou qu'on doit envoyer.

Pour [[getElementPosition]], la syntaxe est:
<syntaxhighlight lang="lua">
float, float, float getElementPosition ( element theElement )
</syntaxhighlight>

Les trois float devant le nom de la fonction est le type de variable que la fonction nous retourne. Dans notre cas, la fonction retourne trois nombres à virgule(x, y et z). Dans les parenthèses, on peut voir les arguments que l'on doit envoyer, dans notre cas, l'element dont on veut récupérer la position, le joueur dans notre exemple.

<syntaxhighlight lang="lua">
function createVehicleForPlayer(thePlayer, command, vehicleModel)
-- on récupère la position x,y,z dans des variables locales
-- une variable locale n'existe que dans le "périmètre" actuel. Ici, les variable x, y et z sont des variables locales qui se détruiront à la fin de la fonction.
local x,y,z = getElementPosition(thePlayer)
end
</syntaxhighlight>

Ensuite, il faut s'assurer que le véhicule n'apparaît pas directement dans le joueur, donc on ajoute quelques unités à la variable ''x'', qui le fera apparaître plus à l'est par rapport au joueur.

<syntaxhighlight lang="lua">
function createVehicleForPlayer(thePlayer, command, vehicleModel)
local x,y,z = getElementPosition(thePlayer) -- On prent la position du joueur qui a tapé la commande
x = x + 5 -- on ajoute 5 unité sur l'axes des x
end
</syntaxhighlight>

Maintenant nous avons besoin d'une autre fonction, celle qui va faire apparaître le véhicule. Nous allons la cherché encore une fois dans la [[Scripting Functions|liste des fonctions serveur]], mais cette fois, comme nous parlons d'un véhicule, nous devons donc aller dans la catégorie'''Vehicle functions''', où l'on va trouver la fonction [[createVehicle]]. Dans la syntaxe, nous pouvons voir que cette fonction ne retourne qu'une seule variable, le véhicule ( de type élément ) que nous venons de créer. Nous pouvons aussi voir qu'il y a des arguments entre crochets [], cela veut dire que ce sont des arguments optionels.

Nous avons déjà tous les arguments pour la fonction [[createVehicle]] dans notre fonction: La position que nous avons juste calculée dans les variables "x, y, z" et l'id du véhicule que nous avons fourni par la commande ("/createVehicle 468") et qui est stocké dans la variable ''vehicleModel''.

<syntaxhighlight lang="lua">
function createVehicleForPlayer(thePlayer, command, vehicleModel)
local x,y,z = getElementPosition(thePlayer) -- récupere la position du joueur dans les variables x, y et z
x = x + 5 -- rajoute 5 unités sur x
-- on crée le véhicule et on enregistre l'élément de type "vehicle" dans la variable ''createdVehicle''
local createdVehicle = createVehicle(tonumber(vehicleModel),x,y,z)
end
</syntaxhighlight>

Avec cette variable, on pourrait faire pas mal de choses sympa, mais ici nous allons juste vérifier si le véhicule à bien été créé ou non.
Sur le wiki de la fonction [[createVehicle]], il y a la partie nomée '''Returns''', la fonction va retourner ''false'' si la voiture n'a pas été créé. Ducoups, on va regarder la valeur de la variable ''createdVehicle''.

Voilà notre code complet:
<syntaxhighlight lang="lua">
function createVehicleForPlayer(thePlayer, command, vehicleModel)
local x,y,z = getElementPosition(thePlayer) -- On prent la position du joueur qui a tapé la commande
x = x + 5 -- on ajoute 5 unités à x
local createdVehicle = createVehicle(tonumber(vehicleModel),x,y,z) -- on crée le véhicule demandé par le joueur et on récupère ce que nous retourne la fonction dans la variable createdVehicle
-- On vérifie si la valeur retournée est égal à ''false'' ( ce qui signifie que ça n'a pas marché )
if (createdVehicle == false) then
-- si c'est le cas, on affiche un message d'erreur dans la chatbox mais seulement pour le joueur.
outputChatBox("Erreur lors de la création du véhicule.",thePlayer)
end
end
addCommandHandler("createVehicle", createVehicleForPlayer)
</syntaxhighlight>

Comme vous pouvez le voir, nous avons utilisé une nouvelle fonction: [[outputChatBox]]. Vous devriez maintenant pouvoir regarder la description de cette fonction par vous même.

==Ce que vous devez savoir==
Vous avez déjà lu quelques informations sur les ressources, les commandes et trouvez des fonctions dans le wiki, mais il y a encore beaucoup à apprendre. Cette section vous donnera une vue d'ensemble plutôt courte sur certaines de ces choses, tout en regardant les pages du wiki si possible.
===Les scripts client et serveur===
Vous pouvez avoir déjà remarqué ces termes (serveur/client) quelque part sur ce wiki, le plus souvent pour les fonctions. MTA ne supporte pas seulement les scripts exécuté par le serveur et des commandes (comme celle qu'on vien de faire) ou d'autres fonctions, mais aussi les scripts éxécuté par le client MTA, ceux des joueurs qui se connecte au serveur. La raison est que certaines fonctions de MTA doit être du coté client comme par exemple le GUI - Graphical User Interface - ( Pour tout ce qui est fenêtres, boutons, etc ), d'autres devraient être du côté client parce qu'ils fonctionnent mieux mais d'autres sont mieux pensées pour être du côté serveur ou ne fonctionne tout simplement pas du côté client.

La plupart de vos scripts (gamemodes, maps) seront surement du côté serveur, comme celui que nous avons fait tout à l'heure. Si vous vous heurtez à quelque chose qui ne peut pas être résolu du côté serveur, vous devrez probablement le faire côté client. Pour un script client, vous devriez créer un script ordinaire (par exemple appelé ''client.lua'') et spécifié dans la meta.xml, comme ceci:
<syntaxhighlight lang="xml">
<script src="client.lua" type="client" />
</syntaxhighlight>
L'attribut ''type'' est par defaut 'server', donc nous avons juste besoin de spécifier que c'est un script client. Lorsque vous faites ceci, le fichier va être télecharger par le joueur sur son ordinateur lorsqu'il se connecte au serveur. Plus d'infos: [[Client side scripts]].

===Ressources plus complexes===
La section précédente nous a montré brièvement comment ajouter des scripts clients à la ressource. Penchons nous maintenant sur la ''meta.xml'' et ce qu'elle fait.

====Premier example - Un script utile====
<syntaxhighlight lang="xml">
/admin_commands
/meta.xml
/commands.lua
/client.lua
</syntaxhighlight>
<syntaxhighlight lang="xml">
<meta>
<info author="Someguy" description="admin commands" />
<script src="commands.lua" />
<script src="client.lua" type="client" />
</meta>
</syntaxhighlight>

* Le "commands.lua" fournit quelques commandes d'admin, comme le fait d'interdire un joueur, en banissant ou quelque chose d'autre ce qui peut être utilisé par l'admin du serveur
* Le "client.lua" fournit un GUI pour être capable d'exécuter les actions mentionnées facilement

Cet exemple de script doit tourner tout le temps (peut être même démarré en même temps que le serveur) car ces commandes d'admin peuvent être appelé à n'importe quelle moment.

====Second example - Un gamemode====
<syntaxhighlight lang="xml">
/counterstrike
/meta.xml
/counterstrike.lua
/buymenu.lua
</syntaxhighlight>
<syntaxhighlight lang="xml">
<meta>
<info author="Quelqu'un" description="Counterstrike remake" type="gamemode" />
<script src="counterstrike.lua" />
<script src="buymenu.lua" type="client" />
</meta>
</syntaxhighlight>

* Le "counterstrike.lua" contient des caractéristiques semblables aux dispositifs suivants :
** Laisser les joueurs choisirent leur équipe et les faire apparaître
** Leur fournir des armes, des cibles et des instructions (peut-être lues d'une carte, voir ci-dessous)
** Définir les règles du jeu, par exemple. La partie se finie, ce qui se produit quand un joueur meurt
** .. et peut-être encore plus
* Le "buymenu.lua" est un script du côté client et crée un menu pour acheter des armes

Cet exemple peut s'appeler un gamemode, il modifie le gameplay, mais définit réellement les règles de celui-ci. Le "type" attribut indique que cet exemple fonctionne avec [[Map Manager]], encore une autre ressource qui a été écrite par l'équipe de MTA pour contrôler des gamemodes et le chargement de cartes. On recommande fortement que vous basiez vos gamemodes sur les techniques qu'il fournit.

Ceci signifie également que ce gamemode ne fonctionnera probablement pas sans carte. Les gamemodes devront toujours être aussi génériques que possible. Un exemple de gamemode utilisant une carte est énoncé dans le prochain exemple.

====Troisième exemple - Une carte====
<syntaxhighlight lang="xml">
/cs-airport
/meta.xml
/airport.map
/airport.lua
</syntaxhighlight>
<syntaxhighlight lang="xml">
<meta>
<info author="Quelqu'un" description="Counterstrike airport map" type="map" gamemodes="counterstrike" />
<map src="airport.map" />
<script src="airport.lua" />
</meta>
</syntaxhighlight>

* Le "airport.map" dans le fichier XML fournit des informations au sujet de la carte au gamemode, ceului-ci peut inclure :
** Là où les joueurs devraient apparaitre, avec quelles armes, avec quelle équipe
** Ce qui sont les cibles
** Temps, heure du monde, Limite de temps
** Fournir les véhicules
* Le ''airport.lua'' peut contenir des actions relatifs a la map comme:
** Ouvrir une certaine porte ou faire éxploser quelque chose quand une autre chose de spécifique se produit
** Créer ou déplacer quelques objets faits sur commande, ou manoeuvrez les objets qui sont créés dans le fichier .map
** .. toutes autre choses relatifs aux ojets du .map

Comme vous pouvez le voir, l'attribut "type" a été changé en 'map', pour dire au [[Map Manager]] que cette ressource est une carte, tandis que l'attribut "gamemodes" indique pour quels gamemodes cette carte est valide, dans ce cas-ci le gamemode de l'exemple de tout à l'heure.
Ce qui peut venir comme une surprise est qu'il y a aussi un script dans la ressource de carte. Évidemment ce n'est pas nécessaire dans une carte, mais ouvre une large gamme de possibilités pour les créateurs de cartes.

Le "airport.map" pourrait être semblable à ceci :
<syntaxhighlight lang="xml">
<map mode="deathmatch" version="1.0">
<terrorists>
<spawnpoint posX="2332.23" posY="-12232.33" posZ="4.42223" skins="23-40" />
</terrorists>
<counterterrorists>
<spawnpoint posX="2334.23443" posY="-12300.233" posZ="10.2344" skins="40-50" />
</counterterrorists>

<bomb posX="23342.23" posY="" posZ="" />

<vehicle posX="" posY="" posZ="" model="602" />
<vehicle posX="" posY="" posZ="" model="603" />
</map>
</syntaxhighlight>

Quand un gamemode est commencé avec une carte, les ressources de carte est automatiquement démaré par le mapmanager et les renseignements qu'il contient peut être lu par le gamemode. Quand la carte change, la ressource de carte actuelle est arrêtée et la ressource de carte suivante est commencée. Pour une explication plus détaillée et des exemples pour savoit comment les ressources de cartes sont utilisées dans le script principal, visitez s'il vous plaît la page [[Writing Gamemodes]].

===Événements===
Les événements sont la façon que MTA dit aux scripts des choses qui arrivent. Par exemple quand un joueur meurt, le [[onPlayerWasted]] l'événement est déclenché. Pour exécuter n'importe quelles actions quand un joueur meurt, vous devez vous préparer similiar à l'ajoutant d'un dresseur d'ordre, comme montré dans [[#Writing_the_script|the first chapter]].

Cet exemple produiras un message avec le nom du joueur qui est mort :
<syntaxhighlight lang="lua">
function playerDied(totalAmmo, killer, killerWeapon, bodypart)
outputChatBox(getPlayerName(source).." died!")
end
addEventHandler("onPlayerWasted",getRootElement(),playerDied)
</syntaxhighlight>

Au lieu de montrer que les arguments sont nécessaires, la page de documentation pour les spectacles d'Événements quels paramètres sont passés à la handler function, similaire à la voie un [[*About_command_handlers|command handler]] fait, juste qu'il se distingue de l'événement à l'événement. Un autre point important est la variable "source", qui existe dans les handler function. Ils ne doivent pas être ajoutés à la liste de paramètre de la fonction, mais cela existe toujours . Il a une différente valeur de l'événement à l'événement, pour les événements de joueur (comme dans l'exemple au-dessus) c'est l'élément de joueur. Comme un autre exemple, vous pouvez jeter un coup d'œil au script de joueur frayant fondamental dans la première section pour recevoir une idée comment "source" est utilisé.

==Où aller d'ici==
Vous devriez maintenant être familiers avec les aspects les plus fondamentaux de MTA scripting et aussi un peu avec la documentation. Le [[Main_Page]] vous fournit des liens vers plus de renseignements, Classes de travaux dirigés et Références qui permettent un coup d'oeil plus profond dans les thèmes dont vous désirez apprendre.

D'ici nous recommandons de lire le [[debugging]] la classe de travaux dirigés. De bonnes adresses déboguantes sont une nécessité absolue quand vous faites des scripts.

[[ru:Scripting Introduction]]
[[it:Introduzione allo scripting]]
[[es:Introducción a la Programación]]

FR/Introduction Programmation

2012-09-20T23:26:54Z

Citizen: pouver to pouvez

Les ressources sont les parties clées de MTA. Une ressource est un dossier ou un .zip qui contient plusieurs fichiers, ainsi qu'une meta qui dit au serveur comment la resource doit-elle être chargée. Une ressource peut être comparée comme un programme qu'on peut lancer ou arrêter, il est possible de lancer plusieurs ressources en même temps.

Tout ce qui a un rapport avec la programmation se passe dans les ressources, se que fait la ressource, définie si c'est un gamemode, une map or quelquechose d'autre. MTA s'installe avec des resources que vous pouvez facultativement utiliser dans vos gamemodes, comme la ressource "maplimits" pour garder les joueurs dans une certaine zone ou encore "deathpickups" pour créer des pickups pour ramasser une arme.

'''La première chose à faire avant de pouvoir programmer en lua, c'est de se procurer un editeur de texte qui supporte le lua. Il vous sera beaucoups plus facile que de le faire avec le bloc-note de Windows. Nous vous recommendons donc [http://notepad-plus.sourceforge.net/uk/site.htm Notepad++] ou [http://luaedit.sourceforge.net/ LuaEdit]. Il y a aussi un logiciel non officiel [[MTASE|MTA Script Editor]] ( malheureusement l'auteur ne travail plus dessus ) que vous pouvez tester.'''

==Créer un script qui fonctionne==
Nous allons voir tout d'abord comment créer un simple script étapes par étapes qui permetra aux joueurs de se deplacer dans la ville. Dans ce tutoriel, on utilisera notepadd++.
===Où sont tous les scripts ?===
Laissez moi d'abord vous présenter comment s'oranise une ressource. Allez dans votre dossier MTA San et et suivez le chemin suivant:

/serveur/mods/deathmatch/resources/

Vous y verez de nombreux fichier avec l'extension .zip, se sont des ressources avec à l'intérieur des exemples de scripts . Toutes les ressources chargées sont dézippé par le serveur afin de pouvoir les exécuter ( les .zip ne sont pas obligatiores, vous pouvez aussi laissez votre ressource en tant que dossier ). Pour créer votre propre ressource, créez simplement un nouveau dossier et nommez le comme vous voulez ( Ne pas utiliser d'espace, utilisez plutôt un _ ) . Nommez le "myserveur" pour ce tutoriel.

Maintenant entrez dans votre dossier. Le chemain devrait donc être

/serveur/mods/deathmatch/resources/myserveur/

===Identifier votre ressource===
Pour que le serveur puisse savoir ce que contient votre ressource, un fichier ''meta.xml'' doit être créé afin d'établir une liste du contenu du dossier. Cette 'meta.xml' doit être à la racine de votre ressource ( et non pas dans un autre sous-dossier ), donc dans le dossier "myserveur" dans notre cas. Donc ouvrez notepadd++, créer un nouveau fichier (Ctrl+N), puis faite "Enregistrez sous ..." (Ctrl+Alt+S), dans "Nom:" vous écrivez "meta" et dans "Type:", sélectionnez "*.xml" ( avant-dernier de la liste ), sauvegardez le dans votre dossier "myserveur".

Maintenant, ecrivez le code suivant dans votre ''meta.xml'':
<syntaxhighlight lang="xml">
<meta>
<info author="Votre Nom" type="gamemode" name="Mon serveur" description="Mon premier serveur MTA" />
<script src="script.lua" />
</meta>
</syntaxhighlight>
Dans la balise ''<info />'', il y a le champ "type" qui indique si la ressource est un ''gamemode'' ou une ''map'', on y reviendra plus tard. Un gamemode est ce dont vous avez besoin pour que votre serveur est une base.

La balise ''<script />'' indique les scripts qui sont dans la ressource, que l'on va maintenant créer.
===Créer un script simple===
Notez que dans la balise ''<script />'', le fichier .lua n'est pas dans un autre sous-dossier. Donc on va créer notre script.lua au même endroit que notre meta.xml ( Reproduisez la même opération mais "Nom:" écrivez 'script' et pour "Type:" choisissez 'Lua(*.lua)' ) puis copier-coller le code suivant:
<syntaxhighlight lang="lua">
function joinHandler()
local x = 1959.55
local y = -1714.46
local z = 10
spawnPlayer(source, x, y, z)
fadeCamera(source, true)
setCameraTarget(source, source)
outputChatBox("Bienvenue sur mon serveur", source)
end
addEventHandler("onPlayerJoin", getRootElement(), joinHandler)
</syntaxhighlight>
Ce script va fous faire apparître aux coordonnées (x, y, z) spécifié dans le code, lorsque vous connecterez au serveur. La fonction ''fadeCamera'' sinon l'écran restera noir. Vous devez aussi dire à la camera de suivre le joueur grâce à la fonction 'setCameraTarget' (sinon il vera une mer bleu).

La variable '''source''' indique qui 'déclenche' la fonction. Le fonction se 'déclenche' lorsqu'un joueur rejoind le serveur, vous utiliserez cette variable pour voir qui à rejoind le serveur. Donc lorsque un joueur( "la source" ) rejoindra notre serveur, on le fera apparaître aux coordonnées indiquées .

Focalisons-nous sur [[addEventHandler]], vous pouvez voir 3 choses: 'onPlayerJoin', qui indique quand éxécuter la fonction X. getRootElement(), qui indique qui/quoi peut être déclencher la fonction (getRootElement() veut dire toutes les choses et tous les joueurs). Et enfin la fonction X à éxecuter ( ici joinHandler ). Pour les autres details, nous verrons plus tard dans d'autres exemples mais tout d'abord testons notre premier gamemode!

===Lancer le gamemode===
Pour lancer le serveur, lancer simplement le 'MTA Server.exe' qui se trouve dans votre dossier 'MTA San et\server'. Une liste d'info concernant le serveur apparaîtra en premier; notez le port du serveur ( 22003 par défaut ), vous en aurez besoin pour rejoindre le serveur. Après, le serveur charge toutes les ressources du dossier 'resource', et enfin "ready to accept connections!"

Avant de pouvoir vous connecter, vous devez lancer votre gamemode. Tapez "start myserver" et appuyer sur Entrer. Le serveur va alors lancer le gamemode que nous avons créé, et nous affichera aussi les erreurs s'il y en a. Maintenant, vous pouvez maintenant lancer MTA, cliquez sur "Quick Connect" et ecrivez ceci: Dans Host: le1er champ: 127.0.0.1 ou localhost ( cela signifie que vous vous connectez au serveur du pc actuel ) et le 2ème champ: le port ( ici 22003 ) et cliquez sur 'Connect'. Si tout se passe bien, après quelques secondes, vous devriez apparaître et pouvoir allez où vous voulez.

Ensuite nous allons créer une commande que les joueurs pourront utiliser pour faire apparître une voiture à coté d'eux.

==Créer une commande==
Revenons à l'intérieur de notre ''script.lua''. Tout d'abord, nous devons créer une fonction qu'on pourra appeler/éxécuter grâce à notre commande et la fonction 'addCommandHandler' afin de créer la commande que les joueurs pourront taper dans le chat( T ) ou la console( F8 ).

<syntaxhighlight lang="lua">
-- On crée la fonction qui sera appelée par notre commande avec les arguments: thePlayer, command, vehicleModel
function createVehicleForPlayer(thePlayer, commandName, vehicleModel)
-- Ici on crée le véhicule
end
-- on crée la commande et on l'attache à notre fonction
addCommandHandler("createVehicle", createVehicleForPlayer)
</syntaxhighlight>
''Note: Grâce au wiki, vous pouvez cliquer sur le nom des fonctions et cela vous redirigera sur la documentation de cette fonction.''

====A propos du addCommandHandler====
Le premier argument du [[addCommandHandler]] est le nom de la commande the player will be able to enter, le second le nom de la fonction à appeler, dans notre cas, ''createVehicleForPlayer''.

Si vous avez déjà de l'expérience dans le codage, vous savez qu'un fonction s'appelle comme ceci:
<syntaxhighlight lang="lua">
nomDeLaFonction(argument1, argument2, argument3, ..)
</syntaxhighlight>
Si l'on regarde bien l'exemple ci-dessus, nous pouvons voir que l'argument1 est thePlayer and argument2 le commandName. thePlayer est celui qui à tapé la commande et commandName contient le nom de la commande qu'il à tapé. Donc si un joueur tape "/greet", cet argument va contenir "greet". Argument3 c'est ce que le joueur à tapé en plus de la commande, vous allez apprendre ceci dans le tutoriel. N'oubliez jamais que les deux premiers arguments sont les arguments standards, mais vous pouvez les renommé si vous voulez, seul l'ordre est important.

Par exemple: Un joueur tape "createVehicle 468" pour faire aparaître une Sanchez, la fonction addCommandHandler va appeller notre fonction createVehicleForPlayer, comme ceci:
<syntaxhighlight lang="lua">
createVehicleForPlayer(thePlayer,"createVehicle","468") -- thePlayer est l'élement joueur qui a tapé la commande
</syntaxhighlight>
Comme nous pouvons le voir, ll fournit plusieurs paramètres: le joueur qui a tapé la commande, la commande qu'il a tapé, et n'importe quelle texte qu'il a mis après, dans notre cas, "468" comme id de la Sanchez. Les deux premiers paramètres sont les même pour tous les addCommandHandler qu'on peut retrouver sur la page du [[addEventHandler]]. Vous devez toujours définir au moins ces deux paramètres pour utiliser les arguments après eux (par exemple pour traiter le texte qui a été entré après la commande, comme dans notre exemple le modèle du véhicule).

''Note: Vous devez créer la commande APRES la fonction que vous allez utiliser pour cette commande, sinon il ne trouvera pas la fonction.''

====Ecrire la fonction====
Pour remplir notre fonction d'instructions, nous devons d'abord pensez à ce que nous devons faire:
* Récupérer la position du joueur, donc on connaitra la position où faire apparaître le véhicule (on veut le faire apparaître à droite du joueur)
* Calculer la position où faire apparître le véhicule (nous ne voulons pas que le véhicule apparaisse dans le joueur)
* Faire apparître les véhicule
* Vérifier si le véhicule a bien apparus, ou aficher un message d'erreur.

Pour ça, nous devons utiliser plusieurs fonctions. Pour trouver la fonction que nous devons utiliser, il faut aller faire un tour dans la [[Scripting Functions|La liste des fonctions serveur]]. D'abord nous avons besoin d'une fonction pour obtenir la position du joueur. Puisque les joueurs sont des éléments, nous devons allez dans la rubrique '''Element functions''' où l'on pourra trouver la fonction [[getElementPosition]]. En cliquant sur le nom de la fonction, le wiki va vous afficher sa description. On peut y voir la syntaxe, qu'est-ce que la fonction retourne. La syntaxe nous montre les argument qu'on peut ou qu'on doit envoyer.

Pour [[getElementPosition]], la syntaxe est:
<syntaxhighlight lang="lua">
float, float, float getElementPosition ( element theElement )
</syntaxhighlight>

Les trois float devant le nom de la fonction est le type de variable que la fonction nous retourne. Dans notre cas, la fonction retourne trois nombres à virgule(x, y et z). Dans les parenthèses, on peut voir les arguments que l'on doit envoyer, dans notre cas, l'element dont on veut récupérer la position, le joueur dans notre exemple.

<syntaxhighlight lang="lua">
function createVehicleForPlayer(thePlayer, command, vehicleModel)
-- on récupère la position x,y,z dans des variables locales
-- une variable locale n'existe que dans le "périmètre" actuel. Ici, les variable x, y et z sont des variables locales qui se détruiront à la fin de la fonction.
local x,y,z = getElementPosition(thePlayer)
end
</syntaxhighlight>

Ensuite, il faut s'assurer que le véhicule n'apparaît pas directement dans le joueur, donc on ajoute quelques unités à la variable ''x'', qui le fera apparaître plus à l'est par rapport au joueur.

<syntaxhighlight lang="lua">
function createVehicleForPlayer(thePlayer, command, vehicleModel)
local x,y,z = getElementPosition(thePlayer) -- On prent la position du joueur qui a tapé la commande
x = x + 5 -- on ajoute 5 unité sur l'axes des x
end
</syntaxhighlight>

Maintenant nous avons besoin d'une autre fonction, celle qui va faire apparaître le véhicule. Nous allons la cherché encore une fois dans la [[Scripting Functions|liste des fonctions serveur]], mais cette fois, comme nous parlons d'un véhicule, nous devons donc aller dans la catégorie'''Vehicle functions''', où l'on va trouver la fonction [[createVehicle]]. Dans la syntaxe, nous pouvons voir que cette fonction ne retourne qu'une seule variable, le véhicule ( de type élément ) que nous venons de créer. Nous pouvons aussi voir qu'il y a des arguments entre crochets [], cela veut dire que ce sont des arguments optionels.

Nous avons déjà tous les arguments pour la fonction [[createVehicle]] dans notre fonction: La position que nous avons juste calculée dans les variables "x, y, z" et l'id du véhicule que nous avons fourni par la commande ("/createVehicle 468") et qui est stocké dans la variable ''vehicleModel''.

<syntaxhighlight lang="lua">
function createVehicleForPlayer(thePlayer, command, vehicleModel)
local x,y,z = getElementPosition(thePlayer) -- récupere la position du joueur dans les variables x, y et z
x = x + 5 -- rajoute 5 unités sur x
-- on crée le véhicule et on enregistre l'élément de type "vehicle" dans la variable ''createdVehicle''
local createdVehicle = createVehicle(tonumber(vehicleModel),x,y,z)
end
</syntaxhighlight>

Avec cette variable, on pourrait faire pas mal de choses sympa, mais ici nous allons juste vérifier si le véhicule à bien été créé ou non.
Sur le wiki de la fonction [[createVehicle]], il y a la partie nomée '''Returns''', la fonction va retourner ''false'' si la voiture n'a pas été créé. Ducoups, on va regarder la valeur de la variable ''createdVehicle''.

Voilà notre code complet:
<syntaxhighlight lang="lua">
function createVehicleForPlayer(thePlayer, command, vehicleModel)
local x,y,z = getElementPosition(thePlayer) -- On prent la position du joueur qui a tapé la commande
x = x + 5 -- on ajoute 5 unités à x
local createdVehicle = createVehicle(tonumber(vehicleModel),x,y,z) -- on crée le véhicule demandé par le joueur et on récupère ce que nous retourne la fonction dans la variable createdVehicle
-- On vérifie si la valeur retournée est égal à ''false'' ( ce qui signifie que ça n'a pas marché )
if (createdVehicle == false) then
-- si c'est le cas, on affiche un message d'erreur dans la chatbox mais seulement pour le joueur.
outputChatBox("Erreur lors de la création du véhicule.",thePlayer)
end
end
addCommandHandler("createVehicle", createVehicleForPlayer)
</syntaxhighlight>

Comme vous pouvez le voir, nous avons utilisé une nouvelle fonction: [[outputChatBox]]. Vous devriez maintenant pouvoir regarder la description de cette fonction par vous même.

==Ce que vous devez savoir==
Vous avez déjà lu quelques informations sur les ressources, les commandes et trouvez des fonctions dans le wiki, mais il y a encore beaucoup à apprendre. Cette section vous donnera une vue d'ensemble plutôt courte sur certaines de ces choses, tout en regardant les pages du wiki si possible.
===Les scripts client et serveur===
Vous pouvez avoir déjà remarqué ces termes (serveur/client) quelque part sur ce wiki, le plus souvent pour les fonctions. MTA ne supporte pas seulement les scripts exécuté par le serveur et des commandes (comme celle qu'on vien de faire) ou d'autres fonctions, mais aussi les scripts éxécuté par le client MTA, ceux des joueurs qui se connecte au serveur. La raison est que certaines fonctions de MTA doit être du coté client comme par exemple le GUI - Graphical User Interface - ( Pour tout ce qui est fenêtres, boutons, etc ), d'autres devraient être du côté client parce qu'ils fonctionnent mieux mais d'autres sont mieux pensées pour être du côté serveur ou ne fonctionne tout simplement pas du côté client.

La plupart de vos scripts (gamemodes, maps) seront surement du côté serveur, comme celui que nous avons fait tout à l'heure. Si vous vous heurtez à quelque chose qui ne peut pas être résolu du côté serveur, vous devrez probablement le faire côté client. Pour un script client, vous devriez créer un script ordinaire (par exemple appelé ''client.lua'') et spécifié dans la meta.xml, comme ceci:
<syntaxhighlight lang="xml">
<script src="client.lua" type="client" />
</syntaxhighlight>
L'attribut ''type'' est par defaut 'server', donc nous avons juste besoin de spécifier que c'est un script client. Lorsque vous faites ceci, le fichier va être télecharger par le joueur sur son ordinateur lorsqu'il se connecte au serveur. Plus d'infos: [[Client side scripts]].

===Ressources plus complexes===
La section précédente nous a montré brièvement comment ajouter des scripts clients à la ressource. Penchons nous maintenant sur la ''meta.xml'' et ce qu'elle fait.

====First example - Un script utile====
<syntaxhighlight lang="xml">
/admin_commands
/meta.xml
/commands.lua
/client.lua
</syntaxhighlight>
<syntaxhighlight lang="xml">
<meta>
<info author="Someguy" description="admin commands" />
<script src="commands.lua" />
<script src="client.lua" type="client" />
</meta>
</syntaxhighlight>

* Le "commands.lua" fournit quelques commandes d'admin, comme le fait d'interdire un joueur, en banissant ou quelque chose d'autre ce qui peut être utilisé par l'admin du serveur
* Le "client.lua" fournit un GUI pour être capable d'exécuter les actions mentionnées facilement

Cet exemple de script doit tourner tout le temps (peut être même démarré en même temps que le serveur) car ces commandes d'admin peuvent être appelé à n'importe quelle moment.

====Second example - Un gamemode====
<syntaxhighlight lang="xml">
/counterstrike
/meta.xml
/counterstrike.lua
/buymenu.lua
</syntaxhighlight>
<syntaxhighlight lang="xml">
<meta>
<info author="Quelqu'un" description="Counterstrike remake" type="gamemode" />
<script src="counterstrike.lua" />
<script src="buymenu.lua" type="client" />
</meta>
</syntaxhighlight>

* Le "counterstrike.lua" contient des caractéristiques semblables aux dispositifs suivants :
** Laisser les joueurs choisirent leur équipe et les faire apparaître
** Leur fournir des armes, des cibles et des instructions (peut-être lues d'une carte, voir ci-dessous)
** Définir les règles du jeu, par exemple. La partie se finie, ce qui se produit quand un joueur meurt
** .. et peut-être encore plus
* Le "buymenu.lua" est un script du côté client et crée un menu pour acheter des armes

Cet exemple peut s'appeler un gamemode, il modifie le gameplay, mais définit réellement les règles de celui-ci. Le "type" attribut indique que cet exemple fonctionne avec [[Map Manager]], encore une autre ressource qui a été écrite par l'équipe de MTA pour contrôler des gamemodes et le chargement de cartes. On recommande fortement que vous basiez vos gamemodes sur les techniques qu'il fournit.

Ceci signifie également que ce gamemode ne fonctionnera probablement pas sans carte. Les gamemodes devront toujours être aussi génériques que possible. Un exemple de gamemode utilisant une carte est énoncé dans le prochain exemple.

====Troisième exemple - Une carte====
<syntaxhighlight lang="xml">
/cs-airport
/meta.xml
/airport.map
/airport.lua
</syntaxhighlight>
<syntaxhighlight lang="xml">
<meta>
<info author="Quelqu'un" description="Counterstrike airport map" type="map" gamemodes="counterstrike" />
<map src="airport.map" />
<script src="airport.lua" />
</meta>
</syntaxhighlight>

* Le "airport.map" dans le fichier XML fournit des informations au sujet de la carte au gamemode, ceului-ci peut inclure :
** Là où les joueurs devraient apparaitre, avec quelles armes, avec quelle équipe
** Ce qui sont les cibles
** Temps, heure du monde, Limite de temps
** Fournir les véhicules
* Le ''airport.lua'' peut contenir des actions relatifs a la map comme:
** Ouvrir une certaine porte ou faire éxploser quelque chose quand une autre chose de spécifique se produit
** Créer ou déplacer quelques objets faits sur commande, ou manoeuvrez les objets qui sont créés dans le fichier .map
** .. toutes autre choses relatifs aux ojets du .map

Comme vous pouvez le voir, l'attribut "type" a été changé en 'map', pour dire au [[Map Manager]] que cette ressource est une carte, tandis que l'attribut "gamemodes" indique pour quels gamemodes cette carte est valide, dans ce cas-ci le gamemode de l'exemple de tout à l'heure.
Ce qui peut venir comme une surprise est qu'il y a aussi un script dans la ressource de carte. Évidemment ce n'est pas nécessaire dans une carte, mais ouvre une large gamme de possibilités pour les créateurs de cartes.

Le "airport.map" pourrait être semblable à ceci :
<syntaxhighlight lang="xml">
<map mode="deathmatch" version="1.0">
<terrorists>
<spawnpoint posX="2332.23" posY="-12232.33" posZ="4.42223" skins="23-40" />
</terrorists>
<counterterrorists>
<spawnpoint posX="2334.23443" posY="-12300.233" posZ="10.2344" skins="40-50" />
</counterterrorists>

<bomb posX="23342.23" posY="" posZ="" />

<vehicle posX="" posY="" posZ="" model="602" />
<vehicle posX="" posY="" posZ="" model="603" />
</map>
</syntaxhighlight>

Quand un gamemode est commencé avec une carte, les ressources de carte est automatiquement démaré par le mapmanager et les renseignements qu'il contient peut être lu par le gamemode. Quand la carte change, la ressource de carte actuelle est arrêtée et la ressource de carte suivante est commencée. Pour une explication plus détaillée et des exemples pour savoit comment les ressources de cartes sont utilisées dans le script principal, visitez s'il vous plaît la page [[Writing Gamemodes]].

===Événements===
Les événements sont la façon que MTA dit aux scripts des choses qui arrivent. Par exemple quand un joueur meurt, le [[onPlayerWasted]] l'événement est déclenché. Pour exécuter n'importe quelles actions quand un joueur meurt, vous devez vous préparer similiar à l'ajoutant d'un dresseur d'ordre, comme montré dans [[#Writing_the_script|the first chapter]].

Cet exemple produiras un message avec le nom du joueur qui est mort :
<syntaxhighlight lang="lua">
function playerDied(totalAmmo, killer, killerWeapon, bodypart)
outputChatBox(getPlayerName(source).." died!")
end
addEventHandler("onPlayerWasted",getRootElement(),playerDied)
</syntaxhighlight>

Au lieu de montrer que les arguments sont nécessaires, la page de documentation pour les spectacles d'Événements quels paramètres sont passés à la handler function, similaire à la voie un [[*About_command_handlers|command handler]] fait, juste qu'il se distingue de l'événement à l'événement. Un autre point important est la variable "source", qui existe dans les handler function. Ils ne doivent pas être ajoutés à la liste de paramètre de la fonction, mais cela existe toujours . Il a une différente valeur de l'événement à l'événement, pour les événements de joueur (comme dans l'exemple au-dessus) c'est l'élément de joueur. Comme un autre exemple, vous pouvez jeter un coup d'œil au script de joueur frayant fondamental dans la première section pour recevoir une idée comment "source" est utilisé.

==Où aller d'ici==
Vous devriez maintenant être familiers avec les aspects les plus fondamentaux de MTA scripting et aussi un peu avec la documentation. Le [[Main_Page]] vous fournit des liens vers plus de renseignements, Classes de travaux dirigés et Références qui permettent un coup d'oeil plus profond dans les thèmes dont vous désirez apprendre.

D'ici nous recommandons de lire le [[debugging]] la classe de travaux dirigés. De bonnes adresses déboguantes sont une nécessité absolue quand vous faites des scripts.

[[ru:Scripting Introduction]]
[[it:Introduzione allo scripting]]
[[es:Introducción a la Programación]]

Page d'accueil

2012-08-30T20:28:55Z

Citizen: Introduction a la programation terminée

<div style="background: #FFEEAA; padding: 5px; float:right; width: 30%;">Dernière version stable de '''Multi Theft Auto: San Andreas''' est '''{{Current Version|full}}'''. Rendez-vous sur la [http://mtasa.com/ page principale] pour la télécharger.
<p>
Vous pouvez aussi télécharger une [http://nightly.mtasa.com/ beta] pour avoir la dernière version ( non stable ).
</p>
</div>
__NOTOC__
Bienvenue sur le wiki de Multi Theft Auto. Sur ce wiki, vous trouverez toutes les informations sur Multi Theft Auto.

Il y a [[How you can help|différents moyens de nous aider]]: créer une map, un gamemode, rediger des articles sur des fonctions, écrire un exemple, écrire un tutorial ou juste jouer à MTA et nous rapportez les bugs trouvés.

<div style="clear:both;"></div>
{| width="100%" cellspacing="0" cellpadding="0"
| colspan="2" |

|-
| width="50%" style="vertical-align:top;" |
<div style="border: 1px dotted #AAAAAA;padding:4px 8px 8px 8px;margin:10px;">
====Pour commencer====

* [[FR/Manuel_Client|Manuel Client]] ( Traduction: [http://wiki.multitheftauto.com/wiki/User:DrawKiie DrawKiie] )
* [[FR/Manuel_Serveur|Manuel Serveur]] ( Traduction: [http://wiki.multitheftauto.com/wiki/User:Rouche Rouche] )
* [[FR/Problemes_connus|Problèmes connus]] ( Traduction: [http://wiki.multitheftauto.com/wiki/User:Rouche Rouche] )
* [[FR/Migrer_de_MTARace_a_MTASA_1.0.x|Migrer de MTA:Race à MTA:SA 1.0.x]] ( Traduction: [http://wiki.multitheftauto.com/wiki/User:Rouche Rouche] )
* [[FR/A propos des Map|A propos des Map]] ( Traduction: [http://wiki.multitheftauto.com/wiki/User:Rouche Rouche] )

</div>

<div style="border: 1px dotted #AAAAAA;padding:4px 8px 8px 8px;margin:10px;">

====Programmer====

* [[FR/Introduction_Programmation|Introduction: La programmation]]
* [[FR/Introduction_GUI|Introduction: Le GUI]] ( Traduction: [http://wiki.multitheftauto.com/wiki/User:FatalTeror FatalTerror] )
* [[FR/Debugage|Tutoriel: Le débugage]] - Comment trouver les erreurs dans son script (Traduction:[http://wiki.multitheftauto.com/wiki/User:Vincenzo Vincenzo] alias Vincentdu90)
* [[FR/Ressources|Introduction: Les ressources]] (Traduction : [http://wiki.multitheftauto.com/wiki/User:Myk3L Myk3L])
** [[FR/Ressource_Acces_Internet|Introduction: L'accès depuis internet]] - Comment créer un site à partir d'une ressource (Traduction : [http://wiki.multitheftauto.com/wiki/User:Myk3L Myk3L])
** [[:Category:Resource|Catalogue des ressources]]
** [[FR/Meta.xml|Meta.xml]] - Derière chaque ressource ce trouve une meta pour la définir
** [[FR/ACL|ACL]] - Access Control List, pour définir les autorisations
* [[FR/Ecrire_Gamemode|Créer un gamemode]]
* [[FR/Fonctions_Utiles|Fonctions Utiles]]

</div>

<div style="border: 1px dotted #AAAAAA;padding:4px 8px 8px 8px;margin:10px;">

====Bases de données====
Cette section décrit toutes les capacités fournies par le LUA/MTA ou par les ressources.
* [[:Category:Resource|Catalogue des ressources]] - Vous devriez le lire pour réaliser un script approprié.
* [[FR/Les_scripts_clients| Les scripts clients]]
</div>
<div style="border: 1px dotted #AAAAAA;padding:4px 8px 8px 8px;margin:10px;">

====Aide générale du LUA====
Des pages conçues pour aider votre compréhension du Lua
*[http://www.lua.org/pil/index.html "Programming in Lua"]
**[http://www.lua.org/manual/5.1/#index Les fonctions Lua]
*[http://lua-users.org/wiki/TutorialDirectory wiki Lua]
*[http://nixstaller.berlios.de/manual/0.2/nixstaller_9.html Un guide général au Lua de Nixstaller]
</div>

| width="50%" style="vertical-align:top;" |
<div style="border: 1px dotted #AAAAAA;padding:4px 8px 8px 8px;margin:10px;">

====Map Editor====
*[[Resource:Editor|Manuel]]
*[[Resource:Editor/EDF|Editor Definition Format]]
*[[Resource:Editor/Plugins|Plugins]]
*[[Resource:Editor#FAQ|Questions Fréquentes]]
</div>

<div style="border: 1px dotted #AAAAAA;padding:4px 8px 8px 8px;margin:10px;">

====Développer Multi Theft Auto====
* [[FR/Compiler_MTASA|Compiler MTASA sur Windows]]
* [[FR/Compiler_MTASA_Server_sur_Mac_OS_X|Compiler MTASA sur Mac OS X]]
* [[FR/Compiler_MTASA_Server_sur_GNU_Linux|Compiler MTASA sur GNU/Linux]]
* [[FR/Directives_de_codage|Directives de codage]]
* [http://code.google.com/p/mtasa-blue Google Code SVN]
* [[FR/Roadmap|Roadmap]]
</div>

<div style="border: 1px dotted #AAAAAA;padding:4px 8px 8px 8px;margin:10px; background:#CCCCFF;">

====Références====
* [[FR/Fonctions_Clients|Fonctions Clients]]
* [[FR/Events_Clients|Events Clients]]
* [[FR/Fonctions_Serveurs|Fonctions Clients]]
* [[FR/Events_Serveurs|Events Clients]]

* [[FR/MTA Classes|MTA Classes]] - Les descriptions détaillées de tous les types personnalisés MTA
** [[FR/Element|MTA Elements]] / [[Element tree]]
</div>

<div style="border: 1px dotted #AAAAAA;padding:4px 8px 8px 8px;margin:10px;">

====[[Id|ID Listes]]====
*[[FR/Animations|Animations]]
*[[FR/Skins_Personnages|Skins Personnages]]
*[[FR/Vetements_CJ|Vêtements CJ]]
*[[FR/Garage|Garage IDs]]
*[[FR/Interieurs_IDs|Intérieurs IDs]]
*[[FR/Materiel_IDs|Matériel IDs]]
*[[FR/Projectiles|Projectiles]]
*[[FR/Radar Blips|Radar Blips]]
*[[FR/Sons|Sons]]
*[[FR/Vehicule_IDs|ID des véhicules]]
*[[FR/Vehicule_Couleurs|Couleurs véhicules]]
*[[FR/Vehicule_Upgrades|Tuning IDs]]
*[[FR/Armes|Armes]]
*[[FR/Meteos|Météos]]
</div>

|-
| colspan="2" |
|}
{{Languages list|fr}}

CreateVehicle

2012-07-27T21:51:00Z

Citizen: Added a "Needs_Checking" for the numberplates which have to contain at least 1 letter

{{Needs_Checking|Numberplates only seem to work for some vehicles, and then only for the front or rear plate only}}
{{Needs_Checking|Explain the direction parameter which should always be false and what is the point of having a parameter whose value need to be the same all the time. --[[User:MTA SE|MTA SE]] 20:05, 5 July 2012 (UTC)}}
{{Needs_Checking|The numberplates have to contain at least 1 letter. For example "132" will not work and the function will fail but, "13A" or "132A" will work}}
__NOTOC__
{{Server client function}}
{{note_box|Vehicles (and other elements) created client-side are only seen by the client that created them, aren't synced and players cannot enter them. They are essentially for display only.}}
This function creates a vehicle at the specified location.

Its worth noting that the position of the vehicle is the center point of the vehicle, not its base. As such, you need to ensure that the z value (vertical axis) is some height above the ground. You can find the exact height using the client side function [[getElementDistanceFromCentreOfMassToBaseOfModel]], or you can estimate it yourself and just spawn the vehicle so it drops to the ground.

==Syntax==
<syntaxhighlight lang="lua">
vehicle createVehicle ( int model, float x, float y, float z [, float rx, float ry, float rz, string numberplate, bool bDirection, int variant1, int variant2 ] )
</syntaxhighlight>

===Required Arguments===
* '''model''': The [[Vehicle IDs|vehicle ID]] of the vehicle being created.
* '''x''': A floating point number representing the X coordinate on the map.
* '''y''': A floating point number representing the Y coordinate on the map.
* '''z''': A floating point number representing the Z coordinate on the map.

===Optional Arguments===
{{OptionalArg}}
* '''rx''': A floating point number representing the rotation about the X axis in degrees.
* '''ry''': A floating point number representing the rotation about the Y axis in degrees.
* '''rz''': A floating point number representing the rotation about the Z axis in degrees.
* '''numberplate''': A string that will go on the number plate of the car (max 8 characters). This is only applicable to cars.
* '''direction''': A boolean which should be set to false. *SERVER ONLY*
{{New feature/item|3.0120|1.2||
* '''variant1''': An integer for the first vehicle variant see [[Vehicle variants]]
* '''variant2''': An integer for the second vehicle variant see [[Vehicle variants]]
}}

===Returns===
Returns the [[vehicle]] element that was created. Returns ''false'' if the arguments are incorrect, or if the vehicle limit of 65535 is exceeded.

==Using trains==
Trains are created using the createVehicle function. They are placed at the nearest point of the GTASA train pathing (railroad tracks) from their spawning point.

==Example==
<section name="Example 1: Server" class="server" show="true">
This script spawns a Rhino on top of one lucky individual.
<syntaxhighlight lang="lua">
function scriptCreateTank ( player, command )
local luckyBugger = getRandomPlayer() -- get a random player
local x, y, z = getElementPosition ( luckyBugger ) -- retrive the player's position
createVehicle ( 432, x, y, z + 10 ) -- create the tank 10 units above them
outputChatBox ( "You got Tank'd!", luckyBugger )
end
--Attach the 'scriptCreateTank' function to the "tank" command
addCommandHandler ( "tank", scriptCreateTank )
</syntaxhighlight>
</section>

<section name="Example 2: Client" class="client" show="true">
This script spawns a Rhino on top of the local player.
<syntaxhighlight lang="lua">
function scriptCreateTank ( commandName )
local luckyBugger = getLocalPlayer() -- get the local player
local x, y, z = getElementPosition ( luckyBugger ) -- retrive the player's position
createVehicle ( 432, x, y, z + 10 ) -- create the tank 10 units above them
outputChatBox ( "You got Tank'd!", 255, 0, 0)
end
--Attach the 'scriptCreateTank' function to the "tank" command
addCommandHandler ( "tank", scriptCreateTank )
</syntaxhighlight>
</section>

<section name="Example 3: Server" class="server" show="true">
This example creates a vehicle five units to the right of a player when they type ''createvehicle'' and its name in the console:
<syntaxhighlight lang="lua">
local distance = 5 --units

-- define our handler (we'll take a variable number of parameters where the name goes, because there are vehicle names with more than one word)
function consoleCreateVehicle ( sourcePlayer, commandName, ... )
-- if a player triggered it, not the admin,
if ( sourcePlayer ) then
-- calculate the position of the vehicle based on the player's position and rotation:
local x, y, z = getElementPosition ( sourcePlayer ) -- get the player's position
local rotZ = getPedRotation ( sourcePlayer ) -- get the player's rotation around the Z axis in degrees
x = x + ( ( math.cos ( math.rad ( rotZ ) ) ) * distance ) -- calculate the X position of the vehicle
y = y + ( ( math.sin ( math.rad ( rotZ ) ) ) * distance ) -- calculate the Y position of the vehicle

-- get the complete vehicle name by joining all passed parameters using Lua function table.concat
local vehicleName = table.concat({...}, " ")
-- get the vehicle's model ID from the name
local vehicleID = getVehicleModelFromName ( vehicleName )
-- if vehicle ID is valid,
if vehicleID then
-- create the vehicle using the information gathered above:
local newVehicle = createVehicle ( vehicleID, x, y, z, 0, 0, rotZ )
-- if vehicle creation failed, give the player a message
if not newVehicle then
outputConsole ( "Failed to create vehicle.", sourcePlayer )
end
end
end
end

-- Attach the 'consoleCreateVehicle' function to the "createvehicle" command
addCommandHandler ( "createvehicle", consoleCreateVehicle )
</syntaxhighlight>
</section>

==See Also==

{{Vehicle functions}}

FR/Introduction Programmation

2012-06-30T08:23:52Z

Citizen: /* Troisième exemple - Une carte */

Les ressources sont les parties clées de MTA. Une ressource est un dossier ou un .zip qui contient plusieurs fichiers, ainsi qu'une meta qui dit au serveur comment la resource doit-elle être chargée. Une ressource peut être comparée comme un programme qu'on peut lancer ou arrêter, il est possible de lancer plusieurs ressources en même temps.

Tout ce qui a un rapport avec la programmation se passe dans les ressources, se que fait la ressource, définie si c'est un gamemode, une map or quelquechose d'autre. MTA s'installe avec des resources que vous pouvez facultativement utiliser dans vos gamemodes, comme la ressource "maplimits" pour garder les joueurs dans une certaine zone ou encore "deathpickups" pour créer des pickups pour ramasser une arme.

'''La première chose à faire avant de pouvoir programmer en lua, c'est de se procurer un editeur de texte qui supporte le lua. Il vous sera beaucoups plus facile que de le faire avec le bloc-note de Windows. Nous vous recommendons donc [http://notepad-plus.sourceforge.net/uk/site.htm Notepad++] ou [http://luaedit.sourceforge.net/ LuaEdit]. Il y a aussi un logiciel non officiel [[MTASE|MTA Script Editor]] ( malheureusement l'auteur ne travail plus dessus ) que vous pouvez tester.'''

==Créer un script qui fonctionne==
Nous allons voir tout d'abord comment créer un simple script étapes par étapes qui permetra aux joueurs de se deplacer dans la ville. Dans ce tutoriel, on utilisera notepadd++.
===Où sont tous les scripts ?===
Laissez moi d'abord vous présenter comment s'oranise une ressource. Allez dans votre dossier MTA San et et suivez le chemin suivant:

/serveur/mods/deathmatch/resources/

Vous y verez de nombreux fichier avec l'extension .zip, se sont des ressources avec à l'intérieur des exemples de scripts . Toutes les ressources chargées sont dézippé par le serveur afin de pouvoir les exécuter ( les .zip ne sont pas obligatiores, vous pouvez aussi laissez votre ressource en tant que dossier ). Pour créer votre propre ressource, créez simplement un nouveau dossier et nommez le comme vous voulez ( Ne pas utiliser d'espace, utilisez plutôt un _ ) . Nommez le "myserveur" pour ce tutoriel.

Maintenant entrez dans votre dossier. Le chemain devrait donc être

/serveur/mods/deathmatch/resources/myserveur/

===Identifier votre ressource===
Pour que le serveur puisse savoir ce que contient votre ressource, un fichier ''meta.xml'' doit être créé afin d'établir une liste du contenu du dossier. Cette 'meta.xml' doit être à la racine de votre ressource ( et non pas dans un autre sous-dossier ), donc dans le dossier "myserveur" dans notre cas. Donc ouvrez notepadd++, créer un nouveau fichier (Ctrl+N), puis faite "Enregistrez sous ..." (Ctrl+Alt+S), dans "Nom:" vous écrivez "meta" et dans "Type:", sélectionnez "*.xml" ( avant-dernier de la liste ), sauvegardez le dans votre dossier "myserveur".

Maintenant, ecrivez le code suivant dans votre ''meta.xml'':
<syntaxhighlight lang="xml">
<meta>
<info author="Votre Nom" type="gamemode" name="Mon serveur" description="Mon premier serveur MTA" />
<script src="script.lua" />
</meta>
</syntaxhighlight>
Dans la balise ''<info />'', il y a le champ "type" qui indique si la ressource est un ''gamemode'' ou une ''map'', on y reviendra plus tard. Un gamemode est ce dont vous avez besoin pour que votre serveur est une base.

La balise ''<script />'' indique les scripts qui sont dans la ressource, que l'on va maintenant créer.
===Créer un script simple===
Notez que dans la balise ''<script />'', le fichier .lua n'est pas dans un autre sous-dossier. Donc on va créer notre script.lua au même endroit que notre meta.xml ( Reproduisez la même opération mais "Nom:" écrivez 'script' et pour "Type:" choisissez 'Lua(*.lua)' ) puis copier-coller le code suivant:
<syntaxhighlight lang="lua">
function joinHandler()
local x = 1959.55
local y = -1714.46
local z = 10
spawnPlayer(source, x, y, z)
fadeCamera(source, true)
setCameraTarget(source, source)
outputChatBox("Bienvenue sur mon serveur", source)
end
addEventHandler("onPlayerJoin", getRootElement(), joinHandler)
</syntaxhighlight>
Ce script va fous faire apparître aux coordonnées (x, y, z) spécifié dans le code, lorsque vous connecterez au serveur. La fonction ''fadeCamera'' sinon l'écran restera noir. Vous devez aussi dire à la camera de suivre le joueur grâce à la fonction 'setCameraTarget' (sinon il vera une mer bleu).

La variable '''source''' indique qui 'déclenche' la fonction. Le fonction se 'déclenche' lorsqu'un joueur rejoind le serveur, vous utiliserez cette variable pour voir qui à rejoind le serveur. Donc lorsque un joueur( "la source" ) rejoindra notre serveur, on le fera apparaître aux coordonnées indiquées .

Focalisons-nous sur [[addEventHandler]], vous pouver voir 3 choses: 'onPlayerJoin', qui indique quand éxécuter la fonction X. getRootElement(), qui indique qui/quoi peut être déclencher la fonction (getRootElement() veut dire toutes les choses et tous les joueurs). Et enfin la fonction X à éxecuter ( ici joinHandler ). Pour les autres details, nous verrons plus tard dans d'autres exemples mais tout d'abord testons notre premier gamemode!

===Lancer le gamemode===
Pour lancer le serveur, lancer simplement le 'MTA Server.exe' qui se trouve dans votre dossier 'MTA San et\server'. Une liste d'info concernant le serveur apparaîtra en premier; notez le port du serveur ( 22003 par défaut ), vous en aurez besoin pour rejoindre le serveur. Après, le serveur charge toutes les ressources du dossier 'resource', et enfin "ready to accept connections!"

Avant de pouvoir vous connecter, vous devez lancer votre gamemode. Tapez "start myserver" et appuyer sur Entrer. Le serveur va alors lancer le gamemode que nous avons créé, et nous affichera aussi les erreurs s'il y en a. Maintenant, vous pouvez maintenant lancer MTA, cliquez sur "Quick Connect" et ecrivez ceci: Dans Host: le1er champ: 127.0.0.1 ou localhost ( cela signifie que vous vous connectez au serveur du pc actuel ) et le 2ème champ: le port ( ici 22003 ) et cliquez sur 'Connect'. Si tout se passe bien, après quelques secondes, vous devriez apparaître et pouvoir allez où vous voulez.

Ensuite nous allons créer une commande que les joueurs pourront utiliser pour faire apparître une voiture à coté d'eux.

==Créer une commande==
Revenons à l'intérieur de notre ''script.lua''. Tout d'abord, nous devons créer une fonction qu'on pourra appeler/éxécuter grâce à notre commande et la fonction 'addCommandHandler' afin de créer la commande que les joueurs pourront taper dans le chat( T ) ou la console( F8 ).

<syntaxhighlight lang="lua">
-- On crée la fonction qui sera appelée par notre commande avec les arguments: thePlayer, command, vehicleModel
function createVehicleForPlayer(thePlayer, commandName, vehicleModel)
-- Ici on crée le véhicule
end
-- on crée la commande et on l'attache à notre fonction
addCommandHandler("createVehicle", createVehicleForPlayer)
</syntaxhighlight>
''Note: Grâce au wiki, vous pouvez cliquer sur le nom des fonctions et cela vous redirigera sur la documentation de cette fonction.''

====A propos du addCommandHandler====
Le premier argument du [[addCommandHandler]] est le nom de la commande the player will be able to enter, le second le nom de la fonction à appeler, dans notre cas, ''createVehicleForPlayer''.

Si vous avez déjà de l'expérience dans le codage, vous savez qu'un fonction s'appelle comme ceci:
<syntaxhighlight lang="lua">
nomDeLaFonction(argument1, argument2, argument3, ..)
</syntaxhighlight>
Si l'on regarde bien l'exemple ci-dessus, nous pouvons voir que l'argument1 est thePlayer and argument2 le commandName. thePlayer est celui qui à tapé la commande et commandName contient le nom de la commande qu'il à tapé. Donc si un joueur tape "/greet", cet argument va contenir "greet". Argument3 c'est ce que le joueur à tapé en plus de la commande, vous allez apprendre ceci dans le tutoriel. N'oubliez jamais que les deux premiers arguments sont les arguments standards, mais vous pouvez les renommé si vous voulez, seul l'ordre est important.

Par exemple: Un joueur tape "createVehicle 468" pour faire aparaître une Sanchez, la fonction addCommandHandler va appeller notre fonction createVehicleForPlayer, comme ceci:
<syntaxhighlight lang="lua">
createVehicleForPlayer(thePlayer,"createVehicle","468") -- thePlayer est l'élement joueur qui a tapé la commande
</syntaxhighlight>
Comme nous pouvons le voir, ll fournit plusieurs paramètres: le joueur qui a tapé la commande, la commande qu'il a tapé, et n'importe quelle texte qu'il a mis après, dans notre cas, "468" comme id de la Sanchez. Les deux premiers paramètres sont les même pour tous les addCommandHandler qu'on peut retrouver sur la page du [[addEventHandler]]. Vous devez toujours définir au moins ces deux paramètres pour utiliser les arguments après eux (par exemple pour traiter le texte qui a été entré après la commande, comme dans notre exemple le modèle du véhicule).

''Note: Vous devez créer la commande APRES la fonction que vous allez utiliser pour cette commande, sinon il ne trouvera pas la fonction.''

====Ecrire la fonction====
Pour remplir notre fonction d'instructions, nous devons d'abord pensez à ce que nous devons faire:
* Récupérer la position du joueur, donc on connaitra la position où faire apparaître le véhicule (on veut le faire apparaître à droite du joueur)
* Calculer la position où faire apparître le véhicule (nous ne voulons pas que le véhicule apparaisse dans le joueur)
* Faire apparître les véhicule
* Vérifier si le véhicule a bien apparus, ou aficher un message d'erreur.

Pour ça, nous devons utiliser plusieurs fonctions. Pour trouver la fonction que nous devons utiliser, il faut aller faire un tour dans la [[Scripting Functions|La liste des fonctions serveur]]. D'abord nous avons besoin d'une fonction pour obtenir la position du joueur. Puisque les joueurs sont des éléments, nous devons allez dans la rubrique '''Element functions''' où l'on pourra trouver la fonction [[getElementPosition]]. En cliquant sur le nom de la fonction, le wiki va vous afficher sa description. On peut y voir la syntaxe, qu'est-ce que la fonction retourne. La syntaxe nous montre les argument qu'on peut ou qu'on doit envoyer.

Pour [[getElementPosition]], la syntaxe est:
<syntaxhighlight lang="lua">
float, float, float getElementPosition ( element theElement )
</syntaxhighlight>

Les trois float devant le nom de la fonction est le type de variable que la fonction nous retourne. Dans notre cas, la fonction retourne trois nombres à virgule(x, y et z). Dans les parenthèses, on peut voir les arguments que l'on doit envoyer, dans notre cas, l'element dont on veut récupérer la position, le joueur dans notre exemple.

<syntaxhighlight lang="lua">
function createVehicleForPlayer(thePlayer, command, vehicleModel)
-- on récupère la position x,y,z dans des variables locales
-- une variable locale n'existe que dans le "périmètre" actuel. Ici, les variable x, y et z sont des variables locales qui se détruiront à la fin de la fonction.
local x,y,z = getElementPosition(thePlayer)
end
</syntaxhighlight>

Ensuite, il faut s'assurer que le véhicule n'apparaît pas directement dans le joueur, donc on ajoute quelques unités à la variable ''x'', qui le fera apparaître plus à l'est par rapport au joueur.

<syntaxhighlight lang="lua">
function createVehicleForPlayer(thePlayer, command, vehicleModel)
local x,y,z = getElementPosition(thePlayer) -- On prent la position du joueur qui a tapé la commande
x = x + 5 -- on ajoute 5 unité sur l'axes des x
end
</syntaxhighlight>

Maintenant nous avons besoin d'une autre fonction, celle qui va faire apparaître le véhicule. Nous allons la cherché encore une fois dans la [[Scripting Functions|liste des fonctions serveur]], mais cette fois, comme nous parlons d'un véhicule, nous devons donc aller dans la catégorie'''Vehicle functions''', où l'on va trouver la fonction [[createVehicle]]. Dans la syntaxe, nous pouvons voir que cette fonction ne retourne qu'une seule variable, le véhicule ( de type élément ) que nous venons de créer. Nous pouvons aussi voir qu'il y a des arguments entre crochets [], cela veut dire que ce sont des arguments optionels.

Nous avons déjà tous les arguments pour la fonction [[createVehicle]] dans notre fonction: La position que nous avons juste calculée dans les variables "x, y, z" et l'id du véhicule que nous avons fourni par la commande ("/createVehicle 468") et qui est stocké dans la variable ''vehicleModel''.

<syntaxhighlight lang="lua">
function createVehicleForPlayer(thePlayer, command, vehicleModel)
local x,y,z = getElementPosition(thePlayer) -- récupere la position du joueur dans les variables x, y et z
x = x + 5 -- rajoute 5 unités sur x
-- on crée le véhicule et on enregistre l'élément de type "vehicle" dans la variable ''createdVehicle''
local createdVehicle = createVehicle(tonumber(vehicleModel),x,y,z)
end
</syntaxhighlight>

Avec cette variable, on pourrait faire pas mal de choses sympa, mais ici nous allons juste vérifier si le véhicule à bien été créé ou non.
Sur le wiki de la fonction [[createVehicle]], il y a la partie nomée '''Returns''', la fonction va retourner ''false'' si la voiture n'a pas été créé. Ducoups, on va regarder la valeur de la variable ''createdVehicle''.

Voilà notre code complet:
<syntaxhighlight lang="lua">
function createVehicleForPlayer(thePlayer, command, vehicleModel)
local x,y,z = getElementPosition(thePlayer) -- On prent la position du joueur qui a tapé la commande
x = x + 5 -- on ajoute 5 unités à x
local createdVehicle = createVehicle(tonumber(vehicleModel),x,y,z) -- on crée le véhicule demandé par le joueur et on récupère ce que nous retourne la fonction dans la variable createdVehicle
-- On vérifie si la valeur retournée est égal à ''false'' ( ce qui signifie que ça n'a pas marché )
if (createdVehicle == false) then
-- si c'est le cas, on affiche un message d'erreur dans la chatbox mais seulement pour le joueur.
outputChatBox("Erreur lors de la création du véhicule.",thePlayer)
end
end
addCommandHandler("createVehicle", createVehicleForPlayer)
</syntaxhighlight>

Comme vous pouvez le voir, nous avons utilisé une nouvelle fonction: [[outputChatBox]]. Vous devriez maintenant pouvoir regarder la description de cette fonction par vous même.

==Ce que vous devez savoir==
Vous avez déjà lu quelques informations sur les ressources, les commandes et trouvez des fonctions dans le wiki, mais il y a encore beaucoup à apprendre. Cette section vous donnera une vue d'ensemble plutôt courte sur certaines de ces choses, tout en regardant les pages du wiki si possible.
===Les scripts client et serveur===
Vous pouvez avoir déjà remarqué ces termes (serveur/client) quelque part sur ce wiki, le plus souvent pour les fonctions. MTA ne supporte pas seulement les scripts exécuté par le serveur et des commandes (comme celle qu'on vien de faire) ou d'autres fonctions, mais aussi les scripts éxécuté par le client MTA, ceux des joueurs qui se connecte au serveur. La raison est que certaines fonctions de MTA doit être du coté client comme par exemple le GUI - Graphical User Interface - ( Pour tout ce qui est fenêtres, boutons, etc ), d'autres devraient être du côté client parce qu'ils fonctionnent mieux mais d'autres sont mieux pensées pour être du côté serveur ou ne fonctionne tout simplement pas du côté client.

La plupart de vos scripts (gamemodes, maps) seront surement du côté serveur, comme celui que nous avons fait tout à l'heure. Si vous vous heurtez à quelque chose qui ne peut pas être résolu du côté serveur, vous devrez probablement le faire côté client. Pour un script client, vous devriez créer un script ordinaire (par exemple appelé ''client.lua'') et spécifié dans la meta.xml, comme ceci:
<syntaxhighlight lang="xml">
<script src="client.lua" type="client" />
</syntaxhighlight>
L'attribut ''type'' est par defaut 'server', donc nous avons juste besoin de spécifier que c'est un script client. Lorsque vous faites ceci, le fichier va être télecharger par le joueur sur son ordinateur lorsqu'il se connecte au serveur. Plus d'infos: [[Client side scripts]].

===Ressources plus complexes===
La section précédente nous a montré brièvement comment ajouter des scripts clients à la ressource. Penchons nous maintenant sur la ''meta.xml'' et ce qu'elle fait.

====First example - Un script utile====
<syntaxhighlight lang="xml">
/admin_commands
/meta.xml
/commands.lua
/client.lua
</syntaxhighlight>
<syntaxhighlight lang="xml">
<meta>
<info author="Someguy" description="admin commands" />
<script src="commands.lua" />
<script src="client.lua" type="client" />
</meta>
</syntaxhighlight>

* Le "commands.lua" fournit quelques commandes d'admin, comme le fait d'interdire un joueur, en banissant ou quelque chose d'autre ce qui peut être utilisé par l'admin du serveur
* Le "client.lua" fournit un GUI pour être capable d'exécuter les actions mentionnées facilement

Cet exemple de script doit tourner tout le temps (peut être même démarré en même temps que le serveur) car ces commandes d'admin peuvent être appelé à n'importe quelle moment.

====Second example - Un gamemode====
<syntaxhighlight lang="xml">
/counterstrike
/meta.xml
/counterstrike.lua
/buymenu.lua
</syntaxhighlight>
<syntaxhighlight lang="xml">
<meta>
<info author="Quelqu'un" description="Counterstrike remake" type="gamemode" />
<script src="counterstrike.lua" />
<script src="buymenu.lua" type="client" />
</meta>
</syntaxhighlight>

* Le "counterstrike.lua" contient des caractéristiques semblables aux dispositifs suivants :
** Laisser les joueurs choisirent leur équipe et les faire apparaître
** Leur fournir des armes, des cibles et des instructions (peut-être lues d'une carte, voir ci-dessous)
** Définir les règles du jeu, par exemple. La partie se finie, ce qui se produit quand un joueur meurt
** .. et peut-être encore plus
* Le "buymenu.lua" est un script du côté client et crée un menu pour acheter des armes

Cet exemple peut s'appeler un gamemode, il modifie le gameplay, mais définit réellement les règles de celui-ci. Le "type" attribut indique que cet exemple fonctionne avec [[Map Manager]], encore une autre ressource qui a été écrite par l'équipe de MTA pour contrôler des gamemodes et le chargement de cartes. On recommande fortement que vous basiez vos gamemodes sur les techniques qu'il fournit.

Ceci signifie également que ce gamemode ne fonctionnera probablement pas sans carte. Les gamemodes devront toujours être aussi génériques que possible. Un exemple de gamemode utilisant une carte est énoncé dans le prochain exemple.

====Troisième exemple - Une carte====
<syntaxhighlight lang="xml">
/cs-airport
/meta.xml
/airport.map
/airport.lua
</syntaxhighlight>
<syntaxhighlight lang="xml">
<meta>
<info author="Quelqu'un" description="Counterstrike airport map" type="map" gamemodes="counterstrike" />
<map src="airport.map" />
<script src="airport.lua" />
</meta>
</syntaxhighlight>

* Le "airport.map" dans le fichier XML fournit des informations au sujet de la carte au gamemode, ceului-ci peut inclure :
** Là où les joueurs devraient apparaitre, avec quelles armes, avec quelle équipe
** Ce qui sont les cibles
** Temps, heure du monde, Limite de temps
** Fournir les véhicules
* Le ''airport.lua'' peut contenir des actions relatifs a la map comme:
** Ouvrir une certaine porte ou faire éxploser quelque chose quand une autre chose de spécifique se produit
** Créer ou déplacer quelques objets faits sur commande, ou manoeuvrez les objets qui sont créés dans le fichier .map
** .. toutes autre choses relatifs aux ojets du .map

Comme vous pouvez le voir, l'attribut "type" a été changé en 'map', pour dire au [[Map Manager]] que cette ressource est une carte, tandis que l'attribut "gamemodes" indique pour quels gamemodes cette carte est valide, dans ce cas-ci le gamemode de l'exemple de tout à l'heure.
Ce qui peut venir comme une surprise est qu'il y a aussi un script dans la ressource de carte. Évidemment ce n'est pas nécessaire dans une carte, mais ouvre une large gamme de possibilités pour les créateurs de cartes.

Le "airport.map" pourrait être semblable à ceci :
<syntaxhighlight lang="xml">
<map mode="deathmatch" version="1.0">
<terrorists>
<spawnpoint posX="2332.23" posY="-12232.33" posZ="4.42223" skins="23-40" />
</terrorists>
<counterterrorists>
<spawnpoint posX="2334.23443" posY="-12300.233" posZ="10.2344" skins="40-50" />
</counterterrorists>

<bomb posX="23342.23" posY="" posZ="" />

<vehicle posX="" posY="" posZ="" model="602" />
<vehicle posX="" posY="" posZ="" model="603" />
</map>
</syntaxhighlight>

Quand un gamemode est commencé avec une carte, les ressources de carte est automatiquement démaré par le mapmanager et les renseignements qu'il contient peut être lu par le gamemode. Quand la carte change, la ressource de carte actuelle est arrêtée et la ressource de carte suivante est commencée. Pour une explication plus détaillée et des exemples pour savoit comment les ressources de cartes sont utilisées dans le script principal, visitez s'il vous plaît la page [[Writing Gamemodes]].

===Événements===
Les événements sont la façon que MTA dit aux scripts des choses qui arrivent. Par exemple quand un joueur meurt, le [[onPlayerWasted]] l'événement est déclenché. Pour exécuter n'importe quelles actions quand un joueur meurt, vous devez vous préparer similiar à l'ajoutant d'un dresseur d'ordre, comme montré dans [[#Writing_the_script|the first chapter]].

Cet exemple produiras un message avec le nom du joueur qui est mort :
<syntaxhighlight lang="lua">
function playerDied(totalAmmo, killer, killerWeapon, bodypart)
outputChatBox(getPlayerName(source).." died!")
end
addEventHandler("onPlayerWasted",getRootElement(),playerDied)
</syntaxhighlight>

Au lieu de montrer que les arguments sont nécessaires, la page de documentation pour les spectacles d'Événements quels paramètres sont passés à la handler function, similaire à la voie un [[*About_command_handlers|command handler]] fait, juste qu'il se distingue de l'événement à l'événement. Un autre point important est la variable "source", qui existe dans les handler function. Ils ne doivent pas être ajoutés à la liste de paramètre de la fonction, mais cela existe toujours . Il a une différente valeur de l'événement à l'événement, pour les événements de joueur (comme dans l'exemple au-dessus) c'est l'élément de joueur. Comme un autre exemple, vous pouvez jeter un coup d'œil au script de joueur frayant fondamental dans la première section pour recevoir une idée comment "source" est utilisé.

==Où aller d'ici==
Vous devriez maintenant être familiers avec les aspects les plus fondamentaux de MTA scripting et aussi un peu avec la documentation. Le [[Main_Page]] vous fournit des liens vers plus de renseignements, Classes de travaux dirigés et Références qui permettent un coup d'oeil plus profond dans les thèmes dont vous désirez apprendre.

D'ici nous recommandons de lire le [[debugging]] la classe de travaux dirigés. De bonnes adresses déboguantes sont une nécessité absolue quand vous faites des scripts.

[[ru:Scripting Introduction]]
[[it:Introduzione allo scripting]]
[[es:Introducción a la Programación]]

FR/Introduction Programmation

2012-06-30T08:13:17Z

Citizen: /* Second example - Un gamemode */

Les ressources sont les parties clées de MTA. Une ressource est un dossier ou un .zip qui contient plusieurs fichiers, ainsi qu'une meta qui dit au serveur comment la resource doit-elle être chargée. Une ressource peut être comparée comme un programme qu'on peut lancer ou arrêter, il est possible de lancer plusieurs ressources en même temps.

Tout ce qui a un rapport avec la programmation se passe dans les ressources, se que fait la ressource, définie si c'est un gamemode, une map or quelquechose d'autre. MTA s'installe avec des resources que vous pouvez facultativement utiliser dans vos gamemodes, comme la ressource "maplimits" pour garder les joueurs dans une certaine zone ou encore "deathpickups" pour créer des pickups pour ramasser une arme.

'''La première chose à faire avant de pouvoir programmer en lua, c'est de se procurer un editeur de texte qui supporte le lua. Il vous sera beaucoups plus facile que de le faire avec le bloc-note de Windows. Nous vous recommendons donc [http://notepad-plus.sourceforge.net/uk/site.htm Notepad++] ou [http://luaedit.sourceforge.net/ LuaEdit]. Il y a aussi un logiciel non officiel [[MTASE|MTA Script Editor]] ( malheureusement l'auteur ne travail plus dessus ) que vous pouvez tester.'''

==Créer un script qui fonctionne==
Nous allons voir tout d'abord comment créer un simple script étapes par étapes qui permetra aux joueurs de se deplacer dans la ville. Dans ce tutoriel, on utilisera notepadd++.
===Où sont tous les scripts ?===
Laissez moi d'abord vous présenter comment s'oranise une ressource. Allez dans votre dossier MTA San et et suivez le chemin suivant:

/serveur/mods/deathmatch/resources/

Vous y verez de nombreux fichier avec l'extension .zip, se sont des ressources avec à l'intérieur des exemples de scripts . Toutes les ressources chargées sont dézippé par le serveur afin de pouvoir les exécuter ( les .zip ne sont pas obligatiores, vous pouvez aussi laissez votre ressource en tant que dossier ). Pour créer votre propre ressource, créez simplement un nouveau dossier et nommez le comme vous voulez ( Ne pas utiliser d'espace, utilisez plutôt un _ ) . Nommez le "myserveur" pour ce tutoriel.

Maintenant entrez dans votre dossier. Le chemain devrait donc être

/serveur/mods/deathmatch/resources/myserveur/

===Identifier votre ressource===
Pour que le serveur puisse savoir ce que contient votre ressource, un fichier ''meta.xml'' doit être créé afin d'établir une liste du contenu du dossier. Cette 'meta.xml' doit être à la racine de votre ressource ( et non pas dans un autre sous-dossier ), donc dans le dossier "myserveur" dans notre cas. Donc ouvrez notepadd++, créer un nouveau fichier (Ctrl+N), puis faite "Enregistrez sous ..." (Ctrl+Alt+S), dans "Nom:" vous écrivez "meta" et dans "Type:", sélectionnez "*.xml" ( avant-dernier de la liste ), sauvegardez le dans votre dossier "myserveur".

Maintenant, ecrivez le code suivant dans votre ''meta.xml'':
<syntaxhighlight lang="xml">
<meta>
<info author="Votre Nom" type="gamemode" name="Mon serveur" description="Mon premier serveur MTA" />
<script src="script.lua" />
</meta>
</syntaxhighlight>
Dans la balise ''<info />'', il y a le champ "type" qui indique si la ressource est un ''gamemode'' ou une ''map'', on y reviendra plus tard. Un gamemode est ce dont vous avez besoin pour que votre serveur est une base.

La balise ''<script />'' indique les scripts qui sont dans la ressource, que l'on va maintenant créer.
===Créer un script simple===
Notez que dans la balise ''<script />'', le fichier .lua n'est pas dans un autre sous-dossier. Donc on va créer notre script.lua au même endroit que notre meta.xml ( Reproduisez la même opération mais "Nom:" écrivez 'script' et pour "Type:" choisissez 'Lua(*.lua)' ) puis copier-coller le code suivant:
<syntaxhighlight lang="lua">
function joinHandler()
local x = 1959.55
local y = -1714.46
local z = 10
spawnPlayer(source, x, y, z)
fadeCamera(source, true)
setCameraTarget(source, source)
outputChatBox("Bienvenue sur mon serveur", source)
end
addEventHandler("onPlayerJoin", getRootElement(), joinHandler)
</syntaxhighlight>
Ce script va fous faire apparître aux coordonnées (x, y, z) spécifié dans le code, lorsque vous connecterez au serveur. La fonction ''fadeCamera'' sinon l'écran restera noir. Vous devez aussi dire à la camera de suivre le joueur grâce à la fonction 'setCameraTarget' (sinon il vera une mer bleu).

La variable '''source''' indique qui 'déclenche' la fonction. Le fonction se 'déclenche' lorsqu'un joueur rejoind le serveur, vous utiliserez cette variable pour voir qui à rejoind le serveur. Donc lorsque un joueur( "la source" ) rejoindra notre serveur, on le fera apparaître aux coordonnées indiquées .

Focalisons-nous sur [[addEventHandler]], vous pouver voir 3 choses: 'onPlayerJoin', qui indique quand éxécuter la fonction X. getRootElement(), qui indique qui/quoi peut être déclencher la fonction (getRootElement() veut dire toutes les choses et tous les joueurs). Et enfin la fonction X à éxecuter ( ici joinHandler ). Pour les autres details, nous verrons plus tard dans d'autres exemples mais tout d'abord testons notre premier gamemode!

===Lancer le gamemode===
Pour lancer le serveur, lancer simplement le 'MTA Server.exe' qui se trouve dans votre dossier 'MTA San et\server'. Une liste d'info concernant le serveur apparaîtra en premier; notez le port du serveur ( 22003 par défaut ), vous en aurez besoin pour rejoindre le serveur. Après, le serveur charge toutes les ressources du dossier 'resource', et enfin "ready to accept connections!"

Avant de pouvoir vous connecter, vous devez lancer votre gamemode. Tapez "start myserver" et appuyer sur Entrer. Le serveur va alors lancer le gamemode que nous avons créé, et nous affichera aussi les erreurs s'il y en a. Maintenant, vous pouvez maintenant lancer MTA, cliquez sur "Quick Connect" et ecrivez ceci: Dans Host: le1er champ: 127.0.0.1 ou localhost ( cela signifie que vous vous connectez au serveur du pc actuel ) et le 2ème champ: le port ( ici 22003 ) et cliquez sur 'Connect'. Si tout se passe bien, après quelques secondes, vous devriez apparaître et pouvoir allez où vous voulez.

Ensuite nous allons créer une commande que les joueurs pourront utiliser pour faire apparître une voiture à coté d'eux.

==Créer une commande==
Revenons à l'intérieur de notre ''script.lua''. Tout d'abord, nous devons créer une fonction qu'on pourra appeler/éxécuter grâce à notre commande et la fonction 'addCommandHandler' afin de créer la commande que les joueurs pourront taper dans le chat( T ) ou la console( F8 ).

<syntaxhighlight lang="lua">
-- On crée la fonction qui sera appelée par notre commande avec les arguments: thePlayer, command, vehicleModel
function createVehicleForPlayer(thePlayer, commandName, vehicleModel)
-- Ici on crée le véhicule
end
-- on crée la commande et on l'attache à notre fonction
addCommandHandler("createVehicle", createVehicleForPlayer)
</syntaxhighlight>
''Note: Grâce au wiki, vous pouvez cliquer sur le nom des fonctions et cela vous redirigera sur la documentation de cette fonction.''

====A propos du addCommandHandler====
Le premier argument du [[addCommandHandler]] est le nom de la commande the player will be able to enter, le second le nom de la fonction à appeler, dans notre cas, ''createVehicleForPlayer''.

Si vous avez déjà de l'expérience dans le codage, vous savez qu'un fonction s'appelle comme ceci:
<syntaxhighlight lang="lua">
nomDeLaFonction(argument1, argument2, argument3, ..)
</syntaxhighlight>
Si l'on regarde bien l'exemple ci-dessus, nous pouvons voir que l'argument1 est thePlayer and argument2 le commandName. thePlayer est celui qui à tapé la commande et commandName contient le nom de la commande qu'il à tapé. Donc si un joueur tape "/greet", cet argument va contenir "greet". Argument3 c'est ce que le joueur à tapé en plus de la commande, vous allez apprendre ceci dans le tutoriel. N'oubliez jamais que les deux premiers arguments sont les arguments standards, mais vous pouvez les renommé si vous voulez, seul l'ordre est important.

Par exemple: Un joueur tape "createVehicle 468" pour faire aparaître une Sanchez, la fonction addCommandHandler va appeller notre fonction createVehicleForPlayer, comme ceci:
<syntaxhighlight lang="lua">
createVehicleForPlayer(thePlayer,"createVehicle","468") -- thePlayer est l'élement joueur qui a tapé la commande
</syntaxhighlight>
Comme nous pouvons le voir, ll fournit plusieurs paramètres: le joueur qui a tapé la commande, la commande qu'il a tapé, et n'importe quelle texte qu'il a mis après, dans notre cas, "468" comme id de la Sanchez. Les deux premiers paramètres sont les même pour tous les addCommandHandler qu'on peut retrouver sur la page du [[addEventHandler]]. Vous devez toujours définir au moins ces deux paramètres pour utiliser les arguments après eux (par exemple pour traiter le texte qui a été entré après la commande, comme dans notre exemple le modèle du véhicule).

''Note: Vous devez créer la commande APRES la fonction que vous allez utiliser pour cette commande, sinon il ne trouvera pas la fonction.''

====Ecrire la fonction====
Pour remplir notre fonction d'instructions, nous devons d'abord pensez à ce que nous devons faire:
* Récupérer la position du joueur, donc on connaitra la position où faire apparaître le véhicule (on veut le faire apparaître à droite du joueur)
* Calculer la position où faire apparître le véhicule (nous ne voulons pas que le véhicule apparaisse dans le joueur)
* Faire apparître les véhicule
* Vérifier si le véhicule a bien apparus, ou aficher un message d'erreur.

Pour ça, nous devons utiliser plusieurs fonctions. Pour trouver la fonction que nous devons utiliser, il faut aller faire un tour dans la [[Scripting Functions|La liste des fonctions serveur]]. D'abord nous avons besoin d'une fonction pour obtenir la position du joueur. Puisque les joueurs sont des éléments, nous devons allez dans la rubrique '''Element functions''' où l'on pourra trouver la fonction [[getElementPosition]]. En cliquant sur le nom de la fonction, le wiki va vous afficher sa description. On peut y voir la syntaxe, qu'est-ce que la fonction retourne. La syntaxe nous montre les argument qu'on peut ou qu'on doit envoyer.

Pour [[getElementPosition]], la syntaxe est:
<syntaxhighlight lang="lua">
float, float, float getElementPosition ( element theElement )
</syntaxhighlight>

Les trois float devant le nom de la fonction est le type de variable que la fonction nous retourne. Dans notre cas, la fonction retourne trois nombres à virgule(x, y et z). Dans les parenthèses, on peut voir les arguments que l'on doit envoyer, dans notre cas, l'element dont on veut récupérer la position, le joueur dans notre exemple.

<syntaxhighlight lang="lua">
function createVehicleForPlayer(thePlayer, command, vehicleModel)
-- on récupère la position x,y,z dans des variables locales
-- une variable locale n'existe que dans le "périmètre" actuel. Ici, les variable x, y et z sont des variables locales qui se détruiront à la fin de la fonction.
local x,y,z = getElementPosition(thePlayer)
end
</syntaxhighlight>

Ensuite, il faut s'assurer que le véhicule n'apparaît pas directement dans le joueur, donc on ajoute quelques unités à la variable ''x'', qui le fera apparaître plus à l'est par rapport au joueur.

<syntaxhighlight lang="lua">
function createVehicleForPlayer(thePlayer, command, vehicleModel)
local x,y,z = getElementPosition(thePlayer) -- On prent la position du joueur qui a tapé la commande
x = x + 5 -- on ajoute 5 unité sur l'axes des x
end
</syntaxhighlight>

Maintenant nous avons besoin d'une autre fonction, celle qui va faire apparaître le véhicule. Nous allons la cherché encore une fois dans la [[Scripting Functions|liste des fonctions serveur]], mais cette fois, comme nous parlons d'un véhicule, nous devons donc aller dans la catégorie'''Vehicle functions''', où l'on va trouver la fonction [[createVehicle]]. Dans la syntaxe, nous pouvons voir que cette fonction ne retourne qu'une seule variable, le véhicule ( de type élément ) que nous venons de créer. Nous pouvons aussi voir qu'il y a des arguments entre crochets [], cela veut dire que ce sont des arguments optionels.

Nous avons déjà tous les arguments pour la fonction [[createVehicle]] dans notre fonction: La position que nous avons juste calculée dans les variables "x, y, z" et l'id du véhicule que nous avons fourni par la commande ("/createVehicle 468") et qui est stocké dans la variable ''vehicleModel''.

<syntaxhighlight lang="lua">
function createVehicleForPlayer(thePlayer, command, vehicleModel)
local x,y,z = getElementPosition(thePlayer) -- récupere la position du joueur dans les variables x, y et z
x = x + 5 -- rajoute 5 unités sur x
-- on crée le véhicule et on enregistre l'élément de type "vehicle" dans la variable ''createdVehicle''
local createdVehicle = createVehicle(tonumber(vehicleModel),x,y,z)
end
</syntaxhighlight>

Avec cette variable, on pourrait faire pas mal de choses sympa, mais ici nous allons juste vérifier si le véhicule à bien été créé ou non.
Sur le wiki de la fonction [[createVehicle]], il y a la partie nomée '''Returns''', la fonction va retourner ''false'' si la voiture n'a pas été créé. Ducoups, on va regarder la valeur de la variable ''createdVehicle''.

Voilà notre code complet:
<syntaxhighlight lang="lua">
function createVehicleForPlayer(thePlayer, command, vehicleModel)
local x,y,z = getElementPosition(thePlayer) -- On prent la position du joueur qui a tapé la commande
x = x + 5 -- on ajoute 5 unités à x
local createdVehicle = createVehicle(tonumber(vehicleModel),x,y,z) -- on crée le véhicule demandé par le joueur et on récupère ce que nous retourne la fonction dans la variable createdVehicle
-- On vérifie si la valeur retournée est égal à ''false'' ( ce qui signifie que ça n'a pas marché )
if (createdVehicle == false) then
-- si c'est le cas, on affiche un message d'erreur dans la chatbox mais seulement pour le joueur.
outputChatBox("Erreur lors de la création du véhicule.",thePlayer)
end
end
addCommandHandler("createVehicle", createVehicleForPlayer)
</syntaxhighlight>

Comme vous pouvez le voir, nous avons utilisé une nouvelle fonction: [[outputChatBox]]. Vous devriez maintenant pouvoir regarder la description de cette fonction par vous même.

==Ce que vous devez savoir==
Vous avez déjà lu quelques informations sur les ressources, les commandes et trouvez des fonctions dans le wiki, mais il y a encore beaucoup à apprendre. Cette section vous donnera une vue d'ensemble plutôt courte sur certaines de ces choses, tout en regardant les pages du wiki si possible.
===Les scripts client et serveur===
Vous pouvez avoir déjà remarqué ces termes (serveur/client) quelque part sur ce wiki, le plus souvent pour les fonctions. MTA ne supporte pas seulement les scripts exécuté par le serveur et des commandes (comme celle qu'on vien de faire) ou d'autres fonctions, mais aussi les scripts éxécuté par le client MTA, ceux des joueurs qui se connecte au serveur. La raison est que certaines fonctions de MTA doit être du coté client comme par exemple le GUI - Graphical User Interface - ( Pour tout ce qui est fenêtres, boutons, etc ), d'autres devraient être du côté client parce qu'ils fonctionnent mieux mais d'autres sont mieux pensées pour être du côté serveur ou ne fonctionne tout simplement pas du côté client.

La plupart de vos scripts (gamemodes, maps) seront surement du côté serveur, comme celui que nous avons fait tout à l'heure. Si vous vous heurtez à quelque chose qui ne peut pas être résolu du côté serveur, vous devrez probablement le faire côté client. Pour un script client, vous devriez créer un script ordinaire (par exemple appelé ''client.lua'') et spécifié dans la meta.xml, comme ceci:
<syntaxhighlight lang="xml">
<script src="client.lua" type="client" />
</syntaxhighlight>
L'attribut ''type'' est par defaut 'server', donc nous avons juste besoin de spécifier que c'est un script client. Lorsque vous faites ceci, le fichier va être télecharger par le joueur sur son ordinateur lorsqu'il se connecte au serveur. Plus d'infos: [[Client side scripts]].

===Ressources plus complexes===
La section précédente nous a montré brièvement comment ajouter des scripts clients à la ressource. Penchons nous maintenant sur la ''meta.xml'' et ce qu'elle fait.

====First example - Un script utile====
<syntaxhighlight lang="xml">
/admin_commands
/meta.xml
/commands.lua
/client.lua
</syntaxhighlight>
<syntaxhighlight lang="xml">
<meta>
<info author="Someguy" description="admin commands" />
<script src="commands.lua" />
<script src="client.lua" type="client" />
</meta>
</syntaxhighlight>

* Le "commands.lua" fournit quelques commandes d'admin, comme le fait d'interdire un joueur, en banissant ou quelque chose d'autre ce qui peut être utilisé par l'admin du serveur
* Le "client.lua" fournit un GUI pour être capable d'exécuter les actions mentionnées facilement

Cet exemple de script doit tourner tout le temps (peut être même démarré en même temps que le serveur) car ces commandes d'admin peuvent être appelé à n'importe quelle moment.

====Second example - Un gamemode====
<syntaxhighlight lang="xml">
/counterstrike
/meta.xml
/counterstrike.lua
/buymenu.lua
</syntaxhighlight>
<syntaxhighlight lang="xml">
<meta>
<info author="Quelqu'un" description="Counterstrike remake" type="gamemode" />
<script src="counterstrike.lua" />
<script src="buymenu.lua" type="client" />
</meta>
</syntaxhighlight>

* Le "counterstrike.lua" contient des caractéristiques semblables aux dispositifs suivants :
** Laisser les joueurs choisirent leur équipe et les faire apparaître
** Leur fournir des armes, des cibles et des instructions (peut-être lues d'une carte, voir ci-dessous)
** Définir les règles du jeu, par exemple. La partie se finie, ce qui se produit quand un joueur meurt
** .. et peut-être encore plus
* Le "buymenu.lua" est un script du côté client et crée un menu pour acheter des armes

Cet exemple peut s'appeler un gamemode, il modifie le gameplay, mais définit réellement les règles de celui-ci. Le "type" attribut indique que cet exemple fonctionne avec [[Map Manager]], encore une autre ressource qui a été écrite par l'équipe de MTA pour contrôler des gamemodes et le chargement de cartes. On recommande fortement que vous basiez vos gamemodes sur les techniques qu'il fournit.

Ceci signifie également que ce gamemode ne fonctionnera probablement pas sans carte. Les gamemodes devront toujours être aussi génériques que possible. Un exemple de gamemode utilisant une carte est énoncé dans le prochain exemple.

====Troisième exemple - Une carte====
<syntaxhighlight lang="xml">
/cs-airport
/meta.xml
/airport.map
/airport.lua
</syntaxhighlight>
<syntaxhighlight lang="xml">
<meta>
<info author="Quelqu'un" description="Counterstrike airport map" type="map" gamemodes="counterstrike" />
<map src="airport.map" />
<script src="airport.lua" />
</meta>
</syntaxhighlight>

* Le "airport.map" dans le fichier XML fournit des informations au sujet de la carte au gamemode, ceului-ci peut inclure :
** Là où les joueurs devraient apparaitre, avec quelles armes, avec quelle équipe
** Ce qui sont les cibles
** Temps, heure du monde, Limite de temps
** Fournir les véhicules
* Le ''airport.lua'' peut contenir les dispositifs carte-spécifiques, celui-ci peut inclure :
** En ouvrant une certaine porte/faisant éclater quelque chose quand quelque chose de spécifique se produit
** Créez ou déplacez quelques objets faits sur commande, ou manoeuvrez les objets qui sont créés dans le fichier .map
** .. toute autre chose carte-spécifiques

Comme vous pouvez voir, l'attribut "type" a changé en 'map', dire [[Map Manager]] que cette ressource est une carte, tandis que l'attribut "gamemodes" indique pour quels gamemodes cette carte est valide, dans ce cas-ci le gamemode de l'exemple ci-dessus.
Ce qui peut venir comme une surprise est qu'il y a aussi un script dans la ressource de Carte. Évidemment ce n'est pas nécessairement nécessaire dans une carte, mais ouvre une large gamme de possibilités pour les producteurs de carte pour créer leur propre monde dans les règles du gamemode pour lequel ils le créent.

Le "airport.map" pourrait être semblable à ceci :
<syntaxhighlight lang="xml">
<map mode="deathmatch" version="1.0">
<terrorists>
<spawnpoint posX="2332.23" posY="-12232.33" posZ="4.42223" skins="23-40" />
</terrorists>
<counterterrorists>
<spawnpoint posX="2334.23443" posY="-12300.233" posZ="10.2344" skins="40-50" />
</counterterrorists>

<bomb posX="23342.23" posY="" posZ="" />

<vehicle posX="" posY="" posZ="" model="602" />
<vehicle posX="" posY="" posZ="" model="603" />
</map>
</syntaxhighlight>

Quand un gamemode est commencé avec une carte, les ressources de carte est automatiquement commencé par le mapmanager et les renseignements qu'il contient peut être lu par la ressource gamemode. Quand la carte change, la ressource de carte actuelle est arrêtée et la ressource de carte suivante est commencée. Pour une explication plus détaillée et des exemples de comment les ressources de carte sont utilisées dans le script principal, visitez s'il vous plaît la page [[Writing Gamemodes]].

===Événements===
Les événements sont la façon que MTA dit aux scripts des choses qui arrivent. Par exemple quand un joueur meurt, le [[onPlayerWasted]] l'événement est déclenché. Pour exécuter n'importe quelles actions quand un joueur meurt, vous devez vous préparer similiar à l'ajoutant d'un dresseur d'ordre, comme montré dans [[#Writing_the_script|the first chapter]].

Cet exemple produiras un message avec le nom du joueur qui est mort :
<syntaxhighlight lang="lua">
function playerDied(totalAmmo, killer, killerWeapon, bodypart)
outputChatBox(getPlayerName(source).." died!")
end
addEventHandler("onPlayerWasted",getRootElement(),playerDied)
</syntaxhighlight>

Au lieu de montrer que les arguments sont nécessaires, la page de documentation pour les spectacles d'Événements quels paramètres sont passés à la handler function, similaire à la voie un [[*About_command_handlers|command handler]] fait, juste qu'il se distingue de l'événement à l'événement. Un autre point important est la variable "source", qui existe dans les handler function. Ils ne doivent pas être ajoutés à la liste de paramètre de la fonction, mais cela existe toujours . Il a une différente valeur de l'événement à l'événement, pour les événements de joueur (comme dans l'exemple au-dessus) c'est l'élément de joueur. Comme un autre exemple, vous pouvez jeter un coup d'œil au script de joueur frayant fondamental dans la première section pour recevoir une idée comment "source" est utilisé.

==Où aller d'ici==
Vous devriez maintenant être familiers avec les aspects les plus fondamentaux de MTA scripting et aussi un peu avec la documentation. Le [[Main_Page]] vous fournit des liens vers plus de renseignements, Classes de travaux dirigés et Références qui permettent un coup d'oeil plus profond dans les thèmes dont vous désirez apprendre.

D'ici nous recommandons de lire le [[debugging]] la classe de travaux dirigés. De bonnes adresses déboguantes sont une nécessité absolue quand vous faites des scripts.

[[ru:Scripting Introduction]]
[[it:Introduzione allo scripting]]
[[es:Introducción a la Programación]]

FR/Introduction Programmation

2012-06-30T08:01:49Z

Citizen: faute

Les ressources sont les parties clées de MTA. Une ressource est un dossier ou un .zip qui contient plusieurs fichiers, ainsi qu'une meta qui dit au serveur comment la resource doit-elle être chargée. Une ressource peut être comparée comme un programme qu'on peut lancer ou arrêter, il est possible de lancer plusieurs ressources en même temps.

Tout ce qui a un rapport avec la programmation se passe dans les ressources, se que fait la ressource, définie si c'est un gamemode, une map or quelquechose d'autre. MTA s'installe avec des resources que vous pouvez facultativement utiliser dans vos gamemodes, comme la ressource "maplimits" pour garder les joueurs dans une certaine zone ou encore "deathpickups" pour créer des pickups pour ramasser une arme.

'''La première chose à faire avant de pouvoir programmer en lua, c'est de se procurer un editeur de texte qui supporte le lua. Il vous sera beaucoups plus facile que de le faire avec le bloc-note de Windows. Nous vous recommendons donc [http://notepad-plus.sourceforge.net/uk/site.htm Notepad++] ou [http://luaedit.sourceforge.net/ LuaEdit]. Il y a aussi un logiciel non officiel [[MTASE|MTA Script Editor]] ( malheureusement l'auteur ne travail plus dessus ) que vous pouvez tester.'''

==Créer un script qui fonctionne==
Nous allons voir tout d'abord comment créer un simple script étapes par étapes qui permetra aux joueurs de se deplacer dans la ville. Dans ce tutoriel, on utilisera notepadd++.
===Où sont tous les scripts ?===
Laissez moi d'abord vous présenter comment s'oranise une ressource. Allez dans votre dossier MTA San et et suivez le chemin suivant:

/serveur/mods/deathmatch/resources/

Vous y verez de nombreux fichier avec l'extension .zip, se sont des ressources avec à l'intérieur des exemples de scripts . Toutes les ressources chargées sont dézippé par le serveur afin de pouvoir les exécuter ( les .zip ne sont pas obligatiores, vous pouvez aussi laissez votre ressource en tant que dossier ). Pour créer votre propre ressource, créez simplement un nouveau dossier et nommez le comme vous voulez ( Ne pas utiliser d'espace, utilisez plutôt un _ ) . Nommez le "myserveur" pour ce tutoriel.

Maintenant entrez dans votre dossier. Le chemain devrait donc être

/serveur/mods/deathmatch/resources/myserveur/

===Identifier votre ressource===
Pour que le serveur puisse savoir ce que contient votre ressource, un fichier ''meta.xml'' doit être créé afin d'établir une liste du contenu du dossier. Cette 'meta.xml' doit être à la racine de votre ressource ( et non pas dans un autre sous-dossier ), donc dans le dossier "myserveur" dans notre cas. Donc ouvrez notepadd++, créer un nouveau fichier (Ctrl+N), puis faite "Enregistrez sous ..." (Ctrl+Alt+S), dans "Nom:" vous écrivez "meta" et dans "Type:", sélectionnez "*.xml" ( avant-dernier de la liste ), sauvegardez le dans votre dossier "myserveur".

Maintenant, ecrivez le code suivant dans votre ''meta.xml'':
<syntaxhighlight lang="xml">
<meta>
<info author="Votre Nom" type="gamemode" name="Mon serveur" description="Mon premier serveur MTA" />
<script src="script.lua" />
</meta>
</syntaxhighlight>
Dans la balise ''<info />'', il y a le champ "type" qui indique si la ressource est un ''gamemode'' ou une ''map'', on y reviendra plus tard. Un gamemode est ce dont vous avez besoin pour que votre serveur est une base.

La balise ''<script />'' indique les scripts qui sont dans la ressource, que l'on va maintenant créer.
===Créer un script simple===
Notez que dans la balise ''<script />'', le fichier .lua n'est pas dans un autre sous-dossier. Donc on va créer notre script.lua au même endroit que notre meta.xml ( Reproduisez la même opération mais "Nom:" écrivez 'script' et pour "Type:" choisissez 'Lua(*.lua)' ) puis copier-coller le code suivant:
<syntaxhighlight lang="lua">
function joinHandler()
local x = 1959.55
local y = -1714.46
local z = 10
spawnPlayer(source, x, y, z)
fadeCamera(source, true)
setCameraTarget(source, source)
outputChatBox("Bienvenue sur mon serveur", source)
end
addEventHandler("onPlayerJoin", getRootElement(), joinHandler)
</syntaxhighlight>
Ce script va fous faire apparître aux coordonnées (x, y, z) spécifié dans le code, lorsque vous connecterez au serveur. La fonction ''fadeCamera'' sinon l'écran restera noir. Vous devez aussi dire à la camera de suivre le joueur grâce à la fonction 'setCameraTarget' (sinon il vera une mer bleu).

La variable '''source''' indique qui 'déclenche' la fonction. Le fonction se 'déclenche' lorsqu'un joueur rejoind le serveur, vous utiliserez cette variable pour voir qui à rejoind le serveur. Donc lorsque un joueur( "la source" ) rejoindra notre serveur, on le fera apparaître aux coordonnées indiquées .

Focalisons-nous sur [[addEventHandler]], vous pouver voir 3 choses: 'onPlayerJoin', qui indique quand éxécuter la fonction X. getRootElement(), qui indique qui/quoi peut être déclencher la fonction (getRootElement() veut dire toutes les choses et tous les joueurs). Et enfin la fonction X à éxecuter ( ici joinHandler ). Pour les autres details, nous verrons plus tard dans d'autres exemples mais tout d'abord testons notre premier gamemode!

===Lancer le gamemode===
Pour lancer le serveur, lancer simplement le 'MTA Server.exe' qui se trouve dans votre dossier 'MTA San et\server'. Une liste d'info concernant le serveur apparaîtra en premier; notez le port du serveur ( 22003 par défaut ), vous en aurez besoin pour rejoindre le serveur. Après, le serveur charge toutes les ressources du dossier 'resource', et enfin "ready to accept connections!"

Avant de pouvoir vous connecter, vous devez lancer votre gamemode. Tapez "start myserver" et appuyer sur Entrer. Le serveur va alors lancer le gamemode que nous avons créé, et nous affichera aussi les erreurs s'il y en a. Maintenant, vous pouvez maintenant lancer MTA, cliquez sur "Quick Connect" et ecrivez ceci: Dans Host: le1er champ: 127.0.0.1 ou localhost ( cela signifie que vous vous connectez au serveur du pc actuel ) et le 2ème champ: le port ( ici 22003 ) et cliquez sur 'Connect'. Si tout se passe bien, après quelques secondes, vous devriez apparaître et pouvoir allez où vous voulez.

Ensuite nous allons créer une commande que les joueurs pourront utiliser pour faire apparître une voiture à coté d'eux.

==Créer une commande==
Revenons à l'intérieur de notre ''script.lua''. Tout d'abord, nous devons créer une fonction qu'on pourra appeler/éxécuter grâce à notre commande et la fonction 'addCommandHandler' afin de créer la commande que les joueurs pourront taper dans le chat( T ) ou la console( F8 ).

<syntaxhighlight lang="lua">
-- On crée la fonction qui sera appelée par notre commande avec les arguments: thePlayer, command, vehicleModel
function createVehicleForPlayer(thePlayer, commandName, vehicleModel)
-- Ici on crée le véhicule
end
-- on crée la commande et on l'attache à notre fonction
addCommandHandler("createVehicle", createVehicleForPlayer)
</syntaxhighlight>
''Note: Grâce au wiki, vous pouvez cliquer sur le nom des fonctions et cela vous redirigera sur la documentation de cette fonction.''

====A propos du addCommandHandler====
Le premier argument du [[addCommandHandler]] est le nom de la commande the player will be able to enter, le second le nom de la fonction à appeler, dans notre cas, ''createVehicleForPlayer''.

Si vous avez déjà de l'expérience dans le codage, vous savez qu'un fonction s'appelle comme ceci:
<syntaxhighlight lang="lua">
nomDeLaFonction(argument1, argument2, argument3, ..)
</syntaxhighlight>
Si l'on regarde bien l'exemple ci-dessus, nous pouvons voir que l'argument1 est thePlayer and argument2 le commandName. thePlayer est celui qui à tapé la commande et commandName contient le nom de la commande qu'il à tapé. Donc si un joueur tape "/greet", cet argument va contenir "greet". Argument3 c'est ce que le joueur à tapé en plus de la commande, vous allez apprendre ceci dans le tutoriel. N'oubliez jamais que les deux premiers arguments sont les arguments standards, mais vous pouvez les renommé si vous voulez, seul l'ordre est important.

Par exemple: Un joueur tape "createVehicle 468" pour faire aparaître une Sanchez, la fonction addCommandHandler va appeller notre fonction createVehicleForPlayer, comme ceci:
<syntaxhighlight lang="lua">
createVehicleForPlayer(thePlayer,"createVehicle","468") -- thePlayer est l'élement joueur qui a tapé la commande
</syntaxhighlight>
Comme nous pouvons le voir, ll fournit plusieurs paramètres: le joueur qui a tapé la commande, la commande qu'il a tapé, et n'importe quelle texte qu'il a mis après, dans notre cas, "468" comme id de la Sanchez. Les deux premiers paramètres sont les même pour tous les addCommandHandler qu'on peut retrouver sur la page du [[addEventHandler]]. Vous devez toujours définir au moins ces deux paramètres pour utiliser les arguments après eux (par exemple pour traiter le texte qui a été entré après la commande, comme dans notre exemple le modèle du véhicule).

''Note: Vous devez créer la commande APRES la fonction que vous allez utiliser pour cette commande, sinon il ne trouvera pas la fonction.''

====Ecrire la fonction====
Pour remplir notre fonction d'instructions, nous devons d'abord pensez à ce que nous devons faire:
* Récupérer la position du joueur, donc on connaitra la position où faire apparaître le véhicule (on veut le faire apparaître à droite du joueur)
* Calculer la position où faire apparître le véhicule (nous ne voulons pas que le véhicule apparaisse dans le joueur)
* Faire apparître les véhicule
* Vérifier si le véhicule a bien apparus, ou aficher un message d'erreur.

Pour ça, nous devons utiliser plusieurs fonctions. Pour trouver la fonction que nous devons utiliser, il faut aller faire un tour dans la [[Scripting Functions|La liste des fonctions serveur]]. D'abord nous avons besoin d'une fonction pour obtenir la position du joueur. Puisque les joueurs sont des éléments, nous devons allez dans la rubrique '''Element functions''' où l'on pourra trouver la fonction [[getElementPosition]]. En cliquant sur le nom de la fonction, le wiki va vous afficher sa description. On peut y voir la syntaxe, qu'est-ce que la fonction retourne. La syntaxe nous montre les argument qu'on peut ou qu'on doit envoyer.

Pour [[getElementPosition]], la syntaxe est:
<syntaxhighlight lang="lua">
float, float, float getElementPosition ( element theElement )
</syntaxhighlight>

Les trois float devant le nom de la fonction est le type de variable que la fonction nous retourne. Dans notre cas, la fonction retourne trois nombres à virgule(x, y et z). Dans les parenthèses, on peut voir les arguments que l'on doit envoyer, dans notre cas, l'element dont on veut récupérer la position, le joueur dans notre exemple.

<syntaxhighlight lang="lua">
function createVehicleForPlayer(thePlayer, command, vehicleModel)
-- on récupère la position x,y,z dans des variables locales
-- une variable locale n'existe que dans le "périmètre" actuel. Ici, les variable x, y et z sont des variables locales qui se détruiront à la fin de la fonction.
local x,y,z = getElementPosition(thePlayer)
end
</syntaxhighlight>

Ensuite, il faut s'assurer que le véhicule n'apparaît pas directement dans le joueur, donc on ajoute quelques unités à la variable ''x'', qui le fera apparaître plus à l'est par rapport au joueur.

<syntaxhighlight lang="lua">
function createVehicleForPlayer(thePlayer, command, vehicleModel)
local x,y,z = getElementPosition(thePlayer) -- On prent la position du joueur qui a tapé la commande
x = x + 5 -- on ajoute 5 unité sur l'axes des x
end
</syntaxhighlight>

Maintenant nous avons besoin d'une autre fonction, celle qui va faire apparaître le véhicule. Nous allons la cherché encore une fois dans la [[Scripting Functions|liste des fonctions serveur]], mais cette fois, comme nous parlons d'un véhicule, nous devons donc aller dans la catégorie'''Vehicle functions''', où l'on va trouver la fonction [[createVehicle]]. Dans la syntaxe, nous pouvons voir que cette fonction ne retourne qu'une seule variable, le véhicule ( de type élément ) que nous venons de créer. Nous pouvons aussi voir qu'il y a des arguments entre crochets [], cela veut dire que ce sont des arguments optionels.

Nous avons déjà tous les arguments pour la fonction [[createVehicle]] dans notre fonction: La position que nous avons juste calculée dans les variables "x, y, z" et l'id du véhicule que nous avons fourni par la commande ("/createVehicle 468") et qui est stocké dans la variable ''vehicleModel''.

<syntaxhighlight lang="lua">
function createVehicleForPlayer(thePlayer, command, vehicleModel)
local x,y,z = getElementPosition(thePlayer) -- récupere la position du joueur dans les variables x, y et z
x = x + 5 -- rajoute 5 unités sur x
-- on crée le véhicule et on enregistre l'élément de type "vehicle" dans la variable ''createdVehicle''
local createdVehicle = createVehicle(tonumber(vehicleModel),x,y,z)
end
</syntaxhighlight>

Avec cette variable, on pourrait faire pas mal de choses sympa, mais ici nous allons juste vérifier si le véhicule à bien été créé ou non.
Sur le wiki de la fonction [[createVehicle]], il y a la partie nomée '''Returns''', la fonction va retourner ''false'' si la voiture n'a pas été créé. Ducoups, on va regarder la valeur de la variable ''createdVehicle''.

Voilà notre code complet:
<syntaxhighlight lang="lua">
function createVehicleForPlayer(thePlayer, command, vehicleModel)
local x,y,z = getElementPosition(thePlayer) -- On prent la position du joueur qui a tapé la commande
x = x + 5 -- on ajoute 5 unités à x
local createdVehicle = createVehicle(tonumber(vehicleModel),x,y,z) -- on crée le véhicule demandé par le joueur et on récupère ce que nous retourne la fonction dans la variable createdVehicle
-- On vérifie si la valeur retournée est égal à ''false'' ( ce qui signifie que ça n'a pas marché )
if (createdVehicle == false) then
-- si c'est le cas, on affiche un message d'erreur dans la chatbox mais seulement pour le joueur.
outputChatBox("Erreur lors de la création du véhicule.",thePlayer)
end
end
addCommandHandler("createVehicle", createVehicleForPlayer)
</syntaxhighlight>

Comme vous pouvez le voir, nous avons utilisé une nouvelle fonction: [[outputChatBox]]. Vous devriez maintenant pouvoir regarder la description de cette fonction par vous même.

==Ce que vous devez savoir==
Vous avez déjà lu quelques informations sur les ressources, les commandes et trouvez des fonctions dans le wiki, mais il y a encore beaucoup à apprendre. Cette section vous donnera une vue d'ensemble plutôt courte sur certaines de ces choses, tout en regardant les pages du wiki si possible.
===Les scripts client et serveur===
Vous pouvez avoir déjà remarqué ces termes (serveur/client) quelque part sur ce wiki, le plus souvent pour les fonctions. MTA ne supporte pas seulement les scripts exécuté par le serveur et des commandes (comme celle qu'on vien de faire) ou d'autres fonctions, mais aussi les scripts éxécuté par le client MTA, ceux des joueurs qui se connecte au serveur. La raison est que certaines fonctions de MTA doit être du coté client comme par exemple le GUI - Graphical User Interface - ( Pour tout ce qui est fenêtres, boutons, etc ), d'autres devraient être du côté client parce qu'ils fonctionnent mieux mais d'autres sont mieux pensées pour être du côté serveur ou ne fonctionne tout simplement pas du côté client.

La plupart de vos scripts (gamemodes, maps) seront surement du côté serveur, comme celui que nous avons fait tout à l'heure. Si vous vous heurtez à quelque chose qui ne peut pas être résolu du côté serveur, vous devrez probablement le faire côté client. Pour un script client, vous devriez créer un script ordinaire (par exemple appelé ''client.lua'') et spécifié dans la meta.xml, comme ceci:
<syntaxhighlight lang="xml">
<script src="client.lua" type="client" />
</syntaxhighlight>
L'attribut ''type'' est par defaut 'server', donc nous avons juste besoin de spécifier que c'est un script client. Lorsque vous faites ceci, le fichier va être télecharger par le joueur sur son ordinateur lorsqu'il se connecte au serveur. Plus d'infos: [[Client side scripts]].

===Ressources plus complexes===
La section précédente nous a montré brièvement comment ajouter des scripts clients à la ressource. Penchons nous maintenant sur la ''meta.xml'' et ce qu'elle fait.

====First example - Un script utile====
<syntaxhighlight lang="xml">
/admin_commands
/meta.xml
/commands.lua
/client.lua
</syntaxhighlight>
<syntaxhighlight lang="xml">
<meta>
<info author="Someguy" description="admin commands" />
<script src="commands.lua" />
<script src="client.lua" type="client" />
</meta>
</syntaxhighlight>

* Le "commands.lua" fournit quelques commandes d'admin, comme le fait d'interdire un joueur, en banissant ou quelque chose d'autre ce qui peut être utilisé par l'admin du serveur
* Le "client.lua" fournit un GUI pour être capable d'exécuter les actions mentionnées facilement

Cet exemple de script doit tourner tout le temps (peut être même démarré en même temps que le serveur) car ces commandes d'admin peuvent être appelé à n'importe quelle moment.

====Second example - Un gamemode====
<syntaxhighlight lang="xml">
/counterstrike
/meta.xml
/counterstrike.lua
/buymenu.lua
</syntaxhighlight>
<syntaxhighlight lang="xml">
<meta>
<info author="Quelqu'un" description="Counterstrike remake" type="gamemode" />
<script src="counterstrike.lua" />
<script src="buymenu.lua" type="client" />
</meta>
</syntaxhighlight>

* Le "counterstrike.lua" contient des caractéristiques semblables aux dispositifs suivants :
** Laissez les joueurs choisir leur équipe et les apparaitre
** Fournissez-leur des armes, des cibles et des instructions (peut-être lues d'une carte, voir ci-dessous)
** Définissez les règles du jeu, par exemple. La partie se finie, ce qui se produit quand un joueur meurt
** .. et peut-être encore plus
* Le "buymenu.lua" est un manuscrit du côté client et crée un menu pour acheter des armes

Cet exemple peut s'appeler un gamemode, depuis lui non seulement des intereferes avec le gameplay, mais définit réellement les règles de lui-même. Le "type" attribut indique que cet exemple fonctionne avec [[Map Manager]], encore une autre ressource qui a été écrite par l'équipe de QA pour contrôler des gamemodes et le chargement de carte. On lui recommande fortement que vous basiez vos gamemodes sur les techniques qu'il fournit.

Ceci signifie également que le gamemode ne fonctionnera pas probablement sans carte. Gamemodes devrait toujours être aussi générique comme possible. Un exemple pour une carte est énoncé dans le prochain exemple.

====Troisième exemple - Une carte====
<syntaxhighlight lang="xml">
/cs-airport
/meta.xml
/airport.map
/airport.lua
</syntaxhighlight>
<syntaxhighlight lang="xml">
<meta>
<info author="Quelqu'un" description="Counterstrike airport map" type="map" gamemodes="counterstrike" />
<map src="airport.map" />
<script src="airport.lua" />
</meta>
</syntaxhighlight>

* Le "airport.map" dans le fichier XML fournit des informations au sujet de la carte au gamemode, ceului-ci peut inclure :
** Là où les joueurs devraient apparaitre, avec quelles armes, avec quelle équipe
** Ce qui sont les cibles
** Temps, heure du monde, Limite de temps
** Fournir les véhicules
* Le ''airport.lua'' peut contenir les dispositifs carte-spécifiques, celui-ci peut inclure :
** En ouvrant une certaine porte/faisant éclater quelque chose quand quelque chose de spécifique se produit
** Créez ou déplacez quelques objets faits sur commande, ou manoeuvrez les objets qui sont créés dans le fichier .map
** .. toute autre chose carte-spécifiques

Comme vous pouvez voir, l'attribut "type" a changé en 'map', dire [[Map Manager]] que cette ressource est une carte, tandis que l'attribut "gamemodes" indique pour quels gamemodes cette carte est valide, dans ce cas-ci le gamemode de l'exemple ci-dessus.
Ce qui peut venir comme une surprise est qu'il y a aussi un script dans la ressource de Carte. Évidemment ce n'est pas nécessairement nécessaire dans une carte, mais ouvre une large gamme de possibilités pour les producteurs de carte pour créer leur propre monde dans les règles du gamemode pour lequel ils le créent.

Le "airport.map" pourrait être semblable à ceci :
<syntaxhighlight lang="xml">
<map mode="deathmatch" version="1.0">
<terrorists>
<spawnpoint posX="2332.23" posY="-12232.33" posZ="4.42223" skins="23-40" />
</terrorists>
<counterterrorists>
<spawnpoint posX="2334.23443" posY="-12300.233" posZ="10.2344" skins="40-50" />
</counterterrorists>

<bomb posX="23342.23" posY="" posZ="" />

<vehicle posX="" posY="" posZ="" model="602" />
<vehicle posX="" posY="" posZ="" model="603" />
</map>
</syntaxhighlight>

Quand un gamemode est commencé avec une carte, les ressources de carte est automatiquement commencé par le mapmanager et les renseignements qu'il contient peut être lu par la ressource gamemode. Quand la carte change, la ressource de carte actuelle est arrêtée et la ressource de carte suivante est commencée. Pour une explication plus détaillée et des exemples de comment les ressources de carte sont utilisées dans le script principal, visitez s'il vous plaît la page [[Writing Gamemodes]].

===Événements===
Les événements sont la façon que MTA dit aux scripts des choses qui arrivent. Par exemple quand un joueur meurt, le [[onPlayerWasted]] l'événement est déclenché. Pour exécuter n'importe quelles actions quand un joueur meurt, vous devez vous préparer similiar à l'ajoutant d'un dresseur d'ordre, comme montré dans [[#Writing_the_script|the first chapter]].

Cet exemple produiras un message avec le nom du joueur qui est mort :
<syntaxhighlight lang="lua">
function playerDied(totalAmmo, killer, killerWeapon, bodypart)
outputChatBox(getPlayerName(source).." died!")
end
addEventHandler("onPlayerWasted",getRootElement(),playerDied)
</syntaxhighlight>

Au lieu de montrer que les arguments sont nécessaires, la page de documentation pour les spectacles d'Événements quels paramètres sont passés à la handler function, similaire à la voie un [[*About_command_handlers|command handler]] fait, juste qu'il se distingue de l'événement à l'événement. Un autre point important est la variable "source", qui existe dans les handler function. Ils ne doivent pas être ajoutés à la liste de paramètre de la fonction, mais cela existe toujours . Il a une différente valeur de l'événement à l'événement, pour les événements de joueur (comme dans l'exemple au-dessus) c'est l'élément de joueur. Comme un autre exemple, vous pouvez jeter un coup d'œil au script de joueur frayant fondamental dans la première section pour recevoir une idée comment "source" est utilisé.

==Où aller d'ici==
Vous devriez maintenant être familiers avec les aspects les plus fondamentaux de MTA scripting et aussi un peu avec la documentation. Le [[Main_Page]] vous fournit des liens vers plus de renseignements, Classes de travaux dirigés et Références qui permettent un coup d'oeil plus profond dans les thèmes dont vous désirez apprendre.

D'ici nous recommandons de lire le [[debugging]] la classe de travaux dirigés. De bonnes adresses déboguantes sont une nécessité absolue quand vous faites des scripts.

[[ru:Scripting Introduction]]
[[it:Introduzione allo scripting]]
[[es:Introducción a la Programación]]

FR/Introduction Programmation

2012-06-30T08:01:24Z

Citizen: /* Troisième exemple - une carte */

Les ressources sont les parties clées de MTA. Une ressource est un dossier ou un .zip qui contient plusieurs fichiers, ainsi qu'une meta qui dit au serveur comment la resource doit-elle être chargée. Une ressource peut être comparée comme un programme qu'on peut lancer ou arrêter, il est possible de lancer plusieurs ressources en même temps.

Tout ce qui a un rapport avec la programmation se passe dans les ressources, se que fait la ressource, définie si c'est un gamemode, une map or quelquechose d'autre. MTA s'installe avec des resources que vous pouvez facultativement utiliser dans vos gamemodes, comme la ressource "maplimits" pour garder les joueurs dans une certaine zone ou encore "deathpickups" pour créer des pickups pour ramasser une arme.

'''La première chose à faire avant de pouvoir programmer en lua, c'est de se procurer un editeur de texte qui supporte le lua. Il vous sera beaucoups plus facile que de le faire avec le bloc-note de Windows. Nous vous recommendons donc [http://notepad-plus.sourceforge.net/uk/site.htm Notepad++] ou [http://luaedit.sourceforge.net/ LuaEdit]. Il y a aussi un logiciel non officiel [[MTASE|MTA Script Editor]] ( malheureusement l'auteur ne travail plus dessus ) que vous pouvez tester.'''

==Créer un script qui fonctionne==
Nous allons voir tout d'abord comment créer un simple script étapes par étapes qui permetra aux joueurs de se deplacer dans la ville. Dans ce tutoriel, on utilisera notepadd++.
===Où sont tous les scripts ?===
Laissez moi d'abord vous présenter comment s'oranise une ressource. Allez dans votre dossier MTA San et et suivez le chemin suivant:

/serveur/mods/deathmatch/resources/

Vous y verez de nombreux fichier avec l'extension .zip, se sont des ressources avec à l'intérieur des exemples de scripts . Toutes les ressources chargées sont dézippé par le serveur afin de pouvoir les exécuter ( les .zip ne sont pas obligatiores, vous pouvez aussi laissez votre ressource en tant que dossier ). Pour créer votre propre ressource, créez simplement un nouveau dossier et nommez le comme vous voulez ( Ne pas utiliser d'espace, utilisez plutôt un _ ) . Nommez le "myserveur" pour ce tutoriel.

Maintenant entrez dans votre dossier. Le chemain devrait donc être

/serveur/mods/deathmatch/resources/myserveur/

===Identifier votre ressource===
Pour que le serveur puisse savoir ce que contient votre ressource, un fichier ''meta.xml'' doit être créé afin d'établir une liste du contenu du dossier. Cette 'meta.xml' doit être à la racine de votre ressource ( et non pas dans un autre sous-dossier ), donc dans le dossier "myserveur" dans notre cas. Donc ouvrez notepadd++, créer un nouveau fichier (Ctrl+N), puis faite "Enregistrez sous ..." (Ctrl+Alt+S), dans "Nom:" vous écrivez "meta" et dans "Type:", sélectionnez "*.xml" ( avant-dernier de la liste ), sauvegardez le dans votre dossier "myserveur".

Maintenant, ecrivez le code suivant dans votre ''meta.xml'':
<syntaxhighlight lang="xml">
<meta>
<info author="Votre Nom" type="gamemode" name="Mon serveur" description="Mon premier serveur MTA" />
<script src="script.lua" />
</meta>
</syntaxhighlight>
Dans la balise ''<info />'', il y a le champ "type" qui indique si la ressource est un ''gamemode'' ou une ''map'', on y reviendra plus tard. Un gamemode est ce dont vous avez besoin pour que votre serveur est une base.

La balise ''<script />'' indique les scripts qui sont dans la ressource, que l'on va maintenant créer.
===Créer un script simple===
Notez que dans la balise ''<script />'', le fichier .lua n'est pas dans un autre sous-dossier. Donc on va créer notre script.lua au même endroit que notre meta.xml ( Reproduisez la même opération mais "Nom:" écrivez 'script' et pour "Type:" choisissez 'Lua(*.lua)' ) puis copier-coller le code suivant:
<syntaxhighlight lang="lua">
function joinHandler()
local x = 1959.55
local y = -1714.46
local z = 10
spawnPlayer(source, x, y, z)
fadeCamera(source, true)
setCameraTarget(source, source)
outputChatBox("Bienvenue sur mon serveur", source)
end
addEventHandler("onPlayerJoin", getRootElement(), joinHandler)
</syntaxhighlight>
Ce script va fous faire apparître aux coordonnées (x, y, z) spécifié dans le code, lorsque vous connecterez au serveur. La fonction ''fadeCamera'' sinon l'écran restera noir. Vous devez aussi dire à la camera de suivre le joueur grâce à la fonction 'setCameraTarget' (sinon il vera une mer bleu).

La variable '''source''' indique qui 'déclenche' la fonction. Le fonction se 'déclenche' lorsqu'un joueur rejoind le serveur, vous utiliserez cette variable pour voir qui à rejoind le serveur. Donc lorsque un joueur( "la source" ) rejoindra notre serveur, on le fera apparaître aux coordonnées indiquées .

Focalisons-nous sur [[addEventHandler]], vous pouver voir 3 choses: 'onPlayerJoin', qui indique quand éxécuter la fonction X. getRootElement(), qui indique qui/quoi peut être déclencher la fonction (getRootElement() veut dire toutes les choses et tous les joueurs). Et enfin la fonction X à éxecuter ( ici joinHandler ). Pour les autres details, nous verrons plus tard dans d'autres exemples mais tout d'abord testons notre premier gamemode!

===Lancer le gamemode===
Pour lancer le serveur, lancer simplement le 'MTA Server.exe' qui se trouve dans votre dossier 'MTA San et\server'. Une liste d'info concernant le serveur apparaîtra en premier; notez le port du serveur ( 22003 par défaut ), vous en aurez besoin pour rejoindre le serveur. Après, le serveur charge toutes les ressources du dossier 'resource', et enfin "ready to accept connections!"

Avant de pouvoir vous connecter, vous devez lancer votre gamemode. Tapez "start myserver" et appuyer sur Entrer. Le serveur va alors lancer le gamemode que nous avons créé, et nous affichera aussi les erreurs s'il y en a. Maintenant, vous pouvez maintenant lancer MTA, cliquez sur "Quick Connect" et ecrivez ceci: Dans Host: le1er champ: 127.0.0.1 ou localhost ( cela signifie que vous vous connectez au serveur du pc actuel ) et le 2ème champ: le port ( ici 22003 ) et cliquez sur 'Connect'. Si tout se passe bien, après quelques secondes, vous devriez apparaître et pouvoir allez où vous voulez.

Ensuite nous allons créer une commande que les joueurs pourront utiliser pour faire apparître une voiture à coté d'eux.

==Créer une commande==
Revenons à l'intérieur de notre ''script.lua''. Tout d'abord, nous devons créer une fonction qu'on pourra appeler/éxécuter grâce à notre commande et la fonction 'addCommandHandler' afin de créer la commande que les joueurs pourront taper dans le chat( T ) ou la console( F8 ).

<syntaxhighlight lang="lua">
-- On crée la fonction qui sera appelée par notre commande avec les arguments: thePlayer, command, vehicleModel
function createVehicleForPlayer(thePlayer, commandName, vehicleModel)
-- Ici on crée le véhicule
end
-- on crée la commande et on l'attache à notre fonction
addCommandHandler("createVehicle", createVehicleForPlayer)
</syntaxhighlight>
''Note: Grâce au wiki, vous pouvez cliquer sur le nom des fonctions et cela vous redirigera sur la documentation de cette fonction.''

====A propos du addCommandHandler====
Le premier argument du [[addCommandHandler]] est le nom de la commande the player will be able to enter, le second le nom de la fonction à appeler, dans notre cas, ''createVehicleForPlayer''.

Si vous avez déjà de l'expérience dans le codage, vous savez qu'un fonction s'appelle comme ceci:
<syntaxhighlight lang="lua">
nomDeLaFonction(argument1, argument2, argument3, ..)
</syntaxhighlight>
Si l'on regarde bien l'exemple ci-dessus, nous pouvons voir que l'argument1 est thePlayer and argument2 le commandName. thePlayer est celui qui à tapé la commande et commandName contient le nom de la commande qu'il à tapé. Donc si un joueur tape "/greet", cet argument va contenir "greet". Argument3 c'est ce que le joueur à tapé en plus de la commande, vous allez apprendre ceci dans le tutoriel. N'oubliez jamais que les deux premiers arguments sont les arguments standards, mais vous pouvez les renommé si vous voulez, seul l'ordre est important.

Par exemple: Un joueur tape "createVehicle 468" pour faire aparaître une Sanchez, la fonction addCommandHandler va appeller notre fonction createVehicleForPlayer, comme ceci:
<syntaxhighlight lang="lua">
createVehicleForPlayer(thePlayer,"createVehicle","468") -- thePlayer est l'élement joueur qui a tapé la commande
</syntaxhighlight>
Comme nous pouvons le voir, ll fournit plusieurs paramètres: le joueur qui a tapé la commande, la commande qu'il a tapé, et n'importe quelle texte qu'il a mis après, dans notre cas, "468" comme id de la Sanchez. Les deux premiers paramètres sont les même pour tous les addCommandHandler qu'on peut retrouver sur la page du [[addEventHandler]]. Vous devez toujours définir au moins ces deux paramètres pour utiliser les arguments après eux (par exemple pour traiter le texte qui a été entré après la commande, comme dans notre exemple le modèle du véhicule).

''Note: Vous devez créer la commande APRES la fonction que vous allez utiliser pour cette commande, sinon il ne trouvera pas la fonction.''

====Ecrire la fonction====
Pour remplir notre fonction d'instructions, nous devons d'abord pensez à ce que nous devons faire:
* Récupérer la position du joueur, donc on connaitra la position où faire apparaître le véhicule (on veut le faire apparaître à droite du joueur)
* Calculer la position où faire apparître le véhicule (nous ne voulons pas que le véhicule apparaisse dans le joueur)
* Faire apparître les véhicule
* Vérifier si le véhicule a bien apparus, ou aficher un message d'erreur.

Pour ça, nous devons utiliser plusieurs fonctions. Pour trouver la fonction que nous devons utiliser, il faut aller faire un tour dans la [[Scripting Functions|La liste des fonctions serveur]]. D'abord nous avons besoin d'une fonction pour obtenir la position du joueur. Puisque les joueurs sont des éléments, nous devons allez dans la rubrique '''Element functions''' où l'on pourra trouver la fonction [[getElementPosition]]. En cliquant sur le nom de la fonction, le wiki va vous afficher sa description. On peut y voir la syntaxe, qu'est-ce que la fonction retourne. La syntaxe nous montre les argument qu'on peut ou qu'on doit envoyer.

Pour [[getElementPosition]], la syntaxe est:
<syntaxhighlight lang="lua">
float, float, float getElementPosition ( element theElement )
</syntaxhighlight>

Les trois float devant le nom de la fonction est le type de variable que la fonction nous retourne. Dans notre cas, la fonction retourne trois nombres à virgule(x, y et z). Dans les parenthèses, on peut voir les arguments que l'on doit envoyer, dans notre cas, l'element dont on veut récupérer la position, le joueur dans notre exemple.

<syntaxhighlight lang="lua">
function createVehicleForPlayer(thePlayer, command, vehicleModel)
-- on récupère la position x,y,z dans des variables locales
-- une variable locale n'existe que dans le "périmètre" actuel. Ici, les variable x, y et z sont des variables locales qui se détruiront à la fin de la fonction.
local x,y,z = getElementPosition(thePlayer)
end
</syntaxhighlight>

Ensuite, il faut s'assurer que le véhicule n'apparaît pas directement dans le joueur, donc on ajoute quelques unités à la variable ''x'', qui le fera apparaître plus à l'est par rapport au joueur.

<syntaxhighlight lang="lua">
function createVehicleForPlayer(thePlayer, command, vehicleModel)
local x,y,z = getElementPosition(thePlayer) -- On prent la position du joueur qui a tapé la commande
x = x + 5 -- on ajoute 5 unité sur l'axes des x
end
</syntaxhighlight>

Maintenant nous avons besoin d'une autre fonction, celle qui va faire apparaître le véhicule. Nous allons la cherché encore une fois dans la [[Scripting Functions|liste des fonctions serveur]], mais cette fois, comme nous parlons d'un véhicule, nous devons donc aller dans la catégorie'''Vehicle functions''', où l'on va trouver la fonction [[createVehicle]]. Dans la syntaxe, nous pouvons voir que cette fonction ne retourne qu'une seule variable, le véhicule ( de type élément ) que nous venons de créer. Nous pouvons aussi voir qu'il y a des arguments entre crochets [], cela veut dire que ce sont des arguments optionels.

Nous avons déjà tous les arguments pour la fonction [[createVehicle]] dans notre fonction: La position que nous avons juste calculée dans les variables "x, y, z" et l'id du véhicule que nous avons fourni par la commande ("/createVehicle 468") et qui est stocké dans la variable ''vehicleModel''.

<syntaxhighlight lang="lua">
function createVehicleForPlayer(thePlayer, command, vehicleModel)
local x,y,z = getElementPosition(thePlayer) -- récupere la position du joueur dans les variables x, y et z
x = x + 5 -- rajoute 5 unités sur x
-- on crée le véhicule et on enregistre l'élément de type "vehicle" dans la variable ''createdVehicle''
local createdVehicle = createVehicle(tonumber(vehicleModel),x,y,z)
end
</syntaxhighlight>

Avec cette variable, on pourrait faire pas mal de choses sympa, mais ici nous allons juste vérifier si le véhicule à bien été créé ou non.
Sur le wiki de la fonction [[createVehicle]], il y a la partie nomée '''Returns''', la fonction va retourner ''false'' si la voiture n'a pas été créé. Ducoups, on va regarder la valeur de la variable ''createdVehicle''.

Voilà notre code complet:
<syntaxhighlight lang="lua">
function createVehicleForPlayer(thePlayer, command, vehicleModel)
local x,y,z = getElementPosition(thePlayer) -- On prent la position du joueur qui a tapé la commande
x = x + 5 -- on ajoute 5 unités à x
local createdVehicle = createVehicle(tonumber(vehicleModel),x,y,z) -- on crée le véhicule demandé par le joueur et on récupère ce que nous retourne la fonction dans la variable createdVehicle
-- On vérifie si la valeur retournée est égal à ''false'' ( ce qui signifie que ça n'a pas marché )
if (createdVehicle == false) then
-- si c'est le cas, on affiche un message d'erreur dans la chatbox mais seulement pour le joueur.
outputChatBox("Erreur lors de la création du véhicule.",thePlayer)
end
end
addCommandHandler("createVehicle", createVehicleForPlayer)
</syntaxhighlight>

Comme vous pouvez le voir, nous avons utilisé une nouvelle fonction: [[outputChatBox]]. Vous devriez maintenant pouvoir regarder la description de cette fonction par vous même.

==Ce que vous devez savoir==
Vous avez déjà lu quelques informations sur les ressources, les commandes et trouvez des fonctions dans le wiki, mais il y a encore beaucoup à apprendre. Cette section vous donnera une vue d'ensemble plutôt courte sur certaines de ces choses, tout en regardant les pages du wiki si possible.
===Les scripts client et serveur===
Vous pouvez avoir déjà remarqué ces termes (serveur/client) quelque part sur ce wiki, le plus souvent pour les fonctions. MTA ne supporte pas seulement les scripts exécuté par le serveur et des commandes (comme celle qu'on vien de faire) ou d'autres fonctions, mais aussi les scripts éxécuté par le client MTA, ceux des joueurs qui se connecte au serveur. La raison est que certaines fonctions de MTA doit être du coté client comme par exemple le GUI - Graphical User Interface - ( Pour tout ce qui est fenêtres, boutons, etc ), d'autres devraient être du côté client parce qu'ils fonctionnent mieux mais d'autres sont mieux pensées pour être du côté serveur ou ne fonctionne tout simplement pas du côté client.

La plupart de vos scripts (gamemodes, maps) seront surement du côté serveur, comme celui que nous avons fait tout à l'heure. Si vous vous heurtez à quelque chose qui ne peut pas être résolu du côté serveur, vous devrez probablement le faire côté client. Pour un script client, vous devriez créer un script ordinaire (par exemple appelé ''client.lua'') et spécifié dans la meta.xml, comme ceci:
<syntaxhighlight lang="xml">
<script src="client.lua" type="client" />
</syntaxhighlight>
L'attribut ''type'' est par defaut 'server', donc nous avons juste besoin de spécifier que c'est un script client. Lorsque vous faites ceci, le fichier va être télecharger par le joueur sur son ordinateur lorsqu'il se connecte au serveur. Plus d'infos: [[Client side scripts]].

===Ressources plus complexes===
La section précédente nous a montré brièvement comment ajouter des scripts clients à la ressource. Penchons nous maintenant sur la ''meta.xml'' et ce qu'elle fait.

====First example - Un script utile====
<syntaxhighlight lang="xml">
/admin_commands
/meta.xml
/commands.lua
/client.lua
</syntaxhighlight>
<syntaxhighlight lang="xml">
<meta>
<info author="Someguy" description="admin commands" />
<script src="commands.lua" />
<script src="client.lua" type="client" />
</meta>
</syntaxhighlight>

* Le "commands.lua" fournit quelques commandes d'admin, comme le fait d'interdire un joueur, en banissant ou quelque chose d'autre ce qui peut être utilisé par l'admin du serveur
* Le "client.lua" fournit un GUI pour être capable d'exécuter les actions mentionnées facilement

Cet exemple de script doit tourner tout le temps (peut être même démarré en même temps que le serveur) car ces commandes d'admin peuvent être appelé à n'importe quelle moment.

====Second example - Un gamemode====
<syntaxhighlight lang="xml">
/counterstrike
/meta.xml
/counterstrike.lua
/buymenu.lua
</syntaxhighlight>
<syntaxhighlight lang="xml">
<meta>
<info author="Quelqu'un" description="Counterstrike remake" type="gamemode" />
<script src="counterstrike.lua" />
<script src="buymenu.lua" type="client" />
</meta>
</syntaxhighlight>

* Le "counterstrike.lua" contient des caractéristiques semblables aux dispositifs suivants :
** Laissez les joueurs choisir leur équipe et les apparaitre
** Fournissez-leur des armes, des cibles et des instructions (peut-être lues d'une carte, voir ci-dessous)
** Définissez les règles du jeu, par exemple. La partie se finie, ce qui se produit quand un joueur meurt
** .. et peut-être encore plus
* Le "buymenu.lua" est un manuscrit du côté client et crée un menu pour acheter des armes

Cet exemple peut s'appeler un gamemode, depuis lui non seulement des intereferes avec le gameplay, mais définit réellement les règles de lui-même. Le "type" attribut indique que cet exemple fonctionne avec [[Map Manager]], encore une autre ressource qui a été écrite par l'équipe de QA pour contrôler des gamemodes et le chargement de carte. On lui recommande fortement que vous basiez vos gamemodes sur les techniques qu'il fournit.

Ceci signifie également que le gamemode ne fonctionnera pas probablement sans carte. Gamemodes devrait toujours être aussi générique comme possible. Un exemple pour une carte est énoncé dans le prochain exemple.

====Troisième exemple - Une carte====
<syntaxhighlight lang="xml">
/cs-airport
/meta.xml
/airport.map
/airport.lua
</syntaxhighlight>
<syntaxhighlight lang="xml">
<meta>
<info author="Quelsqu'un" description="Counterstrike airport map" type="map" gamemodes="counterstrike" />
<map src="airport.map" />
<script src="airport.lua" />
</meta>
</syntaxhighlight>

* Le "airport.map" dans le fichier XML fournit des informations au sujet de la carte au gamemode, ceului-ci peut inclure :
** Là où les joueurs devraient apparaitre, avec quelles armes, avec quelle équipe
** Ce qui sont les cibles
** Temps, heure du monde, Limite de temps
** Fournir les véhicules
* Le ''airport.lua'' peut contenir les dispositifs carte-spécifiques, celui-ci peut inclure :
** En ouvrant une certaine porte/faisant éclater quelque chose quand quelque chose de spécifique se produit
** Créez ou déplacez quelques objets faits sur commande, ou manoeuvrez les objets qui sont créés dans le fichier .map
** .. toute autre chose carte-spécifiques

Comme vous pouvez voir, l'attribut "type" a changé en 'map', dire [[Map Manager]] que cette ressource est une carte, tandis que l'attribut "gamemodes" indique pour quels gamemodes cette carte est valide, dans ce cas-ci le gamemode de l'exemple ci-dessus.
Ce qui peut venir comme une surprise est qu'il y a aussi un script dans la ressource de Carte. Évidemment ce n'est pas nécessairement nécessaire dans une carte, mais ouvre une large gamme de possibilités pour les producteurs de carte pour créer leur propre monde dans les règles du gamemode pour lequel ils le créent.

Le "airport.map" pourrait être semblable à ceci :
<syntaxhighlight lang="xml">
<map mode="deathmatch" version="1.0">
<terrorists>
<spawnpoint posX="2332.23" posY="-12232.33" posZ="4.42223" skins="23-40" />
</terrorists>
<counterterrorists>
<spawnpoint posX="2334.23443" posY="-12300.233" posZ="10.2344" skins="40-50" />
</counterterrorists>

<bomb posX="23342.23" posY="" posZ="" />

<vehicle posX="" posY="" posZ="" model="602" />
<vehicle posX="" posY="" posZ="" model="603" />
</map>
</syntaxhighlight>

Quand un gamemode est commencé avec une carte, les ressources de carte est automatiquement commencé par le mapmanager et les renseignements qu'il contient peut être lu par la ressource gamemode. Quand la carte change, la ressource de carte actuelle est arrêtée et la ressource de carte suivante est commencée. Pour une explication plus détaillée et des exemples de comment les ressources de carte sont utilisées dans le script principal, visitez s'il vous plaît la page [[Writing Gamemodes]].

===Événements===
Les événements sont la façon que MTA dit aux scripts des choses qui arrivent. Par exemple quand un joueur meurt, le [[onPlayerWasted]] l'événement est déclenché. Pour exécuter n'importe quelles actions quand un joueur meurt, vous devez vous préparer similiar à l'ajoutant d'un dresseur d'ordre, comme montré dans [[#Writing_the_script|the first chapter]].

Cet exemple produiras un message avec le nom du joueur qui est mort :
<syntaxhighlight lang="lua">
function playerDied(totalAmmo, killer, killerWeapon, bodypart)
outputChatBox(getPlayerName(source).." died!")
end
addEventHandler("onPlayerWasted",getRootElement(),playerDied)
</syntaxhighlight>

Au lieu de montrer que les arguments sont nécessaires, la page de documentation pour les spectacles d'Événements quels paramètres sont passés à la handler function, similaire à la voie un [[*About_command_handlers|command handler]] fait, juste qu'il se distingue de l'événement à l'événement. Un autre point important est la variable "source", qui existe dans les handler function. Ils ne doivent pas être ajoutés à la liste de paramètre de la fonction, mais cela existe toujours . Il a une différente valeur de l'événement à l'événement, pour les événements de joueur (comme dans l'exemple au-dessus) c'est l'élément de joueur. Comme un autre exemple, vous pouvez jeter un coup d'œil au script de joueur frayant fondamental dans la première section pour recevoir une idée comment "source" est utilisé.

==Où aller d'ici==
Vous devriez maintenant être familiers avec les aspects les plus fondamentaux de MTA scripting et aussi un peu avec la documentation. Le [[Main_Page]] vous fournit des liens vers plus de renseignements, Classes de travaux dirigés et Références qui permettent un coup d'oeil plus profond dans les thèmes dont vous désirez apprendre.

D'ici nous recommandons de lire le [[debugging]] la classe de travaux dirigés. De bonnes adresses déboguantes sont une nécessité absolue quand vous faites des scripts.

[[ru:Scripting Introduction]]
[[it:Introduzione allo scripting]]
[[es:Introducción a la Programación]]

FR/Introduction Programmation

2012-06-30T08:01:01Z

Citizen: Correction de phrase + réécriture de certaine pour en améliorer la compréhension

Les ressources sont les parties clées de MTA. Une ressource est un dossier ou un .zip qui contient plusieurs fichiers, ainsi qu'une meta qui dit au serveur comment la resource doit-elle être chargée. Une ressource peut être comparée comme un programme qu'on peut lancer ou arrêter, il est possible de lancer plusieurs ressources en même temps.

Tout ce qui a un rapport avec la programmation se passe dans les ressources, se que fait la ressource, définie si c'est un gamemode, une map or quelquechose d'autre. MTA s'installe avec des resources que vous pouvez facultativement utiliser dans vos gamemodes, comme la ressource "maplimits" pour garder les joueurs dans une certaine zone ou encore "deathpickups" pour créer des pickups pour ramasser une arme.

'''La première chose à faire avant de pouvoir programmer en lua, c'est de se procurer un editeur de texte qui supporte le lua. Il vous sera beaucoups plus facile que de le faire avec le bloc-note de Windows. Nous vous recommendons donc [http://notepad-plus.sourceforge.net/uk/site.htm Notepad++] ou [http://luaedit.sourceforge.net/ LuaEdit]. Il y a aussi un logiciel non officiel [[MTASE|MTA Script Editor]] ( malheureusement l'auteur ne travail plus dessus ) que vous pouvez tester.'''

==Créer un script qui fonctionne==
Nous allons voir tout d'abord comment créer un simple script étapes par étapes qui permetra aux joueurs de se deplacer dans la ville. Dans ce tutoriel, on utilisera notepadd++.
===Où sont tous les scripts ?===
Laissez moi d'abord vous présenter comment s'oranise une ressource. Allez dans votre dossier MTA San et et suivez le chemin suivant:

/serveur/mods/deathmatch/resources/

Vous y verez de nombreux fichier avec l'extension .zip, se sont des ressources avec à l'intérieur des exemples de scripts . Toutes les ressources chargées sont dézippé par le serveur afin de pouvoir les exécuter ( les .zip ne sont pas obligatiores, vous pouvez aussi laissez votre ressource en tant que dossier ). Pour créer votre propre ressource, créez simplement un nouveau dossier et nommez le comme vous voulez ( Ne pas utiliser d'espace, utilisez plutôt un _ ) . Nommez le "myserveur" pour ce tutoriel.

Maintenant entrez dans votre dossier. Le chemain devrait donc être

/serveur/mods/deathmatch/resources/myserveur/

===Identifier votre ressource===
Pour que le serveur puisse savoir ce que contient votre ressource, un fichier ''meta.xml'' doit être créé afin d'établir une liste du contenu du dossier. Cette 'meta.xml' doit être à la racine de votre ressource ( et non pas dans un autre sous-dossier ), donc dans le dossier "myserveur" dans notre cas. Donc ouvrez notepadd++, créer un nouveau fichier (Ctrl+N), puis faite "Enregistrez sous ..." (Ctrl+Alt+S), dans "Nom:" vous écrivez "meta" et dans "Type:", sélectionnez "*.xml" ( avant-dernier de la liste ), sauvegardez le dans votre dossier "myserveur".

Maintenant, ecrivez le code suivant dans votre ''meta.xml'':
<syntaxhighlight lang="xml">
<meta>
<info author="Votre Nom" type="gamemode" name="Mon serveur" description="Mon premier serveur MTA" />
<script src="script.lua" />
</meta>
</syntaxhighlight>
Dans la balise ''<info />'', il y a le champ "type" qui indique si la ressource est un ''gamemode'' ou une ''map'', on y reviendra plus tard. Un gamemode est ce dont vous avez besoin pour que votre serveur est une base.

La balise ''<script />'' indique les scripts qui sont dans la ressource, que l'on va maintenant créer.
===Créer un script simple===
Notez que dans la balise ''<script />'', le fichier .lua n'est pas dans un autre sous-dossier. Donc on va créer notre script.lua au même endroit que notre meta.xml ( Reproduisez la même opération mais "Nom:" écrivez 'script' et pour "Type:" choisissez 'Lua(*.lua)' ) puis copier-coller le code suivant:
<syntaxhighlight lang="lua">
function joinHandler()
local x = 1959.55
local y = -1714.46
local z = 10
spawnPlayer(source, x, y, z)
fadeCamera(source, true)
setCameraTarget(source, source)
outputChatBox("Bienvenue sur mon serveur", source)
end
addEventHandler("onPlayerJoin", getRootElement(), joinHandler)
</syntaxhighlight>
Ce script va fous faire apparître aux coordonnées (x, y, z) spécifié dans le code, lorsque vous connecterez au serveur. La fonction ''fadeCamera'' sinon l'écran restera noir. Vous devez aussi dire à la camera de suivre le joueur grâce à la fonction 'setCameraTarget' (sinon il vera une mer bleu).

La variable '''source''' indique qui 'déclenche' la fonction. Le fonction se 'déclenche' lorsqu'un joueur rejoind le serveur, vous utiliserez cette variable pour voir qui à rejoind le serveur. Donc lorsque un joueur( "la source" ) rejoindra notre serveur, on le fera apparaître aux coordonnées indiquées .

Focalisons-nous sur [[addEventHandler]], vous pouver voir 3 choses: 'onPlayerJoin', qui indique quand éxécuter la fonction X. getRootElement(), qui indique qui/quoi peut être déclencher la fonction (getRootElement() veut dire toutes les choses et tous les joueurs). Et enfin la fonction X à éxecuter ( ici joinHandler ). Pour les autres details, nous verrons plus tard dans d'autres exemples mais tout d'abord testons notre premier gamemode!

===Lancer le gamemode===
Pour lancer le serveur, lancer simplement le 'MTA Server.exe' qui se trouve dans votre dossier 'MTA San et\server'. Une liste d'info concernant le serveur apparaîtra en premier; notez le port du serveur ( 22003 par défaut ), vous en aurez besoin pour rejoindre le serveur. Après, le serveur charge toutes les ressources du dossier 'resource', et enfin "ready to accept connections!"

Avant de pouvoir vous connecter, vous devez lancer votre gamemode. Tapez "start myserver" et appuyer sur Entrer. Le serveur va alors lancer le gamemode que nous avons créé, et nous affichera aussi les erreurs s'il y en a. Maintenant, vous pouvez maintenant lancer MTA, cliquez sur "Quick Connect" et ecrivez ceci: Dans Host: le1er champ: 127.0.0.1 ou localhost ( cela signifie que vous vous connectez au serveur du pc actuel ) et le 2ème champ: le port ( ici 22003 ) et cliquez sur 'Connect'. Si tout se passe bien, après quelques secondes, vous devriez apparaître et pouvoir allez où vous voulez.

Ensuite nous allons créer une commande que les joueurs pourront utiliser pour faire apparître une voiture à coté d'eux.

==Créer une commande==
Revenons à l'intérieur de notre ''script.lua''. Tout d'abord, nous devons créer une fonction qu'on pourra appeler/éxécuter grâce à notre commande et la fonction 'addCommandHandler' afin de créer la commande que les joueurs pourront taper dans le chat( T ) ou la console( F8 ).

<syntaxhighlight lang="lua">
-- On crée la fonction qui sera appelée par notre commande avec les arguments: thePlayer, command, vehicleModel
function createVehicleForPlayer(thePlayer, commandName, vehicleModel)
-- Ici on crée le véhicule
end
-- on crée la commande et on l'attache à notre fonction
addCommandHandler("createVehicle", createVehicleForPlayer)
</syntaxhighlight>
''Note: Grâce au wiki, vous pouvez cliquer sur le nom des fonctions et cela vous redirigera sur la documentation de cette fonction.''

====A propos du addCommandHandler====
Le premier argument du [[addCommandHandler]] est le nom de la commande the player will be able to enter, le second le nom de la fonction à appeler, dans notre cas, ''createVehicleForPlayer''.

Si vous avez déjà de l'expérience dans le codage, vous savez qu'un fonction s'appelle comme ceci:
<syntaxhighlight lang="lua">
nomDeLaFonction(argument1, argument2, argument3, ..)
</syntaxhighlight>
Si l'on regarde bien l'exemple ci-dessus, nous pouvons voir que l'argument1 est thePlayer and argument2 le commandName. thePlayer est celui qui à tapé la commande et commandName contient le nom de la commande qu'il à tapé. Donc si un joueur tape "/greet", cet argument va contenir "greet". Argument3 c'est ce que le joueur à tapé en plus de la commande, vous allez apprendre ceci dans le tutoriel. N'oubliez jamais que les deux premiers arguments sont les arguments standards, mais vous pouvez les renommé si vous voulez, seul l'ordre est important.

Par exemple: Un joueur tape "createVehicle 468" pour faire aparaître une Sanchez, la fonction addCommandHandler va appeller notre fonction createVehicleForPlayer, comme ceci:
<syntaxhighlight lang="lua">
createVehicleForPlayer(thePlayer,"createVehicle","468") -- thePlayer est l'élement joueur qui a tapé la commande
</syntaxhighlight>
Comme nous pouvons le voir, ll fournit plusieurs paramètres: le joueur qui a tapé la commande, la commande qu'il a tapé, et n'importe quelle texte qu'il a mis après, dans notre cas, "468" comme id de la Sanchez. Les deux premiers paramètres sont les même pour tous les addCommandHandler qu'on peut retrouver sur la page du [[addEventHandler]]. Vous devez toujours définir au moins ces deux paramètres pour utiliser les arguments après eux (par exemple pour traiter le texte qui a été entré après la commande, comme dans notre exemple le modèle du véhicule).

''Note: Vous devez créer la commande APRES la fonction que vous allez utiliser pour cette commande, sinon il ne trouvera pas la fonction.''

====Ecrire la fonction====
Pour remplir notre fonction d'instructions, nous devons d'abord pensez à ce que nous devons faire:
* Récupérer la position du joueur, donc on connaitra la position où faire apparaître le véhicule (on veut le faire apparaître à droite du joueur)
* Calculer la position où faire apparître le véhicule (nous ne voulons pas que le véhicule apparaisse dans le joueur)
* Faire apparître les véhicule
* Vérifier si le véhicule a bien apparus, ou aficher un message d'erreur.

Pour ça, nous devons utiliser plusieurs fonctions. Pour trouver la fonction que nous devons utiliser, il faut aller faire un tour dans la [[Scripting Functions|La liste des fonctions serveur]]. D'abord nous avons besoin d'une fonction pour obtenir la position du joueur. Puisque les joueurs sont des éléments, nous devons allez dans la rubrique '''Element functions''' où l'on pourra trouver la fonction [[getElementPosition]]. En cliquant sur le nom de la fonction, le wiki va vous afficher sa description. On peut y voir la syntaxe, qu'est-ce que la fonction retourne. La syntaxe nous montre les argument qu'on peut ou qu'on doit envoyer.

Pour [[getElementPosition]], la syntaxe est:
<syntaxhighlight lang="lua">
float, float, float getElementPosition ( element theElement )
</syntaxhighlight>

Les trois float devant le nom de la fonction est le type de variable que la fonction nous retourne. Dans notre cas, la fonction retourne trois nombres à virgule(x, y et z). Dans les parenthèses, on peut voir les arguments que l'on doit envoyer, dans notre cas, l'element dont on veut récupérer la position, le joueur dans notre exemple.

<syntaxhighlight lang="lua">
function createVehicleForPlayer(thePlayer, command, vehicleModel)
-- on récupère la position x,y,z dans des variables locales
-- une variable locale n'existe que dans le "périmètre" actuel. Ici, les variable x, y et z sont des variables locales qui se détruiront à la fin de la fonction.
local x,y,z = getElementPosition(thePlayer)
end
</syntaxhighlight>

Ensuite, il faut s'assurer que le véhicule n'apparaît pas directement dans le joueur, donc on ajoute quelques unités à la variable ''x'', qui le fera apparaître plus à l'est par rapport au joueur.

<syntaxhighlight lang="lua">
function createVehicleForPlayer(thePlayer, command, vehicleModel)
local x,y,z = getElementPosition(thePlayer) -- On prent la position du joueur qui a tapé la commande
x = x + 5 -- on ajoute 5 unité sur l'axes des x
end
</syntaxhighlight>

Maintenant nous avons besoin d'une autre fonction, celle qui va faire apparaître le véhicule. Nous allons la cherché encore une fois dans la [[Scripting Functions|liste des fonctions serveur]], mais cette fois, comme nous parlons d'un véhicule, nous devons donc aller dans la catégorie'''Vehicle functions''', où l'on va trouver la fonction [[createVehicle]]. Dans la syntaxe, nous pouvons voir que cette fonction ne retourne qu'une seule variable, le véhicule ( de type élément ) que nous venons de créer. Nous pouvons aussi voir qu'il y a des arguments entre crochets [], cela veut dire que ce sont des arguments optionels.

Nous avons déjà tous les arguments pour la fonction [[createVehicle]] dans notre fonction: La position que nous avons juste calculée dans les variables "x, y, z" et l'id du véhicule que nous avons fourni par la commande ("/createVehicle 468") et qui est stocké dans la variable ''vehicleModel''.

<syntaxhighlight lang="lua">
function createVehicleForPlayer(thePlayer, command, vehicleModel)
local x,y,z = getElementPosition(thePlayer) -- récupere la position du joueur dans les variables x, y et z
x = x + 5 -- rajoute 5 unités sur x
-- on crée le véhicule et on enregistre l'élément de type "vehicle" dans la variable ''createdVehicle''
local createdVehicle = createVehicle(tonumber(vehicleModel),x,y,z)
end
</syntaxhighlight>

Avec cette variable, on pourrait faire pas mal de choses sympa, mais ici nous allons juste vérifier si le véhicule à bien été créé ou non.
Sur le wiki de la fonction [[createVehicle]], il y a la partie nomée '''Returns''', la fonction va retourner ''false'' si la voiture n'a pas été créé. Ducoups, on va regarder la valeur de la variable ''createdVehicle''.

Voilà notre code complet:
<syntaxhighlight lang="lua">
function createVehicleForPlayer(thePlayer, command, vehicleModel)
local x,y,z = getElementPosition(thePlayer) -- On prent la position du joueur qui a tapé la commande
x = x + 5 -- on ajoute 5 unités à x
local createdVehicle = createVehicle(tonumber(vehicleModel),x,y,z) -- on crée le véhicule demandé par le joueur et on récupère ce que nous retourne la fonction dans la variable createdVehicle
-- On vérifie si la valeur retournée est égal à ''false'' ( ce qui signifie que ça n'a pas marché )
if (createdVehicle == false) then
-- si c'est le cas, on affiche un message d'erreur dans la chatbox mais seulement pour le joueur.
outputChatBox("Erreur lors de la création du véhicule.",thePlayer)
end
end
addCommandHandler("createVehicle", createVehicleForPlayer)
</syntaxhighlight>

Comme vous pouvez le voir, nous avons utilisé une nouvelle fonction: [[outputChatBox]]. Vous devriez maintenant pouvoir regarder la description de cette fonction par vous même.

==Ce que vous devez savoir==
Vous avez déjà lu quelques informations sur les ressources, les commandes et trouvez des fonctions dans le wiki, mais il y a encore beaucoup à apprendre. Cette section vous donnera une vue d'ensemble plutôt courte sur certaines de ces choses, tout en regardant les pages du wiki si possible.
===Les scripts client et serveur===
Vous pouvez avoir déjà remarqué ces termes (serveur/client) quelque part sur ce wiki, le plus souvent pour les fonctions. MTA ne supporte pas seulement les scripts exécuté par le serveur et des commandes (comme celle qu'on vien de faire) ou d'autres fonctions, mais aussi les scripts éxécuté par le client MTA, ceux des joueurs qui se connecte au serveur. La raison est que certaines fonctions de MTA doit être du coté client comme par exemple le GUI - Graphical User Interface - ( Pour tout ce qui est fenêtres, boutons, etc ), d'autres devraient être du côté client parce qu'ils fonctionnent mieux mais d'autres sont mieux pensées pour être du côté serveur ou ne fonctionne tout simplement pas du côté client.

La plupart de vos scripts (gamemodes, maps) seront surement du côté serveur, comme celui que nous avons fait tout à l'heure. Si vous vous heurtez à quelque chose qui ne peut pas être résolu du côté serveur, vous devrez probablement le faire côté client. Pour un script client, vous devriez créer un script ordinaire (par exemple appelé ''client.lua'') et spécifié dans la meta.xml, comme ceci:
<syntaxhighlight lang="xml">
<script src="client.lua" type="client" />
</syntaxhighlight>
L'attribut ''type'' est par defaut 'server', donc nous avons juste besoin de spécifier que c'est un script client. Lorsque vous faites ceci, le fichier va être télecharger par le joueur sur son ordinateur lorsqu'il se connecte au serveur. Plus d'infos: [[Client side scripts]].

===Ressources plus complexes===
La section précédente nous a montré brièvement comment ajouter des scripts clients à la ressource. Penchons nous maintenant sur la ''meta.xml'' et ce qu'elle fait.

====First example - Un script utile====
<syntaxhighlight lang="xml">
/admin_commands
/meta.xml
/commands.lua
/client.lua
</syntaxhighlight>
<syntaxhighlight lang="xml">
<meta>
<info author="Someguy" description="admin commands" />
<script src="commands.lua" />
<script src="client.lua" type="client" />
</meta>
</syntaxhighlight>

* Le "commands.lua" fournit quelques commandes d'admin, comme le fait d'interdire un joueur, en banissant ou quelque chose d'autre ce qui peut être utilisé par l'admin du serveur
* Le "client.lua" fournit un GUI pour être capable d'exécuter les actions mentionnées facilement

Cet exemple de script doit tourner tout le temps (peut être même démarré en même temps que le serveur) car ces commandes d'admin peuvent être appelé à n'importe quelle moment.

====Second example - Un gamemode====
<syntaxhighlight lang="xml">
/counterstrike
/meta.xml
/counterstrike.lua
/buymenu.lua
</syntaxhighlight>
<syntaxhighlight lang="xml">
<meta>
<info author="Quelqu'un" description="Counterstrike remake" type="gamemode" />
<script src="counterstrike.lua" />
<script src="buymenu.lua" type="client" />
</meta>
</syntaxhighlight>

* Le "counterstrike.lua" contient des caractéristiques semblables aux dispositifs suivants :
** Laissez les joueurs choisir leur équipe et les apparaitre
** Fournissez-leur des armes, des cibles et des instructions (peut-être lues d'une carte, voir ci-dessous)
** Définissez les règles du jeu, par exemple. La partie se finie, ce qui se produit quand un joueur meurt
** .. et peut-être encore plus
* Le "buymenu.lua" est un manuscrit du côté client et crée un menu pour acheter des armes

Cet exemple peut s'appeler un gamemode, depuis lui non seulement des intereferes avec le gameplay, mais définit réellement les règles de lui-même. Le "type" attribut indique que cet exemple fonctionne avec [[Map Manager]], encore une autre ressource qui a été écrite par l'équipe de QA pour contrôler des gamemodes et le chargement de carte. On lui recommande fortement que vous basiez vos gamemodes sur les techniques qu'il fournit.

Ceci signifie également que le gamemode ne fonctionnera pas probablement sans carte. Gamemodes devrait toujours être aussi générique comme possible. Un exemple pour une carte est énoncé dans le prochain exemple.

====Troisième exemple - une carte====
<syntaxhighlight lang="xml">
/cs-airport
/meta.xml
/airport.map
/airport.lua
</syntaxhighlight>
<syntaxhighlight lang="xml">
<meta>
<info author="Quelsqu'un" description="Counterstrike airport map" type="map" gamemodes="counterstrike" />
<map src="airport.map" />
<script src="airport.lua" />
</meta>
</syntaxhighlight>

* Le "airport.map" dans le fichier XML fournit des informations au sujet de la carte au gamemode, ceului-ci peut inclure :
** Là où les joueurs devraient apparaitre, avec quelles armes, avec quelle équipe
** Ce qui sont les cibles
** Temps, heure du monde, Limite de temps
** Fournir les véhicules
* Le ''airport.lua'' peut contenir les dispositifs carte-spécifiques, celui-ci peut inclure :
** En ouvrant une certaine porte/faisant éclater quelque chose quand quelque chose de spécifique se produit
** Créez ou déplacez quelques objets faits sur commande, ou manoeuvrez les objets qui sont créés dans le fichier .map
** .. toute autre chose carte-spécifiques

Comme vous pouvez voir, l'attribut "type" a changé en 'map', dire [[Map Manager]] que cette ressource est une carte, tandis que l'attribut "gamemodes" indique pour quels gamemodes cette carte est valide, dans ce cas-ci le gamemode de l'exemple ci-dessus.
Ce qui peut venir comme une surprise est qu'il y a aussi un script dans la ressource de Carte. Évidemment ce n'est pas nécessairement nécessaire dans une carte, mais ouvre une large gamme de possibilités pour les producteurs de carte pour créer leur propre monde dans les règles du gamemode pour lequel ils le créent.

Le "airport.map" pourrait être semblable à ceci :
<syntaxhighlight lang="xml">
<map mode="deathmatch" version="1.0">
<terrorists>
<spawnpoint posX="2332.23" posY="-12232.33" posZ="4.42223" skins="23-40" />
</terrorists>
<counterterrorists>
<spawnpoint posX="2334.23443" posY="-12300.233" posZ="10.2344" skins="40-50" />
</counterterrorists>

<bomb posX="23342.23" posY="" posZ="" />

<vehicle posX="" posY="" posZ="" model="602" />
<vehicle posX="" posY="" posZ="" model="603" />
</map>
</syntaxhighlight>

Quand un gamemode est commencé avec une carte, les ressources de carte est automatiquement commencé par le mapmanager et les renseignements qu'il contient peut être lu par la ressource gamemode. Quand la carte change, la ressource de carte actuelle est arrêtée et la ressource de carte suivante est commencée. Pour une explication plus détaillée et des exemples de comment les ressources de carte sont utilisées dans le script principal, visitez s'il vous plaît la page [[Writing Gamemodes]].

===Événements===
Les événements sont la façon que MTA dit aux scripts des choses qui arrivent. Par exemple quand un joueur meurt, le [[onPlayerWasted]] l'événement est déclenché. Pour exécuter n'importe quelles actions quand un joueur meurt, vous devez vous préparer similiar à l'ajoutant d'un dresseur d'ordre, comme montré dans [[#Writing_the_script|the first chapter]].

Cet exemple produiras un message avec le nom du joueur qui est mort :
<syntaxhighlight lang="lua">
function playerDied(totalAmmo, killer, killerWeapon, bodypart)
outputChatBox(getPlayerName(source).." died!")
end
addEventHandler("onPlayerWasted",getRootElement(),playerDied)
</syntaxhighlight>

Au lieu de montrer que les arguments sont nécessaires, la page de documentation pour les spectacles d'Événements quels paramètres sont passés à la handler function, similaire à la voie un [[*About_command_handlers|command handler]] fait, juste qu'il se distingue de l'événement à l'événement. Un autre point important est la variable "source", qui existe dans les handler function. Ils ne doivent pas être ajoutés à la liste de paramètre de la fonction, mais cela existe toujours . Il a une différente valeur de l'événement à l'événement, pour les événements de joueur (comme dans l'exemple au-dessus) c'est l'élément de joueur. Comme un autre exemple, vous pouvez jeter un coup d'œil au script de joueur frayant fondamental dans la première section pour recevoir une idée comment "source" est utilisé.

==Où aller d'ici==
Vous devriez maintenant être familiers avec les aspects les plus fondamentaux de MTA scripting et aussi un peu avec la documentation. Le [[Main_Page]] vous fournit des liens vers plus de renseignements, Classes de travaux dirigés et Références qui permettent un coup d'oeil plus profond dans les thèmes dont vous désirez apprendre.

D'ici nous recommandons de lire le [[debugging]] la classe de travaux dirigés. De bonnes adresses déboguantes sont une nécessité absolue quand vous faites des scripts.

[[ru:Scripting Introduction]]
[[it:Introduzione allo scripting]]
[[es:Introducción a la Programación]]

Talk:Page d'accueil

2012-03-30T13:49:35Z

Citizen: Main discussion started

'''Citizen:'''
Je suis en train de créer toutes les pages du wiki fr pour qu'il ne reste plus qu'à traduire.
I'm creating all the pages for the french wiki, then the contributors will just click on Edit to translate that page.

FR/Vehicule Couleurs

2012-03-30T13:44:03Z

Citizen: Reprise des pages afin de pouvoir les traduire

These are the vehicle colors you can use with [[setVehicleColor]] and [[getVehicleColor]].
{{Vehicle colors}}

==See also==
[[id|ID Lists]]

[[Category:ID Lists]]

FR/Vetements CJ

2012-03-30T13:39:56Z

Citizen: Reprise des pages afin de pouvoir les traduire

These pages contain clothing images and details for all of CJ's apparel.

*[[CJ Clothes\Shirt (0)|Type 0 - Shirt]]
*[[CJ Clothes\Head (1)|Type 1 - Head]]
*[[CJ Clothes\Trousers (2)|Type 2 - Trousers]]
*[[CJ Clothes\Shoes (3)|Type 3 - Shoes]]
*[[CJ Clothes\Tattoos: Left Upper Arm (4)|Type 4 - Tattoos: Left Upper Arm]]
*[[CJ Clothes\Tattoos: Left Lower Arm (5)|Type 5 - Tattoos: Left Lower Arm]]
*[[CJ Clothes\Tattoos: Right Upper Arm (6)|Type 6 - Tattoos: Right Upper Arm]]
*[[CJ Clothes\Tattoos: Right Lower Arm (7)|Type 7 - Tattoos: Right Lower Arm]]
*[[CJ Clothes\Tattoos: Back (8)|Type 8 - Tattoos: Back]]
*[[CJ Clothes\Tattoos: Left Chest (9)|Type 9 - Tattoos: Left Chest]]
*[[CJ Clothes\Tattoos: Right Chest (10)|Type 10 - Tattoos: Right Chest]]
*[[CJ Clothes\Tattoos: Stomach (11)|Type 11 - Tattoos: Stomach]]
*[[CJ Clothes\Tattoos: Lower Back (12)|Type 12 - Tattoos: Lower Back]]
*[[CJ Clothes\Necklace (13)|Type 13 - Necklace]]
*[[CJ Clothes\Watches (14)|Type 14 - Watches]]
*[[CJ Clothes\Glasses (15)|Type 15 - Glasses]]
*[[CJ Clothes\Hats (16)|Type 16 - Hats]]
*[[CJ Clothes\Extra (17)|Type 17 - Extra]]

[[it:Vestiti di CJ]]
[[ru:CJ Clothes]]
[[Category:Scripting Concepts]]
[[Category:ID Lists]]

FR/Skins Personnages

2012-03-30T13:39:19Z

Citizen: Reprise des pages afin de pouvoir les traduire

Skins that the player may use (pedestrian skins).

*[[All Skins Page]] - Not recommended for slow Internet
*[[Special Skins Page]] - New skins available after MTA 1.1

'''Sectioned Skin Pages:'''
----
*[[Skins Page 1]]: 7, 9-29
*[[Skins Page 2]]: 30-41, 43-52
*[[Skins Page 3]]: 53-64, 66-73, 75-76
*[[Skins Page 4]]: 77-85, 87-99
*[[Skins Page 5]]: 100-118, 120-122
*[[Skins Page 6]]: 123-144
*[[Skins Page 7]]: 145-148, 150-167
*[[Skins Page 8]]: 168-189
*[[Skins Page 9]]: 190-207, 209-212
*[[Skins Page 10]]: 213-234
*[[Skins Page 11]]: 235-238, 240-257
*[[Skins Page 12]]: 258-264, 274-288

==Notes:==
*12 pages: 266 total.

*IDs 1-8 (except 7) are non-functional

*The following pairs of IDs produce same character (1st ID used in lists, 2nd disabled)
**118:119
**148:149

*Non-working IDs
1-6
8
42
65
74
86
119
149
208
239
265-273

==See Also==
[[id|ID Lists]]

[[it:Skin Personaggi]]
[[ru:Character Skins]]
[[es:Skins de Personajes]]

[[Category:ID Lists]]

FR/A propos des Map

2012-03-30T13:25:44Z

Citizen: Problème du "rgb(127, 0, 127);" class="sectionSubCaption">Resource" Résolu

{{Needs Checking|Either complete the translation or remove it.}}
Le "Map manager" est une ressource inclue dans la suite serveur de MTA DM. Elle offre des commandes, fonctions et événements pour les modes de jeu afin de dynamiser vos maps. Par exemple, quand un serveur doit charger plusieurs routes pour plusieurs maps, au lieu d'avoir le tout dans un seul script principal, ces routes peuvent êtres stockée dans plusieurs ressources et chargée simplement grâce à la fonction "changeGamemodeMap" quand une map démarre.

Plus spécifiquement, le "Map manager" liste les modes de jeux et maps chargés sur le serveur. Il inclut un listing sur l'interface web, il rafraîchit cette liste fréquemment et met en gras les ressources et/ou maps actuellement entrain d'être utilisées.

== Un Simple Tutoriel ==
Dans cette section nous allons poursuivre le travail commencé dans [[FR/Introduction_Programmation|Introduction to Scripting]]. Nous allons ajouter une ressource qui enregistre l'endroit de spawn des joueurs sur la map, le chargement de ce script se fera depuis le script principal.

Premièrement, créez un dossier dans /Your MTA Server/mods/deathmatch/resources/, nommez-le "mymap". Ensuite dans ce dossier, créez un fichier texte et nommez-le "meta.xml", ce fichier est présent dans chaque scripts.

Ecrivez les lignes suivantes dans le fichier ''meta.xml'' :
<syntaxhighlight lang="xml">
<meta>
<info type="map" gamemodes="myserver"/>
<map src="mymap.map"/>
</meta>
</syntaxhighlight>
Prenez garde car ce fichier est "lié" avec le ''gamemodes=""'' choisit, qui contient le nom de la ressource principale qu'utilise ce mode. le paramètre ''map'', indique le nom de la map qui sera afficher sur le serveur.

Maintenant créez un nouveau fichier texte dans /mymap/ et nommez le "mymap.map", écrivez y les lignes suivantes:
<syntaxhighlight lang="xml">
<map>
<spawnpoint id="spawnpoint1" posX="1959.5487060547" posY="-1714.4613037109" posZ="18" rot="63.350006103516" model="0"/>
</map>
</syntaxhighlight>
Notez que "spawnpoint" est le type de l'élément utilisé dans la fonction [[getElementsByType]], "id" est utilisée dans la fonction [[getElementByID]]

Pour charger la map, le script principal doit pouvoir accéder aux maps par lui même. Quelques modifications sont à apportées dans script.lua situé dans "myserver". Entrez les lignes suivantes :

<syntaxhighlight lang="lua">
function loadMap(startedMap)
mapRoot = getResourceRootElement(startedMap)
end

addEventHandler("onGamemodeMapStart", getRootElement(), loadMap)
</syntaxhighlight>
Par défaut, l'evênement "onGamemodeMapStart" nous donne le "handle"(?) de la map ("startedMap"), lequel nous avons utilisé pour le "handle"(?) de la ressource contenant la map ("mapRoot").

Avec la ressource "handle"(?), nous pouvons extraire les informations relatives au spawnpoint. Jetez un œil à la fonction joinHandler() dans script.lua, à la place de x, y and z, nous pouvons utiliser les informations de la map comme suit :
<syntaxhighlight lang="lua">
function joinHandler()
local spawn = getElementsByType("spawnpoint", mapRoot)
local x,y,z,r
for key, value in pairs(spawn) do
x = getElementData(value, "posX")
y = getElementData(value, "posY")
z = getElementData(value, "posZ")
r = getElementData(value, "rot")
end
spawnPlayer(source, x, y, z)
fadeCamera(source, true)
end
</syntaxhighlight>
Lancez maintenant votre gamemode avec la commande suivante via la console:

'''gamemode myserver mymap'''

==Usage==
Pour utiliser le map manager, vos ressources doivent d'abord être reconnues en tant que gamemodes ou maps.

Vous devez remplir quelques informations pour votre fichier de configuration du '''gamemode resource''' :
<syntaxhighlight lang="xml"><info description="Votre Gamemode" type="gamemode" /></syntaxhighlight>

'''Map resources''' Les maps ont aussi besoin d'information dans le meta.xml, ''type="map"'' et un ou plusieurs ''gamemodes''. Une map peut en effet être compatible avec plusieurs mode de jeu pour se faire il faudra séparer les modes par une virgule ''sans espaces''.
<syntaxhighlight lang="xml"><info description="A gamemode map" type="map" gamemodes="ctv,koth" /></syntaxhighlight>

Il ne peut y avoir qu’un mode de jeu 'Gamemode' Actif ou une map chargée à la fois.

==Paramètres Supplémentaires==
Ces paramètres sont aussi à ajouter dans meta.xml.

'''name:''' Entrez ici un message sympa qui sera afficher lors du démarrage de la ressource. C'est en quelques sorte un alias au cas ou le nom de votre ressource ne vous correspond pas.

==Commandes==
'''changemap newmap [newgamemode]''' (changer le 'Gamemode' d'une map)

'''changemode newgamemode [newmap]''' (lancer un mode de jeu 'Gamemode' et démarrez une map)

'''gamemode newgamemode [newmap]''' (idem que la précédente)

'''stopmode''' (Arrête le mode de jeu et la map en cours)

'''stopmap''' (Arrête la map en cours)

'''maps [gamemode]''' (liste toutes les maps sur le serveurs, ajoutez en option le mode pour lequel vous voulez connaître les maps)

'''gamemodes''' (Liste tout les mode de jeu)

==Paramètres==
'''*mapmanager.color''' [hex color string] (change la couleur de sortie des message du mapmanager) (Par défaut : #E1AA5A)

'''*mapmanager.messages''' [boolean] (si les changements de map/gm sont activés) (Par défaut : true)

'''*mapmanager.ASE''' [boolean] (si le manager doit charger en mode ASE) (Par défaut : true)

==Autres fonctions==
<syntaxhighlight lang="lua">bool changeGamemode ( resource newGamemode, [ resource mapToLoadWith ] )</syntaxhighlight>
Changement de mode de jeu, on peut aussi lui donner une map initial à charger.
<syntaxhighlight lang="lua">bool changeGamemodeMap ( resource newMap, [ resource gamemodeToChangeTo ] )</syntaxhighlight>
Change le mode de jeu d'une map pour un nouveau, on peut choisir un mode de jeu à charger une fois cette map rechargée.
<syntaxhighlight lang="lua">table getGamemodes ( )</syntaxhighlight>
Renvoie une table des tout les modes de jeu et leur pointeurs.
<syntaxhighlight lang="lua">table getGamemodesCompatibleWithMap ( resource theMap )</syntaxhighlight>
Returns a table of compatible gamemode resource pointers.
<syntaxhighlight lang="lua">table getMaps ( )</syntaxhighlight>
Returns a table of all map resource pointers.
<syntaxhighlight lang="lua">table getMapsCompatibleWithGamemode ( [ resource theGamemode ] )</syntaxhighlight>
Returns a table of compatible map resource pointers. If the gamemode is left blank, it returns all maps which aren't compatible with any gamemode.
<syntaxhighlight lang="lua">resource getRunningGamemode ( )</syntaxhighlight>
Returns the currently running gamemode's resource pointer.
<syntaxhighlight lang="lua">resource getRunningGamemodeMap ( )</syntaxhighlight>
Returns the currently running GM map's resource pointer.
<syntaxhighlight lang="lua">bool isGamemode ( resource theGamemode )</syntaxhighlight>
Determines if a resource is a gamemode or not.
<syntaxhighlight lang="lua">bool isGamemodeCompatibleWithMap ( resource theGamemode, resource theMap )</syntaxhighlight>
Determines if a gamemode is compatible with a map or not.
<syntaxhighlight lang="lua">bool isMap ( resource theMap )</syntaxhighlight>
Determines if a resource is a map or not.
<syntaxhighlight lang="lua">bool isMapCompatibleWithGamemode ( resource theMap, resource theGamemode )</syntaxhighlight>
Determines if a map is compatible with a gamemode or not.
<syntaxhighlight lang="lua">bool stopGamemode ( )</syntaxhighlight>
Stops the current gamemode and its map.
<syntaxhighlight lang="lua">bool stopGamemodeMap ( )</syntaxhighlight>
Stop the current GM map.
Determines if a map is compatible with a gamemode or not.

==Fired events==
''(For all these events, "source" is the resource's root element.)''
<syntaxhighlight lang="lua">onGamemodeStart ( resource startedGamemode )</syntaxhighlight>
Fired before a gamemode starts.
<syntaxhighlight lang="lua">onGamemodeStop ( resource stoppedGamemode )</syntaxhighlight>
Fired before a gamemode is stopped.
<syntaxhighlight lang="lua">onGamemodeMapStart ( resource startedMap )</syntaxhighlight>
Fired before a GM map starts.
<syntaxhighlight lang="lua">onGamemodeMapStop ( resource stoppedMap )</syntaxhighlight>
Fired before a GM map is stopped.

==Supported map settings==
The following settings from the [[settings system|registry]] are applied by the map manager when a map is started:
<br>'''gamespeed''' [number]: The map's game speed.
<br>'''gravity''' [number]: The map's gravity.
<br>'''time''' [string of the form '''hh:mm''']: The map's time.
<br>'''weather''' [number]: The map's weather ID.
<br>'''waveheight''' [number]: The map's wave height.
<br>'''locked_time''' [boolean]: Whether the set time will be frozen by the manager or not.
<br>'''minplayers''' [number]: The required minimum number of players to start the map.
<br>'''maxplayers''' [number]: The allowed maximum number of players to start the map.

[[it:Map manager]]
[[ru:Resource:Mapmanager]]

FR/A propos des Map

2012-03-30T13:21:07Z

Citizen: Modification du lien pour qu'il pointe vers la page en français

{{Needs Checking|Either complete the translation or remove it.}}
{{Resource page}}
Le "Map manager" est une ressource inclue dans la suite serveur de MTA DM. Elle offre des commandes, fonctions et événements pour les modes de jeu afin de dynamiser vos maps. Par exemple, quand un serveur doit charger plusieurs routes pour plusieurs maps, au lieu d'avoir le tout dans un seul script principal, ces routes peuvent êtres stockée dans plusieurs ressources et chargée simplement grâce à la fonction "changeGamemodeMap" quand une map démarre.

Plus spécifiquement, le "Map manager" liste les modes de jeux et maps chargés sur le serveur. Il inclut un listing sur l'interface web, il rafraîchit cette liste fréquemment et met en gras les ressources et/ou maps actuellement entrain d'être utilisées.

== Un Simple Tutoriel ==
Dans cette section nous allons poursuivre le travail commencé dans [[FR/Introduction_Programmation|Introduction to Scripting]]. Nous allons ajouter une ressource qui enregistre l'endroit de spawn des joueurs sur la map, le chargement de ce script se fera depuis le script principal.

Premièrement, créez un dossier dans /Your MTA Server/mods/deathmatch/resources/, nommez-le "mymap". Ensuite dans ce dossier, créez un fichier texte et nommez-le "meta.xml", ce fichier est présent dans chaque scripts.

Ecrivez les lignes suivantes dans le fichier ''meta.xml'' :
<syntaxhighlight lang="xml">
<meta>
<info type="map" gamemodes="myserver"/>
<map src="mymap.map"/>
</meta>
</syntaxhighlight>
Prenez garde car ce fichier est "lié" avec le ''gamemodes=""'' choisit, qui contient le nom de la ressource principale qu'utilise ce mode. le paramètre ''map'', indique le nom de la map qui sera afficher sur le serveur.

Maintenant créez un nouveau fichier texte dans /mymap/ et nommez le "mymap.map", écrivez y les lignes suivantes:
<syntaxhighlight lang="xml">
<map>
<spawnpoint id="spawnpoint1" posX="1959.5487060547" posY="-1714.4613037109" posZ="18" rot="63.350006103516" model="0"/>
</map>
</syntaxhighlight>
Notez que "spawnpoint" est le type de l'élément utilisé dans la fonction [[getElementsByType]], "id" est utilisée dans la fonction [[getElementByID]]

Pour charger la map, le script principal doit pouvoir accéder aux maps par lui même. Quelques modifications sont à apportées dans script.lua situé dans "myserver". Entrez les lignes suivantes :

<syntaxhighlight lang="lua">
function loadMap(startedMap)
mapRoot = getResourceRootElement(startedMap)
end

addEventHandler("onGamemodeMapStart", getRootElement(), loadMap)
</syntaxhighlight>
Par défaut, l'evênement "onGamemodeMapStart" nous donne le "handle"(?) de la map ("startedMap"), lequel nous avons utilisé pour le "handle"(?) de la ressource contenant la map ("mapRoot").

Avec la ressource "handle"(?), nous pouvons extraire les informations relatives au spawnpoint. Jetez un œil à la fonction joinHandler() dans script.lua, à la place de x, y and z, nous pouvons utiliser les informations de la map comme suit :
<syntaxhighlight lang="lua">
function joinHandler()
local spawn = getElementsByType("spawnpoint", mapRoot)
local x,y,z,r
for key, value in pairs(spawn) do
x = getElementData(value, "posX")
y = getElementData(value, "posY")
z = getElementData(value, "posZ")
r = getElementData(value, "rot")
end
spawnPlayer(source, x, y, z)
fadeCamera(source, true)
end
</syntaxhighlight>
Lancez maintenant votre gamemode avec la commande suivante via la console:

'''gamemode myserver mymap'''

==Usage==
Pour utiliser le map manager, vos ressources doivent d'abord être reconnues en tant que gamemodes ou maps.

Vous devez remplir quelques informations pour votre fichier de configuration du '''gamemode resource''' :
<syntaxhighlight lang="xml"><info description="Votre Gamemode" type="gamemode" /></syntaxhighlight>

'''Map resources''' Les maps ont aussi besoin d'information dans le meta.xml, ''type="map"'' et un ou plusieurs ''gamemodes''. Une map peut en effet être compatible avec plusieurs mode de jeu pour se faire il faudra séparer les modes par une virgule ''sans espaces''.
<syntaxhighlight lang="xml"><info description="A gamemode map" type="map" gamemodes="ctv,koth" /></syntaxhighlight>

Il ne peut y avoir qu’un mode de jeu 'Gamemode' Actif ou une map chargée à la fois.

==Paramètres Supplémentaires==
Ces paramètres sont aussi à ajouter dans meta.xml.

'''name:''' Entrez ici un message sympa qui sera afficher lors du démarrage de la ressource. C'est en quelques sorte un alias au cas ou le nom de votre ressource ne vous correspond pas.

==Commandes==
'''changemap newmap [newgamemode]''' (changer le 'Gamemode' d'une map)

'''changemode newgamemode [newmap]''' (lancer un mode de jeu 'Gamemode' et démarrez une map)

'''gamemode newgamemode [newmap]''' (idem que la précédente)

'''stopmode''' (Arrête le mode de jeu et la map en cours)

'''stopmap''' (Arrête la map en cours)

'''maps [gamemode]''' (liste toutes les maps sur le serveurs, ajoutez en option le mode pour lequel vous voulez connaître les maps)

'''gamemodes''' (Liste tout les mode de jeu)

==Paramètres==
'''*mapmanager.color''' [hex color string] (change la couleur de sortie des message du mapmanager) (Par défaut : #E1AA5A)

'''*mapmanager.messages''' [boolean] (si les changements de map/gm sont activés) (Par défaut : true)

'''*mapmanager.ASE''' [boolean] (si le manager doit charger en mode ASE) (Par défaut : true)

==Autres fonctions==
<syntaxhighlight lang="lua">bool changeGamemode ( resource newGamemode, [ resource mapToLoadWith ] )</syntaxhighlight>
Changement de mode de jeu, on peut aussi lui donner une map initial à charger.
<syntaxhighlight lang="lua">bool changeGamemodeMap ( resource newMap, [ resource gamemodeToChangeTo ] )</syntaxhighlight>
Change le mode de jeu d'une map pour un nouveau, on peut choisir un mode de jeu à charger une fois cette map rechargée.
<syntaxhighlight lang="lua">table getGamemodes ( )</syntaxhighlight>
Renvoie une table des tout les modes de jeu et leur pointeurs.
<syntaxhighlight lang="lua">table getGamemodesCompatibleWithMap ( resource theMap )</syntaxhighlight>
Returns a table of compatible gamemode resource pointers.
<syntaxhighlight lang="lua">table getMaps ( )</syntaxhighlight>
Returns a table of all map resource pointers.
<syntaxhighlight lang="lua">table getMapsCompatibleWithGamemode ( [ resource theGamemode ] )</syntaxhighlight>
Returns a table of compatible map resource pointers. If the gamemode is left blank, it returns all maps which aren't compatible with any gamemode.
<syntaxhighlight lang="lua">resource getRunningGamemode ( )</syntaxhighlight>
Returns the currently running gamemode's resource pointer.
<syntaxhighlight lang="lua">resource getRunningGamemodeMap ( )</syntaxhighlight>
Returns the currently running GM map's resource pointer.
<syntaxhighlight lang="lua">bool isGamemode ( resource theGamemode )</syntaxhighlight>
Determines if a resource is a gamemode or not.
<syntaxhighlight lang="lua">bool isGamemodeCompatibleWithMap ( resource theGamemode, resource theMap )</syntaxhighlight>
Determines if a gamemode is compatible with a map or not.
<syntaxhighlight lang="lua">bool isMap ( resource theMap )</syntaxhighlight>
Determines if a resource is a map or not.
<syntaxhighlight lang="lua">bool isMapCompatibleWithGamemode ( resource theMap, resource theGamemode )</syntaxhighlight>
Determines if a map is compatible with a gamemode or not.
<syntaxhighlight lang="lua">bool stopGamemode ( )</syntaxhighlight>
Stops the current gamemode and its map.
<syntaxhighlight lang="lua">bool stopGamemodeMap ( )</syntaxhighlight>
Stop the current GM map.
Determines if a map is compatible with a gamemode or not.

==Fired events==
''(For all these events, "source" is the resource's root element.)''
<syntaxhighlight lang="lua">onGamemodeStart ( resource startedGamemode )</syntaxhighlight>
Fired before a gamemode starts.
<syntaxhighlight lang="lua">onGamemodeStop ( resource stoppedGamemode )</syntaxhighlight>
Fired before a gamemode is stopped.
<syntaxhighlight lang="lua">onGamemodeMapStart ( resource startedMap )</syntaxhighlight>
Fired before a GM map starts.
<syntaxhighlight lang="lua">onGamemodeMapStop ( resource stoppedMap )</syntaxhighlight>
Fired before a GM map is stopped.

==Supported map settings==
The following settings from the [[settings system|registry]] are applied by the map manager when a map is started:
<br>'''gamespeed''' [number]: The map's game speed.
<br>'''gravity''' [number]: The map's gravity.
<br>'''time''' [string of the form '''hh:mm''']: The map's time.
<br>'''weather''' [number]: The map's weather ID.
<br>'''waveheight''' [number]: The map's wave height.
<br>'''locked_time''' [boolean]: Whether the set time will be frozen by the manager or not.
<br>'''minplayers''' [number]: The required minimum number of players to start the map.
<br>'''maxplayers''' [number]: The allowed maximum number of players to start the map.

[[it:Map manager]]
[[ru:Resource:Mapmanager]]

Page d'accueil

2012-03-30T13:01:17Z

Citizen: Suppression du FR/ à l'affichage dans le menu

<div style="background: #FFEEAA; padding: 5px; float:right; width: 30%;">Dernière version stable de '''Multi Theft Auto: San Andreas''' est '''{{Current Version|full}}'''. Rendez-vous sur la [http://mtasa.com/ page principale] pour la télécharger.
<p>
Vous pouvez aussi télécharger une [http://nightly.mtasa.com/ beta] pour avoir la dernière version ( non stable ).
</p>
</div>
__NOTOC__
Bienvenue sur le wiki de Multi Theft Auto. Sur ce wiki, vous trouverez toutes les informations sur Multi Theft Auto.

Il y a [[How you can help|différents moyens de nous aider]]: créer une map, un gamemode, rediger des articles sur des fonctions, écrire un exemple, écrire un tutorial ou juste jouer à MTA et nous rapportez les bugs trouvés.

<div style="clear:both;"></div>
{| width="100%" cellspacing="0" cellpadding="0"
| colspan="2" |

|-
| width="50%" style="vertical-align:top;" |
<div style="border: 1px dotted #AAAAAA;padding:4px 8px 8px 8px;margin:10px;">
====Pour commencer====

* [[FR/Manuel_Client|Manuel Client]] ( Traduction: [http://wiki.multitheftauto.com/wiki/User:DrawKiie DrawKiie] )
* [[FR/Manuel_Serveur|Manuel Serveur]] ( Traduction: [http://wiki.multitheftauto.com/wiki/User:Rouche Rouche] )
* [[FR/Problemes_connus|Problèmes connus]] ( Traduction: [http://wiki.multitheftauto.com/wiki/User:Rouche Rouche] )
* [[FR/Migrer_de_MTARace_a_MTASA_1.0.x|Migrer de MTA:Race à MTA:SA 1.0.x]] ( Traduction: [http://wiki.multitheftauto.com/wiki/User:Rouche Rouche] )
* [[FR/A propos des Map|A propos des Map]] ( Traduction: [http://wiki.multitheftauto.com/wiki/User:Rouche Rouche] )

</div>

<div style="border: 1px dotted #AAAAAA;padding:4px 8px 8px 8px;margin:10px;">

====Programmer====

* [[FR/Introduction_Programmation|Introduction: La programmation]] ( Traduction: [http://wiki.multitheftauto.com/wiki/User:Citizen Citizen] )
* [[FR/Introduction_GUI|Introduction: Le GUI]] ( Traduction: [http://wiki.multitheftauto.com/wiki/User:FatalTeror FatalTerror] )
* [[FR/Debugage|Tutoriel: Le débugage]] - Comment trouver les erreurs dans son script (Traduction:[http://wiki.multitheftauto.com/wiki/User:Vincenzo Vincenzo] alias Vincentdu90)
* [[FR/Ressources|Introduction: Les ressources]]
** [[FR/Ressource_Acces_Internet|Introduction: L'accès internet]] - Comment créer un site à partir d'une ressource
** [[:Category:Resource|Catalogue des ressources]]
** [[FR/Meta.xml|Meta.xml]] - Derière chaque ressource ce trouve une meta pour la définir
** [[FR/ACL|ACL]] - Access Control List, pour définir les autorisations
* [[FR/Ecrire_Gamemode|Créer un gamemode]]
* [[FR/Fonctions_Utiles|Fonctions Utiles]]

</div>

<div style="border: 1px dotted #AAAAAA;padding:4px 8px 8px 8px;margin:10px;">

====Bases de données====
Cette section décrit toutes les capacités fournient par le LUA/MTA ou par les ressources.
* [[:Category:Resource|Catalogue des ressources]] - Vous devez le lire pour faire un script appropriés
* [[FR/Les_scripts_clients| Les scripts clients]]
</div>
<div style="border: 1px dotted #AAAAAA;padding:4px 8px 8px 8px;margin:10px;">

====Aide générale du LUA====
Des pages conçues pour aider votre compréhension du Lua
*[http://www.lua.org/pil/index.html "Programming in Lua"]
**[http://www.lua.org/manual/5.1/#index Les fonctions Lua]
*[http://lua-users.org/wiki/TutorialDirectory wiki Lua]
*[http://nixstaller.berlios.de/manual/0.2/nixstaller_9.html Un guide général au Lua de Nixstaller]
</div>

| width="50%" style="vertical-align:top;" |
<div style="border: 1px dotted #AAAAAA;padding:4px 8px 8px 8px;margin:10px;">

====Map Editor====
*[[Resource:Editor|Manuel]]
*[[Resource:Editor/EDF|Editor Definition Format]]
*[[Resource:Editor/Plugins|Plugins]]
*[[Resource:Editor#FAQ|Questions Fréquentes]]
</div>

<div style="border: 1px dotted #AAAAAA;padding:4px 8px 8px 8px;margin:10px;">

====Développer Multi Theft Auto====
* [[FR/Compiler_MTASA|Compiler MTASA sur Windows]]
* [[FR/Compiler_MTASA_Server_sur_Mac_OS_X|Compiler MTASA sur Mac OS X]]
* [[FR/Compiler_MTASA_Server_sur_GNU_Linux|Compiler MTASA sur GNU/Linux]]
* [[FR/Directives_de_codage|Directives de codage]]
* [http://code.google.com/p/mtasa-blue Google Code SVN]
* [[FR/Roadmap|Roadmap]]
</div>

<div style="border: 1px dotted #AAAAAA;padding:4px 8px 8px 8px;margin:10px; background:#CCCCFF;">

====Références====
* [[FR/Fonctions_Clients|Fonctions Clients]]
* [[FR/Events_Clients|Events Clients]]
* [[FR/Fonctions_Serveurs|Fonctions Clients]]
* [[FR/Events_Serveurs|Events Clients]]

* [[FR/MTA Classes|MTA Classes]] - Les descriptions détaillées de tous les types personnalisés MTA
** [[FR/Element|MTA Elements]] / [[Element tree]]
</div>

<div style="border: 1px dotted #AAAAAA;padding:4px 8px 8px 8px;margin:10px;">

====[[Id|ID Listes]]====
*[[FR/Animations|Animations]]
*[[FR/Skins_Personnages|Skins Personnages]]
*[[FR/Vetements_CJ|Vêtements CJ]]
*[[FR/Garage|Garage IDs]]
*[[FR/Interieurs_IDs|Intérieurs IDs]]
*[[FR/Materiel_IDs|Matériel IDs]]
*[[FR/Projectiles|Projectiles]]
*[[FR/Radar Blips|Radar Blips]]
*[[FR/Sons|Sons]]
*[[FR/Vehicule_IDs|ID des véhicules]]
*[[FR/Vehicule_Couleurs|Couleurs véhicules]]
*[[FR/Vehicule_Upgrades|Tuning IDs]]
*[[FR/Armes|Armes]]
*[[FR/Meteos|Météos]]
</div>

|-
| colspan="2" |
|}
[[pl:Main Page]]
[[ru:Main Page]]
[[it:Pagina principale]]
[[nl:Main Page]]
[[de:Hauptseite]]
[[es:Pagina Principal]]

FR/Debugage

2012-03-30T12:48:44Z

Citizen: Created page with "Quand vous scriptez vous pouvez passer à côté de certaines erreurs qui ne sont pas apparentes au premier coup d’œil. Cette page va essayer de vous indiquer quelques démarc..."

Quand vous scriptez vous pouvez passer à côté de certaines erreurs qui ne sont pas apparentes au premier coup d’œil. Cette page va essayer de vous indiquer quelques démarches à suivre pour localiser les erreurs.

==Console de Débogage==
MTA a pour caractéristique de posséder une console de débogage qui comme son nom l'indique vous permet de déceler les erreurs dans les fonctions et scripts. Vous pouvez l'ouvrir en tapant ''debugscript x'' dans la console, ici ''x'' est le niveau de débogage:
* '''1:''' seulement les erreurs
* '''2:''' erreurs et warnings
* '''3:''' erreurs, warnings et messages d'informations
Ainsi, en tapant ''debugscript 3'' tout les messages seront visibles, cependant le niveau 2 est recommandé la plupart du temps pour le débogage. Quand vous testez vos scripts vous devez avoir le ''debugscript'' à disposition , cela vous permettra de détecter facilement les fautes d'orthographes dans les fonctions ou toutes autres erreurs aussi simple.

===Exemple===
L'exemple ci-dessous contient deux erreurs:
<syntaxhighlight lang="lua">
if (getPlayerName(player) == "Fedor")
outputChatbox("Hello Fedor")
end
</syntaxhighlight>
Quand ce bout de code va être chargé, debugscript va vous renvoyer à peu près ceci:
{{Debug info|Loading script failed: C:\<server path>\mods\deathmatch\resources\myResource\script.lua:15: 'then' expected near ´outputChatbox'}}
Cela signifie que le code ne peut-être analysé/traité, car il y a une erreur de syntaxe. On vous montre le répertoire où se trouve le fichier, vous pouvez donc voir dans quelle ressource ce dernier se trouve ('myResource' dans notre cas) et bien sûr on vous donne le nom du fichier en question. Après le nom du fichier, on a le numéro de la ligne et encore après l'erreur/problème en question. C'est bien plus facile à résoudre maintenant, il manque juste 'then':
<syntaxhighlight lang="lua">
if (getPlayerName(player) == "Fedor") then
outputChatbox("Hello Fedor")
end
</syntaxhighlight>
A présent le bout de code se charge et ne renvoie aucune erreur, jusqu'à ce qu'un joueur avec le pseudo 'Fedor' fasse son apparition. Le debugscript va nous renvoyer alors:
{{Debug error|C:\<server path>\mods\deathmatch\resources\d\script.lua:15: attempt to call global 'outputChatbox' (a nil value)}}
Cela signifie que la fonction appelée n'existe pas, cela s'explique facilement par le fait que le nom de la fonction est ''outputChatBox'' (avec une capitale ''B''):
<syntaxhighlight lang="lua">
if (getPlayerName(player) == "Fedor") then
outputChatBox("Hello Fedor")
end
</syntaxhighlight>

Ceci n'est bien sûr qu'un exemple, il y a une multitude d'autres erreurs et problèmes, mais vous avez au moins une idée du débogage.

==Debug logging==
You can also turn debug message logging on by editing ''coreconfig.xml'' in your GTA\MTA folder. You should find the following tag:
<syntaxhighlight lang="xml"><debugfile/></syntaxhighlight>

Replace that with a tag specifying the file you want to log messages to (file path is relative from the GTA folder):
<syntaxhighlight lang="xml"><debugfile>MTA\debugscript.log</debugfile></syntaxhighlight>

All debug messages will be appended to the specified file from now on. To turn logging off, replace that line with an empty tag again.

==Debug strategies==
There are several strategies that support finding errors, apart from going through the code of course. Most of them include outputting debug messages, with differing information depending on the situtation.

===Useful functions===
First of all some functions that may come in handy for debugging.
* [[outputDebugString]] or [[outputChatBox]] for outputting any information
* [http://www.lua.org/manual/5.1/manual.html#pdf-tostring tostring()] on a variable to turn it into a string, for example when it contains a boolean value
* [[getElementType]] to check an MTA Element for its type

===Ajouter un message pour vérifier quand une condition ''if'', ''when'' or ''how often'' est executée===
Un exemple typique qui vérifie si une condition ''if''est executée ou non. Pour faire ceci, il vous suffit d'ajoutez un message que vous reconnaîtrez lorsqu'il s'affichera quand la condition sera executée.
<syntaxhighlight lang="lua">
if (variable1 == variable2) then
outputDebugString("entered if")
-- Instruction
end
</syntaxhighlight>
Une autre pratique serait de vérifier quand est-ce que la valeur de la variable est modifiée. Il faut pour cela chercher le moment où la variable est modifiée et ajouter une fonction qui permet l'affichage d'un message juste après.

===Afficher un message pour vérifier la "valeur" d'une variable===
Prenons le cas ou vous voulez créer un checkpoint (marqueur), mais ce dernier n'apparaît pas à la position attendu. La première chose que vous allez faire sera de vérifier si la fonction [[createMarker]] est executée. Au lieu de faire ceci, vous pouvez vérifier les valeurs qui sont utilisées par la fonction [[createMarker]].
<syntaxhighlight lang="lua">
outputChatBox(tostring(x).." "..tostring(y).." "..tostring(z))
createMarker(x,y,z)
</syntaxhighlight>
Ce code aura pour conséquence de vous afficher un message avec les trois valeurs des variables qui sont utilisées en tant que coordonnées pour le marqueur. Vous pouvez maintenant comparer les valeurs obtenues avec celle désirées. Le [http://www.lua.org/manual/5.1/manual.html#pdf-tostring tostring()] vous permettra de vous assurer que les valeurs des variables seront transformées en "string" (chaîne), même si c'est un boléen.

==Example==
Imagine you created a colshape (collision shape) somewhere and you want a player to stay 10 seconds in it, then perform some action.
<syntaxhighlight lang="lua">
function colShapeHit(player)
-- set a timer to output a message (could as well execute another function)
-- store the timer id in a table, using the player as index
colshapeTimer[player] = setTimer(outputChatBox,10000,1,"The player stayed 10 seconds in the colshape!")
end
addEventHandler("onColShapeHit",getRootElement(),colShapeHit)

function colShapeLeave(player)
-- kill the timer when the player leaves the colshape
killTimer(colshapeTimer[player])
end
addEventHandler("onColShapeLeave",getRootElement(),colShapeLeave)
</syntaxhighlight>
When a player enters the colshape, debugscript outputs the following message:
{{Debug error|..[path]: attempt to index global 'colshapeTimer' (a nil value)}}
This means you tried to index a table that does not exist. In the example above, this is done when storing the timer id in the table. We need to add a check if the table exists and if not create it.

<syntaxhighlight lang="lua">
function colShapeHit(player)
if (colshapeTimer == nil) then
colshapeTimer = {}
end
-- set a timer to output a message (could as well execute another function)
-- store the timer id in a table, using the player as index
colshapeTimer[player] = setTimer(outputChatBox,10000,1,"The player stayed 10 seconds in the colshape!")
end
addEventHandler("onColShapeHit",getRootElement(),colShapeHit)

function colShapeLeave(player)
-- kill the timer when the player leaves the colshape
killTimer(colshapeTimer[player])
end
addEventHandler("onColShapeLeave",getRootElement(),colShapeLeave)
</syntaxhighlight>

Now we still get a warning when a player enters the colshape, waits for the message and leaves it again:

{{Debug warning|[..]: Bad argument @ 'killTimer' Line: ..}}

Except for that (we will talk about that later) everything seems to work fine. A player enters the colshape, the timer is started, if he stays the message occurs, if he leaves the timer is killed.

===A more inconspicuous error===
But for some reason the message gets outputted twice when you stay in the colcircle while in a vehicle. Since it would appear some code is executed twice, we add debug messages to check this.

<syntaxhighlight lang="lua">
function colShapeHit(player)
if (colshapeTimer == nil) then
colshapeTimer = {}
end
-- add a debug message
outputDebugString("colShapeHit")
-- set a timer to output a message (could as well execute another function)
-- store the timer id in a table, using the player as index
colshapeTimer[player] = setTimer(outputChatBox,10000,1,"The player stayed 10 seconds in the colshape!")
end
addEventHandler("onColShapeHit",getRootElement(),colShapeHit)

function colShapeLeave(player)
-- add a debug message
outputDebugString("colShapeLeave")
-- kill the timer when the player leaves the colshape
killTimer(colshapeTimer[player])
end
addEventHandler("onColShapeLeave",getRootElement(),colShapeLeave)
</syntaxhighlight>

Now we notice that both handler functions get executed twice when we are in a vehicle, but only once when we are on-foot. It would appear the vehicle triggers the colshape as well. To confirm this theory, we check the ''player'' variable that '''should''' contain a player element.

<syntaxhighlight lang="lua">
function colShapeHit(player)
if (colshapeTimer == nil) then
colshapeTimer = {}
end
-- add a debug message, with the element type
outputDebugString("colShapeHit "..getElementType(player))
-- set a timer to output a message (could as well execute another function)
-- store the timer id in a table, using the player as index
colshapeTimer[player] = setTimer(outputChatBox,10000,1,"The player stayed 10 seconds in the colshape!")
end
addEventHandler("onColShapeHit",getRootElement(),colShapeHit)

function colShapeLeave(player)
-- add a debug message, with the element type
outputDebugString("colShapeLeave "..getElementType(player))
-- kill the timer when the player leaves the colshape
killTimer(colshapeTimer[player])
end
addEventHandler("onColShapeLeave",getRootElement(),colShapeLeave)
</syntaxhighlight>

The debug messages tell us that one of the ''player'' variables is a player, the other one a vehicle element. Since we only want to react when a player enters the colshape, we add an ''if'' that will end the execution of the function if it's '''not''' an player element.

<syntaxhighlight lang="lua">
function colShapeHit(player)
if (colshapeTimer == nil) then
colshapeTimer = {}
end
-- add a check for the element type
if (getElementType(player) ~= "player") then return end
-- add a debug message, with the element type
outputDebugString("colShapeHit "..getElementType(player))
-- set a timer to output a message (could as well execute another function)
-- store the timer id in a table, using the player as index
colshapeTimer[player] = setTimer(outputChatBox,10000,1,"The player stayed 10 seconds in the colshape!")
end
addEventHandler("onColShapeHit",getRootElement(),colShapeHit)

function colShapeLeave(player)
-- add a check for the element type
if (getElementType(player) ~= "player") then return end
-- add a debug message, with the element type
outputDebugString("colShapeLeave "..getElementType(player))
-- kill the timer when the player leaves the colshape
killTimer(colshapeTimer[player])
end
addEventHandler("onColShapeLeave",getRootElement(),colShapeLeave)
</syntaxhighlight>

Now the script should work as desired, but will still output the warning mentioned above. This happens because the timer we try to kill when a player leaves the colshape will not exist anymore when it reached the 10 seconds and is executed. There are different ways to get rid of that warning (since you know that the timer might not exist anymore and you only want to kill it if it is there). One way would be to check if the timer referenced in the table really exists. To do this, we need to use [[isTimer]], which we will use when we kill the timer:
<syntaxhighlight lang="lua">
if (isTimer(colshapeTimer[player])) then
killTimer(colshapeTimer[player])
end
</syntaxhighlight>

So the complete working code would be:
<syntaxhighlight lang="lua">
function colShapeHit(player)
if (colshapeTimer == nil) then
colshapeTimer = {}
end
-- add a check for the element type
if (getElementType(player) ~= "player") then return end
-- add a debug message, with the element type
outputDebugString("colShapeHit "..getElementType(player))
-- set a timer to output a message (could as well execute another function)
-- store the timer id in a table, using the player as index
colshapeTimer[player] = setTimer(outputChatBox,10000,1,"The player stayed 10 seconds in the colshape!")
end
addEventHandler("onColShapeHit",getRootElement(),colShapeHit)

function colShapeLeave(player)
-- add a check for the element type
if (getElementType(player) ~= "player") then return end
-- add a debug message, with the element type
outputDebugString("colShapeLeave "..getElementType(player))
-- kill the timer when the player leaves the colshape
if (isTimer(colshapeTimer[player])) then
killTimer(colshapeTimer[player])
end
end
addEventHandler("onColShapeLeave",getRootElement(),colShapeLeave)
</syntaxhighlight>

==Debugging Performance Issues==

If your server is using up more resources than it should or you just want to make sure your scripts are efficient you can find the cause using a great tool that comes with MTA SA server, performancebrowser. Make sure that its started with "start performancebrowser" if it doesn't exist then get it from the default resources that come with the server. This tool provides an incredible amount of information for performance debugging. Memory leaks, element leaks and CPU intensive scripts are all easily findable via performancebrowser. If you use -d option in Lua timing you can see which functions are using up the CPU.

To access performancebrowser you will need to go to your web browser and enter the address: http://serverIPHere:serverHTTPPortHere/performancebrowser/ Note that the / at the end is required. So for example: http://127.0.0.1:22005/performancebrowser/ You will then need to login with an in-game admin account or any account that has access to "general.HTTP" Most of the information you will need are in the categories Lua timing and Lua memory, look for values that are much higher than other values.

===Examples of scripts that could cause performance problems===

Adding data to a table but never removing it. This would take months/years before it causes a problem though.
<syntaxhighlight lang="lua">
local someData = {}

function storeData()
someData[source] = true
-- There is no handling for when a player quits, this is considered a memory leak
-- Using the Lua timing tab you can detect the RAM usage of each resource.
end
addEventHandler("onPlayerJoin", root, storeData)
</syntaxhighlight>

Element leaking is possible if you use temporary colshapes for whatever reason and may not destroy them. This would cause bandwidth, CPU and memory performance issues over time.
<syntaxhighlight lang="lua">
function useTemporaryCol()
local col = createColCircle(some code here)
if (normally this should happen) then
destroyElement(col)
end
-- But sometimes it didn't so the script ended but the collision area remained and over time
-- you may end up with hundreds to thousands of pointless collision areas.
-- The Lua timing tab allows you to see the amount of elements each script has created.
end
</syntaxhighlight>

High CPU usage resulting in the server FPS dropping so much that the server is unplayable. In under 24 hours this can create havoc on a very busy server. The amount of "refs" in the Lua timing detect this type of build up, surprisingly the Lua timing tab didn't help in this case but Lua memory did.
<syntaxhighlight lang="lua">
addEventHandler("onPlayerJoin", root, function()
-- Code for joiner
addEventHandler("onPlayerQuit", root, function()
-- Code for when they have quit
-- See the problem? It's bound to root which the event handler is being added again and again and again
end)
end)
</syntaxhighlight>

A function uses up a lot of your CPU because whatever it does takes a long time. This is just some function that takes a long time to complete. Without performancebrowser you'd have no idea its the cause but with performancebrowser you can see that a resource is using lots of CPU in the Lua timing tab. If you then enter: -d into the options edit box it will even tell you what file name and first line of the function that is using up so much CPU.
<syntaxhighlight lang="lua">
function someDodgyCode()
for i=1, 100000 do
-- some code
end
end
</syntaxhighlight>

[[it:Guida al Debug]]
[[Category:Scripting Concepts]]
[[ru:Debugging]]

FR/Introduction GUI

2012-03-30T12:48:34Z

Citizen: Created page with " Une des grandes caractéristiques de MTA:SA c'est d'avoir la possibilité de personnaliser l'interface. Plus couramment appelé GUI(Graphic User Interface)...."

Une des grandes caractéristiques de MTA:SA c'est d'avoir la possibilité de personnaliser l'interface. Plus couramment appelé GUI(Graphic User Interface). L'interface graphique se compose de fenêtres, bouton, les boîtes d'édition, des cases à cocher ... Les GUI peuvent être affichés lorsque l'utilisateur est en jeu.

[[Image:AdminGUI.png|thumb|Le panel admin(GUI)]]

==Un tutoriel pour créer une fenêtre de connexion==
Dans ce tutoriel, nous allons faire une fenêtre de connexion simple avec deux boites de saisie et un bouton.
La fenêtre apparaîtra lorsque le joueur rejoindra le jeu et une fois que le joueur appuiera sur le bouton.

===Créer la fenêtre de connexion===
Tous les GUI doivent être crée dans le coté client. Pour vous simplifier la vie, créez votre code dans des dossiers séparé.
Les fichiers client vous les mettez dans le dossier client que vous avez créer.

Allez sur /Votre Server MTA/mods/deathmatch/resources/votreserver/, et créez un dossier du nom de "login".
Puis dans ce répertoire créer le dosser "client". (login/client)
Créez un fichier texte et nommez le "gui.lua".

Dans ce fichier nous allons écrire une fonction pour créer notre fenêtre. Pour créer une fenetre vous allez devoir utiliser [[guiCreateWindow]]:
<syntaxhighlight lang="lua">
function createLoginWindow()
-- on définie les positions de la fenêtre
local X = 0.375
local Y = 0.375
-- on définie la taille de la fenêtre
local Width = 0.25
local Height = 0.25
-- créez la fenêtre et sauvegardez cette élément sous la variable 'wdwLogin'
-- cliquez sur le nom de la fonction pour regarder sa documentation
wdwLogin = guiCreateWindow(X, Y, Width, Height, "Veuillez vous connecter", true)
end
</syntaxhighlight>

===Relatif et Absolu ===
Notez que l'argument final passé à guiCreateWindow dans l'exemple ci-dessus est ''true''. Cela indique que l'ensemble et les dimensions de la fenêtre sont ''relative'', en signifiant qu'ils sont un ''percentage'' de la grandeur d'écran totale. Cela signifie que si le côté gauche lointain de l'écran est 0 et le droit lointain est 1, une position X de 0.5 représenterait le point de centre de l'écran. De même si le haut de l'écran est 0 et le fond est 1, une position Y de 0.2 serait 20 % de la voie en bas l'écran. Les mêmes principes s'appliquent tant à Largeur qu'à Hauteur aussi (avec une valeur de Largeur de 0.5 sens la fenêtre sera la moitié aussi large que l'écran).

L'alternative à l'utilisation des valeurs relatives utilise absolu (en passant ''false'' au lieu de ''true'' pour guiCreateWindow). Les valeurs absolues sont calculées comme le nombre total de pixels du coin gauche-supérieur du parent (si aucun parent d'élément gui n'est spécifié, le parent est l'écran lui-même). Si nous supposons une résolution d'écran de 1920x1200, le côté gauche lointain de l'écran étant 0 pixels et le droit lointain étant 1920 pixels, une position X de 960 représentera le point de centre de l'écran. De même si le haut de l'écran est 0 pixels et le fond est 1200, une position Y de 20 serait 20 pixels en bas du haut de l'écran. La même pomme de principes tant à la Largeur qu'à la Hauteur aussi (avec une valeur de Largeur de 50 sens la fenêtre sera 50 pixels larges). Vous pouvez utiliser guiGetScreenSize et des petites mathématiques pour calculer certaines positions absolues.

Les différences entre l'utilisation des valeurs relatives et absolues sont tout à fait simples; les valeurs absolues utilisatrices de données de gui resteront toujours exactement la même grandeur de pixel et la position, pendant que les valeurs relatives utilisatrices de données de gui seront toujours un pourcentage de sa grandeur parentale.

L'absolu est généralement plus facile de maintenir en révisant le code à la main, pourtant votre choix de type dépend de la situation dont vous l'utilisez.

Pour les buts de cette introduction nous utiliserons des valeurs relatives.

===Adding the components===
Next, we'll add the text labels (saying "username:" and "password:"), edit boxes (for entering your data) and a button to log in.

To create buttons we use [[guiCreateButton]] and to create edit boxes use [[guiCreateEdit]]:

'''Note that we are now writing more code for our existing 'createLoginWindow' function. This is not a new function and is meant to replace what you already have.'''
<syntaxhighlight lang="lua">
function createLoginWindow()
local X = 0.375
local Y = 0.375
local Width = 0.25
local Height = 0.25
wdwLogin = guiCreateWindow(X, Y, Width, Height, "Please Log In", true)

-- define new X and Y positions for the first label
X = 0.0825
Y = 0.2
-- define new Width and Height values for the first label
Width = 0.25
Height = 0.25
-- create the first label, note the final argument passed is 'wdwLogin' meaning the window
-- we created above is the parent of this label (so all the position and size values are now relative to the position of that window)
guiCreateLabel(X, Y, Width, Height, "Username", true, wdwLogin)
-- alter the Y value, so the second label is slightly below the first
Y = 0.5
guiCreateLabel(X, Y, Width, Height, "Password", true, wdwLogin)

X = 0.415
Y = 0.2
Width = 0.5
Height = 0.15
edtUser = guiCreateEdit(X, Y, Width, Height, "", true, wdwLogin)
Y = 0.5
edtPass = guiCreateEdit(X, Y, Width, Height, "", true, wdwLogin)
-- set the maximum character length for the username and password fields to 50
guiEditSetMaxLength(edtUser, 50)
guiEditSetMaxLength(edtPass, 50)

X = 0.415
Y = 0.7
Width = 0.25
Height = 0.2
btnLogin = guiCreateButton(X, Y, Width, Height, "Log In", true, wdwLogin)

-- make the window invisible
guiSetVisible(wdwLogin, false)
end
</syntaxhighlight>
Note that every GUI component created is a child of the window, this is done by specifying the parent element (wdwLogin, in this case) when creating the component.

This is very useful because not only does it mean that all the components are attached to the window and will move with it, but also that any changes done to the parent window will be applied down the tree to these child components. For example, we can now hide all of the GUI we just created by simply hiding the window:
<syntaxhighlight lang="lua">
guiSetVisible(wdwLogin, false) --hides all the GUI we made so we can show them to the player at the appropriate moment.
</syntaxhighlight>

===Using the function we wrote===
The createLoginWindow function is now complete, but it won't do anything until we call it. It is recommended to create all GUI when the client resource starts, hide them, and show them to the player later when needed. Therefore, we'll write an event handler for "[[onClientResourceStart]]" to create the window:
<syntaxhighlight lang="lua">
-- attach the event handler to the root element of the resource
-- this means it will only trigger when its own resource is started
addEventHandler("onClientResourceStart", getResourceRootElement(getThisResource()),
function ()
createLoginWindow()
end
)
</syntaxhighlight>

As this is a log in window, we now need to show the window when the player joins the game.
This can be done using the same event, "[[onClientResourceStart]]", so we can modify the above code to include showing the window:

'''Note that we are now writing more code for our existing 'onClientResourceStart' handler. This is not a new event handler and is meant to replace what you already have.'''
<syntaxhighlight lang="lua">
addEventHandler("onClientResourceStart", getResourceRootElement(getThisResource()),
function ()
-- create the log in window and its components
createLoginWindow()

-- output a brief welcome message to the player
outputChatBox("Welcome to My MTA:SA Server, please log in.")

-- if the GUI was successfully created, then show the GUI to the player
if (wdwLogin ~= nil) then
guiSetVisible(wdwLogin, true)
else
-- if the GUI hasnt been properly created, tell the player
outputChatBox("An unexpected error has occurred and the log in GUI has not been created.")
end

-- enable the players cursor (so they can select and click on the components)
showCursor(true)
-- set the input focus onto the GUI, allowing players (for example) to press 'T' without the chatbox opening
guiSetInputEnabled(true)
end
)
</syntaxhighlight>

Note that we have a simple security check before making the window visible, so in the unlikely event that the window has not been created, meaning wdwLogin is not a valid element, we don't get an error and just inform the player what has happened.
In the next step, we will create the button functionality for the log in button.

==Scripting the button==
Now that we have created our GUI and shown it to the player, we need to make it work.

===Detecting the click===
When the player clicks on any part of the GUI, the event "[[onClientGUIClick]]" will be triggered for the GUI component you clicked on. This allows us to easily detect any clicks on the GUI elements we want to use.
For example, we can attach the event to the btnLogin button to catch any clicks on it:
<syntaxhighlight lang="lua">
-- attach the event onClientGUIClick to btnLogin and set it to trigger the 'clientSubmitLogin' function
addEventHandler("onClientGUIClick", btnLogin, clientSubmitLogin, false)
</syntaxhighlight>
'''Note the final argument passed is "false". This indicates that the event will only trigger directly on btnLogin, not if the event has propagated up or down the tree. Setting this to "true" while attaching to gui elements will mean that clicking on any element in the same branch will trigger this event.'''

This line of code can now be added inside the createLoginWindow function. It is a common mistake to try and attach events to non-existant GUI elements, so make sure you always attach your events '''after''' the gui element (in this case, the button) has been created:

'''Note that we are now writing more code for our existing 'createLoginWindow' function.'''
<syntaxhighlight lang="lua">
function createLoginWindow()
-- create all our GUI elements
...

-- now add our onClientGUIClick event to the button we just created
addEventHandler("onClientGUIClick", btnLogin, clientSubmitLogin, false)
</syntaxhighlight>

===Managing the click===
Now that we can detect when the player clicks on the button, we need to write code to manage what happens when they do.
In our [[onClientGUIClick]] event handle, we told it to call the function clientSubmitLogin whenever btnLogin is clicked.
Therefore, we can now use the function clientSubmitLogin to control what happens when the button is clicked:
<syntaxhighlight lang="lua">
-- create the function and define the 'button' and 'state' parameters
-- (these are passed automatically by onClientGUIClick)
function clientSubmitLogin(button,state)
-- if our login button was clicked with the left mouse button, and the state of the mouse button is up
if button == "left" and state == "up" then
-- move the input focus back onto the game (allowing players to move around, open the chatbox, etc)
guiSetInputEnabled(false)
-- hide the window and all the components
guiSetVisible(wdwLogin, false)
-- hide the mouse cursor
showCursor(false)
end
end
</syntaxhighlight>
Now, when the button is clicked, the window will be hidden and all controls will be returned to the player. Next, we will tell the server to allow the player to spawn.

===Triggering the server===
Triggering the server can be done using [[triggerServerEvent]]. This allows you to trigger a specified event on the server from the client. The same can be done in reverse using [[triggerClientEvent]].
Here, we use the [[triggerServerEvent]] function to call our own custom event on the server, named "submitLogin", which will then control the spawning of the player serverside.

'''Note that we are now writing more code for our existing 'clientSubmitLogin' function. This is not a new function and is meant to replace what you already have.'''
<syntaxhighlight lang="lua">
function clientSubmitLogin(button,state)
if button == "left" and state == "up" then
-- get the text entered in the 'username' field
local username = guiGetText(edtUser)
-- get the text entered in the 'password' field
local password = guiGetText(edtPass)

-- if the username and password both exist
if username and password then
-- trigger the server event 'submitLogin' and pass the username and password to it
triggerServerEvent("submitLogin", getRootElement(), username, password)

-- hide the gui, hide the cursor and return control to the player
guiSetInputEnabled(false)
guiSetVisible(wdwLogin, false)
showCursor(false)
else
-- otherwise, output a message to the player, do not trigger the server
-- and do not hide the gui
outputChatBox("Please enter a username and password.")
end
end
end
</syntaxhighlight>

===Creating the serverside event===
At this point we now have all the code needed on the client side, so open up your serverside 'script.lua' file (from the [[Scripting Introduction|Introduction to Scripting]]) or another suitable serverside file to work with.

On the server side, recall that we are spawning the player as soon as they login.
So, first of all, we will need to define the custom event that we used before on the client. This can be done using [[addEvent]] and [[addEventHandler]].
<syntaxhighlight lang="lua">
-- create our loginHandler function, with username and password parameters (passed from the client gui)
function loginHandler(username,password)

end

-- define our custom event, and allow it to be triggered from the client ('true')
addEvent("submitLogin",true)
-- add an event handler so that when submitLogin is triggered, the function loginHandler is called
addEventHandler("submitLogin",root,loginHandler)
</syntaxhighlight>

===Logging in===
Now we have a function that is called through the custom event 'submitLogin', we can start to work on logging in and spawning the player, using our 'loginHandler' function:
<syntaxhighlight lang="lua">
function loginHandler(username,password)
-- check that the username and password are correct
if username == "user" and password == "apple" then
-- the player has successfully logged in, so spawn them
if (client) then
spawnPlayer(client, 1959.55, -1714.46, 10)
fadeCamera(client, true)
setCameraTarget(client, client)
outputChatBox("Welcome to My Server.", client)
end
else
-- if the username or password are not correct, output a message to the player
outputChatBox("Invalid username and password. Please re-connect and try again.",client)
end
end

addEvent("submitLogin",true)
addEventHandler("submitLogin",root,loginHandler)
</syntaxhighlight>
'''For the purposes of this tutorial, a very basic username and password system is shown. For a more comprehensive alternative, you can use the Account System or a MySQL database.'''

Also note the use of the variable "client", it's an internal variable used by MTA to identify the player who triggered the event.

Finally, do not forget to include the new gui.lua file in the meta.xml of the main resource, and label it as a client script:
<syntaxhighlight lang="xml">
<script src="client/gui.lua" type="client" />
</syntaxhighlight>

At this point, we now have a basic login window that checks the player's username and password when the login button is clicked. If they are correct, the player is automatically spawned.

For further help with GUI, see the [[:Category:GUI_Tutorials|GUI tutorials]].

[[Category:GUI_Tutorials]]
[[it:Introduzione_allo_scripting_della_GUI]]
[[ru:Introduction to Scripting the GUI]]

FR/Introduction Programmation

2012-03-30T12:48:17Z

Citizen: Created page with "Les ressources sont les parties clées de MTA. Une ressource est un dossier ou un .zip qui contient plusieurs fichiers, ainsi qu'une meta qui dit au serveur comment la resource d..."

Les ressources sont les parties clées de MTA. Une ressource est un dossier ou un .zip qui contient plusieurs fichiers, ainsi qu'une meta qui dit au serveur comment la resource doit-elle être chargée. Une ressource peut être comparée comme un programme qu'on peut lancer ou arrêter, il est possible de lancer plusieurs ressources en même temps.

Tout ce qui a un rapport avec la programmation se passe dans les ressources, se que fait la ressource, définie si c'est un gamemode, une map or quelquechose d'autre. MTA s'installe avec des resources que vous pouvez facultativement utiliser dans vos gamemodes, comme la ressource "maplimits" pour garder les joueurs dans une certaine zone ou encore "deathpickups" pour créer des pickups pour ramasser une arme.

'''La première chose à faire avant de pouvoir programmer en lua, c'est de se procurer un editeur de texte qui supporte le lua. Il vous sera beaucoups plus facile que de le faire avec le bloc-note de Windows. Nous vous recommendons donc [http://notepad-plus.sourceforge.net/uk/site.htm Notepad++] ou [http://luaedit.sourceforge.net/ LuaEdit]. Il y a aussi un logiciel non officiel [[MTASE|MTA Script Editor]] ( malheureusement l'auteur ne travail plus dessus ) que vous pouvez tester.'''

==Créer un script qui fonctionne==
Nous allons voir tout d'abord comment créer un simple script étapes par étapes qui permetra aux joueurs de se deplacer dans la ville. Dans ce tutoriel, on utilisera notepadd++.
===Où sont tous les scripts ?===
Laissez moi d'abord vous présenter comment s'oranise une ressource. Allez dans votre dossier MTA San et et suivez le chemin suivant:

/serveur/mods/deathmatch/resources/

Vous y verez de nombreux fichier avec l'extension .zip, se sont des ressources avec à l'intérieur des exemples de scripts . Toutes les ressources chargées sont dézippé par le serveur afin de pouvoir les exécuter ( les .zip ne sont pas obligatiores, vous pouvez aussi laissez votre ressource en tant que dossier ). Pour créer votre propre ressource, créez simplement un nouveau dossier et nommez le comme vous voulez ( Ne pas utiliser d'espace, utilisez plutôt un _ ) . Nommez le "myserveur" pour ce tutoriel.

Maintenant entrez dans votre dossier. Le chemain devrait donc être

/serveur/mods/deathmatch/resources/myserveur/

===Identifier votre ressource===
Pour que le serveur puisse savoir ce que contient votre ressource, un fichier ''meta.xml'' doit être créé afin d'établir une liste du contenu du dossier. Cette 'meta.xml' doit être à la racine de votre ressource ( et non pas dans un autre sous-dossier ), donc dans le dossier "myserveur" dans notre cas. Donc ouvrez notepadd++, créer un nouveau fichier (Ctrl+N), puis faite "Enregistrez sous ..." (Ctrl+Alt+S), dans "Nom:" vous écrivez "meta" et dans "Type:", sélectionnez "*.xml" ( avant-dernier de la liste ), sauvegardez le dans votre dossier "myserveur".

Maintenant, ecrivez le code suivant dans votre ''meta.xml'':
<syntaxhighlight lang="xml">
<meta>
<info author="Votre Nom" type="gamemode" name="Mon serveur" description="Mon premier serveur MTA" />
<script src="script.lua" />
</meta>
</syntaxhighlight>
Dans la balise ''<info />'', il y a le champ "type" qui indique si la ressource est un ''gamemode'' ou une ''map'', on y reviendra plus tard. Un gamemode est ce dont vous avez besoin pour que votre serveur est une base.

La balise ''<script />'' indique les scripts qui sont dans la ressource, que l'on va maintenant créer.
===Créer un script simple===
Notez que dans la balise ''<script />'', le fichier .lua n'est pas dans un autre sous-dossier. Donc on va créer notre script.lua au même endroit que notre meta.xml ( Reproduisez la même opération mais "Nom:" écrivez 'script' et pour "Type:" choisissez 'Lua(*.lua)' ) puis copier-coller le code suivant:
<syntaxhighlight lang="lua">
function joinHandler()
local x = 1959.55
local y = -1714.46
local z = 10
spawnPlayer(source, x, y, z)
fadeCamera(source, true)
setCameraTarget(source, source)
outputChatBox("Bienvenue sur mon serveur", source)
end
addEventHandler("onPlayerJoin", getRootElement(), joinHandler)
</syntaxhighlight>
Ce script va fous faire apparître aux coordonnées (x, y, z) spécifié dans le code, lorsque vous connecterez au serveur. La fonction ''fadeCamera'' sinon l'écran restera noir. Vous devez aussi dire à la camera de suivre le joueur grâce à la fonction 'setCameraTarget' (sinon il vera une mer bleu).

La variable '''source''' indique qui 'déclenche' la fonction. Le fonction se 'déclenche' lorsqu'un joueur rejoind le serveur, vous utiliserez cette variable pour voir qui à rejoind le serveur. Donc lorsque un joueur( "la source" ) rejoindra notre serveur, on le fera apparaître aux coordonnées indiquées .

Focalisons-nous sur [[addEventHandler]], vous pouver voir 3 choses: 'onPlayerJoin', qui indique quand éxécuter la fonction X. getRootElement(), qui indique qui/quoi peut être déclencher la fonction (getRootElement() veut dire toutes les choses et tous les joueurs). Et enfin la fonction X à éxecuter ( ici joinHandler ). Pour les autres details, nous verrons plus tard dans d'autres exemples mais tout d'abord testons notre premier gamemode!

===Lancer le gamemode===
Pour lancer le serveur, lancer simplement le 'MTA Server.exe' qui se trouve dans votre dossier 'MTA San et\server'. Une liste d'info concernant le serveur apparaîtra en premier; notez le port du serveur ( 22003 par défaut ), vous en aurez besoin pour rejoindre le serveur. Après, le serveur charge toutes les ressources du dossier 'resource', et enfin "ready to accept connections!"

Avant de pouvoir vous connecter, vous devez lancer votre gamemode. Tapez "start myserver" et appuyer sur Entrer. Le serveur va alors lancer le gamemode que nous avons créé, et nous affichera aussi les erreurs s'il y en a. Maintenant, vous pouvez maintenant lancer MTA, cliquez sur "Quick Connect" et ecrivez ceci: Dans Host: le1er champ: 127.0.0.1 ou localhost ( cela signifie que vous vous connectez au serveur du pc actuel ) et le 2ème champ: le port ( ici 22003 ) et cliquez sur 'Connect'. Si tout se passe bien, après quelques secondes, vous devriez apparaître et pouvoir allez où vous voulez.

Ensuite nous allons créer une commande que les joueurs pourront utiliser pour faire apparître une voiture à coté d'eux.

==Créer une commande==
Revenons à l'intérieur de notre ''script.lua''. Tout d'abord, nous devons créer une fonction qu'on pourra appeler/éxécuter grâce à notre commande et la fonction 'addCommandHandler' afin de créer la commande que les joueurs pourront taper dans le chat( T ) ou la console( F8 ).

<syntaxhighlight lang="lua">
-- On crée la fonction qui sera appelée par notre commande avec les arguments: thePlayer, command, vehicleModel
function createVehicleForPlayer(thePlayer, commandName, vehicleModel)
-- Ici on crée le véhicule
end
-- on crée la commande et on l'attache à notre fonction
addCommandHandler("createVehicle", createVehicleForPlayer)
</syntaxhighlight>
''Note: Grâce au wiki, vous pouvez cliquer sur le nom des fonctions et cela vous redirigera sur la documentation de cette fonction.''

====A propos du addCommandHandler====
Le premier argument du [[addCommandHandler]] est le nom de la commande the player will be able to enter, le second le nom de la fonction à appeler, dans notre cas, ''createVehicleForPlayer''.

Si vous avez déjà de l'expérience dans le codage, vous savez qu'un fonction s'appelle comme ceci:
<syntaxhighlight lang="lua">
nomDeLaFonction(argument1, argument2, argument3, ..)
</syntaxhighlight>
Si l'on regarde bien l'exemple ci-dessus, nous pouvons voir que l'argument1 est thePlayer and argument2 le commandName. thePlayer est celui qui à tapé la commande et commandName contient le nom de la commande qu'il à tapé. Donc si un joueur tape "/greet", cet argument va contenir "greet". Argument3 c'est ce que le joueur à tapé en plus de la commande, vous allez apprendre ceci dans le tutoriel. N'oubliez jamais que les deux premiers arguments sont les arguments standards, mais vous pouvez les renommé si vous voulez, seul l'ordre est important.

Par exemple: Un joueur tape "createVehicle 468" pour faire aparaître une Sanchez, la fonction addCommandHandler va appeller notre fonction createVehicleForPlayer, comme ceci:
<syntaxhighlight lang="lua">
createVehicleForPlayer(thePlayer,"createVehicle","468") -- thePlayer est l'élement joueur qui a tapé la commande
</syntaxhighlight>
Comme nous pouvons le voir, ll fournit plusieurs paramètres: le joueur qui a tapé la commande, la commande qu'il a tapé, et n'importe quelle texte qu'il a mis après, dans notre cas, "468" comme id de la Sanchez. Les deux premiers paramètres sont les même pour tous les addCommandHandler qu'on peut retrouver sur la page du [[addEventHandler]]. Vous devez toujours définir au moins ces deux paramètres pour utiliser les arguments après eux (par exemple pour traiter le texte qui a été entré après la commande, comme dans notre exemple le modèle du véhicule).

''Note: Vous devez créer la commande APRES la fonction que vous allez utiliser pour cette commande, sinon il ne trouvera pas la fonction.''

====Ecrire la fonction====
Pour remplir notre fonction d'instructions, nous devons d'abord pensez à ce que nous devons faire:
* Récupérer la position du joueur, donc on connaitra la position où faire apparaître le véhicule (on veut le faire apparaître à droite du joueur)
* Calculer la position où faire apparître le véhicule (nous ne voulons pas que le véhicule apparaisse dans le joueur)
* Faire apparître les véhicule
* Vérifier si le véhicule a bien apparus, ou aficher un message d'erreur.

Pour ça, nous devons utiliser plusieurs fonctions. Pour trouver la fonction que nous devons utiliser, il faut aller faire un tour dans la [[Scripting Functions|La liste des fonctions serveur]]. D'abord nous avons besoin d'une fonction pour obtenir la position du joueur. Puisque les joueurs sont des éléments, nous devons allez dans la rubrique '''Element functions''' où l'on pourra trouver la fonction [[getElementPosition]]. En cliquant sur le nom de la fonction, le wiki va vous afficher sa description. On peut y voir la syntaxe, qu'est-ce que la fonction retourne. La syntaxe nous montre les argument qu'on peut ou qu'on doit envoyer.

Pour [[getElementPosition]], la syntaxe est:
<syntaxhighlight lang="lua">
float, float, float getElementPosition ( element theElement )
</syntaxhighlight>

Les trois float devant le nom de la fonction est le type de variable que la fonction nous retourne. Dans notre cas, la fonction retourne trois nombres à virgule(x, y et z). Dans les parenthèses, on peut voir les arguments que l'on doit envoyer, dans notre cas, l'element dont on veut récupérer la position, le joueur dans notre exemple.

<syntaxhighlight lang="lua">
function createVehicleForPlayer(thePlayer, command, vehicleModel)
-- on récupère la position x,y,z dans des variables locales
-- une variable locale n'existe que dans le "périmètre" actuel. Ici, les variable x, y et z sont des variables locales qui se détruiront à la fin de la fonction.
local x,y,z = getElementPosition(thePlayer)
end
</syntaxhighlight>

Ensuite, il faut s'assurer que le véhicule n'apparaît pas directement dans le joueur, donc on ajoute quelques unités à la variable ''x'', qui le fera apparaître plus à l'est par rapport au joueur.

<syntaxhighlight lang="lua">
function createVehicleForPlayer(thePlayer, command, vehicleModel)
local x,y,z = getElementPosition(thePlayer) -- On prent la position du joueur qui a tapé la commande
x = x + 5 -- on ajoute 5 unité sur l'axes des x
end
</syntaxhighlight>

Maintenant nous avons besoin d'une autre fonction, celle qui va faire apparaître le véhicule. Nous allons la cherché encore une fois dans la [[Scripting Functions|liste des fonctions serveur]], mais cette fois, comme nous parlons d'un véhicule, nous devons donc aller dans la catégorie'''Vehicle functions''', où l'on va trouver la fonction [[createVehicle]]. Dans la syntaxe, nous pouvons voir que cette fonction ne retourne qu'une seule variable, le véhicule ( de type élément ) que nous venons de créer. Nous pouvons aussi voir qu'il y a des arguments entre crochets [], cela veut dire que ce sont des arguments optionels.

Nous avons déjà tous les arguments pour la fonction [[createVehicle]] dans notre fonction: La position que nous avons juste calculée dans les variables "x, y, z" et l'id du véhicule que nous avons fourni par la commande ("/createVehicle 468") et qui est stocké dans la variable ''vehicleModel''.

<syntaxhighlight lang="lua">
function createVehicleForPlayer(thePlayer, command, vehicleModel)
local x,y,z = getElementPosition(thePlayer) -- récupere la position du joueur dans les variables x, y et z
x = x + 5 -- rajoute 5 unités sur x
-- on crée le véhicule et on enregistre l'élément de type "vehicle" dans la variable ''createdVehicle''
local createdVehicle = createVehicle(tonumber(vehicleModel),x,y,z)
end
</syntaxhighlight>

Avec cette variable, on pourrait faire pas mal de choses sympa, mais ici nous allons juste vérifier si le véhicule à bien été créé ou non.
Sur le wiki de la fonction [[createVehicle]], il y a la partie nomée '''Returns''', la fonction va retourner ''false'' si la voiture n'a pas été créé. Ducoups, on va regarder la valeur de la variable ''createdVehicle''.

Voilà notre code complet:
<syntaxhighlight lang="lua">
function createVehicleForPlayer(thePlayer, command, vehicleModel)
local x,y,z = getElementPosition(thePlayer) -- On prent la position du joueur qui a tapé la commande
x = x + 5 -- on ajoute 5 unités à x
local createdVehicle = createVehicle(tonumber(vehicleModel),x,y,z) -- on crée le véhicule demandé par le joueur et on récupère ce que nous retourne la fonction dans la variable createdVehicle
-- On vérifie si la valeur retournée est égal à ''false'' ( ce qui signifie que ça n'a pas marché )
if (createdVehicle == false) then
-- si c'est le cas, on affiche un message d'erreur dans la chatbox mais seulement pour le joueur.
outputChatBox("Erreur lors de la création du véhicule.",thePlayer)
end
end
addCommandHandler("createVehicle", createVehicleForPlayer)
</syntaxhighlight>

Comme vous pouvez le voir, nous avons utilisé une nouvelle fonction: [[outputChatBox]]. Vous devriez maintenant pouvoir regarder la description de cette fonction par vous même.

==Ce que vous devez savoir==
Vous avez déjà lu quelques informations sur les ressources, les commandes et trouvez des fonctions dans le wiki, mais il y a encore beaucoup à apprendre. Cette section vous donnera une vue d'ensemble plutôt courte sur certaines de ces choses, tout en regardant les pages du wiki si possible.
===Les scripts client et serveur===
Vous pouvez avoir déjà remarqué ces termes (serveur/client) quelque part sur ce wiki, le plus souvent pour les fonctions. MTA ne supporte pas seulement les scripts exécuté par le serveur et des commandes (comme celle qu'on vien de faire) ou d'autres fonctions, mais aussi les scripts éxécuté par le client MTA, ceux des joueurs qui se connecte au serveur. La raison est que certaines fonctions de MTA doit être du coté client comme par exemple le GUI - Graphical User Interface - ( Pour tout ce qui est fenêtres, boutons, etc ), d'autres devraient être du côté client parce qu'ils fonctionnent mieux mais d'autres sont mieux pensées pour être du côté serveur ou ne fonctionne tout simplement pas du côté client.

La plupart de vos scripts (gamemodes, maps) seront surement du côté serveur, comme celui que nous avons fait tout à l'heure. Si vous vous heurtez à quelque chose qui ne peut pas être résolu du côté serveur, vous devrez probablement le faire côté client. Pour un script client, vous devriez créer un script ordinaire (par exemple appelé ''client.lua'') et spécifié dans la meta.xml, comme ceci:
<syntaxhighlight lang="xml">
<script src="client.lua" type="client" />
</syntaxhighlight>
L'attribut ''type'' est par defaut 'server', donc nous avons juste besoin de spécifier que c'est un script client. Lorsque vous faites ceci, le fichier va être télecharger par le joueur sur son ordinateur lorsqu'il se connecte au serveur. Plus d'infos: [[Client side scripts]].

===Ressources plus complexes===
La section précédente nous a montré brièvement comment ajouter des scripts clients à la ressource. Let's have some theoretical resources, by looking at the files it contains, the ''meta.xml'' and what they might do:

====First example - A utility script====
<syntaxhighlight lang="xml">
/admin_commands
/meta.xml
/commands.lua
/client.lua
</syntaxhighlight>
<syntaxhighlight lang="xml">
<meta>
<info author="Someguy" description="admin commands" />
<script src="commands.lua" />
<script src="client.lua" type="client" />
</meta>
</syntaxhighlight>

* Le "commands.lua" fournit quelques ordres d'admin, comme le fait d'interdire un joueur, en banissant ou quelque chose d'autre ce qui peut être utilisé par l'admin du serveur
* Le "client.lua" fournit un GUI pour être capable d'exécuter les actions mentionnées facilement

This example might be running all the time (maybe even auto-started when the serveur starts) as it's useful during the whole gaming experience and also wont interfere with the gameplay, unless an admin decides to take some action of course.

====Second example - A gamemode====
<syntaxhighlight lang="xml">
/counterstrike
/meta.xml
/counterstrike.lua
/buymenu.lua
</syntaxhighlight>
<syntaxhighlight lang="xml">
<meta>
<info author="Someguy" description="Counterstrike remake" type="gamemode" />
<script src="counterstrike.lua" />
<script src="buymenu.lua" type="client" />
</meta>
</syntaxhighlight>

* Le "counterstrike.lua" contient des caractéristiques semblables aux dispositifs suivants :
** Laissez les joueurs choisir leur équipe et les apparaitre
** Fournissez-leur des armes, des cibles et des instructions (peut-être lues d'une carte, voir ci-dessous)
** Définissez les règles du jeu, par exemple. La partie se finie, ce qui se produit quand un joueur meurt
** .. et peut-être encore plus
* Le "buymenu.lua" est un manuscrit du côté client et crée un menu pour acheter des armes

Cet exemple peut s'appeler un gamemode, depuis lui non seulement des intereferes avec le gameplay, mais définit réellement les règles de lui-même. Le "type" attribut indique que cet exemple fonctionne avec [[Map Manager]], encore une autre ressource qui a été écrite par l'équipe de QA pour contrôler des gamemodes et le chargement de carte. On lui recommande fortement que vous basiez vos gamemodes sur les techniques qu'il fournit.

Ceci signifie également que le gamemode ne fonctionnera pas probablement sans carte. Gamemodes devrait toujours être aussi générique comme possible. Un exemple pour une carte est énoncé dans le prochain exemple.

====Troisième exemple - une carte====
<syntaxhighlight lang="xml">
/cs-airport
/meta.xml
/airport.map
/airport.lua
</syntaxhighlight>
<syntaxhighlight lang="xml">
<meta>
<info author="Someguy" description="Counterstrike airport map" type="map" gamemodes="counterstrike" />
<map src="airport.map" />
<script src="airport.lua" />
</meta>
</syntaxhighlight>

* Le "airport.map" dans le fichier XML fournit des informations au sujet de la carte au gamemode, ceului-ci peut inclure :
** Là où les joueurs devraient apparaitre, avec quelles armes, avec quelle équipe
** Ce qui sont les cibles
** Temps, heure du monde, Limite de temps
** Fournir les véhicules
* Le ''airport.lua'' peut contenir les dispositifs carte-spécifiques, celui-ci peut inclure :
** En ouvrant une certaine porte/faisant éclater quelque chose quand quelque chose de spécifique se produit
** Créez ou déplacez quelques objets faits sur commande, ou manoeuvrez les objets qui sont créés dans le fichier .map
** .. toute autre chose carte-spécifiques

Comme vous pouvez voir, l'attribut "type" a changé en 'map', dire [[Map Manager]] que cette ressource est une carte, tandis que l'attribut "gamemodes" indique pour quels gamemodes cette carte est valide, dans ce cas-ci le gamemode de l'exemple ci-dessus.
Ce qui peut venir comme une surprise est qu'il y a aussi un script dans la ressource de Carte. Évidemment ce n'est pas nécessairement nécessaire dans une carte, mais ouvre une large gamme de possibilités pour les producteurs de carte pour créer leur propre monde dans les règles du gamemode pour lequel ils le créent.

Le "airport.map" pourrait être semblable à ceci :
<syntaxhighlight lang="xml">
<map mode="deathmatch" version="1.0">
<terrorists>
<spawnpoint posX="2332.23" posY="-12232.33" posZ="4.42223" skins="23-40" />
</terrorists>
<counterterrorists>
<spawnpoint posX="2334.23443" posY="-12300.233" posZ="10.2344" skins="40-50" />
</counterterrorists>

<bomb posX="23342.23" posY="" posZ="" />

<vehicle posX="" posY="" posZ="" model="602" />
<vehicle posX="" posY="" posZ="" model="603" />
</map>
</syntaxhighlight>

Quand un gamemode est commencé avec une carte, les ressources de carte est automatiquement commencé par le mapmanager et les renseignements qu'il contient peut être lu par la ressource gamemode. Quand la carte change, la ressource de carte actuelle est arrêtée et la ressource de carte suivante est commencée. Pour une explication plus détaillée et des exemples de comment les ressources de carte sont utilisées dans le script principal, visitez s'il vous plaît la page [[Writing Gamemodes]].

===Événements===
Les événements sont la façon que MTA dit aux scripts des choses qui arrivent. Par exemple quand un joueur meurt, le [[onPlayerWasted]] l'événement est déclenché. Pour exécuter n'importe quelles actions quand un joueur meurt, vous devez vous préparer similiar à l'ajoutant d'un dresseur d'ordre, comme montré dans [[#Writing_the_script|the first chapter]].

Cet exemple produiras un message avec le nom du joueur qui est mort :
<syntaxhighlight lang="lua">
function playerDied(totalAmmo, killer, killerWeapon, bodypart)
outputChatBox(getPlayerName(source).." died!")
end
addEventHandler("onPlayerWasted",getRootElement(),playerDied)
</syntaxhighlight>

Au lieu de montrer que les arguments sont nécessaires, la page de documentation pour les spectacles d'Événements quels paramètres sont passés à la handler function, similaire à la voie un [[*About_command_handlers|command handler]] fait, juste qu'il se distingue de l'événement à l'événement. Un autre point important est la variable "source", qui existe dans les handler function. Ils ne doivent pas être ajoutés à la liste de paramètre de la fonction, mais cela existe toujours . Il a une différente valeur de l'événement à l'événement, pour les événements de joueur (comme dans l'exemple au-dessus) c'est l'élément de joueur. Comme un autre exemple, vous pouvez jeter un coup d'œil au script de joueur frayant fondamental dans la première section pour recevoir une idée comment "source" est utilisé.

==Où aller d'ici==
Vous devriez maintenant être familiers avec les aspects les plus fondamentaux de MTA scripting et aussi un peu avec la documentation. Le [[Main_Page]] vous fournit des liens vers plus de renseignements, Classes de travaux dirigés et Références qui permettent un coup d'oeil plus profond dans les thèmes dont vous désirez apprendre.

D'ici nous recommandons de lire le [[debugging]] la classe de travaux dirigés. De bonnes adresses déboguantes sont une nécessité absolue quand vous faites des scripts.

[[ru:Scripting Introduction]]
[[it:Introduzione allo scripting]]
[[es:Introducción a la Programación]]

FR/A propos des Map

2012-03-30T12:47:45Z

Citizen: Created page with "{{Needs Checking|Either complete the translation or remove it.}} {{Resource page}} Le "Map manager" est une ressource inclue dans la suite serveur de MTA DM. Elle offre des comma..."

{{Needs Checking|Either complete the translation or remove it.}}
{{Resource page}}
Le "Map manager" est une ressource inclue dans la suite serveur de MTA DM. Elle offre des commandes, fonctions et événements pour les modes de jeu afin de dynamiser vos maps. Par exemple, quand un serveur doit charger plusieurs routes pour plusieurs maps, au lieu d'avoir le tout dans un seul script principal, ces routes peuvent êtres stockée dans plusieurs ressources et chargée simplement grâce à la fonction "changeGamemodeMap" quand une map démarre.

Plus spécifiquement, le "Map manager" liste les modes de jeux et maps chargés sur le serveur. Il inclut un listing sur l'interface web, il rafraîchit cette liste fréquemment et met en gras les ressources et/ou maps actuellement entrain d'être utilisées.

== Un Simple Tutoriel ==
Dans cette section nous allons poursuivre le travail commencé dans [[Scripting Introduction|Introduction to Scripting]]. Nous allons ajouter une ressource qui enregistre l'endroit de spawn des joueurs sur la map, le chargement de ce script se fera depuis le script principal.

Premièrement, créez un dossier dans /Your MTA Server/mods/deathmatch/resources/, nommez-le "mymap". Ensuite dans ce dossier, créez un fichier texte et nommez-le "meta.xml", ce fichier est présent dans chaque scripts.

Ecrivez les lignes suivantes dans le fichier ''meta.xml'' :
<syntaxhighlight lang="xml">
<meta>
<info type="map" gamemodes="myserver"/>
<map src="mymap.map"/>
</meta>
</syntaxhighlight>
Prenez garde car ce fichier est "lié" avec le ''gamemodes=""'' choisit, qui contient le nom de la ressource principale qu'utilise ce mode. le paramètre ''map'', indique le nom de la map qui sera afficher sur le serveur.

Maintenant créez un nouveau fichier texte dans /mymap/ et nommez le "mymap.map", écrivez y les lignes suivantes:
<syntaxhighlight lang="xml">
<map>
<spawnpoint id="spawnpoint1" posX="1959.5487060547" posY="-1714.4613037109" posZ="18" rot="63.350006103516" model="0"/>
</map>
</syntaxhighlight>
Notez que "spawnpoint" est le type de l'élément utilisé dans la fonction [[getElementsByType]], "id" est utilisée dans la fonction [[getElementByID]]

Pour charger la map, le script principal doit pouvoir accéder aux maps par lui même. Quelques modifications sont à apportées dans script.lua situé dans "myserver". Entrez les lignes suivantes :

<syntaxhighlight lang="lua">
function loadMap(startedMap)
mapRoot = getResourceRootElement(startedMap)
end

addEventHandler("onGamemodeMapStart", getRootElement(), loadMap)
</syntaxhighlight>
Par défaut, l'evênement "onGamemodeMapStart" nous donne le "handle"(?) de la map ("startedMap"), lequel nous avons utilisé pour le "handle"(?) de la ressource contenant la map ("mapRoot").

Avec la ressource "handle"(?), nous pouvons extraire les informations relatives au spawnpoint. Jetez un œil à la fonction joinHandler() dans script.lua, à la place de x, y and z, nous pouvons utiliser les informations de la map comme suit :
<syntaxhighlight lang="lua">
function joinHandler()
local spawn = getElementsByType("spawnpoint", mapRoot)
local x,y,z,r
for key, value in pairs(spawn) do
x = getElementData(value, "posX")
y = getElementData(value, "posY")
z = getElementData(value, "posZ")
r = getElementData(value, "rot")
end
spawnPlayer(source, x, y, z)
fadeCamera(source, true)
end
</syntaxhighlight>
Lancez maintenant votre gamemode avec la commande suivante via la console:

'''gamemode myserver mymap'''

==Usage==
Pour utiliser le map manager, vos ressources doivent d'abord être reconnues en tant que gamemodes ou maps.

Vous devez remplir quelques informations pour votre fichier de configuration du '''gamemode resource''' :
<syntaxhighlight lang="xml"><info description="Votre Gamemode" type="gamemode" /></syntaxhighlight>

'''Map resources''' Les maps ont aussi besoin d'information dans le meta.xml, ''type="map"'' et un ou plusieurs ''gamemodes''. Une map peut en effet être compatible avec plusieurs mode de jeu pour se faire il faudra séparer les modes par une virgule ''sans espaces''.
<syntaxhighlight lang="xml"><info description="A gamemode map" type="map" gamemodes="ctv,koth" /></syntaxhighlight>

Il ne peut y avoir qu’un mode de jeu 'Gamemode' Actif ou une map chargée à la fois.

==Paramètres Supplémentaires==
Ces paramètres sont aussi à ajouter dans meta.xml.

'''name:''' Entrez ici un message sympa qui sera afficher lors du démarrage de la ressource. C'est en quelques sorte un alias au cas ou le nom de votre ressource ne vous correspond pas.

==Commandes==
'''changemap newmap [newgamemode]''' (changer le 'Gamemode' d'une map)

'''changemode newgamemode [newmap]''' (lancer un mode de jeu 'Gamemode' et démarrez une map)

'''gamemode newgamemode [newmap]''' (idem que la précédente)

'''stopmode''' (Arrête le mode de jeu et la map en cours)

'''stopmap''' (Arrête la map en cours)

'''maps [gamemode]''' (liste toutes les maps sur le serveurs, ajoutez en option le mode pour lequel vous voulez connaître les maps)

'''gamemodes''' (Liste tout les mode de jeu)

==Paramètres==
'''*mapmanager.color''' [hex color string] (change la couleur de sortie des message du mapmanager) (Par défaut : #E1AA5A)

'''*mapmanager.messages''' [boolean] (si les changements de map/gm sont activés) (Par défaut : true)

'''*mapmanager.ASE''' [boolean] (si le manager doit charger en mode ASE) (Par défaut : true)

==Autres fonctions==
<syntaxhighlight lang="lua">bool changeGamemode ( resource newGamemode, [ resource mapToLoadWith ] )</syntaxhighlight>
Changement de mode de jeu, on peut aussi lui donner une map initial à charger.
<syntaxhighlight lang="lua">bool changeGamemodeMap ( resource newMap, [ resource gamemodeToChangeTo ] )</syntaxhighlight>
Change le mode de jeu d'une map pour un nouveau, on peut choisir un mode de jeu à charger une fois cette map rechargée.
<syntaxhighlight lang="lua">table getGamemodes ( )</syntaxhighlight>
Renvoie une table des tout les modes de jeu et leur pointeurs.
<syntaxhighlight lang="lua">table getGamemodesCompatibleWithMap ( resource theMap )</syntaxhighlight>
Returns a table of compatible gamemode resource pointers.
<syntaxhighlight lang="lua">table getMaps ( )</syntaxhighlight>
Returns a table of all map resource pointers.
<syntaxhighlight lang="lua">table getMapsCompatibleWithGamemode ( [ resource theGamemode ] )</syntaxhighlight>
Returns a table of compatible map resource pointers. If the gamemode is left blank, it returns all maps which aren't compatible with any gamemode.
<syntaxhighlight lang="lua">resource getRunningGamemode ( )</syntaxhighlight>
Returns the currently running gamemode's resource pointer.
<syntaxhighlight lang="lua">resource getRunningGamemodeMap ( )</syntaxhighlight>
Returns the currently running GM map's resource pointer.
<syntaxhighlight lang="lua">bool isGamemode ( resource theGamemode )</syntaxhighlight>
Determines if a resource is a gamemode or not.
<syntaxhighlight lang="lua">bool isGamemodeCompatibleWithMap ( resource theGamemode, resource theMap )</syntaxhighlight>
Determines if a gamemode is compatible with a map or not.
<syntaxhighlight lang="lua">bool isMap ( resource theMap )</syntaxhighlight>
Determines if a resource is a map or not.
<syntaxhighlight lang="lua">bool isMapCompatibleWithGamemode ( resource theMap, resource theGamemode )</syntaxhighlight>
Determines if a map is compatible with a gamemode or not.
<syntaxhighlight lang="lua">bool stopGamemode ( )</syntaxhighlight>
Stops the current gamemode and its map.
<syntaxhighlight lang="lua">bool stopGamemodeMap ( )</syntaxhighlight>
Stop the current GM map.
Determines if a map is compatible with a gamemode or not.

==Fired events==
''(For all these events, "source" is the resource's root element.)''
<syntaxhighlight lang="lua">onGamemodeStart ( resource startedGamemode )</syntaxhighlight>
Fired before a gamemode starts.
<syntaxhighlight lang="lua">onGamemodeStop ( resource stoppedGamemode )</syntaxhighlight>
Fired before a gamemode is stopped.
<syntaxhighlight lang="lua">onGamemodeMapStart ( resource startedMap )</syntaxhighlight>
Fired before a GM map starts.
<syntaxhighlight lang="lua">onGamemodeMapStop ( resource stoppedMap )</syntaxhighlight>
Fired before a GM map is stopped.

==Supported map settings==
The following settings from the [[settings system|registry]] are applied by the map manager when a map is started:
<br>'''gamespeed''' [number]: The map's game speed.
<br>'''gravity''' [number]: The map's gravity.
<br>'''time''' [string of the form '''hh:mm''']: The map's time.
<br>'''weather''' [number]: The map's weather ID.
<br>'''waveheight''' [number]: The map's wave height.
<br>'''locked_time''' [boolean]: Whether the set time will be frozen by the manager or not.
<br>'''minplayers''' [number]: The required minimum number of players to start the map.
<br>'''maxplayers''' [number]: The allowed maximum number of players to start the map.

[[it:Map manager]]
[[ru:Resource:Mapmanager]]