การพัฒนาเกม

ปิด คำถามนี้จะต้องมีมากขึ้นมุ่งเน้น ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัปเดตคำถามเพื่อให้มุ่งเน้นที่ปัญหาเดียวโดยแก้ไขโพสต์นี้ ปิดให้บริการใน2 ปีที่ผ่านมา มีเกมพีซีจำนวนมากออกมาที่มี (เหมือน) กราฟิกโดยประมาณ (กับ bump-maps, shaders, ฯลฯ ) ความซับซ้อนของเสียงและเวลาในการเล่น แต่หนึ่งในนั้นต้องการพื้นที่ 4GB ในขณะที่อีก 13GB ทำไมถึงเป็นอย่างนั้น? ทำไมถึงมีขนาดแตกต่างกันมาก?

13 optimization  pc 

ฉันออกแบบเอ็นจิ้นเกมสำหรับเกมยิง 2D แบบผู้เล่นหลายคนจากบนลงล่างซึ่งฉันต้องการใช้ซ้ำได้อย่างมีเหตุผลสำหรับเกมยิงจากบนลงล่างอื่น ๆ ในขณะนี้ฉันกำลังคิดว่าควรออกแบบระบบเอนทิตี้ของมันอย่างไร ครั้งแรกที่ฉันคิดเกี่ยวกับเรื่องนี้: ฉันมีคลาสชื่อ EntityManager ควรใช้วิธีการที่เรียกว่าการปรับปรุงและอีกวิธีหนึ่งที่เรียกว่าการวาด เหตุผลที่ฉันแยกลอจิกและการเรนเดอร์ก็เพราะฉันสามารถตัดเมธอด Draw ได้หากรันเซิร์ฟเวอร์สแตนด์อะโลน EntityManager เป็นเจ้าของรายการของวัตถุประเภท BaseEntity แต่ละเอนทิตีเป็นเจ้าของรายการของส่วนประกอบเช่น EntityModel (การนำเสนอที่เป็นไปได้ของเอนทิตี), EntityNetworkInterface และ EntityPhysicalBody EntityManager ยังเป็นเจ้าของรายชื่อผู้จัดการองค์ประกอบเช่น EntityRenderManager, EntityNetworkManager และ EntityPhysicsManager ตัวจัดการส่วนประกอบแต่ละตัวจะอ้างอิงถึงองค์ประกอบของเอนทิตี มีสาเหตุหลายประการในการย้ายรหัสนี้ออกจากคลาสของเอนทิตีและดำเนินการโดยรวมแทน ตัวอย่างเช่นฉันใช้ไลบรารีฟิสิกส์ภายนอก Box2D สำหรับเกม ใน Box2D คุณต้องเพิ่มเนื้อหาและรูปร่างให้กับโลก (เป็นเจ้าของโดย EntityPhysicsManager ในกรณีนี้) และเพิ่มการโทรกลับการชนกันของข้อมูล (ซึ่งจะถูกส่งไปยังวัตถุเอนทิตีในระบบของฉัน) จากนั้นคุณเรียกใช้ฟังก์ชันที่จำลองทุกอย่างในระบบ ฉันพบว่ามันยากที่จะหาทางออกที่ดีกว่าในการทำเช่นนี้ในการจัดการส่วนประกอบภายนอกเช่นนี้ การสร้างเอนทิตีทำเช่นนี้: EntityManager ใช้เมธอด RegisterEntity (entityClass, factory) ซึ่งลงทะเบียนวิธีสร้างเอนทิตีของคลาสนั้น นอกจากนี้ยังใช้เมธอด …

13 entity-system  component-based 

ฉันรู้ว่าคำถามนี้เป็นนางฟ้ากว้างและเป็นส่วนตัว แต่ฉันสงสัยว่ามีงานวิจัยที่ตีพิมพ์เกี่ยวกับจำนวนความสำเร็จที่เหมาะสมที่สุดและความท้าทายที่พวกเขาควรนำเสนอ เกมคำถามนี้เกี่ยวข้องโดยตรงกับ shoot-em-up แต่คำตอบที่เหมาะคือทฤษฎีค่อนข้าง หากมีความสำเร็จน้อยเกินไปหรือไม่ท้าทายฉันคาดหวังว่าพวกเขาจะล้มเหลวในเป้าหมายเพื่อให้ผู้คนเล่น หากมีจำนวนมากเกินไปหรือพวกเขายากเกินสมควรฉันคาดว่าคนจะยอมแพ้อย่างรวดเร็ว ฉันเห็นเหตุการณ์ที่เกิดขึ้นใน Starcraft 2 เป็นการส่วนตัว ส่วนของความสำเร็จจะมีคุณชนะหลายร้อยเกมกับฝ่ายตรงข้าม AI ของพวกเขา (น่าเบื่อ!)

13 game-design  social  achievements 

อัลกอริทึมการแรเงาประเภทใดที่อาจใช้สร้างเงาเช่นนี้ สิ่งที่ฉันทำคล้ายกัน แต่ทั้งหมดนั้นทำด้วย 2D drawing API ที่ขับเคลื่อนโดย OpenGL ดังนั้นจึงไม่มีพิกัด Z นอกจากนี้สำหรับมือของฉันเองฉันอยากได้ความรู้สึกแบบที่เห็นที่นี่: ฉันไม่แน่ใจว่าจะทำอย่างไรให้ได้ร่มเงาดูใกล้เคียง จำนวนบัตรถูกผูกไว้กับการเปลี่ยนแปลงและไพ่ถูกโยนลงบนโต๊ะดังนั้นฉันจึงไม่สามารถใช้แผนที่แสงทุกประเภท ฉันควรมองหาอัลกอริทึมประเภทใด (นอกเหนือจากความพร่ามัวที่ฉันรู้ว่าต้องทำ) ขอบคุณ ปรับปรุง ฉันทำเกมการ์ด 2D ฉันต้องการเพิ่มออฟเซ็ทเงาจากการ์ดเล็กน้อยเช่น: วิธีที่ฉันคิดว่าจะทำคือ: รักษาพื้นผิวที่มีขนาดเท่ากับ backbuffer วาดสี่เหลี่ยมสีเข้มเป็นการ์ดชั่วคราวเพื่อพื้นผิวนั้น เบลอพื้นผิวนั้น วาดไพ่ของฉันลงบนพื้นผิวนั้น เพิ่มแสงสว่างบนการ์ด วาดเนื้อนี้ไปที่ backbuffer คำถามของฉันคือ: นี่เป็นวิธีที่ถูกต้องหรือไม่ มีวิธีทำโดยไม่ทำให้พื้นผิว (รักษาบิตแมป ใหญ่เป็น backbuffer)? จะปลอดภัยหรือไม่ที่จะสันนิษฐานว่าขนาดพื้นผิวสูงสุดจะไม่ เกินจากขนาดของแบ็คบุฟเฟอร์? (สิ่งที่ฉันหมายถึงคือถ้า backbuffer เป็น 2000x3000 แล้วมันปลอดภัยที่จะบอกว่าฉันสามารถสร้างพื้นผิวใน หน่วยความจำวิดีโอขนาดนั้นหรือไม่ ขอบคุณ

13 algorithm  shaders  shadows  fragment-shader 

ฉันมีแผนที่เรียงต่อหกเหลี่ยมซึ่งฉันต้องตรวจสอบเมื่อมีการคลิกรูปหกเหลี่ยม รูปหกเหลี่ยมไม่ได้สัมผัสจริง ๆ แต่มีช่องว่างเล็กน้อยระหว่างแต่ละจุด ไม่มีใครรู้ว่าฉันจะไปเกี่ยวกับการตรวจสอบว่ามีการคลิกหกเหลี่ยมโดยไม่ซับซ้อนเกินสิ่งทั้งหมดหรือไม่

13 c#  xna  hexagonal-grid 

ลองนึกภาพ shoot-em-up ง่ายๆสิ่งที่เราทุกคนรู้: คุณคือผู้เล่น (สีเขียว) การเคลื่อนไหวของคุณถูก จำกัด ไว้ที่Xแกน ศัตรูของเรา (หรือศัตรู) อยู่ที่ด้านบนของหน้าจอการเคลื่อนไหวของเขายัง จำกัด อยู่ที่Xแกน ผู้เล่นยิงกระสุน (สีเหลือง) ใส่ศัตรู ฉันต้องการติดตั้ง AI สำหรับศัตรูที่ควรหลีกเลี่ยงกระสุนผู้เล่น ความคิดแรกของฉันคือการแบ่งหน้าจอเป็นส่วนที่แยกและกำหนดน้ำหนักให้กับพวกเขา: มีสองน้ำหนัก: "กระสุน - น้ำหนัก" (สีเทา) เป็นอันตรายที่กำหนดโดยกระสุน กระสุนยิ่งเข้าใกล้ศัตรูก็จะยิ่ง "กระสุน - น้ำหนัก" สูงขึ้น ( 0..1ซึ่ง 1 คืออันตรายสูงสุด) ช่องทางที่ไม่มีกระสุนมีน้ำหนักเป็น 0 น้ำหนักที่สองคือ "ระยะทาง - น้ำหนัก" (สีเขียวมะนาว) สำหรับทุกช่องทางฉันเพิ่ม0.2ค่าความเคลื่อนไหว (ค่านี้ค่อนข้างจะสุ่มเองในตอนนี้และสามารถปรับแต่งได้) จากนั้นฉันก็เพิ่มน้ำหนัก (สีขาว) และไปที่เลนด้วยน้ำหนักต่ำสุด (สีแดง) แต่วิธีการนี้มีข้อบกพร่องที่เห็นได้ชัดเพราะมันสามารถพลาด minima …

13 algorithm  ai  shoot-em-up 

ฉันพยายามหาวิธีทำให้ฉากของฉันเป็นแผนที่ลูกบาศก์ ฉันติดอยู่กับเรื่องนี้และคิดว่าฉันจะขอความช่วยเหลือจากพวกคุณ ฉันใหม่กับ OpenGL และนี่เป็นครั้งแรกที่ฉันใช้ FBO ขณะนี้ฉันมีตัวอย่างการทำงานของการใช้ไฟล์ cubemap bmp และประเภทตัวอย่าง samplerCube ใน shader ที่ต่อกับ GL_TEXTURE1 ฉันไม่ได้เปลี่ยนรหัส shader เลย ฉันแค่เปลี่ยนความจริงที่ว่าฉันจะไม่เรียกฟังก์ชันที่โหลดไฟล์ cubemap bmp และพยายามใช้โค้ดด้านล่างเพื่อแสดงผลเป็น cubemap คุณสามารถเห็นด้านล่างว่าฉันยังแนบพื้นผิวอีกครั้งกับ GL_TEXTURE1 นี่คือเมื่อฉันตั้งเครื่องแบบ: glUniform1i(getUniLoc(myProg, "Cubemap"), 1); มันสามารถเข้าถึงได้ในส่วน Shader uniform samplerCube Cubemapของฉันผ่านทาง ฉันกำลังเรียกใช้ฟังก์ชันด้านล่างดังนี้: cubeMapTexture = renderToCubeMap(150, GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE); ตอนนี้ฉันรู้แล้วในลูปการวาดด้านล่างว่าฉันไม่ได้เปลี่ยนทิศทางมุมมองเพื่อดูแกน + x, -x, + y, -y, + z, …

13 opengl  glsl  cubemap 

ฉันใช้ C # และ XNA อัลกอริทึมปัจจุบันของฉันสำหรับให้แสงสว่างเป็นวิธีเรียกซ้ำ อย่างไรก็ตามมันมีราคาแพงจนถึงจุดที่ก้อน 8x128x8 หนึ่งก้อนคำนวณทุก 5 วินาที มีวิธีการให้แสงแบบอื่นที่จะทำให้เกิดเงาแบบแปรผันได้หรือไม่? หรือวิธีการเวียนเกิดเป็นวิธีที่ดีและบางทีฉันอาจทำผิด ดูเหมือนว่าสิ่งที่เกิดขึ้นซ้ำ ๆ นั้นมีราคาแพง (ถูกบังคับให้ผ่านบล็อกประมาณ 25k ต่อก้อน) ฉันกำลังคิดเกี่ยวกับการใช้วิธีการคล้ายกับการติดตามรังสี แต่ฉันไม่รู้ว่ามันจะทำงานอย่างไร อีกสิ่งหนึ่งที่ฉันพยายามคือการจัดเก็บแหล่งกำเนิดแสงในรายการและสำหรับแต่ละบล็อกจะได้ระยะห่างจากแหล่งกำเนิดแสงแต่ละจุดและการใช้แสงนั้นไปยังระดับที่ถูกต้อง แต่แสงจะผ่านกำแพง รหัสการเรียกซ้ำปัจจุบันของฉันอยู่ด้านล่าง สิ่งนี้ถูกเรียกจากที่ใด ๆ ในก้อนที่ไม่มีระดับแสงเป็นศูนย์หลังจากการล้างและเพิ่มแสงแดดและคบไฟใหม่ world.get___atเป็นฟังก์ชั่นที่สามารถรับบล็อกด้านนอกของก้อนนี้ (นี่คือภายในชั้นเรียนชิ้น) Locationเป็นโครงสร้างของตัวเองที่คล้ายกับ a Vector3แต่ใช้จำนวนเต็มแทนค่าทศนิยม light[,,]เป็น lightmap สำหรับชิ้นข้อมูล private void recursiveLight(int x, int y, int z, byte lightLevel) { Location loc = new …

13 xna  lighting  minecraft-modding  voxels  recursion 

ปิด คำถามนี้เป็นคำถามความคิดเห็นตาม ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัปเดตคำถามเพื่อให้สามารถตอบข้อเท็จจริงและการอ้างอิงได้โดยแก้ไขโพสต์นี้ ปิดให้บริการใน6 ปีที่ผ่านมา ฉันแน่ใจว่าพวกคุณสามารถช่วยได้แน่นอน มหาวิทยาลัยบางแห่งเช่นNCSU , USC , UCSCสำหรับปริญญาโทได้เปิดสอนหลักสูตรเกี่ยวกับการพัฒนาเกมและเกม (บางคนเรียกว่า MS ในสาขาวิทยาการคอมพิวเตอร์โดยเน้นการพัฒนาเกม) ฉันสนใจมากในสาขานี้และฉันต้องการที่จะให้มันยิง แต่เนื่องจากปริญญาโทมีค่าใช้จ่ายสูงมากฉันจึงต้องคำนึงถึงโอกาสในอนาคตเช่นกัน ฉันต้องการทราบว่าหลักสูตรนี้เหมาะสมหรือไม่เมื่อพิจารณาถึงอาชีพด้วย ความคิดเห็นหรือความคิดเห็นใด ๆ ? ทุกคนที่ติดตามสายอาชีพนี้

13 game-industry  education 

ฉันต้องการทราบวิธีการรับจุดเฉพาะในเส้นรอบวงของวงกลมให้มุม เส้นผ่าศูนย์กลางของวงกลมคือ 1 { X: 0.5, Y: 0.5 }และจุดศูนย์กลางของวงกลมคือ

13 xna  c#  mathematics 

เอาล่ะฉันมีเวลายากที่จะเข้าใจว่าบัฟเฟอร์คงที่จะถูกผูกไว้กับขั้นตอนท่อและปรับปรุง ฉันเข้าใจว่า DirectX11 สามารถมีบัฟเฟอร์คงที่ได้ถึง 15 shader ต่อสเตจและแต่ละบัฟเฟอร์สามารถเก็บค่าคงที่ได้มากถึง 4096 ค่า อย่างไรก็ตามฉันไม่เข้าใจว่า ID3D11Buffer COM ที่ใช้ในการโต้ตอบกับบัฟเฟอร์คงที่เป็นเพียงกลไก (หรือที่จับ) ที่ใช้สำหรับเติมช่องบัฟเฟอร์เหล่านี้หรือถ้าวัตถุอ้างอิงตัวอย่างของข้อมูลบัฟเฟอร์ที่ถูกผลักไปมา ระหว่าง GPU และ CPU ฉันคิดว่าความสับสนของฉันในหัวข้อเป็นสาเหตุของปัญหาที่ฉันใช้บัฟเฟอร์คงที่สองแบบ นี่คือตัวอย่างโค้ด shader cbuffer PerFrame : register(b0) { float4x4 view; }; cbuffer PerObject : register(b1) { float4x4 scale; float4x4 rotation; float4x4 translation; }; วิธีการจัดระเบียบรหัสของฉันกล้องจะจัดการอัปเดตข้อมูลที่เกี่ยวข้องต่อเฟรมและ GameObjects จะอัปเดตข้อมูลต่อวัตถุของตัวเอง ทั้งสองคลาสมี ID3D11Buffer ของตัวเองที่ใช้ในการทำสิ่งนี้ (ใช้สถาปัตยกรรมฮับดังนั้นคลาส GameObject …

13 shaders  rendering  hlsl  directx11 

ฉันกำลังทำงานในเกมแรก (C ++) ของฉันและฉันต้องการใช้การออกแบบตามองค์ประกอบ ฉันอ่านมากเกี่ยวกับเรื่องนี้เมื่อเร็ว ๆ นี้และเมื่อวานนี้ฉันตัดสินใจว่าฉันต้องการเก็บข้อมูลวัตถุในไฟล์ JSON ภายนอกเพื่อให้มีความยืดหยุ่นและเข้าถึงได้ง่ายขึ้น จากนั้นก็เริ่มที่ฉันที่ทิ้งไฟล์เหล่านี้ไว้ในไดเรกทอรีต้นไม้ของเกมจะอนุญาตให้ผู้เล่นแก้ไขสิ่งที่พวกเขาต้องการได้อย่างง่ายดาย ฉันไม่ได้กังวลเกี่ยวกับการแสดงรหัสให้กับนักพัฒนาเพราะเกมจะเป็นโอเพ่นซอร์ส แต่ฉันเกรงว่านักเล่นเกมที่ไม่มีประสบการณ์อาจทำลายเกมหรืออย่างน้อยก็ทำลายความสนุก ฉันพลาดอะไรไปรึเปล่า? นโยบายเกี่ยวกับการซ่อนข้อมูลเกม (ในเกมโอเพ่นซอร์ส) คืออะไร เป็นเรื่องปกติหรือไม่ที่จะปล่อยให้ทุกคนสามารถเข้าถึงได้โดยง่าย ถ้าไม่เป็นวิธีที่ดีในการซ่อนข้อมูลคืออะไร?

13 c++  data 

เรากำลังพัฒนาเกมบน iOS ด้วยการสนับสนุนผู้เล่นหลายคน จนถึงตอนนี้ดูเหมือนว่าทุกอย่างจะดี แต่ตอนนี้เราต้องการแน่ใจว่าเซิร์ฟเวอร์สามารถรองรับลูกค้าได้ 10,000 คนหรือไม่ มีความคิดใดที่ฉันจะแน่ใจได้ว่าเซิร์ฟเวอร์จะอยู่รอดได้ในปริมาณมาก

13 server  testing 

สคริปต์คำศัพท์และการเขียนสคริปต์ดูเหมือนจะใช้แทนกันได้ใน Game Development Stack Exchange แต่นอกเหนือจากการอ่านคำถามเกี่ยวกับการเลือกภาษาสคริปต์ฉันไม่เข้าใจความสัมพันธ์ระหว่างสคริปต์และสคริปต์และภาษาหลัก โดยทั่วไปแล้วสคริปต์จะทำอะไรเมื่อจะใช้และสคริปต์ในบริบทบางอย่าง (ตามที่กำหนดโดยโปรแกรมเมอร์เกม) แตกต่างจากภาษาสคริปต์

13 scripting 

ฉันเพิ่งซื้อหนังสือ Orange (GLSL) เมื่อเร็ว ๆ นี้และฉันสงสัยว่าการอ่านหนังสือสีแดงและสีน้ำเงินเป็นสิ่งสำคัญหรือไม่ ความคิดใด ๆ

13 opengl