मैं 2 डी गेम रिज़ॉल्यूशन को स्वतंत्र कैसे बना सकता हूं?

Question

मैं एक साधारण 2 डी गेम पर काम कर रहा हूं। मैंने मोबाइल फ़ोन संस्करण समाप्त कर दिया है।

हालांकि, मेरे बॉस चाहते हैं कि खेल उनके आरटी पर काम करे। मैं "रूपांतरण" कर रहा हूं, लेकिन मेरे बटन गलत स्थानों पर हैं, क्योंकि मैंने स्क्रीन आकार को इस तरह से हार्ड-कोडित किया है:

 texture = game.Content.Load<Texture2D>("StartScreen");
 mainFrame = new Rectangle(0, 0, game.GraphicsDevice.Viewport.Width, game.GraphicsDevice.Viewport.Height);

 // button definitions
 startbrect = new Rectangle(300, 258, 88, 88);
 startbtext = game.Content.Load<Texture2D>("bplay");

इस उदाहरण में, mainframeठीक है, लेकिन startbrectऐसा नहीं है, क्योंकि मैंने विंडोज फोन की स्क्रीन से मिलान करने के लिए आकार को परिभाषित किया है। जब सभी विंडोज 8 फोन की स्क्रीन अलग हैं, तो मैं उत्तरदायी डिजाइन कैसे संभाल सकता हूं? क्या हर बार अच्छे आकार की गणना करने के लिए कोई फार्मूला या मैक्रो है?

Comments

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

— क्रिश्चियन

Im एक और अधिक सुंदर तरीके की तलाश में है, लेकिन मैं इस समय के लिए प्रतिशत के साथ कोशिश करेंगे।

— गब्सन

आपको कैमरे में हेरफेर करके इसे करने में सक्षम होना चाहिए।

— ashes999

मेरा समाधान प्रतिशत से निपटने के लिए बेहतर नहीं था।

— गैबसन

Answer 1

मैं एक संदर्भ स्क्रीन आकार का उपयोग करता हूं, और सब कुछ उसी के अनुपात को ध्यान में रखते हुए, उसके अनुसार सब कुछ स्केल करता हूं।

private static float CalcRatio(Vector2 Sizes)
{
    return Sizes.y/Sizes.x;
}

public static Vector2 CalculateNewPos(Vector2 RefPos, Vector2 RefScreenSize, 
                                      Vector2 CurrentScreenSize)
{       
    return new Vector2((RefPos.x/RefScreenSize.x) * CurrentScreenSize.x, 
                       (RefPos.y/RefScreenSize.y) * CurrentScreenSize.y);
}

public static Vector2 CalculateNewSize(Vector2 RefSize, Vector2 RefScreenSize,
                                       Vector2 CurrentScreenSize)
{       
    float origRatio = CalcRatio(RefSize);
    float perW = RefSize.x * 100f / RefScreenSize.x;    
    float newW = perW / 100f * CurrentScreenSize.x;
    float newH = newW * origRatio;
    return new Vector2(newW, newH);
}

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

पोर्ट्रेट ओरिएंटेशन पर, मैं नए (नए) प्लेएबल क्षेत्र की गणना करता हूं ताकि स्क्रीन लंबवत रूप से भर जाए, और अंतरिक्ष को क्षैतिज रूप से उतना ही बड़ा हो जितना अनुपात रखने के लिए आवश्यक है। लैंडस्केप ओरिएंटेशन पर, मैं स्क्रीन को क्षैतिज रूप से भरता हूं, और ऊर्ध्वाधर आकार सेट करते समय अनुपात रखता हूं।

अधिक के लिए, http://en.wikipedia.org/wiki/Safe_area_(television) देखें क्योंकि यह एक समान है, यदि अवधारणा नहीं है।

Answer 2

मुझे लगता है कि स्वतंत्र लेआउट के समाधान के लिए सबसे आसान और सबसे प्राकृतिक दृष्टिकोण एक रिश्तेदार (प्रतिशत) योजना है। तो शुरू से ही वास्तविक संकल्प के साथ काम न करें लेकिन केवल एक समान [0,1] x [0,1] वर्ग में जहां भी संभव हो।

इसका मतलब है कि किसी दिए गए screen_sizeऔर दिए गए object_sizeऔर दिए गए रिश्तेदार की स्थिति (px, py)(उदाहरण के लिए (0.5, 0.5) स्क्रीन के केंद्र के लिए), ऑब्जेक्ट के ऊपरी, बाएं कोने की गणना निम्न द्वारा की जाती है:

x = px * screen_size.width - 0.5 * object_size.width
y = py * screen_size.height - 0.5 * object_size.height

विचार स्पष्ट होना चाहिए। एक तैयार अमूर्त होगा

x = cx1 * screen_size.width + cx2 * object_size.width + cx3
y = cy1 * screen_size.height + cy2 * object_size.height + cy3

और हर स्थिति को तब परिभाषित किया जाता है (cxi, cyi)। इसके द्वारा एक कोने में वस्तुओं को सीमाओं के साथ या बिना रख सकते हैं, आदि।

कृपया सुनिश्चित करें कि एकल तत्व आकार (बटन, लेबल, ...) को भी स्केल किया गया है।

Answer 3

मोनोमे के लिए विशेष I के पास IRR (इंडिपेंडेंट रेजोल्यूशन रेंडरर) नामक इस समस्या के लिए प्लेटफ़ॉर्म स्वतंत्र समाधान है। इसका बहुत सरल उपयोग है:

1. प्रारंभ () विधि में आईआरआर बनाएं

   _irr = नया ResolutionRenderer (यह, VirtualResolutionWidth, VirtualResolutionHeight, _gfx.PreferredBackBufferWidth, _gfx.PreferredBackBufferHight);

2. कॉल _irr.Draw () में प्रत्येक चक्र ड्रा () कॉल
3. आपूर्ति _irr.GetTransformationMatrix () किसी भी SpriteBatch.Begin () कॉल में आप IRR का उपयोग करना चाहते हैं।

विवरण यहाँ है: http : //pan ईथरनेट . ru/forum/index.php ? /topic/17-monogamexna-examples-v14/ ? p = 44

कोड यहाँ है: https://github.com/pan ईथरनेट / Monogame-Examples