Tiniest2D के साथ 2D गेम बनाएं
इंजन एपीआई संदर्भ
Lesson 8 of 11 • 10 XP
Keep your place in this quest
Log in or sign up for free to subscribe, follow lesson progress, and access more learning content.
API संदर्भ
पूर्ण API संदर्भ
एडिटर के भीतर शॉर्ट फॉर्म में भी उपलब्ध है:

एसेट कन्स्ट्रक्टर्स
कन्स्ट्रक्टर्स मुख्य एसेट प्रकार बनाते हैं जो एडिटर द्वारा उपयोग किए जाते हैं। जब आप एक को किसी वेरिएबल में असाइन करते हैं, तो एडिटर इसे पहचानता है और आपको Ctrl+Click के साथ मेल खाने वाले एसेट एडिटर को खोलने की अनुमति देता है।
| फ़ंक्शन | विवरण |
|---|---|
Sprite(width, height) |
निर्दिष्ट आयामों के साथ एक Sprite एसेट बनाता है |
Scene() या Scene(name) |
एक Scene एसेट बनाता है |
Audio() |
एक छोटा ट्रैकर-शैली ऑडियो एसेट बनाता है |
Object() या Object(name) |
एक गेम ऑब्जेक्ट बनाता है |
लिस्ट मेथड
[] या [value1, value2, ...] के साथ सूचियाँ बनाएं। list[index] के साथ प्रविष्टियों को पढ़ें और ओवरराइट करें, और for (var i = 0; i < list.length(); i = i + 1) के साथ इटरेट करें।
| फ़ंक्शन | विवरण |
|---|---|
list.add(value) |
सूची के अंत में एक मान जोड़ता है |
list.length() |
सूची में तत्वों की संख्या लौटाता है |
list.remove(index) |
दिए गए इंडेक्स पर तत्व को हटा देता है |
list.clear() |
सूची से सभी तत्व हटा देता है |
ऑपरेटर
ऑपरेटर छोटे प्रतीक होते हैं जो सामान्य गणनाएँ करते हैं। मोड्युलो ऑपरेटर विशेष रूप से टाइमर, इंडेक्स, एनिमेशन स्टेप्स या दोहराने वाले पैटर्न को लपेटने के लिए उपयोगी है।
| ऑपरेटर | विवरण |
|---|---|
% |
मोड्युलो। विभाजन के बाद शेष लौटाता है |
ऑब्जेक्ट प्रॉपर्टीज़
ऑब्जेक्ट वे चीजें हैं जिन्हें आपका स्क्रिप्ट आमतौर पर गेम के दौरान हिलाता और बदलता है। ये फ़ंक्शन एक ऑब्जेक्ट की स्थिति, Sprite, टकराव व्यवहार, परत और दृश्य रंग को पढ़ते हैं या अपडेट करते हैं।
| फ़ंक्शन | विवरण |
|---|---|
getX(obj) |
ऑब्जेक्ट की X स्थिति लौटाता है |
setX(obj, x) |
ऑब्जेक्ट की X स्थिति सेट करता है |
getY(obj) |
ऑब्जेक्ट की Y स्थिति लौटाता है |
setY(obj, y) |
ऑब्जेक्ट की Y स्थिति सेट करता है |
getVelocityX(obj) |
ऑब्जेक्ट की X गति लौटाता है |
setVelocityX(obj, vx) |
ऑब्जेक्ट की X गति सेट करता है |
getVelocityY(obj) |
ऑब्जेक्ट की Y गति लौटाता है |
setVelocityY(obj, vy) |
ऑब्जेक्ट की Y गति सेट करता है |
getName(obj) |
ऑब्जेक्ट का नाम लौटाता है |
setName(obj, name) |
ऑब्जेक्ट का नाम सेट करता है |
getSprite(obj) |
ऑब्जेक्ट का Sprite लौटाता है |
setSprite(obj, sprite) |
ऑब्जेक्ट के लिए एक Sprite असाइन करता है (एनिमेशन को फ़्रेम 0 पर रीसेट करता है) |
getLayer(obj) |
ऑब्जेक्ट की ड्रॉइंग परत लौटाता है |
setLayer(obj, layer) |
ऑब्जेक्ट की ड्रॉइंग परत सेट करता है (उच्च = बाद में चित्रित) |
getTint(obj) |
रंग को [r, g, b, a] सूची के रूप में लौटाता है |
setTint(obj, r, g, b, a) |
ऑब्जेक्ट का रंग रंग सेट करता है (0-255 प्रत्येक) |
getCollisionType(obj) |
टकराव प्रकार संख्या लौटाता है |
setCollisionType(obj, type) |
टकराव प्रकार सेट करता है |
Sprite फ़ंक्शन
Sprite फ़ंक्शन कोड को Sprite पिक्सेल डेटा और एनिमेशन गति की जांच या संशोधित करने की अनुमति देते हैं। अधिकांश गेम एडिटर में Sprites को चित्रित करते हैं, लेकिन ये फ़ंक्शन प्रक्रियात्मक प्रभाव, डिबगिंग, या सरल रनटाइम परिवर्तनों के लिए उपयोगी हैं।
| फ़ंक्शन | विवरण |
|---|---|
fillSprite(sprite, r, g, b, a) |
सभी फ़्रेम के सभी पिक्सेल को एक ठोस RGBA रंग (0-255) से भरता है |
getPixel(sprite, frame, x, y) |
दिए गए फ़्रेम में (x,y) पर पिक्सल का [r,g,b,a] लौटाता है, या यदि सीमा से बाहर है, तो null |
setPixel(sprite, frame, x, y, r, g, b, a) |
दिए गए फ़्रेम में (x,y) पर पिक्सल रंग सेट करता है। यदि सीमा से बाहर है तो कुछ नहीं करता |
getAnimationFPS(sprite) |
Sprite की एनिमेशन गति को फ़्रेम प्रति सेकंड में लौटाता है |
setAnimationFPS(sprite, fps) |
Sprite की एनिमेशन गति को फ़्रेम प्रति सेकंड में सेट करता है |
एनीमेशन फ़ंक्शन
एनीमेशन फ़ंक्शन उन ऑब्जेक्ट पर काम करते हैं जो कई फ़्रेमों के साथ Sprites का उपयोग करते हैं। जब आप कोड को वर्तमान एनीमेशन फ़्रेम की जांच या बल देना चाहते हैं, तो उनका उपयोग करें।
| फ़ंक्शन | विवरण |
|---|---|
getFrame(obj) |
ऑब्जेक्ट का वर्तमान एनीमेशन फ़्रेम इंडेक्स लौटाता है |
setFrame(obj, frameIndex) |
ऑब्जेक्ट के एनीमेशन फ़्रेम को सेट करता है (टाइमर को रीसेट करता है) |
getFrameCount(obj) |
ऑब्जेक्ट के Sprite में फ़्रेमों की संख्या लौटाता है |
ट्रांसफॉर्म फ़ंक्शन (फ्लिप/रोटेशन)
ट्रांसफॉर्म फ़ंक्शन एक ऑब्जेक्ट के Sprite को बिना संपादित किए चित्रित करने का तरीका बदलते हैं। ये एक ही Sprite का कई दिशाओं में उपयोग करने के लिए अच्छे हैं।
| फ़ंक्शन | विवरण |
|---|---|
getFlipX(obj) |
लौटाता है कि ऑब्जेक्ट क्षैतिज रूप से फ्लिप किया गया है या नहीं |
setFlipX(obj, flip) |
क्षैतिज फ्लिप सेट करता है। true = फ्लिप किया गया, false = सामान्य |
getFlipY(obj) |
लौटाता है कि ऑब्जेक्ट ऊर्ध्वाधर रूप से फ्लिप किया गया है या नहीं |
setFlipY(obj, flip) |
ऊर्ध्वाधर फ्लिप सेट करता है। true = फ्लिप किया गया, false = सामान्य |
getRotation(obj) |
ऑब्जेक्ट का 90-डिग्री घूर्णन लौटाता है (0-3) |
setRotation(obj, rot) |
90-डिग्री घूर्णन सेट करता है: 0=0, 1=90, 2=180, 3=270 डिग्री CW |
नोट: ये ट्रांसफॉर्म रेंडर समय पर लागू होते हैं केवल। ये टकराव बॉक्स या वास्तविक स्प्राइट पिक्सेल डेटा को प्रभावित नहीं करते हैं।
टकराव प्रकार
टकराव प्रकार तय करता है कि एक ऑब्जेक्ट टकराव जांचों में कैसे भाग लेता है। ऑब्जेक्ट की भूमिका के आधार पर प्रकार चुनें: दीवारों को आमतौर पर स्थिर माना जाता है, खिलाड़ियों को आमतौर पर गतिशील और पिकअप को अक्सर ट्रिगर होते हैं।
| स्थायी | मान | विवरण |
|---|---|---|
COLLISION_NONE() |
0 | कोई टकराव पहचान नहीं |
COLLISION_STATIC() |
1 | टकराता है लेकिन नहीं चलता |
COLLISION_DYNAMIC() |
2 | टकराता है और धकेलता है |
COLLISION_TRIGGER() |
3 | टकराव की पहचान करता है लेकिन ब्लॉक नहीं करता |
सीन फ़ंक्शन
सीन फ़ंक्शन सक्रिय दृश्य को नियंत्रित करते हैं, इसके भीतर कौन से ऑब्जेक्ट हैं, और दृश्य-व्यापी सेटिंग जैसे बैकग्राउंड रंग और गुरुत्वाकर्षण। वे स्थानों पर या नाम द्वारा ऑब्जेक्ट्स को खोजने के लिए खोज सहायक भी प्रदान करते हैं।
| फ़ंक्शन | विवरण |
|---|---|
addObject(scene, obj) |
दृश्य में एक ऑब्जेक्ट जोड़ता है |
removeObject(scene, obj) |
दृश्य से एक ऑब्जेक्ट हटाता है |
setScene(scene) |
सक्रिय दृश्य सेट करता है |
getScene() |
वर्तमान सक्रिय दृश्य लौटाता है |
resetScene(scene) |
दृश्य को इसके प्रारंभिक राज्य में रीसेट करता है (जैसा कि एडिटर में डिज़ाइन किया गया है) |
setBackgroundColor(scene, r, g, b) |
दृश्य का बैकग्राउंड रंग सेट करता है (RGB 0-255) |
getBackgroundColor(scene) |
बैकग्राउंड रंग को [r, g, b] सूची के रूप में लौटाता है |
getGravityX(scene) |
दृश्य गुरुत्वाकर्षण X घटक लौटाता है |
setGravityX(scene, gx) |
दृश्य गुरुत्वाकर्षण X घटक सेट करता है |
getGravityY(scene) |
दृश्य गुरुत्वाकर्षण Y घटक लौटाता है |
setGravityY(scene, gy) |
दृश्य गुरुत्वाकर्षण Y घटक सेट करता है (सकारात्मक = नीचे) |
getObjectAt(scene, x, y) |
बिंदु (x,y) पर पहला ऑब्जेक्ट लौटाता है, या null |
getObjectsAt(scene, x, y) |
बिंदु (x,y) पर सभी ऑब्जेक्ट्स की सूची लौटाता है |
getObjectsInBox(scene, x, y, w, h) |
ओवरलैपिंग बॉक्स वाले सभी ऑब्जेक्ट्स लौटाता है |
getObjectByName(scene, name) |
नाम द्वारा ऑब्जेक्ट खोजता है, या null यदि नहीं मिला |
getObjectCount(scene) |
दृश्य में ऑब्जेक्ट्स की संख्या लौटाता है |
getAllObjects(scene) |
दृश्य में सभी ऑब्जेक्ट्स की सूची लौटाता है |
isObjectInScene(scene, obj) |
यदि ऑब्जेक्ट दृश्य में है तो true लौटाता है |
getObjectsBySprite(scene, sprite) |
दिए गए Sprite का उपयोग करने वाले सभी ऑब्जेक्ट्स लौटाता है |
getObjectsByCollisionType(scene, type) |
दिए गए टकराव प्रकार वाले सभी ऑब्जेक्ट्स लौटाता है |
ऑडियो प्लेबैक
ऑडियो प्लेबैक फ़ंक्शन स्क्रिप्ट से ऑडियो एसेट शुरू और बंद करते हैं। playAudio() एक हैंडल लौटाता है ताकि आप बाद में उस विशिष्ट प्लेबैक उदाहरण को रोक या जांच सकें।
| फ़ंक्शन | विवरण |
|---|---|
playAudio(audio) |
एक ऑडियो एसेट शुरू करता है और एक प्लेबैक हैंडल आईडी लौटाता है |
stopAudio(handle) |
playAudio() द्वारा लौटाए गए प्लेबैक हैंडल को रोकता है |
isAudioPlaying(handle) |
जबकि प्लेबैक हैंडल अभी भी सक्रिय है, true लौटाता है |
स्क्रीन फ़ंक्शन
स्क्रीन फ़ंक्शन मदद करते हैं जब आपको विंडो आकार जानने या स्क्रीन पिक्सेल और दुनिया की स्थितियों के बीच रूपांतरण करने की आवश्यकता होती है। यह माउस लक्ष्यीकरण, क्लिक पहचान, और कैमरा-सचेत UI के लिए उपयोगी है।
| फ़ंक्शन | विवरण |
|---|---|
getScreenWidth() |
स्क्रीन/विंडो की चौड़ाई पिक्सेल में लौटाता है |
getScreenHeight() |
स्क्रीन/विंडो की ऊँचाई पिक्सेल में लौटाता है |
screenToWorld(screenX, screenY) |
स्क्रीन पिक्सेल समन्वय को विश्व समन्वय में परिवर्तित करता है। [worldX, worldY] लौटाता है |
worldToScreen(worldX, worldY) |
विश्व समन्वय को स्क्रीन पिक्सेल समन्वय में परिवर्तित करता है। [screenX, screenY] लौटाता है |
विंडो मोड
निकल किए गए गेम के लिए विंडो मोड को नियंत्रित करें। ये फ़ंक्शन एडिटर में खेलने पर कोई प्रभाव नहीं रखते हैं (एडिटर विंडो स्थिति पर अधिक अधिकार रखता है)।
| स्थायी | मान | विवरण |
|---|---|---|
WINDOW_WINDOWED() |
0 | नियमित विंडो मोड |
WINDOW_MAXIMIZED() |
1 | अधिकतम विंडो (डिफ़ॉल्ट) |
WINDOW_FULLSCREEN() |
2 | बॉर्डरलेस फुल स्क्रीन |
| फ़ंक्शन | विवरण |
|---|---|
getWindowMode() |
वर्तमान विंडो मोड स्थायी लौटाता है |
setWindowMode(mode) |
विंडो मोड सेट करता है। केवल निकल किए गए गेम में कार्य करता है |
उदाहरण:
func start() {
// विंडो मोड सेट करता है (WINDOW_MAXIMIZED निकल किए गए गेम के लिए डिफ़ॉल्ट है)
setWindowMode(WINDOW_MAXIMIZED())
}
नोट: यदि निकल किए गए गेम में setWindowMode() कभी नहीं बुलाया जाता है, तो डिफ़ॉल्ट WINDOW_MAXIMIZED है।
UI फ़ंक्शन
UI एक आभासी स्क्रीन-स्थान समाधान का उपयोग करता है। डिफ़ॉल्ट UI स्थान 100 x 100 है।
आगे के पाठ हेतु फ़ॉन्ट आकार बढ़ाने के लिए uiPushFontSize(size) का उपयोग किया जा सकता है और इसे uiPopFontSize() के साथ पुनर्स्थापित किया जा सकता है। फ़ॉन्ट रंगों को uiPushFontColor(r, g, b[, a]) के साथ स्टैक किया जा सकता है, और UI तत्व भरने को uiPushElementColor(r, g, b[, a]) के साथ स्टैक किया जा सकता है। बाकी तात्कालिक-मोड UI की तरह, ये ओवरराइड्स वर्तमान फ़्रेम की UI बनाते समय लागू होते हैं। यदि pushed आकार 0 या कम है, तो इंजन स्वचालित आकार का उपयोग करता है।
| फ़ंक्शन | विवरण |
|---|---|
getUIResolutionX() |
वर्तमान वर्चुअल UI चौड़ाई लौटाता है |
setUIResolutionX(width) |
अगले UI कॉल्स के लिए उपयोग की जाने वाली वर्चुअल UI चौड़ाई सेट करता है |
getUIResolutionY() |
वर्तमान वर्चुअल UI ऊंचाई लौटाता है |
setUIResolutionY(height) |
अगले UI कॉल्स के लिए उपयोग की जाने वाली वर्चुअल UI ऊंचाई सेट करता है |
uiPushFontSize(size) |
आगामी UI टेक्स्ट के लिए फ़ॉन्ट आकार स्केल पुश करता है। मान <= 0 स्वचालित आकार का उपयोग करते हैं |
uiPopFontSize() |
सबसे हाल के UI फ़ॉन्ट आकार को पुश करता है |
uiPushFontColor(r, g, b) या uiPushFontColor(r, g, b, a) |
आगामी UI टेक्स्ट के लिए फ़ॉन्ट रंग ओवरराइड पुश करता है |
uiPopFontColor() |
सबसे हाल के UI फ़ॉन्ट रंग ओवरराइड को पुश करता है |
uiPushElementColor(r, g, b) या uiPushElementColor(r, g, b, a) |
बक्सों, बटन, टॉगल, सलाइडर्स और इमेज बटन के लिए भरने के रंग का ओवरराइड पुश करता है |
uiPopElementColor() |
सबसे हाल के UI तत्व रंग ओवरराइड को पुश करता है |
uiLabel(text, x, y) |
वर्चुअल UI समन्वय में स्क्रीन-स्पेस टेक्स्ट बनाता है |
uiBox(x, y, w, h) |
एक सरल पैनल बॉक्स बनाता है |
uiButton(text, x, y, w, h) |
एक बटन बनाता है और UI_*() स्थिति स्थिरांक में से एक लौटाता है |
uiToggle(text, value, x, y, w, h) |
एक टॉगल बनाता है और अपडेट की गई बूलियन मान लौटाता है |
uiSlider(text, value, min, max, x, y, w, h) |
एक सलाइडर बनाता है और अपडेट की गई न्यूमेरिक मान लौटाता है |
uiSprite(sprite, x, y) |
UI स्पेस में स्प्राइट को उसके प्राकृतिक आकार में बनाता है |
uiSprite(sprite, x, y, w, h) |
UI स्पेस में एक स्पष्ट आकार में स्प्राइट बनाता है |
uiImageButton(sprite, x, y, w, h) |
एक स्प्राइट बटन बनाता है और UI_*() स्थिति स्थिरांक में से एक लौटाता है |
UI स्थिति स्थिरांक
UI कार्य स्थिति स्थिरांक लौटाते हैं ताकि आपका स्क्रिप्ट यह बता सके कि कोई विजेट Idle, Hovered, Held, या Clicked है। सामान्यतः UI_CLICKED() वह मान है जिसे आप बटन क्रियाओं के लिए चेक करते हैं।
| स्थिरांक | मान | विवरण |
|---|---|---|
UI_IDLE() |
0 | विजेट न तो होवर किया गया है और न ही दबाया गया है |
UI_HOVERED() |
1 | माउस विजेट पर होवर कर रहा है |
UI_HELD() |
2 | माउस बटन विजेट पर दबा हुआ है |
UI_CLICKED() |
3 | इस फ्रेम में विजेट पर क्लिक किया गया था |
कैमरा कार्य
कैमरा स्थिति दृश्य का केंद्र दर्शाता है। ज़ूम स्क्रीन के आकार के बावजूद लगातार लंबवत विश्व दृश्य बनाए रखता है।
| फ़ंक्शन | विवरण |
|---|---|
getCameraX(scene) |
कैमरा X स्थिति लौटाता है (दृश्य का केंद्र) |
setCameraX(scene, x) |
कैमरा X स्थिति सेट करता है |
getCameraY(scene) |
कैमरा Y स्थिति लौटाता है (दृश्य का केंद्र) |
setCameraY(scene, y) |
कैमरा Y स्थिति सेट करता है |
getCameraZoom(scene) |
कैमरा ज़ूम स्तर लौटाता है |
setCameraZoom(scene, zoom) |
कैमरा ज़ूम सेट करता है। ज़ूम 1.0 720 विश्व इकाइयों को लंबवत दिखाता है, 3.0 240 इकाइयाँ दिखाता है। |
ज़ूम व्यवहार: ज़ूम विंडो के आकार या पहलू अनुपात के बावजूद लगातार लंबवत विश्व दृश्य बनाए रखता है। चौड़े स्क्रीन अधिक क्षैतिज दिखाते हैं लेकिन लंबवत एक समान मात्रा।
इनपुट कार्य
इनपुट कार्य गेम को कीबोर्ड और माउस स्थिति पर प्रतिक्रिया करने देते हैं। एक-फ्रेम क्रियाओं के लिए Pressed का उपयोग करें, निरंतर गति के लिए Held का उपयोग करें, और उन क्रियाओं के लिए जो तब होती हैं जब एक बटन छोड़ा जाता है Released का उपयोग करें।
| फ़ंक्शन | विवरण |
|---|---|
isKeyPressed(key) |
केवल उसी फ्रेम पर सत्य है जब बटन दबाया गया हो |
isKeyHeld(key) |
जितना बटन दबाया गया है उतना ही सत्य है |
isKeyReleased(key) |
केवल उस फ्रेम पर सत्य है जब बटन छोड़ा गया हो |
getMouseX() |
स्क्रीन समन्वय में माउस X लौटाता है |
getMouseY() |
स्क्रीन समन्वय में माउस Y लौटाता है |
getMouseDeltaX() |
इस फ्रेम में माउस X गति लौटाता है |
getMouseDeltaY() |
इस फ्रेम में माउस Y गति लौटाता है |
isMouseButtonPressed(button) |
केवल उस फ्रेम पर सत्य है जब माउस बटन दबाया गया हो |
isMouseButtonHeld(button) |
जितना माउस बटन दबाया गया है उतना ही सत्य है |
isMouseButtonReleased(button) |
केवल उस फ्रेम पर सत्य है जब माउस बटन छोड़ा गया हो |
getFPS() |
वर्तमान फ्रेम प्रति सेकंड लौटाता है |
माउस बटन स्थिरांक
माउस बटन स्थिरांक माउस इनपुट कार्यों में पास किए जाते हैं। ये कच्चे संख्याओं की तुलना में कोड को पढ़ने में आसान बनाते हैं।
| स्थिरांक | विवरण |
|---|---|
MOUSE_LEFT() |
बाईं माउस बटन |
MOUSE_RIGHT() |
दाईं माउस बटन |
MOUSE_MIDDLE() |
मध्य माउस बटन |
कुंजी स्थिरांक
कुंजी स्थिरांक कीबोर्ड इनपुट कार्यों में पास किए जाते हैं। इंजन अक्षरों, संख्याओं, फ़ंक्शन कुंजियों, तीरों, और कुछ सामान्य विशेष कुंजियों का उपयोग करता है।
अक्षर: KEY_A() से लेकर KEY_Z()
संख्याएँ: KEY_0() से लेकर KEY_9()
फंक्शन कुंजियाँ: KEY_F1() से लेकर KEY_F12()
विशेष कुंजियाँ:
| स्थिरांक | कुंजी |
|----------|-----|
| KEY_SPACE() | स्पेसबार |
| KEY_ENTER() | एंटर/रिटर्न |
| KEY_ESCAPE() | एस्केप |
| KEY_TAB() | टैब |
| KEY_BACKSPACE() | बैकस्पेस |
| KEY_DELETE() | डिलीट |
| KEY_SHIFT() | शिफ्ट |
| KEY_CTRL() | नियंत्रण |
| KEY_ALT() | आल्ट |
| KEY_LEFT() | बाईं तीर |
| KEY_RIGHT() | दाईं तीर |
| KEY_UP() | ऊपर तीर |
| KEY_DOWN() | नीचे तीर |
| KEY_HOME() | होम |
| KEY_END() | एंड |
गणित कार्य
गणित हेल्पर सामान्य गणनाओं को कवर करता है जो गति, एनीमेशन, यादृच्छता, और मान सीमाओं में प्रयोग होते हैं। ये स्क्रिप्ट को छोटा और पढ़ने में आसान रखते हैं।
| फ़ंक्शन | विवरण |
|---|---|
abs(n) |
अवशिष्ट मान |
min(a, b) |
दो संख्याओं में से छोटी लौटाता है |
max(a, b) |
दो संख्याओं में से बड़ी लौटाता है |
clamp(value, min, max) |
एक मान को कम से कम और अधिकतम के बीच सीमित करता है |
lerp(a, b, t) |
a से b तक t का उपयोग करके रेखीय अंतराल करता है |
floor(n) |
निकटतम पूर्णांक के लिए नीचे गोल करता है |
ceil(n) |
निकटतम पूर्णांक के लिए ऊपर गोल करता है |
round(n) |
निकटतम पूर्णांक के लिए गोल करता है |
sign(n) |
इनपुट के संकेत के आधार पर -1, 0, या 1 लौटाता है |
sqrt(n) |
वर्गमूल |
pow(base, exponent) |
एक आधार को एक घटक के लिए बढ़ाता है |
sin(radians) |
एक कोण के लिए साइन रैडियन में |
cos(radians) |
एक कोण के लिए कोसाइन रैडियन में |
tan(radians) |
एक कोण के लिए टैन्जेंट रैडियन में |
random() |
0.0 और 1.0 के बीच एक यादृच्छिक फ्लोट लौटाता है |
randomRange(min, max) |
न्यूनतम और अधिकतम के बीच एक यादृच्छिक फ्लोट लौटाता है |
randomInt(min, max) |
न्यूनतम और अधिकतम (शामिल) के बीच एक यादृच्छिक पूर्णांक लौटाता है |
PI() |
π (3.14159...) लौटाता है |
TAU() |
τ (2 * π = 6.28318...) लौटाता है |
TWOPI() |
2 * π लौटाता है (जो TAU के समान है) |
E() |
यूरोپا संख्या e (2.71828...) लौटाता है |
deg2rad(degrees) |
डिग्री को रैडियन में परिवर्तित करता है |
rad2deg(radians) |
रैडियन को डिग्री में परिवर्तित करता है |
उपयोगिता कार्य
उपयोगिता कार्य सामान्य हेल्पर्स हैं जो किसी विशिष्ट संपत्ति प्रकार से संबंधित नहीं हैं। print() विशेष रूप से सीखने के दौरान उपयोगी है क्योंकि यह दिखाता है कि आपका स्क्रिप्ट क्या कर रहा है।
| फ़ंक्शन | विवरण |
|---|---|
print(value) |
डिबग आउटपुट में प्रिंट करता है (गेम में दिखाया गया) |
quitGame() |
खेल छोड़ता है। संपादक में, खेल मोड को रोकता है। निर्यात किए गए खेलों में, अनुप्रयोग को बंद करता है |
स्ट्रिंग कार्य
स्ट्रिंग कार्य टेक्स्ट मानों के साथ काम करते हैं। इस समय, यह अनुभाग जान intentionally छोटा है।
| फ़ंक्शन | विवरण |
|---|---|
strlen(string) |
एक स्ट्रिंग की लंबाई लौटाता है (अक्षरों की संख्या) |
संग्रह कार्य
फाइलों में खेल डेटा को सहेजें और लोड करें। संख्याओं, स्ट्रिंग्स, बूलियन्स और सूचियों (जिसमें अंतर्निहित सूचियाँ शामिल हैं) का समर्थन करता है। स्प्राइट, दृश्य, वस्तु, या ऑडियो मानों का समर्थन नहीं करता है।
| फ़ंक्शन | विवरण |
|---|---|
save(path, data) |
बाइनरी प्रारूप में एक फाइल में डेटा सहेजता है। सफलता पर true लौटाता है |
save(path, data, format) |
निर्दिष्ट प्रारूप में डेटा सहेजता है: "binary" या "text" |
save(path, data, format, key) |
प्रदत्त कुंजी स्ट्रिंग का उपयोग करके एन्क्रिप्शन के साथ डेटा सहेजता है |
load(path) |
एक फाइल से डेटा लोड करता है। विफलता पर null लौटाता है |
load(path, key) |
प्रदत्त कुंजी स्ट्रिंग का उपयोग करके एन्क्रिप्टेड डेटा लोड करता है |
fileExists(path) |
यदि फाइल दी गई पथ पर मौजूद है तो true लौटाता है |
deleteFile(path) |
दी गई पथ पर फाइल को हटाता है। सफलता पर true लौटाता है |
getAppDataPath() |
AppData/Tiniest2D फ़ोल्डर पथ लौटाता है (यदि आवश्यकता हो तो बनाता है) |
getDocumentsPath() |
उपयोगकर्ता के दस्तावेज फ़ोल्डर पथ लौटाता है |
getGamePath() |
उस निर्देशिका को लौटाता है जहां खेल निष्पादन किया जाता है |
उदाहरण: खिलाड़ी की प्रगति को सहेजना और लोड करना
// खिलाड़ी डेटा सहेजें
var playerData = [100, "Player1", true, [1, 2, 3]]
var savePath = getAppDataPath() + "/MyGame/save.dat"
if (save(savePath, playerData)) {
print("खेल सहेजा गया!")
}
// खिलाड़ी डेटा लोड करें
if (fileExists(savePath)) {
var loaded = load(savePath)
if (loaded != null) {
var health = loaded[0]
var name = loaded[1]
var hasKey = loaded[2]
var inventory = loaded[3]
}
}
// एन्क्रिप्टेड सहेजना (सामान्य निरीक्षण से डेटा छिपाने के लिए)
var secretData = ["secret", 12345]
save(getAppDataPath() + "/MyGame/config.dat", secretData, "binary", "mySecretKey")
var decrypted = load(getAppDataPath() + "/MyGame/config.dat", "mySecretKey")
// टेक्स्ट प्रारूप (मानव-पढ़ने योग्य, डिबगिंग के लिए उपयोगी)
save(getAppDataPath() + "/MyGame/debug.txt", playerData, "text")
नोट्स:
- बाइनरी प्रारूप (डिफ़ॉल्ट) संकुचित और तेजी है
- टेक्स्ट प्रारूप मानव-पढ़ने योग्य है, डिबगिंग के लिए उपयोगी
- गलत एन्क्रिप्शन कुंजी
nullलौटाती है (डेटा खराब हो जाएगा) - सहेजने पर निर्देशिकाएँ स्वचालित रूप से बनाई जाती हैं