ในการท้าทายนี้คุณจะต้องสร้างมิตรภาพโดยมีเป้าหมายในการเอาชนะมิตรภาพอื่น ๆ ทั้งหมดในการต่อสู้

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

ตัวละครมีความสามารถ การเลือกความสามารถของตัวละครของคุณคือส่วนที่สำคัญที่สุด (และสนุก) ใน KotHนี้ พวกเขาแข็งแกร่งและมีศักยภาพที่จะกำจัดศัตรูของคุณ

ตัวละครมีคะแนนสุขภาพ (HP) และเมื่อฮิต HP ของพวกเขา (หรือไปด้านล่าง) 0, พวกเขาตาย หากตัวละครทั้งหมดในทีมของฝ่ายตรงข้ามเสียชีวิตคุณก็จะชนะ!

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

ตัวละครมีความล่าช้าในการเปิด สิ่งนี้จะกำหนดจำนวนของการทำเครื่องหมายระหว่างแต่ละรอบ (เริ่มต้นที่ 100) ต่ำกว่าดีกว่า

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

คุณลักษณะที่มีคือ:

• ความแข็งแกร่ง: ให้ 10 Max HP และ. 5 HP ต่อเทิร์น
• หน่วยสืบราชการลับ: ให้ 7 มานาสูงสุดและ. 1 มานาต่อเทิร์น
• Agility: ลดการหน่วงเวลาการหมุน 1

การเคลื่อนไหว, วิสัยทัศน์, ช่วงของ
ช่วงมีดังนี้ (อยู่กึ่งกลางรอบ 0) บางช่วงมีความสำคัญซึ่งหมายความว่าพวกเขาสามารถขึ้นลงทางซ้ายขวาหรือลงเท่านั้น

    444
   43334
  4322234
 432111234
 432101234
 432111234
  4322234
   43334
    444

ตัวละครมีวิสัยทัศน์เริ่มต้นที่ 2 มีการแบ่งปันวิสัยทัศน์ระหว่างผู้เล่นที่มีมิตรภาพเดียวกัน

วิธีการเล่น

ผู้เล่นก่อสร้างจะสร้างมิตรภาพของพวกเขา คุณต้องทำตามขั้นตอนต่อไปนี้ :

1. ให้แต่ละจุดแอตทริบิวต์ตัวอักษร ตัวละครแต่ละตัวเริ่มต้นด้วย 5 ในแต่ละสถานะพร้อมกับอีก 20 เพื่อกระจายระหว่าง 3

2. ให้แต่ละความสามารถของตัวละคร อักขระแต่ละตัวเริ่มต้นด้วยสล็อตความสามารถ 4 ตัวและความสามารถจะใช้ 1 ช่องโดยค่าเริ่มต้น ความสามารถบางอย่างสามารถทำซ้ำได้และสามารถให้กับตัวละครหลายครั้ง ไม่อนุญาตให้ใช้ชุดความสามารถของการส่งอื่นโดยไม่ได้รับอนุญาตจากเจ้าของ

3. เขียนรหัสสำหรับบอทของคุณ รหัสจะต้องเป็น Java และจะใช้สำหรับการต่อสู้ (ขั้นตอนต่อไป)

การปฏิบัติ

ตัวละครทุกตัวเริ่มต้นด้วยการกระทำมาตรฐาน 3 อย่าง:

1. ขั้นตอน : ย้ายตัวละครของคุณในช่วงที่สำคัญ 1
2. Slice : โจมตีศัตรูให้กับPrimaryAttributeในช่วงที่สำคัญ 1
3. ยิ้ม : ไม่ทำอะไรเลย

ในเทิร์นของตัวละครจากนั้นจะต้องเลือกการกระทำที่จะดำเนินการ การดำเนินการอาจมีต้นทุนมานาและอาจมีคูลดาวน์ซึ่งกำหนดจำนวนรอบที่คุณต้องรอก่อนที่จะดำเนินการนั้นอีกครั้ง

ความสามารถ
ทุกตัวละครมี 4 ช่องความสามารถ หากความสามารถเป็นตัวเอียงมันเป็นการกระทำ

ความสามารถ

ชื่อคำอธิบายมานะคูลดาวน์ 
                                                     Mobility                                                     

Blink         ย้ายไปที่ตารางช่วง 4 2 2 
 Swap          สถาน Swap กับเป้าหมาย 5 5 
 Teleport      ย้ายได้ทุกที่ 20 5

Dash เพิ่มช่วงของขั้นทีละ 1 ทำซ้ำได้                                               
Mobile Step สามารถเคลื่อนที่ได้ใน 8 ทิศทาง                                                  
                                                    ทุ่ม                                                    

Quick         Slice สองครั้ง 3 0 
 Weave         Slice ศัตรูที่มองเห็นได้ทั้งหมด 15 ครั้ง 10

ดูดซับ Slice แต่ละอันจะขโมย 1 ในแอตทริบิวต์หลักของเป้าหมายของคุณ กินเวลา 20 รอบ                    
Cleave Each Slice สร้างความเสียหาย 1/2 กับศัตรูที่อยู่ใกล้เคียง                                           
Critital เพิ่มโอกาส 30% ที่ Slice จะสร้างความเสียหาย 200% ซึ่งทำซ้ำได้                               
Feast Each Slice จะเพิ่ม HP ของคุณ 3 ครั้งทำซ้ำได้                                             
Slice แบบยืดหยุ่นได้ใน 8 ทิศทางใด ๆ                                                      
มานาขโมย Slice ขโมย 2 มานา ซึ่งทำซ้ำได้                                                           
Reflexive Slice เมื่อหั่นบาง ๆ 0 3 
Ranged เพิ่ม 1 เข้ากับช่วงของ Slice                                                              
ปัดชิ้นที่ต่อเนื่องกันบนเป้าหมายเดียวกันสร้างความเสียหายได้มากกว่า 3 ครั้ง               
                                                    สถานะ                                                     

ปัดเป่า        ลบสถานะทั้งหมดออกจากเป้าหมาย ช่วงที่ 2 20 10 
 Duel          ตรึงคุณและเป้าหมายไว้จนกว่าคุณจะตาย ระยะ 1 25 0 
 ทำให้ล้มลง      คุณและเป้าหมายจะติดสตันในอีก 1,000 ติ๊ก 10 10 
 ดาวตก        ศัตรูทั้งหมดจะถูกสตัน 100 แต้มต่อ 25 25 10 
         เป้าหมายLeashถูกแช่แข็งสำหรับรอบถัดไปของพวกเขา 4 6 
 พิษ        พิษสำหรับ 1 HP เป็นเวลา 5 รอบ 5 0 
 ความเงียบ      เป้าหมายถูกปิดเสียงสำหรับ 5 รอบ 5 7 
 ช้า          เป้าหมายจะช้าลง 40 เห็บสำหรับ 3 รอบถัดไป 10 5 
 Stun          เป้าหมายจะถูกสตันสำหรับอีก 300 เห็บ 10 10

เย็นตัวละครอื่น ๆ ทั้งหมดในระยะ 2 จะถูกชะลอความเร็วโดย 10 เห็บ                                
ภูมิคุ้มกันไม่มีสถานะใดที่สามารถใช้ได้กับคุณ                                                           
                                                    เกี่ยวกับการป้องกัน                                                    

Force Field   Block ถัดไป 5 แหล่งของความเสียหาย ไม่ซ้อน 15 5 
 Ghost         เพื่อการเทิร์นความเสียหายทั้งหมดจะรักษา 10 10 
 Heal          Heal Target สำหรับ 20 HP 10 3 การ 
 คืนค่า       ทุกยูนิตจะถูกฟื้นฟูให้กลับสู่สภาพเต็มพลัง 20 40 
 Shield        คุณไม่สามารถถูกหั่นได้จนกว่าเทิร์นถัดไปของคุณ 3 0

หลบหลีกโอกาส 25% ที่ Slice จะไม่โจมตีคุณ ซึ่งทำซ้ำได้                                         
เสาสามารถหั่นได้เพียงครั้งเดียว                                                            
ฟื้นคืนชีพเมื่อถูกสังหารให้กลับมามีชีวิตด้วย HP เต็ม (และไม่มีสถานะ) 0 40 
Spikes เมื่อทำดาเมจได้รับความเสียหายครึ่งหนึ่งของดาเมจ                                           
                                                     วิสัยทัศน์                                                      

Cloak         Team จะมองไม่เห็นเป็นระยะ 5 ครั้ง 20 20 
 ซ่อน          คุณมองไม่เห็นเป็น 5 เทิร์น 4 7 
 เฟส         กลายเป็นล่องหนสำหรับ 1 เทิร์น 0 3 
 Track         Target ไม่สามารถล่องหนได้และรับความเสียหายมากขึ้น 10% ระยะเวลา 10 รอบ 5 5

ระยะการมองเห็นของศัตรูความมืดลดลง 1 Stacks แต่ไม่สามารถต่ำกว่า 1 ได้                                 
Far Sight Sight Range เพิ่มขึ้น 2 ทำซ้ำได้                                                    
Invisible คุณจะมองไม่เห็นถ้าคุณเริ่มมองเห็นศัตรู                               
True Sight เผยยูนิตที่ซ่อนอยู่ทั้งหมดในระยะที่ 2 เมื่อถึงจุดเริ่มต้น                                     
                                                     ความเสียหาย                                                      

Drain         สร้างความเสียหาย 5 เป้าหมายแก่เป้าหมายและรักษาตัวเอง 5 HP ในขณะที่อยู่ในระยะ 1 10 10 
 Lightning     สร้างความเสียหาย 15 เป้าหมายแก่ศัตรูทั้งหมด 20 10 
 K / O           สังหารเป้าหมายหากเป้าหมายต่ำกว่า 20% HP 20 0 
 กับดักกับดัก          ที่มองไม่เห็น กับดักจะสร้างความเสียหาย 15 ดาเมจเมื่อเหยียบ สแต็ค 10 2 
 Zap           สร้างความเสียหาย 30 ต่อเป้าหมาย 30 5

สร้างความเสียหาย 5 ดาเมจทุกเทิร์นให้กับศัตรูทั้งหมดภายในระยะ 1 ซึ่งทำซ้ำได้                       
                                                      สถิติ                                                      

Werewolf      เพิ่ม 10 ในสถิติทั้งหมดเป็นเวลา 5 รอบ 30 25

บัฟเพิ่มพูล HP ของคุณเป็นสองเท่า ซึ่งทำซ้ำได้                                                           
การกระทำที่ฉลาดมีคูลดาวน์ที่สั้นลง 20% ซึ่งทำซ้ำได้                                             
เน้นเพิ่มอัตราการมานาของคุณเป็น Int / 10 ซึ่งทำซ้ำได้                                  
Regenerate เพิ่มอัตรา Regneration ของคุณด้วย Strength / 2 ซึ่งทำซ้ำได้                                 
การกระทำที่ชาญฉลาดนั้นใช้มานาน้อยกว่า 2 ซึ่งทำซ้ำได้                                                      
แข็งแรงคุณจะได้รับ 10 คะแนนคุณลักษณะ ซึ่งทำซ้ำได้                                                  
อ่อนแอคุณเสีย 15 คะแนนคุณลักษณะ คุณได้รับความสามารถ 2 ช่อง (สิ่งนี้จะเป็นหนึ่งในนั้น)                  
                                                      อื่น ๆ                                                      

แบร์          สามารถเรียกหมีที่มี 5 ในแต่ละสถิติ 8 10 
 โคลน         โคลนด้วยตัวคุณเอง ใช้ความสามารถสองช่อง 100 100 
 Steal         แทนที่การกระทำนี้ด้วยการกระทำครั้งสุดท้ายที่ศัตรูใช้เป้าหมาย ใช้งานได้นาน 10 รอบ 5 0 
 กำแพง          สร้างกำแพงที่ไม่สามารถใช้ได้บนพื้นที่ว่างเปล่าที่ถูกกำหนดเป้าหมายในช่วง 6 10 10 

สถานะ:

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

สถานะทั้งหมด (ยกเว้นพิษ) ทำหน้าที่เป็นอิสระจากกัน

หมายเหตุด้านข้าง:

• หากมีเน็คไทสำหรับแอตทริบิวต์หลักมันจะถูกแก้ไขเป็น STR> AGI> INT
• คุณเล่นบนตาราง 10x10 ทีมจะถูกวางในฝั่งตรงข้าม
• เปอร์เซ็นต์สแต็กคูณยกเว้น Clever

กฎการส่ง

คุณต้องใช้งาน 2 ฟังก์ชั่น:

// Create *exactly* 3 Character templates.  You must return the same templates every time
public List<CharacterTemplate> createCharacters();

// Choose an action for a character.  If the action requires a target or location, it must be set.
public ReadonlyAction choose(Set<ReadonlyAction> actions, ReadonlyCharacter character);

นอกจากนี้คุณยังสามารถเข้าถึงตัวแปรสามตัว (ตัวแปรสมาชิก):

Set<ReadonlyCharacter> team;
Set<EnemyCharacter> enemies;
Map<Point2D, EnemyCharacter> visibleEnemies;

แค่นั้นแหละ. ด้านล่างนี้คุณสามารถค้นหา API ที่สมบูรณ์ตามลำดับตัวอักษร:

class Ability and ReadonlyAbility
    int getNumSlots() returns the number of slots it takes up
    boolean repeatable() returns true if the ability can be repeated
    String name()
class Action and ReadonlyAction
    Set<Point2D> availableLocations()
    Set<ReadonlyCharacter> availableTargets()
    boolean basicAction() returns true if the action is Smile, Step, or Slice
    boolean breaksInvisibiliby()      
    int getCooldown() returns the cooldown cost (not the cooldown remaining)
    int getManaCost()
    String getName()
    int getRemainingCooldown()
    boolean isAvailable() returns true if the action can be performed
    boolean movementAction() returns true if the action is prevented when Frozen
    boolean needsLocation()
    boolean needsTarget()
    void setTarget(ReadonlyCharacter target)
    void setLocation(Point2D location)
class CharacterTemplate
    void addAbility(Ability)
    boolean canAddAbility(Ability)
    List<Ability> currentAbilities()
    Map<Stat, Integer> currentAttributes()
    int getRemainingPoints() returns the total number of ability points you have left to assign
    int getRemainingSlots() returns the total number of slots you have to assign
    int getStat(Stat stat)
    boolean isValid() returns true if your character template is complete and valid
class Point2D
    getX()
    getY()
class Range
    boolean isCardinal() returns true if the range only extends in the 4 cardinal directions
    int getRange() returns the distance of the range
class ReadonlyCharacter and EnemyCharacter
    Class characterClass()
    int cleverness()
    List<ReadonlyAbility> getAbilities()
    Point2D getLocation()   Not on EnemyCharacter
    double getHealth()
    double getMana()
    int getMaxHealth()
    int getMaxMana()
    Range getSightRange()
    Range getSliceRange()
    int getStat(Stat stat)
    Range getStepRange()
    ReadonlyAction getLastAction()
    boolean isFrozen()
    boolean isStunned()
    boolean isPoisoned()
    int getPoisonAmount()
    boolean isSilenced()
    boolean isInvisible()
    boolean isDead()
    Stat primaryStat()
    int smartness()
enum Stat
    INT, STR, AGI

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

วิธีเรียกใช้โครงการ:

มีหลายวิธี:

1. ดาวน์โหลดไฟล์ JARjava -jar Fellowship.jarและเรียกใช้ หากคุณต้องการดาวน์โหลดส่งอื่น ๆ -q 99744ผ่าน java ต้องชี้ไปที่ JDK ไม่ใช่ JRE
2. โคลนrepo คอมไพล์gradle runและวิ่ง คุณต้องมีการติดตั้ง gradle และหากคุณต้องการส่งอาร์กิวเมนต์ให้ใช้-PappArgs="['arg1', 'args2']"
3. โคลนrepo คอมไพล์และรวบรวมด้วยตัวคุณเอง คุณจะต้องห้องสมุดต่อไปนี้: org.eclipse.collections:eclipse-collections-api:8.0.0, org.eclipse.collections:eclipse-collections:8.0.0, com.beust:jcommander:1.48, com.google.code.gson:gson:2.7,org.jsoup:jsoup:1.9.2

หากคุณโคลนคุณต้องใช้การ--recursiveตั้งค่าสถานะและเมื่อคุณดึงการอัปเดตให้รวม--recurse-submodulesสำหรับข้อใดข้อหนึ่งข้างต้นคลาสของคุณต้องไปที่submissions/javaโฟลเดอร์ ถ้าคุณกำลังใช้ gradle หรือคอมไพล์ด้วยตัวคุณเองคุณสามารถใส่คลาสลงในโครงงานได้ คุณจะต้องไม่แสดงข้อคิดเห็นบางบรรทัดในฟังก์ชั่นหลักและอัปเดตพวกเขาให้ชี้ไปที่ชั้นเรียนของคุณ

สกอร์:

+------+-------------------+-------+
| Rank | Name              | Score |
+------+-------------------+-------+
|    1 | TheWalkingDead    | 738.0 |
|    2 | RogueSquad        | 686.0 |
|    3 | Spiky             | 641.0 |
|    4 | Invulnerables     | 609.0 |
|    5 | Noob              | 581.0 |
|    6 | Railbender        | 561.0 |
|    7 | Vampire           | 524.0 |
|    8 | LongSword         | 508.0 |
|    9 | SniperSquad       | 456.0 |
|   10 | BearCavalry       | 430.0 |
|   11 | StaticCloud       | 429.0 |
|   12 | PlayerWerewolf    | 388.0 |
|   13 | LongSwordv2       | 347.0 |
|   14 | Derailer          | 304.0 |
|   15 | Sorcerer          | 266.0 |
|   16 | CowardlySniperMk2 | 262.0 |
|   17 | TemplatePlayer    |  59.0 |
+------+-------------------+-------+

หากคุณมีคำถามใด ๆ หรือต้องการความช่วยเหลือแสดงความคิดเห็นด้านล่างหรือเข้าร่วมห้องสนทนา ! ขอให้โชคดีและสนุก

StaticCloud

คลาวด์ที่เติบโตอย่างรวดเร็วซึ่งสร้างความเสียหายแบบคงที่ให้กับทุกคนที่เข้ามาใกล้ มันประกอบด้วย:

• 1/3 ส่วนที่มองไม่เห็น
  • STR: 5; AGI: 5; INT: 25
  • โคลน , ที่มองไม่เห็น , แบบคงที่
• 2/3 ส่วนที่มองเห็นได้
  • STR: 5; AGI: 5; INT: 25
  • โคลน , คงที่ , คงที่

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

StaticCloud.java
import java.util.Arrays;
import java.util.List;

import org.eclipse.collections.api.set.ImmutableSet;
import org.eclipse.collections.impl.factory.Sets;

import com.nmerrill.kothcomm.game.maps.Point2D;

import fellowship.abilities.ActionAbility;
import fellowship.abilities.damage.Static;
import fellowship.abilities.vision.Invisible;
import fellowship.actions.ReadonlyAction;
import fellowship.actions.other.Clone;
import fellowship.characters.CharacterTemplate;
import fellowship.characters.ReadonlyCharacter;

public class StaticCloud extends SleafarPlayer {
    private CharacterTemplate invisibleTemplate() {
        return new CharacterTemplate(0, 0, 20,
                new ActionAbility(Clone::new), new Invisible(), new Static());
    }

    private CharacterTemplate visibleTemplate() {
        return new CharacterTemplate(0, 0, 20,
                new ActionAbility(Clone::new), new Static(), new Static());
    }

    @Override
    public List<CharacterTemplate> createCharacters() {
        return Arrays.asList(visibleTemplate(), invisibleTemplate(), visibleTemplate());
    }

    private class InvisibleCloud extends Character {
        protected InvisibleCloud(ReadonlyCharacter delegate) {
            super(delegate);
        }

        @Override
        protected ReadonlyAction choose() {
            ReadonlyAction clone = getAction(Clone.class);
            if (clone != null && (isVisible() || !isInEnemySightRange())) {
                int invisibleCount = countCharacters(InvisibleCloud.class);
                if (invisibleCount > 8 && setClosestSafeLocation(clone, getStaticLocations())) {
                    return clone;
                } else if (setCloneLocation(clone, invisibleCount < 3 ? 3 : 1)) {
                    return clone;
                }
            }
            if (step != null && isVisible() && isInEnemySliceRange() &&
                    setClosestSafeLocation(step, getStaticLocations())) {
                return step;
            }
            if (slice != null && isVisible() && setSliceTarget(slice, 0.01)) {
                return slice;
            }
            if (step != null) {
                ImmutableSet<Point2D> avoidLocations = !isVisible() || isInEnemySliceRange() ?
                        Sets.immutable.empty() : getEnemySliceLocations();
                if ((isVisible() || clone != null) && !getEnemyHiddenLocations().isEmpty() &&
                        setClosestLocation(step, avoidLocations, getEnemyHiddenLocations())) {
                    return step;
                }
                if (!getStaticLocations().contains(getLocation()) &&
                        setClosestLocation(step, avoidLocations, getStaticLocations())) {
                    return step;
                }
            }
            return smile;
        }
    }

    private class VisibleCloud extends Character {
        protected VisibleCloud(ReadonlyCharacter delegate) {
            super(delegate);
        }

        @Override
        protected ReadonlyAction choose() {
            ReadonlyAction clone = getAction(Clone.class);
            if (clone != null) {
                int visibleCount = countCharacters(VisibleCloud.class);
                if (visibleCount > 5 && setClosestSafeLocation(clone, getStaticLocations())) {
                    return clone;
                } else if (setCloneLocation(clone, visibleCount < 3 ? 2 : 1)) {
                    return clone;
                }
            }
            if (step != null && isInEnemySliceRange() && setClosestSafeLocation(step, getStaticLocations())) {
                return step;
            }
            if (slice != null && setSliceTarget(slice, 0.01)) {
                return slice;
            }
            if (step != null && !getStaticLocations().contains(getLocation())) {
                if (isInEnemySliceRange() ? setClosestLocation(step, getStaticLocations()) :
                        setClosestSafeLocation(step, getStaticLocations())) {
                    return step;
                }
            }
            return smile;
        }
    }

    @Override
    protected Character createCharacter(ReadonlyCharacter delegate) {
        if (hasAbility(delegate, Invisible.class)) {
            return new InvisibleCloud(delegate);
        } else {
            return new VisibleCloud(delegate);
        }
    }
}

เทมเพลตเพลเยอร์

ใช้ช่วงระยะเวลา , มีความยืดหยุ่น , ZapและKO คุณได้รับอนุญาตให้ใช้ความสามารถนี้หากคุณต้องการ

อย่าลังเลที่จะใช้บอทนี้เป็นเทมเพลตสำหรับสร้างของคุณเอง

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

TemplatePlayer.java
import com.nmerrill.kothcomm.game.maps.Point2D;
import fellowship.abilities.ActionAbility;
import fellowship.abilities.attacking.Flexible;
import fellowship.abilities.attacking.Ranged;
import fellowship.actions.ReadonlyAction;
import fellowship.actions.damage.KO;
import fellowship.actions.damage.Zap;
import fellowship.characters.CharacterTemplate;
import fellowship.characters.ReadonlyCharacter;
import fellowship.Player;
import org.eclipse.collections.api.set.MutableSet;

import java.util.ArrayList;
import java.util.List;
import java.util.Set;

public class TemplatePlayer extends Player{
    private final double CRITICAL_HEALTH = 20;
    @Override
    public List<CharacterTemplate> createCharacters() {
        List<CharacterTemplate> templates = new ArrayList<>();
        for (int i = 0; i < 3; i++) {
            templates.add(new CharacterTemplate(10, 5, 5,
                    new Ranged(),
                    new Flexible(),
                    new ActionAbility(KO::new),
                    new ActionAbility(Zap::new)));
        }
        return templates;
    }

    @Override
    public ReadonlyAction choose(Set<ReadonlyAction> actions, ReadonlyCharacter character) {
        int minPriority = Integer.MAX_VALUE;
        ReadonlyAction chosen = null;
        for (ReadonlyAction action: actions){
            int priority = getPriorityFor(action, character);
            if (priority < minPriority){
                chosen = action;
                minPriority = priority;
            }
        }
        if (chosen == null){
            throw new RuntimeException("No valid actions");
        }
        if (chosen.needsLocation()){
            chosen.setLocation(chooseLocationFor(chosen, character));
        } else if (chosen.needsTarget()){
            chosen.setTarget(chooseTargetFor(chosen));
        }
        return chosen;
    }

    private Point2D chooseLocationFor(ReadonlyAction action, ReadonlyCharacter character){
        if (action.movementAction()){
            if (character.getHealth() < CRITICAL_HEALTH){
                return fromEnemy(action.availableLocations());
            } else {
                return toEnemy(action.availableLocations());
            }
        }
        return toTeam(action.availableLocations());
    }

    private Point2D toEnemy(MutableSet<Point2D> availableLocations){
        if (visibleEnemies.isEmpty()){
            return availableLocations.iterator().next();
        }
        return availableLocations.minBy(p1 ->
                p1.cartesianDistance(visibleEnemies.keysView().minBy(p1::cartesianDistance))
        );
    }

    private Point2D fromEnemy(MutableSet<Point2D> availableLocations){
        if (visibleEnemies.isEmpty()){
            return availableLocations.iterator().next();
        }
        return availableLocations.maxBy(p1 ->
                p1.cartesianDistance(visibleEnemies.keysView().minBy(p1::cartesianDistance))
        );
    }

    private Point2D toTeam(MutableSet<Point2D> availableLocations){
        if (team.isEmpty()){
            return availableLocations.iterator().next();
        }
        return availableLocations.minBy(p1 ->
                p1.cartesianDistance(team.collect(ReadonlyCharacter::getLocation).minBy(p1::cartesianDistance))
        );
    }

    private ReadonlyCharacter chooseTargetFor(ReadonlyAction action){
        return action.availableTargets().minBy(ReadonlyCharacter::getHealth);
    }

    private int getPriorityFor(ReadonlyAction action, ReadonlyCharacter character){
        if (character.isInvisible() && action.breaksInvisibility()){
            return 1000;
        }
        if (action.getName().equals("Smile")){
            return 999;
        }
        if (action.movementAction()){
            if (character.getHealth() < 20){
                return 0;
            }
            return 998;
        }
        if (action.needsTarget()) {
            return ((int) action.availableTargets().minBy(ReadonlyCharacter::getHealth).getHealth());
        }
        return 997;
    }
}

CowardlySniperMk2

ใช้Zap , Farsight * 2 และซ่อน

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

ในโหมดติดตามและมีมานาและคูลดาวน์เพียงพอแล้วจะ 'Zap' ศัตรูที่อ่อนแอที่สุดที่มองเห็นได้

เมื่อมานาลดเหลือ 10% จากนั้นจะหลบหลีกศัตรูจนกว่าจะฟื้นฟูมานา ด้วยวิธีนี้มันสามารถปะทะกับศัตรูที่ติดตามได้เร็วที่สุด หวังว่าจะลบล้าง HP ที่ฟื้นฟูศัตรูได้

หมายเหตุเนื่องจาก 'Zap' เป็นช่วงที่ไม่มีที่สิ้นสุดสมาชิกในทีมจะกำหนดเป้าหมาย bot เดียวกันทั้งหมดเมื่อทำการจับคู่

ฉันมีความแตกต่างอื่น ๆ ของความคิดพื้นฐานเดียวกันนี้ที่ฉันอาจเพิ่มเป็นคำตอบ: พวกเขาทั้งหมดมีประโยชน์ / detriments ที่แตกต่างกันที่ถูกเอาเปรียบ / เปิดเผยขึ้นอยู่กับคู่ต่อสู้ที่มีอยู่

CowardlySniperMk2.java

import com.nmerrill.kothcomm.game.maps.Point2D;
import fellowship.abilities.ActionAbility;
import fellowship.abilities.vision.FarSight;
import fellowship.actions.ReadonlyAction;
import fellowship.actions.damage.Zap;
import fellowship.actions.vision.Hide;
import fellowship.characters.CharacterTemplate;
import fellowship.characters.ReadonlyCharacter;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Set;
import fellowship.*;

public class CowardlySniperMk2 extends Player{

    private final static boolean DEBUG=false; 
    private static Point2D lastAttackedEnemyLocation = null;
    private static HashMap<ReadonlyCharacter, Boolean> rechargingManaMap = new HashMap<>();
    private final double STANDARD_VISION_MOVEMENT_BUFFER = 3;
    private final double MIN_VISION_DISTANCE = 2;

    @Override
    public List<CharacterTemplate> createCharacters() {
        List<CharacterTemplate> templates = new ArrayList<>();
        for (int i = 0; i < 3; i++) {
            templates.add(new CharacterTemplate(8, 8, 4,
                    new ActionAbility(Zap::new),
                    new FarSight(),
                    new FarSight(),
                    new ActionAbility(Hide::new)));
        }
        return templates;
    }

    @Override
    public ReadonlyAction choose(Set<ReadonlyAction> actions, ReadonlyCharacter character) {

        // get last flag for recharging mana
        Boolean rechargingMana = rechargingManaMap.get(character);
        if (rechargingMana == null || rechargingMana)
        {
            rechargingMana = !(character.getMana()>0.90*character.getMaxMana());
        }
        else
        {
            rechargingMana = character.getMana()<0.10*character.getMaxMana();
        }

        rechargingManaMap.put(character,rechargingMana);

        HashMap<Integer, ReadonlyAction> validActions = new HashMap<>();
        HashMap<Integer, String> actionString = new HashMap<>();

        // see if we have arrived at the last attack location of the enemy
        if (character.getLocation().equals(lastAttackedEnemyLocation))
        {
            lastAttackedEnemyLocation = null;
        }

        double closestEnemyVisionDistance = Double.MAX_VALUE;
        for ( Point2D enemyLocation : visibleEnemies.keySet())
        {
            final int enemyVisibiltyRange = visibleEnemies.get(enemyLocation).getSightRange().getRange();
            double visionDistanceDiff = character.getLocation().diagonalDistance(enemyLocation)-enemyVisibiltyRange;
            if (visionDistanceDiff< closestEnemyVisionDistance)
            {
                closestEnemyVisionDistance = visionDistanceDiff;
            }
        }

        for (ReadonlyAction action: actions){

            int priority=-1;
            String message = "";
            switch (action.getName())
            {
                case "Hide":
                    // are we, or will we be within sight range of an enemy
                    if (closestEnemyVisionDistance < STANDARD_VISION_MOVEMENT_BUFFER )
                    {
                        if (!character.isInvisible())
                        {
                            message = ""+closestEnemyVisionDistance;
                            priority = 1000;
                        }
                    }
                    break;

                case "Step":

                    Point2D chosenLocation = null;

                    // are we within sight range of an enemy or are we recharging mana?
                    if (closestEnemyVisionDistance < MIN_VISION_DISTANCE || rechargingMana)
                    {
                        message = "Fleeing (Seen) "+ closestEnemyVisionDistance;
                        priority = 800;

                        if (character.isInvisible())
                        {
                            message = "Fleeing (UnSeen) "+ closestEnemyVisionDistance;
                            priority = 500;
                        }

                        // simple enemy avoidance... chose location that is farthest away from closest enemy
                        double furthestDistance = 0;

                        for ( Point2D enemyLocation : visibleEnemies.keySet())
                        {
                            for (Point2D location : action.availableLocations())
                            {
                                if (location.diagonalDistance(enemyLocation) > furthestDistance)
                                {
                                    furthestDistance = location.diagonalDistance(enemyLocation);
                                    chosenLocation = location;
                                }
                            }
                        }

                        if (chosenLocation == null)
                        {
                            // no moves are better than staying in current location
                            priority = -1;
                            break;
                        }
                    }
                    // are we "tracking" an enemy?
                    else if (lastAttackedEnemyLocation !=null)
                    {
                        priority = 20;
                        message = "Tracking "+ closestEnemyVisionDistance;

                        // head toward last attacked enemy location
                        double distance = Integer.MAX_VALUE;
                        for (Point2D location : action.availableLocations())
                        {
                            if (location.diagonalDistance(lastAttackedEnemyLocation) < distance)
                            {
                                distance = location.diagonalDistance(lastAttackedEnemyLocation);
                                chosenLocation = location;
                            }
                        }
                    }
                    // are we outside the sight range of all enemies?
                    else if (closestEnemyVisionDistance > STANDARD_VISION_MOVEMENT_BUFFER)
                    {
                        // scout for an enemy

                        priority = 10;
                        message = "Scouting "+ closestEnemyVisionDistance;

                        // dumb random location selection... not optimal but is sufficent.
                        int index = getRandom().nextInt(action.availableLocations().size());
                        for (Point2D location : action.availableLocations())
                        {
                            chosenLocation= location;
                            if (--index == 0)
                            {
                                break;
                            }
                        }
                    }
                    else
                    {
                        // we are in the sweet zone... just out of enemy sight range but within our sight range
                        break;
                    }

                    action.setLocation(chosenLocation);
                    break;

                case "Zap":
                    message = ""+closestEnemyVisionDistance;
                    ReadonlyCharacter chosenTarget = null;
                    double chosenTargetHealth = Double.MAX_VALUE;

                    // target the weakest enemy
                    for (ReadonlyCharacter target : action.availableTargets())
                    {
                        if (target.getHealth() < chosenTargetHealth)
                        {
                            chosenTargetHealth = target.getHealth();
                            chosenTarget = target;
                        }
                    }

                    if (chosenTarget != null)
                    {
                        priority = 100;
                        action.setTarget(chosenTarget);
                        lastAttackedEnemyLocation = chosenTarget.getLocation();
                    }
                    else
                    {
                        // nothing to target
                    }

                    break;

                case "Smile":
                    priority = 0;
                    break;
            }

            // add the action to the collection of valid actions to perform
            if (priority >-1)
            {
                validActions.put(priority, action);
                actionString.put(priority, message);
            }

        }


        int highestPriority = -1;
        ReadonlyAction chosen = null;

        // choose the highest priority action
        for (Integer priority : validActions.keySet())
        {
            if (priority > highestPriority)
            {
                highestPriority = priority;
                chosen = validActions.get(priority);
            }
        }
        String message = actionString.get(highestPriority);

        if (chosen == null){
            throw new RuntimeException("No valid actions");
        }

        if (DEBUG) System.out.println(this+"("+System.identityHashCode(character)+"): "+chosen.getName()+ (rechargingMana?" Mana_charge":" Mana_usable")+" H: "+character.getHealth()+" M: "+character.getMana() +(character.isInvisible()?" InVis":" Vis") +" x: "+character.getLocation().getX()+" y: "+character.getLocation().getY()+" "+message);
        return chosen;
    }
}

TheWalkingDead

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

• 1 x ซอมบี้ # 1 (แข็งแกร่งที่สุดและดังนั้นจึงเป็นอัลฟาซอมบี้)
  • STR: 25; AGI: 5; INT: 15
  • โคลน , ฟื้นคืนชีพ , แข็งแรง
• 2 x Zombie # 2 (ไม่มีใครอยากเป็น Zombie # 3 ในเครดิตการปิดดังนั้นทั้งคู่จึงมีหมายเลขเดียวกัน)
  • STR: 15; AGI: 5; INT: 15
  • โคลน , ชุบชีวิต , ดูดซับ

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

TheWalkingDead.java
import java.util.Arrays;
import java.util.List;

import fellowship.abilities.ActionAbility;
import fellowship.abilities.attacking.Absorb;
import fellowship.abilities.defensive.Resurrect;
import fellowship.abilities.stats.Strong;
import fellowship.actions.ReadonlyAction;
import fellowship.actions.other.Clone;
import fellowship.characters.CharacterTemplate;
import fellowship.characters.ReadonlyCharacter;

public class TheWalkingDead extends SleafarPlayer {
    private CharacterTemplate zombie1Template() {
        return new CharacterTemplate(20, 0, 10, new ActionAbility(Clone::new), new Resurrect(), new Strong());
    }

    private CharacterTemplate zombie2Template() {
        return new CharacterTemplate(10, 0, 10, new ActionAbility(Clone::new), new Resurrect(), new Absorb());
    }

    @Override
    public List<CharacterTemplate> createCharacters() {
        return Arrays.asList(zombie1Template(), zombie2Template(), zombie2Template());
    }

    private class Zombie extends Character {
        private int resurrectCountdown = 0;
        private double oldHealth;

        protected Zombie(ReadonlyCharacter delegate) {
            super(delegate);
            this.oldHealth = getHealth();
        }

        @Override
        protected ReadonlyAction choose() {
            if (getHealth() > oldHealth + getHealthRegen() + 0.1) {
                resurrectCountdown = 40;
            }
            if (resurrectCountdown > 0) {
                --resurrectCountdown;
            }
            oldHealth = getHealth();

            ReadonlyAction clone = getAction(Clone.class);
            if (resurrectCountdown > 0) {
                if (step != null && isInEnemySliceRange() && setAvoidEnemiesLocation(step)) {
                    return step;
                }
                if (clone != null && !getSliceLocations().isEmpty() && setClosestLocation(clone, getSliceLocations())) {
                    return clone;
                }
                if (clone != null && setCloneLocation(clone, 1)) {
                    return clone;
                }
                if (slice != null && setSliceTarget(slice, 0.01)) {
                    return slice;
                }
                if (step != null && setAvoidEnemiesLocation(step)) {
                    return step;
                }
            } else {
                if (clone != null && !getSliceLocations().isEmpty() && setClosestLocation(clone, getSliceLocations())) {
                    return clone;
                }
                if (clone != null && setCloneLocation(clone, 1)) {
                    return clone;
                }
                if (slice != null && setSliceTarget(slice, 0.01)) {
                    return slice;
                }
                if (step != null && !getSliceLocations().isEmpty() && setClosestLocation(step, getSliceLocations())) {
                    return step;
                }
            }
            return smile;
        }
    }

    @Override
    protected Character createCharacter(ReadonlyCharacter delegate) {
        return new Zombie(delegate);
    }
}

The Invulnerables

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

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

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

Mage ใน Noxious Sphere

• STR : 5; AGI : 5; INT : 25

Mage ปกป้องตัวเองด้วยการใช้คอมโบของPillarและForce Field ; เมื่อได้รับการโฟกัสและมีสติปัญญาสูงมันจะฟื้นฟูมานาให้มากพอที่จะใช้สกิล Force Field ในการคูลดาวน์ในแต่ละครั้ง สมมติว่าฝ่ายตรงข้ามไม่มีความว่องไวที่เพิ่มขึ้นพวกเขาสามารถโจมตีได้มากถึงห้าสไลซ์ต่อห้าตาและแหล่งความเสียหายห้าแหล่งจะถูกปิดกั้นในช่วงเวลานั้น กล่าวอีกนัยหนึ่งนักเวทย์ต้องการคาถาเพื่อเอาชนะอย่างแน่นอน การหั่นไม่ได้ผลด้วยตัวเองไม่ว่าคุณจะเก่งแค่ไหนก็ตาม

ผู้วิเศษสามารถโจมตีผ่านการหั่นเป็นเวลา 25 ในกรณีฉุกเฉิน แต่ส่วนใหญ่จะร่ายPoisonซ้ำ ๆ ซึ่งสามารถส่งผลให้ MP ฟื้นฟูได้ในระดับสูง เนื่องจาก Poison มีระยะอนันต์ จำกัด ด้วยวิสัยทัศน์ของทีม Mage จึงเป็นวิธีที่ทีมนี้จะโจมตีศัตรูที่หนักหน่วงและหนักหน่วงมาก ส่วนที่เหลือของทีมรักษาวิสัยทัศน์ไว้ในขณะที่ Mage สร้างความเสียหายเป็นสองเท่า พิษย่อมจบลงเร็วกว่าการฟื้นฟู HP ในที่สุดและฉันไม่ต้องกังวลเกี่ยวกับความเสียหายแบบคงที่เช่น Spikes ในกระบวนการ

The Giant Clifftop Falconer

• STR : 35; AGI : 5; INT : 5

หน้าที่หลักของ Falconer คือการทำให้ส่วนที่เหลือของวิสัยทัศน์เป้าหมายของทีมเป็นไปได้เพื่อที่พวกเขาจะสามารถถูกโจมตีโดยการสอดแนมแผนที่ด้วยสายตาของนกเหยี่ยว Far Sightให้การมองเห็นที่เพียงพอว่าศัตรูที่พยายามซ่อนหรือวิ่งหนีสามารถตามปกติด้วยระยะการมองเห็นที่มุมหนึ่งของแผนที่ มันไม่ง่ายเลยที่จะให้ Falconer หลบหนี True Sightคือการไล่ล่าหลักของทีมต่อศัตรูที่มองไม่เห็นซึ่งไม่สามารถสร้างความเสียหายได้ มีขนาดใหญ่และแข็งแรงทำให้ Falconer นั้นทนทานต่อความเสียหายและสามารถแบ่งส่วนได้มากเมื่อจำเป็น ในที่สุด Falconer สามารถปล่อยเหยี่ยวลงบนฝูงชนของศัตรูด้านล่างสั่งให้พวกเขาไปสานในหมู่ศัตรูและสร้างความเสียหายขนาดใหญ่ (35) พื้นที่

นอกเหนือจากงานเหยี่ยวของล่าสัตว์ศัตรูและการรักษาวิสัยทัศน์ของศัตรูเพื่อให้ผู้วิเศษสามารถทำให้เป็นพิษพวกเขาความสามารถในการสาน 35 เป็นกุญแจสำคัญในการจัดการกับศัตรูกลุ่มทีม; เป็นไปได้ที่จะยิงศัตรูจำนวนมากในแบบนั้นและปล่อยให้พวกเขาอยู่ในระดับต่ำพอที่จะทำให้ทีมที่เหลือเสร็จ การจับกลุ่มเป็นกลยุทธ์การสู้ที่ค่อนข้างมากภายใต้กฎเหล่านี้และการสานเป็นหนึ่งในไม่กี่ตัวนับจริงที่มี ถึงอย่างนั้นมันก็ยังไม่ดีพอสำหรับตัวมันเอง

Trollbone Skullrender

• STR : 25; AGI : 5; INT : 5

ภารกิจของ Trollbone คือการเก็บพยุหะศัตรูไว้ในขณะที่หน่วยอื่นสามารถทำงานได้ เช่นเดียวกับผู้วิเศษ Trollbone มีคาถาอนันต์ในช่วงที่น่าพิศวง คอมโบนี้ทำได้ดีมากกับพิษของผู้วิเศษ หากเป็นไปได้ที่จะเผชิญหน้ากับศัตรูทีละคน (และกับหลาย ๆ ทีมมัน) เหยี่ยวจะได้รับการมองเห็น Trollbone จะทำให้ตกใจพวกเขาแล้วผู้วิเศษจะวางยาพิษกับพวกเขาและพวกเขาจะตาย โดยไม่มีความสามารถในการทำสิ่งใด (สิ่งที่น่าพิศวงเป็นเวลา 1,000 ติ๊กบนเป้าหมายและ Trollbone จะสร้างคูลดาวน์ใหม่ให้เร็วขึ้นกว่านั้นเล็กน้อย) นอกจากนี้ยังเป็นสิ่งที่ดีในการปกป้อง Trollbone จากศัตรูที่แข็งแกร่งเดี่ยว พวกเขาไม่สามารถทำอะไรกับเขาได้หากพวกเขาไม่รู้สึกตัว แน่นอนการทุบกะโหลกกับศัตรูนั้นมีแนวโน้มที่จะทำให้ทั้งคู่สั่นสะเทือนทำให้ตกใจและพิษ (และสถานะอื่น ๆ ที่ไม่มีใครใส่ใจ) ในฐานะตัวละครที่เน้นคาถาที่ยังไม่ได้มีความโน้มเอียงอย่างน่าอัศจรรย์ Trollbone จะสร้างเวทย์มนตร์ใหม่โดยไม่ต้องใช้สติปัญญา แต่ผ่านการดื่มเลือดของศัตรูของเขาทำMana Stealทุกการโจมตี นี่เป็นอัตราการฟื้นฟู MP ที่ค่อนข้างดี (และศัตรูที่ติดสตันทำให้เป้าหมายง่ายต่อการขโมย MP จาก) ในที่สุด Trollbone ก็เกิดอาละวาดเป็นครั้งคราวและจะสานผ่านกลุ่มศัตรูในขณะที่หัวของพวกเขากระแทกและดื่มเลือดของพวกเขา กับฝูงศัตรูที่มีขนาดใหญ่พอจริง ๆ แล้วมันจะฟื้นมานาและมันสามารถจบฝูงที่ Falconer อ่อนแอ (25 + 35 คือ 60 ดังนั้นมันจึงใช้ได้แม้ว่าศัตรูจะสร้างใหม่ในระดับหนึ่ง)

กลยุทธ์

แตกต่างจากหลาย ๆ ทีมฉันให้ความสำคัญกับ AI มากกว่าการสร้างทีม กฎพื้นฐานข้อหนึ่งคือทีมจะพยายามจัดกลุ่มหากพวกเขาไม่ยุ่งทำอย่างอื่นทำให้ยากขึ้นสำหรับพวกเขาที่จะได้รับการล้อมรอบและสามารถปกป้องซึ่งกันและกัน หากพวกเขาถูกจับกลุ่มพวกเขาจะพยายามซ่อนตัวอยู่ในมุมหนึ่ง ในทางกลับกันหากศัตรูพยายามหลบหนีหรือวิ่งหนีพวกเขาท่องไปในแผนที่หยิบและเดินไปยังมุมสุ่มหรือศูนย์กลาง นี้มากหรือน้อยรับรองว่า Falconer จะจุดเป้าหมายในที่สุด การเคลื่อนไหวถูกออกแบบมาเพื่อไม่ให้ศัตรูได้รับการโจมตีครั้งแรกถ้าเป็นไปได้ ศัตรูจะต้องเดินเข้าไปใน Slice เล็งตนเอง ผู้วิเศษจะเสมอปล่อย MP ไว้สำหรับสนามพลังป้องกันการสูญเสีย MP ที่อ่อนล้า (วิธีเดียวที่สิ่งนี้สามารถล้มเหลวคือด้วย Absorb ซึ่งสามารถผ่านสนามพลังได้แม้ว่าความเสียหายจะไม่เกิดขึ้นก็ตาม) นี่ไม่ใช่ปัญหาปกติ โดยปกติแล้วผู้วิเศษสามารถสแปมพิษทุกคราวโดยไม่มีปัญหา หากไม่ถูกรบกวนทีมชอบที่จะไล่ล่าศัตรูทีละคนตะลึงพวกเขาเมื่อพวกเขาเข้ามาในสายตาจากนั้นวางยาพิษซ้ำ ๆ จนกว่าพวกเขาจะตาย เมื่อมีศัตรูคนอื่น ๆ ทีมจะพยายามว่าวพวกเขาหากเป็นไปได้วิ่งวนเป็นวงกลมและบังคับให้ศัตรูส่วนใหญ่ไล่ล่าในขณะที่น่าทึ่งและพิษหนึ่งในนั้น ปัญหาหลักคือฝูงซึ่งเป็นสาเหตุที่มีการทอผ้ามากที่นี่ แต่ก็ดูเหมือนยากที่จะเอาชนะกลยุทธ์

Invulnerables.java
import com.nmerrill.kothcomm.game.maps.Point2D;
import fellowship.abilities.*;
import fellowship.abilities.attacking.*;
import fellowship.abilities.defensive.*;
import fellowship.abilities.vision.*;
import fellowship.abilities.stats.*;
import fellowship.abilities.statuses.*;
import fellowship.actions.*;
import fellowship.actions.attacking.*;
import fellowship.actions.damage.*;
import fellowship.actions.defensive.*;
import fellowship.actions.statuses.*;
import fellowship.characters.CharacterTemplate;
import fellowship.characters.ReadonlyCharacter;
import fellowship.characters.EnemyCharacter;
import fellowship.*;

import java.util.ArrayList;
import java.util.List;
import java.util.Set;

public class Invulnerables extends Player {
  @Override
  public List<CharacterTemplate> createCharacters() {
    List<CharacterTemplate> templates = new ArrayList<>();

    templates.add(new CharacterTemplate(0, 0, 20,
                                        new ActionAbility(Poison::new),
                                        new ActionAbility(ForceField::new),
                                        new Focused(),
                                        new Pillar()));

    templates.add(new CharacterTemplate(30, 0, 0,
                                        new ActionAbility(Weave::new),
                                        new Strong(),
                                        new FarSight(),
                                        new TrueSight()));

    templates.add(new CharacterTemplate(20, 0, 0,
                                        new ActionAbility(Weave::new),
                                        new ActionAbility(Knockout::new),
                                        new ManaSteal(),
                                        new Immune()));

    return templates;
  }

  private String lastIdentifier(String s) {
    String[] split = s.split("\\W");
    return split[split.length - 1];
  }

  private boolean hasAbility(ReadonlyCharacter character, String abilityName) {
    for (ReadonlyAbility ability : character.getAbilities()) {
      if (lastIdentifier(ability.name()).equals(abilityName))
        return true;
    }
    return false;
  }

  private boolean hasAbility(EnemyCharacter character, String abilityName) {
    for (ReadonlyAbility ability : character.getAbilities()) {
      if (lastIdentifier(ability.name()).equals(abilityName))
        return true;
    }
    return false;
  }

  private int getSquareDanger(ReadonlyCharacter character, Point2D square) {
    /* A square's danger is basically equal to the number of hits we'd
       expect to take when standing there. Each hit is worth 1; a hit of
       25 damage or more is worth 2. */
    int sliceDanger = 0;
    int otherDanger = 0;
    int cx = square.getX();
    int cy = square.getY();
    for (Point2D enemyLocation : visibleEnemies.keysView()) {
      EnemyCharacter enemy = visibleEnemies.get(enemyLocation);
      if (enemy.isStunned())
        continue; /* approaching stunned enemies is a good thing */
      int dx = enemyLocation.getX() - cx;
      int dy = enemyLocation.getY() - cy;
      if (dx < 0)
        dx = -dx;
      if (dy < 0)
        dy = -dy;
      if (dx + dy <= 1) {
        /* We're in Static range. */
        if (hasAbility(enemy, "Static"))
          otherDanger++;
      }
      if (dx + dy <= enemy.getSliceRange().getRange() &&
          (dx * dy == 0 || !enemy.getSliceRange().isCardinal())) {
        int sliceMultiplier = 1;
        if (hasAbility(enemy, "Quick") && !hasAbility(character, "Pillar"))
          sliceMultiplier *= 2;
        if (enemy.getStat(enemy.primaryStat()) >= 25)
          sliceMultiplier *= 2;
        if (hasAbility(character, "Pillar")) {
          if (sliceDanger >= sliceMultiplier)
            continue;
          sliceDanger = 0;
        }
        sliceDanger += sliceMultiplier;
      }
    }
    return sliceDanger + otherDanger;
  }

  private ReadonlyAction[] forceFieldAction = new ReadonlyAction[3];
  private int goalX = 5;
  private int goalY = 5;

  @Override
  public ReadonlyAction choose(Set<ReadonlyAction> actions, ReadonlyCharacter character) {

    /* Which character are we? */
    int characterNumber;
    if (hasAbility(character, "Focused"))
      characterNumber = 0;
    else if (hasAbility(character, "Immune"))
      characterNumber = 1;
    else if (hasAbility(character, "TrueSight"))
      characterNumber = 2;
    else
      throw new RuntimeException("Unrecognised character!");

    /* If we're at the goal square, pick a new one. */
    if (goalX == character.getLocation().getX() &&
        goalY == character.getLocation().getY()) {
      int i = getRandom().nextInt(5);
      goalX = i < 2 ? 1 : i > 2 ? 9 : 5;
      goalY = i == 2 ? 5 : (i % 2) == 1 ? 1 : 9;
    }

    /* If there are a lot of visible enemies, try to group up in a corner in order
       to prevent being surrounded. */
    if (visibleEnemies.size() > 3) {
      int xVotes = 0;
      int yVotes = 0;
      for (ReadonlyCharacter ally : team) {
        xVotes += ally.getLocation().getX() >= 5 ? 1 : -1;
        yVotes += ally.getLocation().getY() >= 5 ? 1 : -1;
      }
      goalX = xVotes > 0 ? 9 : 0;
      goalY = yVotes > 0 ? 9 : 0;
    }

    /* We need to know our Force Field cooldowns even between turns, so store the
       actions in a private field for later use (they aren't visible via the API) */
    for (ReadonlyAction action : actions) {
      if (action.getName().equals("ForceField"))
        forceFieldAction[characterNumber] = action;
    }

    /* If we know Force Field, ensure we always hang on to enough mana to cast it, and
       never allow our mana to dip low enough that it wouldn't regenerate in time. */
    double mpFloor = 0.0;
    if (forceFieldAction[characterNumber] != null) {
      double mpRegen = character.getStat(Stat.INT) / 10.0;
      if (hasAbility(character, "Focused"))
        mpRegen *= 2;
      mpFloor = forceFieldAction[characterNumber].getManaCost();
      mpFloor -= forceFieldAction[characterNumber].getRemainingCooldown() * mpRegen;
    }
    if (mpFloor > character.getMana())
      mpFloor = character.getMana();

    /* We use a priority rule for actions. */
    int bestPriority = -2;
    ReadonlyAction bestAction = null;
    for (ReadonlyAction action : actions) {
      int priority = 0;
      if (lastIdentifier(action.getName()).equals("ForceField"))
        priority = 20; /* top priority */
      else if (character.getMana() - action.getManaCost() < mpFloor) {
        continue; /* never spend mana if it'd block a force field */
      } else if (lastIdentifier(action.getName()).equals("Quick") ||
                 lastIdentifier(action.getName()).equals("Slice")) {
        int damagePotential =
          lastIdentifier(action.getName()).equals("Quick") ? 50 : 25;
        /* We use these abilities with very high priority to /kill/ an enemy
           who's weak enough to die from the damage. If they wouldn't die,
           we're much more wary about attacking; we do it only if we have
           nothing better to do and it's safe. */
        ReadonlyCharacter chosenTarget = null;
        for (ReadonlyCharacter target : action.availableTargets()) {
          if (!isEnemy(target))
            continue;
          if (target.getHealth() <= damagePotential) {
            chosenTarget = target;
            priority = (damagePotential == 25 ? 19 : 18);
            break; /* can't do beter than this */
          }
          if (hasAbility(target, "Spikes") ||
              hasAbility(target, "Reflexive"))
            /*  (target.getLastAction() != null &&
                target.getLastAction().getName().equals("Ghost")) */
            continue; /* veto the target */
          priority = (damagePotential == 25 ? 3 : 4);
          chosenTarget = target;
        }
        if (chosenTarget == null)
          continue;
        action.setTarget(chosenTarget);
      } else if (lastIdentifier(action.getName()).equals("Weave")) {
        priority = visibleEnemies.size() >= 3 ? 14 :
          visibleEnemies.size() >= 1 ? 6 : -1;
      } else if (lastIdentifier(action.getName()).equals("Smile")) {
        /* If there's a stunned or poisoned enemy in view, we favour Smile
           as the idle action, rather than exploring, so that we don't
           move it out of view. Exception: if they're the only enemy;
           in that case, hunt them down. Another exception: if we're
           running into a corner. */
        for (EnemyCharacter enemy : visibleEnemies) {
          if (enemy.isStunned() || enemy.isPoisoned())
            if (visibleEnemies.size() > 1 && visibleEnemies.size() < 4)
              priority = 2;
        }
        /* otherwise we leave it as 0, and Smile only as a last resort */
      } else if (lastIdentifier(action.getName()).equals("Knockout")) {
        /* Use this only on targets who have more than 50 HP. It doesn't
           matter where they are: if we can see them now, knocking them
           out will guarantee we can continue to see them. Of course, if
           they're already knocked out, don't use it (although this case
           should never come up). If there's only one enemy target in
           view, knocking it out has slightly higher priority, because
           we don't need to fear enemy attacks if all the enemies are
           knocked out.

           Mildly favour stunning poisoned enemies; this reduces the
           chance that they'll run out of sight and reset the poison. */
        ReadonlyCharacter chosenTarget = null;
        for (ReadonlyCharacter target : action.availableTargets())
          if ((target.getHealth() > 50 || target.isPoisoned()) &&
              !target.isStunned() && isEnemy(target)) {
            chosenTarget = target;
            if (target.isPoisoned())
              break;
          }
        if (chosenTarget == null)
          continue;
        action.setTarget(chosenTarget);
        priority = visibleEnemies.size() == 1 ? 17 : 15;
      } else if (lastIdentifier(action.getName()).equals("Poison")) {
        /* Use this preferentially on stronger enemies, and preferentially
           on enemies who are more poisoned. We're willing to poison
           almost anyone, although weak enemies who aren't poisoned
           are faster to kill via slicing. The cutoff is at 49, not 50,
           so that in the case of evasive enemies who we can't hit any
           other way, we can wear them one at a time using poison. */
        ReadonlyCharacter chosenTarget = null;
        int chosenTargetPoisonLevel = -1;
        for (ReadonlyCharacter target : action.availableTargets()) {
          int poisonLevel = 0;

          if (!isEnemy(target))
            continue;
          if (target.isPoisoned())
            poisonLevel = target.getPoisonAmount() + 1;
          if (poisonLevel < chosenTargetPoisonLevel)
            continue;
          if (poisonLevel == 0 && target.getHealth() <= 49)
            continue; /* prefer stronger targets */
          if (poisonLevel == 0 && target.getHealth() == 50 &&
              chosenTarget != null)
            continue; /* we poison at 50, but not with other options */
          chosenTarget = target;
          chosenTargetPoisonLevel = poisonLevel;
          priority = 12;
        }
        if (chosenTarget == null)
          continue;
        action.setTarget(chosenTarget);
      } else if (action.movementAction()) {
        /* A move to a significantly safer square is worth 16.
           A move to a mildly safer square is worth 8.
           Otherwise, move to group, either with the enemy,
           the team, or the goal, at priority 1, if we
           safely can; that's our "idle" action. */
        int currentSquareDanger =
          getSquareDanger(character, character.getLocation());
        int bestSquareDanger = currentSquareDanger;
        int bestGroupiness = 0;
        Point2D bestLocation = null;
        priority = 1;
        for (Point2D location :
               action.availableLocations().toList().shuffleThis(getRandom())) {
          int danger = getSquareDanger(character, location);
          if (danger > bestSquareDanger)
            continue;
          else if (danger < bestSquareDanger) {
            priority = (currentSquareDanger - danger > 2)
              ? 16 : 8;
            bestSquareDanger = danger;
            bestLocation = location;
            bestGroupiness = 0; /* reset the tiebreak */
          }

          int cx = character.getLocation().getX();
          int xDelta = location.getX() - cx;
          int cy = character.getLocation().getY();
          int yDelta = location.getY() - cy;
          int groupiness = 0;
          /* Always hunt down a visible enemy when they're the only
             remaining enemy and doing so is safe. Otherwise, still
             favour hunting them down, but in that situation also
             consider factors like grouping and exploration. */
          for (Point2D enemyLocation : visibleEnemies.keysView())
            if (xDelta * (enemyLocation.getX() - cx) > 0 ||
                yDelta * (enemyLocation.getY() - cy) > 0)
              groupiness += (visibleEnemies.size() == 1 ? 99 : 5);
          /* If there are 4 or more visible enemies, then grouping is
             vitally important (so as to not get surrounded).
             Otherwise, it's more minor. */
          for (ReadonlyCharacter ally : team)
            if (xDelta * (ally.getLocation().getX() - cx) > 0 ||
                yDelta * (ally.getLocation().getY() - cy) > 0)
              groupiness += (visibleEnemies.size() > 3 ? 99 : 3);
          /* When exploring, we bias towards random map locations,
             changing location when we reach them. This helps us beat
             enemies that hide in the corners. When there are a lot
             of visible enemies, this changes to a bias to hide in a
             corner. */
          if (xDelta * (goalX - cx) > 0 ||
              yDelta * (goalY - cy) > 0)
            groupiness += (visibleEnemies.size() > 3 ? 99 : 4);
          if (groupiness >= bestGroupiness) {
            bestLocation = location;
            bestGroupiness = groupiness;
            /* leave priority, safety untouched */
          }
        }
        if (bestLocation == null)
          continue;
        action.setLocation(bestLocation);
      } else
        throw new RuntimeException("unknown action" + action.getName());

      if (priority > bestPriority) {
        bestPriority = priority;
        bestAction = action;
      }
    }
    if (bestAction == null)
      throw new RuntimeException("no action?");

    return bestAction;
  }
}

RogueSquad

ทีมโกงประกอบด้วย:

• 1 ลูกเสือ (อยู่ในเงามืดขณะสำรวจแผนที่)
  • STR: 5; AGI: 5; INT: 25
  • โคลน , ที่มองไม่เห็น , ห่างไกลสายตา
• 2 Assasins (โจมตีศัตรูด้วยพิษร้ายแรง)
  • STR: 5; AGI: 5; INT: 25
  • โคลน , Poison , มุ่งเน้น

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

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

RogueSquad.java
import java.util.Arrays;
import java.util.List;

import fellowship.abilities.ActionAbility;
import fellowship.abilities.stats.Focused;
import fellowship.abilities.vision.FarSight;
import fellowship.abilities.vision.Invisible;
import fellowship.actions.ReadonlyAction;
import fellowship.actions.other.Clone;
import fellowship.actions.statuses.Poison;
import fellowship.characters.CharacterTemplate;
import fellowship.characters.ReadonlyCharacter;

public class RogueSquad extends SleafarPlayer {
    private CharacterTemplate scoutTemplate() {
        return new CharacterTemplate(0, 0, 20,
                new ActionAbility(Clone::new), new Invisible(), new FarSight());
    }

    private CharacterTemplate assasinTemplate() {
        return new CharacterTemplate(0, 0, 20,
                new ActionAbility(Clone::new), new ActionAbility(Poison::new), new Focused());
    }

    @Override
    public List<CharacterTemplate> createCharacters() {
        return Arrays.asList(assasinTemplate(), scoutTemplate(), assasinTemplate());
    }

    private class Scout extends Character {
        protected Scout(ReadonlyCharacter delegate) {
            super(delegate);
        }

        @Override
        protected ReadonlyAction choose() {
            ReadonlyAction clone = getAction(Clone.class);
            if (clone != null && (isVisible() || !isInEnemySightRange()) && setCloneLocation(clone, 3)) {
                return clone;
            }
            if (step != null && isVisible() && isInEnemySliceRange() && setAvoidEnemiesLocation(step)) {
                return step;
            }
            if (slice != null && isVisible() && setSliceTarget(slice, 0.01)) {
                return slice;
            }
            if (step != null && isVisible() && setAvoidEnemiesLocation(step)) {
                return step;
            }
            if (step != null && !isVisible() && setExploreLocation(step)) {
                return step;
            }
            return smile;
        }
    }

    private class Assasin extends Character {
        protected Assasin(ReadonlyCharacter delegate) {
            super(delegate);
        }

        @Override
        protected ReadonlyAction choose() {
            ReadonlyAction clone = getAction(Clone.class);
            ReadonlyAction poison = getAction(Poison.class);
            if (clone != null && setCloneLocation(clone, 1)) {
                return clone;
            }
            if (step != null && isInEnemySliceRange() && setAvoidEnemiesLocation(step)) {
                return step;
            }
            if (slice != null && setSliceTarget(slice, 0.01)) {
                return slice;
            }
            if (poison != null && setPoisonTarget(poison)) {
                return poison;
            }
            if (step != null && setAvoidEnemiesLocation(step)) {
                return step;
            }
            return smile;
        }
    }

    @Override
    protected Character createCharacter(ReadonlyCharacter delegate) {
        if (hasAbility(delegate, Invisible.class)) {
            return new Scout(delegate);
        } else if (hasAbility(delegate, Poison.class)) {
            return new Assasin(delegate);
        } else {
            throw new IllegalArgumentException();
        }
    }
}

คลาสฐานสำหรับบอททั้งหมดของฉัน

SleafarPlayer.java
import java.util.ArrayList;
import java.util.Collection;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.eclipse.collections.api.RichIterable;
import org.eclipse.collections.api.map.ImmutableMap;
import org.eclipse.collections.api.map.MutableMap;
import org.eclipse.collections.api.set.ImmutableSet;
import org.eclipse.collections.api.set.MutableSet;
import org.eclipse.collections.api.tuple.Pair;
import org.eclipse.collections.impl.factory.Maps;
import org.eclipse.collections.impl.factory.Sets;
import org.eclipse.collections.impl.list.primitive.IntInterval;
import org.eclipse.collections.impl.tuple.Tuples;

import com.nmerrill.kothcomm.game.maps.Point2D;

import fellowship.Player;
import fellowship.Range;
import fellowship.abilities.ReadonlyAbility;
import fellowship.abilities.attacking.Critical;
import fellowship.abilities.attacking.Reflexive;
import fellowship.abilities.defensive.Spikes;
import fellowship.abilities.statuses.Immune;
import fellowship.actions.ReadonlyAction;
import fellowship.actions.attacking.Quick;
import fellowship.actions.attacking.Slice;
import fellowship.actions.mobility.Step;
import fellowship.actions.other.Smile;
import fellowship.characters.CharacterInterface;
import fellowship.characters.EnemyCharacter;
import fellowship.characters.ReadonlyCharacter;

public abstract class SleafarPlayer extends Player {
    private static final ImmutableSet<Point2D> MAP_LOCATIONS = IntInterval.fromTo(0, 9)
            .collect(x -> IntInterval.fromTo(0, 9).collect(y -> new Point2D(x, y))).flatCollect(t -> t).toSet()
            .toImmutable();
    protected static final Comparator<CharacterInterface> HEALTH_COMPARATOR = (o1, o2) ->
            Double.compare(o1.getHealth(), o2.getHealth());
    private static final Range BLOCKING_RANGE = new Range(1, true);
    private static final Range STATIC_RANGE = new Range(1);

    protected static boolean hasAbility(CharacterInterface character, Class<?> ability) {
        return character.getAbilities().anySatisfy(a -> a.abilityClass().equals(ability));
    }

    protected static boolean isBear(CharacterInterface character) {
        return character.getAbilities().isEmpty();
    }

    protected static double calcSliceDamage(CharacterInterface character) {
        return character.getStat(character.primaryStat()) * (hasAbility(character, Quick.class) ? 2.0 : 1.0);
    }

    protected static boolean setLocation(ReadonlyAction action, Point2D location) {
        if (location != null) {
            action.setLocation(location);
        }
        return location != null;
    }

    protected static boolean setTarget(ReadonlyAction action, ReadonlyCharacter target) {
        if (target != null) {
            action.setTarget(target);
        }
        return target != null;
    }

    protected abstract class Character {
        protected final ReadonlyCharacter delegate;

        protected Character(ReadonlyCharacter delegate) {
            super();
            this.delegate = delegate;
        }

        protected abstract ReadonlyAction choose();

        protected double getHealth() {
            return delegate.getHealth();
        }

        protected double getHealthRegen() {
            return delegate.getHealthRegen();
        }

        protected double getMana() {
            return delegate.getMana();
        }

        protected double getManaRegen() {
            return delegate.getManaRegen();
        }

        protected Point2D getLocation() {
            return delegate.getLocation();
        }

        protected boolean isVisible() {
            return !delegate.isInvisible();
        }

        protected double getSliceDamage() {
            return delegate.getStat(delegate.primaryStat());
        }

        protected boolean isInEnemySliceRange() {
            return getEnemySliceLocations().contains(delegate.getLocation());
        }

        protected boolean isInEnemySightRange() {
            return getEnemySightLocations().contains(delegate.getLocation());
        }

        protected boolean isInEnemyStepSightRange() {
            return getEnemyStepSightLocations().contains(delegate.getLocation());
        }

        protected double calcSliceRetaliationDamage(CharacterInterface character) {
            double result = 0.0;
            double ownDamage = getSliceDamage();
            for (ReadonlyAbility ability : character.getAbilities()) {
                if (ability.abilityClass().equals(Critical.class)) {
                    ownDamage = ownDamage * 2;
                }
            }
            for (ReadonlyAbility ability : character.getAbilities()) {
                if (ability.abilityClass().equals(Spikes.class)) {
                    result += ownDamage / 2.0;
                } else if (ability.abilityClass().equals(Reflexive.class)) {
                    result += character.getStat(character.primaryStat());
                }
            }
            return result;
        }

        protected double calcSpellRetaliationDamage(CharacterInterface character, double ownDamage) {
            double result = 0.0;
            for (ReadonlyAbility ability : character.getAbilities()) {
                if (ability.abilityClass().equals(Spikes.class)) {
                    result += ownDamage / 2.0;
                }
            }
            return result;
        }

        protected boolean setRandomLocation(ReadonlyAction action) {
            return setLocation(action, chooseRandom(action.availableLocations()));
        }

        protected boolean setRandomLocation(ReadonlyAction action, ImmutableSet<Point2D> avoidLocations) {
            return setLocation(action, chooseRandom(action.availableLocations().difference(avoidLocations)));
        }

        protected boolean setClosestLocation(ReadonlyAction action, ImmutableSet<Point2D> targetLocations) {
            return setLocation(action, chooseClosest(action.availableLocations(), targetLocations));
        }

        protected boolean setClosestLocation(ReadonlyAction action, ImmutableSet<Point2D> avoidLocations,
                ImmutableSet<Point2D> targetLocations) {
            return setLocation(action, chooseClosest(action.availableLocations().difference(avoidLocations),
                    targetLocations));
        }

        protected boolean setClosestHiddenLocation(ReadonlyAction action, ImmutableSet<Point2D> preferredLocations) {
            return setClosestLocation(action, getEnemySightLocations(), preferredLocations);
        }

        protected boolean setClosestSafeLocation(ReadonlyAction action, ImmutableSet<Point2D> preferredLocations) {
            return setClosestLocation(action, getEnemySliceLocations(), preferredLocations);
        }

        protected boolean setFarthestLocation(ReadonlyAction action, ImmutableSet<Point2D> targetLocations) {
            return setLocation(action, chooseFarthest(action.availableLocations(), targetLocations));
        }

        protected boolean setFarthestLocation(ReadonlyAction action, ImmutableSet<Point2D> avoidLocations,
                ImmutableSet<Point2D> targetLocations) {
            return setLocation(action, chooseFarthest(action.availableLocations().difference(avoidLocations),
                    targetLocations));
        }

        public boolean setCloneLocation(ReadonlyAction action, int distance) {
            ImmutableSet<Point2D> cloneLocations = distance < 2 ? team.collect(t -> t.getLocation()).toImmutable() :
                team.flatCollect(t -> t.rangeAround(new Range(distance))).difference(
                team.flatCollect(t -> t.rangeAround(new Range(distance - 1)))).toImmutable();
            if (cloneLocations.isEmpty()) {
                return setRandomLocation(action, getEnemySightLocations()) ||
                        setRandomLocation(action, getEnemySliceLocations()) ||
                        setRandomLocation(action);
            } else {
                return setClosestLocation(action, getEnemySightLocations(), cloneLocations) ||
                        setClosestLocation(action, getEnemySliceLocations(), cloneLocations) ||
                        setClosestLocation(action, cloneLocations);
            }
        }

        protected boolean setAvoidEnemiesLocation(ReadonlyAction action) {
            Point2D location = chooseFarthest(Sets.mutable.ofAll(action.availableLocations())
                    .with(delegate.getLocation()).difference(getEnemySliceLocations()), getEnemyLocations());
            if (location == null || location.equals(delegate.getLocation())) {
                return false;
            } else {
                return setLocation(action, location);
            }
        }

        protected boolean setBlockEnemiesLocation(ReadonlyAction action) {
            return setLocation(action, chooseRandom(action.availableLocations().intersect(getEnemyBlockingLocations())));
        }

        protected boolean setExploreLocation(ReadonlyAction action) {
            return visibleEnemies.size() < enemies.size() && getTeamHiddenLocations().notEmpty() &&
                    setClosestLocation(action, getEnemyStepSightLocations(), getTeamHiddenLocations());
        }

        protected boolean setSliceTarget(ReadonlyAction action, double minHealthReserve) {
            MutableSet<Pair<ReadonlyCharacter, Double>> pairs = action.availableTargets()
                    .collect(t -> Tuples.pair(t, calcSliceRetaliationDamage(t)));
            Pair<ReadonlyCharacter, Double> smallest = chooseSmallest(pairs, (o1, o2) -> {
                int c = Double.compare(o1.getTwo(), o2.getTwo());
                return c == 0 ? Double.compare(o1.getOne().getHealth(), o2.getOne().getHealth()) : c;
            });
            if (smallest == null || smallest.getTwo() > delegate.getHealth() - minHealthReserve) {
                return false;
            } else {
                return setTarget(action, smallest.getOne());
            }
        }

        protected boolean setPoisonTarget(ReadonlyAction action) {
            return setTarget(action, chooseSmallest(action.availableTargets().reject(c -> hasAbility(c, Immune.class)),
                    HEALTH_COMPARATOR));
        }

        protected final ImmutableSet<Point2D> getEnemyLocations() {
            if (enemyLocations == null) {
                enemyLocations = visibleEnemies.keysView().toSet().toImmutable();
            }
            return enemyLocations;
        }

        protected final ImmutableSet<Point2D> getEnemySliceLocations() {
            if (enemySliceLocations == null) {
                enemySliceLocations = visibleEnemies.keyValuesView()
                        .flatCollect(c -> c.getTwo().rangeAround(c.getTwo().getSliceRange(), c.getOne())).toSet()
                        .toImmutable();
            }
            return enemySliceLocations;
        }

        protected final ImmutableSet<Point2D> getEnemySightLocations() {
            if (enemySightLocations == null) {
                enemySightLocations = visibleEnemies.keyValuesView()
                        .flatCollect(c -> c.getTwo().rangeAround(c.getTwo().getSightRange(), c.getOne())).toSet()
                        .toImmutable();
            }
            return enemySightLocations;
        }

        protected final ImmutableSet<Point2D> getEnemyStepSightLocations() {
            if (enemyStepSightLocations == null) {
                enemyStepSightLocations = visibleEnemies.keyValuesView()
                        .flatCollect(c -> Sets.mutable.ofAll(c.getTwo().rangeAround(c.getTwo().getStepRange(), c.getOne()))
                                .with(c.getOne()).flatCollect(r -> c.getTwo().rangeAround(c.getTwo().getSightRange(), r)))
                        .toSet().toImmutable();
            }
            return enemyStepSightLocations;
        }

        protected final ImmutableSet<Point2D> getEnemyHiddenLocations() {
            if (enemyHiddenLocations == null) {
                enemyHiddenLocations = MAP_LOCATIONS.difference(getEnemySightLocations());
            }
            return enemyHiddenLocations;
        }

        protected final ImmutableSet<Point2D> getEnemyBlockingLocations() {
            if (enemyBlockingLocations == null) {
                enemyBlockingLocations = visibleEnemies.keyValuesView()
                        .flatCollect(c -> c.getTwo().rangeAround(BLOCKING_RANGE, c.getOne())).toSet().toImmutable();
            }
            return enemyBlockingLocations;
        }

        protected final ImmutableSet<Point2D> getTeamHiddenLocations() {
            if (teamHiddenLocations == null) {
                teamHiddenLocations = MAP_LOCATIONS.difference(team.flatCollect(c -> c.rangeAround(c.getSightRange())));
            }
            return teamHiddenLocations;
        }

        protected final ImmutableSet<Point2D> getTeamBlockingLocations() {
            if (teamBlockingLocations == null) {
                teamBlockingLocations = team.flatCollect(c -> c.rangeAround(BLOCKING_RANGE)).toImmutable();
            }
            return teamBlockingLocations;
        }

        protected final ImmutableSet<Point2D> getSliceLocations() {
            if (sliceLocations == null) {
                sliceLocations = visibleEnemies.keyValuesView()
                        .flatCollect(c -> c.getTwo().rangeAround(delegate.getSliceRange(), c.getOne())).toSet().toImmutable();
            }
            return sliceLocations;
        }

        protected final ImmutableSet<Point2D> getStaticLocations() {
            if (staticLocations == null) {
                staticLocations = visibleEnemies.keyValuesView()
                        .flatCollect(c -> c.getTwo().rangeAround(STATIC_RANGE, c.getOne())).toSet().toImmutable();
            }
            return staticLocations;
        }

        protected final ImmutableMap<Point2D, Double> getEnemySliceDamage() {
            if (enemySliceDamage == null) {
                MutableMap<Point2D, Double> tmp = MAP_LOCATIONS.toMap(l -> l, l -> 0.0);
                for (Pair<Point2D, EnemyCharacter> p : visibleEnemies.keyValuesView()) {
                    double damage = calcSliceDamage(p.getTwo());
                    for (Point2D l : p.getTwo().rangeAround(p.getTwo().getSliceRange(), p.getOne())) {
                        tmp.put(l, tmp.get(l) + damage);
                    }
                }
                enemySliceDamage = tmp.toImmutable();
            }
            return enemySliceDamage;
        }
    }

    protected ImmutableMap<ReadonlyCharacter, Character> characters = Maps.immutable.empty();

    private ImmutableMap<Class<?>, ReadonlyAction> actions = null;
    protected ReadonlyAction step = null;
    protected ReadonlyAction slice = null;
    protected ReadonlyAction smile = null;

    private ImmutableSet<Point2D> enemyLocations = null;
    private ImmutableSet<Point2D> enemySliceLocations = null;
    private ImmutableSet<Point2D> enemySightLocations = null;
    private ImmutableSet<Point2D> enemyStepSightLocations = null;
    private ImmutableSet<Point2D> enemyHiddenLocations = null;
    private ImmutableSet<Point2D> enemyBlockingLocations = null;
    private ImmutableSet<Point2D> teamHiddenLocations = null;
    private ImmutableSet<Point2D> teamBlockingLocations = null;
    private ImmutableSet<Point2D> sliceLocations = null;
    private ImmutableSet<Point2D> staticLocations = null;
    private ImmutableMap<Point2D, Double> enemySliceDamage = null;

    protected final <T> T chooseRandom(Collection<T> collection) {
        if (!collection.isEmpty()) {
            int i = getRandom().nextInt(collection.size());
            for (T t : collection) {
                if (i == 0) {
                    return t;
                }
                --i;
            }
        }
        return null;
    }

    protected final <T> T chooseSmallest(Collection<T> collection, Comparator<? super T> comparator) {
        if (!collection.isEmpty()) {
            List<T> list = new ArrayList<>();
            for (T t : collection) {
                if (list.isEmpty()) {
                    list.add(t);
                } else {
                    int c = comparator.compare(t, list.get(0));
                    if (c < 0) {
                        list.clear();
                    }
                    if (c <= 0) {
                        list.add(t);
                    }
                }
            }
            return list.get(getRandom().nextInt(list.size()));
        }
        return null;
    }

    protected final Point2D chooseClosest(Collection<Point2D> available, RichIterable<Point2D> targets) {
        if (targets.isEmpty()) {
            return chooseRandom(available);
        } else {
            Map<Point2D, Integer> map = new HashMap<>();
            for (Point2D a : available) {
                map.put(a, targets.collect(t -> t.cartesianDistance(a)).min());
            }
            return chooseSmallest(available, (o1, o2) -> Integer.compare(map.get(o1), map.get(o2)));
        }
    }

    protected final Point2D chooseFarthest(Collection<Point2D> available, RichIterable<Point2D> targets) {
        if (targets.isEmpty()) {
            return chooseRandom(available);
        } else {
            Map<Point2D, Integer> map = new HashMap<>();
            for (Point2D a : available) {
                map.put(a, targets.collect(t -> t.cartesianDistance(a)).min());
            }
            return chooseSmallest(available, (o1, o2) -> Integer.compare(map.get(o2), map.get(o1)));
        }
    }

    protected int countCharacters(Class<?> clazz) {
        return characters.count(c -> c.getClass().equals(clazz));
    }

    protected ReadonlyAction getAction(Class<?> clazz) {
        return actions.get(clazz);
    }

    protected abstract Character createCharacter(ReadonlyCharacter delegate);

    @Override
    public final ReadonlyAction choose(Set<ReadonlyAction> actions, ReadonlyCharacter character) {
        characters = team.collect(c -> characters.getIfAbsentWith(c, this::createCharacter, c))
                .groupByUniqueKey(c -> c.delegate).toImmutable();

        this.actions = Sets.immutable.ofAll(actions).groupByUniqueKey(ReadonlyAction::actionClass);
        step = getAction(Step.class);
        slice = getAction(Slice.class);
        smile = getAction(Smile.class);

        enemyLocations = null;
        enemySliceLocations = null;
        enemySightLocations = null;
        enemyStepSightLocations = null;
        enemyHiddenLocations = null;
        enemyBlockingLocations = null;
        teamHiddenLocations = null;
        teamBlockingLocations = null;
        sliceLocations = null;
        staticLocations = null;
        enemySliceDamage = null;

        return characters.get(character).choose();
    }
}