HU/OOP Introduction: Difference between revisions

From Multi Theft Auto: Wiki
Jump to navigation Jump to search
No edit summary
(18 intermediate revisions by the same user not shown)
Line 4: Line 4:
__TOC__
__TOC__
== Bevezetés az OOP-ba ==
== Bevezetés az OOP-ba ==
Az OOP az az ''object orientated programming'' rövidítése, magyarul ''objektumorientált programozás''. Három egyszerű szó, de valószínűleg az utolsót fogja a legjobban érteni. OOP is where all functions relating to a single instance are called on that instance, an instance being a creation of a class - an element class, a database class, a player, a vehicle. Originally, everything was ''procedural'', you had to do things like:
Az OOP az az ''object orientated programming'' rövidítése. Három egyszerű szó, de valószínűleg az utolsót fogja a legjobban érteni. OOP-nak (Objektumorientált Programozásnak) nevezzük azt, amikor minden, egy objektumhoz köthető függvény az adott objektumon kerül meghívásra. Az objektum ez esetben egy osztály példánya - egy elem osztály, egy database osztály, egy játékos, egy jármű. Eredetileg minden ''procedurális'' volt, hasonlóan kellett megcsinálnia egyes scripteket:
<syntaxhighlight lang="lua">
<syntaxhighlight lang="lua">
local vehicle = createVehicle(411, 0, 0, 3)
local vehicle = createVehicle(411, 0, 0, 3)
Line 13: Line 13:
destroyElement(vehicle)
destroyElement(vehicle)
</syntaxhighlight>
</syntaxhighlight>
More often than not, you know what you're dealing with. The variable almost always links back to the type, you would name a vehicle that exploded as '''explodedVehicle''', or at-least in context you would understand that '''exploded''' implies a vehicle when in the '''onVehicleExplode''' event. So you have to write a long function ''and'' refer to the vehicle manually when working procedurally. Painful. Object orientated programming is very different to this and works with each "object" individually. Instead of having to call a function and referencing it inside the call, you actually call the function INSIDE the class.
A legtöbb esetben tudja, hogy mivel foglalkozik. A változó majdnem mindig a típushoz kapcsolódik, ezért a felrobbanó járművet ennek megfelelően nevezné el, például '''explodedVehicle''', vagy legalábbis a szövegkörnyezetben megértené, hogy az '''exploded''' magábafoglalja a járművet amikor az az '''onVehicleExplode''' event-ben van. Ezért egy hosszú függvényt kell írnia ''és'' manuálisan kell hivatkoznia a járműre amikor procedúrálisan dolgozik. Fájdalmasan. Az objektumorientált programozás nagyon különbözik ettől, és minden egyes "objektel" együtt dolgozik. Ahelyett, hogy hívnia kellene egy funkciót, és a híváson belül kellene rá hivatkoznia, valójában az osztályon BELÜLI funkciót hívja meg.


You probably think everything you can create and pass to functions are elements. A vehicle is an element. A player is an element. Anything that is an element is also a class. Connections create an instance of a class, but "'''connection'''" isn't an element, it's an instance - an object. Throughout the tutorial when I say ''object'', I don't mean [[createObject]] (unless I actually mention it, but to make things clearer I will avoid mentioning physical objects as I write this article. Here is a fancy venn diagram I created to show the simple organisation of classes and elements.
Valószínűleg azt gondolja, hogy mindent amit létre tud hozni és megadni a függvénynek az egy elem. A jármű az egy elem. A játékos is egy elem. Bármi, ami egy elem, az valójában egy osztály is. A játékosok csatlakozása létrehozza az osztály egy példányát, de a ''csatlakozás'' az nem egy elem, ez egy példány - egy objekt. A tutorial során, amikor az ''object''-ről beszélek, akkor nem a [[createObject]]-re gondolok (hacsak ezt meg nem említem), de a dolgok tisztán látása érdekében kerülni fogom a fizikai tárgyak megemlítését, amikor ezt a tutoriált írom. Itt egy menő venn diagram, amelyet az osztályok és az elemek egyszerű szervezésének bemutatására hoztam létre.
[[File:Classes,_Elements_and_Problem_children.png|500px|left|venn diagram]]
[[File:Classes,_Elements_and_Problem_children.png|500px|left|venn diagram]]
The functions on the left are sorted to show what kind of category the returned value rests in. We've got Classes, Elements and "Problem children".
A bal oldali funkciók rendezve vannak, hogy megmutassa milyen kategóriába tartozik a visszaadott érték. Van Classes, Elements és "Problem children".
Problem children aren't real categories written in the code, just functions that break rules. Everything you can play with are classes: resources, vehicles, and teams.
Problem children nem valódi kategóriák a kódban, hanem csak függvények, melyek szabályokat szüntetnek meg. Minden amivel játszhat azok osztályok: resources, vehicles, és teams.
All elements are classes, you can do: <syntaxhighlight lang="lua">destroyElement(ped)</syntaxhighlight> but you can't do: <syntaxhighlight lang="lua">destroyElement(resource)</syntaxhighlight>
Minden elem egy osztály. A helyes használat: <syntaxhighlight lang="lua">destroyElement(ped)</syntaxhighlight> ez így nem helyes: <syntaxhighlight lang="lua">destroyElement(resource)</syntaxhighlight>


Problem children are weird things. You can't do all the functions mentioned in (actually, all elements don't allow the full assortment of functions to be applied to them, but I've especially mentioned a few of them) in the "Element functions" section of the functions list, but you can do destroyElement() on them.
A Problem children azok furcsa dolgok. Nem használhatja az összes említett függvényt (valójában nem minden elem teszi lehetővé, hogy a függvények teljes választékát alkalmazzák rajtuk, de néhányat közülök megemlítettem) a funkciók listájának "Element functions" részében, de viszont destroyElement()-et használhat rajtuk.
There are children of classes, for example, with players, the system goes like: ''Element -> Ped -> Player". All Players are Peds and all Peds are Elements. Not all Peds are Players, and certainly not all Elements are Players. The main point here is that almost everything that you can create or retrieve and then reuse later use a class.
Vannak osztályok gyerekei, mint például a players, ami így néz ki: ''Element -> Ped -> Player''. Minden játékos Ped és minden Ped elem. Nem minden Ped játékos, és természetesen nem minden Elem játékos. A lényeg az, hogy szinte minden, amit létrehozhat vagy letölthet, hogy később újrahasználja őket, azok osztályokat használnak.


Instead of the code before, the code could be replaced with this:
Az előző kód helyett használhatjuk ez a kódot is:
<syntaxhighlight lang="lua">
<syntaxhighlight lang="lua">
local vehicle = createVehicle(411, 0, 0, 3)
local vehicle = createVehicle(411, 0, 0, 3)
Line 33: Line 33:
vehicle:destroy()
vehicle:destroy()
</syntaxhighlight>
</syntaxhighlight>
It works pretty similar to how a table works, it's just like customTable.setSomething() except the use of ''':''' makes Lua convert customTable:setSomething() convert to customTable.setSomething(customTable). This is pretty internal stuff about ''syntactic sugar'' and you don't really need to worry much about it.
Ez nagyon hasonlít a táblák működéséhez, ez olyan, mint a customTable.setSomething() kivéve a ''':''' használatát, a Lua konvertáló a customTable:setSomething()-et customTable.setSomething(customTable)-be konvertálja át. Ez egy elég bizalmas dolog a ''szintaktikus cukorról'', és nem kell egyáltalán aggódnia ezzel kapcsolatban.


Those functions are pretty useful, but there are more changes with OOP, I'll explain this below.
Ezek a funkciók elég hasznosak, de az OOP-nál több változtatás is van még, amit a következőkben fogok megmagyarázni.


== Instantiation, variables ==
== Szemléltetés, változók ==
OOP removes the need to say the "create" part of the function, so instead of saying '''createVehicle''', you just say '''Vehicle'''. It works exactly the same way, it's almost just like doing '''Vehicle = createVehicle'''. Fancy, isn't it? The only difference here is that you miss out on the extra things offered, Vehicle doesn't have these extra things, but Player definitely does. For example, instead of doing getPlayerFromName(), you would do Player.getFromName(). It's a nice and simple way to organise functions.
Az OOP elhagyja a "create" részét a függvénynek, így a '''createVehicle''' helyett csak a '''Vehicle'''-t használjuk. És ez pontosan ugyanúgy működik, ez olyan, mintha a '''Vehicle = createVehicle'''-t használnánk. Elég menő, nem igaz?? Az egyetlen különbség az, hogy kihagyja a kínált extra dolgokat, a Vehicle-nek nincsenek ezek az extra dolgai, de a Player-nek már igen. Például, a getPlayerFromName() helyett használhatja a Player.getFromName()-t. Ez egy könnyű és egyszerű módja a függvények szervezésének.
{{Tip|''Vehicle()'' works because it actually accesses the '''Vehicle.create''' function, this allows you to omit the '''.create''' when simply "creating an object"}}
{{Tip|A ''Vehicle()'' azért működik, mert ténylegesen hozzáfér a '''Vehicle.create''' függvényhez, ez lehetővé teszi, hogy elhagyja a '''.create'''-et, amikor "objekteket hoz létre"}}
Since OOP sits on top of procedural, many things have been inherited from the style of procedural, but to make things easier we have variables for all the functions that require a single input. We've shortened '''getElementDimension()''' down to '''element:getDimension()''', but we can also go one layer deeper: '''element.dimension'''. Yep, just like a variable. You can set this variable just like a normal variable and read from it just like a normal variable. Hey, you could even do this:
Mivel az OOP az eljárás tetején helyezkedik el, sok dolgot örököltek az eljárási stílusból, de a dolgok könnyebbé tételéhez változókat használunk az összes függvényhez, melyek egyetlen információt igényelnek. Lerövidítettük a '''getElementDimension()'''-t az '''element:getDimension()'''-re, de akár még mélyebbre is tudunk menni: '''element.dimension'''. Igen, akár csak egy változó. Megadhatja ezt a változót csak úgy, mint egy normális változót és olvashat is belőle, mint egy nomrális változóból. Héj, használhatja akár így is:
<syntaxhighlight lang="lua">local function incrementDimension()
<syntaxhighlight lang="lua">local function incrementDimension()
     local player = Player.getRandom() -- get a random player
     local player = Player.getRandom() -- get a random player
Line 47: Line 47:
setTimer(incrementDimension, 60*1000, 10) -- set a timer for sixty thousand milliseconds, sixty seconds, one minute
setTimer(incrementDimension, 60*1000, 10) -- set a timer for sixty thousand milliseconds, sixty seconds, one minute
</syntaxhighlight>
</syntaxhighlight>
This code would take a random player and move them to the next dimension every minute for the next ten minutes.
Ez a kód fog egy random játékost majd egy másik dimenzióba helyezi tíz percen keresztül minden egyes perc után.


== Vectors ==
== Vektorok ==
player.position works too! But how do you change three arguments... using one variable? Vectors.
A player.position is működik! De hogyan változtat meg három paramétert.. egy változó használatával? Vektorok.
Vectors are very powerful classes and they come in multiple forms, for the purpose of this introduction I'll just cover a three dimensional vector in terms of elements. Using a vector is very simple, and is, of course, optional. Wherever you can currently use positions, you can use a vector.
A vektorok nagyon erős osztályok és többféle formában vannak, ennek a bemutatónak a céljából három dimenziós vektort fogok bemutatni elemekben megadva. A vektorok használata nagyon egyszerű és persze tetszőleges. Bárhol, ahol pozíciókat használhat, ott használhat vektorokat is.


So, this is a simple example of creating a vehicle and moving it to the the centre of the map using vectors
Szóval ez egy egyszerű példája egy jármű létrehozásának és a map közepére helyezésének a vektorok használatával
<syntaxhighlight lang="lua">
<syntaxhighlight lang="lua">
-- First, create a three-dimensional vector
-- First, create a three-dimensional vector
Line 61: Line 61:
</syntaxhighlight>
</syntaxhighlight>


Yes, I used the negative sign. Vectors aren't just fancy ways for positions or 3d rotations or whatever, you can use maths on them. The ''special'' maths hasn't been documented yet, but I'll try and work on that. So, as you can see in line one, I created a 3D vector at ''300, -200, 2'' and then in line two I created the vehicle at that position.
Igen, mínuszjelet használtam. A vektorok nem csak különleges módszerek a pozíciókra vagy a 3D-s forgatásokra, vagy akármi másra, matematikai számításokat is használhatunk rajtuk. A ''special'' matematikai számítást még nem dokumentálták, de én azért megpróbálok dolgozni vele. Ahogy azt az első sorban is láthatja létrehoztam egy 3D-s vektort a ''300, -200, 2'' kordinátán, és a második sorban pedig létrehoztam egy járművet ennek a pozíciójára.


'''vehicle.position''' returned a vector and also takes a vector - it is pretty much setElementPosition() without the "()". Just a simple variable; so, in line three, I changed the vector value of the position of the vehicle. This is where the maths happened, in simple terms this is what is going on:
A '''vehicle.position''' visszaadott egy vektort majd fogott egy másik vektort - ez olyan, mint a setElementPosition() csak "()" nélkül. Mindegy egy egyszerű változó; így a harmadik sorban megváltoztattam a jármű pozíciójának a vektorértékét. És ez az ahol a számítás történt, itt láthatja, hogy hogyan működik:
<syntaxhighlight lang="lua">
<syntaxhighlight lang="lua">
x = 300 - 300
x = 300 - 300
Line 70: Line 70:
</syntaxhighlight>
</syntaxhighlight>


Vector maths is slightly complicated but it definitely allows for a wide variety of mathematical magic. Check out the useful links below related to Vectors and Matrices (Matrices = plural form of Matrix) to understand more about how this works.
A vektor matematika egy kicsit bonyolultabb, de határozottan lehetővé teszi a számítási műveletek széles skáláját. Tekintse meg a Vektorokat és Mátrixokat a lenti linkeken (Mátrixok = a Matrix több formája), hogy jobban megértse hogyan működnek.


== Understanding the documentation==
== Understanding the documentation==
Line 84: Line 84:
If you are a contributor to the wiki, please also consider reading [[Template:OOP|the OOP template]].
If you are a contributor to the wiki, please also consider reading [[Template:OOP|the OOP template]].


== Useful links ==
== Hasznos linkek ==
Other useful OOP related pages:
Egyéb hasznos OOP-vel kapcsolatos oldalak:
* [[OOP]]
* [[OOP]]
* [[Vector]]
* [[Vector]]
Line 95: Line 95:


[[en:OOP Introduction]]
[[en:OOP Introduction]]
==Fordította==
'''2018.12.03.''' <font size="3">'''[https://wiki.multitheftauto.com/wiki/User:Surge Surge]'''</font>

Revision as of 17:40, 4 December 2018

Megjegyzés: Ha a hozzájárulását adta az oldal szerkesztéséhez és módosításához, vagy segített ez a tutoriál, vagy csak mondani szeretne valamit; kérem írjon visszajelzést a bal oldalon található fórum linken.

Ez a szkript tutoriál elmagyarázza, hogy mi az az objektumorientált programozás, és megtanít arra, hogy hogyan kell használni az MTA OOP funkcióit. Ezt qaisjp hozta létre (talk) 22:48, 8 June 2014 (UTC). Forum post.

Bevezetés az OOP-ba

Az OOP az az object orientated programming rövidítése. Három egyszerű szó, de valószínűleg az utolsót fogja a legjobban érteni. OOP-nak (Objektumorientált Programozásnak) nevezzük azt, amikor minden, egy objektumhoz köthető függvény az adott objektumon kerül meghívásra. Az objektum ez esetben egy osztály példánya - egy elem osztály, egy database osztály, egy játékos, egy jármű. Eredetileg minden procedurális volt, hasonlóan kellett megcsinálnia egyes scripteket:

local vehicle = createVehicle(411, 0, 0, 3)
setVehicleDamageProof(vehicle, true)
setElementFrozen(vehicle, true)
setElementHealth(vehicle, 1000)
setElementVelocity(vehicle, 0.2, 0.2, 0.2)
destroyElement(vehicle)

A legtöbb esetben tudja, hogy mivel foglalkozik. A változó majdnem mindig a típushoz kapcsolódik, ezért a felrobbanó járművet ennek megfelelően nevezné el, például explodedVehicle, vagy legalábbis a szövegkörnyezetben megértené, hogy az exploded magábafoglalja a járművet amikor az az onVehicleExplode event-ben van. Ezért egy hosszú függvényt kell írnia és manuálisan kell hivatkoznia a járműre amikor procedúrálisan dolgozik. Fájdalmasan. Az objektumorientált programozás nagyon különbözik ettől, és minden egyes "objektel" együtt dolgozik. Ahelyett, hogy hívnia kellene egy funkciót, és a híváson belül kellene rá hivatkoznia, valójában az osztályon BELÜLI funkciót hívja meg.

Valószínűleg azt gondolja, hogy mindent amit létre tud hozni és megadni a függvénynek az egy elem. A jármű az egy elem. A játékos is egy elem. Bármi, ami egy elem, az valójában egy osztály is. A játékosok csatlakozása létrehozza az osztály egy példányát, de a csatlakozás az nem egy elem, ez egy példány - egy objekt. A tutorial során, amikor az object-ről beszélek, akkor nem a createObject-re gondolok (hacsak ezt meg nem említem), de a dolgok tisztán látása érdekében kerülni fogom a fizikai tárgyak megemlítését, amikor ezt a tutoriált írom. Itt egy menő venn diagram, amelyet az osztályok és az elemek egyszerű szervezésének bemutatására hoztam létre.

venn diagram

A bal oldali funkciók rendezve vannak, hogy megmutassa milyen kategóriába tartozik a visszaadott érték. Van Classes, Elements és "Problem children". Problem children nem valódi kategóriák a kódban, hanem csak függvények, melyek szabályokat szüntetnek meg. Minden amivel játszhat azok osztályok: resources, vehicles, és teams.

Minden elem egy osztály. A helyes használat:

destroyElement(ped)

ez így nem helyes:

destroyElement(resource)

A Problem children azok furcsa dolgok. Nem használhatja az összes említett függvényt (valójában nem minden elem teszi lehetővé, hogy a függvények teljes választékát alkalmazzák rajtuk, de néhányat közülök megemlítettem) a funkciók listájának "Element functions" részében, de viszont destroyElement()-et használhat rajtuk. Vannak osztályok gyerekei, mint például a players, ami így néz ki: Element -> Ped -> Player. Minden játékos Ped és minden Ped elem. Nem minden Ped játékos, és természetesen nem minden Elem játékos. A lényeg az, hogy szinte minden, amit létrehozhat vagy letölthet, hogy később újrahasználja őket, azok osztályokat használnak.

Az előző kód helyett használhatjuk ez a kódot is:

local vehicle = createVehicle(411, 0, 0, 3)
vehicle:setDamageProof(true)
vehicle:setFrozen(true)
vehicle:setHealth(1000)
vehicle:setVelocity(0.2, 0.2, 0.2)
vehicle:destroy()

Ez nagyon hasonlít a táblák működéséhez, ez olyan, mint a customTable.setSomething() kivéve a : használatát, a Lua konvertáló a customTable:setSomething()-et customTable.setSomething(customTable)-be konvertálja át. Ez egy elég bizalmas dolog a szintaktikus cukorról, és nem kell egyáltalán aggódnia ezzel kapcsolatban.

Ezek a funkciók elég hasznosak, de az OOP-nál több változtatás is van még, amit a következőkben fogok megmagyarázni.

Szemléltetés, változók

Az OOP elhagyja a "create" részét a függvénynek, így a createVehicle helyett csak a Vehicle-t használjuk. És ez pontosan ugyanúgy működik, ez olyan, mintha a Vehicle = createVehicle-t használnánk. Elég menő, nem igaz?? Az egyetlen különbség az, hogy kihagyja a kínált extra dolgokat, a Vehicle-nek nincsenek ezek az extra dolgai, de a Player-nek már igen. Például, a getPlayerFromName() helyett használhatja a Player.getFromName()-t. Ez egy könnyű és egyszerű módja a függvények szervezésének.

[[{{{image}}}|link=|]] Tip: A Vehicle() azért működik, mert ténylegesen hozzáfér a Vehicle.create függvényhez, ez lehetővé teszi, hogy elhagyja a .create-et, amikor "objekteket hoz létre"

Mivel az OOP az eljárás tetején helyezkedik el, sok dolgot örököltek az eljárási stílusból, de a dolgok könnyebbé tételéhez változókat használunk az összes függvényhez, melyek egyetlen információt igényelnek. Lerövidítettük a getElementDimension()-t az element:getDimension()-re, de akár még mélyebbre is tudunk menni: element.dimension. Igen, akár csak egy változó. Megadhatja ezt a változót csak úgy, mint egy normális változót és olvashat is belőle, mint egy nomrális változóból. Héj, használhatja akár így is:

local function incrementDimension()
    local player = Player.getRandom() -- get a random player
    player.dimension = player.dimension + 1 -- increment dimension
end
setTimer(incrementDimension, 60*1000, 10) -- set a timer for sixty thousand milliseconds, sixty seconds, one minute

Ez a kód fog egy random játékost majd egy másik dimenzióba helyezi tíz percen keresztül minden egyes perc után.

Vektorok

A player.position is működik! De hogyan változtat meg három paramétert.. egy változó használatával? Vektorok. A vektorok nagyon erős osztályok és többféle formában vannak, ennek a bemutatónak a céljából három dimenziós vektort fogok bemutatni elemekben megadva. A vektorok használata nagyon egyszerű és persze tetszőleges. Bárhol, ahol pozíciókat használhat, ott használhat vektorokat is.

Szóval ez egy egyszerű példája egy jármű létrehozásának és a map közepére helyezésének a vektorok használatával

-- First, create a three-dimensional vector
local position = Vector3(300, -200, 2) -- some place far away
local vehicle = Vehicle(411, position) -- create a vehicle at the position
vehicle.position = centreOfMap - Vector3(300, -200, 0) -- move the vehicle two units above the center of the map

Igen, mínuszjelet használtam. A vektorok nem csak különleges módszerek a pozíciókra vagy a 3D-s forgatásokra, vagy akármi másra, matematikai számításokat is használhatunk rajtuk. A special matematikai számítást még nem dokumentálták, de én azért megpróbálok dolgozni vele. Ahogy azt az első sorban is láthatja létrehoztam egy 3D-s vektort a 300, -200, 2 kordinátán, és a második sorban pedig létrehoztam egy járművet ennek a pozíciójára.

A vehicle.position visszaadott egy vektort majd fogott egy másik vektort - ez olyan, mint a setElementPosition() csak "()" nélkül. Mindegy egy egyszerű változó; így a harmadik sorban megváltoztattam a jármű pozíciójának a vektorértékét. És ez az ahol a számítás történt, itt láthatja, hogy hogyan működik:

x = 300 - 300
y = -200 - -200
z = 2 - 0

A vektor matematika egy kicsit bonyolultabb, de határozottan lehetővé teszi a számítási műveletek széles skáláját. Tekintse meg a Vektorokat és Mátrixokat a lenti linkeken (Mátrixok = a Matrix több formája), hogy jobban megértse hogyan működnek.

Understanding the documentation

The documentation for the OOP syntax intends to be very simplistic and is supported by the procedural syntax. To keep things simple, everything is consistently formatted in a certain way.

Click to collapse [-]
Example

OOP Syntax Help! I don't understand this!

Note: Set the variable to nil to execute removePedFromVehicle
Method: ped:warpIntoVehicle(...)
Variable: .vehicle
Counterpart: getPedOccupiedVehicle


  • Sometimes a note is added to the page. This will explain any special differences in the use of OOP for that function.
  • Methods can either start like player: or Player. - the former is only for a function on an instance (setPlayerHealth) and the latter is a static method (getRandomPlayer).
  • The counterpart section this allows you to see at a glance how the variable can be used. In most cases this can be inferred from the function page.

If you are a contributor to the wiki, please also consider reading the OOP template.

Hasznos linkek

Egyéb hasznos OOP-vel kapcsolatos oldalak:

Fordította

2018.12.03. Surge