Ruby สู่การเขียน RGSS Part 2 - เข้าใจภาษา Ruby, ฝึกใช้ตัวเลข, ข้อความ, ตัวแปร

หมายเหตุ

• บทความชุด "Ruby สู่การเขียน RGSS" นั้น แบ่งออกเป็นหลาย part และมีเนื้อหาเรียงลำดับ หากยังไม่ได้อ่าน part ก่อนหน้าบทความนี้ ให้ไปอ่านก่อนครับ มิฉะนั้นอาจงง หรือตามไม่ทันครับ
  
• อ่านจบแล้วโปรดทิ้งความคิดเห็นและข้อเสนอแนะไว้ด้วยนะคร้าบ
  

---

ในบทความนี้เราจะมาเริ่มเขียนภาษา Ruby กันจริงๆ จังๆ เสียที ซึ่งใน part ที่แล้วเราได้ลองอุ่นเครื่องด้วยการเขียนโค้ดเล็กๆ น้อยๆ และสังเกตผลลัพธ์จาก console ในบทความนี้ก็เช่นกัน เรายังคงอยู่ที่หน้าจอ console ตลอดการเรียน

ไฟล์ Hello World ที่สร้างมาในบทความที่แล้ว ให้ลบทิ้งไปได้เลย แล้วต่อจากนี้ถ้ามีการเขียนโค้ด ให้สร้างไฟล์เปล่าและตั้งชื่อเองนะ

เนื้อหาในบทความนี้

1. คุณลักษณะในภาษา Ruby
   
2. ตัวเลข, จำนวน
   
3. ข้อความ
   

1. คุณลักษณะในภาษา Ruby
ก่อนที่จะเริ่มเขียนโปรแกรมกันเป็นเรื่องราว อยากให้ทราบถึงคุณลักษณะบางอย่างก่อน เพราะไม่งั้นอาจเกิดปัญหาระหว่างการเขียนโปรแกรมได้ ซึ่งคุณลักษณะของภาษา Ruby นั้นมีดังนี้

Case Sensitive
ไม่ว่าจะเป็นตัวแปร หรือคำสั่งใดๆ ก็ตาม ภาษาอังกฤษแม้จะเป็นคำเดียวกัน แต่มีตัวเล็กตัวใหญ่ต่างกัน ก็ถือว่าเป็นคนละตัวกัน เช่น name จะถูกมองเป็นคนละตัวกับ Name

ลองสร้างไฟล์เปล่าขึ้นมาไฟล์หนึ่ง แล้วเขียนโค้ดดังนี้
[shcode=rails]
money = 500
puts "My money is #{money}"
puts "My money is #{moneY}"
[/shcode]
ถ้ารันแล้วแฮงก์ไม่ต้องตกใจ ดูว่าผลลัพธ์ได้ประมาณนี้หรือไม่


หากเราเขียนโค้ดผิดพลาดจนโปรแกรมไม่สามารถทำงานต่อได้ มันก็จะขึ้น error และจบโปรแกรมลงทันที และให้ลองสังเกตดูคร่าวๆ ว่ามันขึ้น error ว่าอย่างไร ซึ่งมันเขียนว่า undefined local variable or method 'moneY' ... ซึ่งแปลได้ว่า ไม่เคยมีการกำหนดค่าตัวแปร moneY ขึ้น จึงไม่สามารถเรียกค่าได้

กล่าวคือ money นั้น จะถูกมองเป็นคนละตัวกับ moneY นั่นเอง และเราไม่เคยกำหนดค่าของ moneY เอาไว้ พอโปรแกรมอ่านโค้ดบรรทัดที่ 3 ที่ต้องแสดงผล moneY มันเลยไม่รู้จะเอาอะไรมาแสดง จึงแจ้ง error ขึ้นมา

Comments
หากเราเขียนโค้ดเอาไว้ แล้วไม่ต้องการใช้งานโค้ดบรรทัดนั้นชั่วคราว หรือต้องการเขียนอธิบายในตัวโค้ด ในภาษา Ruby สามารถทำได้ โดยใส่เครื่องหมาย # หน้าโค้ดที่เราเขียน ให้เราลองเขียนโค้ดดังนี้ (ลบโค้ดเก่าออกก่อนด้วยนะ)
[shcode=rails]
puts "Hello World!"
#puts "Invisible man!"

#Look at the code below
#This is my information
puts "My name is Splendith."

#The end of the code
[/shcode]
เมื่อกดรันแล้ว สังเกตว่าผลลัพธ์จะขึ้นเพียง
Hello World!
My name is Splendith.
เพราะในบรรทัดอื่นนั้นมีเครื่องหมาย # นำหน้า ทำให้โปรแกรมจะข้ามการอ่านบรรทัดนั้นไป

ทีนี้หากต้องการ comment ทีละหลายบรรทัด การมานั่งเขียน # ทุกบรรทัดคงไม่สะดวกแน่ วิธีการ comment ทีละหลายบรรทัดนั้น ให้ใส่ =begin, =end ครอบหัวท้าย ดังตัวอย่างต่อไปนี้
[shcode=rails]
puts "Hello world!"
=begin
puts "My name is Splendith."
puts "I am 23 years old."
puts "Today is a nice day."

money = 4000
puts "I have #{money} baht."
=end
puts "Good bye!"
[/shcode]
ผลลัพธ์จะขึ้นเพียง
Hello world!
Good bye!

Statement Delimiters หริอตัวคั่นคำสั่ง
โดยปกติแล้วภาษา Ruby ที่เราเขียนนั้น เราจะเขียน 1 คำสั่ง ต่อ 1 บรรทัดใช่ไหมครับ ตัวอย่างเช่นเราเขียน คำสั่ง puts ตามด้วยข้อความ บรรทัดหนึ่ง ถ้าต้องการเขียนคำสั่งอื่นๆ ก็ต้องเขียนบรรทัดใหม่ถูกไหมครับ เราไม่มีทางเขียนแบบนี้ได้
[shcode=rails]
puts "Hello world!" puts "Good bye!"
[/shcode]
เพราะโปรแกรมมันไม่สามารถแยกได้ว่า puts ด้านขวานั้นคืออีกคำสั่งหนึ่ง
แต่อย่างไรก็ตาม หากต้องการเขียนหลายๆ คำสั่งใน 1 บรรทัดนั้น ให้เราใช้เครื่องหมาย semicolon ( ; ) ในการแบ่งคำสั่ง
[shcode=rails]
puts "Hello world!"; puts "Good bye!"
[/shcode]
ซึ่งก็จะสามารถรันได้แล้วโดยไม่มีปัญหา แต่สังเกตว่าในหน้าจอ console นั้น ข้อความ Hello world! ก็ยังคงอยู่คนละบรรทัดกับข้อความ Good bye! ในจุดนี้อย่างงนะครับ เพราะโดยปกติของคำสั่ง puts อย่างที่บอกว่ามันจะทำการขึ้นบรรทัดใหม่หลังจบข้อความเสมอ ไม่ว่าเราจะเขียนโค้ดบรรทัดเดียวกัน หรือคนละบรรทัด หรือจะเว้นห่างกันกี่บรรทัดก็ตาม

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

Reserved Words
คำบางคำไม่สามารถนำมาใช้งานได้ เนื่องจากเป็นคำที่จองไว้เป็นคำสั่งของระบบ เช่นหากเขียนโปรแกรมดังนี้
[shcode=rails]
name = "Splendith"
class = "Magician"

puts "My name is #{name}. My class is #{class}"
[/shcode]
เมื่อรันแล้วจะเกิด error ขึ้น เนื่องจากคำว่า class นั้น เป็นคำเฉพาะที่ภาษา Ruby เอาไว้ใช้งานเฉพาะทาง วิธีดูว่าคำไหนที่เป็นคำเฉพาะทาง มันจะเป็นตัวอักษรสีน้ำเงิน เราไม่ควรเอามาตั้งเป็นชื่อตัวแปร

ทั้งนี้ จากข้อแรกที่เราบอกว่าเป็น case sensitive ดังนั้น ถ้าเปลี่ยนจาก class เป็น Class ก็จะใช้งานได้ปกติ (แต่ในทางปฏิบัติก็ไม่ควรใช้อยู่ดีครับ เพราะเดี๋ยวจะมึนซะเปล่า)

2. ตัวเลข, จำนวน
ในเนื่อหาส่วนนี้ จะมีเล่นกับตัวเลขทั้งหลายกันครับ

การแสดงผลตัวเลข
เราจะใช้ puts เช่นเดิม และตามด้วยตัวเลขได้เลย โดยไม่ต้องมีเครื่องหมายฟันหนู
[shcode=rails]
puts 15.8
[/shcode]

Operators
เครื่องหมายในการคำนวณนั้น ตามวิชาคณิตศาสตร์ที่เราเรียนกันเลยครับ นั่นคือ บวก ( + ), ลบ ( - ), คูณ ( * ) และหาร ( / ) นอกจากนี้ยังมีเครื่องหมายยกกำลัง ( ** ) และเครื่องหมาย modulo ( % ) ซึ่งหมายถึงการคืนค่าเศษจากผลหาร

มาลองเขียนกันเล่นๆ ครับ
[shcode=rails]
puts 5
puts 5 + 2
puts 2 - 14
puts 4 * 3
puts 1.5 / 4
puts 11 % 3
puts 8 ** 3
puts 4 * 2 + 3 - 1
[/shcode]
ผลลัพธ์ที่ได้


ในบรรทัดที่ 6 นั้น 8 % 3 คือ นำ 11 ไป หารด้วย 3 ได้ 3 เศษ 2 แล้วนำ 2 มาตอบ
ในบรรทัดที่ 7 นั้น 8 ** 3 หมายถึง 8 ยกกำลัง 3 ได้ 512
ในบรรทัดที่ 8 เราสามารถใส่เครื่องหมายทางคณิตศาสตร์ต่อกันไปเรื่อยๆ ได้

นอกจากนี้ยังสามารถกำหนดตัวแปรให้มีค่าเป็นตัวเลขได้
[shcode=rails]
a = 5
b = 10
puts a + b
puts "a - b is #{a - b}"
[/shcode]
ผลลัพธ์ ก็จะได้ 15 และ a - b is -5 ตามลำดับ

และยังสามารถเพิ่มค่า-ลดค่าตัวแปรเดิมได้ เช่น
[shcode=rails]
money = 500
money = money + 1000
puts money
[/shcode]
ผลลัพธ์คือ 1500 เพราะได้เพิ่มค่าตัวแปรตัวเองไปอีก 1000 จาก 500

และเราสามารถยุบโดยเขียนแบบนี้ได้
[shcode=rails]
money = 500
money += 1000
puts money
[/shcode]
ผลลัพธ์จะได้ 1500 เช่นกัน

นอกจากนี้ยังใช้ -=, *=, /=, %=, **= ได้ด้วย

ทีนี้มาดูอะไรที่มัน advance ขึ้นนิดนึง
ให้เขียนโค้ดด้านล่าง แล้วก่อนรันเกม ลองทายดูก่อนว่าแต่ละอันได้ผลลัพธ์อะไรบ้าง
[shcode=rails]
puts 5 - 3 * 2 ** 3
puts 7 / 2
puts 1 / 5
[/shcode]
หากไม่เคยเขียนโปรแกรม ท่านอาจจะงงเป็นไก่ตาแตกว่าทำไมผลลัพธ์มันเพี้ยนหลุดโลกเช่นนี้ ลองดูผลลัพธ์ที่ได้กันครับ



พิจารณาบรรทัดที่ 1 :: 5 - 3 * 2 ** 3
จากหลักสากลทุกภาษาแทบทั่วโลกนั้น เราจะทำตัวเลขที่มีเครื่องหมายที่มีความสำคัญมากกว่าก่อน ซึ่งลำดับความสำคัญของเครื่องหมายนั้นเรียงดังนี้

1. วงเล็บ
   
2. **
   
3. *, /, %
   
4. +, -
   

หมายเหตุ: หากเจอเครื่องหมายลำดับเดียวกัน ให้ทำจากซ้ายไปขวา

ดังนั้น ในข้อดังกล่าว เราจะทำ 2 ** 3 ก่อน แล้วค่อยเอา 3 มาคุณ จากนั้นค่อยเอา 5 มาลบ ซึ่งเราสามารถจัดนิพจน์ใหม่ได้ดังนี้คือ (5 - (3 * (2 ** 3))) คำตอบก็จะได้ -19 เหมือนที่แสดงในหน้าจอ console เด๊ะๆ

ในบรรทัดที่ 2 - 3
หลักการสากลของทุกภาษาส่วนใหญ่นั้น (ย้ำว่าส่วนใหญ่) หากเราทำเลขจำนวนเต็ม ไปกระทำใดๆ ก็ตามกับเลขจำนวนเต็ม ค่าที่ออกมาจะได้เลขจำนวนเต็มเสมอ หากมีเศษให้ตัดทิ้งทันที จึงเป็นเหตุผลว่าทำไมผลลัพธ์ออกมาเป็นเลขกลมๆ
ซึ่งถ้าหากต้องการให้ผลลัพธ์ออกมาเป็นทศนิยม เราต้องดัดแปลงนิดหน่อยดังนี้
[shcode=rails]
puts 7.0 / 2 # หรือ 7 / 2.0 หรือ 7.0 / 2.0
puts 1.0 / 5 # หรือ 1 / 5.0 หรือ 1.0 / 5.0
[/shcode]
ผลลัพธ์ก็จะได้ 3.5 และ 0.2 ตามลำดับ ทั้งนี้เพราะมันมีหลักการว่า หากนำจำนวนจริง ไปกระทำใดๆ ก็ตามกับจำนวนเต็ม มันจะได้จำนวนจริงเสมอ ดังนั้นค่าที่ออกมาจึงเป็นจำนวนจริงมีทศนิยม

หมายเหตุ: จำนวนเต็มคือจำนวนที่ไม่มีทศนิยม ส่วนจำนวนจริงในภาษาคอมพิวเตอร์จะมีทศนิยมเสมอ การแทนจำนวนเต็มให้โปรแกรมเข้าใจเป็นจำนวนจริง จะต้องใส่ .0 เสมอ

ทีนี้ลองทำข้อนี้ดูครับ 4 - 2 * 3 / 4 + 5 ** (3 - 1) / 3 ได้เท่าไหร่เอ่ย?
หากคิดแล้วก็ลองเอาไปใส่ในโปรแกรมแล้วรันดู ถ้าคำตอบตรงกับที่คิด แปลว่าท่านเข้าใจแจ่มแจ้งเลยล่ะ

3. ข้อความ
ที่ผ่านมาเราได้คุ้นเคยกับข้อความไปบ้างแล้ว สิ่งที่ท่านน่าจะสังเกตได้คือ มันจะมีฟันหนู ( " ) ครอบเสมอ นั่นแหละเราจะเรียกมันว่าข้อความ หรือภาษาอังกฤษจะใช้คำว่า string

การแสดงผลข้อความ
ผ่านมาจุดนี้ทุกคนคงได้คำตอบแล้วล่ะ นั่นคือใช้คำสั่ง puts ตามด้วยข้อความคร่อมด้วยฟันหนู
[shcode=rails]
puts "Hello world!"
[/shcode]

การต่อข้อความ
เราจะใช้เครื่องหมาย + ในการต่อข้อความ เช่น
[shcode=rails]
puts "Hello" + "world!"
puts "Hello " + "world!"

name = "Splendith"
puts "Hello, " + name
puts "Hello, #{name}"
[/shcode]

ผลลัพธ์


สังเกตว่าในบรรทัดที่ 1 หากเราต่อข้อความ มันจะไม่ใส่เว้นวรรคให้ ต้องเพิ่มเองให้เหมือนบรรทัดที่ 2
ในบรรทัดที่ 4 เรากำหนดตัวแปร name ให้มีค่า "Splendith"
ในบรรทัดที่ 5 เราสามารถเอาข้อความไปต่อกับตัวแปรที่เป็นชนิดข้อความได้เลย หรือสามารถทำแบบบรรทัดที่ 6 เหมือนที่เคยทำในตัวอย่างก่อนๆ ก็ได้ ผลลัพธ์เหมือนกัน

การทวีคูณข้อความ
ในภาษา Ruby มีท่าพิเศษที่เราสามารถเอาข้อความไป * กับตัวเลขได้ด้วย
[shcode=rails]
puts "Hello" * 4
[/shcode]

ผลลัพธ์ก็จะได้ HelloHelloHelloHello
หรือถ้าเราต้องการเส้นคั่นเก๋ๆ
[shcode=rails]
puts "--------------------------------------------------"
[/shcode]
เราสามารถเขียนเป็น
[shcode=rails]
puts "-" * 50
[/shcode]
ได้เลย โหดฝุดๆ ^^

Escape Characters

ทีนี้มาดูตัวอย่างที่มัน advance ขึ้นอีกนิด
[shcode=rails]
puts "The length of a standard ruler is 12" or 1' or 30 cm."
[/shcode]
เมื่อรันแล้วจะพบว่ามัน error ใช่ไหมครับ พอจะเดาได้ไหมว่าเป็นที่อะไร?
หากมองไม่ออก ไม่เป็นไรครับ เราบอกว่า string ต้องคร่อมด้วยฟันหนู ( " ) ถูกไหมครับ แต่เจ้ากร๊รม ในข้อความของเราก็ดันมีเครื่องหมาย " ในนั้น (12") ทำให้โปรแกรมมันมองว่า เครื่องหมาย " หลังเลข 12 คือการจบข้อความ แล้วก็ ต่อด้วย or 1' or 30 cm." อะไรไม่รู้ข้างหลัง มันอ่านไม่ได้ มันเลย error ขึ้น

วิธีการแก้นั้นไม่ยาก มันจะมีสิ่งที่เรียกว่า escape character ซึ่งมีแทบทุกภาษาเช่นกัน

• \" ใช้แทนเครื่องหมาย " ในข้อความ
  
• \\ ใช้แทนเครื่องหมาย \ ในข้อความ
  
• \n ใช้แทนขึ้นบรรทัดใหม่ในข้อความ
  
• \t ใช้แทนการเคาะ tab ในข้อความ
  
• และยังมีอย่างอื่นอีก ซึ่งจะไม่ลงที่นี่
  

ว่าแล้วก็ลองแก้ดูครับ โดยเปลี่ยนจาก 12" เป็น 12\"
[shcode=rails]
puts "The length of a standard ruler is 12\" or 1' or 30 cm."
[/shcode]
ทีนี้โปรแกรมก็จะมองว่า \" คือ เครื่องหมาย " ที่อยู่ด้านในข้อความ มิใช้เครื่องหมายปิดข้อความแต่อย่างใด

ผลลัพธ์


มาลองดูอีกตัวอย่างหนี่งดู
[shcode=rails]
puts "Thai flag has 3 colors\n1. red\n2. white\n3. blue"
[/shcode]
ผลลัพธ์


อันนี้เป็นตัวอย่างการขึ้นบรรทัดใหม่ให้ดู ซึ่งจริงๆ แล้วควรจะเขียนแยกบรรทัดกันเพื่อง่ายต่อการอ่านครับ

Single Quote
นอกจากการใส้ข้อความในเครื่องหมายฟันหนู ( " ) หรือ double quote แล้ว ยังสามารถใส่ในเครื่องหมาย ( ' ) หรือ single quote (ภาษาไทยเรียก เครื่องหมายฝนทอง *0*) ได้อีกด้วย เช่น

Code:

puts 'Hello world!'

การครอบด้วย ' ยังสามารถใช้เครื่องหมาย " ด้านในโดยไม่ต้องเขียน \"
การครอบด้วย " ยังสามารถใช้เครื่องหมาย ' ด้านในโดยไม่ต้องเขียน \' เช่นกัน

Code:

puts '12" = 30 cm'
puts "1' = 30 cm"

แต่ๆๆๆๆๆๆๆๆๆๆๆๆๆๆๆๆๆๆๆๆๆๆๆๆๆๆๆๆๆๆๆๆๆ
เครื่องหมาย ' นั้น ไม่รองรับ escape character นอกจาก \\ และ \' และไม่รองรับการแทนนิพจน์ด้วย #{} ลองดูได้จากตัวอย่างนี้ครับ

Code:

name = "Splendith"
puts "Hello, #{name}.\tToday is a nice day!"
puts 'Hello, #{name}.\tToday is a nice day!'

ผลที่ได้


ผลลัพธ์จากเครื่องหมาย ' นั้นจะไม่แทนตัวแปรและ escape character ลงไป และยังคงข้อความเดิมไว้

ข้อควรระวัง
ให้ดูตัวอย่างดังต่อไปนี้ครับ
[shcode=rails]
money = 500
puts "I have " + money + " baht."
[/shcode]
เมื่อรันดู จะพบกับ error เนื่องจากเราไม่สามารถเอาข้อความไปต่อกับตัวเลขได้ ดังนั้น มันจึงพังตรง ". I have " + money + " baht." เพราะ money เป็นตัวแปรชนิดตัวเลข

วิธีการแก้ไขมี 2 แบบ แบบแรกคือ ให้ใช้ #{} แทน
[shcode=rails]
money = 500
puts "I have #{money} baht."
[/shcode]
ซึ่งเป็นวิธีที่ควรใช้

ส่วนแบบที่สองนั้น ให้ใส่ .to_s ตามหลังตัวแปรชนิดตัวเลขของเราในการแสดงผลข้อความ
[shcode=rails]
money = 500
puts "I have " + money.to_s + " baht."
[/shcode]
money.to_s มีความหมายว่า เฮ้ย เจ้าโปรแกรม ให้มอง money ให้เป็นข้อความเพื่อนำไปแสดงนะ อะไรทำนองนั้น

หลายคนก็สงสัยว่า ทำแบบนี้ได้หรือเปล่าเอ่ยย
[shcode=rails]
money = "500"
puts "I have " + money + " baht."
[/shcode]
พูดง่ายๆ คือ เก็บตัวแปร money เป็นข้อความ "500" ไปซะเลย
คำตอบคือ ได้ แต่ อันตราย มากๆ เพราะคุณจะสูญเสียความเป็นตัวเลขในตัวแปร money ไปทันที กล่าวคือ คุณไม่สามารถใช้ operator มาคำนวณได้อีก

เพื่อให้เข้าใจมากกว่านี้ สมมุติผมมีเงิน 500 บาท ต่อมาพ่อให้ผมอีก 1000 บาท ผมจะมีเงินรวม 1500 บาทใช่ไหมครับ ถ้าเราดันเปลี่ยน money เป็นชนิดข้อความ เราก็จะเขียนมั่วๆ ได้แบบนี้
[shcode=rails]
money = "500"
puts "I have " + money + " baht."

money = money + 1000
puts "Now I have " + money + " baht."
[/shcode]
ซึ่งแน่นอนว่ามัน error เพราะในบรรทัดที่ 4 เราเอาตัวแปร money ซึ่งเป็นข้อความ ไป + กับตัวเลข
เราก็จะแก้เป็นแบบนี้
[shcode=rails]
money = "500"
puts "I have " + money + " baht."

money = money + "1000"
puts "Now I have " + money + " baht."
[/shcode]
ผลก็คือ รันได้ ไม่ error แต่เราจะมีเงิน 5001000 บาท แทน พ่อให้ทีรวยเละเบย เพราะมันมองเป็นการเอาข้อความมาต่อกัน ถูกไหมครับ

มันจึงเป็นเหตุผลว่า หากเป็นข้อมูลตัวเลขที่ต้องเอาไปคำนวณภายหลัง เช่น + - * / % ** เราต้องเก็บเป็นตัวเลข ห้ามเก็บเป็นข้อความเด็ดขาด

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

นอกจากนี้ตัวแปรในภาษา Ruby ยังมีหลายประเภท หลายคนอาจสังเกตโค้ดใน RGSS ว่าบางตัวแปรนั้นมีเครื่องหมาย $ นำหน้า (เช่น $game_variables, $data_items) และบางตัวแปรจะมีเครื่องหมาย @ นำหน้า (เช่น @hp, @mp, @event) หรือแม้กระทั่งตัวแปรที่ขึ้นต้นด้วย @@ ก็มี ในตอนนี้เราอย่าเพิ่งไปสนใจขนาดนั้น เดี๋ยวในเรื่อง class ของ Ruby ผมจะอธิบายทั้งหมดอีกครั้งครับ

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

สำหรับบทความในส่วนนี้ผมค่อนข้างจะชินกับมันมากแล้วก็เลยเฉยๆ แต่สำหรับคนที่จะเรียนรู้ RGSS ถือว่ามีประโยชน์มากครับ

ยกนิ้วให้สำหรับกระทู้ดีมีประโยชน์ครับ ^ ^ b

โอ้ มาอีกแล้ว

เครื่องคิดเลขงั้นหรือนี่ ต้องลองจริงๆซะแล้ว // เราเอาชื่อตัวในเกมมาใส่โดยบอกไอดีตัวละครนั้นได้ป่าวครับ อย่างใน อีเวนต์จะใช้คำว่า \n[ไอดี] แต่ผมไม่รู้ในสคริปต์อะ

เครื่องคิดเลขงั้นหรือนี่ ต้องลองจริงๆซะแล้ว // เราเอาชื่อตัวในเกมมาใส่โดยบอกไอดีตัวละครนั้นได้ป่าวครับ อย่างใน อีเวนต์จะใช้คำว่า \n[ไอดี] แต่ผมไม่รู้ในสคริปต์อะ

ได้ครับ ให้ใช้ $game_actors[<ไอดี>].name ครับ
แต่มีข้อแม้ว่าเกมจะต้องถูกรันเรียบร้อยก่อน จึงจะสามารถใช้ได้

แต่ที่ผ่านมาในบทความชุดนี้ โค้ดที่เราพิมให้แสดงผลบนจอ console กันนั้น มันแสดงผลก่อนรันเกมครับ ดังนั้นมันจะยังไม่รู้จักตัวแปรดังกล่าวครับ

ซึ่งถ้ามีโอกาส ผมจะเขียนบทความ วิธีการนำข้อมูลต่างๆ ในเกม มาแสดงผลใน script อีกครั้งครับผม

ผมจะเอาไปโมสคริปต์ครับท่าน ขอบคุณครับ อิๆ