इस पोस्ट में मैं इस बारे में बात करूंगा कि आप वीडियो गेम में क्रियाओं और कटकैसेन के अनुक्रम को कैसे लागू कर सकते हैं। यह लेख इस लेख का अनुवाद है और इसी विषय पर मैंने मॉस्को के लुआ में एक प्रस्तुति दी, इसलिए यदि आप वीडियो देखना पसंद करते हैं, तो आप इसे यहाँ देख सकते हैं ।

लेख कोड लुआ में लिखा गया है, लेकिन आसानी से अन्य भाषाओं में लिखा जा सकता है (विधि के अपवाद के साथ जो कोरटाइन का उपयोग करता है, क्योंकि वे सभी भाषाओं में नहीं हैं)।

लेख दिखाता है कि एक तंत्र कैसे बनाया जाए जो आपको निम्नलिखित फॉर्म के कटकनेसेस लिखने की अनुमति देता है:

local function cutscene(player, npc) player:goTo(npc) if player:hasCompleted(quest) then npc:say("You did it!") delay(0.5) npc:say("Thank you") else npc:say("Please help me") end end 

प्रविष्टि

एक्शन सीक्वेंस अक्सर वीडियो गेम में पाए जाते हैं। उदाहरण के लिए, cutscenes में: चरित्र दुश्मन से मिलता है, उसे कुछ कहता है, दुश्मन जवाब देता है, और इसी तरह। गेमप्ले में क्रियाओं का क्रम पाया जा सकता है। इस gif पर एक नज़र डालें:



1. दरवाजा खुलता है
2. चरित्र घर में प्रवेश करता है
3. दरवाजा बंद हो जाता है
4. स्क्रीन धीरे-धीरे गहराती है
5. स्तर बदलता है
6. स्क्रीन चमकीली फीकी पड़ जाती है
7. चरित्र कैफे में प्रवेश करता है

क्रियाओं के अनुक्रमों का उपयोग एनपीसी के व्यवहार को स्क्रिप्ट करने या बॉस की लड़ाइयों को लागू करने के लिए भी किया जा सकता है जिसमें बॉस कुछ क्रियाओं को एक दूसरे से करता है।

समस्या

एक मानक गेम लूप की संरचना एक्शन दृश्यों के कार्यान्वयन को कठिन बनाती है। मान लीजिए कि हमारे पास निम्नलिखित गेम लूप हैं:

 while game:isRunning() do processInput() dt = clock.delta() update(dt) render() end 

हम निम्नलिखित cutscene को लागू करना चाहते हैं: खिलाड़ी एनपीसी से संपर्क करता है, एनपीसी कहता है: "आपने यह किया!", और फिर एक छोटे से ठहराव के बाद कहता है: "धन्यवाद!"। एक आदर्श दुनिया में, हम इसे इस तरह से लिखेंगे:

 player:goTo(npc) npc:say("You did it!") delay(0.5) npc:say("Thank you") 

और यहाँ हम एक समस्या का सामना कर रहे हैं। चरणों को पूरा करने में कुछ समय लगता है। कुछ क्रियाएं खिलाड़ी से इनपुट का इंतजार भी कर सकती हैं (उदाहरण के लिए, डायलॉग बॉक्स को बंद करने के लिए)। delay फ़ंक्शन के बजाय, आप एक ही sleep को नहीं बुला सकते sleep - ऐसा लगेगा जैसे गेम जमी है।

आइए समस्या को हल करने के लिए कुछ दृष्टिकोणों पर एक नज़र डालें।

बूल, एनम, राज्य मशीनें

क्रियाओं के अनुक्रम को लागू करने का सबसे स्पष्ट तरीका है कि वर्तमान स्थिति के बारे में जानकारी को बूल, लाइनों या एनम में संग्रहीत करना। कोड कुछ इस तरह दिखेगा:

 function update(dt) if cutsceneState == 'playerGoingToNpc' then player:continueGoingTo(npc) if player:closeTo(npc) then cutsceneState = 'npcSayingYouDidIt' dialogueWindow:show("You did it!") end elseif cutsceneState == 'npcSayingYouDidIt' then if dialogueWindow:wasClosed() then cutsceneState = 'delay' end elseif ... ... --   ... end end 

यह दृष्टिकोण आसानी से स्पेगेटी कोड और इफ-इमोशन की लंबी श्रृंखलाओं की ओर जाता है, इसलिए मैं समस्या को हल करने के इस तरीके से बचने की सलाह देता हूं।

कार्रवाई की सूची

कार्रवाई सूची राज्य मशीनों के समान है। एक्शन लिस्ट एक के बाद एक की जाने वाली क्रियाओं की सूची है। गेम लूप में, update फ़ंक्शन को वर्तमान कार्रवाई के लिए कहा जाता है, जो हमें इनपुट को संसाधित करने और गेम को प्रस्तुत करने की अनुमति देता है, भले ही कार्रवाई में लंबा समय लगता हो। कार्रवाई पूरी होने के बाद, हम अगले पर जाते हैं।

कटकीन में जिसे हम लागू करना चाहते हैं, हमें निम्नलिखित कार्यों को लागू करने की आवश्यकता है: GoToAction, DialogueAction और DelayAction।

आगे के उदाहरणों के लिए, मैं Lua में OOP के लिए मिडिलक्लास लाइब्रेरी का उपयोग करूंगा।

यहां बताया गया है कि DelayAction कैसे लागू किया DelayAction है:

 --  function DelayAction:initialize(params) self.delay = params.delay self.currentTime = 0 self.isFinished = false end function DelayAction:update(dt) self.currentTime = self.currentTime + dt if self.currentTime > self.delay then self.isFinished = true end end 

ActionList:update फ़ंक्शन इस तरह दिखता है:

 function ActionList:update(dt) if not self.isFinished then self.currentAction:update(dt) if self.currentAction.isFinished then self:goToNextAction() if not self.currentAction then self.isFinished = true end end end end 

और अंत में, स्वयं cutscene का कार्यान्वयन:

 function makeCutsceneActionList(player, npc) return ActionList:new { GoToAction:new { entity = player, target = npc }, SayAction:new { entity = npc, text = "You did it!" }, DelayAction:new { delay = 0.5 }, SayAction:new { entity = npc, text = "Thank you" } } end -- ... -    actionList:update(dt) 

नोट : Lua में, someFunction({ ... }) कॉल इस तरह से किया जा सकता है: someFunction{...} । यह आपको DelayAction:new{ delay = 0.5 } लिखने की अनुमति देता है DelayAction:new{ delay = 0.5 } बजाय DelayAction:new{ delay = 0.5 } DelayAction:new({delay = 0.5}) ।

यह बहुत बेहतर लग रहा है। कोड स्पष्ट रूप से क्रियाओं का क्रम दिखाता है। यदि हम एक नई क्रिया जोड़ना चाहते हैं, तो हम आसानी से कर सकते हैं। DelayAction कक्षाएं बनाने में यह काफी सरल है कि DelayAction को और अधिक सुविधाजनक बनाया जा सके।

मैं आपको सलाह देता हूं कि आप एक्शन लिस्ट के बारे में सीन मिडिलडिच की प्रस्तुति देखें, जो अधिक जटिल उदाहरण प्रदान करता है।


कार्रवाई सूची आम तौर पर बहुत उपयोगी होती है। मैंने उन्हें काफी समय तक अपने खेल के लिए इस्तेमाल किया और कुल मिलाकर खुशी हुई। लेकिन इस दृष्टिकोण में कमियां भी हैं। मान लें कि हम कुछ अधिक जटिल कटकिन को लागू करना चाहते हैं:

 local function cutscene(player, npc) player:goTo(npc) if player:hasCompleted(quest) then npc:say("You did it!") delay(0.5) npc:say("Thank you") else npc:say("Please help me") end end 

एक / अन्य सिमुलेशन करने के लिए, आपको गैर-रेखीय सूचियों को लागू करने की आवश्यकता है। यह टैग का उपयोग करके किया जा सकता है। कुछ क्रियाओं को टैग किया जा सकता है, और फिर, कुछ शर्त के द्वारा, अगली क्रिया पर जाने के बजाय, आप एक ऐसे कार्य पर जा सकते हैं जिसमें वांछित टैग हो। यह काम करता है, हालांकि उपरोक्त फ़ंक्शन के रूप में पढ़ना और लिखना इतना आसान नहीं है।

Lua coroutines इस कोड को एक वास्तविकता बनाते हैं।

Korutiny

लुआ में कोरुआ मूल बातें

कोरुटिन एक फ़ंक्शन है जिसे रोका जा सकता है और फिर बाद में फिर से शुरू किया जा सकता है। मुख्य कार्यक्रम के रूप में एक ही धागे में कोरआउट को निष्पादित किया जाता है। कोरटाइन के लिए कोई नया धागा कभी नहीं बनाया जाता है।

coroutine.yield को रोकने के लिए, आपको coroutine.yield को कॉल करना होगा, फिर से शुरू करने के लिए - coroutine.resume । एक सरल उदाहरण:

 local function f() print("hello") coroutine.yield() print("world!") end local c = coroutine.create(f) coroutine.resume(c) print("uhh...") coroutine.resume(c) 

कार्यक्रम का आउटपुट:

 नमस्ते
 उह ...
 दुनिया

यहाँ यह कैसे काम करता है। सबसे पहले, हम coroutine.create का उपयोग करके coroutine.create बनाते हैं। इस कॉल के बाद, कॉरटिन शुरू नहीं होता है। ऐसा होने के लिए, हमें इसे coroutine.resume का उपयोग करके चलाने की आवश्यकता है। तब फ़ंक्शन f को कहा जाता है, जो "हेलो" लिखता है और कोरटाइन.फील्ड के साथ खुद को रोक देता है। यह return समान है, लेकिन हम coroutine.resume साथ f को फिर से शुरू कर सकते हैं।

यदि आप coroutine.yield कॉल करते समय तर्क पास करते हैं, तो वे "मुख्य धारा" में coroutine.resume संबंधित कॉल के रिटर्न मान बन जाएंगे।

उदाहरण के लिए:

 local function f() ... coroutine.yield(42, "some text") ... end ok, num, text = coroutine.resume(c) print(num, text) -- will print '42 "some text"' 

ok एक वैरिएबल है जो हमें कोरटाइन की स्थिति जानने की अनुमति देता है। यदि ok है, तो कोरटाइन के साथ सब कुछ ठीक है, अंदर कोई त्रुटि नहीं हुई है। इसके पीछे के मान ( num , text ) वही तर्क हैं जो हमने yield लिए पारित किए थे।

यदि ok false , तो कोरटाइन के साथ कुछ गलत हो गया था, उदाहरण के लिए, error फ़ंक्शन को इसके अंदर बुलाया गया था। इस स्थिति में, दूसरा रिटर्न मान एक त्रुटि संदेश होगा। कोरटाइन का एक उदाहरण जिसमें एक त्रुटि होती है:

 local function f() print(1 + notDefined) end c = coroutine.create(f) ok, msg = coroutine.resume(c) if not ok then print("Coroutine failed!", msg) end 

निष्कर्ष:

 Coroutine विफल!  इनपुट: 4: शून्य मान (वैश्विक 'नोटिफाइड') पर अंकगणित करने का प्रयास

Coroutine की स्थिति coroutine.status कॉल करके प्राप्त की जा सकती है। Corutin निम्नलिखित स्थितियों में हो सकता है:

• "रनिंग" - वर्तमान में कोर्उटिन चल रहा है। corutine.status को corutin से ही बुलाया गया था
• "निलंबित" - कोरुटिन को रोक दिया गया था या कभी भी शुरू नहीं किया गया था
• "सामान्य" - कोरुटिन सक्रिय है, लेकिन निष्पादित नहीं किया गया है। यानी, corutin ने अपने भीतर एक और corutin लॉन्च किया
• "मृत" - coroutine पूर्ण निष्पादन (यानी, coroutine पूरा हुआ)

अब, इस ज्ञान की मदद से, हम कोरआउट्स के आधार पर क्रियाओं और कटकैन के अनुक्रमों की एक प्रणाली को लागू कर सकते हैं।

Corutin का उपयोग करके cutscenes बनाना

यहां नई प्रणाली पर आधार Action क्लास जैसा दिखेगा:

 function Action:launch() self:init() while not self.finished do local dt = coroutine.yield() self:update(dt) end self:exit() end 

एक्शन सूचियों के लिए दृष्टिकोण समान है: कार्रवाई का update फ़ंक्शन तब तक कहा जाता है जब तक कि कार्रवाई पूरी नहीं हो जाती। लेकिन यहां हम कोरटाइन का उपयोग करते हैं और गेम लूप के प्रत्येक पुनरावृत्ति में yield करते हैं ( Action:launch को कुछ कोरआउट से कहा जाता है)। गेम लूप के update में कहीं न कहीं हम इस तरह से वर्तमान कटक का निष्पादन फिर से शुरू करते हैं:

 coroutine.resume(c, dt) 

और अंत में, एक cutscene बनाने:

 function cutscene(player, npc) player:goTo(npc) npc:say("You did it!") delay(0.5) npc:say("Thank you") end -- -  ... local c = coroutine.create(cutscene, player, npc) coroutine.resume(c, dt) 

यहां बताया गया है कि delay फ़ंक्शन कैसे लागू किया जाता है:

 function delay(time) action = DelayAction:new { delay = time } action:launch() end 

इस तरह के रैपर बनाने से कटकसीन कोड की पठनीयता में सुधार होता है। DelayAction इस तरह लागू किया DelayAction :

 -- Action -   DelayAction local DelayAction = class("DelayAction", Action) function DelayAction:initialize(params) self.delay = params.delay self.currentTime = 0 self.isFinished = false end function DelayAction:update(dt) self.currentTime = self.currentTime + dt if self.currentTime >= self.delayTime then self.finished = true end end 

यह कार्यान्वयन उसी के समान है जिसे हमने क्रिया सूचियों में उपयोग किया है! आइए Action:launch पर एक नज़र डालें Action:launch फ़ंक्शन फिर से:

 function Action:launch() self:init() while not self.finished do local dt = coroutine.yield() -- the most important part self:update(dt) end self:exit() end 

यहां मुख्य बात यह है कि while , जो कार्रवाई पूरी होने तक चलता है। यह कुछ इस तरह दिखता है:



आइए अब goTo फ़ंक्शन को देखें:

 function Entity:goTo(target) local action = GoToAction:new { entity = self, target = target } action:launch() end function GoToAction:initialize(params) ... end function GoToAction:update(dt) if not self.entity:closeTo(self.target) then ... --  , AI else self.finished = true end end 

Coroutines घटनाओं के साथ अच्छी तरह से चलती हैं। WaitForEventAction वर्ग को लागू करें:

 function WaitForEventAction:initialize(params) self.finished = false eventManager:subscribe { listener = self, eventType = params.eventType, callback = WaitForEventAction.onEvent } end function WaitForEventAction:onEvent(event) self.finished = true end 

इस फ़ंक्शन को update विधि की आवश्यकता नहीं है। यह तब तक निष्पादित किया जाएगा (हालांकि यह कुछ भी नहीं करता ...) जब तक कि यह आवश्यक प्रकार के साथ एक घटना प्राप्त नहीं करता है। यहाँ इस वर्ग का व्यावहारिक अनुप्रयोग है - say कार्य का कार्यान्वयन:

 function Entity:say(text) DialogueWindow:show(text) local action = WaitForEventAction:new { eventType = 'DialogueWindowClosed' } action:launch() end 

सरल और पठनीय। जब संवाद बॉक्स बंद हो जाता है, तो यह 'DialogueWindowClosed` प्रकार की एक घटना भेज देता है। कहने का कार्य समाप्त होता है और अगले एक को निष्पादित करना शुरू होता है।

Coroutine का उपयोग करके, आप आसानी से नॉनलाइनियर कटस्कैन और डायलॉग ट्री बना सकते हैं:

 local answer = girl:say('do_you_love_lua', { 'YES', 'NO' }) if answer == 'YES' then girl:setMood('happy') girl:say('happy_response') else girl:setMood('angry') girl:say('angry_response') end 

इस उदाहरण में, say फ़ंक्शन पहले की तुलना में थोड़ा अधिक जटिल है। यह संवाद में खिलाड़ी की पसंद को लौटाता है, हालांकि इसे लागू करना मुश्किल नहीं है। उदाहरण के लिए, WaitForEventAction को WaitForEventAction से उपयोग किया जा सकता है, जो PlayerChoiceEvent ईवेंट को पकड़ लेगा और फिर उस प्लेयर की पसंद को लौटाएगा जिसकी जानकारी ईवेंट ऑब्जेक्ट में शामिल होगी।

थोड़ा और अधिक जटिल उदाहरण

कोरटाइन के साथ, आप आसानी से ट्यूटोरियल और छोटे quests बना सकते हैं। उदाहरण के लिए:

 girl:say("Kill that monster!") waitForEvent('EnemyKilled') girl:setMood('happy') girl:say("You did it! Thank you!") 

एअर इंडिया के लिए कॉरआउट का भी इस्तेमाल किया जा सकता है। उदाहरण के लिए, आप एक फ़ंक्शन बना सकते हैं जिसके साथ राक्षस कुछ प्रक्षेपवक्र के साथ आगे बढ़ेगा:

 function followPath(monster, path) local numberOfPoints = path:getNumberOfPoints() local i = 0 --      while true do monster:goTo(path:getPoint(i)) if i < numberOfPoints - 1 then i = i + 1 --     else --   i = 0 end end end 

जब राक्षस खिलाड़ी को देखता है, तो हम बस कोरटाइन को पूरा करना बंद कर सकते हैं और इसे हटा सकते हैं। इसलिए, followPath भीतर एक अनंत लूप ( while true ) वास्तव में अनंत नहीं है।

कोरुटिन के साथ, आप "समानांतर" क्रियाएं कर सकते हैं। जब तक दोनों कार्रवाई पूरी नहीं हो जाती तब तक कटक अगली कार्रवाई के लिए आगे नहीं बढ़ेगा। उदाहरण के लिए, हम एक कटक बनायेंगे जहाँ एक लड़की और एक बिल्ली अलग-अलग गति से मित्र के बिंदु पर जाती है। उनके आने के बाद, बिल्ली कहती है "म्याऊ"।

 function cutscene(cat, girl, meetingPoint) local c1 = coroutine.create( function() cat:goTo(meetingPoint) end) local c2 = coroutine.create( function() girl:goTo(meetingPoint) end) c1.resume() c2.resume() --  waitForFinish(c1, c2) --    cat:say("meow") ... end 

यहां सबसे महत्वपूर्ण हिस्सा waitForFinish फंक्शन है, जो कि WaitForFinishAction क्लास के आसपास एक आवरण है, जिसे निम्नानुसार लागू किया जा सकता है:

 function WaitForFinishAction:update(dt) if coroutine.status(self.c1) == 'dead' and coroutine.status(self.c2) == 'dead' then self.finished = true else if coroutine.status(self.c1) ~= 'dead' then coroutine.resume(self.c1, dt) end if coroutine.status(self.c2) ~= 'dead' then coroutine.resume(self.c2, dt) end end 

यदि आप Nth नंबर की क्रियाओं को सिंक्रनाइज़ करने की अनुमति देते हैं, तो आप इस वर्ग को अधिक शक्तिशाली बना सकते हैं।

आप एक ऐसा वर्ग भी बना सकते हैं जो तब तक इंतजार करेगा जब तक कि सभी कोरूटाइन में से एक पूरा नहीं हो जाता है, बजाय इसके कि सभी कोराउटाइन के पूरा होने का इंतजार किया जाए। उदाहरण के लिए, इसका उपयोग मिनी-गेम रेसिंग में किया जा सकता है। कोरटाइन के अंदर एक सवार के फिनिश लाइन तक पहुंचने और फिर कुछ सीक्वेंस करने के लिए इंतजार करना होगा।

धनिया के फायदे और नुकसान

Coroutines एक बहुत ही उपयोगी तंत्र है। इनका उपयोग करके आप cutscenes और गेमप्ले कोड लिख सकते हैं जो पढ़ने और संशोधित करने में आसान है। इस तरह के Cutscenes को आसानी से मॉडर्स या उन लोगों द्वारा लिखा जा सकता है जो प्रोग्रामर नहीं हैं (उदाहरण के लिए, गेम या स्तर के डिजाइनर)।

और यह सब एक धागे में किया जाता है, इसलिए सिंक्रनाइज़ेशन या दौड़ की स्थिति में कोई समस्या नहीं है।

अप्रोच के नुकसान हैं। उदाहरण के लिए, बचत के साथ समस्याएं हो सकती हैं। मान लीजिए कि आपके गेम में कोरटाइन के साथ एक लंबा ट्यूटोरियल है। इस ट्यूटोरियल के दौरान खिलाड़ी सहेज नहीं पाएगा क्योंकि ऐसा करने के लिए, आपको कोरआउट की वर्तमान स्थिति (जिसमें इसकी पूरी स्टैक और अंदर वैरिएबल के मूल्य शामिल हैं) को सहेजने की आवश्यकता होगी, ताकि सेव से आगे लोड होने पर, आप ट्यूटोरियल जारी रख सकें।

( नोट : प्लूटोल्यूलेट्स लाइब्रेरी का उपयोग करते हुए, कोरटाइन को क्रमबद्ध किया जा सकता है, लेकिन लाइब्रेरी केवल लुआ 5.1 के साथ काम करती है)

यह समस्या कटकनेस के साथ नहीं होती है, जैसा कि आमतौर पर कटकीन के बीच के खेल की अनुमति नहीं है।

यदि आप इसे छोटे टुकड़ों में तोड़ते हैं, तो एक लंबे ट्यूटोरियल की समस्या हल हो सकती है। मान लीजिए कि एक खिलाड़ी ट्यूटोरियल के पहले भाग से गुजरता है और उसे ट्यूटोरियल जारी रखने के लिए दूसरे कमरे में जाना चाहिए। इस बिंदु पर, आप एक चौकी बना सकते हैं या खिलाड़ी को बचाने का अवसर दे सकते हैं। सहेजने में, हम कुछ ऐसा लिखेंगे जैसे "खिलाड़ी ने ट्यूटोरियल के भाग 1 को पूरा किया"। अगला, खिलाड़ी ट्यूटोरियल के दूसरे भाग से गुजरेगा, जिसके लिए हम पहले से ही एक और कॉरआउट का उपयोग करेंगे। और इसी तरह ... जब लोड हो रहा है, तो हम सिर्फ उस हिस्से के अनुरूप कॉरटीन को निष्पादित करना शुरू करते हैं जो खिलाड़ी को गुजरना होगा।

निष्कर्ष

जैसा कि आप देख सकते हैं, क्रियाओं और cutscenes के अनुक्रम को लागू करने के लिए कई अलग-अलग दृष्टिकोण हैं। यह मुझे लगता है कि कोरटाइन दृष्टिकोण बहुत शक्तिशाली है और मुझे डेवलपर्स के साथ साझा करने में खुशी हो रही है। मुझे उम्मीद है कि समस्या का यह समाधान आपके जीवन को आसान बना देगा और आपको अपने खेल में महाकाव्य कटकनेसेस बनाने की अनुमति देगा।