คณิตศาสตร์ในเกม: Collision Detection และ Hitbox คืออะไร

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

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

ระบบชนกันในเกมคืออะไร? (Collision Detection)

ในโลกแห่งความเป็นจริง ถ้าคุณเดินไปชนกำแพง คุณจะหยุด เพราะกฎของฟิสิกส์ แต่ในโลกของเกม ตัวละครและวัตถุทุกอย่างถูกสร้างขึ้นจากจุด (Vertices) และพื้นผิว (Polygons) ที่คอมพิวเตอร์คำนวณพิกัด X, Y, Z อย่างต่อเนื่อง

Collision Detection หรือระบบตรวจจับการชนกัน คือกระบวนการทางคณิตศาสตร์ที่เอนจินเกมใช้ตรวจสอบว่าวัตถุสองชิ้นกำลังเข้ามาแชร์พื้นที่เดียวกันในจักรวาลของเกมหรือไม่ ถ้าหากว่ามีการซ้อนทับกัน เอนจินก็จะสั่งการให้เกิดเหตุการณ์ตามที่โปรแกรมเมอร์กำหนด เช่น เสียงดัง 'ตุ๊ก!', ลดพลังชีวิต (HP), หรือการเด้งสะท้อนกลับ

ถ้าไม่มีระบบนี้ ตัวละครเราก็จะเดินทะลุกำแพง ลอยขึ้นฟ้า หรือฟันดาบทะลุผ่านตัวบอสไปได้ง่ายๆ เกมก็จะไม่ต่างจากหนังฝรั่งที่เสียการเชื่อมโยงทางตรรกะ

การคำนวณแบบ AABB กับ Circle Collision

ในการทำ Collision Detection การจะให้คอมพิวเตอร์ไปคำนวณพิกัดทุกจุดของโมเดล 3 มิติหรือสไปรต์ 2 มิติที่ซับซ้อนทุกเฟรมนั้น กินทรัพยากรเครื่องมากเกินไป นักพัฒนาเกมจึงใช้คณิตศาสตร์ในเกมเพื่อสร้าง 'รูปทรงจำลอง' (Bounding Volume) คลุมตัวละครไว้ก่อน เพื่อตรวจสอบอย่างรวดเร็ว โดยที่นิยมที่สุดมี 2 แบบ คือ

1. AABB (Axis-Aligned Bounding Box)

AABB คือการห่อตัวละครด้วยกล่องสี่เหลี่ยมผืนผ้าที่ไม่หมุนตามตัวละคร (ขอบขนานกับแกน X และ Y เสมอ) การคำนวณทางคณิตศาสตร์นั้นง่ายมาก เพราะเราแค่เช็คดูว่ากล่องสองใบมีการซ้อนทับกันหรือไม่

สูตรคือ: กล่อง A และกล่อง B จะชนกันก็ต่อเมื่อ

ขอบซ้ายของ A น้อยกว่าขอบขวาของ B และ
ขอบขวาของ A มากกว่าขอบซ้ายของ B และ
ขอบบนของ A มากกว่าขอบล่างของ B และ
ขอบล่างของ A น้อยกว่าขอบบนของ B

วิธีนี้เร็วมาก แต่มีจุดอ่อนคือ ถ้าตัวละครเป็นรูปทรงกลมหรือรูปร่างเพรียวบาง เมื่อหมุนตัว กล่อง AABB จะกินพื้นที่ว่างเปล่าเยอะ ทำให้เกิดอาการ 'โดนโดยที่ไม่ควรโดน' เพราะขอบของกล่องไปโดนศัตรู ทั้งที่ตัวจริงยังไม่ถึง

2. Circle Collision (การชนกันแบบวงกลม)

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

สูตรระยะทาง (Distance) = √((x2 - x1)² + (y2 - y1)²) ถ้า Distance <= (Radius_A + Radius_B) แปลว่าเกิดการชน

วิธีนี้ให้ความแม่นยำที่ดีขึ้นสำหรับวัตถุกลม และไม่ต้องกังวลเรื่องการหมุนตัว เพราะวงกลมหมุนยังไงก็เหมือนเดิม

Hitbox คืออะไร? การกำหนดให้แม่นยำในเกม Action

เมื่อพูดถึงเกมต่อสู้หรือเกมแอคชั่นอย่าง xGame คำถามที่นักพัฒนามือใหม่มักสงสัยคือ Hitbox คืออะไร?

Hitbox คือกล่องหรือรูปทรงจำลองที่ซ่อนอยู่ในตัวละคร ใช้สำหรับตรวจสอบการชนกันโดยเฉพาะ โดยเราสามารถแบ่งได้เป็น 2 ประเภทหลักที่ทำงานคู่กันเสมอ:

Hitbox: พื้นที่การโจมตี เช่น ใบดาบ ปลายกระสุน หรือหมัด เมื่อ Hitbox นี้เคลื่อนที่เข้าหาศัตรู ระบบจะเช็คว่ามันชนกับพื้นที่รับผลกระทบของฝั่งตรงข้ามหรือไม่
Hurtbox: พื้นที่รับความเสียหาย มักจะอยู่ที่ตัวของตัวละคร ถ้า Hurtbox ของเราไปโดน Hitbox ของศัตรู เราก็จะเสียเลือด

การกำหนด Hitbox ให้แม่นยำคือศาสตร์อย่างหนึ่ง ถ้ากล่องใหญ่เกินไป เกมจะง่ายจนไม่สนุก (ฟันอากาศก็โดน) แต่ถ้าเล็กเกินไป เกมจะยากจนน่าหงุดหงิด (ฟันโดนติดเสื้อผ้าแต่ไม่เกิดดาเมจ)

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

ตัวอย่างโค้ดเบื้องต้น

เรามาดูโค้ดจริงกันครับ สมมติว่าเราเขียนเกมด้วย Python และต้องการเช็ค Collision Detection แบบ AABB ระหว่างตัวละครผู้เล่นกับศัตรู โค้ดจะหน้าตาประมาณนี้

class Box:
    def __init__(self, x, y, width, height):
        self.x = x
        self.y = y
        self.width = width
        self.height = height

    @property
    def left(self):
        return self.x

    @property
    def right(self):
        return self.x + self.width

    @property
    def top(self):
        return self.y

    @property
    def bottom(self):
        return self.y + self.height

def check_aabb_collision(box1, box2):
    # เช็คเงื่อนไขการชนกันแบบ AABB
    if box1.left < box2.right and box1.right > box2.left and \
       box1.top < box2.bottom and box1.bottom > box2.top:
        return True
    return False

# สมมติว่าผู้เล่นฟันดาบ สร้าง Hitbox ขึ้นมา
player_hitbox = Box(100, 50, 40, 40)
# ศัตรูยืนอยู่ใกล้ๆ มี Hurtbox
enemy_hurtbox = Box(130, 60, 30, 30)

if check_aabb_collision(player_hitbox, enemy_hurtbox):
    print("ศัตรูโดนโจมตี! ลด HP ไป 10")
else:
    print("ฟาดพลาด!")

สังเกตได้ว่าโค้ดนั้นไม่ซับซ้อนอย่างที่คิด แต่มันคือหัวใจสำคัญที่ขับเคลื่อนเกมแอคชั่นทุกเกมบนโลก การปรับค่า width และ height แค่ 2-3 พิกเซล ก็อาจจะเปลี่ยนความรู้สึกของเกมจาก 'กระบอง' ไปเป็น 'ดาบคมบาดแผล' ได้

สรุป

คณิตศาสตร์ในเกมไม่ใช่เรื่องของตัวเลขที่น่าเบื่อ แต่มันคือเส้นเลือดที่ทำให้โลกเสมือนจริงมีชีวิตชีวา การเข้าใจหลักการของ Collision Detection และรู้ว่า Hitbox คืออะไร จะช่วยให้คุณเล่นเกมได้อย่างเข้าใจมุมมองของคนทำเกมมากขึ้น หรือถ้าคุณกำลังฝึกเขียนเกมของตัวเอง สิ่งเหล่านี้คือพื้นฐานที่คุณต้องฝึกฝน

ลองนึกภาพเกมโปรดของคุณสิครับ คิดว่าทีมงานเขากำหนดขนาดของ Hitbox ไว้เท่าไหร่? ครั้งต่อไปที่คุณเล่นเกมแล้วรอดจากท่าไม้ตายบอสมาได้อย่างหวุดหวิด อย่าลืมขอบคุณคณิตศาสตร์และนักพัฒนาที่ตั้งค่าพิกัดพวกนี้ไว้อย่างแม่นยำ

คุณล่ะครับ เคยเจอเกมไหนที่ระบบการชน (Hitbox) แม่นยำจนน่าทึ่ง หรือเพี้ยนจนน่าหงุดหงิดบ้างไหม? มาแชร์กันได้ในคอมเมนต์เลย!