โธมัส LIVELY สิทธิทั้งหมด สวัสดีทุกคน. ฉันโทมัสมีชีวิตชีวา งานสัมมนาครั้งนี้เป็นไปได้ การเขียนเกม 2D ใน C ใช้ SDL ดังนั้นผมจึงรู้ว่าคุณกำลังทั้งหมด ถามว่าใช่ฉันจริงๆ ต้องการที่จะเล่นเกมและทำให้เกม แต่สิ่งที่เป็นธุรกิจนี้ SDL? ดังนั้น SDL เป็นห้องสมุด C มันหมายถึงง่าย DirectMedia ชั้น และมันเป็นข้ามแพลตฟอร์ม ห้องสมุดพัฒนาเกม มันทำงานบน Windows, Mac, ลินุกซ์แม้ iOS และ Android สามารถจัดการกับสิ่งที่ชอบ การเข้าถึงระบบเสียง สำหรับเครื่องคอมพิวเตอร์แป้นพิมพ์และ เมาส์จอยสติ๊กถ้าพวกเขากำลังแนบ ในมือถือก็ยังสามารถทำ สัมผัสการป้อนข้อมูลและทุกที่ และแน่นอนที่จะจัดการกับกราฟิก การวาดภาพสิ่งที่หน้าจอ ดังนั้นจึงใช้กันอย่างแพร่หลายมากแม้ว่า คุณอาจไม่เคยได้ยินมาก่อน มันสร้างขึ้นในยกตัวอย่างเช่น เครื่องยนต์แหล่งวาล์ว ซึ่งเกมอำนาจเช่น Portal และ Team Fortress 2 มันยังอยู่ในจำนวนมาก ของเกมอินดี้ที่ออกมา ดังนั้นฉันตื่นเต้นที่จะได้เห็นสิ่งที่คุณ ทั้งหมดจะทำกับมัน 

เป้าหมายการสัมมนาจะได้รับคุณ ออกไปได้รับการพัฒนาด้วย SDL เรากำลังจะไปเรียนรู้วิธีการ เพื่อสร้างหน้าต่างเกม เรากำลังจะสร้างสไปรท์, ซึ่งเป็นภาพในเกมของคุณ ที่สามารถย้ายไปรอบ ๆ เรากำลังจะไปเรียนรู้วิธีการ และสไปรท์เคลื่อนไหวที่ เพื่อย้ายไปรอบ ๆ ให้ พวกเขาเปลี่ยนแปลงตลอดเวลา และเรากำลังจะไปเรียนรู้วิธีการ ในการจับภาพแป้นพิมพ์และเมาส์ ข้อมูลจากคอมพิวเตอร์ สิ่งที่เราจะไม่ได้รับการพูดคุย เกี่ยวกับวันนี้เป็นกราฟิก 3D เพราะเห็นว่าเป็นความซับซ้อนมาก เรื่องที่เราไม่ได้มีเวลาสำหรับ เราจะไม่เรียนรู้วิธีการ เล่นเสียงในเกมของเรา และเราจะไม่ได้รับการสร้าง แต่สำหรับสิ่งที่ลินุกซ์ 

ตอนนี้ caveats มีว่า หวังว่าภายในสิ้นการสัมมนา คุณจะสะดวกสบายกับ เอกสาร SDL, ดังนั้นคุณจะสามารถที่จะไปคิดออก วิธีการเล่นเสียงสำหรับตัวคุณเอง นอกจากนี้ยังมีอาคารสำหรับ Mac หรือ PC ควรจะทำงาน เหมือนกับอาคารสำหรับลินุกซ์ แต่การติดตั้งเป็นไป จะแตกต่างกันเล็กน้อย ดังนั้นคุณควรจะสามารถที่จะคิด วิธีการที่จะทำสิ่งเหล่านี้ ในตอนท้ายของการสัมมนาในวันนี้ 

ดังนั้นสำหรับการตั้งค่าที่เรากำลังจะ ที่จะใช้เครื่องเสมือน เราจะใช้ IDE CS50 เพราะ เราเพียงแค่จะต้องเขียนใน C. แต่เนื่องจาก IDE ไม่ได้เป็นเบราว์เซอร์ที่เรา ไม่สามารถสร้างหน้าต่างใหม่หรือการแสดงผล กราฟิกในนั้น ดังนั้นเราจึงจำเป็นต้องใช้เครื่องเสมือน เพื่อให้คุณสามารถปฏิบัติตามคำแนะนำ ที่นี่ที่ manual.CS50.net/appliance/15 การติดตั้งเครื่อง CS50 อย่างเป็นทางการ ซึ่งเป็นเพียงเสมือนลินุกซ์ เครื่อง 

และจากนั้นเมื่อคุณมี ที่ตั้งทั้งหมด up-- มัน อาจใช้เวลาสักครู่เพราะ download-- ขนาดใหญ่มากที่คุณจะ การทำงานใน VM ปรับปรุง sudo apt-get และที่จะจริงๆ ในการปรับปรุงซอฟต์แวร์ทั้งหมด แพคเกจในเครื่องเสมือนของคุณ 

หลังจากนั้นคุณกำลังจะไปทำงาน sudo apt-get ติดตั้ง libsdl2-2.0-0, libsdl2-DBG, libsdl2-dev และ นอกจากนี้ libsdl2-ภาพ 2.0-0, libsdl2 ภาพ-DBG, และ libsdl2 ภาพ-dev ดังนั้นสิ่งที่จะทำอย่างไร นั่นเป็นเพียงการแก้ปัญหาการติดตั้ง ข้อมูลเอกสารส่วนหัว และไบนารีสำหรับสองห้องสมุด ปกติเก่า SDL 2.0 และห้องสมุดอีก เรียกว่าภาพ SDL ซึ่ง เราจะต้องใช้ ในการโหลดไฟล์ภาพในเกมของเรา 

ดังนั้นเมื่อคุณมีที่ยัง ที่เพียงแค่เมื่อมันถามว่า คุณเพียงแค่พิมพ์ใช่กด Enter การติดตั้งแพคเกจเหล่านั้น แล้วคุณควรจะดีไป เพื่อที่จะได้รับรหัสการกระจายคุณ can-- โอ้รักนี้จะไม่มีการปรับปรุง ถ้าคุณมี GitHub account-- ถ้าคุณมีบัญชี GitHub, คุณสามารถทำ Git นี้ คำสั่งโคลนที่จะซื้อคืน และที่จะดาวน์โหลด Git repo กับทุกรหัสในนั้น เพื่อที่คุณจะมีรหัส 

หากคุณไม่ได้มี GitHub บัญชีสิ่งที่คุณควรทำคือการพิมพ์ wgithttps: //github.com/tlively/sdl seminar-- และนี่ก็เป็น different-- /archive/master.zip ดังนั้นอีกครั้งที่เดียวกันแน่นอน URL, ยกเว้นว่ามันจะเป็นไปได้ tlively / SDL_seminar / master.zip และ คุณกำลังใช้ wgit ดาวน์โหลดที่ และจากนั้นคุณสามารถเพียง เปิดเครื่องรูดเก็บที่ แล้วคุณจะมี ทุกรหัสแหล่งที่มา ดังนั้นขออภัยเกี่ยวกับที่ และแล้วรหัสนอกจากนี้ยังจะเป็นเจ้าภาพที่ หน้าเว็บสัมมนา CS50 ในคู่ วัน 

ทั้งหมดขวา ดังนั้นวิธีที่เราจะเริ่มต้น การเขียนเกมของเราเอง? ดีสิ่งแรก เรากำลังจะต้องการที่จะทำ จะดูเอกสาร SDL ดังนั้นนี่คือที่ VM และนี่คือหน้าเว็บ ผมเคยสำรวจจะมีชีวิตอยู่ libsdl.org สิ่งที่ฉันจะทำนี่คือไปกว่า แถบด้านข้างภายใต้เอกสาร และคลิกที่วิกิพีเดีย นี้จะนำฉันไปที่วิกิพีเดียที่ว่า มีมากที่สุดของเอกสารสำหรับ SDL กว่าในแถบด้านข้างที่นี่เรา ไปคลิก API ตามหมวดหมู่ เพราะเป็นไปเพื่อให้ เรามีมุมมองที่ดีเด็ดขาด ของทั้ง API สำหรับการ SDL 

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

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

ดังนั้นขอเริ่มต้น หวังว่าคุณได้อยู่แล้ว ดาวน์โหลดรหัสกระจาย และเพื่อให้สิ่งที่คุณสามารถทำได้คือขวา ที่นี่ในเครื่อง CS50, เพียงแค่เปิดสถานี ไปเลย. ดังนั้นผมจึงได้ดาวน์โหลดแล้ว รหัสการกระจายการใช้ซิป วิธี. และฉันได้ซิปมัน ดังนั้นที่นี่มันมีอยู่ในการสัมมนาหลัก SDL ดังนั้นฉันจะไปลงในไดเรกทอรีที่ และสิ่งที่เราเห็นที่นี่เป็น ที่เรามีเจ็ดไฟล์ C และนี่เป็นไปรหัส เรากำลังจะได้รับการมองหาที่ในวันนี้ เรามี Makefile และเรามีไดเรกทอรีทรัพยากร ซึ่งก็มีภาพ ที่คุณจะได้เห็นเร็วพอ 

ดังนั้นขอเปิดไฟล์เหล่านี้ โดยใช้โปรแกรมแก้ไข G-แก้ไข ดังนั้นผมจึงต้องการที่จะเปิดแฟ้มทั้งหมดที่ เริ่มต้นด้วยการทักทายและจบด้วย .c ไปเลย. เพื่อให้เป็นหน้าต่างเล็ก ๆ ดังนั้นเรา จะพยายามที่จะทำให้มันมีขนาดใหญ่กว่า ไม่มีก็กลับออกไป 

ทั้งหมดขวา ดังนั้นที่นี่เป็นครั้งแรก ไฟล์ที่เรากำลังจะไปดูที่ มันเรียกว่า hello1_sdl.c และทั้งหมดนี้ก็คือเริ่มต้น SDL ห้องสมุดเพื่อให้เราสามารถเริ่มใช้มัน วิธีที่คุณจะได้รู้ว่าจะมา ขึ้นด้วยรหัสคุณหรือไม่ ดีถ้าเรามองข้าม ที่เอกสาร และเราไปสู่​​การเริ่มต้น และปิดส่วน ก็จะบอกให้เราทราบ เกี่ยวกับวิธีการเริ่มต้น SDL ดังนั้นแน่นอนอ่านบางเวลาอื่น ๆ มันจะบอกคุณทั้งหมด เกี่ยวกับสิ่งที่เกิดขึ้นที่นี่ แต่ปมหลักของเรื่องคือ เราจำเป็นต้องเรียก SDL ฟังก์ชันนี้ในนั้น และผ่านมันสิ่งที่ชนิดของสิ่งที่ เราต้องการให้ห้องสมุดในการเริ่มต้น ดังนั้นในกรณีที่เรากำลังจะ ในการเริ่มต้นวิดีโอสำหรับตอนนี้ เพื่อให้เราสามารถเริ่มต้นการแสดงภาพ 

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

แล้วสิ่งที่เราต้องการอีก ที่จะทำคือก่อนที่จะออกจากโปรแกรม ถ้าเราเริ่มต้นได้ประสบความสำเร็จใน SDL, เราก็ต้องเรียกว่า SDL เลิก และที่จะจัดการกับการทำความสะอาด ทั้งหมดของทรัพยากรภายใน SDL สำหรับเรา ดังนั้นเอกสารอีกครั้ง there--, ที่นี่เราอยู่ในการเริ่มต้น และปิดส่วน ของเอกสาร คุณก็สามารถคลิกที่ ฟังก์ชั่นที่นี่ SDL เลิก และคุณสามารถอ่านข้อมูลเกี่ยวกับการที่ดี และจำนวนมากของฟังก์ชั่นเหล่านี้ หน้าเอกสาร มีรหัสตัวอย่างดังนั้นนี้ เป็นทรัพยากรที่ดีมาก แน่นอนใช้เวลาบางส่วน อ่านส่วนของวิกิพีเดียนี้ ถ้าคุณกำลังจะทำ นี้สำหรับโครงการ 

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

นอกจากนั้นเราจะให้มัน ทุกคำสั่งตามปกติเช่นเดียวกับ ทั้งสองคำสั่ง ดังนั้น -lsdl2 จับภาพ การเชื่อมโยงในห้องสมุดภาพ SDL และ -lm จริงจัดการการเชื่อมโยง ในมาตรฐานห้องสมุดคณิตศาสตร์ C ดังนั้นเราจะไม่ได้ไปต้อง เหล่านั้นสำหรับทุกไฟล์ C ของเรา แต่เราเพียงแค่ใส่ไว้ในเพื่อที่เราจะสามารถทำได้ ใช้ Makefile เดียวกันสำหรับทุกอย่าง โดยไม่ต้องแก้ไข 

กว่าที่นี่ในแหล่งที่มา นี่คือที่ที่คุณต้องการ ใส่ไฟล์ที่คุณกำลังจะ เพื่อรวบรวมสำหรับโครงการของคุณ แต่เนื่องจากทุกคนของฉัน C ไฟล์ที่นี่มีฟังก์ชั่นหลัก ก็จะได้รับสับสน ถ้าเราใส่พวกเขาทั้งหมดใน ดังนั้นฉันจะเพียงแค่พูดว่า สำหรับตอนนี้ hello1_sdl.c, ซึ่งเป็นหนึ่งในที่เราเพียงแค่มองไปที่ ดังนั้นถ้าผมกลับไปมากกว่า ที่นี่ผมไม่สามารถทำให้ และสิ่งที่มันไม่ได้เป็นเพียง ที่รวบรวมไฟล์แรก และจากนั้นเราสามารถพิมพ์ ./game เพราะ มันเป็นปฏิบัติการมันผลิต และทั้งหมดก็ไม่ได้พิมพ์ เริ่มต้นที่ประสบความสำเร็จ ดังนั้นเราทำสิ่งที่ถูกต้อง แต่นั่นก็เป็นชนิดของน่าเบื่อ เพราะเราไม่เห็นหน้าต่าง ไม่มีอะไรย้ายไปรอบ ๆ 

ดังนั้นที่ดีที่เราได้เริ่มต้น SDL ตอนนี้ขอย้ายไปยังบางสิ่งบางอย่าง เล็ก ๆ น้อย ๆ ที่น่าสนใจมากขึ้น ดังนั้นที่นี่เรามี hello2_window.c และ นี้เป็นไปได้มากขึ้นเล็กน้อย โปรแกรม C ที่ซับซ้อนที่ เริ่มต้น SDL เช่นเดียวกับก่อน ยกเว้นตอนนี้เรายังจะ ในการเริ่มต้นจับเวลา SDL และสิ่งนี้เป็นไปเพื่อให้เรา เข้าถึงจับเวลาภายใน ฟังก์ชั่นการใช้งานและที่เกี่ยวกับเวลา 

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

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

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

ดังนั้นเราจึงมีการเปิดหน้าต่างนี้หวังว่า และสิ่งที่เรากำลังจะไป ทำคือการที่เรากำลังจะ ที่จะเรียก SDL 5,000 มิลลิวินาที ซึ่งเป็นเช่นเดียวกับห้าวินาที และเมื่อเรากำลังทำกับที่ มันจะทำลายหน้าต่าง ทำความสะอาดห้​​องสมุด SDL, และออกจากโปรแกรม ถ้าอย่างนั้นเราไปข้างหน้าและให้ที่ยิง 

ดังนั้นตอนนี้แทนการเปลี่ยนแปลง Makefile ทุกครั้ง ฉันก็ไม่สามารถทำและ จากนั้นในบรรทัดคำสั่ง บอกแหล่งที่มาเท่ากับแล้ว ไฟล์ที่เรากำลังรวบรวม ดังนั้นจึงเป็น hello2_window.c ที่ยอดเยี่ยม ไม่มี erros ตอนนี้ถ้าเราทำงานที่ปฏิบัติการของเรา เราจะเห็นหน้าต่างนี้ ขณะนี้มีไม่กี่ ปัญหาเกี่ยวกับหน้าต่าง เราสามารถย้ายไปรอบ ๆ แต่มันก็มี ขยะพื้นหลังนี้ภายในของมัน ดังนั้นเราจึงยังไม่ได้วาด อะไรและดังนั้นจึงเป็นเรื่อง เพียงเต็มไปด้วยขยะซึ่ง สวยมากสิ่งที่เราคาดหวัง 

นอกจากนี้เราไม่สามารถปิดหน้าต่าง ฉันกดปุ่ม X ที่นี้ และมุมที่เกิดขึ้นไม่มีอะไร ดังนั้นเราจะเห็นว่าในการแก้ไขปัญหา ว่าในนิด ๆ หน่อย ๆ ดังนั้นขอแก้ไขส่วนที่ หน้าต่างที่เต็มไปด้วยขยะแรก ดังนั้นถ้าเราไปมากกว่าที่จะ hello3_image.c สิ่งที่ เราสามารถมองเห็นคือการที่เราได้เพิ่มไม่กี่ สิ่งที่เพิ่มเติมได้ที่นี่ เราได้เพิ่มหัวใหม่นี้ แฟ้มที่จะได้รับฟังก์ชั่นจับเวลา ผมคิดว่าเราไม่ว่าในที่ผ่านมา อย่างใดอย่างหนึ่งมากเกินไปและผมไม่ได้พูดถึงมัน แต่ตอนนี้เพราะเรา การทำงานร่วมกับภาพ เราต้องรวม SDL ไฟล์ส่วนหัวภาพได้เป็นอย่างดี ดังนั้นจึงเป็นสิ่งเดียวกับที่ ก่อนที่จะเริ่มต้น SDL นี่ ข้อตกลงเดียวกันกับการสร้างหน้าต่าง เราได้เห็นว่าก่อนหน้านี้ 

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

และเรากำลังจะใช้ SDL renderer PRESENTVSYNC VSync เป็นสิ่งที่เพียงแค่ทำให้ กราฟิกของคุณดูดีขึ้นและป้องกัน สิ่งที่เรียกว่าหน้าจอ ความหวาดกลัวที่ครึ่งหนึ่ง ของกรอบและครึ่งหนึ่งของต่อไป ได้รับการวาดกรอบในเวลาเดียวกัน และมันก็ดูน่ากลัว แต่อีกครั้งคุณสามารถไปอ่าน เกี่ยวกับการที่ตัวคุณเอง 

ดังนั้นเราจึงมีธงบางอย่างที่นี่ และเพื่อให้เราเพียงแค่จะเรียก SDL ฟังก์ชันนี้สร้าง renderer เรากำลังจะให้หน้าต่าง เพื่อเชื่อมโยงกับที่แสดงผล หนึ่งในเชิงลบหมายความว่าเราไม่สนใจสิ่งที่ ไดรเวอร์กราฟิกที่เรากำลังจะใช้ ดังนั้นควรที่สวยมาก มักจะเป็นหนึ่งในเชิงลบ จนกว่าคุณจะรู้เกี่ยวกับโปรแกรมควบคุมกราฟิก และจากนั้นเรากำลังจะ ที่จะผ่านมันธงของเรา ดังนั้นหากที่ส่งกลับโมฆะแล้วเรา จะพิมพ์ข้อผิดพลาดตามปกติ แต่แล้วเรายังจะ ที่จะทำลายหน้าต่าง ในการทำความสะอาดทรัพยากรเหล่านั้นก่อน เรียก SDL เลิกและกลับ 

ตอนนี้ส่วนที่น่าสนใจที่นี่ เป็นที่ที่เราโหลดภาพของเรา โดยใช้ฟังก์ชั่นนี้ IMG_load นี้เป็นฟังก์ชั่นเดียวที่เรากำลังจะไป ที่จะใช้จากห้องสมุดภาพ SDL มันเป็นเพียงคนเดียวที่เราต้องการ มันเป็นฟังก์ชั่นที่ใช้เวลาสตริง ที่เป็นเส้นทางของทรัพยากรภาพใด ๆ และจะสามารถ .png เป็น GIF, บิตแมปใด ๆ ของสิ่งเหล่านี้ และนั่นเป็นเหตุผลที่ฟังก์ชั่นนี้เป็นสิ่งที่ดีดังนั้น มันสามารถจัดการสวยมากรูปแบบใด ๆ โหลดลงในหน่วยความจำและเก็บไว้ เป็นสิ่งที่เรียกว่าผิว SDL 

ตอนนี้พื้นผิว SDL เป็นเพียง struct ที่แสดงถึงข้อมูลภาพในความทรงจำ เพื่อให้คุณสามารถอ่านเพิ่มเติมเกี่ยวกับ ว่าในเอกสารที่สอง และถ้าข้อผิดพลาดนี้แล้วเรา จะทำสิ่งที่ทั้งที่ เราพิมพ์ข้อผิดพลาดของเราปิด ทรัพยากรและจากนั้นออกจากโปรแกรม ตอนนี้สิ่งที่น่าสนใจคือก่อน เราสามารถวาดภาพนี้ไปที่หน้าต่าง เราต้องทำให้มันเป็นจริงเนื้อ ตอนนี้เนื้อสอดคล้อง เพื่อโหลดข้อมูลภาพ ในหน่วยความจำกราฟิกของฮาร์ดแวร์ของ 

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

ทั้งหมดขวา ที่นี่เราจะได้เป็นบางส่วน ฟังก์ชั่นการแสดงผลที่เกิดขึ้นจริง ดังนั้นการเรียก SDL_RenderClear และผ่านมัน แสดงผลที่เกี่ยวข้องกับหน้าต่างของเรา ก็ทำให้หน้าต่างสีดำ ดังนั้นจึงเอาว่าขยะที่เราเห็นใน หน้าต่างของเราก่อนและทำให้มันเป็นสีดำ และจากนั้นเรากำลังจะ ที่จะเรียก SDL_RenderCopy, ให้แสดงผลของเราเนื้อของเรา และเราจะพูดคุยเกี่ยวกับสิ่งที่ เขตข้อมูลเหล่านี้อยู่ในบิต แต่ที่เป็นไปได้ นำข้อมูลพื้นผิว และคัดลอกลงบนของเรา หน้าต่างการวาดภาพ ดังนั้นหลังจากที่เราได้ทำสำเนานี้ ข้อมูลบนหน้าต่างของเรา เราจะต้องทำเช่นนี้ฟังก์ชั่นพิเศษ เรียกว่า SDL_RenderPresent 

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

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

อีกครั้งที่เรากำลังจะ ที่จะรอห้าวินาที แล้วเรากำลังจะไป ทำความสะอาดทรัพยากรของเรา เรามีค่อนข้างน้อยมากขึ้นในเวลานี้ และจากนั้นเรากำลังจะ เพื่อออกจากโปรแกรม ดังนั้นขอให้ทำอย่างนั้น ฉันจะพิมพ์ให้แล้วแหล่งที่มา เท่ากับ hello-- นี้คือตอนนี้ 3image.c สิทธิทั้งหมดที่รวบรวมไม่มีข้อผิดพลาด และคุณสามารถดูที่นี่ฉันได้ในขณะนี้ ดึงออกมาภาพของฉันสวัสดี CS50! ไปที่หน้าต่างของเราที่ หายไปหลังจากห้าวินาที 

ตอนนี้ยังมีปัญหาใช่มั้ย? นี้ไม่ได้เป็นแอพลิเคชันที่ดี เพราะเมื่อฉันพยายามที่จะปิดหน้าต่าง ไม่มีอะไรเกิดขึ้น. ที่ x ยังไม่ตอบสนอง ดังนั้นลองมาดูที่ที่ ไฟล์ต่อไป, hello4animation ดังนั้นนี่คือไฟล์ ที่จะแนะนำ การเคลื่อนย้ายและการเคลื่อนไหวไปที่ภาพของเรา ดังนั้นเรากำลังจะทำ สิ่งเดียวกับก่อน เริ่มต้น SDL สร้าง หน้าต่างสร้าง renderer ที่ โหลดภาพลงใน หน่วยความจำในการสร้างพื้นผิว เราได้เห็นทุกที่ก่อน ตอนนี้เป็นของใหม่ เรากำลังจะมีโครงสร้างที่เรียกว่า ดูแลรักษา SDL ซึ่งเป็นเพียงรูปสี่เหลี่ยมผืนผ้า ถ้าเราไปมากกว่าที่นี่เราสามารถ จะค้นหาสำหรับดูแลรักษา SDL, และคุณสามารถเห็นมันเป็น โครงสร้างที่เรียบง่ายมาก มันมี x, y สำหรับ ตำแหน่งและมัน มีความกว้างและความสูงสำหรับ ขนาดของสี่เหลี่ยม 

ดังนั้นสิ่งที่เรากำลังจะทำคือเรา จะกำหนดปลายทางดูแลรักษา SDL นี้ สำหรับปลายทาง และนี่เป็นสถานที่ที่ บนหน้าจอที่ เรากำลังจะได้รับการวาดภาพ ภาพของเราที่เหมาะสมดังนั้น ถ้าเรากำลังจะได้รับ ภาพเคลื่อนไหวไปรอบ ๆ แล้วปลายทางที่ เรากำลังจะวาดภาพ จะต้องมีการย้ายไปรอบ ๆ ดังนั้นเราจะเรียกสิ่งนี้ ฟังก์ชั่น SDL_QueryTexture และแจ้งให้ทราบผมผ่านอยู่ ของ dest.w ซึ่งเป็นความกว้าง และ dest.h ซึ่งเป็นความสูง และเพื่อให้เป็นไป SDL_QueryTexture ในการจัดเก็บในเขตข้อมูลเหล่านั้นกว้าง และความสูงของพื้นผิวของเรา 

และแล้วสิ่งที่ฉันจะ ทำคือการที่ฉันจะ การตั้ง dest.x จะเป็นหน้าต่าง ความกว้าง dest.w ลบซึ่งเป็น ความกว้างของเทพดาหารด้วย 2 และนี้จะตั้งขึ้นเพื่อให้ ว่าภาพที่เป็นศูนย์กลางอย่างสมบูรณ์แบบ ในหน้าต่างของเราทุกคนใช่มั้ย? ดังนั้นตอนนี้ฉันมีตำแหน่ง Y และนี้เป็นไปได้ เป็นตัวแปรที่เป็น เปลี่ยนเพราะเรากำลังจะได้รับ ภาพเคลื่อนไหวในทิศทางการ y และตอนนี้เรามีบางสิ่งบางอย่าง เรียกว่าห่วงการเคลื่อนไหว 

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

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

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

ดังนั้นต่อไปสิ่งที่ฉัน ทำจริงในวงนี้หรือไม่? ฉันจะล้างหน้าต่าง ผมตั้ง dest.y ซึ่งเป็น int ไปยัง ตำแหน่ง y ที่เกิดขึ้นจริงของฉันโยนลงไปเป็น int ตอนนี้ผมต้องการที่ลอยละเอียด สำหรับตำแหน่ง y ที่ของฉันในเกมของฉัน แต่แล้วก็จริง วาดมันลงบนหน้าจอ มันต้อง ints เพราะในหน่วยของ พิกเซลเพื่อให้เป็นสิ่งที่หล่อสำหรับ ฉันจะวาดภาพ ดังนั้นนี่คือสี่เหลี่ยมต้นฉบับ และนี่คือสี่เหลี่ยมปลายทาง ดังนั้นผมจึงผ่าน null สำหรับ สี่เหลี่ยมแหล่งที่มา จะบอกว่าผมต้องการที่จะดึงพื้นผิวทั้งหมดของฉัน แต่ถ้าคุณมีจำนวนมากของ พื้นผิวในเกมของคุณ และพวกเขากำลังทั้งหมดในแผนที่พื้นผิวขนาดใหญ่ ที่ถูกโหลดลงใน SDL เป็นเพียงหนึ่ง พื้นผิวที่คุณสามารถ ใช้รูปสี่เหลี่ยมผืนผ้าแหล่งที่มา ที่จะเลือกหนึ่งของพื้นผิวที่มีขนาดเล็ก หนึ่งในสไปรท์ขนาดเล็ก ออกจากที่แผนที่พื้นผิวขนาดใหญ่ 

ดังนั้นอีกครั้งฉันผ่านของฉันทำให้ฉัน เนื้อและตอนนี้ปลายทาง นี้เป็นไปได้ที่ใน หน้าต่างก็จะได้รับการวาด และจากนั้นก็เพราะฉันเคลื่อนไหว บางสิ่งบางอย่างที่ฉันต้องการการเคลื่อนไหว ฉันจะได้รับการปรับปรุง ตำแหน่งเทพดาในแต่ละเฟรม ดังนั้นผมจึงมีการเลื่อนนี้เรียกว่าค่าคงที่ ความเร็วในหน่วยพิกเซลต่อวินาที ตอนนี้ทุกครั้งที่เราทำเคลื่อนไหว กรอบเป็นเพียง 1/60 ของวินาที ดังนั้นฉันจะแบ่งที่ 60 แล้วเรามาดูผม ที่ลบจากตำแหน่ง Y ฉันลบทำไม? เราจะไปที่ในครั้งที่สอง ดังนั้นแล้วฉันทำความสะอาดทรัพยากรของฉัน และโปรแกรมที่มากกว่า 

ดังนั้นขอให้ที่ ดังนั้นขอให้ไปลงใน SRCS = hello4 animation.c ทั้งหมดใช่มั้ย? เกม. มีคุณไป ดังนั้นผมจึงมีมันเลื่อนขึ้น หน้าต่างซึ่งเป็นระเบียบสวย แต่ยึดมั่นในผมก็ลบ จากตำแหน่ง y ที่ทุกเวลา สิ่งที่เกิดขึ้นที่นั่น? ดีก็ปรากฎว่าใน SDL และ ในความเป็นจริงมากที่สุดในคอมพิวเตอร์กราฟิก แหล่งที่มาสำหรับระบบการประสานงาน เป็นที่ด้านบนซ้ายของหน้าต่าง 

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

ลองดูที่ไฟล์ต่อไป นี่คือส่วนหนึ่งของการเป็น แสดงที่ในที่สุดเราก็ ได้รับที่ X ที่มุมของหน้าต่าง ที่ควรจะปิดหน้าต่าง ไปทำงาน. ดังนั้นสิ่งที่เกิดขึ้น? เราเริ่มต้น SDL สร้างหน้าต่าง สร้าง renderer โหลดภาพ สร้างเนื้อ เหมือนอย่างที่เราเคยเห็นมาก่อน เรามีสี่เหลี่ยมปลายทางเดียวกัน เป็นก่อนที่จะสายเดียวกันในการค้นหาเนื้อ แต่ครั้งนี้เราแล้ว จะแบ่งความกว้าง และความสูงของปลายทางของเราโดยที่ 4 นี้จะมีผลกระทบของ การปรับภาพของเราลงเมื่อ เราแสดงมันในหน้าต่างโดยสี่ เพื่อให้เป็นระเบียบสวย เราก็สามารถปรับขนาดเช่นเดียวกับที่ เรากำลังจะเริ่มต้นเทพดา ในใจกลางของหน้าจอ และตอนนี้เรามี x และความเร็ว Y และ ทั้งที่พวกเขากำลังจะไปเริ่มต้นที่ศูนย์ 

นี้เป็นไฟล์ผิด ฉันขอโทษ. เพื่อให้เป็นความจริงทุกประการ ที่ยังคงทั้งหมดในแฟ้มนี้ เรามีแบ่ง 4 และทุกอย่าง ดังนั้นที่นี่เรามี x และ y ที่ตำแหน่งของเรา สำหรับศูนย์ของหน้าต่าง และเราให้มันความเร็วเริ่มต้น ความเร็วคงที่ ผมเชื่อว่าเป็น 300 พิกเซลต่อวินาที ขณะนี้เรามี int นี้อาจก็เช่นกัน เป็นบูลที่เรียกว่าขอปิด และแทนที่จะทำ วง จำกัด ในการจับเวลาที่นี่ เรากำลังจะได้เป็นแรงบันดาล ตราบใดที่ใกล้จะไม่ได้รับการร้องขอ 

ดังนั้นวิธีที่เราดำเนินการเหตุการณ์ที่เกิดขึ้น? ดี SDL คิวขึ้นในเหตุการณ์ที่เกิดขึ้น คิวที่แท้จริงอยู่เบื้องหลัง และแล้วแต่ละเฟรม เราสามารถ dequeue เหตุการณ์ จากคิวที่ใช้ SDL_PullEvent สายนี้ และอีกครั้งแน่นอนไปอ่าน เกี่ยวกับเรื่องนี้ในเอกสารประกอบ มีรายละเอียดมากขึ้นเป็นจำนวนมากและ ฟังก์ชั่นอื่น ๆ อีกมากมายที่คุณสามารถใช้กับเรื่องนี้ เราผ่านมันอยู่ ของสิ่งนี้ SDL_Event ที่เรามีที่นี่ในกอง 

ตอนนี้สิ่งที่เป็น SDL_event แล้ว? เพราะ SDL ถ้าเรามองใน documentation-- ปล่อยให้ของ เห็น API ตามหมวดหมู่การป้อนข้อมูล กิจกรรมการจัดการเหตุการณ์ เราสามารถมองไปที่จำนวน ของเหตุการณ์ที่แตกต่างกันที่นี่ และเราจะเห็นมี ตันทั้งหมดของพวกเขา ดังนั้นสิ่งนี้คือสิ่งที่ SDL_Event? SDL_Event เป็นสหภาพ ว้าว, สิ่งที่ยูเนี่ยนหรือไม่? คุณอาจจะไม่เคยได้ ได้ยินว่าก่อนที่ และที่ตกลง 

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

ดังนั้นวิธีที่เราสามารถบอกชนิดของเหตุการณ์ เราก็โผล่ออกจากคิวนี้? ดีที่เราสามารถทดสอบ event.type และถ้าเกิดว่ามีค่าเท่ากับ เพื่อ SDL_Quit เรารู้ มันเป็นกรณีที่ ถูกสร้างขึ้นเมื่อเรา ตีว่า X ในมุมของหน้าต่าง และเราสามารถตั้งค่าการร้องขอใกล้เท่ากับ 1 ส่วนที่เหลือเป็นเพียงการเคลื่อนไหวบางอย่าง ที่คุณเคยเห็นมาก่อน ถ้าอย่างนั้นเราไปข้างหน้าและทำให้ นี้และดูว่าทำงานได้ดี ดังนั้นฉันจะทำและพิมพ์ แล้ว SRCS = hello5_events.c เราจะไปที่นั่น. เกม. 

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

ดังนั้นลองมองกลับไปที่รหัส ดังนั้นวิธีการที่ฉันได้รับมัน กำยำรอบเช่นนั้น? จำได้ว่าผมตั้งค่าทั้ง x และ ปีแรกที่ความเร็ว และความเร็วเป็นบวก อย่างต่อเนื่องเพื่อให้เป็น จะได้รับมันเริ่มออก และจะลงไปทางด้านขวา 

ตอนนี้แต่ละเฟรมที่นอกเหนือไปจากการจัดการ เหตุการณ์ใด ๆ ที่อาจเกิดขึ้น ฉันจะตรวจสอบว่าผีของฉัน พยายามที่จะออกไปจากหน้าต่าง ดังนั้นเราจึงสามารถทำได้โดยเพียงแค่การตรวจสอบ x_pos 0, y_pos 0 แล้ว ยัง x_pos และ y_pos กับ ความกว้างและความสูงหน้าต่างหน้าต่าง ขอให้สังเกตที่ผมเคยหัก ความกว้างของผีสาง และนี่คือเพราะถ้าฉันไม่ได้ ลบความกว้างของสไปรต์, มันจะตรวจสอบว่า ต้นกำเนิดของสไปรต์ ไม่ได้ไปนอกหน้าต่าง แต่เราต้องการทั้งหมด ความกว้างของผีสาง ที่มักจะต้องอยู่ภายในหน้าต่างและ ทั้งความสูงของสไปรต์ เสมอภายในหน้าต่าง ดังนั้นสิ่งที่เป็นลบสำหรับ จำนวนมากของรูปทรงเรขาคณิตที่นี่สามารถ จะเป็นประโยชน์ที่จะดึงมันออกมา บนกระดาษที่มีการประสานงาน ระบบที่จะเห็นสิ่งที่เกิดขึ้น 

ดังนั้นถ้าฉันไม่ชนกันผมก็ เพียงแค่ตั้งค่าตำแหน่ง เพื่อที่จะไม่ได้ไป ออกจากหน้าจอ และฉันจะไปถ้ามันตีกลับ ที่หนึ่งของผนังที่ ฉันจะคัดค้าน x ความเร็วเพื่อที่จะ เริ่มตีกลับในทิศทางอื่น ๆ และในทำนองเดียวกันถ้ามันฮิต ด้านบนหรือด้านล่าง ฉันจะตั้งค่าความเร็วการ y เท่ากับความเร็ว y ที่เชิงลบ เพื่อที่จะกลับมา ดังนั้นนี่เป็นเพียงวิธีการที่เรามีที่นี่ 

และตำแหน่งการปรับปรุง เช่นเดียวกับที่เราเคยเห็นมาก่อน หารด้วย 60 เพราะเรา จัดการเพียง 1/60 ของวินาที และแล้วการแสดงผล เหมือนกับก่อน และเพื่อให้ทุกอย่าง ที่เกิดขึ้นในไฟล์นี้ เพื่อให้เป็นวิธีที่เราทำเหตุการณ์ สิ่งสำคัญที่ต้องนำมาใช้ที่นี่ เป็นหน้าที่ SDL_PullEvent นี้ และแน่นอนคุณควรอ่าน เอกสารเพิ่มเติมเกี่ยวกับ SDL_Event สหภาพเพราะชนิดของข้อมูลนี้ สำคัญมากเพราะเราใช้มัน สำหรับทุกประเภทของกิจกรรม 

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

ตอนนี้เป็นชนิดของแฟนซี เพราะเราสามารถใช้ W, A, S, D ที่นี่หรือปุ่มลูกศรที่เกิดขึ้นจริง เราจะเห็นว่าในเวลาเพียงสอง ดังนั้นเรากำลังจะดำเนินการ เหตุการณ์เช่นเดียวกับก่อนที่จะ เราดึงเหตุการณ์ แต่ตอนนี้เรากำลังจะไป สลับกับประเภทการแข่งขัน ถ้ามัน SDL_Quit เรา จะตั้งอยู่ใกล้ ขอให้หนึ่งเช่นเดียวกับก่อนที่จะ ที่จัดการ x ใน มุมของหน้าต่าง เพื่อให้หน้าต่างของเราจริงปิด 

มิฉะนั้นถ้าเราได้รับคีย์ SDL ลง เหตุการณ์ซึ่งหมายความว่าเรากดคีย์ แล้วสิ่งที่เรากำลังจะทำคือเรา จะเปิดสิ่งนี้ที่นี่ ซึ่ง means-- เพื่อ event.key หมายถึงการรักษาสหภาพเหตุการณ์ของเรา ไปและได้รับที่สำคัญ โครงสร้างเหตุการณ์ในนั้น ดังนั้นมันจะเปิดออกที่นี้ ยูเนี่ยนเป็นโครงสร้างเหตุการณ์ที่สำคัญ แล้วไปที่สำคัญ โครงสร้างของเหตุการณ์สาขาของตน เรียกว่า keysym แล้ว scancode และอีกครั้งอ่านแน่นอน เอกสารเกี่ยวกับเรื่องนี้ คำที่ใช้ปัจจัยการผลิตที่ค่อนข้างน่าสนใจ คุณจะได้รับการสแกนรหัสหรือรหัสที่สำคัญ และมันก็เป็นเพียงเล็กน้อยบอบบาง แต่ เอกสารค่อนข้างดี 

ดังนั้นถ้าเราเห็นโค้ดสแกน กดปุ่มของเราเป็น W หรือขึ้น เรากำลังจะตั้งค่าเท่ากับ 1 และจากนั้นเราแยกออกจากสวิทช์ที่ ถ้ามันเป็น A หรือซ้ายเราตั้งทิ้งไว้ 1, et ฯลฯ และอื่น ๆ สำหรับการลงและขวา ตอนนี้ออกมาในครั้งนี้สวิทช์ด้านนอก ถ้าเราดูที่สำคัญถึงเหตุการณ์ นั่นหมายความว่าเราได้เปิดตัวที่สำคัญ และเราไม่ได้กด ดังนั้นฉันจะพูดขึ้นเท่ากับ 0, ซ้ายเท่ากับ 0 ลงเท่ากับ 0 ขวา เท่ากับ 0, และอื่น ๆ 

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

ดังนั้นเรากำลังจะไป กำหนดความเร็ว เราตั้งค่าความเร็วเป็น 0 แล้วถ้าขึ้นกด และไม่ได้ลงแล้วเรา ตั้งค่าความเร็ว y ที่ความเร็วเชิงลบ โปรดจำไว้ว่าในเชิงลบเนื่องจาก ทิศทาง y ที่เชิงลบขึ้น และทิศทางบวก y จะลดลง หากมีการกดลง และไม่ขึ้นแล้วเรา จะตั้งค่าให้ความเร็วในเชิงบวก ซึ่งหมายถึงการไปลงหน้าจอ สิ่งเดียวกันกับด้านซ้ายและขวา 

และจากนั้นเรากำลังจะปรับปรุง ตำแหน่งเช่นเดียวกับก่อนที่จะ เรากำลังจะทำการปะทะกัน การตรวจสอบที่มีขอบเขต แต่เราไม่ได้ไปตั้งค่า ความเร็วความเร็วเพราะเป็นเพียง ควบคุมโดยแป้นพิมพ์ แต่เราจะไปตั้งค่า ตำแหน่งที่จะเก็บมันไว้ในหน้าต่าง และเรากำลังจะตั้งค่า ในตำแหน่งที่ struct แล้วทำทุก การแสดงผลจากสิ่งที่มาก่อน ดังนั้นเรามาดูสิ่งที่มันไม่ เพื่อให้ SRCS-- เรามาดู นี้ hello6_keyboard.c 

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

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

แต่มีผู้อื่นง่ายขึ้นเล็กน้อย บางที API สำหรับการป้อนข้อมูลของเมาส์ และนั่นก็เป็นเพียงแค่ได้รับรัฐเมาส์ SDL ดังนั้นผมจึงมี int สำหรับ x และ y ที่ตำแหน่งเคอร์เซอร์ ผมผ่านไป SDL_GetMouseState, ซึ่งชุดเหล่านี้ และนี่คือตำแหน่งใน ระบบพิกัดของหน้าต่าง ดังนั้นถ้ามวลเป็นในด้านบนซ้าย ของหน้าต่างที่จะ 0, 0 

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

เพื่อให้เป็นเพียงเพื่อให้แน่ใจว่าผมกำลังพูดถึง เกี่ยวกับศูนย์ของภาพที่นี่ จากนั้นเราได้รับเดลต้า x และ y ซึ่ง คือความแตกต่างจากเป้าหมาย ไปยังตำแหน่งที่แท้จริงของภาพ และจากนั้นเราจะได้รับ ระยะทางที่นี่ซึ่ง เป็นไปได้ที่พีทาโกรัส ทฤษฎีบท, รากที่สองของ x ครั้ง x บวกครั้งวายวาย 

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

ตอนนี้ก็ปรากฎว่า SDL_GetMouseState, นอกเหนือไปจากการตั้งค่า และข้อโต้แย้ง x y ที่นี่ มันก็จะส่งกลับ int ที่สอดคล้อง สถานะของปุ่มเมาส์ ดังนั้นเราจึงไม่สามารถอ่านว่า โดยตรง แต่ที่เราสามารถทำได้ ใช้แมโครเหล่านี้เป็นหนึ่งเดียว ผู้ประกอบการค่าที่เหมาะสมไม่ว่าน่ากลัว เพียงค่าที่เหมาะสมและ ดังนั้นเราจึงบอกว่าปุ่มซึ่งเป็นผลที่ได้ SDL_GetMouseState ของเราว่า และค่าที่เหมาะสมและแมโครนี้ นี่ SDL_BUTTON_LEFT 

ดังนั้นนี้เป็นไปได้เพียงแค่แก้ไข เพื่อบิตแมปที่สอดคล้อง ปุ่มซ้ายของเมาส์ถูกกด และดังนั้นหากค่าที่เหมาะสม และเกิดขึ้นและมัน ไม่เป็นศูนย์ซึ่งหมายความว่า ปุ่มซ้ายถูกกด แล้วเราจริงจะปฏิเสธ ทั้ง x และ y ที่ความเร็วที่ ซึ่งก็จะทำให้ภาพหนี ตำแหน่งที่ปรับปรุง การตรวจจับการชนเห็นมัน ทั้งหมดก่อนที่จะกระทำขวาทั้งหมด ขอให้มัน เพื่อให้คุณได้ทำให้ SRCS = hello7_mouse.c ที่ดี ไม่มีข้อผิดพลาด และเกม 

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

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

ทั้งหมดขวา และตอนนี้สิ่งที่เกิดขึ้น? ดี. เรายังคงดังต่อไปนี้ เมาส์เช่นเดียวกับก่อน แต่เมื่อเราได้รับเมาส์ เราได้มีกระวนกระวายใจขั้นต้นนี้ สิ่งที่เกิดขึ้นที่นั่น? ทั้งในเวกเตอร์ของเรา คณิตศาสตร์จำได้ว่าเราเป็น ระยะห่างระหว่างการที่ เคอร์เซอร์และศูนย์ของภาพ? ดีที่ว่าวิธีการ 0 เราเริ่มได้รับ เช่นการจัดเรียงของพฤติกรรมบ้านี้ ที่ภาพจะเป็นประเภทของ เช่นสั่นรอบเคอร์เซอร์ และที่สร้างความกระวนกระวายใจนี้ และที่น่าเกลียดจริงๆ และคุณอาจไม่ ต้องการเกมของคุณทำแบบนั้น เว้นแต่จะเรียงลำดับของผลพิเศษบางอย่าง 

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

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

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