AlienWar

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

คณะกรรมการ

มันเป็นบอร์ดสองมิติ
ความยาวของด้านใดด้านหนึ่งของคณะกรรมการคือMath.ceil(sqrt(species * 100 * 2.5))= ~ 40% ของคณะกรรมการที่ใช้ กระดานเป็นดาวเคราะห์ดังนั้นถ้าคุณเดินออกจากแผนที่ทางทิศตะวันตกคุณจะกลับมาทางทิศตะวันออก หากคุณเดินออกไปทางเหนือคุณจะพบว่าตัวเองอยู่ทางทิศใต้

ความสามารถ

สัตว์แต่ละชนิดในโลกมีความสามารถ ที่นี่พวกเขาคือ:

ชื่อ        ผลประโยชน์ 
ชีวิต HP = lifeLVL * 5 (ลดทุกครั้งที่คุณโจมตี, 0 = ตาย), ฐาน HP = 10
ความแรงการโจมตีของคุณจะสร้างความเสียหายแบบสุ่มในระยะ [1 ถึงความแข็งแกร่ง LVL]
Defense สุ่มเลือก int ในระยะ [0 ถึง (50 / defenseLVL + 1)], ถ้า int == 0 จากนั้นหลบการโจมตีครั้งต่อไป
การมองเห็นจะช่วยให้คุณมองเห็นvisionLVL / 2 ฟิลด์รอบ ๆ ตัวคุณ
cleverness Blurs (เพิ่มขึ้น) ความสามารถทุกอย่างแบบสุ่มในช่วง [0 ถึงclevernessLVL / 2] เมื่อส่งไปยังเอเลี่ยนอื่น

เกม

• แต่ละการส่งจะมี 100 ครั้ง
• หลังจากสร้างความแตกต่างมนุษย์ต่างดาวแต่ละคนสามารถตั้งค่าความสามารถ 10 คะแนนรวม คุณสามารถกำหนดจุดที่แตกต่างกันสำหรับทุกอินสแตนซ์
• หากคุณตั้งค่ามากกว่า 10 คะแนนอินสแตนซ์จะตาย
• เกมประกอบด้วย 1,000 รอบ แต่ละรอบ:
  • move(char[] fields)ทุกคนต่างด้าวมีการกลับย้ายผ่าน ซึ่งรวมถึงการย้าย STAY
  • หากมนุษย์ต่างดาวหลายคนอยู่ในสนาม 2 จะถูกสุ่มเลือก:
    • หากทั้งสองเห็นด้วยกับความสงบสุข (กลับเท็จในwantToFight) พวกเขาจะอยู่ที่พวกเขาอยู่พวกเขาจะต่อสู้
    • สิ่งนี้จะวนซ้ำจนกว่ามนุษย์ต่างดาวเพียงคนเดียวเท่านั้นที่อยู่ในทุ่งหรือทุกคนเห็นด้วยกับความสงบสุข

• ถ้ามนุษย์ต่างดาวฆ่าบางสิ่งเขาจะได้รับ 1/5 ของความสามารถของศัตรูแต่ละตัว ผู้ชนะจะได้รับ HP เติมด้วย 2 * enemyLifeLVL

• ผู้ชนะคือผู้ที่มีความสามารถมากที่สุด (ผลรวมของความสามารถของเอเลี่ยนที่มีชีวิต)

การต่อสู้

มนุษย์ต่างดาวทั้งสองจะตีกัน "ในเวลาเดียวกัน" ซึ่งหมายความว่าถ้าคุณฆ่าคนต่างด้าวอื่น ๆ เขายังคงสามารถตีคุณในครั้งเดียว

dodging: rand.nextInt(50 / defenseLvl + 1) == 0ก่อนที่คุณจะได้รับการตีเกมจะคำนวณถ้าคุณสามารถหลบการโจมตีโดยใช้ defenseLvl จะไม่มากกว่า 50เมื่อคำนวณทักษะการหลบของคุณ (ดังนั้นโอกาสหลบสูงสุดคือ 50%)

กดปุ่ม: หากคุณไม่ได้หลบการโจมตีที่คุณจะได้รับการตีและ HP rand.nextInt(enemy.getStrengthLvl()) + 1ของคุณจะลดลง

การต่อสู้สิ้นสุดลงเมื่อมนุษย์ต่างดาวที่เกี่ยวข้องกับการตาย หากมีผู้ชนะจะได้รับรางวัล

Gamerules

• ระดับพื้นฐานสำหรับทุกความสามารถ (โดยไม่ให้คะแนนความสามารถใด ๆ ) คือ 1 (ฐาน HP คือ 10)
• ค่าที่ส่งเมื่อถูกขอให้ต่อสู้คือชีวิต (ไม่ใช่ HP!), ความแข็งแกร่ง, การป้องกันและสายตาระดับ
• ความฉลาดจะไม่ถูกส่งเมื่อถูกขอให้ต่อสู้
• ตัวเลขลอยตัวทั้งหมดจะถูกปัดเศษเป็นจำนวนเต็มที่ใกล้เคียงที่สุดเมื่อใช้ / ส่ง แต่เก็บไว้และเพิ่มเป็นลอย
• โอกาสหลบสูงสุดคือ 50% มิฉะนั้นการต่อสู้อาจไม่สิ้นสุด

เหยื่อ

มีอยู่ 5 ชนิดที่อยู่บนสนามแล้ว พวกเขาเลือกที่จะไม่ต่อสู้เมื่อถูกถาม

Whale: เลเวล 10 life Stays   
Cow: เลเวล 10 ความแกร่งย้ายแบบสุ่ม
เต่า: เลเวล 10 การป้องกันทางตะวันตกเฉียงใต้
Eagle: เลเวล 10 การมองเห็นตรวจสอบทุ่งพยายามหลีกเลี่ยงอันตราย      
มนุษย์: เลเวล 10 ความฉลาดตะวันออกเฉียงเหนือ

พวกเขาจะแสดงด้วยตัวอักษรตัวแรกของพวกเขา (เช่นWสำหรับปลาวาฬ) ในแผนที่ (มนุษย์ต่างดาวที่มีAช่องว่างด้วยช่องว่าง' ')

กฎเพิ่มเติม

• ไม่อนุญาตการสะท้อนกลับ
• ไม่อนุญาตการโต้ตอบ (สร้างภาพเป็นต้น) กับเอเลี่ยนตัวอื่น
• ไม่อนุญาตให้เขียน / อ่านทรัพยากรภายนอกเช่นไฟล์หรือฐานข้อมูล
• อนุญาตให้ส่งเฉพาะ Java (รุ่น 1.8) (Java นั้นค่อนข้างง่ายและคุณไม่จำเป็นต้องเป็นผู้เชี่ยวชาญสำหรับเกมนี้)
• การส่งทั้งหมดจะต้องขยายคลาสของคนต่างด้าวและจะถูกวางไว้ในแพ็คเกจของเอเลี่ยน
• ฉันจะยอมรับคนต่างด้าวที่ดีที่สุดในวันที่ 19 กรกฎาคม มนุษย์ต่างดาวทั้งหมดที่ส่งโดย 12:00 UTC ในวันนั้นจะถูกทดสอบ
• ส่งได้สูงสุด 3 ต่อผู้ใช้เนื่องจากมีเอเลี่ยนจำนวนมากอยู่แล้ว

ตัวอย่างของเอเลี่ยน

package alien;

import planet.Move;

public class YourUniqueNameHere extends Alien {

    public void setAbilityPoints(float[] abilities) {
        abilities[0] = 2; //life
        abilities[1] = 2; //strength
        abilities[2] = 2; //defense
        abilities[3] = 2; //vision
        abilities[4] = 2; //cleverness
    }

    public Move move(char[][] fields) {
        //you are in the middle of the fields, say fields[getVisionFieldsCount()][getVisionFieldsCount()]
        return Move.STAY;
    }

    public boolean wantToFight(int[] enemyAbilities) {
        //same order of array as in setAbilityPoints, but without cleverness
        return true;
    }

}

โปรแกรมควบคุม

รหัสที่มาสำหรับโปรแกรมควบคุมที่สามารถพบได้ที่นี่ อัปเดตตอนนี้กับเอเลี่ยนทั้งหมดที่รวมอยู่ในการรันล่าสุด

คะแนนสุดท้าย (20.07.2014, เฉลี่ย 10 เกม)

Alien.PredicatClaw 1635.4
คนต่างด้าว LazyBee 1618.8
คนต่างด้าวช่างภาพ LongVisionAlien 1584.6
คนต่างด้าวเลือกของคุณการต่อสู้ 1571.2
คนต่างด้าว Bender 1524.5
คนต่างด้าว HerjanAlien 1507.5
เอเลี่ยน .unkyBob 1473.1
ต่างด้าว. SecretWeapon2 1467.9
Alien.PredicatEyees 1457.1
เอเลี่ยน 1435.9
มนุษย์ต่างดาว GentleGiant 1422.4
เอเลี่ยนropropircanlien 1321.2
alien.VanPelt 1312.7
คนต่างด้าวใหม่ซื้อ 1270.4
คนต่างด้าว BananaPeel 1162.6
มนุษย์ต่างดาวสะสม 1159.2
คนต่างด้าวพาลเอเลี่ยน 1106.3
เอเลี่ยน Geoffrey 778.3
ต่างด้าว. SecretWeapon 754.9
ต่างด้าว. SecretWeapon3 752.9
คนต่างด้าว. Junk 550.3
ต่างดาวหิน 369.4
เอเลี่ยน Assassin 277.8
Alien.Predicoward 170.1
เหยื่อ. 155.2
เอเลี่ยน 105.
เอเลี่ยน 99.6
มนุษย์ต่างดาว. 69.7
เอเลี่ยน 56.
เอเลี่ยน. ผู้จัดการ 37.6
คนต่างด้าวโอกินาว่าชีวิต 14.2
เหยื่อ. 10.5
alien .Gamer 4.5
เอเลี่ยน. สุ่ม 0
เอเลี่ยน. ยาม 0
เหยื่อ. Eagle 0
เอเลี่ยน 0
alien.WeakestLink 0
เอเลี่ยน. 0   
alien.Survivor 0
เอเลี่ยน. เร่ง 0
เอเลี่ยน. 0
เอเลี่ยน. 0
alien.CleverAlien 0
เหยื่อมนุษย์ 0
alien.BlindBully 0
เหยื่อเต่า 0
alien.AimlessWanderer 0

PredicatClaw (rawr)

เอเลี่ยนคนนี้จะกลืนคุณหมด (โอเคบางทีเธอจะเคี้ยวคุณก่อน) ... ถ้าคุณดูอ่อนแอตามอัลกอริธึมการทำนายของเธอ

สายพันธุ์ของเพรดิแคตที่มีกรงเล็บและเขี้ยวที่รุนแรงกว่าคู่ของมัน

แก้ไข: ลำดับความสำคัญเป้าหมายใหม่

package alien;

import planet.Move;

/* Predict + Cat = Predicat! */
public class PredicatClaw extends Alien {
    private static final int LIF=0, STR=1, DEF=2;
    private static final int WHALE=6, COW=1, TURTLE=4, EAGLE=3, HUMAN=2, ALIEN=-1, NONE=0;

    @Override
    public void setAbilityPoints( float[] abilities ) {
        abilities[LIF] = 4.5f;
        abilities[STR] = 5.5f;
    }

    @Override
    public Move move( char[][] fields ) {

        /* Some credits to Eagle for letting me learn how to do the moves */
        int vision = getVisionFieldsCount(); //count of fields / middle
        int fieldX;
        int fieldY;
        Move bestMove=Move.STAY;
        int bestScore=-1;

       for (Move move : Move.values()) {
            fieldX = vision + move.getXOffset();
            fieldY = vision + move.getYOffset();
            switch(fields[fieldX][fieldY]){
            case 'W' : 
                if(bestScore<WHALE){
                    bestMove=move;
                    bestScore=WHALE;
                }
                break;
            case 'C' :
                if(bestScore<COW){
                    bestMove=move;
                    bestScore=COW;
                }
                break;
            case 'T' :
                if(bestScore<TURTLE){
                    bestMove=move;
                    bestScore=TURTLE;
                }
                break;
            case 'E' :
                if(bestScore<EAGLE){
                    bestMove=move;
                    bestScore=EAGLE;
                }
                break;
            case 'H' :
                if(bestScore<HUMAN){
                    bestMove=move;
                    bestScore=HUMAN;
                }
                break;
            case 'A' :
                if(bestScore<ALIEN){
                    bestMove=move;
                    bestScore=ALIEN;
                }
                break;
            case ' ' :
                if(bestScore<NONE){
                    bestMove=move;
                    bestScore=NONE;
                }
                break;
            }
        }

        if(vision==1 && bestScore>1){
            return bestMove;
        }

        //check immediate outer field
        for (int i=vision-2; i<=vision+2; i++) {
            for(int j=vision-2; j<=vision+2; j++){
                if(i==0 || i==4 || j==0 || j==4){
                    switch(fields[i][j]){
                    case 'W' :
                        bestMove = this.getBestMoveTo(i,j);
                        bestScore = WHALE;
                        break;
                    case 'C' :
                        if(bestScore<COW){
                            bestMove = this.getBestMoveTo(i,j);
                            bestScore = COW;
                        }
                        break;
                    case 'T' :
                        if(i>=vision && j<=vision){
                            return this.getBestMoveTo(i-1,j+1);
                        }
                        if(bestScore<TURTLE){
                            bestMove = this.getBestMoveTo(i,j);
                            bestScore = TURTLE;
                        }
                        break;
                    case 'E' :
                        if(bestScore<EAGLE){
                            bestMove = this.getBestMoveTo(i,j);
                            bestScore = EAGLE;
                        }
                        break;
                    case 'H' :
                        if(i<=vision && j>=vision){
                            return this.getBestMoveTo(i+1,j-1);
                        }
                        if(bestScore<HUMAN){
                            bestMove = this.getBestMoveTo(i,j);
                            bestScore = HUMAN;
                        }
                        break;
                    case 'A' :
                        if(bestScore<ALIEN){
                            bestMove = this.getBestMoveTo(i,j);
                            bestScore = ALIEN;
                        }
                        break;
                    case ' ' :
                        if(bestScore<NONE){
                            bestMove = this.getBestMoveTo(i,j);
                            bestScore = NONE;
                        }
                        break;
                    }
                }
            }
        }

        return bestMove;
    }

    @Override
    public boolean wantToFight( int[] enemyAbilities ) {
        /*
            Fight IF
                1) I CAN BEAT YOU
                2) ????
                3) MEOW!
        */
        float e_hp = enemyAbilities[LIF]*5+10;
        float e_dmg = 1 + enemyAbilities[STR]/2;
        float e_hit = 1 - (1/(50/this.getDefenseLvl()+1));

        float m_hp = this.getCurrentHp();
        float m_dmg = 1 + this.getStrengthLvl()/2;
        float m_hit = 1 - (1/(50/enemyAbilities[DEF]+1));

        return (e_hp/(m_dmg*m_hit) < m_hp/(e_dmg*e_hit));
    }

    private Move getBestMoveTo(int visionX, int visionY){
        int vision = getVisionFieldsCount();

        if(visionX < vision && visionY < vision){
            return Move.NORTHWEST;
        }
        else if(visionX > vision && visionY < vision){
            return Move.NORTHEAST;
        }
        else if(visionX < vision && visionY > vision){
            return Move.SOUTHWEST;
        }
        else if(visionX > vision && visionY < vision){
            return Move.SOUTHEAST;
        }
        else if(visionX == vision && visionY < vision){
            return Move.NORTH;
        }
        else if(visionX == vision && visionY > vision){
            return Move.SOUTH;
        }
        else if(visionX > vision && visionY == vision){
            return Move.EAST;
        }
        else if(visionX < vision && visionY == vision){
            return Move.WEST;
        }
        else{
            return Move.WEST;
        }

    }
}

ผู้จัดการ

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

public class Manager extends Alien {

    private static final int STRENGTH = 5;

    @Override
    public void setAbilityPoints( float[] abilities ) {
        abilities[/* strength   */ 1] = STRENGTH;
        abilities[/* defense    */ 2] = 5;
        abilities[/* cleverness */ 4] = 0; // just to make sure
    }

    @Override
    public Move move( char[][] fields ) {
        return Move.WEST;
    }

    @Override
    public boolean wantToFight( int[] enemyAbilities ) {
        return enemyAbilities[1] < STRENGTH;
    }
}

CartographyLongVisionAlien

เอเลี่ยนตัวนี้เป็นรูปแบบการแสดงที่สอดคล้องกันของหนึ่งในความพยายามของฉันในการสร้างเอเลี่ยนที่มีศักยภาพในการชนะ

มันมีการมองเห็นเริ่มต้น 5x5 ซึ่งใช้ในการสร้างแผนที่ภายในของพื้นที่โดยรอบทำให้มันมีความสามารถในการหลีกเลี่ยงศัตรูที่เหนือกว่า

ในการทดสอบโดยเฉลี่ยของฉันมี 100 รอบโดยเฉลี่ยแล้วมันย่องไปข้างหน้ากับเอเลี่ยนตัวอื่น (2014/09/07)

อัพเดท GIF ที่แสดงเอฟเฟกต์การขับไล่ / ดึงดูด

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

 package alien;

 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Random;
 import planet.Move;
 import planet.Planet;

 /**
  * Created by moogie on 09/07/14.
  * 
  * This Alien attempts to map the visible and guess the movements within the immediate non-visible area around the alien.
  * To this end, the alien can initially see 5x5 grid. It applies weights on the cells of its internal map based on the 
  * prey/alien/blanks within its field of view. It then performs a simple blur to guess movements and then chooses the optimum move
  * based on the contents of its internal map.
  * 
  * If it is asked to fight, it performs battle simulations to determine whether it should nominate to fight.
  */
 public class CartographerLongVisionAlien extends Alien
 {
   private final static byte LIFE = 0, STR = 1, DEF = 2, VIS = 3, CLV = 4;

   // Plant Entity symbols
   private static final char TURTLE = 'T';
   private static final char HUMAN = 'H';
   private static final char WHALE = 'W';
   private static final char COW = 'C';
   private static final char EAGLE = 'E';
   private static final char ALIEN = 'A';
   private static final HashMap<Character, Move> preyMovement = new HashMap<>();

   static 
   {
     preyMovement.put(WHALE, Move.STAY);
     preyMovement.put(TURTLE, Move.SOUTHWEST);
     preyMovement.put(HUMAN, Move.NORTHEAST);
   };

   // Map constants
   public static final int MAP_SIZE_DIV_2 = 10;
   public static final int MAP_SIZE = MAP_SIZE_DIV_2 * 2 + 1;
   private static final int MAP_SIZE_MINUS_ONE = MAP_SIZE - 1;
   private static final double FADE_FACTOR=0.85;

   // Planet constants
   private static final int STARTING_HP = 10;
   private static final int START_HEALING_FACTOR = 5;
   private static final int MAX_DEFENCE = 50;

   // Battle Simulation constants
   private static final double AMBIGUOUS_ENEMY_HP_FACTOR = 2;
   private static final int SIMULATED_BATTLE_COUNT = 100;
   private static final int SIMULATED_BATTLE_THREASHOLD = (int)(SIMULATED_BATTLE_COUNT*1.0);

   private Random rand = new Random(Planet.rand.nextLong());

   /** The alien's map of the immediate and mid-range area */
   public double[][] map = new double[MAP_SIZE][MAP_SIZE];

   public void setAbilityPoints( float[] abilities )
   {
     // +0.5 gain due to rounding trick "borrowed" from PredicatClaw http://codegolf.stackexchange.com/a/32925/20193
     abilities[LIFE] = 3.5f; // We do need some hit points to ensure that we can survive the melee of the beginning game.
     abilities[STR] = 4.5f; // A Moderate attack strength means that we do not have to go through as many fight rounds.
     abilities[DEF] = 0; // We will get from prey and other aliens
     abilities[VIS] = 2; // A minimum of 2 is required to get a 5x5 field of view
     abilities[CLV] = 0; // We will get from prey and other aliens
   }

   /**
    * simulate alien memory fade. This allows an alien to eventually venture back to areas already traversed.
    */
   private void fadeMap()
   {
     for ( int y = 0; y < MAP_SIZE; y++ )
     {
       for ( int x = 0; x < MAP_SIZE; x++ )
       {
         map[x][y] *= FADE_FACTOR;
       }
     }
   }

   /**
    * shift the maps with the movement of the alien so that the alien is always at the centre of the map
    * 
    * @param move
    */
   private void shiftMaps( Move move )
   {
     int i, j;
     final int offsetX = -move.getXOffset();
     final int offsetY = -move.getYOffset();
     double[][] tempMap = new double[MAP_SIZE][MAP_SIZE];
     for ( int y = 0; y < MAP_SIZE; y++ )
     {
       for ( int x = 0; x < MAP_SIZE; x++ )
       {
         i = x + offsetX;
         j = y + offsetY;

         if ( i >= 0 && i <= MAP_SIZE_MINUS_ONE && j >= 0 && j <= MAP_SIZE_MINUS_ONE )
         {
           tempMap[i][j] = map[x][y];
         }
       }
     }
     map = tempMap;
   }

   /**
    * Updates a cell in the alien's map with the desirability of the entity in the cell
    * 
    * @param x
    * @param y
    * @param chr
    */
   private void updateMap( int x, int y, char chr )
   {
     // Note that these desire values are just guesses... I have not performed any analysis to determine the optimum values!
     // That said, they seem to perform adequately.
     double desire = 0;

     int i=x;
     int j=y;
     switch ( chr )
     {
       case WHALE:
         desire=2;
         break;
       case TURTLE:
       case HUMAN:
         desire=1;
         Move preyMove = preyMovement.get( chr );

         // predict movement into the future
         while ( i >= 0 && i <= MAP_SIZE_MINUS_ONE && j >= 0 && j <= MAP_SIZE_MINUS_ONE )
         {
           map[i][j] = ( map[i][j] + desire ) / 2;
           i+=preyMove.getXOffset();
           j+=preyMove.getYOffset();
           desire/=2;
         }
         break;
       case COW:
         desire = 0.5;
         break;
       case EAGLE:
         desire = 1;
         break;
       case ALIEN:
         desire = -10;
         break;
     }

     map[x][y] = ( map[x][y] + desire ) / 2;
   }

   /**
    * Apply a blur the map to simulate the movement of previously seen entities that are no longer within the field of view.
    */
   private void convolve()
   {
     double[][] tempMap = new double[MAP_SIZE][MAP_SIZE];

     int count;
     double temp;
     for ( int y = 0; y < MAP_SIZE; y++ )
     {
       for ( int x = 0; x < MAP_SIZE; x++ )
       {
         count = 0;
         temp = 0;
         for ( int i = x - 1; i < x + 2; i++ )
         {
           for ( int j = y - 1; j < y + 2; j++ )
           {
             if ( i >= 0 && i <= MAP_SIZE_MINUS_ONE && j >= 0 && j <= MAP_SIZE_MINUS_ONE )
             {
               temp += map[i][j];
               count++;
             }
           }
         }
         temp += map[x][y] * 2;
         count += 2;

         tempMap[x][y] = temp / count;
       }
     }
     map = tempMap;
   }

   /**
    * Determine the move that minimises the risk to this alien and maximises any potential reward.
    * 
    * @param fields
    * @return
    */
   private Move findBestMove( char[][] fields )
   {
     List<Move> moveOptions = new ArrayList<>();
     double bestMoveScore = -Double.MAX_VALUE;
     double score;

     // find the moves that have the best score using the alien's map
     for ( Move move : Move.values() )
     {
       int x = MAP_SIZE_DIV_2 + move.getXOffset();
       int y = MAP_SIZE_DIV_2 + move.getYOffset();
       score = map[x][y];
       if ( score == bestMoveScore )
       {
         moveOptions.add( move );
       }
       else if ( score > bestMoveScore )
       {
         bestMoveScore = score;
         moveOptions.clear();
         moveOptions.add( move );
       }
     }

     Move move = moveOptions.get( rand.nextInt( moveOptions.size() ) );

     // if the best move is to stay...
     if ( move == Move.STAY )
     {
       // find whether there are no surrounding entities in field of vision...
       int midVision = getVisionFieldsCount();
       boolean stuck = true;
       out: for ( int i = 0; i < fields.length; i++ )
       {
         for ( int j = 0; j < fields.length; j++ )
         {
           if ( !( i == midVision && j == midVision ) && fields[i][j] != ' ' )
           {
             stuck = false;
             break out;
           }
         }
       }

       // there there are no other entities within field of vision and we are healthy... choose a random move
       if ( stuck && getCurrentHp() > getLifeLvl() * 2 )
       {
         move = Move.getRandom();
       }
     }
     return move;
   }

   /**
    * Update the alien's map with the current field of vision
    * 
    * @param fields
    */
   private void mapVisibleSurroundings( char[][] fields )
   {
     int midVision = getVisionFieldsCount();

     // update the map with currently visible information
     for ( int y = -midVision; y <= midVision; y++ )
     {
       for ( int x = -midVision; x <= midVision; x++ )
       {
         char chr = fields[midVision + x][midVision + y];
         updateMap( MAP_SIZE_DIV_2 + x, MAP_SIZE_DIV_2 + y, chr );
       }
     }

     // ensure that the map where this alien currently sits is marked as empty.
     updateMap( MAP_SIZE_DIV_2, MAP_SIZE_DIV_2, ' ' );
   }

   public Move move( char[][] fields )
   {
     Move returnMove = null;

     // pre-move decision processing
     mapVisibleSurroundings( fields );
     convolve();

     returnMove = findBestMove( fields );

     // post-move decision processing
     fadeMap();
     shiftMaps( returnMove );

     return returnMove;
   }

   public boolean wantToFight( final int[] enemyAbilities )
   {
     double toughnessFactor =((double) enemyAbilities[STR])/(enemyAbilities[LIFE]*10); // a fudge-factor to ensure that whales are attacked.
     if (enemyAbilities[VIS]>=3 && enemyAbilities[LIFE]>4.5f) toughnessFactor*=3.5; // make sure that we do not attack other Cartogapher aliens 
     return winsBattleSimulation( enemyAbilities, toughnessFactor );
   }

   /**
    * Perform simulations to determine whether we will win against the enemy most of the time.
    * 
    * @param enemyAbilities
    * @return
    */
   private boolean winsBattleSimulation( int[] enemyAbilities, double toughnessFactor )
   {
     int surviveCount = 0;
     for ( int i = 0; i < SIMULATED_BATTLE_COUNT; i++ )
     {
       int estimatedEnemyHitPoints =
           STARTING_HP + (int)( enemyAbilities[LIFE] * START_HEALING_FACTOR * AMBIGUOUS_ENEMY_HP_FACTOR * toughnessFactor );
       int enemyPoints = estimatedEnemyHitPoints;
       int myHitPoints = getCurrentHp();
       int myDefenceLevel = getDefenseLvl() < MAX_DEFENCE ? getDefenseLvl() : MAX_DEFENCE;
       int enemyDefenceLevel = enemyAbilities[DEF] < MAX_DEFENCE ? enemyAbilities[DEF] : MAX_DEFENCE;

       while ( !( myHitPoints <= 0 || enemyPoints <= 0 ) )
       {
         if ( rand.nextInt( MAX_DEFENCE / myDefenceLevel + 1 ) != 0 )
         {
           myHitPoints -= rand.nextInt( enemyAbilities[STR] ) + 1;
         }

         if ( rand.nextInt( MAX_DEFENCE / enemyDefenceLevel + 1 ) != 0 )
         {
           enemyPoints -= rand.nextInt( getStrengthLvl() ) + 1;
         }
       }
       if ( myHitPoints > 0 )
       {
         surviveCount++;
       }
     }
     return ( surviveCount >= SIMULATED_BATTLE_THREASHOLD );
   }

 }

เลือกการต่อสู้ของคุณ

เอเลี่ยนตัวนี้วิ่งหนีจากเอเลี่ยนตัวอื่น แต่วิ่งไปหาเหยื่อ (ตราบเท่าที่มันจะไม่พามันไปหาเอเลี่ยน)

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

เราต่อสู้กับการต่อสู้เท่านั้นที่เราคิดว่าเราสามารถชนะได้อย่างสะดวกสบาย - เราประเมินว่ามันจะใช้เวลาเท่าไหร่ในการฆ่าเอเลี่ยนของเราและจะฆ่าศัตรูของเราเท่าไหร่และเข้าร่วมการต่อสู้ถ้ามันเป็น "สองเท่า" ฝ่ายตรงข้ามของเรา

package alien;

import planet.Move;

import java.util.Collections;
import java.util.HashSet;
import java.util.Set;

import static java.lang.Math.*;

public class ChooseYourBattles extends Alien {
    private static final boolean DEBUG = false;
    private static final int LIFE = 0;
    private static final int STRENGTH = 1;
    private static final int DEFENCE = 2;
    private static final int VISION = 3;
    private static final int CLEVERNESS = 4;
    private static final Set<Character> prey = new HashSet<>();
    {
        Collections.addAll(prey, 'H', 'T', 'W', 'C', 'E');
    }

    public void setAbilityPoints(float[] abilities) {
        // Rounding promotes these to 4 and 7 - 11 points!
        abilities[LIFE] = 3.5f;
        abilities[STRENGTH] = 6.5f;
    }

    @Override
    public Move move(char[][] fields) {
        if (DEBUG) {
            StringBuilder sb = new StringBuilder();
            for (int j = 0; j < 2 * getVisionFieldsCount() + 1; j++) {
                for (int i = 0; i < 2 * getVisionFieldsCount() + 1; i++) {
                    char chr = fields[i][j];
                    if (chr == ' ') chr = '.';
                    if (i == getVisionFieldsCount() && j == getVisionFieldsCount()) chr = 'X';
                    sb.append(chr);
                }
                sb.append('\n');
            }
            String view = sb.toString();
            System.out.println(this.toString());
            System.out.println(view);
        }

        Move bestMove = null;
        int bestEnemyDistance = Integer.MIN_VALUE;
        int bestPreyDistance = Integer.MAX_VALUE;

        for (Move tryMove: Move.values()) {
            int currentDistanceToEnemy = Integer.MAX_VALUE;
            int currentDistanceToPrey = Integer.MAX_VALUE;
            int x = getVisionFieldsCount() + tryMove.getXOffset();
            int y = getVisionFieldsCount() + tryMove.getYOffset();
            for (int i = 0; i < 2 * getVisionFieldsCount() + 1; i++) {
                for (int j = 0; j < 2 * getVisionFieldsCount() + 1; j++) {
                    char chr = fields[i][j];
                    if (chr == 'A' && (i != getVisionFieldsCount() || j != getVisionFieldsCount())) {
                        // Use L-infinity distance, but fll back to L-1 distance
                        int distance = max(abs(i - x), abs(j - y)) * 100 + abs(i -x) + abs(j - y);
                        if (distance < currentDistanceToEnemy) currentDistanceToEnemy = distance;
                    } else if (prey.contains(chr)) {
                        int distance = max(abs(i - x), abs(j - y)) * 100 + abs(i -x) + abs(j - y);
                        if (distance < currentDistanceToPrey) currentDistanceToPrey = distance;
                    }
                }
            }
            if (currentDistanceToEnemy > bestEnemyDistance
                    || (currentDistanceToEnemy == bestEnemyDistance && currentDistanceToPrey < bestPreyDistance)) { // Prefer to stay put
                bestMove = tryMove;
                bestEnemyDistance = currentDistanceToEnemy;
                bestPreyDistance = currentDistanceToPrey;
            }
        }

        if (DEBUG) {
            System.out.println("Going " + bestMove);
            System.out.println();
        }
        return bestMove;
    }

    @Override
    public boolean wantToFight(int[] enemyAbilities) {
        // Estimate whether likely to survive the encounter - are we at least "twice as hard" as our opponent
        return getCurrentHp() * (50.0 + getDefenseLvl()) / (enemyAbilities[STRENGTH])
                > 2.0 * (enemyAbilities[LIFE] * 5 + 10) * (50.0 + enemyAbilities[DEFENCE])/ (getStrengthLvl());
    }

    @Override
    public String toString() {
        return "ChooseYourBattles" + System.identityHashCode(this)
                + ": HP " + getCurrentHp()
                + ", LFE " + getLifeLvl()
                + ", STR " + getStrengthLvl()
                + ", DEF " + getDefenseLvl()
                + ", VIS " + getVisionLvl()
                + ", CLV " + getClevernessLvl();
    }
}

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

ขี้ยา

เอเลี่ยนตัวนี้ติดบางอย่างบางสิ่งบางอย่างเขาเริ่มสงครามด้วยการแก้ไขที่น่ารังเกียจ

ในขณะที่การแก้ไขของเขาจะแข็งแกร่ง (fix > 3 ) เขาพอใจที่จะนั่งในอาการมึนงงของเขาและเป็นอะไรก็ได้

อย่างไรก็ตามเมื่อการแก้ไขของเขาเริ่มเสื่อมสภาพ (fix <= 3 ) เขาเริ่มสะดุดในทิศทางที่มองไม่เห็นพยายามคิดว่าเกิดอะไรขึ้น หากถูกขอให้ต่อสู้เขาจะระมัดระวังและต่อสู้ก็ต่อเมื่อเขาคิดว่าเขาสามารถชนะได้

เมื่อการแก้ไขของเขาหมดลงเขาก็ติดยาเสพติดเขาจะต้องเริ่มวงจรอุบาทว์

public class Junkie extends Alien {
    private int fix = 10;

    public void setAbilityPoints(float[] abilities) {
        abilities[0] = 4; //life
        abilities[1] = 3; //strength
        abilities[2] = 3; //defense
    }

    public Move move(char[][] fields) {
        fix -= 1;
        if (fix == 0) {
            fix = 10;
        }
        else if(fix <= 3 && fix > 0) {
            return Move.getRandom();
        }

        return Move.STAY;
    }

    public boolean wantToFight(int[] enemyAbilities) {
        if(fix > 3) {
            return true;
        }
        // Am I stronger than their defense and can I withstand their attack?
        else if(enemyAbilities[2] < getStrength() && enemyAbilities[1] < getDefense()) {
            return true;
        }

        return false;
    }
}

เปลือกกล้วย

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

package alien;

import planet.Move;
public class BananaPeel extends Alien{
    public void setAbilityPoints(float[] abilities){
        abilities[0] = 0.5f;  // banana peels barely hold themselves together
        abilities[1] = 9.5f;  // banana peels can't help tripping people up
        abilities[2] = 0;  // banana peels can't defend themselves
        abilities[3] = 0;  // banana peels can't see
        abilities[4] = 0;  // banana peels can't think
    }

    public Move move(char[][] fields){
        return Move.STAY; // banana peels can't move
    }

    public boolean wantToFight(int[] enemyAbilities){
        return enemyAbilities[0] == 0 || enemyAbilities[1] == 0;
    }
}

แวน Pelt

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

package alien;

import java.util.Collections;
import java.util.LinkedList;
import java.util.List;

import planet.Move;

public class VanPelt extends Alien {

    private static final int LIFE = 0;
    private static final int STRENGTH = 1;
    private static final int DEFENSE = 2;
    private static final int VISION = 3;
    private static final int CLEVER = 4;

    // we all agreed before starting to move a certain direction if we're not
    // hunting or avoiding, helps avoid self-collisions... since we can't tell 
    // who we're fighting
    private static Move randomMove = Move.getRandom();

    @Override
    public void setAbilityPoints(float[] abilities) {
        abilities[LIFE] = 3.5f;
        abilities[STRENGTH] = 6f;
        abilities[VISION] = 0.5f;
    }

    @Override
    public Move move(char[][] fields) {
        int curHealth = this.getCurrentHp();
        List<Target> targets = new LinkedList<Target>();
        int vision = getVisionFieldsCount();
        boolean foundMe = false;
        for (int x = 0; x < fields.length; x++) {
            for (int y = 0; y < fields[x].length; y++) {
                switch (fields[x][y]) {
                case ' ' :
                    continue;
                case 'A' :
                    if (!foundMe && x == vision && y == vision) {
                        foundMe = true;
                        continue;
                    }
                    break;
                }
                targets.add(new Target(-vision + x, -vision + y, fields[x][y]));
            }
        }
        // if we're low health we need to move away from danger
        double desiredX = 0;
        double desiredY = 0;
        if (curHealth < this.getLifeLvl() * 7) {
            for (Target t : targets) {
                if (t.id == 'A') {
                    // closer aliens are more dangerous
                    desiredX -= vision / t.x;
                    desiredY -= vision / t.y;
                }
            }
        } else {
            // seek and destroy closest prey
            Collections.sort(targets);
            for (Target t : targets) {
                if (t.id != 'A') {
                    desiredX = t.x;
                    desiredY = t.y;
                    break;
                }
            }
        }
        desiredX = (int)Math.signum(desiredX);
        desiredY = (int)Math.signum(desiredY);
        for (Move m : Move.values()) {
            if (m.getXOffset() == desiredX && m.getYOffset() == desiredY) {
                return m;
            }
        }

        return randomMove;
    }

    @Override
    public boolean wantToFight(int[] enemyAbilities) {
        // we don't want to fight if we're hurt
        int curHealth = this.getCurrentHp();
        if (curHealth < this.getLifeLvl() * 4) {
            return false;
        }
        // determine if we're fighting prey
        int count = 0;
        int abilityMaxed = 0;
        int total = 0;
        for (int i = 0; i < enemyAbilities.length; i++) {
            total += enemyAbilities[i];
            if (enemyAbilities[i] == 11) {
                count++;
                abilityMaxed = i;
            }
        }
        // very likely to be prey, ignoring cows... they're dangerous
        if (abilityMaxed != STRENGTH && (count == 1 || total < 10)) {
            return true;
        }

        // else use a scoring system with tinkered constants
        double score = enemyAbilities[LIFE] * 4.0 
                + enemyAbilities[DEFENSE] * 0.5 
                + enemyAbilities[STRENGTH] * 5.0;

        double myScore = this.getDefenseLvl() * 0.5 +
                this.getStrengthLvl() * 5.0 +
                this.getCurrentHp() * 2.5;

        return myScore > score * 2;
    }



    private class Target implements Comparable<Target> {
        public int x, y;
        public char id;
        public int distanceSq;

        public Target(int x, int y, char id) {
            // adjust for known movement patterns
            switch(id) {
            case 'T' :
                x += Move.SOUTHWEST.getXOffset();
                y += Move.SOUTHWEST.getYOffset();
                break;
            case 'H' :
                x += Move.NORTHEAST.getXOffset();
                y += Move.NORTHEAST.getYOffset();
                break;
            }
            this.x = x;
            this.y = y;
            this.id = id;

            distanceSq = x * x + y * y;
        }

        @Override
        public int compareTo(Target other) {
            return distanceSq - other.distanceSq;
        }
    }

}

ชีวิตโอกินาวา

ไม่น่าแปลกใจที่ฉันจะเป็นคนสุดท้ายที่ยืนอยู่

package alien;

import planet.Move;


public class OkinawaLife extends Alien{
    public void setAbilityPoints(float[] abilities){
        abilities[0] = 8.5f;
        abilities[1] = 0.5f;
        abilities[3] = 1;
    }

    public Move move(char[][] fields){
        int vision = getVisionFieldsCount(); //count of fields / middle
        char me = fields[vision][vision]; //middle of fields
        int leastDanger = Integer.MAX_VALUE;
        Move bestMove = Move.STAY;
        for (Move move : Move.values()) {
            int danger = 0;
            for (int i = 1; i <= vision; i++) { //loop through fields in specific direction
                int fieldX = vision + (i * move.getXOffset());
                int fieldY = vision + (i * move.getYOffset());
                switch(fields[fieldX][fieldY])  {
                    case 'A': danger++;
                    case ' ': break;
                    case 'C': break;
                    case 'E': break;
                    case 'H': break;
                    default: danger--;
                }
            }
            if (danger < leastDanger) {
                bestMove = move;
                leastDanger = danger;
            }
        }
        return bestMove;
    }

    public boolean wantToFight(int[] enemyAbilities){
        return enemyAbilities[1] == 0;
    }
}

ผู้ล่า

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

package alien;

import planet.Move;

public class Hunter extends Alien   {
    private final static byte LIFE=0, STR=1, DEF=2, VIS=3, CLV=4;

    public void setAbilityPoints(float[] abilities) {
        abilities[LIFE] = 0;
        abilities[STR] = 9;
        abilities[DEF] = 0;
        abilities[VIS] = 1;
        abilities[CLV] = 0;
    }

    public Move move(char[][] fields)   {
        int vision = getVisionFieldsCount(); //count of fields / middle
        char me = fields[vision][vision]; //middle of fields
        int leastDanger = Integer.MAX_VALUE;
        Move bestMove = Move.STAY;
        for (Move move : Move.values()) {
            int danger = 0;
            for (int i = 1; i <= vision; i++) { //loop through fields in specific direction
                int fieldX = vision + (i * move.getXOffset());
                int fieldY = vision + (i * move.getYOffset());
                switch(fields[fieldX][fieldY])  {
                    case 'A': danger++;
                    case ' ': break;
                    default: danger--;
                }
            }
            if (danger < leastDanger) {
                bestMove = move;
                leastDanger = danger;
            }
        }
        return bestMove;
    }

    public boolean wantToFight(int[] enemyAbilities)    {
        return ((double)this.getCurrentHp() * this.getDefenseLvl()) / (double)enemyAbilities[STR] > (enemyAbilities[LIFE] * enemyAbilities[DEF]) / this.getStrengthLvl();
    }
}

มันมากกว่า 9000!

package alien;

import planet.Move;

public class Over9000 extends Alien {
    public void setAbilityPoints(float[] abilities) {
        abilities[0] = 10;
    }

    public Move move(char[][] fields) {
        return Move.WEST;
    }

    public boolean wantToFight(int[] enemyAbilities) {
        return enemyAbilities[1] <= 9000;
    }

    @Override
    public int getStrengthLvl() {
        return 9001; // It's over 9000!!!!!!111
    }
}

ใช่มันเป็นความพยายามที่โจ่งแจ้งในการโกง แต่มันก็ส่งเสียงร้องตามกฎ หากผู้ทะเยอทะยานเข้าสู่planet.Specieขั้นสุดท้ายช่องโหว่นี้จะปิดลง

หิน

ฉันคิดว่ามันเป็นการโจมตีคนที่อ่อนแอและ "ฉลาด" เท่านั้น

package alien;

import planet.Move;

public class Rock extends Alien{
    public void setAbilityPoints(float[] abilities){
        abilities[0] = 0.5f;
        abilities[1] = 9.5f;
    }

    public Move move(char[][] fields){
        return Move.STAY;
    }

    public boolean wantToFight(int[] enemyAbilities){
        return enemyAbilities[0] + enemyAbilities[1] + enemyAbilities[2] + enemyAbilities[3] < 10;
    }
}

Morphling

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

package alien;

import planet.Move;
import java.util.Random;


public class Morphling extends Alien {

    @Override
    public void setAbilityPoints(float[] abilities) {
        Random rand = new Random();
        for(int attr = 0, maxPoints = 10, value = rand.nextInt(maxPoints); attr <5 && maxPoints > 0 ; attr++, maxPoints -=value, value = rand.nextInt(maxPoints)){
            abilities[attr] = value;
            if(attr == 4 && (maxPoints-=value) > 0){
                abilities[1]+=maxPoints;
            }
        }
    }

    @Override
    public Move move(char[][] fields) {
        int vision = getVisionFieldsCount(); //count of fields / middle
        char me = fields[vision][vision]; //middle of fields
        int leastDanger = Integer.MAX_VALUE;
        Move bestMove = Move.STAY;
        for (Move move : Move.values()) {
            int danger = 0;
            for (int i = 1; i <= vision; i++) { //loop through fields in specific direction
                int fieldX = vision + (i * move.getXOffset());
                int fieldY = vision + (i * move.getYOffset());
                switch(fields[fieldX][fieldY])  {
                    case 'A': danger++;
                    case ' ': break;
                    case 'T': break;
                    case 'E': break;
                    case 'H': break;
                    default: danger--;
                }
            }
            if (danger < leastDanger) {
                bestMove = move;
                leastDanger = danger;
            }
        }
        return bestMove;
    }

    @Override
    public boolean wantToFight(int[] enemyAbilities) {
        return getStrengthLvl() > enemyAbilities[1];
    }

}

เบนเดอร์ "ดัด" Rodriguez

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

สรุป

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

ปลาวาฬและนกอินทรีก็งอได้เช่นกัน =)

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

ย้ายไปทางตะวันตกหรือทางใต้เว้นแต่คุณจะพบสิ่งที่น่าสนใจในการโจมตี:

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

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

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

ฉันอาจปรับแต่งตัวเลขในเมทริกซ์ที่น่าปรารถนาด้วยอัลกอริทึมทางพันธุกรรมของ James_picเพื่อผลลัพธ์ที่ดียิ่งขึ้น แต่ฉันไม่รู้ว่าจะทำอย่างไร

ความแข็งขัน

wantToFightเบนเดอร์ส่วนใหญ่เป้าหมายเหยื่อและสวยอนุรักษ์นิยมกับเขา ใครก็ตามที่มีกำลังมากกว่า 4 จะหลบหนีเว้นแต่คุณคิดว่าคุณกำลังเผชิญกับมนุษย์ที่ฉลาด มนุษยชาติที่ฉลาดนั้นแสดงให้เห็นโดยมีการป้องกันและการมองเห็นมากกว่ามนุษย์ต่างดาวที่น่าจะมี มันถูกปรับตามช่วงเวลาของสถิติความสามารถของ Bender ในการอธิบายถึงมนุษย์ต่างดาวที่ฆ่าเต่าและนกอินทรี

package alien;

import planet.Move;
import java.util.HashMap;

/// The Bender "Kill All Humans" Alien
///
/// This alien operates on the principle that killing puny
/// Humans is easy and inflates your perceived strength,
/// which will intimidate other aliens into steering clear.
///
/// Whales and Eagles are also bendable. =)
public class Bender extends Alien {

    private static final boolean DEBUG = false;
    private final int LIF = 0, STR = 1, DEF = 2, VIS = 3, CLV = 4;
    protected static HashMap<Character, Integer> preyDesirability = new HashMap<Character, Integer>() {{
        put('A', -5);
        put('W',  5);
        put('C',  0); // Originally -2, but Cows don't attack
        put('T',  2);
        put('E',  3);
        put('H',  4);
    }};
    private static final int bananaTweak = -2;

    private static final HashMap<Character, Move> preyMovement = new HashMap<Character, Move>() {{
        put('W', Move.STAY);
        put('T', Move.SOUTHWEST);
        put('H', Move.NORTHEAST);
    }};

    public void setAbilityPoints(float[] abilities) {
        abilities[LIF] = 3.5f; // Shiny metal ass
        abilities[STR] = 5.5f; // Bending strength
        abilities[DEF] = 0;
        abilities[VIS] = 1;    // Binocular eyes
        abilities[CLV] = 0;
    }

    /// Looks for humans to intercept!
    ///
    /// Generally speaking, move either west or south
    /// unless you have found something interesting to
    /// attack:
    /// - For the prey whose movement is known, we add
    ///   their desirability to the index at which they
    ///   will be next turn.
    /// - For those we do not, we divide their desirability
    ///   equally among the squares that they may move to
    ///   next turn. Aliens get a bonus negative to their
    ///   existing square because of banana peels.
    public Move move(char[][] fields) {

        int vision = getVisionFieldsCount();
        // I am at fields[vision][vision]

        if (DEBUG) {
            System.out.format("\n----- %s -----\n", this);
        }

        float[][] scoringMap = new float[fields.length][fields.length];
        for (int y = 0; y < fields.length; y++) {
            for (int x = 0; x < fields.length; x++) {

                // Ignore my square and blanks
                if (x == vision && y == vision ||
                    fields[x][y] == ' ') {
                    continue;
                }

                // Check out the prey 8^]
                char organism = fields[x][y];
                float desirability = preyDesirability.get(organism);

                // If we know where it's going, score tiles accordingly...
                if (preyMovement.containsKey(organism)) {
                    Move preyMove = preyMovement.get(organism);
                    if (DEBUG) {
                        System.out.println(String.format("Prey %s will move %s", organism, preyMove));
                    }
                    int newPreyX = x + preyMove.getXOffset();
                    int newPreyY = y + preyMove.getYOffset();
                    try {
                        scoringMap[newPreyX][newPreyY] += desirability;
                        if (DEBUG) {
                            System.out.println(String.format(
                                "Adding %.1f to %d, %d",
                                desirability,
                                newPreyX,
                                newPreyY));
                        }
                    }
                    catch(Exception e) {
                        if (DEBUG) {
                            System.out.println(String.format(
                                "Failed adding %.1f to %d, %d",
                                desirability,
                                newPreyX,
                                newPreyY));
                        }
                    }
                }
                // ...otherwise, divide its score between its
                //    available moves...
                else {
                    for (int j = y - 1; j <= y + 1; j++) {
                        for (int i = x - 1; i <= x + 1; i++) {
                            try {
                                scoringMap[i][j] += desirability / 9.;
                            }
                            catch (Exception e) {
                                if (DEBUG) {
                                    //System.out.println(e);
                                }
                            }
                        }
                    }
                }
                // ...and if it is an alien, add a handicap
                //    for bananas and rocks.
                if (organism == 'A') {
                    scoringMap[x][y] += bananaTweak;
                }
            }
        }

        // Evaluate immediate surroundings 8^|
        //
        // +-----------+
        // |           |
        // |   # # #   |
        // |   # B #   |
        // |   # # #   |
        // |           |
        // +-----------+
        float bestScore = -10;
        int[] bestXY = new int[2];
        for (int y = vision - 1; y <= vision + 1; y++) {
            for (int x = vision - 1; x <= vision + 1; x++) {

                if (DEBUG) {
                    System.out.format("\nx:%d, y:%d", x, y);
                }
                // Look for the best score, but if scores
                // are tied, try for most southwest high score
                if (scoringMap[x][y] > bestScore ||
                    scoringMap[x][y] == bestScore && (
                        x <= bestXY[0] && y > bestXY[1] ||
                        y >= bestXY[1] && x < bestXY[0])
                    ) {
                    bestScore = scoringMap[x][y];
                    bestXY[0] = x;
                    bestXY[1] = y;
                    if (DEBUG) {
                        System.out.format("\nBest score of %.1f found at %d, %d", bestScore, x, y);
                    }
                }
            }
        }

        if (DEBUG) {
            StringBuilder sb = new StringBuilder();
            sb.append("\n-----\n");
            for (int y = 0; y < fields.length; y++) {
                for (int x = 0; x < fields.length; x++) {
                    sb.append(String.format("%5s", fields[x][y]));
                }
                sb.append("\n");
            }
            for (int y = 0; y < scoringMap.length; y++) {
                for (int x = 0; x < scoringMap.length; x++) {
                    sb.append(String.format("%5.1f", scoringMap[x][y]));
                }
                sb.append("\n");
            }
            System.out.println(sb.toString());
        }

        // If something looks tasty, go for it :^F
        if (bestScore > 0.5) {
            for (Move m : Move.values()) {
                if (m.getXOffset() == bestXY[0] - vision &&
                    m.getYOffset() == bestXY[1] - vision) {
                    if (DEBUG) {
                        System.out.println("Using immediate circumstances.");
                        System.out.println(m);
                    }
                    return m;
                }
            }
        }

        // If nothing looks good, do a lookahead to
        // the south, west, and southwest to guess
        // which is best. 8^[
        //
        // There is potential in recursively applying our
        // vision data with updated score rankings, but
        // that would be hard. :P
        float westScore = 0, southScore = 0, southWestScore = 0;
        for (int y = vision - 1; y < vision + 1; y++) {
            for (int x = 0; x < vision; x++) {
                // +-----------+
                // |           |
                // | # # #     |
                // | # # B     |
                // | # # #     |
                // |           |
                // +-----------+
                westScore += scoringMap[x][y] / (vision - x);
            }
        }
        for (int y = vision; y < fields.length; y++) {
            for (int x = vision - 1; x < vision + 1; x++) {
                // +-----------+
                // |           |
                // |           |
                // |   # B #   |
                // |   # # #   |
                // |   # # #   |
                // +-----------+
                southScore += scoringMap[x][y] / (y - vision);
            }
        }
        for (int y = vision; y < fields.length; y++) {
            for (int x = 0; x < vision; x++) {
                // +-----------+
                // |           |
                // |           |
                // | # # B     |
                // | # # #     |
                // | # # #     |
                // +-----------+
                southWestScore += scoringMap[x][y] / Math.sqrt((y - vision) + (vision - x));
            }
        }
        if (southScore > westScore && southScore > southWestScore) {
            if (DEBUG) {
                System.out.println(Move.SOUTH);
            }
            return Move.SOUTH;
        }
        if (westScore > southScore && westScore > southWestScore) {
            if (DEBUG) {
                System.out.println(Move.WEST);
            }
            return Move.WEST;
        }
        if (DEBUG) {
            System.out.println(Move.SOUTHWEST);
        }
        return Move.SOUTHWEST;
    }

    public boolean wantToFight(int[] enemyAbilities) {

        // Be afraid...
        if (enemyAbilities[STR] > 4) {

            // ...unless you suspect you are being lied to
            if (enemyAbilities[DEF] + enemyAbilities[VIS] > 4 * sumMyAbilities() / 5.) {

                // Enemy has more than expected attribute levels of unhelpful
                // abilities. Assume you're dealing with a clever bastard.
                return true;
            }

            return false;
        }
        return true;
    }

    int sumAbilities(int[] abilities){
        int sum = 0;
        for (int ability : abilities){
            sum += ability;
        }
        return sum;
    }

    int sumMyAbilities(){
        return sumAbilities(new int[]{
            getLifeLvl(),
            getStrengthLvl(),
            getDefenseLvl(),
            getVisionLvl(),
            getClevernessLvl()
        });
    }
}