วิธีแก้ปัญหาการชนของวัตถุแข็งแบบ 2D

 (sassnow.ski)
3 คะแนน โดย GN⁺ 2024-05-25 | 1 ความคิดเห็น | แชร์ทาง WhatsApp
  • การ แก้ปัญหาการชนของวัตถุแข็ง ในฟิสิกส์เกม 2D คือปัญหาในการคำนวณการเปลี่ยนแปลงความเร็วเพื่อไม่ให้วัตถุที่แตะหรือซ้อนทับกันอยู่แล้วทะลุผ่านกันในเฟรมถัดไป
  • ลูปของเกมจะอัปเดตตำแหน่งจาก ความเร็ว และ Δt ในทุกเฟรม ดังนั้นหากเรขาคณิตซ้อนทับกันที่ตำแหน่งใหม่ วัตถุก็จะทะลุผ่านกันหากไม่มีการจัดการเพิ่มเติม
  • การชนไม่ใช่แค่การ สัมผัสกัน เท่านั้น แต่ต้องดูด้วยว่าวัตถุที่สัมผัสกันยังคงเคลื่อนที่เข้าหากันตามความเร็วปัจจุบันหรือไม่
  • การพิจารณาว่ากำลังเคลื่อนที่ออกจากพื้นผิวหรือไม่นั้นดูได้จากเครื่องหมายของดอตโปรดักต์ระหว่าง เวกเตอร์ปกติ (normal) กับความเร็ว โดยถ้าเป็นบวกแปลว่ามีองค์ประกอบไปในทิศเดียวกัน ถ้าเป็นลบแปลว่ามีองค์ประกอบไปในทิศตรงข้าม
  • ในกรณีของวัตถุสองชิ้น สิ่งสำคัญกว่าความเร็วของแต่ละชิ้นคือ ความเร็วสัมพัทธ์ และเวกเตอร์ปกติของการชน โดยเมื่ออยู่ในสถานะสัมผัสกันและความเร็วปกติสัมพัทธ์เป็นลบ ก็ถือว่าเป็นการชนได้

ขอบเขตของฟิสิกส์วัตถุแข็งและการแก้ปัญหาการชน

  • หัวข้อที่กล่าวถึงคือ ฟิสิกส์วัตถุแข็ง (rigid body physics) ซึ่งจัดการกับวัตถุที่ไม่เปลี่ยนรูปแม้จะได้รับแรง
    • ในโลกความจริง วัตถุทุกชนิดล้วนเปลี่ยนรูปได้ในระดับโมเลกุล ดังนั้นวัตถุแข็งสมบูรณ์จึงไม่มีอยู่จริง
    • ในการจำลองฟิสิกส์ส่วนใหญ่ การคำนวณรายละเอียดการเปลี่ยนรูปเช่นนี้ทำได้ยากมากหรือมีต้นทุนสูง
    • หากวัตถุดูสมจริงเพียงพอ การลดรูปให้เป็นวัตถุแข็งก็เป็นแนวทางที่ใช้งานได้จริง
  • การจัดการการชนในเกมเอนจินมักแบ่งเป็นสองขั้นตอน
    • การตรวจจับการชน (collision detection): ตัดสินว่าวัตถุใดในฉากกำลังชนกันอยู่
    • การแก้ปัญหาการชน (collision resolution): กำหนดสถานะหลังการชนจากทิศทางการเคลื่อนที่ ความเร็ว วัสดุ และปัจจัยอื่นของวัตถุที่ชนกัน
  • จุดเน้นในที่นี้ไม่ใช่ขั้นตอนการหาว่ามีการตัดกันทางเรขาคณิตหรือไม่ แต่เป็น การแก้ปัญหาการชน ที่ใช้กำหนดการเคลื่อนที่หลังชน

การเกิดการชนในลูปของเกม

  • เกมส่วนใหญ่จะคำนวณตำแหน่งของวัตถุในฉากซ้ำ ๆ ภายในลูปใหญ่
  • ในแต่ละรอบ ตำแหน่งของวัตถุจะถูกอัปเดตตาม ความเร็ว (velocity) ปัจจุบัน
    • ความเร็วเป็นปริมาณเวกเตอร์ที่มีทั้งขนาดและทิศทาง
    • ความยาวของลูกศรแทนความเร็วเชิงขนาด ส่วนทิศที่ลูกศรชี้แทนทิศทางการเคลื่อนที่
  • การเปลี่ยนตำแหน่งในช่วงเวลา Δt แสดงด้วย การกระจัด (displacement)
    • การกระจัดก็เป็นปริมาณเวกเตอร์ที่มีทั้งขนาดและทิศทางเช่นกัน
    • หากลูปของเกมทำงาน 60 ครั้งต่อวินาที ค่า Δt จะเท่ากับ 1/60 วินาที
  • ตำแหน่งใหม่ได้มาจากการนำการกระจัดที่คำนวณจากความเร็วปัจจุบันไปบวกกับตำแหน่งเดิม
  • หากตำแหน่งใหม่ของวัตถุสองชิ้นทำให้เรขาคณิตของทั้งคู่ซ้อนทับกัน วัตถุก็จะทะลุและผ่านกันไปหากไม่มีการจัดการเพิ่มเติม

ค่าที่การแก้ปัญหาการชนพยายามหา

  • เป้าหมายของการแก้ปัญหาการชนคือกำหนด การเปลี่ยนแปลงความเร็ว ของแต่ละวัตถุเพื่อให้วัตถุไม่ทะลุผ่านกันอีกเมื่อการจำลองดำเนินต่อไป
  • ความเร็วก่อนและหลังการชนแสดงด้วยสัญลักษณ์ต่อไปนี้
    • v_a,i, v_b,i: ความเร็วก่อนชนของวัตถุ a, b
    • v_a,f, v_b,f: ความเร็วหลังชนของวัตถุ a, b
    • Δv_a, Δv_b: การเปลี่ยนแปลงความเร็วของแต่ละวัตถุที่เกิดจากการชน
  • ท้ายที่สุดแล้ว การแก้ปัญหาการชนก็คือปัญหาในการหาค่า Δv_a และ Δv_b
  • หากต้องการให้การชนดูสมจริง การเปลี่ยนแปลงความเร็วที่เลือกต้องสอดคล้องกับกฎฟิสิกส์ที่เกี่ยวข้อง

แค่สัมผัสกันยังบอกไม่ได้ว่าเป็นการชน

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

เวกเตอร์ปกติของพื้นผิวและทิศทางที่เคลื่อนที่ออก

  • การพิจารณาว่าวัตถุกำลังเคลื่อนที่ออกจากพื้นผิวใดสามารถดูได้จาก ทิศทางเวกเตอร์ปกติ (normal direction) ของพื้นผิวนั้น
  • ทิศทางเวกเตอร์ปกติจะตั้งฉากกับพื้นผิว และชี้ไปในทิศที่ออกห่างจากพื้นผิวโดยตรง
    • สำหรับพื้นผิวเรียบ ทิศทางเวกเตอร์ปกติจะเหมือนกันทุกจุด
    • สำหรับพื้นผิวโค้ง ทิศทางเวกเตอร์ปกติจะต่างกันในแต่ละจุด
    • บนเส้นรอบวงของวงกลม ทิศทางจากจุดศูนย์กลางไปยังจุดบนเส้นรอบวงนั้นคือทิศทางเวกเตอร์ปกติ
  • ทิศทางเวกเตอร์ปกติแสดงด้วย เวกเตอร์ที่ผ่านการนอร์มัลไลซ์ ซึ่งมีความยาว 1
    • เวกเตอร์ที่มีความยาว 1 เรียกอีกอย่างว่าเวกเตอร์หนึ่งหน่วย (unit vector)
    • เพื่อแสดงว่าเป็นเวกเตอร์ที่ผ่านการนอร์มัลไลซ์แล้ว อาจใส่สัญลักษณ์ ^ ไว้เหนือชื่อตัวแปร
  • ทิศทางเวกเตอร์ปกติที่จุดใดจุดหนึ่งจะตั้งฉากกับ เส้นสัมผัส (tangent) ของพื้นผิว ณ จุดนั้น

ใช้ดอตโปรดักต์เพื่อพิจารณาองค์ประกอบของทิศทาง

  • เมื่อต้องการคำนวณว่าเวกเตอร์หนึ่งชี้ไปในทิศเดียวกับอีกเวกเตอร์มากน้อยแค่ไหน สามารถใช้ ดอตโปรดักต์ (dot product) ได้
  • สำหรับเวกเตอร์สองมิติ ดอตโปรดักต์คือผลรวมของผลคูณระหว่างองค์ประกอบที่สอดคล้องกัน และผลลัพธ์เป็น สเกลาร์ ไม่ใช่เวกเตอร์
  • ในเชิงเรขาคณิต ดอตโปรดักต์สามารถมองได้ว่าเป็นความยาวสเกลาร์ของการฉายเวกเตอร์หนึ่งไปบนอีกเวกเตอร์หนึ่ง คูณด้วยความยาวของเวกเตอร์เป้าหมายที่ใช้ฉาย
  • เครื่องหมายของดอตโปรดักต์บอกความสัมพันธ์ของทิศทางระหว่างเวกเตอร์สองตัว
    • หากมุมระหว่างเวกเตอร์ทั้งสองน้อยกว่า 90° ดอตโปรดักต์จะเป็น บวก และโดยทั่วไปถือว่าชี้ไปในทิศทางคล้ายกัน
    • หากมุมมากกว่า 90° ดอตโปรดักต์จะเป็น ลบ และโดยทั่วไปถือว่าชี้ไปในทิศตรงข้าม
    • หากมุมเท่ากับ 90° พอดี ดอตโปรดักต์จะเป็น 0
  • หากดอตโปรดักต์ระหว่างเวกเตอร์ความเร็วของวัตถุกับเวกเตอร์ปกติของพื้นผิวเป็นบวก แสดงว่าวัตถุกำลังเคลื่อนที่ออกจากพื้นผิวนั้น

การนำไปใช้กับการชนของวัตถุสองชิ้น

  • เมื่อมีวัตถุสองชิ้น เช่น กล่องสองใบ ก็จะมีเวกเตอร์ความเร็วแยกสำหรับแต่ละวัตถุ
  • ในกรณีนี้จะใช้ ความเร็วสัมพัทธ์ (relative velocity) แทนการดูความเร็วของแต่ละชิ้นแยกกัน
    • ความเร็วสัมพัทธ์คือผลต่างของความเร็วของวัตถุทั้งสอง
    • ในเชิงเรขาคณิต มันคือเวกเตอร์ที่ชี้จากปลายของ v_b ไปยังปลายของ v_a
    • ตัวอย่างเช่น หากรถสองคันชนประสานงากันโดยแต่ละคันวิ่งที่ 50km/h ภายใต้เงื่อนไขเดียวกัน จะเทียบได้กับรถคันหนึ่งพุ่งชนรถที่หยุดนิ่งด้วยความเร็ว 100km/h
  • ทิศทางที่แทนพื้นผิวในการชนแสดงด้วย เวกเตอร์ปกติของการชน (collision normal)
    • วิธีคำนวณเวกเตอร์ปกติของการชนจะแตกต่างกันตามรูปร่างหรือเรขาคณิตของวัตถุที่ชนกัน
    • ตัวอย่างในที่นี้คือ vertex-edge collision ซึ่งเป็นกรณีที่จุดหรือมุมของวัตถุหนึ่งชนกับขอบของอีกวัตถุหนึ่ง
    • ใน vertex-edge collision เวกเตอร์ปกติของการชนจะตั้งฉากกับขอบนั้น
  • ตามธรรมเนียม หากแทนวัตถุเป็น a, b เวกเตอร์ปกติของการชนจะชี้ไปทางวัตถุ a
    • จะเรียกวัตถุใดว่า a หรือ b ก็ได้ ตราบใดที่ใช้ให้สอดคล้องกันตลอดการคำนวณ

นิยามการชนด้วยความเร็วปกติสัมพัทธ์

  • หากคำนวณดอตโปรดักต์ของความเร็วสัมพัทธ์ v_ab กับเวกเตอร์ปกติของการชน n^ ก็จะตัดสินได้ว่าวัตถุทั้งสองกำลังเคลื่อนที่ในทิศทางที่ก่อให้เกิดการชนหรือไม่
  • ค่านี้เรียกว่า ความเร็วปกติสัมพัทธ์ (relative normal velocity)
    • เป็นองค์ประกอบของความเร็วสัมพัทธ์ในทิศของเวกเตอร์ปกติของการชน
    • ในที่นี้เครื่องหมายของมันสำคัญ แต่ในภายหลังก็ยังมีบทบาทสำคัญในการคำนวณแรงที่เกิดขึ้นระหว่างการชนด้วย
  • เครื่องหมายของความเร็วปกติสัมพัทธ์ใช้แยกสถานะของการชน
    • หากค่าเป็น บวก แสดงว่าวัตถุทั้งสองกำลังแยกออกจากกันอยู่แล้ว
    • หากค่าเป็น ลบ แสดงว่าวัตถุทั้งสองยังคงพุ่งเข้าชนกันอยู่
  • สรุปแล้ว การชนจะเกิดขึ้นเมื่อจุดของวัตถุหนึ่งแตะกับอีกวัตถุหนึ่ง และ ความเร็วปกติสัมพัทธ์ มีค่าเป็นลบ

บทความที่เกี่ยวข้อง

1 ความคิดเห็น

 
GN⁺ 2024-05-25
ความคิดเห็นจาก Hacker News
  • สวัสดีครับ ผมเป็นผู้เขียนบทความนี้เอง! ขอเสริมบริบทเล็กน้อยว่า บทความนี้เป็นแค่ตอนที่ 1 ของซีรีส์บล็อกเกี่ยวกับ ฟิสิกส์วัตถุแข็งเกร็ง ที่ผมตั้งใจจะเขียน
    บทความนี้มุ่งไปที่คนที่ไม่ใช่นักพัฒนาเกมและไม่มีพื้นฐานคณิตศาสตร์แข็งแรงนักเหมือนผม ดังนั้นผมจึงอธิบายแนวคิดบางอย่างที่คนมีประสบการณ์ด้านนี้อาจมองว่าแทบจะชัดเจนอยู่แล้วค่อนข้างยาว ถ้ามีคำถาม ผมยินดีตอบครับ
    • ถ้าจะให้ฟีดแบ็ก ตัวอย่างในช่วงเกริ่นนำที่ว่า “Mario เด้งออกมาจากบน Goomba…” ดูเหมือนอาจทำให้เข้าใจผิดได้เล็กน้อย เกมคลาสสิกตระกูล Super Mario บน NES และ SNES ส่วนใหญ่ไม่ได้ต้องใช้และไม่ได้ใช้การคำนวณแบบนี้เป็นส่วนใหญ่
      ผู้เริ่มต้นพัฒนาเกมมักเข้าใจผิดว่าการจัดการการชนต้องใช้ การคำนวณการชนของวัตถุแข็งเกร็ง หรือเอนจินฟิสิกส์ 2D อย่าง Box2D ถ้าคุณอยากทำเกมบิลเลียดหรือเกมที่กล่องถล่มลงมาแบบ Angry Birds ก็ใช่ แต่ถ้าเป็นแพลตฟอร์มเมอร์ 2D แค่ตรวจจับการชนด้วยการเปรียบเทียบสี่เหลี่ยมที่จัดแนวตามแกน แล้วปรับพิกัด X/Y ของตัวละครเพื่อย้อนการซ้อนทับ หรือกำหนดความเร็วแกน Y หลังจากกระโดด/ลงพื้น ก็เพียงพอแล้ว วิธีนี้ยังทำให้ปรับจูนความรู้สึกในการควบคุมตัวละครได้ละเอียดกว่า และมีแรงเฉื่อยอยู่ด้วย แต่โดยทั่วไปไม่ใช่แรงเฉื่อยที่สมจริงทางฟิสิกส์ หากมือใหม่พยายามใช้ฟิสิกส์สมจริง การเคลื่อนไหวมักจะลอย ๆ และไม่น่าพอใจ
      ตัวอย่างทิวทอเรียลที่เริ่มด้วยแนวทางง่าย ๆ แบบไม่ใช้เอนจินฟิสิกส์: https://www.love2d.org/wiki/Tutorial:Baseline_2D_Platformer
    • ดีมากครับ ส่วน “A word about math” สำคัญจริง ๆ ผมเองก็ไม่ได้เก่งคณิตศาสตร์นัก แต่เมื่อก่อนเคยลดทอนแนวคิดทางคณิตศาสตร์ให้เรียบง่ายสุด ๆ แล้วทำซิมูเลชันฟิสิกส์พื้นฐานมาก ๆ ขึ้นมา
      ผมค่อย ๆ ซ้อนองค์ประกอบอย่างจุดและเส้นขึ้นไปเรื่อย ๆ ใส่สเต็ปย่อย ๆ กับเส้นดีบักแบบมองเห็นได้ไว้เยอะมาก ผลลัพธ์เลยกระตุกและช้ามาก แต่ก็พอทำงานได้ในระดับหนึ่ง
    • บทความยอดเยี่ยมและอ่านสนุกครับ ผมก็เป็นคนที่พื้นฐานคณิตศาสตร์ไม่แข็งแรงเหมือนกัน ขอบคุณที่อธิบายแนวคิดที่ “ชัดเจนอยู่แล้ว” แบบนี้ :)
      มีแผนจะอ่านและอธิบาย XPBD (Extended Position Based Dynamics - http://mmacklin.com/xpbd.pdf) ต่อไปไหมครับ? แนวคิดนี้ดูเหมือนจะได้รับความสนใจมากขึ้นเรื่อย ๆ และผมเคยใช้ผ่าน https://github.com/Jondolf/bevy_xpbd ใน Bevy แล้วค่อนข้างประสบความสำเร็จ ดูเสถียรกว่าแนวทางทั่วไป
    • อ่านบทความนี้สนุกมากครับ :) ในฐานะคนที่เคยลำบากกับเนื้อหาคล้าย ๆ กันตอนอยู่โรงเรียน ก็เข้าใจได้ง่ายดี
      ถ้าเพิ่ม RSS feed ให้ติดตามต่อได้จะดีมากครับ
    • อธิบายได้ดีมากครับ!
      ขอถามด้วยความสงสัยว่าใช้ เครื่องมือ อะไรในการทำหน้านั้นครับ?
  • โอ้! เป็นบทความที่ค้นคว้ามาดี อธิบายลึก และยังมีปฏิสัมพันธ์ได้ด้วย
    พูดตามตรง ตอนแรกที่เห็นชื่อโดเมนแล้วรู้ว่า top-level domain เป็น “.ski” ผมนึกว่าเป็นเว็บของคนที่เขียน Mechanical Watch [1] กับบทความเจ๋ง ๆ อื่น ๆ เสียอีก ปรากฏว่าเป็นคนละคนโดยสิ้นเชิง แต่คุณภาพใกล้เคียงกันเลย ใน top-level domain “.ski” นี้มีสูตรลับอะไรอยู่หรือเปล่านะ :)
    1. https://news.ycombinator.com/item?id=31261533
    • เหตุผลง่ายมากครับ “ski” เป็นปัจจัยท้ายที่พบบ่อยที่สุดใน นามสกุลโปแลนด์ ตัวอย่างที่ดังที่สุดคือ Kowalski มีคนที่เป็นชาวโปแลนด์หรือมีเชื้อสายโปแลนด์อยู่ไม่น้อย
      ผู้เขียนของ https://ciechanow.ski ที่พวกเราชอบกันที่นี่ ก็เป็นโปรแกรมเมอร์ชาวโปแลนด์ที่ทำงานอยู่ที่ Apple
  • ตอนนี้ผมกำลังทำ เกมยิงยานอวกาศ 2D เป็นโปรเจกต์เสริมกับลูกชาย เกมเป็นมุมมองจากด้านบน โดยผู้เล่นแต่ละคนควบคุมยานบางลำ บินไปรอบ ๆ พื้นที่ปิดที่เต็มไปด้วยเศษซากอวกาศและยิงใส่กัน
    องค์ประกอบสำคัญของเกมนี้คือเศษซากอวกาศสามารถเคลื่อนที่ได้ภายในสนาม และสามารถนำมาใช้แบบสร้างสรรค์ เช่น ขังฝ่ายตรงข้ามหรือขัดขวางไม่ให้บรรลุเป้าหมายได้ ในฐานะส่วนหนึ่งของโปรเจกต์ ผมตั้งใจจะข้ามการใช้เอนจินเกมไปเลย เพราะอยากสอนโครงสร้างแอปพลิเคชันให้ลูกเพิ่มอีกหน่อย และถึงภายหลังจะใช้เอนจินเกมสำเร็จรูป อย่างน้อยก็อยากให้ได้ผ่านกระบวนการลงมือทำทุกอย่างเองสักครั้ง ทุกอย่างยังโอเคจนกระทั่งเริ่มเข้าใกล้การตรวจจับและจัดการการชน จากนั้นสถานการณ์ก็แย่ลงอย่างรวดเร็ว แม้ผมจะมีพื้นฐานคณิตศาสตร์เชิงทฤษฎี แต่ก็ถูกกรณีขอบจำนวนมหาศาลถาโถมจนรับมือไม่ไหวอย่างรวดเร็ว สุดท้ายเลยยอมแพ้และตัดสินใจใช้ Box2D ผมไม่ใช่นักพัฒนาเกมมืออาชีพ แต่มีประสบการณ์พัฒนาซอฟต์แวร์มากกว่า 20 ปีและมีพื้นฐานคณิตศาสตร์ ถึงอย่างนั้นก็ยังพลาดเพราะประเมินปัญหานี้ต่ำเกินไป พูดด้วยคำพูดดูเหมือนง่าย แต่พอลงรายละเอียด ความซับซ้อนเหมือนจะโตขึ้นแบบทวีคูณ
    • เกมนั้นจำเป็นต้องมี การชนทางฟิสิกส์ที่สมจริง จริง ๆ หรือเปล่าครับ? ถ้าไม่ ก็อาจเป็นความซับซ้อนที่ไม่จำเป็น เกมยิง 2D ก่อนปี 2000 แทบทั้งหมด และเกมหลังจากนั้นก็มีเพียงส่วนน้อยมากที่ใช้วิธีแบบนั้น
      วิธีทั่วไปในการทำเกมยิงด้วยการเปรียบเทียบสี่เหลี่ยมแบบง่ายมากอยู่ที่นี่: https://kidscancode.org/blog/2016/08/pygame_shmup_part_3/
      อย่างไรก็ตาม ถ้าวัตถุเศษซากอวกาศต้องชนและรวมกลุ่มกันอย่างสมจริง และคุณต้องการให้ยานของผู้เล่นผลักกลุ่มวัตถุหนัก ๆ ได้ยาก การใช้ไลบรารีฟิสิกส์ก็สมเหตุสมผล
    • เคยดู Verlet integration [1] ไหมครับ? มันค่อนข้างน่าเชื่อถือและใช้งานได้จริงสำหรับหลายกรณี และจริง ๆ แล้วค่อนข้างเรียบง่าย ผมแปลกใจกับตัวเองที่ทำระบบฟิสิกส์พื้นฐานขึ้นมาได้ภายในไม่กี่ชั่วโมงหลังจากดูทิวทอเรียลยอดเยี่ยมนี้ [2]
      [1]https://m.youtube.com/watch?v=lS_qeBy3aQI&pp=ygUSVmVybGV0IGl...

[2]https://m.youtube.com/watch?v=3HjO_RGIjCU&pp=ygUSdmVybGV0IGl...

  • ถึงอย่างนั้น ผมคิดว่าน่าจะเป็นบทเรียนที่ดีให้ลูกชายได้ เพราะการไล่ตามความฝันที่จะทำทุกส่วนของโปรเจกต์เองล้วน ๆ ไม่ได้คุ้มค่าเสมอไป
  • แม้จะไม่ใช่ตอนนี้ แต่ภายหลังก็น่าจะเป็นเอกสารอ้างอิงที่มีประโยชน์ http://www.jeffreythompson.org/collision-detection/table_of_... ครอบคลุมเรื่อง การตรวจจับการชน ระหว่างจุด วงกลม สี่เหลี่ยม เส้นตรง พหุภาค และสามเหลี่ยม
  • ผมชอบคำอธิบายของเกม N มาโดยตลอด: https://www.metanetsoftware.com/technique/tutorialA.html
    นั่นเป็นยุคที่ Flash มีอยู่ทุกที่
  • ผมสนุกกับการทำ เดโม TypeScript ที่มีลูกบอลเด้งและชนกันในหัวข้อนี้ ได้เรียนรู้อะไรเยอะมาก
    โค้ด: https://github.com/vandrieu/canvas-bouncing-ball
    ลอจิกการชนอยู่ใน src/collision.ts
    ผลลัพธ์/เดโม: https://vandrieu.github.io/canvas-bouncing-ball/
    • เป็นเดโมที่ดีมากจริง ๆ ทำได้ยอดเยี่ยม! ถ้าไม่ว่าอะไร ผมอยากลองเปลี่ยนมันให้เป็น เกมมัลติเพลเยอร์ เล็ก ๆ
      ถ้าเป็นไปได้ ช่วยเพิ่มไลเซนส์ให้ได้ไหม?
  • ถ้าอยากลงลึกไปถึงพลวัตของวัตถุแข็งเกร็งและเงื่อนไขจำกัดต่าง ๆ ซีรีส์บล็อกโพสต์นี้มีประโยชน์มาก: https://www.toptal.com/game/video-game-physics-part-i-an-int...
  • การชนคือการละเมิด ข้อจำกัดไม่ตัดกันแบบรายคู่ ระหว่างวัตถุ แรงชนคือ Lagrange multiplier ของข้อจำกัดนี้ เวกเตอร์ปกติของการชนคืออนุพันธ์ย่อยที่ทำให้เป็นเวกเตอร์หน่วยแล้วของฟังก์ชันข้อจำกัดเทียบกับโครงแบบของวัตถุหนึ่งชิ้น
    • วิธีแบบนั้นน่าจะเหมาะเมื่อคำนวณฟิสิกส์ที่ 1kHz ขึ้นไป และใช้อัลกอริทึมอินทิเกรชันที่เสถียรเชิงตัวเลขซึ่งเคารพการอนุรักษ์พลังงาน
      แต่ในเกม มักใช้การอัปเดตฟิสิกส์ที่บางครั้งลดลงถึง 30Hz พร้อมวิธี Euler-Cromer แบบตามอำเภอใจ จึงต้องใช้แนวทางที่ค่อนข้างต่างออกไป
    • น่าสนใจมาก! มี แหล่งข้อมูล ที่อธิบายมุมมองนี้เพิ่มเติมไหม?
  • เจ๋งมากจริง ๆ! ชอบทั้งคำอธิบาย การโต้ตอบ และโดยเฉพาะน้ำเสียงเป็นกันเองของบทความ รอติดตามบทความถัด ๆ ไปครับ
  • การสร้าง เอนจินฟิสิกส์วัตถุแข็งเกร็ง 2D เป็นโปรเจกต์ที่สนุกมากจริง ๆ ผมเคยทำขึ้นมาด้วย JavaScript ก่อนจะเรียนพีชคณิตเชิงเส้น และต้องขุดคณิตศาสตร์ลงไปลึกมากเพื่อให้มันทำงานได้
    ผมใช้เวลาหลายเดือน แต่ก็เหมือนเพิ่งขูดผิวของสิ่งที่เกินพื้นฐานที่เป็นที่รู้จักกันไปนิดเดียว การสร้างเอนจินที่เสถียรซึ่งวัตถุไม่กดทะลุกันหรือสั่นเป็นโพรงกระต่ายที่ไม่มีที่สิ้นสุด และบทความที่เน้นคณิตศาสตร์หนัก ๆ ที่ผมหาได้ก็แทบไม่ได้แตะเรื่องนี้ ผมทำความเข้าใจคณิตศาสตร์จากซีรีส์บทความเก่าของ Christ Hecker
    http://www.chrishecker.com/Rigid_Body_Dynamics
    • ใช่เลย! “Part 3: Collision Response” คือเนื้อหาที่บทความเหล่านี้ใช้เป็นแหล่งอ้างอิงอยู่จริง ๆ
  • ผมเริ่มจาก canvas เพื่อเรียน JavaScript และสร้างเกมเบราว์เซอร์เล็ก ๆ น่ารักขึ้นมาหลายเกมโดยไม่มีประสบการณ์พัฒนาเกมมาก่อน หนึ่งในนั้นเป็นโคลน Galaga ซึ่งโดยรวมทำงานได้ดี
    ส่วนที่ยากคือ การชนของโพรเจกไทล์ ผมควรจะเอาตำแหน่งปัจจุบันของกระสุนกับตำแหน่งใน time step ถัดไป แล้วดู hitbox ของศัตรูในลักษณะเดียวกันเพื่อตรวจว่าตัดกันหรือไม่ แต่ผมตรวจแค่ time step ปัจจุบันเท่านั้น ดังนั้นกระสุนจึงอาจพุ่งผ่านศัตรูไปได้อย่างกับมีเวทมนตร์! เรื่องงี่เง่าจริง ๆ สักวันหนึ่งผมอาจกลับไปแก้ก็ได้