ทรีด็อกเตอร์เพื่อนบ้านที่ใจดีของคุณเพิ่งให้สัตว์วิเศษสามตัวที่ชื่อCodémon มีทัวร์นาเมนต์การต่อสู้ในเมือง Colorville ใกล้เคียง คุณเป็นคนที่ดีที่สุดอย่างที่ไม่มีใครเคยเป็นหรือเปล่า?

ภาพรวม

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

มอนสเตอร์

Codémonเป็นสัตว์ตัวน้อยที่ซับซ้อน มีห้าประเภท (องค์ประกอบ) ให้เลือกสามสถิติและสามช่องย้ายในแต่ละ

ประเภท

Codémonแต่ละประเภทจะถูกกำหนดหนึ่งประเภท ห้าประเภทคือ Normal, Psychic, Fire, Water และ Grass แต่ละคนมีจุดแข็งและจุดอ่อน ความเสียหายขึ้นอยู่กับแผนภูมิต่อไปนี้:

ตัวเลขคือตัวคูณความเสียหาย ยกตัวอย่างเช่น Fire attacking Water มีตัวปรับแต่ง 0.5 (ครึ่งดาเมจ) ในขณะที่ Fire Attacking Grass มีสองเท่า (2)

สถิติ

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

สัตว์ประหลาดแต่ละตัวมีค่าเริ่มต้นที่ 50 สำหรับแต่ละสถานะและสูงสุด 100 เมื่อคุณสร้างสัตว์ประหลาดของคุณคุณจะสามารถกำหนด80คะแนนสถิติเพิ่มเติม (แต่ละ) โปรดจำไว้ว่าไม่มีสถิติบุคคลใดสามารถไปได้เกิน 100 ดังนั้นคุณอาจมีการแจกแจง 100/80/50, 90/80/60 หรือ 65/65/100 แต่ 120/50/60 นั้นผิดกฎหมาย ทีมใดก็ตามที่มีสถิติผิดกฎหมายถูกตัดสิทธิ์ คุณไม่จำเป็นต้องใช้คะแนน 80 คะแนน แต่คุณอาจไม่ควรทำตามขั้นต่ำ 50/50/50

คุณสามารถพิจารณาสถิติของ HP ได้ แต่Codémonแต่ละตัวจะไม่สามารถแก้ไขได้ 100 HP เมื่อ HP ลดลงเหลือศูนย์พวกเขาจะไม่สามารถต่อสู้ต่อไปได้ HP ได้รับการเติมเต็ม 100 ก่อนการต่อสู้แต่ละครั้ง

การเคลื่อนไหว

สัตว์ประหลาดแต่ละตัวรู้การเคลื่อนไหวของการต่อสู้สามครั้ง ทั้งสามตัวที่เลือกจะต้องแตกต่างกันดังนั้นจึงไม่มี Punch / Punch / Punch

มี 15 การเคลื่อนไหวสามประเภท แต่ละประเภทมีการโจมตีโดยตรงการโจมตีที่อ่อนแอกว่าด้วยเอฟเฟกต์และเอฟเฟกต์เคลื่อนไหวเพียงอย่างเดียว

id  name        type    power   uses    usable  effect

0   Punch       N       20      -       NFWG
1   Heal        N        0      3       NFWG    Heals 50 HP
2   Slow        N       10      5       NFWG    Enemy speed x0.8
3   Pain        P       20      -       PFWG
4   Sleep       P        0      3       PFWG    No enemy action until wake
5   Weaken      P       10      5       PFWG    Enemy Atk x0.8
6   Fireball    F       20      -       NPFW
7   Burn        F        0      3       NPFW    Enemy -10 HP each turn
8   Sharpen     F       10      5       NPFW    Own Atk x1.25
9   Watergun    W       20      -       NPWG    
10  Confuse     W        0      3       NPWG    Enemy may strike itself (10 power)
11  Shield      W       10      5       NPWG    Own Def x1.25
12  Vine        G       20      -       NPFG
13  Poison      G        0      3       NPFG    Enemy -5xTurns HP each turn
14  Sap         G       10      5       NPFG    Enemy Def x0.8

typeหมายถึงประเภทของการย้าย powerเป็นพลังที่โดดเด่น usesระบุจำนวนครั้งที่สามารถใช้งานได้ต่อการรบหนึ่งครั้ง ( -ไม่ จำกัด จำนวน) usableแสดงประเภทที่สามารถใช้งานได้ (ตัวอย่างเช่น Punch ไม่สามารถกำหนดให้กับประเภท Psychic ได้เนื่องจากไม่มีP) effectแสดงให้เห็นถึงผลกระทบที่มีการเคลื่อนไหว มีโอกาส 75% ของการทำงานแต่ละเอฟเฟกต์ยกเว้น Heal ซึ่งใช้ได้เสมอ

สำหรับผลกระทบที่มีการเปลี่ยนแปลงสถิติของมอนสเตอร์, ผลกระทบที่อาจจะซ้อนกัน ตัวอย่างเช่นการใช้ Weaken สองครั้งอาจลดการโจมตีของฝ่ายตรงข้ามให้มีประสิทธิภาพ 0.64 เอฟเฟกต์ที่ไม่เปลี่ยนค่าสถานะของมอนสเตอร์ (สลีปเบิร์น ฯลฯ ) จะไม่ซ้อนกัน

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

การเผาไหม้เสียหายที่ฝ่ายตรงข้าม 10 HP ตอนท้ายของแต่ละหันเมื่อใช้งาน ยาพิษทำงานคล้ายกัน แต่ใช้เวลาเพิ่มขึ้นในแต่ละเทิร์น ในเทิร์นแรกมันคือ 5 และจะได้รับ 5 เทิร์นทุกครั้งหลังจากนั้น ดังนั้นเมื่อถึงเทิร์นที่สี่มันจะสร้างความเสียหายเป็นเวลา 20 ปีซึ่งเป็นความเสียหายแบบคงที่ซึ่งไม่ได้รับผลกระทบจากประเภทของสัตว์ประหลาดหรืออาจได้รับโบนัส

ความสับสนอาจทำให้สัตว์ประหลาดโจมตีตัวเองแทนที่จะทำตามที่ได้รับคำสั่งให้ทำ การโจมตีนี้มีพลัง 10 และมีโอกาส 30% ที่จะเกิดขึ้นในเทิร์นที่กำหนด

เพื่อให้ชัดเจนเอฟเฟกต์ล่าสุดจนถึงสิ้นสุดการต่อสู้ (ยกเว้นนอนตามที่กล่าวไว้ข้างต้น)

การเคลื่อนไหวจะได้รับพลังเพิ่มขึ้น 20% หากใช้โดยมอนสเตอร์ประเภทที่เกี่ยวข้อง ตัวอย่างเช่นมอนสเตอร์ Grass ที่ใช้ Vine จะได้รับการเพิ่มประสิทธิภาพในขณะที่ใช้ Punch เขาไม่ได้เป็น

สถิติลับ

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

โดยเฉพาะหลังจากการต่อสู้ทุกสองครั้งคุณจะได้รับ "โบนัส" หนึ่งคะแนนสำหรับมอนสเตอร์แต่ละตัวในทีมของคุณ คะแนนจะถูกมอบให้กับมอนสเตอร์ทุกคนตายหรือมีชีวิตอยู่ผู้ชนะหรือแพ้ คุณสามารถกำหนดสิ่งนี้ให้กับหนึ่งในสามของสถิติที่คุณเลือก คุณไม่สามารถวางบนมอนสเตอร์ตัวเดียวได้ สัตว์ประหลาดแต่ละตัวจะได้หนึ่งตัวในแต่ละครั้ง คะแนนเหล่านี้มีภูมิคุ้มกันต่อการ จำกัด 100 เนื่องจากจะมีรอบการต่อสู้ 100 รอบซึ่งหมายความว่าคุณจะได้รับสถิติเดียวมากถึง 149 ถ้าคุณจัดสรรโบนัสทั้งหมดให้กับมัน อีกครั้งฝ่ายตรงข้ามจะเห็นสถิติ "ฐาน" ของคุณเท่านั้นดังนั้นยิ่งคุณเข้าสู่ทัวร์นาเมนต์มากเท่าไหร่ความรู้ของพวกเขาก็จะแตกต่างจากความจริง

การต่อสู้

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

หลังจากนั้นให้เลี้ยวด้วยขั้นตอนต่อไปนี้:

• Switch: สวิตช์มอนสเตอร์บังคับจะมีขึ้น (ถ้ามี)
• เลือกการต่อสู้
• Switch: สวิตช์มอนสเตอร์ตัวเลือกใด ๆ(เลือกเป็นการกระทำการต่อสู้) เกิดขึ้น
• ตรวจสอบการนอนหลับ: โอกาสที่จะตื่นจากการนอนหลับ
• การโจมตี 1: หากทำได้มอนสเตอร์ที่เร็วกว่านั้นจะใช้การเคลื่อนไหวที่เลือกไว้
• Attack 2: หากทำได้มอนสเตอร์ตัวอื่นจะใช้ท่าที่เลือก
• เอฟเฟกต์ความเสียหาย: ใช้ความเสียหายจากไฟไหม้ / พิษกับสัตว์ประหลาด

"Speedier" หมายถึงสัตว์ประหลาดที่มีความเร็วสูงกว่า หากสถิติความเร็วทั้งสองเหมือนกันจะถูกเลือกโดยเหรียญ PRNG พลิกแต่ละเทิร์น

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

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

เอฟเฟกต์ความเสียหายจะเกิดขึ้นไม่ว่าคุณจะฆ่าฝ่ายตรงข้ามที่ใช้งานอยู่หรือไม่ก็ตาม ด้วยวิธีนี้สมาชิกของทั้งสองทีมอาจตายในเทิร์นเดียว

เมื่อทีมใดทีมหนึ่งวิ่งออกมาจากสัตว์ประหลาดที่ใช้งานได้พวกเขาแพ้ หากทั้งสองทีมหมดลงในเทิร์นเดียวกันมันจะเสมอกัน หากการต่อสู้มีระยะเวลา 1,000 รอบมันจะเสมอกัน

สูตรในการพิจารณาความเสียหายคือ:

floor((effAttack / effDefense) * movePower * typeMultiplier * moveBoost)

effAttackและeffDefenseเป็นสถิติที่มีประสิทธิภาพสำหรับมอนสเตอร์ การโจมตีที่ได้ผลจะได้รับจากการเพิ่มการโจมตีและการโจมตีโบนัสจากนั้นคูณ (โดย 0.8 หรือ 1.25) หากเอฟเฟกต์ใด ๆ เปลี่ยน โปรดจำไว้ว่าเอฟเฟกต์เหล่านี้สามารถซ้อนกันได้

ความเสียหายสามารถเป็น 0 ได้เมื่อตัวดัดแปลงประเภทคือ 0 (ปกติ <--> Psychic) ​​หรือพลังการเคลื่อนที่เป็น 0 (Heal, Burn, etc) มิฉะนั้นจะมีการบังคับใช้ค่าต่ำสุดที่ 1

การแข่งขัน

ทัวร์นาเมนต์มีอายุ 100 รอบ ในแต่ละรอบทีมจะถูกสับและจับคู่กันโดยการสุ่ม หากมีจำนวนทีมที่คี่เหลือจะได้รับ bye (คะแนนเป็นเสมอ) การชนะการรบจะได้รับ2คะแนนจากทีมการผูกนั้นมีค่า1และไม่เสียอะไรเลย ทีมที่มีคะแนนมากที่สุดในตอนท้ายชนะ!

หากทีมถูกมัดการแข่งขันที่มีเพียงทีมเดียวเท่านั้นที่จะเข้าร่วมจะถูกตัดสินเพื่อตัดสินลำดับ

โปรโตคอล

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

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

คุณสามารถเขียนข้อมูล / สถานะลงดิสก์ได้ วางไฟล์ใด ๆ ในโฟลเดอร์ย่อยที่มีชื่อเดียวกับทีมของคุณ อย่าเขียนข้อมูลมากกว่า 32 กิโลไบต์มิเช่นนั้นคุณจะถูกตัดสิทธิ์ ข้อมูลจะคงอยู่ระหว่างรอบ แต่จะถูกล้างระหว่างการแข่งขัน

คำสั่ง

ข้อมูลทีม

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

ค้นหา:

T

การตอบสนอง:

name|member0|member1|member2

nameเป็นสตริงที่มีชื่อทีมของคุณ โปรดใช้ตัวอักษรและตัวเลขเท่านั้นเพื่อความสะดวกในการแยกวิเคราะห์ memberNเป็นสายสมาชิกโดยให้รายละเอียดของสัตว์ประหลาดแต่ละตัว:

สตริงสมาชิก:

name:typeid:attack:defense:speed:moveid0:moveid1:moveid2

อีกครั้ง 'ชื่อ' เป็นสตริงคราวนี้ด้วยชื่อของสัตว์ประหลาดนี้ typeidเป็นประเภทของมัน รหัสประเภทอยู่ในลำดับที่แสดงในแผนภูมิด้านบนโดยปกติ = 0 และหญ้า = 4

สามฟิลด์ถัดไปคือสถิติพื้นฐานของคุณ โปรดจำไว้ว่าข้อ จำกัด ที่อธิบายไว้ในส่วนสถิติข้างต้น

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

ตัวอย่างการตอบกลับข้อมูลทีมอาจมีลักษณะเช่นนี้:

DummyTeam|DummyA:0:50:60:70:0:1:2|DummyB:0:50:60:70:0:1:2|DummyC:0:50:60:70:0:1:2

ทีมใด ๆ ที่ส่งขยะจัดรูปแบบไม่ดีหรือมีข้อมูลผิดกฎหมายที่นี่จะไม่เข้าร่วมจนกว่าจะได้รับการแก้ไข

เลือกใช้งาน

สิ่งนี้จะถูกส่งเมื่อเริ่มการต่อสู้แต่ละครั้งและเมื่อสัตว์ประหลาดตายและจำเป็นต้องเปลี่ยน

ค้นหา:

C#battleState

battleStateแสดงสถานะของการต่อสู้ปัจจุบัน อดทนกับฉันที่นี่มันน่าเกลียด:

yourTeamState#theirTeamState

ที่ไหนXteamStateมีลักษณะดังนี้:

name:activeSlot|member0state|member1state|member2state

activeSlotแสดงให้เห็นว่ามอนสเตอร์ตัวใดที่กำลังใช้งานอยู่ (0-2) รัฐสมาชิกมีสองรสชาติ หากเป็นทีมของคุณจะให้ข้อมูลเพิ่มเติม ดังนั้น,

สมาชิกของคุณรัฐ:

name:id:attack:defense:speed:hp:typeid:poisonedturns:moveCount0:moveCount1:moveCount2:bonusAttack:bonusDefense:bonusSpeed:effectid:effectid:effectid

สมาชิกของพวกเขารัฐ:

name:id:attack:defense:speed:hp:typeid:poisonedturns:effectid:effectid:effectid

idnameเป็นเพียงตัวระบุจำนวนเต็มคุณสามารถใช้ในการติดตามของมอนสเตอร์ถ้าคุณไม่ชอบใช้

attack:defense:speedเป็นสถิติฐานของคุณ

poisonedturns บอกคุณกี่ครั้งที่คุณได้รับพิษ

moveCountXบอกจำนวนการใช้ที่เหลือสำหรับการเคลื่อนไหวในแต่ละครั้ง ถ้า 0 จะไม่สามารถใช้งานได้ สำหรับการเคลื่อนไหวแบบไม่ จำกัด นี่จะเป็นค่าลบ

bonus(stat) คือจำนวนคะแนนโบนัสที่คุณกำหนดให้แต่ละสถานะ

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

รหัสผลกระทบคือ:

0  NONE           (should not appear, internal use)
1  POISON
2  CONFUSION 
3  BURN 
4  SLEEP 
5  HEAL           (should not appear, internal use)
6  ATTACK_UP
7  ATTACK_DOWN
8  DEFENSE_UP
9  DEFENSE_DOWN
10 SPEED_DOWN

การตอบสนอง:

memberSlot

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

การต่อสู้การกระทำ

ในแต่ละตาคุณต้องตัดสินใจว่าจะทำอย่างไร

ค้นหา:

A#battleState

battleStateที่นี่จะตรงตามที่กล่าวไว้ข้างต้น

การตอบสนอง:

หากต้องการใช้การย้ายให้ส่งสล็อตที่มีการย้ายกลับมาตัวอย่างเช่นถ้าฉันกำหนด Punch to slot 0 การส่งจะ0ทำการ Punch

เพื่อสลับไปยังสมาชิกอีกคนหนึ่งส่งสล็อตสมาชิกบวกสิบ ดังนั้นเพื่อสลับไปยังสมาชิก 2 12ส่ง

สิ่งใดที่ไม่ได้อยู่ใน [0,1,2,10,11,12] จะถือว่าไม่ถูกต้องและจะไม่ส่งผลให้เกิดการกระทำนี้

สถิติโบนัส

หลังจากการต่อสู้ทุกสองครั้งคุณจะได้รับคะแนนโบนัสลับสำหรับสมาชิกแต่ละคนในทีม

ค้นหา:

B#yourTeamState

สถานะทีมของคุณเหมือนที่แสดงไว้ข้างต้นอย่าทำให้ฉันซ้ำ

การตอบสนอง:

stat0:stat1:stat2

คำตอบของคุณจะแสดงถึงสถิติที่จะเพิ่มสำหรับสมาชิกแต่ละคนในทีม การโจมตีคือ 0, การป้องกันคือ 1, ความเร็วคือ 2

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

2:0:1

ตัวควบคุม

ตัวควบคุมสามารถพบได้ใน BitBucket: https: //Geobits@bitbucket.org/Geobits/codemon.git

เพียงแค่โยนไฟล์คลาสที่รวบรวมการส่งและผู้เล่นทั้งหมดในโฟลเดอร์และเรียกใช้

Tournamentระดับหลักของตัวควบคุมที่เรียกว่า การใช้งานคือ:

java Tournament [LOG_LEVEL]

ระดับการบันทึกจาก 0-4 ให้ข้อมูลเพิ่มขึ้น ระดับ 0 จะทำการแข่งขันแบบเงียบ ๆ และให้ผลลัพธ์โดยที่ระดับ 3 จะแสดงความเห็นแบบเลี้ยวต่อเลี้ยว ระดับ 4 คือเอาต์พุตดีบัก

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

ในโพสต์ของคุณรวมคำสั่งที่ฉันจะต้องเพิ่มในของฉันplayers.confและขั้นตอนการรวบรวมใด ๆ (ถ้าจำเป็น)

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

อื่น ๆ กฎ

• คุณไม่สามารถอ่านหรือเขียนทรัพยากรภายนอกใด ๆ (ยกเว้นในโฟลเดอร์ย่อยของคุณเองสูงสุด 32 kB ตามที่ระบุไว้ข้างต้น)

• ทีมของคุณต้องเข้าร่วมทัวร์นาเมนต์ "blind" นั่นหมายความว่าคุณไม่สามารถวิเคราะห์แหล่งที่มาของคนอื่นเพื่อหาว่าทีม / สัตว์ประหลาดที่เฉพาะเจาะจงจะทำอย่างไรในสถานการณ์ที่กำหนด คุณสามารถวิเคราะห์การเคลื่อนไหว / สถิติของคู่ต่อสู้และติดตามขณะที่การแข่งขันดำเนินไป แต่ไม่มีการเข้ารหัสข้อมูลใน

• อย่ารบกวนกระบวนการ / การส่งอื่น ๆ ไม่เรียกใช้พวกเขาใช้การสะท้อนเพื่อรับข้อมูลของพวกเขา ฯลฯ อย่ายุ่งกับคอมพิวเตอร์ของฉัน อย่าลองเลย นี่คือดุลยพินิจของฉัน ผู้ฝ่าฝืนอาจถูกห้ามไม่ให้เข้าในอนาคต

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

• คอมเมนต์อาจไม่ได้มีไว้เพื่อโพสต์รายการอื่น ๆ นอกจากนี้คุณต้องไม่พยายามตัดสิทธิ์ผู้แข่งขันรายอื่นทางอ้อม (ตัวอย่างเช่นใช้ชื่อทีมอักขระ 27M กับผู้เล่น DQ ที่พยายามเขียนสิ่งนี้ลงดิสก์) การส่งแต่ละครั้งควรเล่นเพื่อให้ได้รับรางวัลของตนเอง

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

• การแข่งขันจะจัดขึ้นในคอมพิวเตอร์ของฉันที่ใช้ Ubuntu ด้วยโปรเซสเซอร์ Intel i7 3770K

ผล

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

------- Final Results -------

158     Happy3Campers
157     LittleKid
71      InsideYourHead
68      HardenedTrio
46      BitterRivals

ผลการเล่นแบบเล่นต่อเต็มบนGoogle ไดรฟ์

Happy 3 campers - PHP

คนขี้ขลาดกลุ่มหนึ่งที่ชอบกัดฟันฝ่ายค้านด้วยคาถาที่ทำให้ร่างกายอ่อนแอ

แก้ไข : นาย Lumpy ได้รับการตีสอนอย่างรุนแรงและจะไม่พูดคำไม่ดีอีกต่อไป

มีประโยชน์Grass - atk:50 def:99 spd:81 Confuse Poison Heal

บีเวอร์แขนพิษที่ชอบทำให้คนสับสนด้วยการจับมือที่มีปัญหา

FlippyWater - atk:50 def:99 spd:81 Confuse Burn Heal

ทหารผ่านศึกกระดานข่าวที่มีจุดอ่อนสำหรับการพูดคุยไร้เบื่อและเปลวไฟ

บ๊องFire - atk:50 def:99 spd:81 Burn Poison Heal

อาวุธที่มีอำนาจทำลายล้างสูงเป็นขนมที่เขาโปรดปราน

เป็นก้อนPhp - lines:500 clarity:05 spd:01 Gather Guess Store

ต้องขอบคุณ IQ เกือบ 2 หลักของเขาและความทรงจำที่เป็นปรากฏการณ์ก้อนเป็นสิ่งที่สามารถคาดเดาการเคลื่อนไหวของศัตรู ส่วนใหญ่แล้ว

กลยุทธ์

กลยุทธ์คือการมีศัตรูถูกวางยาพิษเผาและสับสนโดยเร็วที่สุด
การนอนหลับไม่ได้ถูกใช้เนื่องจากดูเหมือนว่าจะมีพลังน้อยกว่าคาถาทั้งสามด้านบน
สับสนในระยะยาวเนื่องจากลดการโจมตีลง 30% (ทั้งการทำดาเมจและการร่ายเวทย์) ช่วยป้องกันหมอรักษาตัวเองและเป็นอันตรายต่อผู้โจมตีอย่างรุนแรง (50 def / 100 atk monster) จะสร้างความเสียหาย 20 คะแนน )

เมื่อศัตรูถูกวางอย่างละเอียดแล้วค่ายของฉันก็แค่เฝ้าดูเขาเสียงดังฉ่าเน่าและชกต่อยตาย

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

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

หลังการป้องกันความเร็วเป็นสถิติที่สำคัญที่สุดในการเพิ่มความเร็ว
ความคิดริเริ่มเป็นสิ่งสำคัญสำหรับการใช้การรักษาก่อนที่จะถึงการระเบิดครั้งต่อไป

การโจมตีไม่ได้ใช้เลย

คาถาเป็นอาวุธที่ดีที่สุดหรือไม่?

คาถาเช่นพิษการเผาไหม้และความสับสนหลบหนีตรรกะหิน / กระดาษ / กรรไกรโดยรวมของการโจมตีอื่น ๆ

เมื่อมอนสเตอร์ได้รับผลกระทบมันจะยังคงเสีย HP ต่อไปแม้ว่าคาถาแคสเตอร์จะตาย ราวกับว่าผีของล้อเลื่อนยังคงโจมตีเขาอยู่
นอกจากนี้พิษจะมีพลังอย่างรวดเร็วกว่าการโจมตีครั้งใหญ่ที่เต็มไปด้วยบัฟ (เต็ม 50 คะแนนหลังจาก 5 รอบ)

อายุขัยของสัตว์ประหลาดที่เป็นพิษและถูกเผาไหม้ไม่เกิน 8 รอบแม้จะมีการรักษา 3 ครั้ง

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

รหัส

วิงวอนกับ php campers.php

มันเป็นสิ่งที่น่าเกลียด แต่ส่วนติดต่อก็ไม่ได้ช่วยอะไรเช่นกัน

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

<?php

// ============================================================================
// Game
// ============================================================================
class G {
    static $code_type = array ("Normal", "Psychic", "Fire", "Water", "Grass", "?", "self"); 
    static $code_move = array    ("Punch", "Heal", "Slow", "Pain", "Sleep", "Weaken", "Fireball", "Burn", "Sharpen", "Watergun", "Confuse", "Shield", "Vine", "Poison", "Sap", "?", "self", "pass");
    static $move_uses = array (1000,3,5,1000,3,5,1000,3,5,1000,3,5,1000,3,5,   2000,2000);
    static $move_type      = array (0,0,0,1,1,1,2,2,2,3,3,3,4,4,4, 5,5,5);
    static $move_dmg       = array (20,0,10,20,0,10,20,0,10,20,0,10,20,0,10,  20,10,0);
    static $move_forbidden = array (1,1,1,0,0,0,4,4,4,2,2,2,3,3,3);
    static $code_effect = array ("N", "Poison", "Confuse", "Burn", "Sleep", "H", "Sharpen", "Weaken", "Shield", "Sap", "Slow"); 
    static $decode_type, $decode_move, $decode_effect;
    static $damage_multiplier = array (
        array (2, 0, 1, 1, 1, 0),
        array (0, 2, 1, 1, 1, 0),
        array (1, 1,.5, 2,.5, 0),
        array (1, 1,.5,.5, 2, 0),
        array (1, 1, 2,.5,.5, 0),
        array (2, 2, 2, 2, 2,-1),
        array (9, 9, 9, 9, 9, 9, 1));
    static $atk_score = array ("Poison"=> 1002, "Confuse"=>1001, "Burn"=>1000);
    static $status_field = "atk:def:spd:hp:type:Pturns";
    static $all_moves, $strong_moves, $medium_moves, $effect_moves, $possible_moves;

    function init()
    {
        self::$status_field = explode (":", self::$status_field);
        foreach (array ("type", "move", "effect") as $table) self::${"decode_$table"} = array_flip (self::${"code_$table"});
        foreach (self::$code_move as $c=>$m)
        {
            if ($m == "?") break;
            self::$all_moves[] = new Move($m);
            if (self::$move_uses[$c] >  5) self::$strong_moves[] = $m;
            if (self::$move_uses[$c] == 5) self::$medium_moves[] = $m;
            if (self::$move_uses[$c] == 3) self::$effect_moves[] = $m;
            for ($type = 0 ; $type != 5 ; $type++) if ((self::$move_uses[$c] >  5) && (self::$move_forbidden[$c] != $type)) self::$possible_moves[$type][] = $m;
        }
    }

    function __construct ($name, $team)
    {
        $this->turn = 0;
        $this->name = $name;
        $this->team = $team;
        $this->results_pending = false;
    }

    function parse_team ($tpack, $own_team)
    {
        $pack = explode ("|", $tpack);
        list ($name,$active) = explode (":", array_shift($pack));
        if ($own_team)
        {
            $team = $this->team;
        }
        else
        {
            if (!isset($this->enemies[$name])) $this->enemies[$name] = new Team(array (new Monster (), new Monster (), new Monster ()));
            $team = $this->foes = $this->enemies[$name];
        }
        $team->active = $active;
        foreach ($pack as $i=>$mpack) $team->monster[$i]->parse_monster ($own_team, $mpack);
    }

    function choose_active ()
    {
        // detect start of round
        $team = $this->team;
        $foes = $this->foes;
        foreach ($team->monster as $i=>$m) if ($m->hp > 0) $candidate[$i] = $m;
        if (count ($candidate) == 3)
        {
            $this->results_pending = false;
            $this->round++;

            // reinitialize all monsters
            foreach (array($team, $foes) as $t)
            foreach ($t->monster as $m)
                $m->start_round();

            // guess initial opponent
            $opponent = $foes->initial_opponent();
        }
        else
        {
            $this->analyze_last_round();
            $opponent = $foes->active();
        }
        return $this->do_switch ($opponent);
    }

    function choose_attacker ($foe)
    {
        foreach ($this->team->monster as $i=>$m) if ($m->can_attack($foe)) $candidate[$i] = $m;
        if (isset($candidate))
        {
            uasort ($candidate, function ($a,$b) use ($foe) { return ($a->atk_score != $b->atk_score) ? $b->atk_score - $a->atk_score : $b->life_expectancy($foe) - $a->life_expectancy($foe); });
            return key($candidate);
        }
        return -1;
    }

    function do_switch ($foe)
    {
        $replacement = $this->choose_attacker ($foe);
        if ($replacement < 0)
        {
            $candidate =  $this->team->monster;
            uasort ($candidate, function ($a,$b) use ($foe) { return $b->life_expectancy($foe) - $a->life_expectancy($foe); });
            $replacement = key($candidate);
        }

        $this->old_own = $this->team->monster[$replacement];
        $this->old_own->attack = "pass";
        return $replacement;
    }

    function choose_action ()
    {
        $this->analyze_last_round();
        $own = $this->team->active();
        $foe = $this->foes->active();
        $this->old_own = $own;

        if ($own->hp <= $own->max_damage($foe) && $own->can_do ("Heal")) return $own->execute("Heal");
        if ($attack = $own->can_attack($foe)) return $own->execute($attack);
        if ($own->hp <= 50 && $own->can_do ("Heal")) return $own->execute("Heal");

        return 10 + $this->do_switch ($foe);    
    }

    function choose_bonus()
    {
        foreach ($this->team->monster as $m)
        {
            if ($m->spd_b == 0) { $m->spd_b++; $res[] = 2; }
            else                { $m->def_b++; $res[] = 1; }
        }
        return implode (":", $res);
    }

    function parse ($parts)
    {
        self::parse_team ($parts[1], true);
        self::parse_team ($parts[2], false);    
    }

    function analyze_last_round()
    {
        if ($this->results_pending)
        {
            $this->results_pending = false;

            $foes = $this->foes;
            $foe = null;
            foreach ($foes->monster as $m) if ($m->hp != $m->old->hp) $foe = $m;
            if ($foe === null) $foe = $foes->monster[$foes->active];

            $this->old_own->guess_attack($foe);
        }
    }

    function process ($line)
    {
        $parts = explode ("#", $line);
        switch ($parts[0])
        {
        case "T": // register for tournament
            echo "$this->name|$this->team";
            break;
        case "C": // designate active monster
            $this->parse ($parts);
            echo $this->choose_active();
            break;
        case "A": // choose round action
            $this->parse ($parts);
            echo $this->choose_action();

            // save current state
            foreach (array($this->team, $this->foes) as $t)
            foreach ($t->monster as $m)
            {
                unset ($m->old);
                $m->old = clone ($m);
            }
            $this->results_pending = true;
            break;
        case "B": // distribute stat bonus
            echo $this->choose_bonus();
            break;
        }

    }
}
G::init();

// ============================================================================
// Move
// ============================================================================
class Move {
    function __construct ($move)
    {
        $this->register($move);
    }

    function register ($move)
    {
        $this->type = G::$decode_move[$move];
        $this->reinit();
    }

    function reinit()
    {
        $this->uses = G::$move_uses[$this->type];
    }

    function __tostring() { return G::$code_move[$this->type]."($this->uses)"; }
}

// ============================================================================
// Monster
// ============================================================================
class Monster { 
    function __construct ($name="?", $type="?", $atk=100, $def=100, $spd=100, $m0="?", $m1="?", $m2="?")
    {
        $this->name = $name;
        $this->type = G::$decode_type[$type];
        $this->atk  = $atk;
        $this->def  = $def;
        $this->spd  = $spd;
        $this->hp   = 100;
        $this->move = array (new Move($m0), new Move($m1), new Move($m2));
        $this->atk_b = 0;
        $this->def_b = 0;
        $this->spd_b = 0;
        foreach (G::$code_effect as $e) $this->$e = 0;
    }

    function __tostring ()
    {
        return implode (":", array (
            $this->name,
            $this->type,
            $this->atk,
            $this->def,
            $this->spd,
            $this->move[0]->type,
            $this->move[1]->type,
            $this->move[2]->type));
    }

    function start_round()
    {
        foreach ($this->move as $m) $m->reinit();
    }

    function parse_monster ($own_team, $spack)
    {
        $pack = explode (":", $spack);
        $name = array_shift ($pack); // get name
        array_shift ($pack); // skip id
        if ($this->name == "?") $this->name = $name; // get paranoid
        else if ($this->name != $name) die ("expected $this->name, got $name");

        // store updated values
        foreach (G::$status_field as $var) $this->$var = array_shift ($pack);
        if ($own_team)
        {
            foreach ($this->move as $m) $m->new_count = array_shift($pack);
            $pack = array_slice ($pack, 3); // these are maintained internally
        }
        $var = array();
        foreach ($pack as $e) @$var[G::$code_effect[$e]]++; 
        foreach (G::$code_effect as $e) $this->$e = @$var[$e]+0;
    }

    function damage_recieved ($attack, $foe=null)
    {
        if ($attack == "self") $foe = $this;
        $a = G::$decode_move[$attack];
        $type = G::$move_type[$a];
        $dmg = g::$move_dmg[$a];

        if ($dmg == 0) return 0;

        $atk = ($foe ->atk+$foe ->atk_b) * pow (.8, ($foe ->Weaken - $foe ->Sharpen));
        $def = ($this->def+$this->def_b) * pow (.8, ($this->Sap    - $this->Shield ));

        $boost = ($foe->type == $type) ? 1.2 : 1;
        return max (floor ($dmg * $atk / $def * $boost * G::$damage_multiplier[$this->type][$type]), 1);
    }

    function guess_attack_from_effect ($attacks)
    {
        foreach ($attacks as $status) if ($this->$status != $this->old->$status) return $status;
        return "?";
    }

    function guess_attack_from_damage ($foe, $damages)
    {
        $select = array();
        foreach (G::$possible_moves[$foe->type] as $attack)
        {
            $dmg = $this->damage_recieved ($attack, $foe);
            foreach ($damages as $damage) if ($damage != 0 && abs ($dmg/$damage-1) < 0.1) $select[$attack] = 1;
        }
        $res = array();
        foreach ($select as $a=>$x) $res[] = $a;
        return $res;
    }

    function guess_attack ($foe)
    {
        $attempt = G::$decode_move[$this->old->attack];
        $success = ($this->old->attack == "pass");
        foreach ($this->move as $m)
        {
            if ($m->type == $attempt)
            {
                if ($m->new_count == $m->uses-1)
                {
                    $m->uses--;
                    $success = true;
                }
                break;
            }
        }

        $possible = array();
        $attack = $this->guess_attack_from_effect (array("Burn", "Confuse", "Poison", "Sleep", "Slow", "Weaken", "Sap"));
        if ($attack == "?") $attack = $foe->guess_attack_from_effect (array("Sharpen", "Shield"));
        if ($attack == "?")
        {
            $foe_damage = $this->old->hp - $this->hp - (10 * $this->Burn + 5 * $this->Pturns*$this->Poison);
            if ($this->old->attack == "Heal" && $success) $foe_damage += 50;
            $possible_dmg[] = $foe_damage;
            //;!;if ($this->Confuse) $possible_dmg[] = $foe_damage + $this->damage_recieved ("self");
            $possible = $this->guess_attack_from_damage ($foe, $possible_dmg);
            if (count ($possible) == 1) $attack = $possible[0];
        }
        if ($attack == "?")
        {
            $own_damage = $foe->old->hp - $foe->hp 
                        - (10 * $foe->Burn + 5 * $foe->Pturns*$foe->Poison)
                        + $foe->damage_recieved ($this->attack);
            if (abs ($own_damage/50+1) < 0.1) $attack = "Heal";
        }
        if ($attack != "?")
        {
            $type = G::$decode_move[$attack];
            if ($attack != "?")
            {
                foreach ($foe->move as $m) if ($m->type == $type) goto found_old;
                foreach ($foe->move as $m) if ($m->type == 15) { $m->register($attack); goto found_new; }
            }
            found_new:
            found_old:
        }
    }

    function max_damage($foe)
    {
        $dmg = 0;
        foreach ($foe->move as $m) $dmg = max ($dmg, $this->damage_recieved (G::$code_move[$m->type], $foe));
        return $dmg;
    }

    function expected_damage ($foe)
    {
        return $this->max_damage($foe) + 10 * $this->Burn + 5 * ($this->Pturns+1);
    }

    function life_expectancy ($foe)
    {
        $hp = $this->hp;
        $poison = $this->Pturns;
        $heal = $this->can_do ("Heal");
        $dmg = $this->max_damage($foe);
        for ($turn = 0 ; $hp > 0 && $turn < 10; $turn++)
        {
            $hp -= 10 * $this->Burn + 5 * $poison;
            if ($poison > 0) $poison++;
            $hp -= $dmg;
            if ($hp <= 0 && $heal > 0) { $hp+=50; $heal--; }
        }
        return 100 * $turn + $this->hp;
    }

    function can_attack ($foe)
    {
        $attack = false;
        if ($this->hp > 0)
        {
            if      (!$foe->Poison  && $this->can_do ("Poison" )) $attack = "Poison";
            else if (!$foe->Confuse && $this->can_do ("Confuse")) $attack = "Confuse";
            else if (!$foe->Burn    && $this->can_do ("Burn"   )) $attack = "Burn";
        }
        $this->atk_score = ($attack === false) ? 0 : G::$atk_score[$attack];
        return $attack;
    }

    function can_do($move)
    {
        $type = G::$decode_move[$move];
        foreach ($this->move as $m) if ($m->type == $type && $m->uses > 0) return $m->uses;
        return false;
    }

    function execute($move)
    {
        $type = G::$decode_move[$move];
        foreach ($this->move as $i=>$m) if ($m->type == $type) 
        { 
            if ($m->uses > 0)
            {
//;!;               $m->uses--;
                $this->attack = $move;
            }
            else $this->attack = "pass";
            return $i; 
        }
        die ("$this asked to perform $move, available ".implode(",", $this->move));
    }
}

// ============================================================================
// Team
// ============================================================================
class Team {
    function __construct ($members)
    {
        $this->monster = $members;
    }

    function __tostring()
    {
        return implode ("|", $this->monster);
    }

    function active ()
    {
        return $this->monster[$this->active];
    }

    function initial_opponent()
    {
        return $this->monster[0];
    }
}

// ============================================================================
// main
// ============================================================================
$input = $argv[1];

$team_name = "H3C";
$mem_file = "$team_name/memory.txt";
$trc_file = "$team_name/trace.txt";
if (!file_exists($team_name)) mkdir($team_name, 0777, true) or die ("could not create storage directory '$team_name'");
if ($input == "T") array_map('unlink', glob("$team_name/*.txt"));

if (file_exists($mem_file)) $game = unserialize (file_get_contents ($mem_file));
else
{
    $team = new Team (
        array (
            new Monster ("Handy" , "Grass" , 50, 99, 81, "Confuse", "Poison", "Heal"),
            new Monster ("Nutty" , "Fire"  , 50, 99, 81, "Burn"   , "Poison", "Heal"),
            new Monster ("Flippy", "Water" , 50, 99, 81, "Confuse" , "Burn" , "Heal")));
    $game = new G($team_name,$team);
}

$game->process ($input);
file_put_contents ($mem_file, serialize($game));

ผล

LittleKid ยังคงเป็นอันตราย แต่ทั้งสามคนของฉันเอาชนะความชั่วร้ายของเขาด้วยอัตรากำไรที่ยุติธรรม

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

คู่แข่งใหม่จาก Planet JavaScript อยู่ในระดับเดียวกับทีมในแบบตัวต่อตัว แต่จะแย่กว่าคู่แข่งรายอื่น พวกเขาช่วยลดคะแนนของ LittleKid ได้จริง :)

ดังนั้นดูเหมือนว่าเพื่อนที่น่ากอดของฉันจะยังคงเป็นกษัตริย์ของเขาอยู่ - ตอนนี้ ...

170             H3C
158             Nodemon
145             LittleKid
55              InsideYourHead
42              HardenedTrio
30              BitterRivals

HardenedTrio, Python 3

เนื่องจาก Geobits ดีพอที่จะให้เราส่งสองครั้งฉันคิดว่าฉันจะส่งเรื่องโง่ ๆ สำหรับเรื่องแรก: P

ปาร์ตี้คือสาม Codemon (Metapod1, Metapod2, Metapod3) ด้วยสถิติและการเคลื่อนไหวที่เหมือนกัน:

• 80 การโจมตี 100 การป้องกัน 50 ความเร็ว
• Punch, Heal, Shield Harden

คะแนนโบนัสทั้งหมดจะได้รับการกำหนดเพื่อการป้องกัน

from collections import namedtuple
import sys

BattleState = namedtuple("BattleState", ["us", "them"])
TeamState = namedtuple("TeamState", ["name", "active", "members"])
MemberState = namedtuple("MemberState", ["name", "id", "attack", "defense", "speed", "hp",
                                         "typeid", "poisonedturns", "otherstats"])

def parse_battle_state(state):
    return BattleState(*map(parse_team_state, state.split("#")))

def parse_team_state(state):
    na, *members = state.split("|")
    name, active = na.split(":")
    return TeamState(name, int(active), list(map(parse_member_state, members)))

def parse_member_state(state):
    name, id_, attack, defense, speed, hp, typeid, poisonedturns, *rest = state.split(":")
    return MemberState(name, int(id_), float(attack), float(defense), float(speed),
                       float(hp), int(typeid), int(poisonedturns), rest)

command = sys.argv[1].strip()

if command.startswith("T"):
    print("HardenedTrio|Metapod1:0:80:100:50:0:1:11|"
          "Metapod2:0:80:100:50:0:1:11|Metapod3:0:80:100:50:0:1:11")

elif command.startswith("C"):
    battle_state = parse_battle_state(command[2:])

    for i, codemon in enumerate(battle_state.us.members):
        if codemon.hp > 0:
            print(i)
            break

elif command.startswith("A"):
    battle_state = parse_battle_state(command[2:])
    current_codemon = battle_state.us.members[battle_state.us.active]

    if current_codemon.hp < 50 and int(current_codemon.otherstats[1]) > 0:
        print(1) # Heal up if low

    elif int(current_codemon.otherstats[2]) > 0:
        print(2) # Harden!

    else:
        print(0) # Punch!

elif command.startswith("B"):
    print("1:1:1")

ทำงานด้วย

py -3 <filename>

(หรือมีpython/ python3แทนที่จะpyขึ้นอยู่กับการติดตั้งของคุณ)

ในหัวคุณทับทิม

• Brian : Psychic, Attack: 100, Defense: 50, Speed: 80, เจ็บปวด, Fireball, Watergun
• Elemon1 : พลังจิต, การโจมตี: 100, การป้องกัน: 50, ความเร็ว: 80, Fireball, Watergun, Vine
• Elemon2 : พลังจิต, การโจมตี: 100, การป้องกัน: 50, ความเร็ว: 80, Fireball, Watergun, Vine

TEAM_SPEC = "InsideYourHead"+
            "|Brian:1:100:50:80:3:6:9"+
            "|Elemon1:1:100:50:80:6:9:12"+
            "|Elemon2:1:100:50:80:6:9:12"

def parse_battle_state request
    request.map do |team_state|
        state = {}
        parts = team_state.split '|'
        state[:active] = parts.shift.split(':')[1].to_i
        state[:monsters] = parts.map do |monster_state|
            monster = {}
            parts = monster_state.split(':')
            monster[:name] = parts[0]
            monster[:hp] = parts[5].to_i
            monster[:type] = parts[6].to_i
            monster
        end
        state
    end
end

request = ARGV[0].split '#'
case request.shift
when 'T'
    puts TEAM_SPEC
when 'C'
    battle_state = parse_battle_state request
    my_state = battle_state[0]
    puts my_state[:monsters].find_index {|monster| monster[:hp] > 0}
when 'A'
    battle_state = parse_battle_state request
    my_state, their_state = *battle_state
    my_monster = my_state[:monsters][my_state[:active]]
    their_monster = their_state[:monsters][their_state[:active]]
    puts [1,0,1,2,0][their_monster[:type]]
when 'B'
    puts '0:0:0'
end

ทำงานด้วย

ruby InsideYourHead.rb

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

กลยุทธ์ค่อนข้างง่าย: โจมตี! สัตว์ประหลาดทั้งสามนั้นมีท่าโจมตีที่บริสุทธิ์เท่านั้นและพวกเขาเลือกการเคลื่อนไหวตามประเภทของสัตว์ประหลาดของคู่ต่อสู้

ฉันอาจทดลองโยนในการรักษาในภายหลัง

LittleKid, Java

เด็กน้อยพบโคเดมอนที่เหมือนกัน 3 ตัวและฝึกฝนพวกมัน พวกเขาน่ารำคาญมากกับการโจมตี + รักษาพิษ การใช้โคเดมอนชนิดปกติเท่านั้นไม่จำเป็นต้องจับคู่กับศัตรูเฉพาะเนื่องจากพิษทำงานได้ดีกับทุกประเภท

public class LittleKid {

    public static void main(String[] args) {
        if(args.length < 1){
            System.out.println("Geobits says you can't do this.");
            System.exit(0);
        }

        String[] sections = args[0].split("#");
        String me, them, out = "";
        switch(sections[0]){
            case "T":
                out = "LittleKid";
                out += "|Poisoner:0:80:100:50:0:1:13";
                out += "|Poisoner:0:80:100:50:0:1:13";
                out += "|Poisoner:0:80:100:50:0:1:13";
                break;
            case "B":
                out = "1:1:1";
                break;
            case "C":
                me = sections[1];
                them = sections[2];
                int pick = 0;

                if(!isAlive(me, pick)){
                    for(int i=0;i<3;i++){
                        if(isAlive(me,i))
                            pick = i;
                    }
                }

                out = String.valueOf(pick);
                break;
            case "A":
                me = sections[1];
                them = sections[2];
                int active = getActive(me);
                int enemyActive = getActive(them);
                if (getField(me, HP, active) < 50 && getField(me, MOVE1, active) != 0) {
                    out = "1";
                } else if (getEffectCount(them, POISON, enemyActive, false) < 1 && getField(me, MOVE2, active) != 0) {
                    out = "2";
                } else {
                    out = "0";
                }
                break;
            default:
                out = "Invalid query from controller.";             
        }
        System.out.println(out);
    }

    static boolean isAlive(String teamState, int who){
        return getField(teamState, HP, who) > 0;
    }

    static int getActive(String teamState){
        return Integer.parseInt(teamState.split("\\|")[0].split(":")[1]);
    }

    static int getField(String teamState, int field, int who){
        String[] fields = teamState.split("\\|")[who+1].split(":");
        return Integer.parseInt(fields[field]);
    }

    static int getEffectCount(String teamState, int effect, int who, boolean mine){
            String[] fields = teamState.split("\\|")[who+1].split(":");
            int count = 0;
            for(int i=mine?14:8;i<fields.length;i++){
                if(Integer.parseInt(fields[i]) == effect)
                    count++;
            }
            return count;
    }

    final static int ID =       1; 
    final static int ATTACK =   2; 
    final static int DEFENSE =  3; 
    final static int SPEED =    4; 
    final static int HP =       5; 
    final static int TYPE =     6;
    final static int MOVE0 =    8; 
    final static int MOVE1 =    9; 
    final static int MOVE2 =    10;

    final static int POISON =           1;
}

Nodémon - Javascript

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

ฉันไม่ได้ติดตั้ง PHP ดังนั้นจึงไม่ได้ทดสอบกับ Campers แต่ดูเหมือนว่าจะเป็นคู่แข่งที่ดีสำหรับ LittleKid ในการทดลองของฉัน (และกำจัด Bitter Rivals)

/*jshint node:true*/
'use strict';

var fs = require('fs');

var dataFile = 'Nodemon/data.json';
function getData(callback) {
  fs.readFile(dataFile, 'utf8', function(err, contents) {
    var data = {round: 0};

    if(!err) {
      data = JSON.parse(contents);
    }

    callback(data);
  });
}

function saveData(data, callback) {
  fs.mkdir('Nodemon', function() {    
    fs.writeFile(dataFile, JSON.stringify(data), callback);
  });
}

var effect = {
  poison: '1',
  confusion: '2',
  burn: '3',
  sleep: '4',
  heal: '5',
  attackUp: '6',
  attackDown: '7',
  defenseUp: '8',
  defenseDown: '9',
  speedDown: '10'
};

function parseMemberCommon(args) {
  return {
    name: args[0],
    id: args[1],
    baseAttack: +args[2],
    baseDefense: +args[3],
    baseSpeed: +args[4],
    hp: +args[5],
    typeId: args[6],
    poisonedTurns: +args[7],
    effects: args.slice(8)
  };
}

function parseOwnMember(arg) {
  var args = arg.split(':');

  var ownArgs = args.splice(8, 6);

  var member = parseMemberCommon(args);

  member.moveCount = [
    +ownArgs[0],
    +ownArgs[1],
    +ownArgs[2]
  ];

  member.bonusAttack = +ownArgs[3];
  member.bonusDefense = +ownArgs[3];
  member.bonusSpeed = +ownArgs[3];

  return member;
}

function parseOpponentMember(arg) {
  return parseMemberCommon(arg.split(':'));
}

function parseTeamStateCommon(arg, memberParse) {
  var args = arg.split(':');
  var state = {
    name: args[0],
    members: []
  };
  args = arg.substring(state.name.length + 1).split('|');
  var activeSlot = args[0];
  for(var index = 1; index < args.length; index++) {
    state.members.push(memberParse(args[index]));
  }
  state.activeMember = state.members[activeSlot];
  return state;
}

function parseOwnState(arg) {
  return parseTeamStateCommon(arg, parseOwnMember);
}

function parseOpponentState(arg) {
  return parseTeamStateCommon(arg, parseOpponentMember);
}

function parseBattleState(arg) {
  var args = arg.split('#');
  return {
    own: parseOwnState(args[0]),
    opponent: parseOpponentState(args[1])
  };
}

function teamData() {

  saveData({round:0}, function() {
    console.log('Nodemon|' + 
      'Charasaur:0:50:80:100:10:13:1|' +
      'Bulbtortle:4:50:80:100:10:13:1|' +
      'Squirtmander:1:50:80:100:10:13:4');
  });
}

function getActiveIndex(battleState) {
  for(var index = 0; index < battleState.own.members.length; index++) {
    var member = battleState.own.members[index];
    if(member.hp > 0) {
      return index;
    }
  }
}

function chooseActive(arg) {
  var battleState = parseBattleState(arg);

  getData(function(data) {
    var allFull = true;
    for(var index = 0; index < battleState.opponent.members.length; index++) {
      var member = battleState.opponent.members[index];
      if(!data.maxSpeed || member.baseSpeed > data.maxSpeed) {
        data.maxSpeed = member.baseSpeed;
      }
      if(member.hp < 100) {
        allFull = false;
      }
    }

    if(allFull) {
      data.round++;
    }

    saveData(data, function() {
      console.log(getActiveIndex(battleState));
    });    
  });
}

function useMove(moves, battleState) {
  var fighter = battleState.own.activeMember;

  for(var moveIndex = 0; moveIndex < moves.length; moveIndex++) {
    var move = moves[moveIndex];
    if(fighter.moveCount[move]) {
      return move;
    }

    for(var memberIndex = 0; memberIndex < battleState.own.members.length; memberIndex++) {
      var member = battleState.own.members[memberIndex];

      if(member.hp > 0 && member.moveCount[move] > 0) {
        return 10 + memberIndex;
      }
    }
  }

  return -1;  //do nothing
}

function battleAction(arg) {
  var battleState = parseBattleState(arg);

  var fighter = battleState.own.activeMember;
  var opponent = battleState.opponent.activeMember;

  var attemptedMoves = [];

  if(opponent.effects.indexOf(effect.poison) === -1) {
    attemptedMoves.push(1);
  }

  if(opponent.effects.indexOf(effect.confusion) === -1) {
    attemptedMoves.push(0);
  }

  if(fighter.name === 'Squirtmander') {
    //sleep
    if(opponent.effects.indexOf(effect.sleep) === -1) {
      attemptedMoves.push(2);
    }
  }
  else {
    //heal
    if(fighter.hp <= 60) {
      attemptedMoves.push(2);
    }
  }

  console.log(useMove(attemptedMoves, battleState));
}

function bonusStats(arg) {
  var teamState = parseOwnState(arg);

  getData(function(data) {
    var result = '1:';

    if(data.round % 4 === 0) {
      result += '1:';
    }
    else {
      result += '2:';
    }
    if(teamState.members[2].baseSpeed + teamState.members[2].bonusSpeed > data.maxSpeed + (data.round / 2)) {
      result += '1';
    }
    else {
      result += '2';
    }
    console.log(result);
  });
}

var actions = {
  'T': teamData,
  'C': chooseActive,
  'A': battleAction,
  'B': bonusStats
};

var arg = process.argv[2];
actions[arg[0]](arg.substring(2));

ทำงานด้วย

node nodemon

ป.ล. ขอโทษด้วยที่พยักหน้ารับ

Bitter Rivals - Java

ทีม Grass / Fire / Water ที่ชอบเปลี่ยนมัน

Greenosaur

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

Type: Grass
Attack:   80     Vine
Defense:  50     Punch
Speed:   100     Pain

Searizard

พยายามทำลายศัตรูด้วยการโจมตีน้อย เบิร์นส์และบั้งไฟหลังจากนั้น

Type: Fire
Attack:  100     Fireball
Defense:  50     Burn
Speed:    80     Sap

Blastshield

ใช้โล่เพื่อเสริมการป้องกันที่สูงอยู่แล้ว รักษาเมื่อจำเป็น

Type: Water
Attack:   80     Watergun
Defense: 100     Shield
Speed:    50     Heal

รหัส

นี่รวมอยู่ในคอนโทรลเลอร์ด้วย นี่คือทีมแข่งขันซึ่งแตกต่างจาก DummyTeam คำสั่งที่ต้องการplayers.confคือ:

java BitterRivals

public class BitterRivals {

    public static void main(String[] args) {
        if(args.length < 1){
            System.out.println("You're not doing this right. Read the spec and try again.");
            System.exit(0);
        }

        String[] sections = args[0].split("#");
        String me, them, out = "";
        switch(sections[0]){
            case "T":
                out = "BitterRivals";
                out += "|Greenosaur:4:80:50:100:12:0:3";
                out += "|Searizard:2:100:50:80:6:7:14";
                out += "|Blastshield:3:80:100:50:9:11:1";
                break;
            case "B":
                out = "2:0:1";
                break;
            case "C":
                me = sections[1];
                them = sections[2];

                int pick = 0;
                switch(getField(them, TYPE, getActive(them))){
                    case 0:
                    case 1:
                    case 3:
                        pick = 0;
                        break;
                    case 2:
                        pick = 2;
                        break;
                    case 4:
                        pick = 1;
                        break;
                }

                if(!isAlive(me, pick)){
                    for(int i=0;i<3;i++){
                        if(isAlive(me,i))
                            pick = i;
                    }
                }

                out = pick + "";
                break;
            case "A":
                me = sections[1];
                them = sections[2];
                int active = getActive(me);
                int oType = getField(them, TYPE, getActive(them));
                switch(active){
                    case 0:         // Greenosaur
                        switch(oType){
                            case 0:
                            case 4:
                                out = "1";
                                break;
                            case 1:
                                out = "2";
                                break;
                            case 3:
                                out = "0";
                                break;
                            case 2:
                                if(isAlive(me, 2)){
                                    out = "12";
                                } else if(isAlive(me, 1)){
                                    out = "11";
                                } else {
                                    out = "1";
                                }
                                break;
                        }
                        break;
                    case 1:         // Searizard
                        if(oType == 3){
                            if(isAlive(me, 0)){
                                out = "10";
                                break;
                            } else if(isAlive(me, 2)){
                                out = "12";
                                break;
                            }
                            if(getEffectCount(them, BURN, getActive(them), false) < 1 && getField(me, MOVE1, active) > 0){
                                out = "1";
                            } else if(getField(me, MOVE2, active) > 0){
                                out = "2";
                            } else {
                                out = "3";
                            }                           
                        } else {
                            if(getField(them, ATTACK, getActive(them)) < 80){
                                if(getEffectCount(them, DEFENSE_DOWN, getActive(them), false) < 1 && getField(me, MOVE2, active) > 0){
                                    out = "2";
                                    break;
                                } else if(getEffectCount(them, BURN, getActive(them), false) < 1 && getField(me, MOVE1, active) > 0){
                                    out = "1";
                                    break;
                                }
                            }
                            out = "0";
                        }
                        break;
                    case 2:         // Blastshield
                        if(oType == 4){
                            if(isAlive(me, 1)){
                                out = "11";
                                break;
                            } else if(isAlive(me, 0)){
                                out = "10";
                                break;
                            }
                        }
                        if(getField(me, HP, active) < 50 && getField(me, MOVE2, active) > 0){
                            out = "2";
                        } else if(getEffectCount(me, DEFENSE_UP, active, true) < 3 && getField(me, MOVE1, active) > 0){
                            out = "1";
                        } else {
                            out = "0";
                        }
                        break;
                }
                break;
            default:
                out = "Invalid query from controller.";             
        }
        System.out.println(out);
    }

    static boolean isAlive(String teamState, int who){
        return getField(teamState, HP, who) > 0;
    }

    static int getActive(String teamState){
        return Integer.parseInt(teamState.split("\\|")[0].split(":")[1]);
    }

    static int getField(String teamState, int field, int who){
        String[] fields = teamState.split("\\|")[who+1].split(":");
        return Integer.parseInt(fields[field]);
    }

    static int getEffectCount(String teamState, int effect, int who, boolean mine){
            String[] fields = teamState.split("\\|")[who+1].split(":");
            int count = 0;
            for(int i=mine?14:8;i<fields.length;i++){
                if(Integer.parseInt(fields[i]) == effect)
                    count++;
            }
            return count;
    }

    final static int ID =       1; 
    final static int ATTACK =   2; 
    final static int DEFENSE =  3; 
    final static int SPEED =    4; 
    final static int HP =       5; 
    final static int TYPE =     6; 
    final static int PTURNS =   7; 
    final static int MOVE0 =    8; 
    final static int MOVE1 =    9; 
    final static int MOVE2 =    10; 
    final static int HA =       11; 
    final static int HD =       12; 
    final static int HS =       13; 

    final static int POISON =           1;
    final static int CONFUSION =        2;
    final static int BURN =             3;
    final static int SLEEP =            4;
    final static int ATTACK_UP =        6;
    final static int ATTACK_DOWN =      7;
    final static int DEFENSE_UP =       8;
    final static int DEFENSE_DOWN =     9;
    final static int SPEED_DOWN =       10;
}

ข้อผิดพลาด 310: การเปลี่ยนเส้นทางมากเกินไป - C ++

ทีมงานที่ได้รับการฝึกอบรมมาอย่างดีเพื่อจัดการกับการทำลายล้างพิษ

สามสัปดาห์ที่ผ่านมาฉันฝึกcodémonsของฉันไม่ได้ ฉันก่อตั้งหลายทีม และในที่สุดฉันก็พร้อมที่จะเผชิญกับความท้าทายนี้ เพื่อตอบโต้ผู้วางยาพิษทั้งหมดของฉันฉันก่อตั้งทีมที่มีcodémonsที่แตกต่างกันมากโดยแต่ละคนมีบทบาทเฉพาะ

ยาแก้พิษ

Type : Normal - atk:50 def:100 spd:80 - Poison/Burn/Heal

ยาแก้พิษรักพิษ มากจนฉันไม่สามารถหยุดเขาจากการวิ่งเข้าโจมตีพิษ

เซน

Type : Fire - atk:100 def:80 spd:50 - Poison/Vine/Heal

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

Triforce

Type : Psychic - atk:88 def:60 spd:82 - Fireball/Watergun/Vine

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

คุณสามารถดาวน์โหลดทีมได้ที่นี่:

Linux:

http://dl.free.fr/iHYlmTOQ2

เปิดตัวด้วย ./Error310TMR

Windows:

http://dl.free.fr/vCyjtqo2s

เปิดตัวด้วย ./Error310TMR.exe

รหัสเป็นโครงการ c ++ ที่สมบูรณ์ ฉันไม่ทราบวิธีการเผยแพร่

$ wc -l src/*
    165 src/BruteForce.cpp
     26 src/BruteForce.h
    349 src/Codemon.cpp
     77 src/Codemon.h
     21 src/Logger.cpp
     35 src/Logger.h
    105 src/NoTimeToExplain.cpp
     27 src/NoTimeToExplain.h
    240 src/Recoverator.cpp
     31 src/Recoverator.h
     26 src/StrManip.cpp
     16 src/StrManip.h
    303 src/Team.cpp
     68 src/Team.h
     88 src/TooManyRedirects.cpp
     24 src/TooManyRedirects.h
     87 src/Unrecoverable.cpp
     27 src/Unrecoverable.h
     59 src/enums.cpp
    119 src/enums.h
     68 src/main.cpp
   1961 total

แต่มันมีประสิทธิภาพมาก:

------- Final Results -------

176     Error310TMR
131     H3C
130     LittleKid
121     Nodemon
58      InsideYourHead
47      HardenedTrio
37      BitterRivals

เทพนิยาย

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

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

#!/bin/perl
use 5.20.0;
use strict;

use constant MINE => 0;
use constant THEIRS => 1;

$_ = $ARGV[0];

if(/^T/){
    say 'FairyTale|Fairy:1:89:90:51:3:4:13|Dragon:2:100:50:80:6:1:8|Assassin:0:70:60:100:0:1:10';

} elsif(/^C#(.*)/){
    my $state = readBattleState($1);
    if($state->[MINE]->{$state->[MINE]->{slot}}{hp}){
        say $state->[MINE]->{slot};
    } elsif($state->[MINE]->{($state->[MINE]->{slot}+1)%3}{hp}){
        say (($state->[MINE]->{slot}+1)%3);
    } else {
        say (($state->[MINE]->{slot}+2)%3);
    }

} elsif(/^A#(.*)/){
    my $state = readBattleState($1);
    my @actives = (
        $state->[MINE]->{$state->[MINE]->{slot}},
        $state->[THEIRS]->{$state->[THEIRS]->{slot}}
    );
    if($state->[MINE]->{slot} == 0){
        if(!exists($actives[THEIRS]{effects}{4}) && $actives[MINE]{pp}->[1]){
            say 1;
        } elsif(!exists($actives[THEIRS]{effects}{1}) && $actives[MINE]{pp}->[2]) {
            say 2;
        } elsif(!$actives[THEIRS]{type}) {
            if($state->[MINE]->{($state->[MINE]->{slot}+1)%3}{hp} > 0){
                say (($state->[MINE]->{slot}+1)%3);
            } elsif($state->[MINE]->{($state->[MINE]->{slot}+2)%3}{hp} > 0) {
                say (($state->[MINE]->{slot}+2)%3);
            } else {
                say 0;
            }
        } else {
            say 0;
        }
    } elsif($state->[MINE]->{slot} == 1){
        if(!exists($actives[MINE]{effects}{6}) && $actives[MINE]{pp}->[2]){
            say 2;
        } elsif ($actives[MINE]{hp} > 10 && $actives[MINE]{hp} < 50 && $actives[MINE]{pp}->[1]){
            say 1;
        } else {
            say 0;
        }
    } elsif($state->[MINE]->{slot} == 2){
        if(!exists($actives[MINE]{effects}{6}) && $actives[MINE]{pp}->[2]){
            say 2;
        } elsif ($actives[MINE]{hp} > 10 && $actives[MINE]{hp} < 50 && $actives[MINE]{pp}->[1]){
            say 1;
        } elsif($actives[THEIRS]{type} == 1) {
            if($state->[MINE]->{($state->[MINE]->{slot}+1)%3}{hp} > 0){
                say (($state->[MINE]->{slot}+1)%3);
            } elsif($state->[MINE]->{($state->[MINE]->{slot}+2)%3}{hp} > 0) {
                say (($state->[MINE]->{slot}+2)%3);
            } else {
                say 0;
            }
        } else {
            say 0;
        }
    }

} elsif(/^B#(.*)/){
    my $state = readTeam($1, 1);
    say '1:0:2';
}

sub readBattleState {
    local $_ = $_[0];
    if(/^(.*?)#(.*?)$/){
        my @teams;
        $teams[0] = readTeam($1, 1);
        $teams[1] = readTeam($2, 0);
        return \@teams;
    }
}

sub readTeam {
    my $isMine = $_[1];
    local $_ = $_[0];
    if(/.*?:(?<slot>.*?)\|(.*?)\|(.*?)\|(.*?)$/){
        my %team;
        $team{slot} = $1;
        $team{0} = $isMine ? readYourMember($2) : readTheirMember($2);
        $team{1} = $isMine ? readYourMember($3) : readTheirMember($3);
        $team{2} = $isMine ? readYourMember($4) : readTheirMember($4);
        return \%team;
    }
    return 0;
}

sub readYourMember {
    local $_ = $_[0];
    if(/(?<name>.*?):(?<id>.*?):(?<atk>.*?):(?<def>.*?):(?<spd>.*?):(?<hp>.*?):(?<type>.*?):(?<poison>.*?):(?<move0>.*?):(?<move1>.*?):(?<move2>.*?):(?<batk>.*?):(?<bdef>.*?):(?<bspd>.*?)(?<effects>(?::.*)|$)/){
        my %effects = map { $_ => 1 } readEffects($+{effects});
        my %member = (
            name   => $+{name},
            id     => $+{id},
            hp     => $+{hp},
            atk    => $+{atk}+$+{batk},
            def    => $+{def}+$+{bdef},
            spd    => $+{spd}+$+{bspd},
            type   => $+{type},
            pp     => [$+{move0}, $+{move1}, $+{move2}],
            poistrn=> $+{poison},
            effects=> \%effects
        );
        return \%member;
    }
}

sub readTheirMember {
    local $_ = $_[0];
    if(/(?<name>.*?):(?<id>.*?):(?<atk>.*?):(?<def>.*?):(?<spd>.*?):(?<hp>.*?):(?<type>.*?):(?<poison>.*?)(?<effects>(?::.*)|$)/){
        my %effects = map { $_ => 1 } readEffects($+{effects});
        my %member = (
            name   => $+{name},
            id     => $+{id},
            hp     => $+{hp},
            atk    => $+{atk},
            def    => $+{def},
            spd    => $+{spd},
            type   => $+{type},
            poistrn=> $+{poison},
            effects=> \%effects
        );
        return \%member;
    }
    return 0;
}

sub readEffects {
    local $_ = $_[0];
    my @retval = /:([^:]*)/g;
    if(!@retval){
        @retval = (0);
    }
    return @retval;
}

ทำงานด้วย

perl fairytale.pl

Dummy Team - Java

(ไม่ใช่การแข่งขัน CW)

นี่คือทีมหลอกตาที่จะฝึกซ้อม เป็นประเภทปกติทั้งหมดซึ่งเลือกสุ่มระหว่างการเคลื่อนไหว (Punch, Heal, Slow) ในแต่ละเทิร์น ขอให้สนุกกับมัน

public class DummyTeam {

    public static void main(String[] args) {
        if(args.length < 1){
            System.out.println("You need to run this from the tournament. Try to keep up.");
            System.exit(0);
        }

        String[] sections = args[0].split("#");
        String out = "";
        switch(sections[0]){
            // team data
            //      sends back all Normal types with minimum stats and Normal moves (randomized name suffixes to distinguish in tests)
            case "T":
                out = "DummyTeam";
                for(int i=0;i<3;i++)
                    out += "|Dummy"+((char)(Math.random()*26)+65) + i + ":0:50:50:50:0:1:2";
                break;
            // bonus points
            //      shoves them all in defense every time
            case "B":
                out = "1:1:1";
                break;
            // choose active
            //      picks last active if alive, otherwise loops to find first living member
            case "C":
                String[] team = sections[1].split("\\|");
                int current = Integer.parseInt(team[0].split(":")[1]);
                if(Integer.parseInt(team[current+1].split(":")[5]) > 0){
                    out = current + "";
                } else {
                    for(int i=1;i<team.length;i++){
                        if(Integer.parseInt(team[i].split(":")[5]) > 0){
                            out = (i - 1) + "";
                        }
                    }
                }               
                break;
            // choose action
            //      chooses a random move. does not check if it ran out of uses, so wastes turns quite often
            case "A":
                out = ((int)(Math.random()*3)) + "";
                break;
            default:
                out = "Invalid query from controller.";             
        }
        System.out.println(out);
    }


}