จะใช้เวลาเดินทางเข้าเกมอย่างไร?

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

ฉันค้นหาในเว็บเป็นจำนวนมาก แต่โดยทั่วไปแล้วผลลัพธ์ของฉันจะเรียกว่าใช้เวลาเหมือนกับ "มันคือ 3:00" หรือมีการจับเวลา

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

ขอบคุณล่วงหน้า!

แนวคิดของอาเรย์นั้นค่อนข้างจะนำไปใช้ใน Braid ได้อย่างไร เมื่อสิ่งเดียวที่ทำหน้าที่เกี่ยวกับตัวละครคือแรงดึงดูดอินพุตคีย์บอร์ด / จอยแพดและตัวละครอื่น ๆ คุณต้องเก็บตำแหน่งและความเร็วในแต่ละขั้นตอนเพื่อที่จะได้รู้ทุกสิ่งที่สำคัญเกี่ยวกับตัวละครนั้น หากคุณเก็บ 10 snapshots ต่อวินาทีต่อตัวอักษรก็ยังน้อยกว่า 50K สำหรับหนึ่งนาทีของตัวละครตัวหนึ่ง - จัดการได้ง่ายในระบบส่วนใหญ่และคุณสามารถหาวิธีที่มีประสิทธิภาพมากกว่านั้น

อ่านข้อมูลเกี่ยวกับรูปแบบคำสั่ง มันมีไว้สำหรับการเลิกการกระทำ (และการทำใหม่ในภายหลัง) ซึ่งจะจัดการได้มากกว่าตำแหน่งของเรือ แต่การกระทำทั้งหมดที่ผู้เล่นทำ

แต่ฉันคิดว่าความคิดของคุณอาเรย์เป็นเสียงเช่นกัน

แทนที่จะมีสองอาร์เรย์แยกกันคุณน่าจะมีหนึ่งคลาสที่อธิบายตำแหน่งของผู้เล่น (อาจมีคลาสพอยต์ใน Java อยู่แล้ว ... ฉันเป็นผู้ชาย C # เมื่อเร็ว ๆ นี้) และใช้อาร์เรย์เดียวเพื่อดำรงตำแหน่งที่ผ่านมา

คุณต้องตั้งค่า "ring buffer" ซึ่งหมายความว่าเมื่อคุณไปยังจุดสิ้นสุดของอาร์เรย์คุณจะวนกลับไปที่จุดเริ่มต้นของอาร์เรย์เขียนทับรายการที่เก่าที่สุด หากคุณย้อนเวลากลับไปสิ่งตรงกันข้ามก็เป็นจริง (เมื่อคุณไปถึงจุดเริ่มต้น

หากคุณต้องการเก็บข้อมูลที่ผ่านมา 30 วินาทีคุณจำเป็นต้องรู้อัตราเฟรมของคุณหากคุณต้องการจัดสรรพื้นที่ล่วงหน้าและใช้อาร์เรย์ขนาดคงที่ หากคุณแสดงผลเกมที่ 10 เฟรม / วินาทีคูณ 30 วินาทีนั่นคือ 300 องค์ประกอบ

GDCVaultมีการบรรยายโดย Jon Blow (ผู้สร้างBraid ) บนไซต์ของพวกเขาที่ชื่อว่าThe Implementation of Rewind in Braid ในราคา $ 3.95 ฉันจะเดิมพันว่ามีข้อมูลที่คุณต้องการ;)

แก้ไข: อาจจะไม่ได้อยู่ใน Java แต่ความคิดควรถือ

เช่นเดียวกับErik J ที่กล่าวว่าการเก็บตำแหน่งที่ผ่านมาของผู้เล่นเป็นการรวบรวมวัตถุจุดในเสียงเรียกเข้าแบบบัฟเฟอร์

อย่างไรก็ตามฉันขอแนะนำให้ใช้คิวเพื่อใช้บัฟเฟอร์ การอัปเดตถูกกว่าอาร์เรย์มากและคุณไม่จำเป็นต้องรู้อัตราเฟรมล่วงหน้า:

update():
   time_queue.push(player.positions)
   if current_time() - start_time > n:
       queue.pop()

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

update():
    time_queue.push({
        'pos': player.positions,
        'time': current_time()
    })
    first_entry = queue.peek()
    while current_time() - first_entry['time'] > n:
       queue.pop()
       first_entry = queue.peek()

หวังว่านี่จะช่วยได้!

มีรูปแบบการออกแบบที่เรียกว่าMementoฉันคิดว่ามันเป็นจุดเริ่มต้นสำหรับเกมอย่าง Braid

รูปแบบของที่ระลึกเป็นรูปแบบการออกแบบซอฟต์แวร์ที่ให้ความสามารถในการเรียกคืน> วัตถุไปสู่สถานะก่อนหน้า (ยกเลิกการย้อนกลับผ่าน)

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

http://en.wikipedia.org/wiki/Memento_pattern

ข้อมูล Adcional ที่นี่: http://dofactory.com/Patterns/PatternMemento.aspx

มีเกมวางจำหน่ายสำหรับ XBox360 ที่เกี่ยวข้องกับการย่นเวลา มันธรรมดาดังนั้นฉันจำชื่อตอนนี้ไม่ได้ อย่างไรก็ตามในการสัมภาษณ์กับนักพัฒนาซอฟต์แวร์พวกเขาได้อธิบายวิธีจัดการเวลา:

เฟรม X ทุกตัว (ที่มีค่า X ต่ำกว่านำไปสู่การปรับแต่งที่ละเอียดยิ่งขึ้น) คุณจะได้ "snapshot" ของ gameworld ณ จุดนั้นและเชื่อมโยงกับเวลาในเกม

ในขณะที่เล่นเกมโดยปกติการส่งต่อเวลาปฏิกิริยาที่ป้อนเข้าทุกครั้งจะมีส่วนทำให้เกิดชุดภาพรวมในอนาคต

โลกของเกมจะวนซ้ำระหว่างสแน็ปช็อตในเวลาปัจจุบันและเฟรมสแนปช็อต X ในอนาคต

จากนั้นเมื่อคุณต้องการย้อนเวลาให้ตั้งทิศทางของเวลาไปข้างหลังเพื่อที่จะวนซ้ำระหว่างเฟรมปัจจุบันและเฟรม snapshot X ในอดีต (ขณะปิดการใช้งานความสามารถในการสร้างสแนปชอตในอนาคต)

คุณสามารถปรับเวลาเสมือนของเกมให้เป็นมิติที่คล้ายกับอวกาศได้ ดังนั้นการเดินทางข้ามเวลาจากภายนอกคือการเคลื่อนที่แบบ n + 1 มิติในจักรวาลเสมือนจริงของเกม

สมมติว่ามีการโต้ตอบกับผู้ใช้และระบบฟิสิกส์บางอย่างที่กำหนดพฤติกรรมของจักรวาลของคุณเมื่อไม่มีการป้อนข้อมูลของผู้ใช้สิ่งที่คุณต้องบันทึกคือผลของการโต้ตอบของผู้ใช้ (ตัวอย่างเช่นการเปลี่ยนแปลงในเวกเตอร์ความเร็ว n + 1 มิติ / การเร่งความเร็ว) ฟิสิกส์ของคุณควรจะย้อนเวลากลับไปได้

วิธีนี้คุณจะต้องใช้หน่วยความจำน้อยกว่ามากในการคำนวณสถานะของจักรวาลเกมในเวลาที่กำหนด

สมมุติว่าเอนทิตีมีตำแหน่งการหมุนความเร็ว x และ y สิ่งเหล่านี้คือการเร่งความเร็วสถานะการเคลื่อนไหวพื้นฐานค่าหรืออะไรก็ตามที่คุณเรียกว่า คุณสามารถบันทึกข้อมูลได้สองวิธี:
1. บันทึกการหมุน, ตำแหน่ง x และ y
2. บันทึกการหมุน, ความเร็ว x และความเร็ว y

หากคุณมีความเร็วคงที่คุณสามารถบันทึกการหมุนหรือบันทึกความเร็วเดียวสำหรับทั้งสองแกนเท่านั้น

การหมุนแบบออมทรัพย์เป็นสิ่งจำเป็นในเกมเว้นแต่เอนทิตีของคุณจะมีการหมุนเวียนแบบคงที่สิ่งที่ไม่ได้อยู่ในกรณีส่วนใหญ่

ที่กล่าวว่าการใช้รายการวัตถุหลายค่าเป็นสิ่งที่จำเป็น หากคุณมีระบบจับเวลาที่ดีตัวอย่างเช่นเรียกวิธีการอัพเดต 20 ครั้งในหนึ่งวินาทีและดังนั้นจึงเป็นอิสระจาก fps คุณสามารถสร้างอาร์เรย์ของวัตถุ 20 * 30 เพื่อเก็บค่าการเคลื่อนไหวที่คุณต้องการในช่วง 30 วินาทีที่ผ่านมา . ไม่แนะนำให้ใช้อาร์เรย์อย่างง่ายเนื่องจากคุณจะต้องย้ายทุกองค์ประกอบหนึ่งดัชนีออกจากการเรียกใช้การปรับปรุงแต่ละครั้ง

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

หากคุณทำลายวัตถุอย่าลืมรวมพวกมันไว้ด้วยเพื่อให้แน่ใจว่าคุณจะไม่เครียดกับเพื่อนที่เรียบร้อยของคุณมิสเตอร์ขยะมูลฝอย;)