คำถามติดแท็ก algorithm

ในเกม 2D ที่ฉันทำงานด้วยเอ็นจิ้นเกมสามารถให้ฉันสำหรับแต่ละหน่วยรายการของหน่วยอื่น ๆ ที่อยู่ในระยะการมองของมัน ฉันอยากจะรู้ว่ามีอัลกอริทึมที่จัดตั้งขึ้นเพื่อเรียงลำดับหน่วยในกลุ่มที่แต่ละกลุ่มจะถูกกำหนดโดยหน่วยเหล่านั้นทั้งหมดที่ "เชื่อมต่อ" กับแต่ละอื่น ๆ (แม้จะผ่านคนอื่น ๆ ) ตัวอย่างอาจช่วยให้เข้าใจคำถามได้ดีขึ้น (E = ศัตรู, O = หน่วยของตัวเอง) ก่อนอื่นข้อมูลที่ฉันจะได้รับจากเอ็นจิ้นเกม: E1 can see E2, E3, O5 E2 can see E1 E3 can see E1 E4 can see O5 E5 can see O2 E6 can see E7, O9, O1 E7 can …

12 algorithm 

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

12 algorithm  procedural-generation 

จากภาพด้านล่างฉันต้องตรวจจับลำดับที่เหมาะสมที่สุดบนกระดาน (เส้นสีเขียว) เส้นสีน้ำเงิน / แดงแสดงได้ แต่ไม่ใช่การเคลื่อนไหวที่ดีที่สุด นี่คือกฎ: คุณสามารถย้ายไปที่ไทล์ใด ๆ ที่เหมือนกันและเป็นเพื่อนบ้านของคุณ (เส้นทแยงมุมใช้ได้) เมื่อคุณเยี่ยมชมไทล์แล้วคุณจะไม่สามารถเยี่ยมชมไทล์ได้อีก ฉันคิดเกี่ยวกับการวนลูปผ่านแต่ละโหนดและมองไปที่เพื่อนบ้านแล้วจึงวนซ้ำ เมื่อฉันพบความเคลื่อนไหวที่เป็นไปได้ฉันสามารถใส่มันลงในโครงสร้าง เมื่อพบการเคลื่อนไหวที่เป็นไปได้ทั้งหมดฉันจะเลือกการเคลื่อนที่ที่มีจำนวนโหนดมากที่สุด มันจะยากขึ้นเมื่อโหนดมีเพื่อนบ้านมากกว่าหนึ่งที่ตรงกัน ดังนั้นมีอัลกอริทึมที่ฉันสามารถใช้ได้หรือไม่? ฉันกำลังคิดว่าจะเติมน้ำท่วม แต่ก็ไม่เป็นไปตามกฎ # 2 ตามที่ร้องขอนี่คือวิดีโอของการเล่นเกมที่คล้ายกัน http://youtube.com/watch?v=eumnCTG0AE8

12 algorithm 

ในต้นแบบที่ฉันทำมี minigame คล้ายกับ bejeweled การใช้กริดที่เป็นอาร์เรย์ 2 มิติ ( int[,]) ฉันจะรู้ได้อย่างไรเมื่อผู้ใช้เริ่มการแข่งขัน? ฉันสนใจแค่แนวนอนและแนวตั้งเท่านั้น จากด้านบนของหัวฉันคิดว่าฉันจะมองแต่ละทิศทาง สิ่งที่ต้องการ: int item = grid[x,y]; if(grid[x-1,y]==item) { int step=x; int matches =2; while(grid[step-1,y]==item) { step++; matches++ } if(matches>2) //remove all matching items } else if(grid[x+1,y]==item //.... else if(grid[x,y-1==item) //... else if(grid[x,y+1]==item) //... ดูเหมือนว่าควรจะมีวิธีที่ดีกว่า มีอะไรบ้าง

12 algorithm  game-mechanics 

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

12 2d  c#  algorithm  graphics-programming  particles 

อัลกอริธึมทางทฤษฎีกราฟเส้นทางที่สั้นที่สุดที่น่านับถือ A * และการปรับปรุงในภายหลัง สำหรับฉันแล้วดูเหมือนว่า RL เป็นกระบวนทัศน์ที่เป็นธรรมชาติมากขึ้นในการย้ายตัวละครไปรอบ ๆ พื้นที่เกม และถึงกระนั้นฉันก็ยังไม่ทราบว่าเป็นนักพัฒนาเกมเดียวที่ใช้เครื่องมือสร้างเส้นทางการเรียนรู้แบบ Reinforcement Learning (ฉันไม่ได้อนุมานได้เลยว่าแอปพลิเคชัน RL ในการค้นหาเส้นทางคือ 0 เพียงว่ามันมีขนาดเล็กมากเมื่อเทียบกับ A * และเพื่อน ๆ ) ไม่ว่าจะด้วยเหตุผลใดก็ตามไม่ใช่เพราะนักพัฒนาซอฟต์แวร์เหล่านี้ไม่รู้จัก RL เนื่องจากหลักฐานจากข้อเท็จจริงที่ว่า RL ถูกใช้บ่อยในที่อื่น ๆ ในเอ็นจิ้นเกม คำถามนี้ไม่ใช่ข้ออ้างสำหรับการเสนอความคิดเห็นเกี่ยวกับ RL ในการชี้แนะทาง ในความเป็นจริงฉันสมมติว่าการตั้งค่าโดยปริยายสำหรับ A * et al มากกว่า RL นั้นถูกต้อง - แต่การตั้งค่านั้นไม่ชัดเจนสำหรับฉันและฉันอยากรู้อยากเห็นมากเกี่ยวกับเหตุผลของมันโดยเฉพาะอย่างยิ่งจากทุกคนที่พยายามใช้ RL เพื่อหาเส้นทาง

12 algorithm  path-finding 

การทำงานกับ Wii ฉันมักพบว่าจำเป็นต้องจดจำท่าทางที่เรียบง่ายจนถึงตอนนี้ฉันสามารถดูขนาดของการเร่งความเร็วเพื่อรับรู้ท่าทางที่เรียกออกมาในเอกสารการออกแบบเกมของเราได้ แต่ฉันต้องการสร้าง ระบบที่แข็งแกร่งยิ่งขึ้นซึ่งอนุญาตให้ "บันทึก" ตัวอย่างท่าทางและการรับรู้ท่าทางสัมผัสที่ซับซ้อน คุณเคยใช้กลยุทธ์อะไรบ้างในอดีต? พวกเขาทำงานทำไม ทำไมพวกเขาไม่ทำงาน คุณจะทำอะไรที่แตกต่าง

12 algorithm  motion-control 

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

11 physics  algorithm  voxels  simulations 

ฉันได้ยินมาว่าคุณสามารถคำนวณเวลาเดลต้าด้วยฟังก์ชันสองอย่างที่เรียกว่า SDL_GetPerformanceCounter และ SDL_GetPerformanceFrequency ฉันไม่แน่ใจว่าทำงานได้อย่างไร แต่ฉันได้ยินมาว่ามันคล้ายกับการใช้ SDL_GetTicks () Uint64 NOW, LAST; double deltaTime = 0; while (somebool) { LAST = SDL_GetPerformanceCounter(); NOW = SDL_GetPerformanceCounter(); LAST = NOW; deltaTime = (NOW - LAST) / (double)SDL_GetPerformanceFrequency(); /**Rendering**/ } ฉันมีรหัสนี้ แต่เมื่อใดก็ตามที่ฉันพิมพ์ deltaTime หรือพยายามใช้มันจะเท่ากับตัวเลขสุ่มและตัวเลขบ้าเสมอ ถูกต้องหรือไม่

11 c++  algorithm  sdl 

ฉันต้องการวิธีการแบ่งพื้นที่ 3 มิติเป็นรูปร่างกล่องที่จัดแนวแกนแบบสุ่ม ตอนนี้ฉันกำลังแบ่งพื้นที่ 2d สำหรับการทดสอบ วิธีที่ฉับพลันที่สุดที่ฉันคิดขึ้นมาคือการกำหนดขนาดสี่เหลี่ยมผืนผ้า (1, 1) แล้วแบ่งสี่เหลี่ยมที่มีอยู่ทั้งหมดกลับเป็นรูปสี่เหลี่ยมผืนผ้าไม่สม่ำเสมอสองอันสลับกันระหว่างแกน X และ Y ปัญหาที่นี่ชัดเจน วิธีการนี้ส่งผลให้เส้นยืดยาว (ทำเครื่องหมายด้วยสีแดง) สิ่งที่ฉันต้องการคือสิ่งที่ดูเป็นธรรมชาติมากขึ้น (ฉันรวมตัวอย่าง) ดูไม่มีเส้นตรงยาวจากบนลงล่างหรือจากซ้ายไปขวา ข้อ จำกัด เพียงอย่างเดียวคือฉันอาจต้องการ จำกัด ขนาดที่เล็กที่สุดของสี่เหลี่ยมผืนผ้าโดยไม่กระทบกับความละเอียดของขนาด นั่นคือถ้าส่วนที่เล็กที่สุดคือ 1 ตารางเซนติเมตรกว่าห้องที่เล็กที่สุดของวินาทีไม่ควรเป็น 2 ตารางหน่วย ดังนั้นขั้นตอนวิธีควรเป็นไปตามข้อ จำกัด ทั้งสามดังต่อไปนี้: รูปสี่เหลี่ยมผืนผ้ามีขนาดเล็กไม่เล็ก ขนาดของรูปสี่เหลี่ยมไม่ได้เป็นการคูณแบบแยกขนาดที่เล็กที่สุด เช่นถ้า rect ที่เล็กที่สุดคือ 3 square unit มากกว่า rects ที่ใหญ่กว่าจะไม่ถูก จำกัด ให้เป็น 6, 9, 12 และอื่น ๆ …

11 algorithm  procedural-generation  random  space-partitioning 

สำหรับสัปดาห์ที่แล้วฉันได้ทำงานกับระบบสินค้าคงคลังด้วย Unity3D ตอนแรกฉันได้รับความช่วยเหลือจากพวกที่ Design3 แต่มันก็ไม่นานจนเราแยกทางกันเพราะฉันไม่ชอบวิธีที่พวกเขาใช้รหัสพวกเขาไม่มีกลิ่นของ OOP ใด ๆ ฉันทำตามขั้นตอนต่อไป - รายการใช้มากกว่าหนึ่งช่องระบบการจัดวางขั้นสูง (รายการพยายามอย่างดีที่สุดเพื่อหาสิ่งที่เหมาะสมที่สุด) ระบบเมาส์ในตัวเครื่อง (เมาส์ถูกขังอยู่ในพื้นที่ใช้งานกระเป๋า) ฯลฯ นี่คือตัวอย่างการทำงานของฉัน สิ่งที่เราต้องการมีในเกมของเราคือคุณลักษณะการจัดระเบียบอัตโนมัติ - ไม่ใช่การจัดเรียงอัตโนมัติ เราต้องการคุณสมบัตินี้เนื่องจากคลังของเราจะเป็น 'เรียลไทม์' - ไม่เหมือนใน Resident Evil 1,2,3 ฯลฯ ที่คุณจะหยุดเกมชั่วคราวและทำสิ่งต่างๆในคลังของคุณ ทีนี้ลองนึกภาพตัวคุณเองในสถานการณ์ที่ถูกล้อมรอบไปด้วยซอมบี้และคุณไม่มีกระสุนคุณมองไปรอบ ๆ คุณเห็นว่ามีกระสุนอยู่ในพื้นดินดังนั้นคุณจึงไปหาพวกเขาและพยายามเลือกพวกเขา แต่พวกเขาไม่ พอดี! คุณดูสินค้าคงคลังของคุณและพบว่าหากคุณจัดระเบียบบางรายการใหม่มันจะพอดี! - ตอนนี้ผู้เล่น - ในสถานการณ์นั้นไม่มีเวลาที่จะจัดระเบียบใหม่เพราะเขาล้อมรอบด้วยซอมบี้และจะตายถ้าเขาหยุดและจัดระเบียบสินค้าคงคลังเพื่อให้มีพื้นที่ (จำสินค้าคงคลังในแบบเรียลไทม์ไม่หยุดชั่วคราว) - จะไม่ มันจะดีสำหรับการที่จะเกิดขึ้นโดยอัตโนมัติ? - ใช่! (ฉันเชื่อว่าสิ่งนี้ได้ถูกนำไปใช้ในบางเกมเช่น Dungeon siege หรืออะไรบางอย่างเพื่อให้แน่ใจว่าทำได้) ลองดูตัวอย่างนี้: ใช่ดังนั้นหากคุณจัดเรียงปัญหาโดยอัตโนมัติคุณจะได้รับช่องว่างของคุณ …

11 algorithm  unity  inventory 

ฉันกำลังมองหาอัลกอริทึมที่ดีสำหรับปัญหาต่อไปนี้: กำหนดตาราง voxels แบบ 3 มิติ (ซึ่งอาจว่างเปล่าหรือเติมเต็ม) ถ้าฉันเลือก voxels ที่ไม่ติดกันสองตัวฉันต้องการทราบว่าพวกมันเชื่อมต่อกันด้วยหรือไม่ voxels อื่น ๆ ตัวอย่างเช่น (เพื่อแสดงให้เห็นถึงสถานการณ์ใน 2D) โดยที่ # เป็นสี่เหลี่ยมจัตุรัสที่กรอก: 1 2 3 a # # # b # # c # # # หากฉันเลือก a3 และ c3 ฉันต้องการตรวจสอบโดยเร็วที่สุดหากพวกเขาเชื่อมต่ออยู่ หากมีเส้นทางระหว่าง a3 และ c3 ถึงพิกเซลที่เติม (สถานการณ์จริงอยู่ในตาราง voxel 3D แน่นอน) ฉันดูอัลกอริธึมเติมน้ำท่วมและค้นหาอัลกอริธึมเส้นทาง แต่ฉันไม่แน่ใจว่าจะเลือกแบบใด ทั้งสองทำงานที่ไม่จำเป็น: …

11 3d  algorithm  path-finding  voxels 

ฉันเพิ่งได้รับอนุญาตให้ใช้รูป ... ภาพด้านล่างจากเกมของฉันแสดงบล็อกมืดบางส่วนซึ่งได้รับการยอมรับว่าเป็นส่วนหนึ่งของรูปร่าง "T" ตามที่เห็นรหัสได้ทำให้บล็อกมืดลงด้วยจุดสีแดงและไม่เห็นรูปร่าง "T" ที่มีเส้นขอบสีเขียว รหัสของฉันวนซ้ำผ่าน x / y ทำเครื่องหมายบล็อกที่ใช้หมุนรูปร่างทำซ้ำเปลี่ยนสีทำซ้ำ ฉันเริ่มพยายามแก้ไขการตรวจสอบนี้ด้วยความกังวลใจมาก แนวคิดปัจจุบันคือ: วนรอบตารางและจดบันทึกรูปแบบที่เกิดขึ้นทั้งหมด (ไม่ทำเครื่องหมายบล็อกตามที่ใช้) และวางสิ่งเหล่านี้ลงในอาร์เรย์ วนซ้ำผ่านกริดอีกครั้งคราวนี้สังเกตว่าบล็อกใดถูกครอบครองโดยรูปแบบใดและด้วยเหตุใดจึงมีหลายรูปแบบ วนลูปผ่านกริดอีกครั้งคราวนี้สังเกตว่ารูปแบบใดขัดขวางรูปแบบใด รู้สึกอย่างนั้น ... ฉันจะทำยังไงดี? ฉันคิดว่าฉันจะต้อง ลองผสมผสานรูปร่างที่ขัดแย้งกันหลายแบบเริ่มต้นด้วยสิ่งกีดขวางรูปแบบส่วนใหญ่ก่อน ฉันจะเข้าใกล้คนนี้ได้อย่างไร ใช้เหตุผลที่บอกว่าฉันมี 3 รูปร่างที่ขัดแย้งกันครอบครอง 8 บล็อกและรูปร่างเป็น 4 บล็อกต่อหนึ่งดังนั้นฉันจึงสามารถมีได้สูงสุดสองรูปร่าง (ฉันยังต้องการรวมรูปร่างอื่น ๆ และอาจมีการให้คะแนนน้ำหนักซึ่งจะต้องพิจารณาเมื่อผ่านรูปร่างที่ขัดแย้งกัน แต่อาจเป็นอีกวัน) ฉันไม่คิดว่ามันเป็นปัญหาการจัดเก็บขยะ แต่ฉันไม่แน่ใจว่าจะหาอะไร หวังว่าจะทำให้รู้สึกขอบคุณสำหรับความช่วยเหลือของคุณ แก้ไขแม้จะมีความชัดเจนของคำถามทุกคนดูเหมือนจะเข้าใจใช่ ฉันต้องการค้นหารูปร่าง "T" สูงสุดภายในแต่ละสี (เพราะถ้าฉันให้คะแนนสองและคุณได้สามคุณจะรำคาญเล็กน้อย)

11 algorithm  grid  puzzle  patterns 

ฉันใช้อัลกอริทึม Diamond-Square ตามบทความนี้: http://www.lighthouse3d.com/opengl/terrain/index.php?mpd2 ปัญหาคือฉันได้หน้าผาที่สูงชันเหล่านี้ไปทั่วแผนที่ มันเกิดขึ้นที่ขอบเมื่อภูมิประเทศถูกแบ่งย่อยซ้ำแล้วซ้ำอีก: นี่คือแหล่งที่มา: void DiamondSquare(unsigned x1,unsigned y1,unsigned x2,unsigned y2,float range) { int c1 = (int)x2 - (int)x1; int c2 = (int)y2 - (int)y1; unsigned hx = (x2 - x1)/2; unsigned hy = (y2 - y1)/2; if((c1 <= 1) || (c2 <= 1)) return; // Diamond stage …

11 algorithm  procedural-generation  terrain 

ฉันมีเกมที่ต้องการให้ผู้เล่นแต่ละคนเคลื่อนที่ตามเส้นทางที่ระบุ ฉันวาดเส้นทางโดยใช้เส้นโค้งเบซิเยร์ ฉันจะกำหนดความยาวรวมของจริง (ไม่ใช่แบบเส้นตรง) ของเส้นทางและระยะทางที่ผู้เล่นแต่ละคนทำไว้ได้อย่างไร (ระยะห่างระหว่างจุดเริ่มต้นและจุดที่ระบุบนเส้นทาง) UPDATE: พา ธ ถูกแสดงในระนาบคาร์ทีเซียน (2D)

11 algorithm  geometry  splines