मुझे संरचनाओं के रूप में बिंदुओं और आकारों का प्रतिनिधित्व कब करना चाहिए?

Question

मेरे सरल रूबी 2 डी गेम विकास ढांचे के हिस्से के रूप में, मेरी गेम ऑब्जेक्ट्स में स्थिति (x और y मान) और आकार (चौड़ाई और ऊंचाई) है।

class MyGameObject
  attr_accessor :x
  attr_accessor :y
  attr_accessor :width
  attr_accessor :height
  ...

एक और दृष्टिकोण जो मैंने देखा है वह एक Pointसंरचना के रूप में स्थिति का इलाज कर रहा था , और एक Sizeसंरचना के रूप में आकार :

Point = Struct.new(:x, :y)
Size = Struct.new(:width,:height)

class MyGameObject
  attr_accessor :position   # Point instance
  attr_accessor :size       # Size instance
  ...

कुछ चौखटे पूर्व का उपयोग करते हैं (मुझे लगता है कि GDX, Gosu ...)। अन्य लोग बाद वाले (cocos2d-iphone) का उपयोग करते हैं। समस्या यह है, यह मेरे लिए पूरी तरह से स्पष्ट नहीं है कि दोनों व्यवहारों के फायदे और नुकसान (खेल के विकास में) - मुझे नहीं पता कि कुछ रूपरेखाओं ने एक को क्यों चुना और दूसरे को नहीं।

क्या मेरे विचार में महत्वपूर्ण अंतर हैं?

Answer 1

कुछ भी Rectangleकक्षा का उपयोग करते हैं :

class Rectangle
{
    float x, y, w, h;
}
class GameObject
{
    Rectangle dimensions;
}

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

मैं इस तरह से दो अलग-अलग वैक्टर के साथ जाने के लिए कहूंगा:

class Vector2
{
    float x, y;
    //helper functions like operator overload, dot, length, distance, etc.
}

class GameObject
{
    Vector2 position;
    Vector2 size;
    Vector2 direction;
}

इस तरह से आप वस्तुओं के बीच कोण जैसी चीजों को आसानी से संभाल सकते हैं, जैसे:

GameObject foe;
GameObject player;
Vector2 dist = player.position - foe.position;
dist.normalize();
float angleBetween = acos(dist.dot(foe.direction));

आयतों से वेक्टर्स निकालने के बजाय, या उन्हें सादे फ़्लोट्स से बनाएं।

Answer 2

सामान्य तौर पर, हमेशा एक अलग डेटा संरचना का उपयोग करें। यह आपके कोड को उपयोग करने, पढ़ने और बनाए रखने में काफी आसान बनाता है। आपको कितनी बार बनाम xसे अलग होने की आवश्यकता है y, आपको वेक्टर ऑफ़सेट, लंबाई, डॉट उत्पाद, आदि की गणना करने की कितनी बार आवश्यकता है? सामान्य मामले के लिए लक्ष्य; उस कोड को बनाएं जिसे आप बार-बार लिखना आसान बनाते हैं, जिसके लिए अंक और वैक्टर, आमतौर पर व्यक्तिगत घटकों पर संचालन के बजाय पूरे "ऑब्जेक्ट" पर काम करने वाले होते हैं।

एकमात्र अपवाद मैं बनाऊंगा , ठीक से प्रोफाइलिंग के बाद , आप पाते हैं कि अलग संरचना बहुत धीमी है। रूबी जैसी भाषाएं सरल उपयोगकर्ता-परिभाषित "बाय-वैल्यू" को संभव नहीं बनाती हैं और, मेरे अनुभव में, अंक और वैक्टर "बाय-रेफरेंस" प्रकार के होते हैं, जो कई बार दर्द होता है और अस्थायी लोगों पर ध्यान दिए बिना बड़े पैमाने पर मंदी हो सकती है । यह लाभप्रद हो सकता है, उदाहरण के लिए, किलों के दो सरणियों के लिए, एक के लिए xऔर एक के लिए y, फिर Pointवस्तुओं की एक एकल सरणी के लिए ; यह बहुत अधिक दर्द के साथ काम करने के लिए है, हालांकि केवल उस विभाजन को करने के लिए यदि आपके पास वैध प्रदर्शन मीट्रिक है तो यह इंगित करने के लिए कि यह सार्थक है!

Comments

+1, लेकिन मैं इस बात का उल्लेख करना चाहूंगा कि पूर्वगामीकरण सभी बुराई की जड़ है।

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

@GustavoMaciel: वास्तव में। तथ्य: क्रूला डी विल सिर्फ अपने व्यक्तित्व को साफ करने से पहले अपनी अलमारी को अनुकूलित करने की कोशिश कर रही थी, और देखो कि उसे कहां मिला।

— सीन मिडिलिचच