การสร้างเกมมีหลายขั้นตอน แต่พอแบ่งได้สองส่วน คือการออกแบบเกม และการกำหนดกลไกในการเล่นเกม
การออกแบบเกม เป็นการออกแบบรูปลักษณ์สิ่งต่างๆ ที่ปรากฏในโลกของเกม เช่น พื้นที่สำหรับเล่นเกม ตัวละคร วัตถุต่างๆ เสียงประกอบ เป็นต้น ซึ่งผู้เล่นจะเห็นและได้ยินขณะเล่นเกม
เมื่อมีพร้อมทุกอย่างในโลกของเกมแล้ว ในการเล่นเกมต้องมีกลไกขับเคลื่อนเกม เช่น เป้าหมายในการเล่นเกม ซึ่งเป็นตัวกำหนดทิศทางในการเล่นเกม ยกตัวอย่างเช่น เกมผจญภัยมี 4 ด่าน เป้าหมายอาจเป็นเอาตัวรอดให้ได้ในแต่ละด่าน ครบทั้ง 4 ด่านด้วยเวลาที่กำหนดไว้ในแต่ละด่าน หรือต้องทำภาระกิจให้สำเร็จในแต่ละด่าน ครบทั้ง 4 ด่าน
นอกจากเป้าหมายของเกมแล้ว เกมต้องมีกฎกติกา มีวิธีการให้คะแนน มีหลายๆ ด่าน (Game Levels) เพื่อเพิ่มความท้าทายให้ผู้เล่น และถ้าเกมยาวมากอาจใช้วิธีเล่าเรื่องประติดประต่อเรื่องราวในแต่ละฉาก เพื่อสร้างความตื่นเต้นเร้าใจให้ผู้เล่นติดตามเกมต่อ
กลไกหลายๆ อย่างที่กล่าวมา เป็นภาพรวมของทั้งเกม แต่กลไกบางอย่างต้องระบุลงไปยัง สิ่งต่างๆ ที่อยู่ในโลกของเกม โดยเฉพาะตัวละครหลักๆ ที่มีบทบาทมากในเกม และบางตัวที่เป็นเสมือนตัวแทนของผู้เล่น ที่ผู้เล่นสามารถควบคุมและโต้ตอบกับเกมได้ ตัวละครเหล่านี้ต้องมีกลไกในการเล่น สามารถโต้ตอบกันเองได้ หรือโต้ตอบกับสิ่งแวดล้อมในเกมได้ วิธีใส่กลไกก็ทำได้ด้วยการเขียนโปรแกรมให้ตัวละครนั้นเอง
การเขียนโปรแกรมใน Kodu เป็นการสร้างพฤติกรรมให้ตัวละคร ตอบสนองต่อเหตุการณ์ต่างๆ ที่เกิดขึ้นในเกม เช่น ผู้ใช้กดคีย์ลูกศรทำให้ตัวละครเคลื่อนที่ หรือผู้เล่นทำคะแนนได้ครบ 5 คะแนนแล้ว ผู้เล่นเป็นฝ่ายชนะ เป็นต้น
ดังนั้นการเขียนโปรแกรมให้แต่ละตัวละคร จะมีลักษณะเป็นรายการหลายๆ รายการเรียงต่อกันมา โดยในแต่ละรายการจะประกอบด้วย เหตุการณ์ที่ตัวละครนั้นเฝ้ารอให้เกิดขึ้น ตามด้วยการตอบสนองต่อเหตุการณ์จากตัวละครนั้น
ใน Kodu การเขียนโปรแกรมในแต่ละแถว (มีเลขกำกับอยู่) จะใช้วิธีเลือกไอคอน (มีให้เลือกในโปรแกรม) เรียงต่อกันหลัง WHEN เพื่อระบุถึงเหตุการณ์ที่รอให้เกิดขึ้น และเลือกไอคอนเรียงต่อกันหลัง DO แสดงสิ่งที่ต้องการจะทำเมื่อเกิดเหตุการณ์นั้นขึ้นมาจริงๆ เพื่อให้เห็นภาพในการเขียนโปรแกรม คราวหน้ามาลองเขียนเกมง่ายๆ
หลักการเขียนโปรแกรมเกม Kodu
Kodu เป็นโปรแกรมภาษาเฉพาะด้าน (Domain-specific language) สร้างมาสำหรับการสร้างเกม โดยอาศัยไวยากรณ์ภาษา (Grammar) ของ Kodu เป็นตัวกำหนดวิธีการเขียนโปรแกรมในเกม
การเขียนเกมใน Kodu เริ่มจากการสร้างโลกของเกมขึ้นมาก่อน โดยสร้างพื้นที่ในการเล่นเกม (Terrain) จากนั้นสร้างตัวละคร หรือ วัตถุต่างๆ เข้าไปบนพื้นที่นั้น ต่อมาคือการสร้างกฎของเกม เพื่อให้ตัวละครและวัตถุต่างๆ ทำงานร่วมกัน ตามที่เกมได้ถูกออกแบบไว้
กฎต่างๆ ในเกม จะถูกกำหนดโดยการเขียนโปรแกรมเข้าไปยังตัวละคร หรือวัตถุต่างๆ และลักษณะการเขียนโปรแกรมใน Kodu คือการสั่งให้ตัวละคร หรือวัตถุต่างๆ ทำงานเมื่อเหตุการณ์ต่างๆ เกิดขึ้น เช่นในตัวอย่างตามรูปด้านบน เป็นการกำหนดกฎให้ตัวละคร Kodu มีทั้งหมด 4 เหตุการณ์ แต่ทำงาน 5 อย่าง
ไวยากรณ์ของ Kodu อยู่ในรูปแบบง่ายๆ คือ แต่ละบรรทัด หรือแต่ละรายการ (มีตัวเลขกำกับอยู่) เป็นกฎหนึ่งๆ สำหรับตัวละครหรือวัตถุนั้น และกฎนั้นอยู่ในรูปแบบตามไวยากรณ์ของ Kodu ดังนี้
When Condition Do Action
อธิบายได้ว่า เมื่อ (When) เหตุการณ์ที่เฝ้ารอเกิดขึ้น (Condition) ให้ทำ (Do) งานดังนี้ (Action)
จากรูปด้านบน อธิบายกฎตามหลักไวยากรณ์ของ Kodu ได้ดังนี้
- เมื่อผู้เล่นใช้จอยสติ๊กด้านซ้ายของเกมแพด ตัวละคร Kodu จะเคลื่อนที่ตามทิศทางของจอยสติ๊ก
- เมื่อผู้เล่นใช้คีย์ลูกศรบนคีย์บอร์ด ตัวละคร Kodu จะเคลื่อนที่ตามทิศทางของคีย์ลูกศร (เกมนี้ผู้เล่นสามารถจะใช้เกมแพด หรือจะใช้คีย์บอร์ดในการเล่นก็ได้)
- เมื่อตัว Kodu ชน (bump) กับแอปเปิ้ล ให้ตัว Kodu กินผลแอปเปิ้ลนั้น (it)
- ในกรณีที่กฎมีการย่อหน้า และไม่มีเงื่อนไขของเหตุการณ์กำกับอยู่ หมายความว่า ให้ใช้เงื่อนไขก่อนหน้านั้น ซึ่งก็คือกฎในข้อ 3 เมื่อตัว Kodu ชน กับแอปเปิ้ล ให้เพิ่มคะแนน 1 คะแนนแก่ผู้เล่น
- เมื่อผู้เล่นทำคะแนนะได้ครบ 5 คะแนน ผู้เล่นชนะ
ไวยากรณ์ของ Kodu ยังมีให้ศึกษาอีก มาตามต่อคราวหน้าครับ
การสร้างเงื่อนไขในเกม Kudo
เกมใน Kodu ถูกขับเคลื่อนด้วยเหตุการณ์ต่างๆ ระหว่างโปรแกรมทำงาน หรือระหว่างการเล่นเกม ดังนั้นการเขียนโปรแกรมจึงขึ้นกับเหตุการณ์เหล่านั้น และสามารถแสดงเป็นกฎได้ดังนี้
When Condition (เงื่อนไขของเหตุการณ์) Do Action (สิ่งที่จะทำเมื่อเกิดเหตุการณ์ขึ้น)
กฎด้านบนนี้เป็นเพียงแค่กฎเบื้องต้น เพราะเบื้องหลังของแต่ละรายการคำสั่งในโปรแกรม Kodu ถูกกำกับด้วยไวยากรณ์ภาษา (Kodu Grammar) ที่ต้องใช้ให้ถูกต้อง เพื่อให้เกมทำงานได้ถูกต้องตามที่ได้ออกแบบไว้
การเข้าใจไวยากรณ์ของเกมจะทำให้เขียนโปรแกรมใน Kodu ได้ดีขึ้น เหมือนเข้าใจในไวยากรณ์ภาษาอังกฤษ ก็จะอ่านเขียนภาษาอังกฤษได้ดีขึ้น แต่ก็ไม่ได้หมายความว่า ต้องเข้าใจไวยากรณ์ใน Kodu ทั้งหมดก่อนถึงจะเริ่มเขียนโปรแกรมบน Kodu ได้ ดังนั้นมาเริ่มต้นศึกษาแบบง่ายๆ ก่อน
ส่วนประกอบสำคัญของไวยากรณ์ คือ Production Rules เป็นกฎสำหรับสร้างภาษา ประกอบไปด้วย Variables และ Terminals ซึ่งอยู่ในรูปแบบดังนี้
Variable –> Variables Terminals
Variable คือคำที่แปรเปลี่ยนได้ตามกฎ(อื่น) คำเหล่านี้จะขึ้นต้นด้วยอักษรตัวใหญ่ เช่น Rule, Condition, Action, Sensor, Filter, FilterSet, Actuator, Selector, Modifier เป็นต้น
Terminal คือคำที่สิ้นสุด ไม่สามารถเปลี่ยนแปลงต่อไปได้อีกแล้ว คำเหล่านี้จะขึ้นต้นด้วยอักษรตัวเล็ก เช่น kodu, cycle, apple, see, move, red, eat, toward, quickly, hear เป็นต้น คำเหล่านี้จะเป็นไอคอนต่างๆ ที่ใช้ในการเขียนโปรแกรมใน Kodu ซึ่งไอคอนต่างๆ พอจะแบ่งเป็นกลุ่มๆ (ตัวอย่าง) ได้ดังนี้
- ไอคอนตัวละครหรือวัตถุ
-
Production Rules เป็นกฎที่ใช้อธิบายตัวภาษาเพื่อสร้างกฎของเกม ในขณะที่กฎของเกมที่ใช้ตอนเขียนโปรแกรม (When … D0 …) คือผลลัพธ์สุดท้ายจากการใช้ Production Rules
ด้านซ้ายมือของ Production Rules จะมีได้แต่ตัวแปร และมีแค่ตัวเดียว แต่ด้านขวามือ ตัวแปรและ Terminal อาจมีตัวเดียว หลายตัว หรือไม่มีเลยก็ได้
คราวหน้ามาดูว่า จากกฎสำหรับสร้างภาษา จะไปสู่ประโยคหรือกฎคำสั่งที่ใช้ในการเขียนเกมใน Kodu ได้อย่างไร
หลักการใช้คำสั่งในเกม Kudo
1. Rule –> Condition Action
Rule คือกฎของเกมที่ต้องการจะสร้าง Condition เป็นเงื่อนไขของเหตุการณ์ Action สิ่งที่จะทำเมื่อเงื่อนไขนั้นเป็นจริง กฎนี้ยังใช้งานไม่ได้ เนื่องจากด้านขวามือมีแต่ตัวแปร (Variable) ซึ่งไม่สามารถแทนที่ได้ด้วยไอคอนใน Kodu ดังนั้นมาดูกฎข้ออื่นกันต่อว่า ตัวแปรเหล่านี้เปลี่ยนไปเป็นอะไรได้บ้าง
2. Condition –> Sensor Filter
3. Action –> Actuator Selector Modifier
Sensor (การรับรู้) Filter (ตัวกรอง) Actuator (ตัวกระทำ) Selector (ตัวเลือก) Modifier (ตัวขยาย) ทั้งหมดนี้ก็ยังเป็นตัวแปรอยู่ แทนที่ด้วยไอคอนไม่ได้ แต่สามารถแทนที่กันเองได้
กฎการแทนที่ เป็นกฎที่ทำให้ไวยากรณ์ขยายออกไปได้ด้วยการแทนคำจากกฎข้อหนึ่งไปแทนคำในกฎอีกข้อหนึ่ง คือแทนคำที่เป็นตัวแปรทางซ้ายมือ ด้วยคำทางขวามือ (อาจเป็น Variable หรือ Terminal ก็ได้)
ยกตัวอย่างในกรณีนี้ เราสามารถนำ Sensor Filter ไปแทนตัวแปร Condition ในกฎข้อแรกได้ ดังนี้ Rule –> Sensor Filter Action
และเมื่อแทน Action ด้วย ก็จะได้กฎใหม่ดังนี้ Rule –> Sensor Filter Actuator Selector Modifier มาดูกฎข้ออื่นๆ กันต่อ
4. Sensor –> see | hear | bump
5. Filter –> apple | blue | health
6. Actuator –> move | shoot| add
7. Selector –> toward | me | avoid
8. Modifier –> 5 points | red | quickly
คราวนี้เราจะเห็นคำที่เป็น Terminals กันบ้างแล้ว แท่ง (Vertical bar) ที่กั้นระหว่างคำด้านขวามือ หมายความว่า ให้เลือกใช้คำใดคำหนึ่ง ตัวอย่างเช่น เลือก hear แทน Sensor, apple แทน Filter, add แทน Actuator เป็นต้น
คราวนี้มาลองดูตัวอย่างกฎในเกม ที่ได้จากกฎสร้างภาษาด้านบน เพื่อนำไปเขียนโปรแกรมใน Kodu เช่น ต้องการเขียนกฎให้ตัว Kodu เมื่อเห็นผลแอปเปิ้ลแล้ว ให้เคลื่อนที่ไปหาผลแอปเปิ้ลนั้นอย่างรวดเร็ว เมื่อใช้กฎสร้างภาษาที่กล่าวมา ร่วมกับกฎการแทนที่แล้ว จะได้กฎคำสั่งสุดท้ายตามขั้นตอนดังนี้
- Rule –> Condition Action
- Rule –> Sensor Filter Action
- Rule –> see Filter Action
- Rule –> see apple Action
- Rule –> see apple Actuator Selector Modifier
- Rule –> see apple move Selector Modifier
- Rule –> see apple move toward Modifier
- Rule –> see apple move toward quickly
กฎสุดท้ายจะมีแต่ Terminal ในด้านขวามือ ซึ่งสามารถเขียนในโปรแกรม Kodu ได้ดังนี้
When see apple Do move toward quickly
สังเกตว่า When และ Do ไม่ได้อยู่ในไวยากรณ์ของ Kodu แต่เป็นส่วนหนึ่งในกฎของเกมที่ใช้แยกระหว่างเหตุการณ์ กับสิ่งที่จะทำเมื่อเหตุการณ์นั้นเกิดขึ้น รูปล่างนี้แสดงการเขียนกฎสุดท้ายที่ได้จากตัวอย่างด้านบนให้ตัว Kodu
หลักการสร้างเกมใน Kudo
ที่ผ่านมา Kodu Grammar 1 2 3 เป็นไวยากรณ์สำหรับกฎเพียงข้อเดียว ที่เริ่มต้นด้วยตัวแปร Rule แต่สำหรับโปรแกรมเกมใน Kodu สามารถมีได้หลายกฎและองค์ประกอบอื่นๆ อีก ในคราวนี้เรามามองไวยากรณ์ที่กว้างขึ้น ครอบคลุมทั้งโปรแกรม ซึ่งจะมีตัวแปรเพิ่มขึ้นมาอีก
จุดเริ่มต้นของไวยากรณ์ของโปรแกรมเกมคือ Game ซึ่งประกอบไปด้วยตัวละคร Actors หลายๆ ตัว ในหนึ่งเกม
Game –> Actors
ตัวละครถือว่าเป็นวัตถุ Object หรือกลุ่มของวัตถุ Object Actors ซึ่งไม่ระบุจำนวน ขึ้นกับแต่ละเกม
Actors –> Object | Object Actors
ไวยากรณ์รูปแบบนี้ จะเห็นว่าตัวแปร (ในที่นี้คือ Actors ด้านซ้าย) สามารถแทนที่ด้วยตัวมันเอง (Actors ด้านขวาสุด) ไวยากรณ์ในลักษณะนี้ คล้ายกับฟังก์ชันที่เรียกตัวเอง (Recursive function) ถ้าเลือกแทนที่ด้วย Object Actors โดยมีจุดสิ้นสุดของการวนซ้ำ ถ้าเลือกใช้ตัวแปร Object
วัตถุสามารถเขียนโปรแกรมได้อย่างน้อยหนึ่งหน้า Page หรือมากกว่านั้น แต่ไม่เกิน 12 หน้า
Object –> Page | Page Object
ในแต่ละหน้าสามารถ มีได้หนึ่งกฎ Rule หรือหลายกฎก็ได้
Page –> Rule | Rule Page
กฎถูกกำหนดด้วยเงื่อนไขของเหตุการณ์ Condition และสิ่งที่จะทำ Action เมื่อเกิดเหตุการณ์ขึ้น กฎยังสามารถมีกฏซ้อน (Nested Rules) ได้ด้วย กฎซ้อนนี้สร้างได้ด้วยการสลับไปใช้ Page ในหน้าใหม่ เพื่อแสดงพฤติกรรมที่เปลี่ยนไปจากเดิม เมื่อเหตุการณ์ที่กำหนดไว้เกิดขึ้น หรือการเปลี่ยนระดับของเกม (Game Level)
Rule –> Condition Action | Condition Action Page
Condition Action และตัวแปรที่ตามมาจะคล้ายของเดิม แต่มีไวยากรณ์ที่ขยายมากขึ้น เอาไว้คราวหน้ามาดูรายละเอียดกัน
ที่มา https://tapanee023.wordpress.com/%E0%B8%
เข้าถึงเมื่อ 7 มิถุนายน 2558
![358365[1]](http://www.malangmo.com/wp-content/uploads/2013/10/3583651.png)
