गायब होने के करीब आते ही मैं कैसे कुछ बनाता हूं जो मैं फ्लैश / ब्लिंक करता हूं?

Question

मेरे खेल में जब आप किसी दुश्मन को मारते हैं तो वे हेल्थ पैक या सोने की तरह गिर सकते हैं। मैं चाहता हूं कि यह समय सीमा हो ताकि अगर आप इसे नहीं उठाते हैं तो यह अंततः गायब हो जाता है। मैं चाहता हूं कि आइटम अधिक बार फ्लैश हो जाए और ड्रॉप "मौत" के करीब पहुंच जाए। आप "अधिक बार चमकती" एल्गोरिदम कैसे करते हैं?

Answer 1

वर्तमान में दिए गए दृष्टिकोणों में से किसी एक के साथ मेरी चिंता यह है कि वे दोनों 'वैरिएबल-स्पीड' को नष्ट कर देंगे, जो न केवल खिलाड़ियों के लिए विचलित करने वाला हो सकता है, बल्कि यह भी पता लगाने में मुश्किल कर सकता है कि गायब होने से पहले कितनी देर तक कोई वस्तु बची है । इसके बजाय, अपने मानकों में कहीं (चाहे वे रेंडरर के लिए या पर एक प्रति-वस्तु के आधार वैश्विक हो) मैं चार स्थिरांक होगा: slowBlinkTime, slowBlinkRate, fastBlinkTimeऔर fastBlinkRate। रेंडर करते समय, यदि आपके ऑब्जेक्ट का शेष जीवन इससे कम है fastBlinkTime, तो इसे ब्लिंक करें fastBlinkRate; अन्यथा अगर यह इससे कम है slowBlinkTime, तो इसे ब्लिंक करें slowBlinkRate। यदि आप एक कदम और आगे जाना चाहते हैं, तो आपके पास विशिष्ट blinkTimeएस और की एक सरणी हो सकती हैblinkRateएस और उन्हें एक-एक करके जांचें, लेकिन व्यवहार में यह अधिक होने की संभावना है और बस 'चेतावनी' और 'महत्वपूर्ण' राज्य होने चाहिए। कोड कुछ इस तरह दिखेगा:

float blinkCycle;
if ( entity.timeLeft < fastBlinkTime ) {
  blinkCycle = entity.timeLeft/fastBlinkRate;
} else if ( entity.timeLeft < slowBlinkTime ) {
  blinkCycle = entity.timeLeft/slowBlinkRate;
}
blinkCycle = blinkCycle - floor(blinkCycle); // find blinkCycle 'mod 1'
if ( (entity.timeLeft < slowBlinkTime) && (blinkCycle < 0.5f) ) {
  renderBlinked(entity); // this should be the 'blinked' state, whether flashed or missing
} else {
  renderNormal(entity); // the normal render for the entity
}

ध्यान दें कि यह कोड आधा-आधा, आधा-पलक झपकने का चक्र निर्धारित करता है (जो कि 0.5fपरीक्षण में यही दर्शाता है), लेकिन आसानी से दो-तिहाई की तरह कुछ के लिए ट्वीक किया जा सकता है, बस एक-तिहाई बंद करके उचित स्थिरांक। यह भी तेज और धीमी अवस्थाओं के बीच पलक झपकाने के लिए कुछ भी नहीं करता है, लेकिन यह पॉलिश करने के लिए अपेक्षाकृत सरल है।

यह प्लग इन करने के लिए सीधा होना चाहिए, और इससे IMHO को काफी फायदा होगा कि खिलाड़ी 'स्लो' से स्विच को 'फास्ट' ब्लिंकिंग में देख पाएंगे और यह जान पाएंगे कि उनके पास कितना समय बचा है। मैं पैरामीटर मानों के साथ शुरू करूँगा जैसे 5s के लिए slowBlinkTimeऔर 0.5s के लिए slowBlinkRate, और 2s / 0.25s के लिए fastBlinkTimeऔर fastBlinkRate, लेकिन यह निश्चित रूप से किसी विशेष गेम पर निर्भर है।

Comments

मुझे समझ नहीं आ रहा है। अगर पलक झपकते और तेज हो जाए, तो क्या यह एक बेहतर गेज नहीं होगा कि वस्तु केवल 2 मोड से कितनी देर के लिए बची है?

— डैनियल कापलान

@tieTYT समस्या यह है कि, विशेष रूप से जब ब्लिंकिंग की दर परिवर्तनशील होती है, तो यह उपयोगकर्ताओं के लिए कठिन है (ए) यह निर्धारित करता है कि कोई वस्तु कितनी तेजी से पलक झपक रही है, और (बी) यह सहसंबंधी है कि उसे कितने समय तक रहना है। कल्पना कीजिए कि 0, 100 बनाम 'स्विच' से 0, 50 और 100 पदों पर एक स्लाइडर है; लोग 5-10% के भीतर स्लाइडर के मूल्य का अनुमान लगाने में सक्षम हो सकते हैं, लेकिन उन्हें पता चल जाएगा कि स्विच किस मूल्य पर है - और किसी स्थिति की तुलना में दर को मापना बहुत कठिन है।

— स्टीवन स्टडनिक

वोट का सुझाव देने के बावजूद, मुझे लगता है कि यह सबसे अच्छा जवाब है। इसके अलावा, इसे लागू करना आसान है (कम से कम वैचारिक रूप से)। मेरे जवाब को अधिक वोट मिले, लेकिन मैं अभी भी नेत्रहीन इससे संतुष्ट नहीं हूं। आपका दृष्टिकोण एक संतोषजनक रूप देगा।

— डैनियल कपलान

Answer 2

यदि T T से 0 से नीचे जाता है, तो आप पाप ((T - t) () जैसी किसी चीज़ का उपयोग कर सकते हैं, यदि संख्या 0 है तो आप ऑब्जेक्ट को ड्रा करेंगे, यदि यह <0 है तो आप नहीं

---

मैंने इसे स्वयं आज़माया है और मुझे इसके साथ छेड़छाड़ करनी है। मेरे लिए T 100 था। इस समीकरण ने पूरे समय तेजी से सुपर ब्लिंक किया। तो इसे धीमा करने के लिए, मैंने समीकरण को पाप में बदल दिया (((- t - t) / 10)।)। यह / 6 और / 7 जैसी संख्याओं के साथ छेड़छाड़ के बाद था।

मैंने भी यह कोशिश की: पाप ((टी - टी) 100 * 1/100)

और फिर मुझे यह पसंद नहीं आया कि यह ड्रॉप कितना अदृश्य लग रहा था। मैं चाहता था कि यह शायद ही कभी अदृश्य हो। मैंने यह किया है कि ऐसा करने से: पाप ((T - t) 100 * 1/100) + .5 कि + .5 साइन "लाइन" को ऊपर उठाता है ताकि यह अक्सर <0 न हो जाए।

इसमें से किसी ने भी वैसा काम नहीं किया जैसा मैं चाहता था। समस्या यह है कि पलक भी जल्द ही शुरू हो जाएगी। मैं चाहता था कि ड्रॉप 3 सेकंड के लिए दिखाई दे और फिर झपकी लेना शुरू करें। इसे पूरा करने के लिए, मैंने कुछ इस तरह किया:

isVisible(drop)
  if drop.t > x
    return true
  else
    sin((T - x - drop.t)² * 1/100) + .5 >= 0

वह x3 सेकंड का होगा।

यह भी ध्यान देने योग्य है कि यह वह उपकरण है जिसका उपयोग मैंने पूरे समय यह कल्पना करने के लिए किया कि पलक कैसे दिखेगी। मुझे लगता है कि दृश्य उपकरण के बिना यह 5 गुना अधिक लंबा होगा।

Comments

बहुत बढ़िया, मैं इस समाधान से प्यार करता हूं, एक और त्वरित तरीका होगाsin(t * pow((t/T), 1.5))

— गुस्तावो मैकिएल

Answer 3

शायद एक और चर की मदद से?

current_length = 4
length_decrease = 0.5
current_time = current_length

function update(delta_time)
    if current_time > 0 then
        draw()
    end
    current_time -= delta_time
    if current_time < -current_length then
        current_length -= length_decrease -- feel free to get creative here
        if current_length < 0 then
            disable_object()
        end
        current_time += current_length * 2
    end
end

आपके द्वारा प्रस्तावित समाधान की तुलना में यह थोड़ा लंबा है, लेकिन आप अपने आप को महंगे sinऔर powसंचालन से बचाते हैं , और पलक झपकते ही आपका अधिक नियंत्रण रहता है।