วิธีสร้างเกมที่ใช้ข้อความพื้นฐานใน C ++
เกมที่ใช้ข้อความในภาษา C++ ช่วยให้ผู้เล่นป้อนคำสั่งผ่านหน้าต่างคอนโซล และโปรแกรมจะประมวลผลการเคลื่อนไหวของผู้เล่น ที่นี่ ฉันได้สร้างเกมโอเอกซ์แบบข้อความที่อนุญาตให้ผู้ใช้เล่นได้สองตัวเลือก ผู้ใช้สามารถเล่นกับคอมไพเลอร์ C++ หรือเล่นกับมนุษย์ก็ได้ เกมนี้มีคุณสมบัติที่คอยเพิ่มคะแนนให้กับผู้เล่นที่ชนะ หลังจากประกาศผลการแข่งขันนัดแรกแล้ว จะมีตัวเลือกการแข่งขันใหม่
กฎเกณฑ์สำหรับการชนะเกม
ผู้เล่นสองคนเล่นเกมโอเอกซ์ โดยวาง X และ 0 ไว้ในช่องว่างที่มีอยู่ทั้งหมดเก้าช่องบนตารางขนาดสามคูณสาม เกมนี้ชนะโดยผู้เล่นคนแรกที่ได้รับคะแนนสามแต้มติดต่อกันในแนวตั้ง แนวนอนหรือแนวทแยง ผู้เล่นแต่ละคนจะต้องคิดอย่างชาญฉลาดและมองไปข้างหน้าถึงการเคลื่อนไหวครั้งต่อไปของผู้เล่นอีกคน
รหัสสำหรับการออกแบบเกมโอเอกซ์แบบข้อความมีส่วนต่างๆ แบ่งตามฟังก์ชันการทำงาน ในส่วนแรก ผู้ใช้ตัดสินใจว่าจะเล่นกับคอมพิวเตอร์หรือเล่นกับเพื่อนมนุษย์ หลังจากตัดสินใจเลือกโหมดเกนแล้ว โปรแกรมจะขอให้ผู้ใช้ป้อนข้อมูล ผู้เล่นทั้งสองป้อนข้อมูลทีละรายการ
//รับข้อมูลจากผู้เล่น
เป็นโมฆะ ผู้เล่นอินพุต ( ผู้เล่น & ผู้เล่น ) {
ภายใน ตำแหน่ง ;
ศาล << สิ้นสุด ;
ศาล << ' \t ' << ผู้เล่น รับชื่อ ( ) << ' เปลี่ยน: ' ;
ศาล << ' \t เข้าสู่ตำแหน่ง ' <> ตำแหน่ง ;
ตำแหน่ง - - = 1 ;
ถ้า ( ดัชนีว่างเปล่า [ ตำแหน่ง ] == 1 ) {
ศาล << '-----ตำแหน่งไม่ว่าง-------' << สิ้นสุด ;
ผู้เล่นอินพุต ( ผู้เล่น ) ;
} อื่น {
ดัชนีว่างเปล่า [ ตำแหน่ง ] = 1 ;
ว่างเปล่านับ - - = 1 ;
ผู้เล่น รับชื่อ ( ) . เปรียบเทียบ ( “ผู้เล่นฉัน” ) == 0 ? กระดาน [ ตำแหน่ง ] = 'เอ็กซ์' : : กระดาน [ ตำแหน่ง ] = 'โอ' ;
}
}
หลังจากรับอินพุตจากผู้ใช้แล้ว มันจะตรวจสอบกฎการชนะ ฟังก์ชัน checkWin() มีพารามิเตอร์สองตัว p1 และ p2 เพื่อตรวจสอบว่าผู้เล่นชนะหรือไม่ ตัวแปรที่แตกต่างกันจะถูกประกาศในฟังก์ชัน i, j และ k เป็นตัวแปรจำนวนเต็มที่ถูกประกาศสำหรับการวนซ้ำ และแฟล็กเป็นฟังก์ชันบูลีนเพื่อตรวจสอบเงื่อนไขการชนะ การวนซ้ำเริ่มต้นจากตำแหน่งแรกและวนซ้ำไปเรื่อยๆ สำหรับตำแหน่งทั้งเก้า first_ Symbol คืออักขระที่สามารถเป็น 0 หรือ X ได้ หากเป็นจริง จากนั้นจะมีการตรวจสอบชุดค่าผสมที่เป็นไปได้ทั้งหมดสำหรับกฎการชนะ มิฉะนั้น ตัววนซ้ำจะย้ายไปยังตำแหน่งถัดไป และสิ่งเดียวกันจะดำเนินต่อไปจนกว่าจะตรวจสอบตำแหน่งที่เป็นไปได้ทั้งหมด หากตั้งค่าสถานะเป็นจริง จะมีการประกาศผู้ชนะ และโปรแกรมจะขอให้ทำการเลือกอีกครั้ง
เป็นโมฆะ เช็ควิน ( ผู้เล่น & p1 ผู้เล่น & หน้า 2 ) {
ภายใน ฉัน เจ เค ;
บูล ธง = เท็จ ;
ถ่าน first_สัญลักษณ์ ;
สำหรับ ( ฉัน = 0 ; ฉัน < 8 ; ฉัน ++ ) {
first_สัญลักษณ์ = กระดาน [ รายชื่อผู้ชนะ [ ฉัน ] . แถว [ 0 ] ] ;
ถ้า ( ( first_สัญลักษณ์ ! = 'เอ็กซ์' ) && ( first_สัญลักษณ์ ! = 'โอ' ) ) {
ธง = เท็จ ;
ดำเนินการต่อ ;
}
ธง = จริง ;
สำหรับ ( เจ = 0 ; เจ < 3 ; เจ ++ ) {
ถ้า ( first_สัญลักษณ์ ! = กระดาน [ รายชื่อผู้ชนะ [ ฉัน ] . แถว [ เจ ] ] ) {
ธง = เท็จ ;
หยุดพัก ;
}
}
ถ้า ( ธง ) {
เกมเปิด = 0 ;
ถ้า ( first_สัญลักษณ์ == 'เอ็กซ์' ) {
ศาล << '------------------------' << สิ้นสุด ;
ศาล << ' \t ผู้เล่นที่ฉันชนะ' << สิ้นสุด ;
ศาล << '------------------------' << สิ้นสุด ;
หน้า 1 วอน ( ) ;
} อื่น {
หน้า 2 วอน ( ) ;
ถ้า ( ต่อต้านคอมพิวเตอร์ ) {
ศาล << '------------------------' << สิ้นสุด ;
ศาล << ' \t คอมพิวเตอร์ชนะ' << สิ้นสุด ;
ศาล << '------------------------' << สิ้นสุด ;
} อื่น {
ศาล << '------------------------' << สิ้นสุด ;
ศาล << ' \t ผู้เล่นที่ 2 ชนะ' << สิ้นสุด ;
ศาล << '------------------------' << สิ้นสุด ;
}
}
แสดงคะแนน ( p1,p2 ) ;
หยุดพัก ;
}
รหัสส่วนนี้แสดงคะแนนของเกม หากเกมแข่งขันกับคอมพิวเตอร์ คะแนนของผู้เล่น 1 และคอมพิวเตอร์จะแสดงขึ้น มิฉะนั้น คะแนนของผู้เล่น 1 และผู้เล่น 2 จะแสดงขึ้น
เป็นโมฆะ แสดงคะแนน ( ผู้เล่น & p1 ผู้เล่น & หน้า 2 ) {
ศาล << สิ้นสุด ;
ศาล << ' \t คะแนน: \t ' ;
ถ้า ( ต่อต้านคอมพิวเตอร์ )
ศาล << ' ผู้เล่นฉัน: ' << หน้า 1 รับคะแนน ( ) << ' \t คอมพิวเตอร์: ' << หน้า 2 รับคะแนน ( ) << สิ้นสุด ;
อื่น
ศาล << ' ผู้เล่นฉัน: ' << หน้า 1 รับคะแนน ( ) << ' \t ผู้เล่นที่ 2: ' << หน้า 2 รับคะแนน ( ) << สิ้นสุด ;
}
นี่คือรหัสหลักสำหรับการเล่นเกมโอเอกซ์สำหรับผู้เล่นสองคน ผู้ใช้สามารถเลือกจากขั้นตอนต่างๆ ที่จะดำเนินการโดยใช้คำสั่ง switch case รหัสนี้มีอินเทอร์เฟซที่เป็นมิตรต่อผู้ใช้สำหรับการเล่นเกมบนคอมไพเลอร์ C++ และโค้ดจะยังคงดำเนินการต่อไปจนกว่าผู้ใช้จะเลือกตัวเลือกออก
ภายใน หลัก ( ){
ภายใน ช ;
ในขณะที่ ( 1 ) {
ศาล << ' ----------เมนู----------' << สิ้นสุด ;
ศาล << ' \t 1. เกมผู้เล่น 1 คน' << สิ้นสุด ;
ศาล << ' \t 2. เกมผู้เล่น 2 คน' << สิ้นสุด ;
ศาล << ' \t 3. เพื่อออก ' << สิ้นสุด ;
ศาล << ' ----------' << สิ้นสุด ;
ศาล << สิ้นสุด ;
ศาล << ' \t เลือกตัวเลือก' <> ช ;
สวิตช์ ( ช ) {
กรณี 1 : : {
เกม * เกม = ใหม่ เกม ;
เกม - - > ความร้อน ( ) ;
เกม - - > onePlayerGame ( ) ;
}
หยุดพัก ;
กรณี 2 : : {
เกม * เกม = ใหม่ เกม ;
เกม - - > ความร้อน ( ) ;
เกม - - > twoPlayerGame ( ) ;
}
หยุดพัก ;
กรณี 3 : :
กลับ 0 ;
ค่าเริ่มต้น : :
ศาล << 'OOP ตัวเลือกไม่ถูกต้อง โปรดลองอีกครั้ง' ;
}
}
กลับ 0 ;
}
รหัสที่สมบูรณ์สำหรับเกม Tic-Tac-Toc แบบข้อความ
นี่คือโค้ดที่สมบูรณ์สำหรับการออกแบบและการใช้งานเกมโอเอกซ์แบบข้อความ
#รวม
#รวม<รายการ>
#รวม
#รวม<สตริง>
#รวม <เวลา>
โดยใช้ เนมสเปซ มาตรฐาน ;
พิมพ์def โครงสร้าง {
ภายใน * แถว ;
} วินลิสต์ ;
ระดับ ผู้เล่น {
ส่วนตัว : :
ชื่อสตริง ;
ภายใน คะแนน ;
สาธารณะ : :
ผู้เล่น ( ) : : ผู้เล่น { '' } { }
ผู้เล่น ( สตริงเอ็น ) : : คะแนน { 0 } , ชื่อ { n } { }
เป็นโมฆะ วอน ( ) {
//เพิ่มคะแนน
คะแนน ++ ;
}
ภายใน รับคะแนน ( ) { กลับ นี้ - - > คะแนน ; }
สตริง getName ( ) { กลับ นี้ - - > ชื่อ ; }
} ;
ระดับ เกม {
ส่วนตัว : :
ถ่าน กระดาน [ 9 ] ;
ภายใน ดัชนีว่างเปล่า [ 9 ] ;
ภายใน เกมเปิดต่อต้านคอมพิวเตอร์ ;
ภายใน ว่างเปล่านับ ;
รายชื่อผู้ชนะ WinList [ 8 ] ;
เป็นโมฆะ บอร์ดแสดงผล ( ) {
ศาล << สิ้นสุด ;
ศาล << ' | | ' << สิ้นสุด ;
ศาล << ' ' << กระดาน [ 0 ] << ' | ' << กระดาน [ 1 ] << ' | ' << กระดาน [ 2 ] << สิ้นสุด ;
ศาล << ' | | ' << สิ้นสุด ;
ศาล << '-----------' << สิ้นสุด ;
ศาล << ' | | ' << สิ้นสุด ;
ศาล << ' ' << กระดาน [ 3 ] << ' | ' << กระดาน [ 4 ] << ' | ' << กระดาน [ 5 ] << สิ้นสุด ;
ศาล << ' | | ' << สิ้นสุด ;
ศาล << '-----------' << สิ้นสุด ;
ศาล << ' | | ' << สิ้นสุด ;
ศาล << ' ' << กระดาน [ 6 ] << ' | ' << กระดาน [ 7 ] << ' | ' << กระดาน [ 8 ] << สิ้นสุด ;
ศาล << ' | | ' << สิ้นสุด ;
ศาล << สิ้นสุด ;
}
เป็นโมฆะ อินพุตคอมพิวเตอร์ ( ) {
ภายใน ตำแหน่ง ;
ตำแหน่ง = แรนด์ ( ) % 10 ;
ถ้า ( ดัชนีว่างเปล่า [ ตำแหน่ง ] == 1 ) {
ถ้า ( ว่างเปล่านับ < 0 )
กลับ ;
อินพุตคอมพิวเตอร์ ( ) ;
} อื่น {
ศาล << 'คอมพิวเตอร์เลือก:' << ตำแหน่ง + 1 << สิ้นสุด ;
ดัชนีว่างเปล่า [ ตำแหน่ง ] = 1 ;
ว่างเปล่านับ - - = 1 ;
กระดาน [ ตำแหน่ง ] = 'โอ' ;
}
}
เป็นโมฆะ ผู้เล่นอินพุต ( ผู้เล่น & ผู้เล่น ) {
ภายใน ตำแหน่ง ;
ศาล << สิ้นสุด ;
ศาล << ' \t ' << ผู้เล่น รับชื่อ ( ) << ' เปลี่ยน: ' ;
ศาล << ' \t เข้าสู่ตำแหน่ง ' <> ตำแหน่ง ;
ตำแหน่ง - - = 1 ;
ถ้า ( ดัชนีว่างเปล่า [ ตำแหน่ง ] == 1 ) {
ศาล << '-----ตำแหน่งไม่ว่าง-------' << สิ้นสุด ;
ผู้เล่นอินพุต ( ผู้เล่น ) ;
} อื่น {
ดัชนีว่างเปล่า [ ตำแหน่ง ] = 1 ;
ว่างเปล่านับ - - = 1 ;
ผู้เล่น รับชื่อ ( ) . เปรียบเทียบ ( “ผู้เล่นฉัน” ) == 0 ? กระดาน [ ตำแหน่ง ] = 'เอ็กซ์' : : กระดาน [ ตำแหน่ง ] = 'โอ' ;
}
}
เป็นโมฆะ เช็ควิน ( ผู้เล่น & p1 ผู้เล่น & หน้า 2 ) {
ภายใน ฉัน เจ เค ;
บูล ธง = เท็จ ;
ถ่าน first_สัญลักษณ์ ;
สำหรับ ( ฉัน = 0 ; ฉัน < 8 ; ฉัน ++ ) {
first_สัญลักษณ์ = กระดาน [ รายชื่อผู้ชนะ [ ฉัน ] . แถว [ 0 ] ] ;
ถ้า ( ( first_สัญลักษณ์ ! = 'เอ็กซ์' ) && ( first_สัญลักษณ์ ! = 'โอ' ) ) {
ธง = เท็จ ;
ดำเนินการต่อ ;
}
ธง = จริง ;
สำหรับ ( เจ = 0 ; เจ < 3 ; เจ ++ ) {
ถ้า ( first_สัญลักษณ์ ! = กระดาน [ รายชื่อผู้ชนะ [ ฉัน ] . แถว [ เจ ] ] ) {
ธง = เท็จ ;
หยุดพัก ;
}
}
ถ้า ( ธง ) {
เกมเปิด = 0 ;
ถ้า ( first_สัญลักษณ์ == 'เอ็กซ์' ) {
ศาล << '------------------------' << สิ้นสุด ;
ศาล << ' \t ผู้เล่นที่ฉันชนะ' << สิ้นสุด ;
ศาล << '------------------------' << สิ้นสุด ;
หน้า 1 วอน ( ) ;
} อื่น {
หน้า 2 วอน ( ) ;
ถ้า ( ต่อต้านคอมพิวเตอร์ ) {
ศาล << '------------------------' << สิ้นสุด ;
ศาล << ' \t คอมพิวเตอร์ชนะ' << สิ้นสุด ;
ศาล << '------------------------' << สิ้นสุด ;
} อื่น {
ศาล << '------------------------' << สิ้นสุด ;
ศาล << ' \t ผู้เล่นที่ 2 ชนะ' << สิ้นสุด ;
ศาล << '------------------------' < 0 ) && ( เกมเปิด ! = 0 ) ) {
ถ้า ( ต่อต้านคอมพิวเตอร์ )
มือ == 1 ? อินพุตคอมพิวเตอร์ ( ) : : ผู้เล่นอินพุต ( หน้า 2 ) ;
อื่น
มือ == 1 ? ผู้เล่นอินพุต ( หน้า 1 ) : : ผู้เล่นอินพุต ( หน้า 2 ) ;
มือ = ! มือ ;
บอร์ดแสดงผล ( ) ;
เช็ควิน ( p1,p2 ) ;
}
ถ้า ( ว่างเปล่านับ <= 0 ) {
ศาล << ' --------------------------------------' << สิ้นสุด ;
ศาล << ' \t ไม่มีผู้ชนะ' << สิ้นสุด ;
ศาล << ' --------------------------------------' << สิ้นสุด ;
}
ศาล << สิ้นสุด ;
ศาล <> รีแมตช์ ;
ถ้า ( ( รีแมตช์ == 'และ' ) || ( รีแมตช์ == 'และ' ) ) {
ความร้อน ( ) ;
เล่น ( p1,p2 ) ;
}
}
เป็นโมฆะ แสดงคะแนน ( ผู้เล่น & p1 ผู้เล่น & หน้า 2 ) {
ศาล << สิ้นสุด ;
ศาล << ' \t คะแนน: \t ' ;
ถ้า ( ต่อต้านคอมพิวเตอร์ )
ศาล << ' ผู้เล่นฉัน: ' << หน้า 1 รับคะแนน ( ) << ' \t คอมพิวเตอร์: ' << หน้า 2 รับคะแนน ( ) << สิ้นสุด ;
อื่น
ศาล << ' ผู้เล่นฉัน: ' << หน้า 1 รับคะแนน ( ) << ' \t ผู้เล่นที่ 2: ' << หน้า 2 รับคะแนน ( ) << สิ้นสุด ;
}
สาธารณะ : :
เกม ( ) : : ว่างเปล่านับ { 0 } , เกมออน { 1 } , ต่อต้านคอมพิวเตอร์ { 0 } {
ความร้อน ( ) ;
รายชื่อผู้ชนะ [ 0 ] . แถว = ใหม่ ภายใน [ 3 ] { 0 , 1 , 2 } ;
รายชื่อผู้ชนะ [ 1 ] . แถว = ใหม่ ภายใน [ 3 ] { 3 , 4 , 5 } ;
รายชื่อผู้ชนะ [ 2 ] . แถว = ใหม่ ภายใน [ 3 ] { 6 , 7 , 8 } ;
รายชื่อผู้ชนะ [ 3 ] . แถว = ใหม่ ภายใน [ 3 ] { 0 , 3 , 6 } ;
รายชื่อผู้ชนะ [ 4 ] . แถว = ใหม่ ภายใน [ 3 ] { 1 , 4 , 7 } ;
รายชื่อผู้ชนะ [ 5 ] . แถว = ใหม่ ภายใน [ 3 ] { 2 , 5 , 8 } ;
รายชื่อผู้ชนะ [ 6 ] . แถว = ใหม่ ภายใน [ 3 ] { 0 , 4 , 8 } ;
รายชื่อผู้ชนะ [ 7 ] . แถว = ใหม่ ภายใน [ 3 ] { 2 , 4 , 6 } ;
}
เป็นโมฆะ ความร้อน ( ) {
เกมเปิด = 1 ;
ว่างเปล่านับ = 0 ;
แสนด์ ( เวลา ( 0 ) ) ;
สำหรับ ( ขนาด_t ฉัน = 0 ; ฉัน < 10 ; ฉัน ++ ) {
ดัชนีว่างเปล่า [ ฉัน ] = 0 ;
กระดาน [ ฉัน ] = ( ฉัน + 1 ) + '0' ;
ว่างเปล่านับ ++ ;
}
ว่างเปล่านับ -- ;
}
เป็นโมฆะ onePlayerGame ( ) {
//สร้างผู้เล่น
ผู้เล่นพี ( “ผู้เล่นฉัน” ) ;
ผู้เล่นค ( 'คอมพิวเตอร์' ) ;
ศาล << ' -----------------------' << สิ้นสุด ;
ศาล << ' \t ผู้เล่น I: X \t คอมพิวเตอร์: โอ' << สิ้นสุด ;
ศาล << ' -----------------------' << สิ้นสุด ;
ศาล << สิ้นสุด ;
ต่อต้านคอมพิวเตอร์ = 1 ;
เล่น ( ค,พี ) ;
}
เป็นโมฆะ twoPlayerGame ( ) {
//สร้างผู้เล่น
ผู้เล่นพี ( “ผู้เล่นฉัน” ) ;
ผู้เล่นค ( 'ผู้เล่นที่ 2' ) ;
ศาล << ' -----------------------' << สิ้นสุด ;
ศาล << ' \t ผู้เล่น I: X \t ผู้เล่นที่ 2: โอ' << สิ้นสุด ;
ศาล << ' -----------------------' << สิ้นสุด ;
ศาล << สิ้นสุด ;
ต่อต้านคอมพิวเตอร์ = 0 ;
เล่น ( ค,พี ) ;
}
} ;
ภายใน หลัก ( )
{
ภายใน ช ;
ในขณะที่ ( 1 ) {
ศาล << ' ----------เมนู----------' << สิ้นสุด ;
ศาล << ' \t 1. เกมผู้เล่น 1 คน' << สิ้นสุด ;
ศาล << ' \t 2. เกมผู้เล่น 2 คน' << สิ้นสุด ;
ศาล << ' \t 3. เพื่อออก ' << สิ้นสุด ;
ศาล << ' ----------' << สิ้นสุด ;
ศาล << สิ้นสุด ;
ศาล << ' \t เลือกตัวเลือก' <> ช ;
สวิตช์ ( ช ) {
กรณี 1 : : {
เกม * เกม = ใหม่ เกม ;
เกม - - > ความร้อน ( ) ;
เกม - - > onePlayerGame ( ) ;
}
หยุดพัก ;
กรณี 2 : : {
เกม * เกม = ใหม่ เกม ;
เกม - - > ความร้อน ( ) ;
เกม - - > twoPlayerGame ( ) ;
}
หยุดพัก ;
กรณี 3 : :
กลับ 0 ;
ค่าเริ่มต้น : :
ศาล << 'OOP ตัวเลือกไม่ถูกต้อง โปรดลองอีกครั้ง' ;
}
}
กลับ 0 ;
}
นี่เป็นโค้ดที่สมบูรณ์สำหรับการเล่นเกมโอเอกซ์ ซึ่งสามารถเล่นได้ในสองโหมด ไม่ว่าจะเล่นด้วยคอมพิวเตอร์หรือกับเพื่อนมนุษย์ นี่คือโค้ดอเนกประสงค์ รวมถึงคำสั่งที่เป็นไปได้ทั้งหมด เมื่อผู้ใช้ป้อนตำแหน่งที่เต็มแล้ว จะไม่เขียนทับตำแหน่งนี้และถือว่าการย้ายนี้ไม่ถูกต้อง
จนถึงตอนนี้ผู้เล่นได้เลือกกล่องแรกแล้วในเทิร์นถัดไปคอมพิวเตอร์จะทำเครื่องหมายกล่องที่หก:
ผู้เล่นทั้งสองได้เลือกกล่องทั้งสองจนถึงตอนนี้ และในเทิร์นถัดไป ผู้เล่นที่ฉันเลือกกล่องที่เจ็ดทำให้เกิดการสร้างรูปแบบแนวตั้งติดต่อกัน:
ผู้ใช้เลือกที่จะใช้คอมพิวเตอร์เพื่อเล่นเกม ดังนั้นหลังจากทำไปแล้วสามครั้ง ผู้ใช้จะชนะจากคอมพิวเตอร์และเพิ่มหนึ่งคะแนนลงในบันทึกของผู้เล่น 1 หลังจากการแข่งขันนัดแรกจบลง คอมไพเลอร์จะขอการแข่งขันใหม่ ผู้ใช้ตัดสินใจจากตัวเลือกและโปรแกรมจะกลับสู่ส่วนหลัก หลังจากเลือกตัวเลือกที่สามแล้ว คอมไพเลอร์ก็มีการเรียกใช้โค้ด
บทสรุป
เกมที่ใช้ข้อความอาศัยอักขระข้อความและอินเทอร์เฟซบรรทัดคำสั่งสำหรับการโต้ตอบกับผู้เล่น ไม่มีภาพกราฟิก เสียง หรือภาพเคลื่อนไหว ผู้ใช้ป้อนคำสั่งผ่านหน้าต่างคอนโซล เกมโอเอกซ์ที่ใช้ข้อความที่เป็นมิตรต่อผู้ใช้สร้างขึ้นโดยใช้ C ++ ใช้คำสั่งที่แตกต่างกันเพื่อสร้างเกมที่สามารถเล่นได้ด้วยคอมพิวเตอร์หรือผู้เล่นคนอื่น