ตัวแยกวิเคราะห์กฎทั่วไปสำหรับกฎเกมกระดาน RPG - จะทำอย่างไร?

ฉันต้องการสร้างเครื่องมือแยกวิเคราะห์กฎทั่วไปสำหรับระบบ RPG แบบปากกาและกระดาษ กฎสามารถเกี่ยวข้องโดยปกติ 1 ถึง N เอนทิตี 1 ถึง N บทบาทของลูกเต๋าและการคำนวณค่าตามหลายคุณลักษณะของเอนทิตี

ตัวอย่างเช่น:

ผู้เล่นมี STR 18 อาวุธที่ติดตั้งในปัจจุบันของเขาให้โบนัสแก่ +1 STR แต่ malus ของ DEX -1 เขาโจมตีมอนสเตอร์เอนทิตี้ของและตอนนี้เกมลอจิกจำเป็นต้องเรียกใช้ชุดของกฎหรือการกระทำ:

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

นอกจากกฎทางคณิตศาสตร์อย่างง่ายยังสามารถมีข้อ จำกัด เช่นการใช้เฉพาะกับผู้ใช้ระดับหนึ่ง (ตัวอย่างนักรบ vs ตัวช่วยสร้าง) หรือคุณลักษณะอื่น ๆ ดังนั้นนี่ไม่ได้ จำกัด เฉพาะการดำเนินการทางคณิตศาสตร์

หากคุณคุ้นเคยกับระบบสวมบทบาทอย่างเช่นดันเจี้ยนและมังกรคุณจะรู้ว่าฉันทำอะไรอยู่

ปัญหาของฉันคือตอนนี้ฉันไม่มีเงื่อนงำวิธีการสร้างสิ่งนี้อย่างถูกวิธีที่สุด ฉันต้องการให้ผู้คนสามารถตั้งกฎชนิดใดก็ได้และต่อมาก็ทำการกระทำเช่นการเลือกผู้เล่นและสัตว์ประหลาดและทำการกระทำ (ชุดของกฎเช่นการโจมตี)

ฉันขอความช่วยเหลือจากด้านฐานข้อมูลของสิ่งต่าง ๆ น้อยลง แต่เพิ่มเติมเกี่ยวกับวิธีสร้างโครงสร้างและตัวแยกวิเคราะห์เพื่อให้กฎของฉันมีความยืดหยุ่น ภาษาของตัวเลือกสำหรับสิ่งนี้คือ php

แก้ไขฉัน:

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

สิ่งที่ฉันลองมาแล้ว:แค่คิดถึงแนวคิดแทนที่จะเสียเวลาในการสร้างสถาปัตยกรรมที่ผิด จนถึงตอนนี้ฉันมีความคิดที่จะอนุญาตให้ผู้ใช้สร้างคุณลักษณะได้มากเท่าที่พวกเขาต้องการจากนั้นกำหนดคุณลักษณะให้มากที่สุดเท่าที่พวกเขาต้องการให้กับเอนทิตีประเภทใดก็ได้ เอนทิตีสามารถเป็นผู้เล่นมอนสเตอร์ไอเท็มหรืออะไรก็ได้ ทีนี้เมื่อทำการคำนวณบางอย่างข้อมูลจะมีให้แก่ตัวแยกวิเคราะห์กฎเพื่อให้ตัวแยกวิเคราะห์กฎสามารถทำสิ่งต่าง ๆ ได้เช่นถ้า Player.base_attack + ลูกเต๋า (1x6)> Monster.armor_check จากนั้น Monster.health - 1; คำถามที่นี่เป็นเรื่องเกี่ยวกับวิธีการสร้างโปรแกรมแยกวิเคราะห์

แก้ไขครั้งที่สอง:

นี่คือตัวอย่างของค่าพื้นฐานที่น่าสนใจ แต่การคำนวณอย่างถูกต้องมีสิ่งต่าง ๆ มากมายและตัวแปรที่ต้องคำนึงถึง:

Base Attack Bonus (Term) โบนัสการโจมตีพื้นฐานของคุณ (โดยทั่วไปเรียกว่า BAB โดยชุมชน d20) เป็นโบนัสการโจมตีที่ได้มาจากคลาสตัวละครและเลเวล โบนัสโจมตีพื้นฐานเพิ่มขึ้นในอัตราที่แตกต่างกันสำหรับคลาสตัวละครที่แตกต่างกัน ตัวละครจะได้รับการโจมตีครั้งที่สองต่อรอบเมื่อโบนัสการโจมตีพื้นฐานของเขาถึง +6 หนึ่งในสามที่มีโบนัสการโจมตีพื้นฐานที่ +11 หรือสูงกว่าและหนึ่งในสี่ที่มีโบนัสการโจมตีพื้นฐานจาก +16 หรือสูงกว่า โบนัสการโจมตีพื้นฐานที่ได้รับจากคลาสที่แตกต่างกันเช่นสำหรับตัวละครมัลติคลาส โบนัสการโจมตีพื้นฐานของตัวละครไม่อนุญาตให้มีการโจมตีอีกต่อไปหลังจากที่มาถึง +16 จะต้องไม่น้อยกว่า +0 และไม่เพิ่มขึ้นเนื่องจากระดับคลาสหลังจากระดับตัวละครถึงระดับที่ 20 โบนัสการโจมตีขั้นต่ำเป็นสิ่งจำเป็นสำหรับบาง feats

คุณสามารถอ่านได้ที่นี่http://www.dandwiki.com/wiki/Base_Attack_Bonus_(Term)รวมถึงลิงก์ไปยังคลาสและ feats ซึ่งมีกฎของตัวเองอีกครั้งเพื่อคำนวณค่าที่จำเป็นสำหรับการโจมตีฐาน

ฉันเริ่มคิดว่าการทำให้เป็นเรื่องธรรมดาที่สุดเท่าที่จะทำได้ก็ยากที่จะทำให้ตัวแยกวิเคราะห์กฎที่ดีทำได้

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

ก่อนอื่นให้ค้นหาชุดของการดำเนินการดั้งเดิมที่สามารถดำเนินการอื่นได้ ตัวอย่างเช่น:

• รับหรือตั้งค่าคุณสมบัติของผู้เล่น NPC หรือสัตว์ประหลาด

• รับผลของการทอยตาย

• ประเมินนิพจน์ทางคณิตศาสตร์

• ประเมินนิพจน์เงื่อนไข

• ทำการแยกตามเงื่อนไข

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

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

เขียนล่ามที่ประเมิน AST ของคุณ มันก็สามารถอ่านแต่ละโหนดในต้นไม้และทำสิ่งที่มันพูดว่า: a = bกลายเป็นกลายเป็นnew Assignment("a", "b") vars["a"] = vars["b"];ถ้ามันทำให้ชีวิตของคุณง่ายขึ้นให้เปลี่ยน AST ให้อยู่ในรูปแบบที่ง่ายกว่าก่อนการประเมิน

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

ATK = D20
if ATK >= player.ATK
    DEF = D20
    if DEF < monster.DEF
        monster.HP -= ATK
        if monster.HP < 0
            monster.ALIVE = 0
        end
    end
end

เรียนรู้วิธีฝังภาษาสคริปต์ที่มีอยู่เช่น Python หรือ Lua ลงในแอปพลิเคชันของคุณและใช้สิ่งนั้น ข้อเสียของการใช้ภาษาที่ใช้งานทั่วไปสำหรับงานเฉพาะโดเมนก็คือสิ่งที่เป็นนามธรรมนั้นรั่ว: คุณลักษณะและ gotchas ทั้งหมดของภาษายังคงปรากฏอยู่ ข้อเสียคือคุณไม่จำเป็นต้องปรับใช้ด้วยตนเอง - และนั่นเป็นข้อดีที่สำคัญ พิจารณามัน

ฉันจะเริ่มต้นด้วยการพิจารณา "เฟส" ที่แตกต่างกันของแต่ละการกระทำ

ตัวอย่างเช่น Combat Phase อาจเกี่ยวข้องกับ:

GetPlayerCombatStats();
GetEnemyCombatStats();
GetDiceRoll();
CalculateDamage();

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

ตัวอย่างเช่นคุณอาจมีบางอย่างที่ดูเหมือนว่ารวมอยู่ในGetPlayerCombatStats()วิธีการของคุณ:

GetPlayerCombatStats()
{
    Stats tempStats = player.BaseStats;

    player.GetCombatStats(player, monster, tempStats);

    foreach(var item in Player.EquippedItems)
        item.GetCombatStats(player, monster, tempStats);
}

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

อีกตัวอย่างหนึ่งสมมติว่าคุณต้องการSword of Slaying Everything ยกเว้น Squidที่ให้ +4 กับทุกอย่างยกเว้นกรณีที่มีหนวดซึ่งในกรณีนี้คุณต้องวางดาบของคุณและได้ -10 ในการต่อสู้

คลาสอุปกรณ์ของคุณสำหรับดาบนี้อาจมีสิ่งGetCombatStatsที่มีลักษณะดังนี้:

GetCombatStats(Player player, Monster monster, Stats tmpStats)
{
    if (monster.Type == MonsterTypes.Tentacled)
    {
        player.Equipment.Drop(this);
        tmpStats.Attack -= 10;
    }
    else
    {
        tmpStats.Attack += 4;
    }
}

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

สิ่งสำคัญที่ต้องพิจารณาคืออะไรที่คะแนนสามารถเปลี่ยนแปลงได้และองค์ประกอบใดบ้างที่มีอิทธิพลต่อค่าเหล่านั้น เมื่อคุณมีสิ่งเหล่านี้แล้วการสร้างองค์ประกอบของตัวเองน่าจะง่าย :)

ฉันใช้เวลาดูที่maptoolเฉพาะกรอบ 4 เอ็ดดังก้องของ เป็นระบบที่ดีที่สุดที่ฉันเคยเห็นในการตั้งค่าสิ่งที่คุณกำลังพูดถึง น่าเสียดายที่สิ่งที่ดีที่สุดก็คือความโหดร้าย ระบบ "มาโคร" ของพวกเขามี ... สมมุติว่า ... พัฒนาไปตามกาลเวลา

สำหรับ "parser กฎ" ฉันแค่ติดกับสิ่งที่ภาษาการเขียนโปรแกรมที่คุณพอใจแม้จะเป็น PHP จะไม่มีวิธีใดที่ดีในการเข้ารหัสกฎทั้งหมดในระบบของคุณ

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

ฉันคิดว่าคุณต้องสามารถคิดอย่างเป็นนามธรรมเกี่ยวกับสิ่งที่กำลังจะเกิดขึ้นในพื้นที่ที่มีปัญหาของคุณมาพร้อมกับแบบจำลองบางประเภทแล้วเชื่อมต่อ DSL ของคุณตามนั้น

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

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

เส้นทางเดียวคือการกำหนดสิ่งที่เรียกว่า DSL ภายนอกที่คุณกำหนดไวยากรณ์ของคุณและใช้เครื่องมือเช่น antlr เพื่อแยกวิเคราะห์และเรียกตรรกะของคุณ อีกเส้นทางหนึ่งคือการใช้สิ่งอำนวยความสะดวกในภาษาการเขียนโปรแกรมเพื่อกำหนด DSL ของคุณ ภาษาเช่น Groovy และ Ruby นั้นดีเป็นพิเศษในพื้นที่นี้

หนึ่งกับดักที่คุณต้องหลีกเลี่ยงคือการผสมตรรกะการแสดงผลของคุณกับรูปแบบเกมของคุณ ฉันจะลงคะแนนให้จอแสดงผลอ่านแบบจำลองของคุณและแสดงอย่างเหมาะสมแทนที่จะผสมรหัสที่แสดงซึ่งผสมกับแบบจำลองของคุณ