สมุดบันทึกของท่านวา~~~

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

- การวางตำแหน่งของภาพ (Position And Movement)
ตำแหน่งของภาพก็เป็นอีกส่วนหนึ่งที่สำคัญเหมือนกัน และก็เป็นอีกส่วนที่มีคำสั่งมากมายไม่แพ้กับหัวข้ออื่นๆเช่นกันครับ
คำสั่ง at คำสั่งนี้จะเป็นการกำหนดตำแหน่ง ของตัวละครครับ ว่าจะต้องปรากฎอยู่ที่ตำแหน่งไหนของหน้าจอ คำสั่งนี้จำเป็นที่จะต้องวางไว้อยู่หลังคำสั่ง show หรือ sceneครับ มีหลักการใช้งานดังนี้

“คำสั่ง show | scene“ “at” function1 [ , function2 ]

โดยที่ค่า functionต่างๆดังนี้ 
left <--- ตำแหน่งซ้ายของจอ
right <--- ตำแหน่งขวาของจอ
center <--- ตำแหน่งกึ่งกลางจอ
offscreenleft, offscreenright <--- ตำแหน่างนอกขอบจอทางด้านซ้าย / ขวา
Position <--- เป็นฟังก์ชั่นที่กำหนดตำแหน่ง ณ จุดใดๆบนจอ (กำหนดจุดเอง) มีลักษณะการใช้งานเบื้องต้นดังนี้

Position(**properties)

ค่า properties เป็นชุดของพารามิเตอร์ครับ ชุดพารามิเตอร์นี้มีมากมายหลายตัวจนผมจำเป็นต้องขอตัดออกไปก่อน แล้วจะนำมาอธิบายให้อีกทีในบทหลังๆละกันครับ ซึ่งในฟังก์ชั่นนี้ผมจะขออธิบายแค่เฉพาะพารามิเตอร์ที่จำเป็นต่อการทำงานก่อนละกันครับ สามารถไปหาอ่านเพิ่มเติมได้ ที่นี่ 
xpos <---- กำหนดตำแหน่งของแกน X ของรูป ยึดตามมุมล่างซ้ายของภาพเป็นหลัก ใช้ค่าพิกเซลในการกำหนดค่า (เริ่มต้นจากมุมซ้ายบนของจอ) ในการกำหนดค่า
ypos <---- กำหนดตำแหน่งของแกน Y ของรูป ยึดตามมุมล่างซ้ายของภาพเป็นหลัก ใช้ค่าพิกเซลในการกำหนดค่า (เริ่มต้นจากมุมซ้ายบนของจอ) ในการกำหนดค่า
xanchor <---- กำหนดตำแหน่งแนวแกน X ของรูป ยึดตามมุมบนซ้ายของภาพเป็นหลัก ใช้ค่าทศนิยม(0.0-1.0 เริ่มต้นจากมุมล่างขวาของจอ)ในการกำหนดค่า
yanchor <---- กำหนดตำแหน่งแนวแกน Y ของรูป ยึดตามมุมบนซ้ายของภาพเป็นหลัก ใช้ค่าทศนิยม(0.0-1.0 เริ่มต้นจากมุมล่างขวาของจอ)ในการกำหนดค่า
หมายเหตุ หากเราต้องการที่จะใช้ค่า xposและ ypos ร่วมกับค่า xanchor และ yanchor ก็สามารถทำได้เพียงแต่ว่าผลที่ออกมาจะได้ตำแหน่งที่หักล้างกันระหว่าง ค่า xpos กับ xanchor และค่า ypos กับ yanchor ไปลองเล่นดูละกันครับ
xalign <---- เป็นทางลัดที่เราจะสามารถใช้กำหนดตำแหน่งในแนวแกน X โดยที่เปรียบเสมือนว่าเราได้กำหนดค่า xpos และ xanchor ไว้แล้ว โดยปกติจะกำหนดไว้เป็นค่าทศนิยม (0.0-1.0)
yalign <---- เป็นทางลัดที่เราจะสามารถใช้กำหนดตำแหน่งในแนวแกน Y โดยที่เปรียบเสมือนว่าเราได้กำหนดค่า ypos และ yanchor ไว้แล้ว โดยปกติจะกำหนดไว้เป็นค่าทศนิยม (0.0-1.0)
xoffset <---- เหมือน xalign แต่วิธีกำหนดค่าจะกำหนดเป็นพิกเซลเทน
yoffset <---- เหมือน yalign แต่วิธีกำหนดค่าจะกำหนดเป็นพิกเซลเทน
ตัวอย่างการใช้งาน

    show eileen happy at Position(xpos=250, ypos=300, xanchor=0.5, yanchor=0.5)
    show eileen happy at Position(xalign=0.5,yalign=0.5)

Move() <--- ฟังก์ชั่นนี้จะเป็นการเลื่อนรูปไปตามตำแหน่งที่เรากำหนด มีลักษณะการใช้งานเบื้องต้นดังนี้

 

Move (startpos, endpos, time, repeat=False, bounce=False,time_warp = ฟังก์ชั่น,**properties)

โดยพารามิเตอร์แต่ละตัวมีความหมายดังนี้
startpos <--- ตำแหน่งเริ่มต้น 
endpos <--- ตำแหน่งปลายทาง
time <--- ระยะเวลาที่ใช้ (คิดเป็นวินาที)
time_warp <---- กำหนดว่าจะเริ่มต้นตำแหน่งในการเคลื่อนที่ ณ เสี้ยวเวลาที่เท่าไหร่ อย่างเช่นว่าในเวลา1วินาทีภาพเคลื่อนที่ไป100พิกเซลหากว่าเรากำหนดให้เป็น 0.5 วินาที ตำแหน่งมันก็จะเริ่มต้นที่ตำแหน่งเมื่อมันเคลื่อนที่ไปแล้ว 0.5 วินาทีก็คือ 50 พิกเซลครับ พารามิเตอร์ตัวนี้ผมเองก็ไม่ค่อยอยากจะแนะนำให้ใช้สักเท่าไหร่ครับเพราะว่าค่อนข้างยุ่งยากในการใช้งาน เนื่องจากว่าเราไม่สามารถที่จะใส่ค่าของเวลาลงไปในพารามิเตอร์ตัวนี้ได้ตรงๆ แต่เราจะต้องสร้างฟังก์ชั่นชึ้นมาเพื่อให้พารามิเตอร์เรียกใช้ขึ้นมาแทนครับ(ตัวนี้ผมจะไม่ขอกล่าวละกันครับแต่ถ้าใครต้องการรู้จริงๆให้มาถามผมอีกทีละกันครับ)
repeat= True /False <--- เป็น True ถ้าต้องการกำหนดให้วนลูป
bounce= True/False <--- เป็น True ถ้าต้องการให้รูปที่เรากำหนดเด้งกลับมายังจุดเริ่มต้นเมื่อมันวิ่งไปถึงจุดสุดท้ายแล้ว

หมายเหตุ ทั้งค่า startpos และ endpos มีหลักการใช้งานดังนี้ 
การกำหนดตำแหน่งสามารถเรียกกำหนดได้ 2 แบบ คือ
แบบ 2 ตำแหน่ง <--- คือ เราจะเขียน กำหนดตำแหน่งเพียงแกน x และ y เท่านั้น โดยอ้างอิง ณ ที่จุดซ้ายบนของภาพ เช่น (1.0,1.0)
แบบ 4 ตำแหน่ง <--- คือ เราจะเขียน กำหนดตำแหน่งเพียงแกน x และ y เช่นกัน แต่จะอ้างอิง ณ ที่จุดซ้ายบนของภาพ และ จุดกึ่งกลางของภาพด้วย ดังนั้นจะได้เป็น (xแกนซ้าย,y แกนซ้าย,x กึ่งกลาง,y กึ่งกลาง) เช่น (0.0,1.0,0.0,1.0)
โดยปกติแล้วเค้านิยมเรียกใช้งานกันแบบ 2 ตำแหน่งอ่ะครับเพราะว่าเข้าใจง่ายดี (มั้ง 5555)
ส่วนค่าตำแหน่งที่เรากำหนดนั้นจำเป็นที่จะต้องเป็นค่าที่อยู่ ระหว่าง 0.0ถึง 1.0 นะครับ โดยที่ตำแหน่ง (0.0,0.0) จะอยู่ที่ตำแหน่งขวาล่างของจอ และตำแหน่ง (1.0,1.0) จะอยู่ที่ตำแหน่งซ้ายบนของจอครับ

ตัวอย่างการใช้งาน

    show eileen happy at Move((1.0, 1.0, 1.0, 1.0),      #startpos (แบบ 4 ตำแหน่ง)
                              (0.0, 1.0, 0.0, 1.0),      #endpos (แบบ 4 ตำแหน่ง)
                              4.0,                       #time
                              repeat=True,               #repeat
                              bounce=True)               #bounce

pan <--- ฟังก์ชั่นนี้เหมือนกับฟังก์ชั่น Moveทุกประการเพียงแต่ว่า Move มันจะขยับเฉพาะรูปที่เรากำหนดแต่ pan มันจะขยับทั้งรูปและฉากเลย มีลักษณะการใช้งานเบื้องต้นดังนี้

 

Pan (startpos, endpos, time, repeat=False, bounce=False,time_warp = ฟังก์ชั่น,**properties)

โดยพารามิเตอร์แต่ละตัวสามารถอ่านอ้างอิงจาก Move ได้
หมายเหตุ ค่า startpos และ endpos มีหลักการใช้งานที่แตกต่างกันออกไปดังนี้
ค่าตำแหน่งของMove จะวิ่งอยู่ที่ 0.0 – 1.0 แต่ว่าของ Pan กำหนดตามพิกเซลของรูปเลยโดยที่ตำแหน่งนี้จะอ้างอิงที่จุดซ้ายบนของจอเสมอ
ตัวอย่างการใช้งาน

scene bg onememorial at Pan((0, 800), (0, 0), 10.0)

zoom <---- ตามตัวครับซูมฉากได้ทั้งขยายใหญ่หรือซูมภาพออกก็ไม่หวั่น มีลักษณะการใช้งานเบื้องต้นดังนี้

 

Zoom(size, start, end, time,time_warp = ฟังก์ชั่น ,bilinear=True / False,opaque=True / False ,**properties)

โดยพารามิเตอร์แต่ละตัวมีความหมายดังนี้
size <---- ขนาดของภาพที่จะทำการแสดงขึ้นมา (กว้าง,สูง) ภาพจะอยู่ที่ตำแหน่ง (0,0) เสมอ
start <---- ขนาดและตำแหน่งของภาพเมื่อเริ่มต้น ( ตำแหน่งที่แกน x, ตำแหน่งที่แกน y ,กว้าง(ขนาดที่ต้องการซูม) ,สูง (ขนาดที่ต้องการซูม))
end <---- ขนาดและตำแหน่งของภาพหลังการซูม ( ตำแหน่งที่แกน x,ตำแหน่งที่แกน y ,กว้าง(ขนาดที่ต้องการซูม) ,สูง (ขนาดที่ต้องการซูม))
time <---- เวลาที่ใช้ในการซูม มีหน่วยเป็นวินาที
time_warp <---- วิธีการใช้งานเหมือนกับ Move
bilinear=True / False <---- เปิดใช้ระบบลบรอยหยักของรูปที่เรากำหนด
opaque=True / False <---- เป็น false ถ้าต้องการให้ฉากหลังของรูปโปร่งใส ถ้าเป็น true ฉากข้างหลังจะออกเละๆไม่น่าดู
ตัวอย่างการใช้งาน

    scene washington at Zoom((800, 600),            #size
                             (0, 0, 800, 600),      #start
                             (300, 100 , 400, 300 ),#end
                             0.5)                   #time

FactorZoom <----เหมือนกับฟังก์ชั่น Move แต่เป็นการซูมที่ตัวละครแทน มีลักษณะการใช้งานเบื้องต้นดังนี้

 

FactorZoom(size, start, end, time,time_warp = ฟังก์ชั่น ,bilinear=True / False,opaque=True / False ,**properties)

โดยพารามิเตอร์แต่ละตัวมีความหมายดังนี้
size <---- ขนาดของภาพที่จะทำการแสดงขึ้นมา (กว้าง,สูง)
start <---- ขนาดและตำแหน่งของภาพเมื่อเริ่มต้น กำหนดว่ามีขนาดเป็นกี่เท่าของขนาดปกติ
end <---- ขนาดและตำแหน่งของภาพหลังการซูม กำหนดว่ามีขนาดเป็นกี่เท่าของขนาดปกติ
time <---- เวลาที่ใช้ในการซูม มีหน่วยเป็นวินาที
time_warp <---- วิธีการใช้งานเหมือนกับ Move
bilinear=True / False <---- เปิดใช้ระบบลบรอยหยักของรูปที่เรากำหนด
opaque=True / False <---- เป็น false ถ้าต้องการให้ฉากหลังของรูปโปร่งใส
ตัวอย่างการใช้งาน

    show eileen happy at FactorZoom(1.0, 1.1, 1.0) , center

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

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

 

RotoZoom (rot_start, rot_end, rot_delay, zoom_start, zoom_end, zoom_delay, rot_repeat=False, zoom_repeat=False, rot_bounce=False, zoom_bounce=False, rot_anim_timebase=False, zoom_anim_timebase=False, rot_time_warp=None, zoom_time_warp=None, opaque=True, **properties)

โดยพารามิเตอร์แต่ละตัวมีความหมายดังนี้
rot_start <---- ค่าองศาของรูปเมื่อเริ่มต้น
rot_end <---- ค่าองศาของรูปตอนจบ
rot_delay <---- เวลาในการกระทำการหมุน มีหน่วยเป็นวินาที
zoom_start <---- ขนาดของรูปเมื่อเริ่มต้น (ให้ขยายกี่เท่า) ถ้ากำหนดให้เป็น 0 ก็จะทำให้ภาพมันหดหายไป
zoom_end <---- ขนาดของรูปเมื่อจบการทำงาน (ให้ขยายกี่เท่า) ถ้ากำหนดให้เป็น 0 ก็จะทำให้ภาพมันหดหายไป
zoom_delay <---- เวลาที่ใช้ในการซูม
rot_repeat=False <---- สั่งให้หมุนใหม่(วนลูป)เมื่อหมุนเสร็จแล้ว
zoom_repeat=False <---- สั่งให้ซูมใหม่(วนลูป)เมื่อซูมเสร็จแล้ว
rot_bounce=False <---- สั่งให้หมุนกลับที่เดิมเมื่อหมุนเสร็จแล้ว
zoom_bounce=False <---- สั่งให้ซูมกลับเมื่อซูมเสร็จแล้ว
rot_anim_timebase=False <---- กำหนดให้ใช้เวลาในการหมุนแบบมาตรฐาน(ไม่รุแปลถูกรึเปล่าแต่ว่าจะเซตหรือไม่เซตค่านี้แล้วไม่เห็นความแตกต่างเลยแฮะ)
zoom_anim_timebase=False <---- กำหนดให้ใช้เวลาในการซูมแบบมาตรฐาน(ไม่รุแปลถูกรึเปล่าแต่ว่าจะเซตหรือไม่เซตค่านี้แล้วไม่เห็นความแตกต่างเลยแฮะ)
rot_time_warp=None <---- คล้ายกับ time_warp ของฟังก์ชั่น Move แต่ในที่นี้จะเป็นตำแหน่งของการหมุนแทน
zoom_time_warp=None <---- คล้ายกับ time_warp ของฟังก์ชั่น Move แต่ในที่นี้จะเป็นขนาดของการซูมแทน
opaque=True <---- เป็น false ถ้าต้องการให้ฉากหลังของรูปโปร่งใส ถ้าเป็น true ฉากข้างหลังจะออกเละๆไม่น่าดู
ตัวอย่างการใช้งาน

    show magic_circle at RotoZoom(0,360,5,0,1,1, 
                                  rot_repeat=True,rot_anim_timebase=True, 
                                  opaque=False,xalign=0.5, yalign=0.5)  

Revolve <---- เป็นการกำหนดการเคลื่อนที่ของูปที่เรากำหนดให้เคลื่อนที่ไปในแนวเส้นโค้งหรือวงกลม

 

Revolve (start, end, time, around=(0.5, 0.5), cor=(0.5, 0.5),**kwargs)

start <---- ค่าองศาเริ่มต้น(เมื่อเทียบกับจุดศูนย์กลาง)
end <---- ค่าองศาสุดท้าย(เมื่อเทียบกับจุดศูนย์กลาง)
time <---- เวลาที่ใช้ในการเคลื่อนที่
around=(0.5, 0.5) <---- จุดที่ต้องการให้รูปวิ่งผ่าน ในที่นี้อาจใช้อ้างถึงรัศมี(ระยะห่างของรูปและจุดศูนย์กลาง)ได้ด้วย กำหนดค่าโดยใช้ค่าทศนิยม(0.0-1.0) ค่าดีฟอลที่(0.5, 0.5) จะกำหนดหรือไม่ก็ได้
cor=(0.5, 0.5) <---- จุดศูนย์กลางที่ต้องการให้รูปหมุนรอบ กำหนดค่าโดยใช้ค่าทศนิยม(0.0-1.0) ค่าดีฟอลที่(0.5, 0.5) ยึดมุมขวาล่างที่จุด(0.0,0.0) จะกำหนดหรือไม่ก็ได้
**kwargs <---- เป็นชุดของพารามิเตอร์ เหมือนกับ **properties ในฟังก์ชั่น Move แต่สำหรับชุดพารามิเตอร์นี้จะเป็นพารามิเตอร์ที่ใช้รวมกับฟังก์ชั่น Motion ซึ่งผมจะไม่ขอกล่าวถึง มี 2 ตัวที่จะขอยกมาคือ repeat=False, bounce=False โดยวิธีการใช้งานนั้นเหมือนกับฟังก์ชั่น Move

ตัวอย่างการใช้งาน

    show circle at Position(xpos=200, ypos=150), Revolve(0, 360, 2)

 

เราจะเห็นว่ามีการใช้ฟังก์ชั่นPosition แทนการใช้คำสั่ง around ในฟังก์ชั่น Revolve ได้ด้วยเนื่องจาก cor จะกำหนดเป็นค่าทศนิยมแต่ Position จะสามารถกำหนดเป็นค่า พิกเซลได้ซึ่งเข้าใจง่ายกว่า

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

$ renpy.layer_at_list([ ฟังก์ชั่นต่างๆ ])

ตัวอย่างการใช้งาน

    $ renpy.layer_at_list([ Zoom((800, 600), (200, 0, 400, 300), (0, 0, 800, 600),0.5)])  
    ##หรือ
    $ renpy.layer_at_list([ Move((0, 40), (0, -40), 1.0, bounce=True, repeat=True) ])

 

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

- Sound
- การตัดฉาก(Transitions)

- Sound สำหรับในเรื่องของเสียงและเพลงใน Renpy นั้น ไฟล์ที่รองรับก็ได้แก่ .ogg, .mp2, .mp3, .wav นะครับ

เริ่มต้นจากเรื่องง่ายๆก่อนนะจ๊ะสำหรับส่วนนี้จะมีคำสั่งหลักๆอยู่ 3 ตัวด้วยครับ คือ คำสั่ง play, queue และstop 

คำสั่ง play เป็นคำสั่งที่ใช้สำหรับเปิดเพลงหรือเสียง วีธีการใช้งานคำสั่งนีมีดังนี้ครับ

"play" ( "sound" | "music" ) Name of music file 
( "fadeout" Number )?
( "fadein" Number )?
( "channel" 0-7 )?

option ต่างๆก็ได้แก่
"sound" | "music" (เลือกเอาอย่างใดอย่างหนึ่ง) เป็นการกำหนดให้รู้ว่าเสียงที่เราเอาเข้ามานั้นเป็นเสียงหรือเพลง

Name of music file หมายถึงชื่อไฟล์ของเพลงหรือเสียงที่เราต้องการครับ เราจำเป็นที่ตะต้องเขียนช่อนี้อยู่ภายใต้เครื่องหมาย “ ” ด้วยนะครับ(เพราะเป็นค่า string) ไฟล์ที่สามารถรองรับได้ก็ได้แก่ไฟล์ .ogg, .mp2, .mp3, .wav
"fadeout" Number เป็นการกำหนดว่าเมื่อปิดหรือหยุดเพลงมาแล้วเสียงมันจะค่อยลงภายในกี่วินาที ส่วน Number นั้นหมายถึงเวลาที่จะใชัให้มันค่อยลง คิดเป็นวินาที จะมีหรือไม่มีก็ได้

"fadein" Number เป็นการกำหนดว่าเมื่อเปิดเพลงมาแล้วเสียงมันจะค่อยๆดังขึ้นภายในกี่วินาที ส่วน Number นั้นหมายถึงเวลาที่จะใชัให้มันดังขึ้น คิดเป็นวินาที จะมีหรือไม่มีก็ได้

"channel" 0-7 เป็นการกำหนดแชนแนลของเสียงว่าจะให้ออกที่แชนแนลไหน มี 7 แชนแล(0-7) จะมีหรือไม่มีก็ได้ ในกรณีที่เป็น sound ค่า defaults เป็น 0 ถ้า เป็น music ค่า defaults จะเป็น 7 (แชนแนลก็คือลำโพงนะแหล่ะครับ มีอยู่ 8 ตัวคือ ลำโพงหมายเลข 0-7 ) ส่วนใหญ่การกำหนดอย่างงี้หมายถึงการเล่นเพลงหลายๆเพลงพร้อมกันในเวลาเดียวกันอ่ะนะ ประมาณว่าเปิดเพลงซ้อนกันได้ 8 เพลงในเวลาเดียวกันอ่ะนะ หรือบางทีก็มีเพลงเป็นพื้นหลังแล้วเอฟเฟคก็ช่องอื่นเป็นต้น

ตัวอย่างการใช้งานคำสั่งนี้ เช่น 

    play music "mozart.ogg"
    play sound "18005551212.ogg"
    play sound "woof.ogg"

เรามาดูอะไรที่มันออกจะซับซ้อนกว่านี้หน่อยดีกว่านะจ๊ะ

    play music [ "01.wav", "012.wav" ] fadeout 1.0 fadein 1.0 

เล่น 2 เพลงต่อกันไปเลย (จบเพลงสุดท้ายก็มาเริ่มเพลงแรกใหม่) ถ้าอยากต่ออีกเป็น 3 หรือ 4 เพลง ก็ค่อยเพิ่มต่อไปอีกเรื่อยๆนะครับ

คำสั่ง queue (คิวเพลงน่ะแหล่ะ) คำสั่งนี้เหมือนกับคำสั่ง play ก็มิปาน ต่างกันนิดหน่อยตรงที่มันไม่สามารถกำหนด fadein/fadeout ได้เท่านั้นเอง 
มีลักษณะการใช้งานดังนี้

"queue" ( "sound" | "music" ) Name of music file
( "channel" 0-7 )?

ส่วนoption ต่างๆให้ไปดูที่คำสั่ง play เอาละกันครับเพราะว่ามันเหมือนกันเด๊ะเลยล่ะ ตัวอย่างการใช้งานมีดังนี้

    queue sound "woof.ogg"
    queue music [ "a.ogg", "b.ogg" ]

คำสั่ง stop ใช้สำหรับหยุดเพลงและเสียง มีลักษณะการใช้งานดังนี้

"stop" ( "sound" | "music" )
( "fadeout" Number)?
( "channel" 0-7 )?

option ต่างๆให้ไปดูที่คำสั่ง play เช่นกันครับ ตัวอย่างการใช้งานมีดังนี้

    stop sound
    stop music fadeout 1.0

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

“hide” ชื่อตัวละคร

ตัวอย่างการใช้งานคือ 

    image eileen happy = "eileen_happy.png"
    hide eileen happy

คำสั่ง with เป็นคำสั่งที่มีไว้สำหรับกำหนดรูปแบบในการตัดฉากหรือรูปแบบในการปรากฏตัวของตัวละครครับ โดยมีหลักการใช้งานดังนี้

"with" คำสั่ง option, ตัวแปร, ฟังก์ชั่น

โดยปกติคำสั่งนี้มักจะนำหน้าหรือตามหลังคำสั่ง show ,hide ,scene
คำสั่ง option ในที่นี้นั้นเราจะรวมไปถึงตัวแปรต่างๆที่เราสามารถระบุค่าที่ต้องการจะปรับแต่งค่าต่างๆที่อยู่นอกเหนือจากนี้ได้โดยใช้ function ที่กำหนดมาให้ ฟังก์ชั่นและ optionต่างๆนั้นมีดังนี้

None <--- กำหนดว่าไม่ต้องทำอะไร
Pause(time) <---- เป็นฟังก์ชั่นที่บอกให้หยุดรอก่อนโดยตัวแปร time คือจำนวนของวินาทีที่เราต้องการที่จะหยุดรอ 
Fade(out_time, hold_time, in_time,color = '# ค่าของสี เลขฐาน16') <--- เป็นฟังชั่นที่ใช้กำหนดให้แสดง BackGround เป็นสีต่างๆที่เราต้องการก่อนแล้วค่อยทำการแสดงภาพที่เราต้องการตามขึ้นมาโดยที่ถ้าเราไม่ใส่ค่าอะไรจะให้ค่าดีฟอลเป็น สี background เป็นสีดำ เวลาในการขึ้น Background เป็น 0.5 เวลาที่ใช้ในการแสดงสี Background เป็น 0และเวลาในการแสดงภาพที่เราต้องการจะเป็น 0.5 โดยที่ค่าพารามิเตอร์ต่างๆมีความหมายดังนี้
out_time คือ เวลาในการขึ้น Background
hold_time คือ เวลาที่ใช้ในการแสดงสี Background
in_time คือ เวลาที่เปลี่ยนจาก background มาป็นรูปปกติ
color = '# ค่าของสี เลขฐาน16' คือ สีของ backgroundที่เราต้องการ
หากเราต้องการใช้เป็นแบบดีฟอลให้เรียกใช้เป็นคำสั่ง fade แทน 

ตัวอย่างการใช้งาน เช่น

    show eileen happy
    with Fade(0.3,0,0.5,color = '#FFFFFF') ####<--- จะได้เป็นแฟรชสีขาว

หรือ

    show eileen happy
    with fade ####<---- ในกรณีที่ไม่ต้องการจะกำหนดค่าอะไรใช้เป็นค่าดีฟอลแทน

Dissolve(time) <--- จะค่อยๆปรากฏภาพขึ้นมาตามเวลาที่เรากำหนดในวงเล็บ มีหน่วยเป็นวินาที หากไม่กำหนดค่าในวงเล็บ จะให้ค่าดีฟอลเป็น 0.5 วินาทีถ้าเราต้องการใช้เป็นแบบดีฟอลให้เรียกใช้เป็นคำสั่ง dissolve แทน

ตัวอย่างการใช้งาน เช่น

    show eileen happy
    with Dissolve(10) ####<---- ใช้เวลา 10 วินาทีในการปรากฏภาพขึ้นมา 

หรือ

    show eileen happy
    with dissolve ####<---- ตั้งค่าดีฟอลโดยกำหนดให้ใช้เวลา 0.5 วินาทีในการปรากฏภาพขึ้นมา

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

    show eileen happy
    with move ####<---- หากว่าเราต้องการที่จะเลื่อนตำแหน่งเราต้องใช้คำสั่งmove 
              ####      กำหนดไปทั้งตำแหน่งเริ่มและตำแหหน่งจบเลยครับ
    show eileen happy at left
    with move ####<----- จะเป็นการเลื่อนภาพจากตรงกลางมายังด้านซ้ายของจอ

moveinright, moveinleft, moveintop, moveinbottom <---- สั่งให้รูปที่กำหนดวิ่งเข้ามาจากนอกจอสู่ในจอทางด้าน ขวา / ซ้าย / บน และ ล่าง ตามลำดับ โดยปกติจะใช้ร่วมกับคำสั่ง show หรือ scene 
moveoutright, moveoutleft, moveouttop, moveoutbottom <---- สั่งให้รูปที่กำหนดวิ่งออกไปจากจอโดยวิ่งออกไปทาง ขวา / ซ้าย / บน และ ล่าง ตามลำดับ โดยปกติจะใช้ร่วมกับคำสั่ง hide
zoomin <---- ค่อยๆขยายจนกลายเป็นขนาดปกติ (ประมาณว่าผุดขึ้นมา)
zoomout <---- ค่อยๆหดตัวจนกลายเป็นหายไปเลย
zoominout <---- ให้ผลเหมือนกับ zoomin กับ zoomout หมายความว่า หากเราใช้กับคำสั่ง show หรือ scenc จะได้ผลออกมาเป็น zoomin แต่ว่าหากใช้กับคำสั่ง hide จะให้ผลออกมาเป็น zoomout
vpunch <---- เขย่าขึ้นลง
hpunch <---- เขย่าซ้ายขวา
blinds <---- เป็นการตัดฉากโดยมีลักษณะการตัดฉากเป็นแบบเปิดม่านเป็นซี่ๆ
squares <---- เป็นการตัดฉากโดยมีลักษณะการตัดฉากเป็นแบบเป็นบล็อคสี่เหลี่ยมหลายๆบล็อคขึ้นมา
wiperight <---- ตัดฉากใหม่แบบเปิดม่านไปทางขวา
wipeleft <---- ตัดฉากใหม่แบบเปิดม่านไปทางซ้าย
wipeup <---- ตัดฉากใหม่แบบเปิดม่านขึ้นข้างบน
wipedown <---- ตัดฉากใหม่แบบเปิดม่านลงข้างล่าง
slideright <---- ตัดฉากใหม่แบบเลื่อนแผ่นภาพใหม่เข้ามาทางขวา
slideleft <---- ตัดฉากใหม่แบบเลื่อนแผ่นภาพภาพใหม่เข้ามาทางซ้าย
slideup <---- ตัดฉากใหม่แบบเลื่อนแผ่นภาพใหม่มาจากข้างล่าง
slidedown <---- ตัดฉากใหม่แบบเลื่อนแผ่นภาพใหม่มาจากข้างบน
slideawayright <---- ตัดฉากใหม่แบบเลื่อนแผ่นภาพเก่าออกไปทางขวา
slideawayleft <---- ตัดฉากใหม่แบบเลื่อนแผ่นภาพเก่าออกไปทางซ้าย
slideawayup <---- ตัดฉากใหม่แบบเลื่อนแผ่นภาพเก่าออกไปทางด้านบน
slideawaydown <---- ตัดฉากใหม่แบบเลื่อนแผ่นภาพเก่าออกไปทางด้านล่าง
irisout <---- ตัดฉากใหม่แบบเป็นสี่เหลี่ยมขยายวงออกไป
irisin <---- ตัดฉากใหม่แบบเป็นสี่เหลี่ยมหดตัวเข้ามา

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

ImageDissolve (image, time, ramplen, reverse=False)

โดยพารามิเตอร์แต่ละตัวมีความหมายดังนี้
image <---- รูปขาวดำที่ต้องการ 
time <---- เวลาทั้งหมดที่ใช้ในการตัดฉาก
ramplen <---- จากตามที่แปลมันหมายถึงจำนวนพิกเซลที่ใช้ในการไล่สี(ไม่แน่ใจนะ) แต่ที่ทดลองมามันเป็นการกำหนดค่าความสมูทในการไล่สีอ่ะครับ ถ้ายิ่งมีค่ามากก็จะดูนุ่มนวลมากขึ้นเวลาที่ตัดฉาก ถ้ากำหนดค่าน้อยๆก็จะตัดฉากใหม่แบบแข็งๆแต่เร็ว
reverse=False <---- ถ้าเป็น True จะเป็นการไล่เปลี่ยนฉากใหม่โดยจะเริ่มเปลี่ยนจากสีดำก่อนแล้วค่อยๆไล่เปลี่ยนไปจนถึงสีขาวแทน

ตัวอย่างการใช้งาน

    $ circleirisin = ImageDissolve("id_circleiris.png", 1.0, 8, reverse=True)
    show eileen happy
    with dissolve
    scene black
    with circleirisin

หรือเราจะใช้เป็นอย่างงี้ก็ได้

    show eileen happy
    with dissolve
    scene black
    with ImageDissolve("id_circleiris.png", 1.0, 8, reverse=True)

- text 
- font 
- การ return และ ending
- การใช้ทางเลือกและmenu

text / font ตรงนี้อยากจะบอกว่าลักษณะการใช้งานนั้นมันเหมือนกับการใช้งานในภาษา HTML เลยล่ะ คือว่ามันจะมีลักษณะการใช้างานที่เป็น tag น่ะ โดยทั่วไปแล้วเราจะใช้งานคำสั่งลักษณะนี้ในกรอบคำพูดอ่ะนะ อย่างเช่น

e “ {b} ข้อความ {/b} , {i}italic{/i}”

เอาล่ะเรามาเริ่มดูกันเลยดีกว่าว่ามันมีอะไรกันบ้างนะจ๊ะในส่วนนี้ เหอ...เหอ...เหอ...

- {b}bold{/b} <--- ตัวหนา
- {i}italic{/i} <--- ตัวเอียง
- {u}underlined{/u} <--- ขีดเส้นใต้
- {size=8}smaller{/size} <--- กำหนดขนาด
- {size=+12}bigger{/size} <--- เพิ่มขนาด
- {size=-8}smaller{/size} <--- ลดขนาด
- {w} ข้อความ <--- เบรคการขึ้นข้อความ(พอเราคลิกแล้วมันจะไปต่อ)
- {p} ข้อความ <--- เหมือนกับ{w}แต่จะขึ้นบรรทัดใหม่ด้วย
- {image = ชื่อรูป} <--- ใส่รูปลงไป
- {color=#f00}color{/color} <--- สีของข้อความ
- {a= ชื่อของ label } ข้อความ {/a} <--- ทำลิงค์ข้อความลักษณะการทำงานจะเหมือนกับคำสั่ง jump เลยล่ะ
- {font=filename.ttf}text{/font} <--- กำหนดfont ภาษา
- {plain} text {/plain} <--- ยกเลิกตัวหนา ตัวเอียง และขีดเส้นใต้ เมื่ออยู่ภายต้คำสั่งนี้ (จะมีผลก็ต่อเมื่อเราประกาศ ตัวหนา ตัวเอียง และขีดเส้นใต้ไว้ตั้งแต่ตอนที่เราประกาศ Character)

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

centered"ข้อความ"

renpy.register_sfont(name,size,bold,italics,underline,filename,spacewidth,default_kern ,charset)

ฟังก์ชันตัวนี้นั้นเราจะประกาศอยู่ในส่วน init ของโปรแกรมครับโดยที่ parameter นั้นมีความหมายดังต่อไปนี้

name <----- ชื่อของ font (กำหนดเอง)
size <----- ขนาดของ font
bold = True/false <----- กำหนดfont ตัวหนา ถ้าไม่ประกาศถือว่าเป็น False
italics = True/false <----- กำหนดfont ตัวเอียง ถ้าไม่ประกาศถือว่าเป็น False 
underline = True/false <----- กำหนดการขีดเส้นใต้ font ถ้าไม่ประกาศถือว่าเป็น False
filename = ” ชื่อไฟล์รูปภาพ ” <----- รูปของ font ใช้เป็น .png(ตรงนี้เราต้องวาดรูปออกมาเองเป็นสายของ font แต่ผมเองก็ไม่แน่ใจเหมือนกันว่าจะต้องเรียงอักษรตามอักขระรึเปล่านะใครว่าๆลองหน้อยละกัน)
spacewidth = 4 <----- ความกว้างของการเว้นวรรค(spacebar)
default_kern = -1 <----- กำหนดระยะห่างตัวอักษรของ font ทุกตัว 
charset = u'123456......' <----- เซตของตัวอักษรที่เราต้องการให้เกมส์แสดงออกมา(ถ้าไม่กำหนดแสดงว่าเอาหมด)
kerns = {u' ตัวอักษร1 ตัวอักษร2 ' : ระยะห่างที่เราต้องการ , u' ตัวอักษร2 ตัวอักษร3' : ระยะห่างที่เราต้องการ,...} <----- กำหนดระยะห่างของตัวอักษรเป็นตัวๆไปเลยว่า A กะ B ห่างเท่าไหร่ B กะ C ห่างเท่าไหร่ (บ้าพลังมั่กๆอย่าไปเสียเวลาทำเลย หรือถ้าใครว่างๆก็ลองมาทำชุดตัวอักษรพวกนี้แจกกันก็ได้)
ตัวนี้เราสามารถสร้างได้ 2 แบบครับคือแบบประกาศไปเลยตรงนั้นกับสร้างไฟล์ประกาศและกำหนดจากภายนอกจากนั้นก็ import ไฟล์ที่เราสร้างขึ้นมาเอง

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

kerns = {u'ตัวอักษร1 ตัวอักษร2' : ระยะห่างที่เราต้องการ , u'ตัวอักษร2 ตัวอักษร3' : ระยะห่างที่เราต้องการ,...}

2. หลังจากที่เราระเบิดพลังในการเขียนเสร็จแล้วทีนี้เราก็จะมา save file ให้เรา save เป็น .py นะครับอย่าลืม(ไม่ใช่.rpy) 
3. เมื่อถึงเวลาที่เราต้องการที่จะเรียกใช้งานนั้นให้เราทำการ import ไฟล์ของเราที่สร้างไว้ในส่วน init ด้วยครับโดยมีการประกาศใช้งานดังนี้ครับ
import ชื่อไฟล์ที่เราตั้งขึ้นมาจากขอที่ 1 อ่ะครับ(ไม่ต้องมี .py นะครับ)
4. ขั้นตอนสุดท้ายก็คือการเรียกใช้งานล่ะครับการเรียกใช้งานก็ดังนี้ครับ

kerns = ชื่อไฟล์ที่เราตั้งขึ้นมาจากขอที่ 1 .kerns <------ เช่น kerns = testfont.kerns (ไม่ต้องมี “ ”)

หน้า main.rpy
    Codeบรรทัดที่ 1.......
    Codeบรรทัดที่ 2.......
    Codeบรรทัดที่ 3.......
    Call A
    Codeบรรทัดที่ 4.......
..........

 

หน้า A.rpy
    Codeบรรทัดที่ 1.......
    Codeบรรทัดที่ 2.......
    Codeบรรทัดที่ 3.......
    return

2. การ return ค่า จะคล้ายๆกับ ending แต่จะมีค่าตัวแปรตามออกมาด้วหลังจากจบโปรแกรมย่อยที่เราเขียนโดยปกติจะนิยมใช้ในการเขียน function ซึ่งการเขียนฟังก์ชั่นนั้นผมจะขกล่าวในบทหลังๆครับ ลักษณะการใช้งานคือ

return ตัวเลข / ค่าตัวแปร / ค่าString

Menu และทางเลือก ต่อมาก็เป็นการเลือก,ส่งค่าและแสดง menuซึ่งถือได้ว่าเป็นคำสั่งยอดฮิตของเกมส์แนวนี้เลยก็ว่าได้เอาล่ะเรามาดูกันดีกว่าว่ามันจะมีลักษณะการใช้ Menu ยังไง

“menu” name : <--------- name ในที่นี้หมายถึง ชื่อ Label ของmenu นี้(กำหนดเอง)
    “ข้อความคำถามของทางเลือกนั้น”
    "ทางเลือก 1" : <--------- ข้อความที่จะแสดงบนทางเลือกนั้น
        Codeบรรทัดที่ 1.......
        Codeบรรทัดที่ 2.......
        Codeบรรทัดที่ 3.......
    "ทางเลือก 2" if (XXXX) : <--------- เรายังสามารถที่จะใช้ คำสั่งif ภายในคำสั่ง menu ได้ด้วย
        Codeบรรทัดที่ 1.......
        Codeบรรทัดที่ 2.......
        Codeบรรทัดที่ 3.......
    ...............
        ...............
    with dissolve <--------- นอกจากนี้เรายังสามารถกำหนดลักษณะการปรากฏของ menu ด้วยคำสั่ง with ได้อีกด้วย 

ส่วนหากอยากจะรู้ว่าการใช้คำสั่ง with โดยต้องการที่จะตั้งเป็นค่าอื่นๆนอกจาก dissolve นั้นามารถอ่านเพิ่มเติมได้จากที่นี่ Transitions

หมายเหตุ เวลาที่เขียนคำสั่งนี้เราต้องล่นบรรทัดเข้ามาด้วยครับ ดังรูป

เอาล่ะครับเพื่อความต่อเนื่องในการศึกษาผมก็จะรีบๆสอนต่อละกันครับสำหรับเนื้อหาในตอนที่ 2 ที่ผมจะหยิบยกขึ้นมานั้นก็จะเกี่ยวข้องกับเรื่อง

- การใช้ตัวแปรเบื้องต้น (python)
- กรอบคำพูด (Character)
เห็นว่าหัวข้อน้อยๆอย่างงี้ก็เห่อะยุ่งยากพอดูเลยล่ะ

การใช้ตัวแปรเบื้องต้น(Python)
python แปลตรงตัว หมายถึง งูใหญ่ , งูเหลือม , อนาคอนด้า ฯลฯ หรืออีกความหมายหนึ่งหมายถึง การสิงสู่ ,การเข้าสิง
python ตามความหมายของในที่นี้นั้นก็คือกำหนดเรียกใช้งานภาษา Python ครับซึ่งมันก็จะรวมไปถึงเรื่องที่เกี่ยวของกับตัวแปรด้วยครับ
ตัวแปรนั้นเปรียบเสมือนแฟ้มที่คอยทำหน้าที่เก็บข้อมูลต่างๆที่จำเป็นต่อการทำงานของโปรแกรมเอาไว้ โดยปกติแล้วเราจะนิยมประกาศค่าตัวแปรไว้ในส่วน init ครับ การประกาศค่าตัวแปรpythonใน Ren’py นั้นแบ่งการใช้งานได้ 2 ลักษณะคือ

1 .) ประกาศค่าบรรทัดเดียว การเรียกใช้งานก็แสนจะง่ายจนน่าตกใจครับ

“$” name “=” ค่าตัวแปร 

ตัวอย่าง
$ e = 30
$ d = “hello”

ส่วนเวลาที่เราจะตั้งชื่อตัวแปรมันยังไงก็ได้นะครับขออย่างเดียวว่าอย่าไปตั้งซ้ำกับ keyword ของมันก็พอครับ
keyword ของภาษานี้มีดังนี้ครับ
http://www.renpy.org/wiki/renpy/doc/reference/The_Ren%27Py_Language#head-a34a0457ffbdae8847e5808b40f058ab85619167

2 .) แบบหลายบรรทัด การทำงานในรูปแบบนี้ค่อนข้างแปลกๆไปหน่อย คือเป็นการประกาศทีละหลายบรรทัดไปเลย มันจะเป็นตัวที่ทำหน้าที่ mark ให้โปรแกรมรู้ว่าตำแหน่งนี้เป็นส่วนของการประกาศ function หรือ ใช้ประกาศค่า array และการเรียกใช้งานเกี่ยวกับ UI Function การเรียกใช้งานก็แสนจะง่ายจนน่าตกใจกว่าอันแรกอีกครับ

“python :”
ตัวอย่าง
python :
    e = 30
    d = “hello”
    q = true

ตัวแปรที่มีการประกาศอยู่ภายใต้คำสั่ง python ไม่ต้องใส่ “$” ที่หน้าตัวแปรนะครับ แล้วอย่าลืมล่นย่อหน้าเข้ามา 4 ครั้งด้วยนะครับ

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

$ name “=” “[” ค่าต่างๆ1 , ค่าต่างๆ2 , ... “]”
ตัวอย่าง
$ exam = [1,2,3,4,5,6]

หากเวลาเราต้องการเรียกใช้งานตัวแปร array ก็เพียงแค่ ประกาศตามนี้

$ name[ตัวเลข]
ตัวอย่าง
$ exam[0]      ---> ค่าของตัวแปรตัวนี้ตือ 1
$ exam[1]      ---> ค่าของตัวแปรตัวนี้ตือ 2

หากเราประกาศค่าภายใต้คำสั่ง python เราไม่ต้องใส่ $ ที่หน้าตัวแปรนะครับ
ตัวเลขในที่นี้หมายถึงลำดับช่องของอเรย์ที่เราต้องการ(เราสามารถใส่เป็นค่าตัวแปรแทนตัวเลขก็ได้นะครับถ้าหากว่าค่าตัวแปรเป็นชนิดตัวเลข int)


ต่อมาก็จะเป็นการนำค่าตัวแปรมาแสดงในเฟรมคำพูด

“ข้อความ %(ตัวแปร)s”
ตัวอย่าง 

$ exam = [1,2,3,4,5,6]

$ first = exam[0]
$ name = “vashiya”

“สวัสดีคุณ %(name)s”
“ตัวเลขในตำแหน่งแรกของคุณคือ %(first)d”

ข้อสังเกต จากตัวอย่างข้างต้นเราจะเห็นว่าค่าตัวแปรภายในวงเล็นนั้นไม่จำเป็นต้องใส่ $
อีกทั้งเรายังไม่สามารถนำค่าตัวแปรที่เป็นชนิด Array มาใส่ลงในข้อความได้โดยตรง แต่เราต้องทำการฝากค่าผ่านตัวแปรตัวอื่นแล้วนำมาแสดงผลลงในข้อความอีกทีหนึ่งครับ (ในที่นี้ปมตั้งชื่อตัวแปรนั้นว่า first ครับ)
จะเห็นว่าเราจะต้องมี “%( )s” ครอบตัวแปรที่เราต้องการแสดงไว้เท่านี้เราก็สามารถแสดงค่าต่างๆออกมาได้แล้ว โดยที่ตัวอักษรข้างหลังวงเล็บนั้นจะเป็นตัวที่กำหนดว่าตัวแปรที่ต้องการแสดงออกมานั้นเป็นตัวแปรชนิดไหน

“%( )s” จะแสดงตัวแปรที่เป็นค่า string(ตัวอักษรต่างๆ)
“%( )d” จะแสดงตัวแปรที่เป็นค่า int (ค่าตัวเลขต่างๆ)
“%( )f” จะแสดงตัวแปรที่เป็นค่า ทศนิยม

ที่ยกมาคือตัวที่ใช้บ่อยที่สุดยังมีรูปแบบอื่นๆอีกลองหาดูละกัน http://www.python.org/doc/2.3.5/lib/typesseq-strings.html

หลังจากที่เราเกริ่นเกี่ยวกับการ output ค่ากันมาบ้างแล้ว ต่อไปเราจะมาพูดเกี่ยวกับการ input ค่ากันบ้างนะครับ
หากว่าเราต้องการใส่ตัวอักษรอะไรให้เกมส์เหมือนกับตอนที่เราป้อนชื่อตัวเราเองลงไปในตอนเริ่มเกมส์ทั่วไปน่ะแหล่ะครับ
มีการประกาศใช้งานดังนี้ครับ

$ ชื่อตัวแปร = renpy.input(‘ข้อความ’)
ตัวอย่าง
$ name = renpy.input(‘กรุณาพิมพ์ชื่อของคุณ’)

 

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

สำหรับส่วนในการแสดงส่วน input นี้ให้เป็นภาษาไทยนั้นให้เราทำการเปลี่ยน font ให้เป็น font ที่รองรับภาษาไทยได้ ประมาณบรรทัดที่ 150 ในไฟล์ option.rpy

style.default.font = " angsa.ttf " <------ เคยอธิบายไปแล้วในเรื่องการปรับแต่งค่าก่อนการสร้างเกมส์ อย่าลืมลบ # ออกก่อนล่ะ

โดยที่เราจะต้องทำการ Copy File font ภาษาไทยของเรามาลงใน Folder game ของเราก่อนนะครับทีนี้เนี่ยะมันก็จะสามารถแสดงผลภาษาไทยได้ทั้ง Inputและ Output เลยล่ะ

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

Character ( name , Keyword Arguments1 , Keyword Arguments2 , ... )

name หมายถึง ชื่อของตัวละครหากไม่ต้องการจะแสดงชื่อให้พิมพ์ None ซะ โดยปกติไม่สามารถพิมพ์ภาษาไทยได้ หากต้องการให้พิมพ์ภาษาไทยได้ต้องแก้ไขดังนี้

$ name = file(config.gamedir + "/ชื่อไฟล์ที่เก็บชื่อตัวละครไว้.txt ").read().decode("utf-8") <------เพิ่มคำสั่งบรรทัดนี้ลงไป
$ a = Character(name, color="#c8ffc8", what_font="ชื่อของ font ภาษาไทย", font="ชื่อของ font ภาษาไทย") <----- จากนั้นก็ประกาศค่าตามปกติ

หนึ่ง ชื่อก็หนึ่งไฟล์ไปเลยนะครับไม่ต้องงก ตอนที่ save ไฟล์ .txt ให้ save เป็นชนิด UTF-8 ด้วย <----- (ตรงนี้สำคัญมากๆ)

Keyword Arguments หมายถึง option ต่างๆที่เราจะกำหนดลงไปมีมากมายหลายตัวจะขอยกมาแค่ตัวที่พบบ่อยๆละกัน

- color = "#c8ffc8" <--- สีชื่อของตัวละคร
- what_color="#000" <----- กำหนดสีของtext
- what_font="angsananew" <----- กำหนด font ของ text ในเฟรม
- font = "angsananew" <----- กำหนด font ของชื่อตัวละคร
- who_prefix = “ตัวอักษร” <----- กำหนดให้ตัวอักษรที่เราตั้งไว้นำหน้าชื่อตัวละครเสมอ
- who_suffix = “ตัวอักษร” <----- กำหนดให้ตัวอักษรที่เราตั้งไว้ตามหลังชื่อตัวละครเสมอ
- what_prefix = “ตัวอักษร” <----- กำหนดให้ตัวอักษรที่เราตั้งไว้นำหน้าข้อความเสมอ
- what_suffix = “ตัวอักษร” <----- กำหนดให้ตัวอักษรที่เราตั้งไว้ตามหลังข้อความเสมอ
- window_left_margin = 200 <----- กำหนดให้เฟรมอยู่ห่างจากจอด้านซ้ายไปกี่พิกเซล
- window_right_margin = 200 <----- กำหนดให้เฟรมอยู่ห่างจากจอด้านขวาไปกี่พิกเซล
- window_xmargin=20 <----- กำหนดให้เฟรมอยู่ห่างจากจอด้านซ้ายและขวาไปกี่พิกเซล
- window_ymargin=30 <----- กำหนดให้เฟรมอยู่ห่างจากจอด้านบนและล่างไปกี่พิกเซล
- window_yfill=True <----- กำหนดให้เฟรมมีขนาดใหญ่เต็มจอ
- window_yminimum = 300 <----- กำหนดความสูงของเฟรม
- what_underline = True <----- กำหนดให้ขีดเส้นใต้ใต้ข้อความเสมอ
- show_two_window = True <----- กำหนดให้แยกชื่อตัวละครกับเฟรมคำพูดออกมาอยู่คนละเฟรม
- show_side_image = “ชื่อภาพ” <----- กำหนดรูปไว้ในกรอบคำพูด โดยปกติแล้วมักจะประกาศรวมอยู่กับฟังก์ชัน image สามารถเรียกใช้งานได้ดังนี้

show_side_image = image(“ชื่อภาพ”, ypos=380, xpos=100) โดยที่
ypos = 380 <----- ตำแหน่งของภาพที่จะแสดงในแกน y
xpos = 100 <----- ตำแหน่งของภาพที่จะแสดงในแกน x

- ctc = “ ชื่อภาพ “ <----- รูปภาพท้ายข้อความเวลาจะขึ้นข้อความใหม่(สามารถใช้ร่วมกับ ฟังก์ชัน animetion ได้ ซึ่งจะขอกล่าวในบทถัดไป)
- ctc_position = "nestled" / "fixed" <----- “nestled” รูปภาพท้ายข้อความจะขึ้นอยู่ที่ท้ายข้อความ ในขณะที่ “fixed” จะทำให้ภาพไปอยู่ที่มุมขวาล่างของกรอบข้อความเสมอ
- window_background = None <------ ไม่ต้องการให้มีเฟรมคำพูด
- show_say_vbox_properties = dict( xalign=0.5 , yalign=0.5) <----- กำหนดให้ตัวหนังสือทั้งหมดอยู่ห่างจากเฟรมด้านซ้าย(x) และเฟรมด้านบน(y) ตามที่เรากำหนด 

ที่เหลือสามารถอ่านเพิ่มเติมได้ในนี้ครับ http://www.renpy.org/wiki/renpy/doc/reference/Properties_and_Styles

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

               สำหรับวิธีการในเวอร์ชั่นใหม่นั้นเราก็จะประกาศเพียงแค่


               $ a = Character("ชื่อภาษาไทย", color="#c8ffc8", what_font="ชื่อ font ภาษาไทยของคำพูดตัวละครนั้น.ttf", font="ชื่อ font ภาษาไทยของชื่อตัวละคร.ttf") 

               ตัวอย่าง
               $ e = Character("ไอรีน",color="#c8ffc8",font="angsa.ttf",
what_font="angsa.ttf" ) 

               # เวลาจะใช้งานก็ประกาศแล้วเขียนภาษาไทยตามปกติเลย
               e "ภาษาไทย"


               เท่านี้ก็สามาเราเรียกใช้ภาษาไทยได้หมดแล้วครับ ที่เหลือก็เพียงแค่ Copy ไฟล์ Font ภาษา                  ไทยมาไว้ใน Folder Game ของเราก่อนเท่านั้นเองครับ
 

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