ฉันจะคำนวณระดับปัจจุบันจาก XP ทั้งหมดได้อย่างไรเมื่อแต่ละระดับต้องการ XP เพิ่มเติมตามสัดส่วน

ในเกมของฉัน, XP ที่จำเป็นในการเข้าถึงระดับถัดไปคือปัจจุบันระดับ×ระดับเกณฑ์ ระบุว่าฉันจะได้รับระดับปัจจุบันของฉันจากXP ทั้งหมดที่เคยได้รับ?

---

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

Level Threshold = 50
Current Level = 1

เริ่มต้นที่ระดับ 1 ฉันต้องการ(1 × 50) = 50 XP เพื่อไปที่ระดับ 2 และต่อไป

Level 1: 50 XP needed to reach level 2
Level 2: 100 more XP needed to reach level 3
Level 3: 150 more XP needed to reach level 4

กล่าวอีกนัยหนึ่งตารางความก้าวหน้ามีดังนี้:

Level 1: 0 XP to 49 XP
Level 2: 50 XP to 149 XP 
Level 3: 150 XP to 299 XP
Level 4: 300 XP to 499 XP

หากฉันมี 300 XP ฉันจะไปถึงระดับ 4 ฉันจะคำนวณได้อย่างไรโดยทั่วไป

เมื่อออกกำลังคณิตศาสตร์และแก้ปัญหาตามLevelเงื่อนไขXPเราได้รับ:

$$Level = \frac{1 + \sqrt{1 + 8 \times XP \div 50}}{2}$$

ตัวอย่างเช่นระดับของผู้เล่นสำหรับคืออะไร$XP = 300$

$$\frac{1 + \sqrt{1 + 8 \times 300 \div 50}}{2} = 4$$

ตามที่ขอ.

หรือระดับสำหรับXP = 100000อะไร

$$\frac{1 + \sqrt{1 + 8 \times 100000 \div 50}}{2} = 63$$

มีการแสดงออกโดยทั่วไปมากกว่าสำหรับเกณฑ์การเริ่มต้นโดยพลการที่ระดับ 1:

$$Level = \frac{1 + \sqrt{1 + 8 \times threshold \div 50}}{2}$$

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

$$XP = \frac{(Level^2-Level) \times threshold}{2}$$

โปรดทราบว่าสูตรด้านบนใช้งานได้กับเศษส่วน แต่คุณต้องปัดเศษเป็นค่าจำนวนเต็มถัดไป ตัวอย่างเช่นใน C ++ / C # คุณสามารถใช้ระดับ (int)

เพื่อให้ได้สูตรรูปแบบปิดด้านบนฉันใช้สมการความแตกต่างผลบวกของเกาส์และสูตรสมการกำลังสอง

หากคุณมีความสนใจในการแก้ปัญหาของสูตรนี้ทีละขั้นตอน ...

เราทำขั้นตอนวิธี recursive Experience(next_level) = Experience(current_level) + current_level*50โดยเริ่มต้นการพิจารณาของเราในท้ายที่สุดว่า

ตัวอย่างเช่นการขอรับเรามี:$XP_{Level3}$

$$XP_{Level3} = XP_{Level2} + 2 \times 50$$

ที่2*50มาจากคำขอของ OP ที่ประสบการณ์ที่จำเป็นในการเข้าถึงระดับถัดไปคือระดับปัจจุบัน * 50

ตอนนี้เราแทนด้วยตรรกะเดียวกันในสูตร นั่นคือ:$Xp_{Level2}$

ทดแทนลงในสูตรข้างต้น:$XP_{Level2} = XP_{Level1} + 2 \times 50$

$$Xp_{Level3} = Xp_{Level1} + 1 \times 50 + 2 \times 50$$

และ$Xp_{Level1}$เพียง 50 ซึ่งเป็นจุดเริ่มต้นของเรา ด้วยเหตุนี้

$$Xp_{Level3} = 50 + 2 \times 50 = 150$$

เราสามารถจดจำรูปแบบสำหรับการคำนวณระดับที่สูงขึ้นซ้ำ ๆ

$$Xp_{LevelN} = 50 + 2 \times 50 + 3 \times 50 + ... + (N-1) \times 50 = \sum_{i=0}^{n-1} i \times 50$$

โดยที่ N คือระดับที่ต้องทำให้สำเร็จ ในการรับค่า XP สำหรับระดับ N เราจำเป็นต้องแก้หา N

$$Xp_{LevelN} \div 50 = \sum_{i=0}^{n-1} i$$

ตอนนี้ทางขวามือเป็นเพียงการรวมจาก 1 ถึง N-1 ซึ่งสามารถแสดงโดยการสรุปแบบเกาส์ที่มีชื่อเสียง$N \times (N+1)\div2-N$ Nด้วยเหตุนี้

$$Xp_{LevelN} \div 50 = N(N+1) \div 2-N$$

หรือเพียงแค่

$$2*(Xp_{LevelN} - 50) \div 50 = N(N+1)-2N$$

ในที่สุดวางทุกอย่างไว้ด้านหนึ่ง:

$$0 = N^2-N-2 \times Xp_{LevelN} \div 50$$

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

$$N = \frac{1 + \sqrt{\frac{1+4 \times 2 \times Xp_{LevelN}}{50}}}{2}$$

เงื่อนไขระดับปัจจุบันบน XP และเกณฑ์เชิงเส้นจึงเป็น:

$$Level = \frac{1 + \sqrt{1+8\times XP \div threshold}}{2}$$

หมายเหตุการรู้ขั้นตอนเหล่านี้อาจเป็นประโยชน์ในการแก้ปัญหาสำหรับความก้าวหน้าที่ซับซ้อนยิ่งขึ้น ในขอบเขตของ RPG คุณจะเห็นนอกเหนือจากความก้าวหน้าเชิงเส้นเช่นที่นี่ความเป็นเศษส่วนที่ใช้กันทั่วไปหรือความสัมพันธ์แบบสแควร์เช่น . อย่างไรก็ตามสำหรับการติดตั้งเกมเองฉันเชื่อว่าวิธีนี้จะไม่เหมาะสมที่สุดเท่าที่ควรเพราะคุณควรรู้ถึงความก้าวหน้าในทุกระดับของคุณก่อนแทนที่จะคำนวณพวกมันตอนรันไทม์ สำหรับเครื่องยนต์ของฉันฉันใช้ตารางประสบการณ์ที่ได้รับการประมวลผลล่วงหน้าซึ่งมีความยืดหยุ่นและบ่อยครั้งขึ้น อย่างไรก็ตามในการเขียนตารางเหล่านั้นก่อนหรือเพียงแค่ถามตัวเองว่าจำเป็นต้องใช้อะไรสมมติว่าได้สูตรนี้ให้วิธีที่เร็วที่สุดที่มุ่งตอบคำถามเฉพาะของ OP$Level = \frac{\sqrt{XP}}{5.0}$XPLevel 100

แก้ไข : สูตรนี้ทำงานได้อย่างเต็มที่ตามที่ควรและมันจะออกมาอย่างถูกต้องตามlevelเงื่อนไขในปัจจุบันXP ด้วยความก้าวหน้าเชิงเส้นตามที่ร้องขอโดย OP (สูตรก่อนหน้าแสดงผลลัพธ์เป็น "ระดับ + 1" โดยสมมติว่าผู้เล่นเริ่มต้นจากระดับ 0 ซึ่งเป็นความผิดพลาดของฉัน - ฉันได้แก้ไขมันในช่วงพักเที่ยงด้วยการเขียนลงบนกระดาษทิชชู่เล็ก ๆ ! :)

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

expLeft = playerExp
level = 1
while level < levelCap and expLeft >= 0:
    expLeft = expLeft - expToAdvanceFrom(level)
    level = level + 1

if expLeft < 0: level = level - 1     # correct overshoot

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

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

คำถามได้รับการตอบด้วยรหัส แต่ฉันคิดว่าควรตอบด้วยคณิตศาสตร์ บางคนอาจต้องการเข้าใจแทนที่จะคัดลอกและวาง

ระบบของคุณอธิบายได้อย่างง่ายดายด้วยความสัมพันธ์ที่เกิดซ้ำ:

$$\text{XP}_{\text{Level}+1} = \text{XP}_{\text{Level}} + \text{Level} \cdot \text{Threshold}$$

ซึ่งเสนอวิธีแก้ปัญหาแบบปิดง่ายสำหรับ $\text{XP}$:

$$\text{XP}_{\text{Level}} = \frac{(\text{Level}-1) \cdot \text{Level} \cdot \text{Threshold}}{2}$$

ซึ่งเราสามารถแก้ปัญหาได้ $\text{Level}$:

$$\text{Level} = \left\lfloor \frac{\sqrt{\text{Threshold}^2 + 8 \cdot \text{XP} \cdot \text{Threshold}}}{2 \cdot \text{Threshold}}+\frac{1}{2} \right\rfloor$$

(ตัดให้เป็นจำนวนเต็มเนื่องจากผู้เล่นต้องการXP ที่จำเป็นทั้งหมดเพื่อรับโบนัสระดับใด ๆ )

นี่คือวิธีหนึ่งในการแก้ปัญหาโดยใช้พีชคณิตพื้นฐาน หากคุณไม่สนใจขั้นตอนต่าง ๆ ให้ข้ามไปที่ด้านล่าง

สิ่งง่าย ๆ ที่จะเกิดขึ้นคือระดับnประสบการณ์ทั้งหมดที่eจำเป็นในการได้รับระดับนั้น:

e = sum from k=1 to n of (t(k-1))

tคำย่อมาจากการเพิ่มขึ้นของ XP ที่จำเป็นต่อระดับ - 50 ในตัวอย่าง

เราสามารถแก้ปัญหาข้างต้นโดยใช้สูตรสำหรับลำดับเลขคณิต ( ตัวตนรวม ):

e = t/2 * n(n-1)

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

n^2 - n - 2e/t = 0

ตอนนี้เราสามารถใช้สูตรสมการกำลังสอง:

n = (1 + sqrt(1+8e/t))/2

---

สมการสุดท้าย:

level = 0.5 + sqrt(1 + 8*(total experience)/(threshold)) / 2

คณิตศาสตร์ที่เกี่ยวข้องทั้งหมดที่นี่มีความสำคัญมากที่จะต้องทราบด้วยเหตุผลทุกประการซึ่งบางส่วนนั้นเกี่ยวข้องกับการพัฒนาเกม

แต่

นี่คือเว็บไซต์พัฒนาเกมไม่ใช่ไซต์คณิตศาสตร์ ดังนั้นเรามาคุยกันว่าสิ่งเหล่านี้ไม่ได้เป็นชุดอัลกอริทึม แต่เป็นชุดเพราะนั่นคือประเภทของคณิตศาสตร์ที่ใช้กับการปรับระดับในเกมที่คุณอาจพัฒนาเพื่อขายจริง ๆ และนี่คือระบบที่ปรับระดับมากที่สุด ระบบ (อย่างน้อยในอดีต)

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

มีสองเหตุผลที่ดีในการเลือกหมายเลขรอบ:

• ประสบการณ์ในระดับนั้นเป็นตัวเลขที่ดี "100; 200; 1,000,000; ฯลฯ "
• เดลต้าระหว่างระดับมีแนวโน้มที่จะเป็นคนอื่นที่ดีจำนวนรอบที่ผู้เล่นสามารถมองและคำนวณในหัวของเขา

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

เหตุใดจึงสำคัญที่ต้องจำไว้?

อัลกอริทึมชุดผสมส่วนใหญ่ไม่ได้สร้างตัวเลขกลมที่ดี

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

เราจะรู้ได้อย่างไรว่าการประมาณแบบใดที่เหมาะสม เราพิจารณาว่าประเด็นของการปรับระดับนั้นอยู่ในระบบเกม

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

• หมวกถูกพบก่อนหน้านี้ค่อนข้างเร็วซึ่งระบบระดับนั้นมีอยู่เพียงเพื่อช่วยให้ผู้เล่นผ่านด่านแรกของเกมด้วยวิธีที่เน้นเพื่อบังคับให้พวกเขาเรียนรู้ระบบเกมที่สมบูรณ์ เมื่อพวกเขา "เติบโตเต็มที่" เกมเริ่มยาว
• XP ที่ได้รับ VS ระดับความยากมีเศรษฐกิจที่แน่นอนโดยที่ใช่มีระดับสูงสุด แต่มันอยู่ไกลเกินกว่าที่เราคาดหวังว่าผู้เล่นจะเล่นเกมจนจบประมาณครึ่งทางผ่านแผนภูมิปรับระดับ ใน RPGs DQ / FF-รูปแบบที่มีตัวละครหลาย / เรียนมันเป็นเรื่องธรรมดาที่จะมีตัวละครที่แตกต่างกัน / การเรียนจะทำให้ระดับง่ายขึ้นโดยได้รับประสบการณ์ในอัตราที่แตกต่างกว่าการเปลี่ยน XP ที่จำเป็นสำหรับแต่ละระดับชั้นเรียนตัวอักษรต่อ ด้วยวิธีนี้ผู้เล่นสามารถจดจำตัวเลขกลมตัวน้อยน่ารักเป็นเป้าหมายสากลได้อย่างง่ายดายและรู้ว่าตัวละครแต่ละตัวจะดำเนินต่อไปในอัตราที่กำหนดโดยระบบเกม ( XP + (XP * Modifier)หรืออะไรก็ตาม)
• ระดับสูงสุดขึ้นอยู่กับหมวดหมู่อักขระภายนอก นั่นคือปัจจัยนอกระบบเกมบางอย่างที่เหมาะสมกำหนดว่าระบบระดับดูเหมือนว่า นี่เป็นเรื่องธรรมดามากขึ้นเนื่องจากหลาย ๆ เกมเป็นแบบจ่ายต่อการชนะ แต่เล่นฟรี ผู้เล่นฟรีสามารถต่อยอดที่เลเวล 70, ผู้สมัครสมาชิกอาจต่อยอดที่เลเวล 80, การซื้อครั้งเดียวอาจทำให้ใครบางคนก้าวไปข้างหน้าด้วยระดับที่เกินขีด จำกัด สากล ฯลฯ
• ระดับสูงสุดเป็นสากลและผูกติดอยู่กับโลกของเกมในบางวิธี ระบบนี้ได้รับความนิยมโดย WoW
• ระบบระดับสูงสุดอื่นใดที่คุณอาจใฝ่ฝันที่เพิ่มประสิทธิภาพการเล่นเกมอย่างชาญฉลาดมากกว่าเพียงแค่ให้รางวัลแก่ผู้เล่นที่เสียเวลาในชีวิตของพวกเขาในนาทีที่สร้างขึ้นมากกว่าผู้เล่นคนอื่น ๆ

มีเป็นบางระบบเกมที่มีระดับสูงสุดและไม่มีระบบจะถูกกำหนดอัลกอริทึม โดยทั่วไประบบเช่นนี้ใช้ระบบ X-powers-of-Y บางระบบเพื่อทำให้ตัวเลขระเบิดอย่างรวดเร็ว นี่ทำให้มันง่ายมากที่จะได้เลเวล L-1 โดยคาดว่าผู้เล่นส่วนใหญ่จะได้เลเวล L ยากมากที่จะเลเวล L + 1 และผู้เล่นจะโตขึ้นและตายก่อนที่จะถึง L + 2 ในกรณีนี้ "L" เป็นระดับที่คุณตัดสินใจคือระดับเป้าหมายที่เหมาะสมสำหรับการเล่นและโดยปกติแล้วจะมีการต่อยอดระบบ แต่ไม่เปิดตัวเลือกสำหรับผู้ที่จะหลอกตัวเองให้คิดว่าความคิดที่ดีสำหรับ XP ตลอดไป (อุบาทว์!) ในระบบประเภทนี้คณิตศาสตร์ที่พบที่นี่เหมาะสมอย่างยิ่ง แต่มันเป็นกรณีที่แคบมากและไม่ค่อยพบในเกมจริง

ดังนั้นสิ่งที่เราจะทำ?

คำนวณระดับและ XP หรือไม่ ไม่กำหนดระดับและ XP? ใช่.

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

รหัสสำหรับเรื่องนี้ค่อนข้างตรงไปตรงมาและเป็นเพียงการกำหนดช่วง:

level(XP) when XP < 100  -> 1;
level(XP) when XP < 200  -> 2;
level(XP) when XP < 500  -> 3;
level(XP) when XP < 1000 -> 4;
% ...more levels...
level(XP) when XP > 1000000 -> 70. % level cap

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

level(XP) ->
    if
        XP < 100  -> 1;
        XP < 200  -> 2;
        XP < 500  -> 3;
        XP < 1000 -> 4;
        % ...more levels...
        XP > 1000000 -> 70 % level cap
    end.

มันเป็นคณิตศาสตร์ที่น่าทึ่งใช่ไหม ไม่เลย. มันเป็นคู่มือการใช้งานของการกำหนดองค์ประกอบชุด? อ๋อ นั่นคือทั้งหมดที่มีและนี่เป็นวิธีที่ฉันได้เห็นมันทำจริง ๆในเกมส่วนใหญ่ตลอดหลายปีที่ผ่านมา

ในฐานะที่เป็นบันทึกด้านข้างนี้ไม่ควรทำทุกครั้งที่ผู้เล่นได้รับประสบการณ์ โดยปกติคุณจะติดตาม "XP to go" เป็นค่าเดียวและเมื่อผู้เล่นหมดแรงหรือเกินกว่าค่า "to go" (ไม่ว่าคุณจะทำอะไร) คุณจะคำนวณสิ่งนี้เพื่อให้ทราบว่าผู้เล่นอยู่ที่ไหนจริงๆ ที่, จัดเก็บ, คำนวณคำสั่ง "to go" ถัดไปลบส่วนที่เหลือ (ถ้าอนุญาตให้นำ XP ไปข้างหน้า) และทำซ้ำ