การพัฒนาเกม

เมื่อเร็ว ๆ นี้ฉันได้ฝึกสอนนักพัฒนาที่เพิ่งเริ่มทำเกมพิกเซลอาร์ทและตระหนักว่ามี "ภูมิปัญญาดั้งเดิม" รอบ ๆ สเกลพิกเซลศิลปะที่ไม่ชัดเจนสำหรับผู้ใช้ใหม่และอาจมีการบันทึกไม่ดี ดังนั้นนี่คือความพยายามในการแก้ไขปัญหานี้ .... ฉันได้ยินมาว่าฉันควรจะปรับสเกลพิกเซลภาพเป็น 200%, 300% และอื่น ๆ ไม่ได้อยู่ระหว่างขนาดเช่น 120% ทำไมถึงเป็นอย่างนั้น? ไม่ควรปรับ "ใช้งานได้" อย่างที่มันทำกับรูปภาพอื่น ๆ ถ้าฉันต้องทำให้ตัวละครของฉันใหญ่ขึ้นหรือเล็กลงเพื่อให้ได้รูปแบบการเล่นที่ถูกต้อง ฉันจะแก้ไขสิ่งนี้ได้อย่างไร ฉันบอกว่า "ไม่ดี" ในการใช้งานภาพพิกเซลในระดับที่แตกต่างกันในหนึ่งเกม - เพราะเหตุใด ตัวอย่างเช่นหากฉันปรับขนาดตัวละครของฉันดังนั้นสไปรต์เท็กเซลแต่ละพิกเซลจะเป็นพิกเซลหน้าจอ 4x4 ในขณะที่ภาพพื้นหลังของฉันจะถูกปรับให้เพิ่มขึ้น จุดสิ้นสุดของวันไม่ใช่พิกเซลหรือไม่

13 scale  pixel-art 

ฉันดูเหมือนจะอ่านต่อไปมันเป็นความคิดที่ดีที่จะใช้XxxManagerสไตล์คลาสในการเขียนโปรแกรมเกมเอ็นจิ้น แต่ถึงแม้ว่าฉันพยายามที่จะหลีกเลี่ยงการใช้พวกเขาฉันมักจะจบลงด้วยสิ่งที่เก็บนักแสดง / เอนทิตี้ / จบลงด้วยการเป็นManagerถ้าด้วยชื่ออื่น นี่เป็นรูปแบบที่ไม่ดีที่จะติดตามหรือไม่ ถ้าเป็นเช่นนั้นทางเลือกคืออะไร?

13 architecture  software-engineering  design-patterns 

ฉันมีตัวละครตัวนี้ใน Unity3D (โหมด 2D) ... ในความชันที่ดูเหมือนนี้ แต่ฉันต้องการให้ตัวละครยืนตามเส้นสีแดง .. เหมือนด้านล่าง ฉันจะสร้างมันใน Unity3d ได้อย่างไร ฉันได้ตั้งค่านี้แล้ว ฉันกำลังใช้ Addforce แบบง่ายสำหรับการเคลื่อนย้าย ... หากฉันลบข้อ จำกัด ตำแหน่ง z ส่งผลให้เกิดการเคลื่อนไหวแปลก ๆ เช่นการกลิ้งและอื่น ๆ .... ความช่วยเหลือใด ๆ ที่จะได้รับการชื่นชม :)

13 2d  physics  unity  rotation  procedural 

ฉันกำลังสร้างเกมโดยใช้แผนที่ย่อยที่ทำจากสี่เหลี่ยมหลายพันตาราง ในขณะนี้แต่ละสแควร์จะมี collider สแควร์สำหรับตรวจสอบการชนกัน อย่างไรก็ตามด้วยบล็อกขนาดเล็กหลายพันบล็อกการตรวจสอบพวกเขาทั้งหมดสำหรับการชนนั้นไม่มีประสิทธิภาพ หากฉันรู้ว่า tilemap จะมีลักษณะเช่นนี้ล่วงหน้าฉันสามารถใช้ colliders ขนาดใหญ่ 3 หรือ 4 ตัวแทนตัวเล็ก ๆ หลายพันตัว: มีอัลกอริธึมมาตรฐานบางประเภทสำหรับการรวมไทล์เล็ก ๆ ที่อยู่ติดกันให้ใหญ่ที่สุด? ถ้ามีใครช่วยอธิบายได้ที่นี่หรือชี้ไปที่วรรณกรรมเกี่ยวกับอัลกอริธึมดังกล่าว อีกทางหนึ่งบางทีการประมวลผลล่วงหน้าตัวสร้างไทล์ด้วยวิธีนี้อาจเป็นวิธีที่ผิด ถ้าเป็นเช่นนั้นสิ่งที่ถูกต้องที่จะจัดการกับประสิทธิภาพของ colliders จำนวนมากคืออะไร?

13 collision-detection  tiles  tilemap  efficiency 

ฉันต้องการสร้างเครื่องมือที่คล้ายกับเครื่องมือภูมิประเทศของ Unity ซึ่งมีปุ่มสลับบางปุ่มในตัวตรวจสอบ: ฉันจะออกแบบที่คล้ายกันนี้ได้อย่างไร ฉันรู้วิธีสร้างปุ่มปกติและส่วนประกอบ UI อื่น ๆ ในตัวตรวจสอบ แต่ฉันไม่สามารถหาข้อมูลเพียงพอที่จะทำให้ปุ่มสลับ จนถึงตอนนี้ฉันได้ใช้การสลับปกติที่สร้างช่องทำเครื่องหมาย: var tmp = EditorGUILayout.Toggle( SetAmountFieldContent, _setValue ); if ( tmp != _setValue ) { _setValue = tmp; if ( _setValue ) _smoothValue = false; } tmp = EditorGUILayout.Toggle( SmoothValueFieldContent, _smoothValue ); if ( tmp != _smoothValue ) { _smoothValue …

13 unity 

โดยทั่วไปฉันต้องการทราบว่าฉันสามารถลบความบิดเบี้ยวหรือการยืดภาพที่แสดงเมื่อขนาดวิวพอร์ต / หน้าต่างเปลี่ยนไปอย่างไร ภาพต่อไปนี้แสดงให้เห็นถึงการบิดเบือน / การยืดที่ฉันกำลังพูดถึง: รูปภาพต้นฉบับ (หน้าต่างสี่เหลี่ยม) ภาพบิดเบี้ยว / ยืดออก (หน้าต่างรูปสี่เหลี่ยมผืนผ้า) ตามหลักการแล้วภาพที่สองควรแสดงทรงกลมโดยไม่ต้องยืดออกในแนวนอนและจะทำให้ฉากกับผู้ใช้มากขึ้นเพื่ออธิบายขนาดหน้าต่างที่ใหญ่ขึ้น สิ่งนี้สามารถทำได้? ฉันทำงานกับ OpenGL เพื่อแสดงภาพและฉันใช้ประโยชน์จากการคาดการณ์มุมมองผ่านการโทร: glMatrixMode(GL_PROJECTION) glLoadIdentity() gluPerspective(60, window.width/window.height, 0.01f, 100.0f) อัตราส่วนภาพwidth/heightเป็นไปตามเอกสาร / บทช่วยสอนทั้งหมดที่ฉันพบดังนั้นฉันไม่คาดหวังว่ามันจะไม่ถูกต้อง อย่างไรก็ตามความสงสัยของฉันคือมันส่งผลกระทบต่อปัญหาการยืด หลังจากคิดแล้ว ตามจริงแล้วเมื่อฉันคิดเกี่ยวกับประเด็นนี้มากขึ้นฉันก็จะเชื่อว่าการแก้ปัญหานั้นเกี่ยวข้องกับความสัมพันธ์ที่เป็นสัดส่วนโดยตรงระหว่างมุมมองในทิศทาง y กับทิศทาง fovy และอัตราส่วนภาพ การใช้ภาพด้านบนเป็นข้อมูลอ้างอิงหากความกว้างเพิ่มขึ้น (ก่อให้เกิดการยืดในแนวนอน) ดูเหมือนว่าน่าจะเป็นไปได้มากที่มุม fovy ต้องเพิ่มขึ้นเพื่อทำให้เกิดการยืดแนวตั้งที่ 'แก้ไข' สัดส่วนของภาพที่แสดงผล ในทำนองเดียวกันการลดความกว้างต้องลดลงในมุม fovy ปรับปรุง: ดังนั้นหลังจากตรวจสอบเรื่องนี้ต่อไปฉันได้ตัดสินใจที่จะเปลี่ยนวิธีการตั้งค่า frustum การดูเช่นนี้: gluPerspective(60 * (float)window.width/window.height, (float)window.width/window.height, …

13 opengl  perspective  viewport  aspect-ratio 

กำหนดเอนทิตีที่ชื่อEntityAฉันต้องการกำหนดพื้นที่พิกัดเฉพาะที่ซึ่งตำแหน่งของEntityAเป็นจุดเริ่มต้นเวกเตอร์ส่วนหัวของมันคือแกน X และปกติของเวกเตอร์หัวเรื่องคือแกน Y: จากพิกัดโลกของพวกเขาฉันจะค้นหาตำแหน่งของเอนทิตี้อื่นในEntityAพื้นที่ท้องถิ่นได้อย่างไร ตัวอย่าง: EntityAตำแหน่งส่วนกลางของ (50,50) และตำแหน่งนั้นEntityBคือ (80,90) ตำแหน่งของEntityBในEntityAพื้นที่ท้องถิ่นคืออะไร? แก้ไข: กรุณาใช้คณิตศาสตร์ง่ายๆ

13 2d  mathematics  coordinates 

ตรงข้ามกับการแสดงผล CPU หรือซอฟต์แวร์ฉันถือว่า? โดยทั่วไปแล้วการแสดงผลในปัจจุบันทั้งหมดจะเป็นไปตาม GPU ใช่ไหมว่าคุณจะใช้ OpenGL หรือ Direct X มีคนให้ข้อมูลฉันที่นี่ไม่พบคำตอบที่เหมาะสมหรือไม่

13 opengl  directx  rendering  gpu  software-rendering 

หากคุณดูเกม 3 มิติที่ช่วยให้คุณควบคุมกล้องโดยใช้เมาส์ - โดยเฉพาะอย่างยิ่งเกมสไตล์นักกีฬาคนแรกและคนที่สาม - โดยทั่วไปคุณจะพบรายละเอียดเฉพาะสองอย่าง: ตามค่าเริ่มต้นการเลื่อนเมาส์ไปข้างหน้าจะทำให้กล้องเงยหน้าขึ้นและดึงกลับลงมา ตัวเลือกในการกลับด้านนี้ (ไปข้างหน้า = ลง) เรียกว่า "แกนกลับหัว Y" หรือบางอย่างที่คล้ายกัน ฉันไม่เคยเข้าใจมาก่อนและดูเหมือนจะย้อนกลับมาหาฉันเสมอจนถึงจุดที่ฉันสับสนในเกมใด ๆ ที่มีการตั้งค่าเริ่มต้น ดูเหมือนชัดเจนว่าสัญชาตญาณว่าเมาส์ (หรือยิ่งกว่านั้นคือ thumbstick ที่ดูเหมือนหัวนั่งอยู่บนคอ) เป็นการจำลองหัวของตัวละครในมุมมอง เลื่อนไปทางซ้ายคุณมองไปทางซ้าย เลื่อนไปทางขวาคุณดูขวา ดันไปข้างหน้าหัวผลักไปข้างหน้าและคุณมองลงไป ...ใช่ไหม ในความเป็นจริงการวางแนวนี้เป็นค่าเริ่มต้นในเกม 3D ยุคต้น ๆ มากมายเช่นการจำลองการบิน MechWarrior 2 เป็นต้น แต่ในบางครั้งมันก็เปลี่ยนไป มีเหตุผลทางประวัติศาสตร์ใด ๆ ที่อยู่เบื้องหลังการกลับทิศทางการควบคุมกล้องเริ่มต้นนี้หรือไม่? อาจมีบทความใด ๆ เกี่ยวกับเหตุผลที่อยู่เบื้องหลังการเปลี่ยนแปลงมันหรือการศึกษาแสดงให้เห็นว่าทำไมมันถึงเป็นการเปลี่ยนแปลงที่พึงปรารถนาที่จะทำ?

13 input  control  ui-design 

การปรับใช้ E / C ของฉันเป็นสิ่งพื้นฐานที่หน่วยงานเป็นเพียง ID ของคอมโพเนนต์คือข้อมูลและระบบดำเนินการกับข้อมูล ตอนนี้ฉันมีปัญหากับวัสดุวัตถุและการแสดงผลโดยทั่วไป สำหรับ objetcs ธรรมดาที่ฉันมี a ModelComponent, เชื่อมโยงกับ a RenderSystem, ModelComponentจะมีรหัสจุดสุดยอดบัฟเฟอร์ที่ระบบการเรนเดอร์ใช้ ง่ายMaterialComponentอาจจะมีสีหรือความแข็งแรง specular ฯลฯ แต่ผมอยากให้มันเป็นพอมีความยืดหยุ่นเพื่อให้สามารถมากกว่าหนึ่งทำให้ผ่านและ "ผลกระทบ" MaterialComponentทั่วไปที่ไม่ได้เป็นเรื่องง่ายเป็นตัวแปรที่เรียบง่ายใน พยายามแก้ไขปัญหาเหล่านี้ฉันหาวิธีแก้ไขสองวิธี: 1 - ส่วนประกอบวัสดุที่มีความพิเศษมาก บางสิ่งเช่นนี้ struct Material : public Component { ShaderData* shader; std::vector<std::pair<std::string, boost::any>> uniforms; [...] }; และในระบบเรนเดอร์ฉันจะวนซ้ำและส่งชุดไปที่ shader ฉันคิดว่านี่จะช้า แต่เร็วพอสำหรับจุดประสงค์ของฉัน 2 - อีกชั้นหนึ่งของนามธรรม, MaterialData การมีคลาสเพื่อห่อวัสดุเฉพาะที่สามารถสืบทอดได้โดยวัสดุพิเศษอะไรก็ตามคลาสพื้นฐานจะมีบางอย่างเช่นvoid …

13 component-based  entity-system  entity-component 

ใน Direct3D นั้น shader แบบหลายตัวนั้นใช้งานง่ายเพราะคุณสามารถกำหนด pass ภายในโปรแกรมได้อย่างแท้จริง ใน OpenGL ดูเหมือนว่าจะซับซ้อนกว่านี้เล็กน้อยเนื่องจากเป็นไปได้ที่จะให้โปรแกรม shader เป็นจุดสุดยอดรูปทรงเรขาคณิตและส่วนที่แตกต่างกันตามที่คุณต้องการ ตัวอย่างที่เป็นที่นิยมของเครื่องมัลติพลาสเดอร์คือเครื่องจิ้มอเนกประสงค์ การผ่านหนึ่งครั้งจะมีเอฟเฟ็กต์การแรเงาที่เกิดขึ้นจริงและอีกอันจะสร้างโครงร่าง ถ้าฉันมีสองจุดยอด "cel.vert" และ "outline.vert" และสองชิ้นส่วน "cel.frag" และ "outline.frag" (คล้ายกับที่คุณทำใน HLSL) ฉันจะทำได้อย่างไร รวมเข้าด้วยกันเพื่อสร้าง shader toon แบบเต็ม? ฉันไม่ต้องการให้คุณพูดว่าสามารถใช้รูปทรงเรขาคณิตสำหรับเรื่องนี้ได้เพราะฉันแค่อยากรู้ทฤษฎีที่อยู่เบื้องหลัง GLSL หลายตัว;)

13 opengl  shaders  glsl 

ฉันกำลังเขียนเกมจำลองการจัดการกีฬา เช่นเดียวกับเกมการจัดการกีฬาส่วนใหญ่มันใช้สถิติอย่างหนัก ฉันต้องการใช้ผู้เล่นจริงทีมและชื่อลีก i) ฉันเสี่ยงต่อการเข้าสู่การต่อสู้ทางกฎหมายหรือไม่หากฉันควรใช้ชื่อจริง? ii) แล้วสีและตราสัญลักษณ์ของทีมเป็นอย่างไรบ้าง? อัปเดต ขอบคุณมากสำหรับข้อมูลทั้งหมด!

13 legal 

คำถาม เมื่อคุณมีเกม 2D ที่ใช้ภาพที่มีขนาดใหญ่มาก (ใหญ่กว่าฮาร์ดแวร์ของคุณสามารถรองรับได้) คุณจะทำอย่างไร อาจมีวิธีแก้ปัญหาที่น่าสนใจสำหรับปัญหานี้ซึ่งไม่เคยเกิดขึ้นกับฉันมาก่อน ฉันกำลังทำงานกับผู้สร้างเกมผจญภัยกราฟิก ผู้ชมเป้าหมายของฉันคือผู้ที่มีประสบการณ์การพัฒนาเกม (และการเขียนโปรแกรม) เพียงเล็กน้อยหรือไม่มีเลย หากคุณทำงานกับแอปพลิเคชันเช่นนี้คุณไม่ต้องการให้มันจัดการกับปัญหาภายในแทนที่จะบอกให้คุณ "แยกภาพของคุณออก" บริบท เป็นที่ทราบกันดีว่าการ์ดกราฟิกกำหนดข้อ จำกัด เกี่ยวกับขนาดของพื้นผิวที่สามารถใช้ได้ ตัวอย่างเช่นเมื่อทำงานกับ XNA คุณจะถูก จำกัด ขนาดพื้นผิวสูงสุดที่ 2048 หรือ 4096 พิกเซลขึ้นอยู่กับโปรไฟล์ที่คุณเลือก โดยทั่วไปแล้วสิ่งนี้จะไม่ก่อปัญหามากในเกม 2D เพราะส่วนใหญ่มีระดับที่สามารถสร้างจากชิ้นส่วนที่เล็กกว่า (เช่นแผ่นกระเบื้องหรือสไปรต์ที่ถูกเปลี่ยนรูป) แต่ลองคิดถึงเกมผจญภัยกราฟิก point'nclick แบบคลาสสิค (เช่น Monkey Island) ห้องพักในเกมผจญภัยกราฟิกมักจะได้รับการออกแบบโดยรวมโดยมีส่วนที่ทำซ้ำได้น้อยหรือไม่มีเลยเหมือนกับจิตรกรที่ทำงานในแนวนอน หรืออาจเป็นเกมเช่น Final Fantasy 7 ที่ใช้ฉากหลังที่มีการแสดงผลขนาดใหญ่ ห้องเหล่านี้บางห้องมีขนาดใหญ่พอสมควรซึ่งมีความกว้างตั้งแต่สามหน้าจอขึ้นไป ตอนนี้ถ้าเราพิจารณาภูมิหลังเหล่านี้ในบริบทของเกมความละเอียดสูงที่ทันสมัยพวกเขาจะเกินขนาดพื้นผิวที่รองรับสูงสุดได้อย่างง่ายดาย ตอนนี้ทางออกที่ชัดเจนของเรื่องนี้คือการแบ่งพื้นหลังออกเป็นส่วนย่อย ๆ ที่พอดีกับความต้องการและวาดมันเคียงข้างกัน แต่คุณ (หรือศิลปินของคุณ) จะต้องเป็นคนที่แยกพื้นผิวทั้งหมดของคุณหรือไม่ …

13 xna  c#  2d  graphics  textures 

ฉันกำลังพัฒนา platformer 2D กับเพื่อน ๆ เราได้ใช้ชุดเริ่มต้น XNA Platformer ซึ่งใช้ไฟล์. txt เพื่อจัดเก็บแผนที่ย่อย ในขณะที่ง่าย แต่ก็ไม่ได้ให้การควบคุมและความยืดหยุ่นเพียงพอกับการออกแบบระดับ ตัวอย่าง: สำหรับเนื้อหาหลายเลเยอร์จำเป็นต้องใช้หลายไฟล์วัตถุแต่ละชิ้นได้รับการแก้ไขบนกริดไม่อนุญาตให้มีการหมุนของวัตถุจำนวนอักขระที่ จำกัด เป็นต้นดังนั้นฉันจึงทำการวิจัยเกี่ยวกับวิธีการจัดเก็บข้อมูลระดับ และไฟล์แผนที่ สิ่งนี้เกี่ยวข้องกับการจัดเก็บระบบไฟล์ของแผนที่ย่อยไม่ใช่โครงสร้างข้อมูลที่เกมจะใช้ในขณะที่ทำงานอยู่ การแมปไทล์ถูกโหลดลงในอาร์เรย์ 2D ดังนั้นคำถามนี้เกี่ยวกับแหล่งที่มาเพื่อเติมอาร์เรย์ การใช้เหตุผลสำหรับฐานข้อมูล: จากมุมมองของฉันฉันเห็นความซ้ำซ้อนของข้อมูลน้อยลงโดยใช้ฐานข้อมูลเพื่อเก็บข้อมูลไทล์ ไทล์ในตำแหน่ง x, y ที่มีคุณสมบัติเหมือนกันสามารถนำกลับมาใช้ใหม่ได้จากระดับหนึ่งไปอีกระดับ ดูเหมือนว่ามันจะง่ายพอที่จะเขียนวิธีการดึงไทล์ทั้งหมดที่ใช้ในระดับเฉพาะจากฐานข้อมูล เหตุผลสำหรับ JSON / XML: ไฟล์ที่สามารถแก้ไขได้ด้วยสายตาการเปลี่ยนแปลงสามารถติดตามผ่าน SVN ได้ง่ายขึ้นมาก แต่มีเนื้อหาซ้ำแล้วซ้ำอีก มีข้อเสียใด ๆ (เวลาโหลด, เวลาในการเข้าถึง, หน่วยความจำและอื่น ๆ ) เปรียบเทียบกับอีกรุ่นหรือไม่? และสิ่งที่ใช้กันทั่วไปในอุตสาหกรรม? ปัจจุบันไฟล์มีลักษณะดังนี้: .................... .................... .................... …

13 xna  c#  xml 

ฉันกำลังสร้างเกม platformer ที่มีคุณสมบัติ "ร่วมมือ" ซึ่งฉันต้องการทำงานผ่านเครือข่าย / อินเทอร์เน็ต ตอนนี้ฉันได้อ่านเกี่ยวกับการเขียนโปรแกรมเกมบนเครือข่ายรวมถึงบทความอย่างที่โปรแกรมเมอร์ทุกคนต้องการทราบเกี่ยวกับการสร้างเครือข่ายเกมและดังนั้นฉันจึงเข้าใจความแตกต่างระหว่างเทคนิคต่าง ๆ เช่นการล็อก Peer-to-Peer และสถาปัตยกรรมทำนายเซิร์ฟเวอร์ ฉันได้ข้อสรุปว่าสำหรับเกมเรียลไทม์ใด ๆ ที่กำลังจะเล่นผ่านอินเทอร์เน็ต Peer-to-Peer lockstep ไม่ได้เป็นตัวเลือก ฉันยังกังวลว่าสำหรับสถาปัตยกรรมแพลตฟอร์มไคลเอนต์เซิร์ฟเวอร์แบบง่าย (โดยไม่ต้องคาดเดาลูกค้า) จะส่งผลให้เกมเพลย์เสื่อมสภาพเนื่องจากความล่าช้าระหว่างการกระทำและปฏิกิริยาที่เกิดจากการไปกลับไปยังเซิร์ฟเวอร์ (ต้องบอกว่าฉันต้องการขจัดความต้องการเซิร์ฟเวอร์กลางและมีเพียงหนึ่งผู้เล่นเท่านั้นที่ลูกค้าจะได้สัมผัสกับความล่าช้านี้) สิ่งนี้ทำให้การคาดการณ์ของลูกค้า แต่สำหรับเกมง่ายๆเช่น platformer มันยังฟังดูค่อนข้างซับซ้อน ฉันจะไปเกี่ยวกับการสร้างระบบคาดการณ์ลูกค้าทำงานสำหรับเกม platformer ที่มีผู้เล่นหลายคนได้อย่างไร

13 networking  multiplayer  platformer