বেঁচে থাকার খেলা - AlienWar


96

AlienWar

এই গেমটি খুব জনাকীর্ণ গ্রহে অনুষ্ঠিত হয় যেখানে এলিয়েনরা সেরা জাতি superior আপনার কাজটি হল আপনার নিজের এলিয়েন তৈরি করা এবং অন্য সকলকে বীট করা।

বোর্ড

এটি একটি 2 মাত্রিক বোর্ড।
বোর্ডের এক পাশের দৈর্ঘ্য Math.ceil(sqrt(species * 100 * 2.5))= ~ 40% ব্যবহৃত বোর্ড। বোর্ডটি একটি গ্রহ, সুতরাং আপনি যদি পশ্চিমে মানচিত্রের বাইরে চলে যান তবে আপনি পূর্ব দিকে ফিরে আসবেন। আপনি যদি উত্তরে হাঁটেন তবে আপনি নিজেকে দক্ষিণে খুঁজে পাবেন।

ক্ষমতা

গ্রহের প্রতিটি প্রজাতির ক্ষমতা রয়েছে। এখানে তারা:

নাম         বেনিফিট 
লাইফ এইচপি = লাইফএলভিএল * 5 (আপনার নেওয়া প্রতিটি হিট, 0 = মৃত) কমান , বেস এইচপি = 10
শক্তি আপনার হিটগুলি [1 থেকে পাওয়ারএলভিএল] ক্ষতিতে একটি এলোমেলোভাবে কাজ করে
প্রতিরক্ষা এলোমেলোভাবে পরিসীমা নির্বাচন করুন [0 থেকে (50 / ডিফেন্সলভিএল) + 1)], যদি int == 0 হয় তবে পরবর্তী আক্রমণটি
দৃষ্টি আপনাকে ভিশনএলভিএল দেয় চারপাশে / 2 ক্ষেত্রঅন্যান্য এলিয়েনকে প্রেরণ করার সময় 
চতুরতা অস্পষ্টভাবে প্রতিটি ক্ষমতা (0 থেকে চতুরতা এলভিএল / 2] এ
 পরিসীমাতে বৃদ্ধি পায়

খেলাাটি

  • প্রতিটি জমা দেওয়ার 100 টি উদাহরণ থাকবে।
  • ইনস্ট্যান্সিংয়ের পরে, প্রতিটি এলিয়েন মোট 10 টি পয়েন্ট সেট করতে পারে। আপনি প্রতিটি উদাহরণের জন্য বিভিন্ন পয়েন্ট সেট করতে পারেন।
  • আপনি যদি 10 টিরও বেশি পয়েন্ট সেট করেন তবে উদাহরণটি মারা যায়।
  • একটি খেলা 1000 রাউন্ড নিয়ে গঠিত। প্রতিটি রাউন্ড:
    • প্রতিটি এলিয়েনের মাধ্যমে একটি পদক্ষেপ ফিরে আসতে হবে move(char[] fields)। এতে মুভ.স্টেএ অন্তর্ভুক্ত রয়েছে।
    • বেশ কয়েকটি এলিয়েন যদি মাঠে থাকে তবে 2 জন এলোমেলোভাবে নির্বাচিত হবে:
      • যদি উভয়ই শান্তিতে সম্মত হয় (মিথ্যা প্রত্যাবর্তন করে wantToFight) তারা যেখানে থাকে সেখানেই থাকবে, অন্যথায় তারা লড়াই করবে।
      • কেবলমাত্র একজন বিদেশী মাঠে না থাকে বা সমস্ত শান্তিতে সম্মত না হওয়া পর্যন্ত এই লুপগুলি লুপ হয়।
  • যদি কোনও এলিয়েন কিছু মারে তবে সে তার প্রতিটি শত্রুর সক্ষমতা 1/5 পাবে । বিজয়ীদের এইচপি 2 * শত্রুজীবলভিএল দিয়ে পুনরায় পূরণ করা হবে

  • বিজয়ী হ'ল সর্বাধিক ক্ষমতা (জীবিত এলিয়েনদের ক্ষমতার যোগফল)।

মারামারি

উভয় এলিয়েন একে অপরকে "একই সাথে" আঘাত করবে, এর অর্থ আপনি যদি অন্য পরকীয়াকে হত্যা করেন তবে সে আপনাকে একবারে আঘাত করতে পারে।

ডজিং: আপনি আঘাত পাওয়ার আগে আপনি ব্যবহার করে আক্রমণটি ডজ করতে পারলে গেমটি গণনা করা হবে rand.nextInt(50 / defenseLvl + 1) == 0DefenceLvl কখনই 50 এর বেশি হবে নাআপনার ডজ দক্ষতা গণনা করার (সুতরাং সর্বোচ্চ ডজ-সুযোগ 50%) 50

হিট করা: আপনি আক্রমণটি ডজ না করলে আপনি আঘাত পাবেন এবং আপনার এইচপি হ্রাস পাবে rand.nextInt(enemy.getStrengthLvl()) + 1

লড়াইয়ে লড়াই শেষ হয় যখন জড়িত উভয় বা উভয়ই পরকীয়ার মৃত্যু হয়। বিজয়ী যদি উপস্থিত থাকে তবে পুরষ্কারটি পেয়ে যায়।

খেলার নিয়ম

  • প্রতিটি ক্ষমতার জন্য বেস স্তর (কোনও ক্ষমতা পয়েন্ট না দিয়ে) 1 (বেস এইচপি 10)।
  • যুদ্ধ করার জন্য যখন পাঠানো মানগুলি হ'ল জীবন (এইচপি নয়!), শক্তি, প্রতিরক্ষা এবং দৃষ্টি হ'ল তা হ'ল ।
  • যখন লড়াই করতে বলা হয় তখন চালাকি পাঠানো হয় না।
  • সমস্ত ভাসমান নম্বরগুলি ব্যবহার / প্রেরণ করার সময় নিকটতম পূর্ণসংখ্যার দিকে রাউন্ড করা হবে তবে ফ্লোট হিসাবে সঞ্চিত এবং বাড়ানো হবে।
  • সর্বাধিক ডজ-সুযোগ 50%। অন্যথায় মারামারি কখনও শেষ হতে পারে না।

শিকার

ইতিমধ্যে মাঠে রয়েছে এমন 5 টি প্রজাতি রয়েছে। যেহেতু তারা শিকার হয়, তাই তারা যখন জিজ্ঞাসা করা হয় তখন লড়াই না করা বেছে নেয়।

তিমি: lvl 10 জীবন বাস   
গরু: lvl 10 শক্তি এলোমেলো পদক্ষেপ
কচ্ছপ: lvl 10 প্রতিরক্ষা দক্ষিণ পশ্চিম
Agগল: lvl 10 দৃষ্টি ক্ষেত্র পরীক্ষা করে, বিপদ এড়াতে চেষ্টা করে      
মানব: lvl 10 চতুরতা উত্তর পূর্ব

তাদের Wমানচিত্রে তাদের প্রথম অক্ষর (অর্থাত্ তিমির জন্য) দিয়ে উপস্থাপিত করা হবে (শুভ্রক্ষেত্রের সাথে এলিয়েন A, খালি ক্ষেত্র ' ')।

অতিরিক্ত বিধি

  • প্রতিবিম্ব নিষিদ্ধ করা হয়।
  • অন্যান্য এলিয়েনের সাথে কথোপকথন (ইনস্ট্যান্সিং ইত্যাদি) অনুমোদিত নয়।
  • বাহ্যিক সংস্থান যেমন ফাইল বা ডাটাবেস লেখার / পড়াও নিষেধ।
  • কেবল জাভা (সংস্করণ 1.8) জমা দেওয়ার অনুমতি দেওয়া হয়েছে (জাভা বরং সহজ, এবং আপনাকে এই গেমটির জন্য বিশেষজ্ঞ হতে হবে না)।
  • সমস্ত জমা দিতে অবশ্যই এলিয়েন-শ্রেণি প্রসারিত করতে হবে এবং এলিয়েন-প্যাকেজে রাখা হবে।
  • আমি 19 ই জুলাই সেরা এলিয়েন গ্রহণ করব। সেদিন 12:00 ইউটিসি দ্বারা জমা দেওয়া সমস্ত এলিয়েন পরীক্ষা করা হবে।
  • ইতিমধ্যে অনেকগুলি এলিয়েন থাকার কারণে ব্যবহারকারী প্রতি সর্বোচ্চ 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
এলিয়েন.লজিবি 1618.8
এলিয়েন.কার্টোগ্রাফার লংভিশনআলিয়েন 1584.6
এলিয়েন.চুজ ইয়ুর ব্যাটেলস 1571.2
এলিয়েন.বেন্ডার 1524.5
এলিয়েন.হিরজান আলেইন 1507.5
এলিয়েন.ফানকিবু 1473.1
alien.SecretWeapon2 1467.9
এলিয়েন.প্রিডিক্যাটিস 1457.1
এলিয়েন.কর্পোলেটআলিয়ান 1435.9
এলিয়েন.জেন্টলজেন্ট 1422.4
এলিয়েন.ক্রপ সার্কেলআলিয়েন 1321.2
এলিয়েন.ভ্যানপেল্ট 1312.7
এলিয়েন.নুগুয়ে 1270.4
এলিয়েন.বানানাপীল 1162.6
এলিয়েন.রক 1159.2
alien.BullyAlien 1106.3
এলিয়েন.জিফরি 778.3
alien.SecretWeapon 754.9
alien.SecretWeapon3 752.9
এলিয়েন.ফানকি জ্যাক 550.3
এলিয়েন.স্টোন 369.4
alien.Assassin 277.8
এলিয়েন.প্রিডিকওয়ার্ড 170.1
শিকার। গরু 155.2
এলিয়েন.মার্ফলিং 105.3
এলিয়েন.এলি 99.6
alien.Warrior 69.7
এলিয়েন.হান্টার 56.3
এলিয়েন.ম্যানেজার 37.6
এলিয়েন.ওকিনাওয়া লাইফ 14.2
শিকার। তিমি 10.5
এলিয়েন.গেমার 4.5
alien.Randomite 0
alien.Guard 0
prey.Eagle 0
এলিয়েন.রোগ 0
alien.WeakestLink 0
alien.Fleer 0   
alien.Survivor 0
alien.Sped 0
এলিয়েন.জানকি 0
alien.Coward 0
alien.CleverAlien 0
শিকার 0 হিউম্যান 0
alien.BlindBully 0
prey.Turtle 0
এলিয়েন.অ্যামলেস ওয়ান্ডারার 0

14
তিনটি ডাউনটি, পৃথিবীতে কি? এবং আমি একটি নেতিবাচক মন্তব্য দেখতে পাচ্ছি না। নিষ্ক্রিয় আক্রমণাত্মক লোকেরা কি বিরক্তি প্রকাশ করেছে যে এটি জাভাতেই সীমাবদ্ধ?
মার্টিন ইন্ডার

6
@ এম.বয়েটনার আমার নীচের অংশটি জাভাতে godশ্বরবাদকে সীমাবদ্ধতার জন্য (যদিও এটি কখনও তৈরি করা সবচেয়ে উত্তম ভাষায় সীমাবদ্ধ থাকলেও আমি এটি এটিকে 1 টি ভাষাতেই সীমাবদ্ধ রাখার জন্য এটিকে নীচে নামিয়ে দেব)। ডাউনভিটগুলি কী হবে তা স্পষ্ট হওয়ায় কোনও মন্তব্য যুক্ত করার বিষয়টি আমি দেখতে পাইনি।
গ্যারেথ

6
হুম, আমি এখানে মিশ্র অনুভূতি অনুভব করছি
মিঃ এলিয়েন

5
@ ব্যবহারকারী 3334871 আমি মনে করি না যে 17 টি উত্তর থাকা সত্ত্বেও কোনও বিধি পরিবর্তন করা (এবং সম্ভবত আরও কয়েক ডজন লোক জমা দেওয়ার ক্ষেত্রে কাজ করা) একটি ভাল ধারণা। যেহেতু এখানে আমাদের মধ্যে খুব কমই পেশাদার গেম ডিজাইনার, তবে কোনও স্ব-তৈরি কোট-এর কিছু ভারসাম্যপূর্ণ সমস্যা থাকতে পারে - তবে সম্ভাব্য কৌশলগুলির স্থান অনুসন্ধান করা এখনও মজাদার (যা সম্ভবত এটি উত্তর দিয়ে বিচার করা, upvotes এবং তারা), আমি মনে করি না যে এটি কোনও সমস্যা of
মার্টিন ইন্ডার

5
@ মনু গণিতের জন্য বোর্ডের মোড়কে কীভাবে কিছুটা বিভ্রান্তিকর তার বিবরণটি ঝুঁকির জন্য। আপনি বলছেন এটি একটি গ্রহ এবং এটি পূর্ব / পশ্চিমে আবৃত। এমন কিছুই নেই যা সত্যই ইঙ্গিত দেয় যে এটি উত্তর / দক্ষিণকেও মোড়ানো করে। প্রকৃতপক্ষে, যদি এটি হয় তবে এটি প্রযুক্তিগতভাবে আর কোনও গোলক নয়, একটি টরাস: কোটাকু / ক্লাসিক-jrpg-worlds-are-actual-donuts-1239882216 । আপনি এটিও দেখতে পাচ্ছেন যে আপনি যখন কোনও বিশ্বের মানচিত্রের (উত্তর মেরু) শীর্ষে "বন্ধ" হাঁটেন তখন আপনি নীচে (দক্ষিণ মেরু) উপস্থিত হন না। অতএব, মাইকেল এর পরামর্শ অবশ্যই বৈধ, আমি মনে করি।
মার্টিন ইন্ডার

উত্তর:


11

PredicatClaw (কাঁচা)

এই কল্পিত এলিয়েন আপনাকে পুরো গ্রাস করবে (ঠিক আছে, সে আপনাকে প্রথমে কিছুটা চিবিয়ে ফেলবে) ... যদি আপনি তার ভবিষ্যদ্বাণী অ্যালগরিদমের ভিত্তিতে দুর্বল বলে মনে করেন।

প্রেডিক্যাটসের একটি প্রজাতি যার প্রতিদ্বন্দ্বীদের তুলনায় তীব্র নখ এবং ফ্যাং থাকে।

সম্পাদনা: নতুন লক্ষ্য অগ্রাধিকার

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;
        }

    }
}

1
অভিশাপ! সেই ভবিষ্যদ্বাণীগুলি মারাত্মক! আমি নোট করেছি যে আমরা দুজনেই কম-বেশি একই wantToFightঅ্যালগরিদমে স্থির হয়েছি ।
জেমস_পিক

@ জেমস_পিক, আমি দেখতে পাচ্ছি যে দুর্দান্ত মনরা একই রকম চিন্তা করে। : ডি
মার্ক গ্যাব্রিয়েল

27

ম্যানেজার

এখানে একজন ম্যানেজার। স্বভাবতই, চতুরতা 0 এবং তিনি সর্বদা চেষ্টা করেন যেখানে সূর্য না don't এবং, অবশ্যই, তিনি কেবল দুর্বলদের সাথে লড়াই করবেন এবং ঝামেলা বাঁচাতে খুব ভাল:

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;
    }
}

+1, যদি কেবল পরিচিতির জন্য হয়। : পি
অ্যাফনার্টন

6
যতবার আমি এই মন্তব্যটি পড়েছি ("কেবলমাত্র নিশ্চিত করার জন্য") আমাকে হাসতে হবে :
ম্যাথিয়াস

মজাদার, আমি কেবল এটি পড়ছিলাম: blog.codinghorror.com/i-shall-call-it-somethingmanager
11684

@ 11684 কোনও শালীন বিকাশকারী অবশ্যই তা জানেন, তবে আমার ক্ষেত্রে আমি আসলে একজন পরিচালক হিসাবে বোঝাতে চাইছি;)
ইনগো বার্ক

18

CartographyLongVisionAlien

এই এলিয়েন এমন একটি এলিয়েন উত্পাদন করার আমার প্রচেষ্টার একটি সংক্ষিপ্ত পারফরম্যান্স বৈকল্পিক যা সম্ভাব্য জয়ের সম্ভাবনা।

এটিতে প্রাথমিক 5x5 দৃষ্টি রয়েছে যা এটি আশেপাশের অঞ্চলটির অভ্যন্তরীণ মানচিত্র তৈরি করতে ব্যবহার করে এটিকে উচ্চতর শত্রু পরিহারের ক্ষমতা প্রদান করে।

আমার 100 টি রাউন্ডের পরীক্ষায়, গড়ে, এটি অন্যান্য সমস্ত এলিয়েনের চেয়ে ছিটকে যায়। (09/07/2014)

পুনর্বৃদ্ধি / আকর্ষণ ক্ষেত্রের প্রভাব দেখায় আপডেট হওয়া জিআইএফ

সিমুলেশনের অ্যানিমেটেড জিআইএফ উত্পাদন করতে আমি গেম কোডটি সংশোধন করেছি। আপনি এখানে একটি অনুরূপ দেখতে পারেন

 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 );
   }

 }

শিকারের ভবিষ্যতের পূর্বাভাস যোগ করার জন্য এবং তিমিদের আক্রমণ হওয়ার সম্ভাবনা নিশ্চিত করার জন্য আপডেট করা হয়েছে
মোগি

4
হ্যাঁ! অবশেষে একজন এলিয়েন বিজয়ী হচ্ছেন যিনি কেবল শক্তি এবং
জীবনকেই

3
এটি একটি নিয়মিত অভিনয় ছিল যে একটি এলিয়েন পাওয়া খুব কঠিন ছিল! অন্যান্য শীর্ষে প্রবেশকারীরা বেশিরভাগই একই ধারণা অনুসরণ করে থাকে: এলিয়েনদের এড়ান, শিকারটিকে আক্রমণ করুন এবং কেবল লড়াইয়ের সূচনা করুন যা আপনি প্রায় জয়ের গ্যারান্টিযুক্ত। এই এলিয়েন একই ধারণা অনুসরণ করে তবে আরও ভাল এলিয়েন এড়ানো। এটি এটিকে সামান্যতম প্রান্ত দেয় কারণ আপনি কোনও লড়াইয়ে হেরে গেলে আরও বেশি দক্ষতা অর্জন করা "ব্যয়বহুল"।
মোগি

আমি অন্যান্য আরও বিদেশী ধারণাগুলি চেষ্টা করেছি কিন্তু যথেষ্ট তথ্য উন্মুক্ত নয়। যেমন মানচিত্রের আকার, এলিয়েনের সংখ্যা ইত্যাদি
মোগি

দারূন কাজ! আমিও তথ্যের অভাবে কিছুটা হতাশ হয়েছি - অতীত থেকে অতিরিক্ত তথ্য আহরণ করা সৃজনশীল।
বেনি

15

আপনার যুদ্ধ চয়ন করুন

এই এলিয়েন অন্যান্য এলিয়েন থেকে দূরে পালিয়ে যায়, তবে এটি শিকারের দিকে চলে যায় (যতক্ষণ না এটি এলিয়েনের দিকে না নেয়)।

শুরুর মানগুলি চয়ন করতে আমাকে সহায়তা করার জন্য আমি জেনেটিক অ্যালগরিদম ব্যবহার করেছি। ফলাফলগুলি সূচিত করে যে প্রাথমিক ব্যাটগুলি পেতে আমাদের শক্তি এবং জীবনের উপর নির্ভর করা উচিত। ভিশন পরে দরকারী, কিন্তু আমরা পরাস্ত শত্রুদের থেকে এটি চয়ন করতে পারেন।

আমরা কেবলমাত্র যুদ্ধগুলিই আমরা ভাবি যে আমরা স্বাচ্ছন্দ্যে জিততে পারি - আমরা অনুমান করি যে আমাদের বিদেশীটিকে হত্যা করতে কতটা পদক্ষেপ নেওয়া হবে, আমাদের শত্রুকে হত্যা করতে কতটা লাগবে, এবং যুদ্ধে যদি আমরা "দ্বিগুণ শক্ত" হয়ে থাকি তবে কেবল যুদ্ধে যোগ দেই আমাদের প্রতিপক্ষ

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();
    }
}

আপনি যদি নিজের জেনেটিক অ্যালগরিদম / প্রজনন প্রোগ্রাম চালাতে চান তবে এই উদ্দেশ্যে নিয়ন্ত্রণ প্রোগ্রামের একটি কাঁটাযুক্ত অনুলিপি পেয়েছি ।


কীভাবে এটি checkAbilitesOkপদ্ধতিটিতে চেকটিকে বাইপাস করে ?
ফ্রিএএসআইনবিয়ার

checkAbilitiesOkঅ্যারেতে ভাসমানগুলি 10.0 পর্যন্ত যোগ করে তা পরীক্ষা করে। যাইহোক, ভাসমান মানগুলি গেম যুক্তিতে ইনটগুলিতে গোলাকার হয় এবং জাভা ০.০ আপকে ঘিরে।
জেমস_পিক

@ ঠিকঠাক এটি এখনও 10 পয়েন্ট নির্ধারণ করে, সেগুলি কেবল বুদ্ধিমানভাবে বিতরণ করা হয়।
কমনগ্যুই

1
আমার বলা উচিত যে এটি আমার ধারণাটি মূলত ছিল না - আমি এটি
প্রিডিক্যাটক্লোর

1
খুব সুন্দর. আপনার স্ট্যাটাসের ধ্রুবকগুলি সম্ভবত আমার চেয়ে ভাল এবং আপনার ওয়াসটফাইট অবশ্যই স্মার্ট, আমি কেবল অলস ছিলাম। :)
বেনি

12

নেশাখোর

এই এলিয়েন কিছুতে আসক্ত । তিনি যুদ্ধটি বেশ খারাপ বাজে ফিক্সের সাথে শুরু করেন।

যখন তার স্থিরতা শক্তিশালী হচ্ছে ( fix > 3) তখন তিনি নিজের বোকামিটিতে বসে আনন্দিতভাবে সন্তুষ্ট হন এবং কোনও কিছুর জন্য প্রস্তুত হন।

যাইহোক, একবার তার ফিক্সটি বন্ধ হয়ে যেতে শুরু করে ( fix <= 3) সে কী ঘটেছিল তা বোঝার চেষ্টা করার মতো কোনও বোধগম্য দিক থেকে চারপাশে হোঁচট খেতে শুরু করে। যদি লড়াই করতে বলা হয়, তবে সে সাবধান হয় এবং যদি সে ভাবতে পারে যে সে জিততে পারে only

একবার তার সংশোধন শেষ হয়ে যায়, তিনি আসক্ত হওয়ার পরে, তাকে অবশ্যই দুষ্টচক্রটি পুনরায় চালু করতে হবে।

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;
    }
}

আমি খুব নিশ্চিত যে এটি && fix > 0অপ্রয়োজনীয়তার কারণে অপসারণ করা নিরাপদ ।
টিমটেক

10

কলার খোসা

কেবলমাত্র এমন লোকদের ট্রিপ করার চেষ্টা করে যাদের কিছুটা হ্যাচিং প্রয়োজন। এটি হারাতে আপনার স্বাস্থ্যকর হবে না।

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;
    }
}

এটি লক্ষ করাও গুরুত্বপূর্ণ যে [0] স্বাস্থ্যের চেয়ে জীবন, সুতরাং 100 এর আগে 510 এইচপি হবে (বা এরই মধ্যে নেওয়া ক্ষতির উপর নির্ভর করে) তবে আমি জানি না যে কোনও এলিয়েন এ উচ্চতর হবে কিনা ..
গিগালা

@ জিগালা ভাল চিন্তাভাবনা, আমি এটিকে কিছুটা বদলেছি।
টিমটেক

9

ভ্যান পেল্ট

জুমানজি থেকে শিকারী। যখন আঘাত না করা হয় তখন সে শিকার করে, যখন হয় তখন এড়িয়ে যায় এবং কী হত্যা করতে পারে তার শালীন বিচারক। কলার খোসা তাকে ছুঁড়ে মারতে থাকে, তবে কিছু নতুন কৌশল শিখিয়েছিল।

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;
        }
    }

}

কলা খোসা এড়াতে শিখেছি, তাই না? : পি
টিমটেক

8

ওকিনাওয়া জীবন

অবাক হওয়ার কিছু নেই যে আমিই দাঁড়িয়ে আছি।

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;
    }
}

7

শিকারী

আমিও কেবল মাত্র agগলের চলনটি চুরি করেছি, এখন ছাড়া তিনি অন্যান্য এলিয়েনের পাশাপাশি সব কিছুর দিকে যেতে চান। যতটা সম্ভব শিকারের শিকার এবং খামার করার চেষ্টা করে এবং লড়াইয়ের লড়াই তখনই মনে হয় যখন এটির জয়ের ভাল সুযোগ রয়েছে।

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();
    }
}

7

এটা 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চূড়ান্ত করা হয় তবে এই ফাঁকটি বন্ধ হয়ে যাবে।


4
ওহ না! আমি জানতাম আমি কিছু ভুলে গিয়েছি ... আমি
লুফোলটি

আমি কিছুটা হতাশ হয়েছি যে এই উত্তরটিতে আমার অন্যান্য, প্রবীণ, বর্তমানে বিজয়ী, প্রবেশের চেয়ে অনেক বেশি উত্সাহ রয়েছে।
জেমস_পিক

7

শিলা

আমি মনে করি এটি কেবল দুর্বল এবং "চালাক" লোকদের আক্রমণ করে।

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;
    }
}

3
আমি নিশ্চিত নই যে রক একবার জয়ের লড়াইয়ের কারণে তার শত্রুদের কিছু বাফ পেতে শুরু করলে কতটা ভাল থাকবে। ভাল লাগছে যদিও।
কাইল কানোজ

@ কাইলক্যানোস আমি বুঝতে পেরেছি; তবে, আমি ধরে নিয়েছি যে আমি বেশিরভাগ শিকার / এলিয়েনদের সাথে লড়াই করব, যতক্ষণ না তারা চালাক না হয়। এও কি ওকে কিছু বাফ দেবে না?
টিমটেক

এখন আমার মন্তব্যে ফিরে তাকানো, আমার মনে হয় আমি যা বলতে চেয়েছিলাম তা আসলেই ছিল না। আমি বলতে চেয়েছিলাম যে শত্রুরা যখন স্তরগুলি দিয়ে মারতে শুরু wantToFightকরে trueতখন শর্তটি দেওয়া হবে না ; আপনি দ্রুত একটি শক্তিশালী শান্তবাদী হয়ে উঠবেন।
কাইল কানোজ

কাইলক্যানোস ওহ, আমি পেয়েছি আমি এটিকে কিছুটা বদলেছি।
টিমটেক

6

Morphling

অন্য কোনও নাম ভাবতে পারেনি, এই লোকটি এলোমেলোভাবে তার ক্ষমতাগুলিতে 10 পয়েন্ট বিতরণ করে। প্রায় ওকিনাওয়া লাইফের মতো চলন (আপনার প্রচেষ্টার জন্য thx) এবং কেবল তার লড়াই শত্রুর শক্তির চেয়ে বেশি হলে লড়াই করতে চায়।

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];
    }

}

আহ্, আপনি জানেন, আপনি ঠিক বলেছেন। বন্ধ বন্ধনীগুলি আমাকে এই চ্যালেঞ্জটি হত্যা করছে (তার কারণে আমার কয়েকবার সম্পাদনা করতে হয়েছিল)। আমি এখন এটি দেখতে, এবং এটি সঠিক। যে ইশারা জন্য ধন্যবাদ!
ব্যবহারকারী 3334871

@ ব্যবহারকারী 3334871 যদিও আমি আপনার পরামর্শটি দিয়ে পরীক্ষা করেছি এবং আমার মরফ্লিং আরও ভালভাবে বেঁচে উঠেছে: ডি
সিকোরস্কি

@ সিকর্স্কি আচ্ছা, খুশি আমি সাহায্য করতে পারি, নিশ্চিত না কেন এটি আরও বেশি ভাড়া দেওয়া হবে, হাহা।
ব্যবহারকারী 3334871

@ সিকোর্স্কি আমার অনুমান যে কেবলমাত্র অর্থ দাঁড়ানো যে সমস্ত পদক্ষেপ বিপজ্জনক হলে সর্বনিম্ন বিপজ্জনক পদক্ষেপ নেওয়ার চেয়ে বেশিরভাগ স্থানে থাকা প্রায়শই নিরাপদ।
মার্টিন এন্ডার

আহ, "হেডলাইটের হরিণ" কৌশলটি আমার পছন্দ হয়েছে।
ব্যবহারকারী 3334871

6

বেন্ডার "নমন" রড্রিগেজ

কোড মন্তব্যে আমি বেশ উদার ছিলাম। কী চলছে তা দেখতে আপনি সেগুলি প্রসঙ্গে পড়তে পারেন তবে আমি নীচে কিছু স্নিপেটও যুক্ত করব।

সারাংশ

এই এলিয়েন এই নীতিতে কাজ করে যে শাস্তি হিউম্যানকে হত্যা করা সহজ এবং আপনার অনুভূত শক্তিকে স্ফীত করে দেয় যা অন্যান্য এলিয়েনকে স্টিয়ারিং ক্লিয়ারে ভয় দেখাবে।

তিমি এবং agগলগুলিও বেন্ডেবল। =)

আন্দোলন

আক্রমণে আকর্ষণীয় কিছু না পেলে পশ্চিম বা দক্ষিণে সরান:

  • যে শিকারটির চলাচল জানা যায়, তাদের জন্য আমরা তাদের আকাঙ্ক্ষাকে স্কয়ারে যুক্ত করি যেখানে তারা পরের বার হবে।
  • আমরা যা করি না তাদের জন্য আমরা তাদের আকাঙ্ক্ষাকে স্কোয়ারের মধ্যে সমানভাবে বিভক্ত করি যাতে তারা পরবর্তী সময়ে যেতে পারে।
    • কলা খোসার কারণে এলিয়েনরা তাদের বিদ্যমান স্কোয়ারে নেতিবাচক বোনাস পান।

আপনি যদি কাছাকাছি আকর্ষণীয় কিছু না পেয়ে থাকেন, তবে দক্ষিণ, পশ্চিম বা দক্ষিণ-পশ্চিমে আরও আশাব্যঞ্জক বিকল্প কিনা তা অনুধাবন করুন।

একটি বা দুটি প্রচলিত দিকনির্দেশনা বাছাই করা এই সুযোগটি কমিয়ে দেয় যে কোনও প্রদত্ত বেন্ডার তার যে কোনও দেশবাসীর কাছাকাছি আসবে এবং তার প্রধান শিকারের দিকনির্দেশক কাউন্টার তুললে তাকে দ্রুত সমস্ত মানুষকে হত্যা করতে সহায়তা করা উচিত।

আরও ভাল ফলাফলের জন্য আমি সম্ভবত জেমস_পিকের জেনেটিক অ্যালগরিদমের সাথে কাঙ্ক্ষিত ম্যাট্রিক্সে নম্বরগুলি টুইঙ্ক করতে পারি, তবে কীভাবে এটি করতে হয় তা আমি জানি না।

হামলাদারিতা

বেন্ডার বেশিরভাগ ক্ষেত্রে শিকারকে লক্ষ্য করে এবং এটি তার সাথে বেশ রক্ষণশীল wantToFight। আপনি যদি একজন চালাক মানুষের সাথে কথা ভাবছেন না তবে আপনি শক্তি 4 এর বেশি কাউকে এড়িয়ে চলা উচিত । চতুর মানবতাটি কোনও পরকীয়া হওয়ার চেয়ে বেশি প্রতিরক্ষা এবং দৃষ্টি থাকার মাধ্যমে প্রদর্শিত হয়। কচ্ছপ এবং agগলকে মেরে থাকা এলিয়েনদের জন্য অ্যাকাউন্ট হিসাবে এটি বেন্ডারের নিজস্ব সক্ষমতার পরিসংখ্যান দ্বারা উদাহরণস্বরূপ সামঞ্জস্য হয়েছে।

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()
        });
    }
}

আমি লক্ষ্য করেছি যে একটি লুপ লজিক ত্রুটি ছিল যেখানে ভেরিয়েবলটি বাড়ানো হয় তা সরাসরি তুলনা করা যাচ্ছিল না এবং কেবল পূর্ণসংখ্যার ওভারফ্লো মোড়কের মাধ্যমে অসীম পুনরাবৃত্তি এড়ানো হয়। আশা করি আপনার উত্তরটি আপডেট করার সাথে সাথে আমার ঠিক আছে। (এটি সময়ে সময়ে সিমুলেশনটি বিরতি দিয়েছিল)
মোগি

@ মুগি হে। তাহলে আমি কি শুধু দুর্ঘটনার মাধ্যমেই ভাল করছি? এটি ধরার জন্য ধন্যবাদ
মাইকেল 14

আমি পুরো বিষয়টি নিয়ে গিয়ে আরও কয়েকটি সমস্যা সমাধান করেছি।
মাইকেল 18

5

সৈনিক

এটি একটি খুব সাধারণ মনের পরকীয়া যিনি কেবল লড়াই করতে চান। সে তার শত্রুদের ও তার চারপাশের বিষয় সম্পর্কে চিন্তা করে না।

public class Warrior extends Alien {

    public void setAbilityPoints(float[] abilities) {
        abilities[0] = 5;
        abilities[1] = 5;
    }

    public Move move(char[][] fields) {
        return Move.getRandom(); //enemies are everywhere!
    }

    public boolean wantToFight(int[] enemyAbilities) {
        return true; //strong, therefore no stronger enemies.
    }
}

আপনার কাছে এখন আপনার নিজের বিরুদ্ধে বিদেশী পরীক্ষা করার জন্য কেউ আছেন have


4

ভীরু

আমি আক্রমণে আক্রান্ত হওয়ার আশঙ্কা থেকে রক্ষা পাওয়ার জন্য এবং মূলত agগলের চলাচলের প্যাটার্নটি চুরি করেছি।

public class Coward extends Alien{
    public void setAbilityPoints(float[] abilities){
        abilities[0] = 1;  // life
        abilities[1] = 0;  // str
        abilities[2] = 2; // def
        abilities[3] = 7;  // vis
        abilities[4] = 0;  // clv
    }

    // shamelessly stole Eagle's movement to avoid danger
    public Move move(char[][] fields){
        int vision = getVisionFieldsCount(); 
        char me = fields[vision][vision];
        int leastDanger = Integer.MAX_VALUE;
        Move bestMove = Move.STAY;
        for (Move move : Move.values()) {
            int danger = 0;
            for (int i = 1; i <= vision; i++) {
                int fieldX = vision + (i * move.getXOffset());
                int fieldY = vision + (i * move.getYOffset());
                if (fields[fieldX][fieldY] != ' ') {
                    danger++;
                }
            }
            if (danger < leastDanger) {
                bestMove = move;
                leastDanger = danger;
            }
        }
        return bestMove;
    }

    public boolean wantToFight(int[] enemyAbilities){
        return false;
    }
}

আমি ভুল হলে আমাকে সংশোধন করুন, তবে যেহেতু প্রতিটি দক্ষতার 1 ভিত্তি রয়েছে, তাই নির্বাণ vision=1যথেষ্ট হবে?
জাস্টহেল্ফ

@ আসফাল্ফ: কোডটি সম্পর্কে আমার সংক্ষিপ্ত পাঠটি মনে হয়েছিল যে 1 setAbilityPointsটির মানগুলি বেশি লিখেছেন, তবে গভীরতর দিকে তাকিয়ে আমি মনে করি আপনি সঠিক are আমি এটিকে এ কারণেই ছেড়ে যাচ্ছি কারণ একটি বৃহত্তর দৃষ্টিভঙ্গি আমাকে আরও দেখতে এবং বিপদ এড়াতে দেয়, তবে ধরা দেওয়ার জন্য ধন্যবাদ।
কাইল কানোজ

এছাড়াও, গণিত.সাগর সর্বদা 0.5 এর উপরে থাকে, সুতরাং আপনার যদি একটি বিজোড় সংখ্যা থাকে তবে আপনি একটি অতিরিক্ত দর্শন পান
Andreas

@ মনু: দৌড়ানোর দূরত্বকে উন্নত করতে আমি আমার দৃষ্টি ও প্রতিরক্ষা মানগুলি পরিবর্তন করেছি।
কাইল কানোস

4

উপহাস

আতঙ্ক

রহস্যোদ্ঘাটন

RUUUUUUUUUUN

AAAAAAAAAAAAAAAAAAAAAAA


যখনই সম্ভব যুদ্ধগুলি এড়িয়ে চলুন।

package alien; import planet.Move;

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

    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;
        ArrayList<Integer> dangerOnSides = new ArrayList<Integer>();
        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());
                if (fields[fieldX][fieldY] != ' ') {
                    danger++;
                }
            }
            if (danger < leastDanger) {
                bestMove = move;
                leastDanger = danger;
            }
            dangerOnSides.add(danger);
        }

        boolean noDanger = false;
        for (int i : dangerOnSides) {
           if (i == 0) {
              noDanger = true;
           }
           else { noDanger = false; break; }
        }

        if (noDanger) {
              // Hahhhhhhhh.......
              return Move.STAY;
        }

        int prev = -1;
        boolean same = false;
        for (int i : dangerOnSides) {
           if (prev == -1)
           { prev = i; continue; }
           if (i == prev) {
              same = true;
           }
           else { same = false; break; }

           prev = i;
        }

        if (same) {
              // PANIC
              return Move.getRandom();
        }

        return bestMove;
    }

    public boolean wantToFight(int[] enemyAbilities) {
        return false;
    }
}


2
@ কুইনকঙ্কস এটি একটি কাকতালীয় ঘটনা, এটি দেখেনি ...
stommestack

দুঃখিত, আমি ঠিক বুঝতে পেরেছিলাম যে দুজনের উত্তরই copyগল থেকে অনুলিপি করেছে। আপনি অন্য উত্তরটি অনুলিপি করেননি, আমি কেবল যথেষ্ট যত্ন সহকারে পড়িনি। তবে, একটি আলাদা নাম উপযুক্ত হবে।
জাস্টিন 21

1
নাম বদলেছে!
stommestack

2
নাম রাখা উচিত রিন্সউইন্ড।
ম্যাগাস

4

প্রিডিকওয়ার্ড (পুর)

ভবিষ্যদ্বাণীগুলির একটি জাত যা ভয় পেয়ে এবং ঝামেলা থেকে দূরে থাকে (এখনও অবধি) বেঁচে আছে। তাদের জীবনযাত্রার কারণে তারা যুদ্ধের প্রবৃত্তি বিকাশ করতে পারেনি, তবে তাদের উপলব্ধি ব্যতিক্রমী।

তাদের ধরনের তাদের সহকর্মী প্রেডিক্যাটস দ্বারা তত্পর।

সম্পাদনা: পরিবর্তিত ম্যানহাটনের দূরত্বের পরিবর্তে ওজনযুক্ত দূরত্ব

package alien;

import planet.Move;
import java.util.ArrayList;
import java.awt.Point;

/* Predict + Cat = Predicat! */
public class Predicoward extends Alien {
    /*
        - - - - - - - - - - - - -
        - - - - - - - - - - - - -
        - - - - - - - - - - - - -
        - - - - - - - - - - - - -
        - - - - - - - - - - - - -
        - - - - - - - - - - - - -
        - - - - - - P - - - - - -
        - - - - - - - - - - - - -
        - - - - - - - - - - - - -
        - - - - - - - - - - - - -
        - - - - - - - - - - - - -
        - - - - - - - - - - - - -
        - - - - - - - - - - - - -

        Risk score = sum of weighted distances of all aliens within vision range
    */
    @Override
    public void setAbilityPoints( float[] abilities ) {
        abilities[3] = 10;
    }

    @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

        Move bestMove=Move.STAY;
        int bestRiskScore=10000;
        int riskScore=0;
        ArrayList<Point> aliens = new ArrayList<Point>();

        //generate alien list
        for (int x=0; x<=vision*2; x++) {
            for(int y=0; y<=vision*2; y++){
                if(x==vision && y==vision) continue;
                if(fields[x][y]=='A'){
                    aliens.add(new Point(x,y));
                }
            }
        }

        for (Move move : Move.values()) {
            int x = vision + move.getXOffset();
            int y = vision + move.getYOffset();
            riskScore = 0;

            for(Point alienCoord : aliens){
                riskScore += this.getDistance(x, y, alienCoord);
            }

            if(riskScore < bestRiskScore){
                bestRiskScore = riskScore;
                bestMove = move;
            }
        }

        return bestMove;
    }

    @Override
    public boolean wantToFight( int[] enemyAbilities ) {
        //I don't want to fight :(
        return false;
    }

    //Return weighted distance (more weight for near opponents)
    private int getDistance(int x, int y, Point to){
        int xDist = Math.abs(x-(int)to.getX());
        int yDist = Math.abs(y-(int)to.getY());
        int numberOfMovesAway = Math.max(xDist, yDist);

        if(numberOfMovesAway==0){
            return 1000;
        }
        else if(numberOfMovesAway==1){
            return 100;
        }
        else if(numberOfMovesAway==2){
            return 25;
        }
        else{
            return 6-numberOfMovesAway;
        }
    }
}

2
ভাল লাগছে! তবে দয়া করে আপনার মুদ্রণ-বিবৃতিগুলি বের করুন, আমি প্রতিযোগিতাটি চালানোর সময় তারা আমাকে বিভ্রান্ত করবে।
কমনগ্যুই

ওহ, আমি মুদ্রণ বিবৃতি ছেড়ে? আমি পরে এগুলি পরিবর্তন করব। হা হা। এছাড়াও এটি এখনও চূড়ান্ত নয়। এই মুহুর্তে, প্রিডিকওয়ার্ড চুষছে। তার এলিয়েন চুরির অ্যালগরিদম শিগগিরই উন্নত হবে। :) সম্পাদনা: যিনি মুদ্রণ বিবৃতি মুছে ফেলা হয়েছে তার জন্য ধন্যবাদ। : ডি (জোপ?)
গ্যাব্রিয়েল

সম্পাদনা: প্রিডিকোয়ার্ডগুলি গতকাল যে অদ্ভুত সামান্য প্রতিযোগিতামূলক ভবিষ্যদ্বাণী ছিল তার চেয়ে পালিয়ে যাওয়ার ক্ষেত্রে এখন আরও ভাল। > :)
গ্যাব্রিয়েল

ট্রিভিয়া: এটি আমার প্রিয় প্রিডিকাট <3
মার্ক গ্যাব্রিয়েল

4

প্রেডিকেট আইস (মিয়া)

প্রেডিকেটস এর একটি প্রজাতি যার তুলনামূলক তুলনায় তীক্ষ্ণ দৃষ্টি রয়েছে যা এটি তার শত্রুদের উপর ভালভাবে ঝাঁকুনির অনুমতি দেয়।

সম্পাদনা: নতুন লক্ষ্য অগ্রাধিকার

package alien;

import planet.Move;

/* Predict + Cat = Predicat! */
public class PredicatEyes extends Alien {
    private static final int LIF=0, STR=1, DEF=2, VIS=3;
    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] = 4.5f;
        abilities[VIS] = 1;
    }

    @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' : 
                return move;
            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.getRandom();
        }

    }
}

3

ক্রপ সার্কেল এলিয়েন

চারিদিকে অনির্দিষ্টকালের জন্য চেনাশোনাগুলি, এবং কখনও লড়াই করতে চায় না, তিনি ফসলের সেরিল তৈরি করে খুশি। তবে, আপনি যদি সত্যিই লড়াই করতে চান, তবে তিনি আপনাকে ছুঁড়ে মারবেন।

package alien;

import planet.Move;

public class CropCircleAlien extends Alien {

    private int i = 0;

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

    @Override
    public Move move(char[][] fields) {
        switch (getI()) {
        case 0:
            setI(getI() + 1);
            return Move.EAST;
        case 1:
            setI(getI() + 1);
            return Move.SOUTHEAST;
        case 2:
            setI(getI() + 1);
            return Move.SOUTH;
        case 3:
            setI(getI() + 1);
            return Move.SOUTHWEST;
        case 4:
            setI(getI() + 1);
            return Move.WEST;
        case 5:
            setI(getI() + 1);
            return Move.NORTHWEST;
        case 6:
            setI(getI() + 1);
            return Move.NORTH;
        case 7:
            setI(getI() + 1);
            return Move.NORTHEAST;
        default:
            return Move.STAY;
        }
    }

    @Override
    public boolean wantToFight(int[] enemyAbilities) {
        return false;
    }

    public void setI(int i) {
        if (i < 8) {
            this.i = i;
        } else {
            this.i = 0;
        }
    }

    public int getI() {
        return this.i;
    }
}

2
আপনি মুভের মাধ্যমে পুনরাবৃত্তি করলে এটি পরিষ্কার হবে।
চার্লস

4
কেন যে পরিবর্তন করবেন getI()করতে iকেবল অপসারণ getI()? এছাড়াও আপনি পরিবর্তন হতে পারে setI(int i)জন্য this.i = i % 8;এবং যেহেতু আপনি শুধুমাত্র যে এক জায়গায় এটি ব্যবহার, শুধু প্রতিটি কলের পরিবর্তন করতে setI(getI() + 1)করতেi = (i + 1) % 8;
জাস্টিন

3

CleverAlien

চতুর এলিয়েন কেবল তার ইচ্ছার উপরে নির্ভর করে। তিনি এলোমেলোভাবে ঘোরাঘুরি করেন, এবং এলোমেলোভাবে লড়াইয়ের সিদ্ধান্ত নেন। তিনি আশা করেন যে তিনি ভাগ্য দিয়ে তার শত্রুদের পরাস্ত করতে সক্ষম হবেন। (আমার যদি কোনও সিনট্যাক্স ত্রুটি থাকে তবে আমাকে ক্ষমা করুন, আমি জাভা লোক নই)

package alien;

import planet.Move;

public class CleverAlien extends Alien {

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

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

public boolean wantToFight(int[] enemyAbilities) {
    //same order of array as in setAbilityPoints, but without cleverness
    int tmp = (int) ( Math.random() * 2 + 1);
    return tmp == 1;
    }
}

8
tmp == 1 ? true : false? কেন হবে না (tmp == 1) == true ? true : false? ;) (ইঙ্গিত: এটি হিসাবে একই মাত্র tmp == 1 )।
মার্টিন Ender

3

দুর্বৃত্ত

অন্যরা যেমন বলেছে, আমি কিছুটা theগলের আন্দোলনটি ব্যবহার করছি। একটি বিজয়ী এলিয়েন করার চেষ্টা করার পরিবর্তে (আমার সেরা ধারণা ইতিমধ্যে ডি নেওয়া হয়েছিল :), আমি কিছু চরিত্রের সাথে একটি বিদেশী করার সিদ্ধান্ত নিয়েছি! আমার এলিয়েন একটি ভাড়াটে বন্দুক, যা ভিনগ্রহের যুদ্ধ থেকে অবহেলিত, এবং কেবল এই গ্রহে কেবল সেই নোংরা মানুষকে শিকার করার জন্য, যিনি তার মৃত্যুর কাঠির onণ থেকে বেরিয়ে এসেছেন। আমার পরকীয়া মানুষের জন্য গ্রহটি অনুসন্ধান করবে এবং তাকে হত্যা না করে মানুষের পিছনে অনুসরণ করবে। একবার তার কাছাকাছি এলিয়েনকে দেখা গেলে তিনি দ্রুত মানবকে হত্যা করার চেষ্টা করবেন এবং তার সম্পূর্ণ কাজটি থেকে "তার ভাগ্য" নিয়ে এই নতুন শত্রুর বিরুদ্ধে মুখোমুখি হবেন।

package alien;

import planet.Move;

public class Rogue extends Alien {

    private int threatPresent = 0;
    private int turnNorth = 0;

    public void setAbilityPoints(float[] abilities) {
        abilities[0] = 3;
        abilities[1] = 6;
        abilities[2] = 0;
        abilities[3] = 1;
        abilities[4] = 0;
    }

    public Move move(char[][] fields) {
        int vision = getVisionFieldsCount();
        char me = fields[vision][vision];
        int humanPresent = 0;            
        //This way, if there is no alien near, the current threat will not trigger attacking
        int isThereCurrThreat = 0;
        Move bestMove = Move.STAY;
        for (Move move : Move.values()) {
            for (int i = 1; i <= vision; i++) {
                int fieldX = vision + (i * move.getXOffset());
                int fieldY = vision + (i * move.getYOffset());
                if (fields[fieldX][fieldY] == 'A') {
                    isThereCurrThreat = 1;
                }

                if (fields[fieldX][fieldY] == 'T') {
                    humanPresent = 1;
                    //Turtles are basically dumb humans, right?
                }

                if (fields[fieldX][fieldY] == 'H') {
                    humanPresent = 1;
                }
            }

            //Alway follow that filthy human
            if (humanPresent == 1) {
                bestMove = move;
            }

           }

         if(humanPresent == 0) {
             //Alternate moving north and east towards the human
             //If I hit the edge of world, I search for the turtle as well
             if(turnNorth == 1) {
                bestMove = Move.NORTH;
                turnNorth = 0;
             }

             else {
                bestMove = Move.EAST;
                turnNorth = 1;
             }
         }

      //If a threat was found, attack accordingly.
      threatPresent = isThereCurrThreat;
      return bestMove;

    }

  public boolean wantToFight(int[] enemyAbilities) {
      //Only fight if another enemey is near
      if (threatPresent == 1) {
        return true;
        }

      else {
        return false;
      }
   }
}

কোডটি এই ধারণাটিকে কেন্দ্র করে তৈরি করা হয়েছে যে মানুষের দিকে আমার স্প্রিন্ট করা উচিত। একবার আমি তাকে মারলাম, তারপরে আমি দক্ষিণ-পশ্চিমে জড়িয়ে পড়ি, যেখানে আমি কচ্ছপের সন্ধান করব।

সম্পাদনা: ওহ, এবং কচ্ছপের জিনিস সম্পর্কে ... আমার এলিয়েন তাদের পছন্দ করে না, সুতরাং এটি আপনারা সম্পূর্ণ ক্যানন।


ঠিক বুঝতে পারলাম আমি কচ্ছপের দিকেও ছিটকে পড়তে পারি। কে উচ্চ ডজ দুর্বৃত্তদের পছন্দ করে না?
ব্যবহারকারী 3334871

2
জাভা 8 এর ব্লক অংশ যদি সরাসরি বুলিয়ান হিসাবে ইন্ট ব্যবহার করছে? কারণ এটি আমার মেশিনে মোটেই সংকলন করে না (জাভা 7)। ইঙ্গিত: হিউম্যানপ্রেস
সিকোরস্কি

হেক যদি আমি জানি, আমার জাভা অভিজ্ঞতাটি বেশিরভাগ স্ক্রিপ্ট এবং কলেজ স্তরের শ্রেণিতে সীমাবদ্ধ ছিল। আমি কেবল তুলনা করব, ঠিক তেমন সবকিছুই পীচিযুক্ত। সতর্ক থাকুন জন্য ধন্যবাদ!
ব্যবহারকারী 3334871

এছাড়াও, @ সিকোর্স্কি, আপনি কি পরীক্ষাগুলি চালানোর জন্য আপনার নিজস্ব বা ডিএন ফাংশন তৈরি করেছেন? অথবা এটি কেবলমাত্র প্রদত্ত কোডের মাধ্যমেই করা যেতে পারে? আমি শপথ করছি, যেহেতু আমি সত্যিকারের জাভা পরিবেশে কোডিং করেছি, আমি জাভা কোড কার্যকর করার নিয়মগুলি ভুলে গেছি :(
ইউজার 3334871

গিথুব লিঙ্কে ওপি যে কোড দিয়েছে তা কেবল ডাউনলোড করুন না, অন্যান্য ক্লাস যুক্ত করুন এবং পরীক্ষা শুরু করুন। ওহ আপনাকে প্ল্যানেট ক্লাসে প্রতিটি এলিয়েন শ্রেণিতে প্রবেশ করতে হবে।
সিকোরস্কি

3

ক্র্যাশ অবতরণ করেছে এবং কেবল বেঁচে থাকার চেষ্টা করছে। এটি বেশিরভাগই তত্পরতা এবং বুদ্ধিমত্তার দ্বারা বেঁচে থাকে এবং লড়াইয়ের শুরু করা উচিত কি না তা যত্ন সহকারে বিবেচনা করে প্রতিটি দাগ গণনা করে। বেঁচে থাকা কেবল শিকার শুরু করে এবং তাদের বড় বড় অস্ত্র দিয়ে অন্য সমস্ত এলিয়েনকে এড়াতে চাইছিল তবে আরও সাহসী হওয়ায় তাদের পিছনে যেতে শুরু করতে পারে। সত্যিই যখন এটি চলে যায় তখন কে কার মুখোমুখি হয় তা চিন্তা করে না।

package alien;

import planet.Move;

public class Survivor extends Alien {

    private int boldness = 0;
    private float life = 0;
    private float str = 1;
    private float def = 4;
    private float clever = 10 - life - str - def;

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

    public Move move(char[][] fields) {
        //you are in the middle of the fields, say fields[getVisionFieldsCount()][getVisionFieldsCount()]
        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':
                    if(boldness < 10)
                        danger++;
                    else
                        danger--;
                    break;
                case ' ':
                    break;
                default:
                    danger-=2;
            }
        }
        if (danger < leastDanger) {
            bestMove = move;
            leastDanger = danger;
        }
    }
    return bestMove;
    }

    public boolean wantToFight(int[] enemyAbilities) {
        //same order of array as in setAbilityPoints, but without cleverness
        bool fight = boldness < 50;//After 50 fights, believes self unstoppable            
        int huntable = 0;
        for(int ability : enemyAbilities){
            if(ability == 1)
                huntable++;
        }
        if(huntable >= 3){
             fight = true;
        }//if at least 3 of the visible stats are 1 then consider this prey and attack
        else if((float)enemyAbilities[1] / (float)getDefenseLvl() <= (float)getStrengthLvl() + (float)(getClevernessLvl() % 10) / (float)enemyAbilities[2] && enemyAbilities[0] / 5 < getLifeLvl() / 5)
            fight = true;//If I fancy my odds of coming out on top, float division for chance
        if(fight){//Count every scar
            boldness++;//get more bold with every battle
            life += enemyAbilities[0] / 5;
            str += enemyAbilities[1] / 5;
            def += enemyAbilities[2] / 5;
            clever += (10 - (enemyAbilities[0] + enemyAbilities[1] + enemyAbilities[2] + enemyAbilities[3] - 4)) / 5;//count the human cleverness attained or the enemies who buffed clever early
        }
        return fight;
    }

}

1
আমি নিশ্চিত যে for(int ability in enemyAbilities){এটি একটি সিনট্যাক্স ত্রুটি - চেষ্টা করুনfor(int ability : enemyAbilities){
জোশুয়া

3

FunkyBob

প্রথম অগ্রাধিকার বেঁচে থাকা, অন্যথায় কিছু শিকার খোঁজার চেষ্টা করবে। সর্বাধিক হুমকী বা সর্বাধিক শিকার সহ সাধারণ দিকনির্দেশের জন্য দৃশ্যমান অঞ্চলটি মূল্যায়ন করে। আমার পরীক্ষার সময় বেঁচে থাকার হার প্রায় 85-90% বলে মনে হয়।

package alien;
import planet.Move;

public class FunkyBob extends Alien {
    public void setAbilityPoints(float[] abilities) {
        abilities[0] = 2.5f;
        abilities[1] = 5.5f;
        abilities[3] = 2;
    }

    private int QtyInRange(char[][] fields, int x, int y, int numStepsOut, char specie)
    {
        int count = 0;
        for(int i = numStepsOut * -1; i <= numStepsOut; i++)
            for(int j = numStepsOut * -1; j <= numStepsOut; j++)
                if(fields[x+i][y+j] == specie)
                    count++;
        return count;
    }

    private int AssessSquare(char[][] fields, int x, int y, int visibility){
        int score = 0;

        for(int i = 0; i <= visibility; i++)
        {
            score += (-1000 / (i == 0 ? 0.3 : i)) * QtyInRange(fields, x, y, i, 'A');
            score += (100 / (i == 0 ? 0.3 : i)) * QtyInRange(fields, x, y, i, 'T');
            score += (100 / (i == 0 ? 0.3 : i)) * QtyInRange(fields, x, y, i, 'H');
            score += (100 / (i == 0 ? 0.3 : i)) * QtyInRange(fields, x, y, i, 'E');
            score += (50 / (i == 0 ? 0.3 : i)) * QtyInRange(fields, x, y, i, 'W');
            score += (50 / (i == 0 ? 0.3 : i)) * QtyInRange(fields, x, y, i, 'C');
        }

        return score;
    }

    public Move move(char[][] fields)   {
        int vision = getVisionFieldsCount();
        Move bestMove = Move.STAY;
        int bestMoveScore = AssessSquare(fields, vision, vision, vision - 1);

        for (Move move : Move.values()) {
            int squareScore = AssessSquare(fields, vision + move.getXOffset(), vision + move.getYOffset(), vision - 1);
            if(squareScore > bestMoveScore)
            {
                bestMoveScore = squareScore;
                bestMove = move;
            }

        }
        return bestMove;
    }

    public boolean wantToFight(int[] enemyAbilities)    {
        return ((getCurrentHp() + this.getStrengthLvl()) / 2) >
                ((enemyAbilities[0] * 3) + enemyAbilities[1]);
    }
}

3

FunkyJack

কেবল কিক্সের জন্য, কিছুটা ভিন্ন পদ্ধতির সাথে এখানে আরেকটি প্রবেশ। এই এক শুধুমাত্র মারামারি এড়ানো উপর দৃষ্টি নিবদ্ধ করা হয়। প্রথম কয়েক দফায় শত্রুদের দ্বারা ঘিরে থাকার কারণে এটি সত্যিকারের কার্যকর কৌশল নয়। 40% বর্গক্ষেত্র প্রথম দফায় দখল করা হয় যাতে গড়ে আপনি অবিলম্বে 3-4 শত্রুদের সাথে সংযুক্ত হন। তবে প্রাথমিক খালি স্কোয়ারগুলিকে প্রজাতির 2.5 গুনের চেয়ে 12.5 গুণ বৃদ্ধি করে যখন এটি বেঁচে থাকার গড় হার পায় 98.5%।

package alien;
import planet.Move;

public class FunkyJack extends Alien {
    public void setAbilityPoints(float[] abilities) {
        abilities[0] = 4.5f;
        abilities[1] = 1.5f;
        abilities[3] = 4;
    }

    private int QtyInRange(char[][] fields, int x, int y, int numStepsOut, char specie)
    {
        int count = 0;
        for(int i = numStepsOut * -1; i <= numStepsOut; i++)
            for(int j = numStepsOut * -1; j <= numStepsOut; j++)
                if(fields[x+i][y+j] == specie)
                    count++;
        return count;
    }

    private int AssessSquare(char[][] fields, int x, int y, int visibility, int prevScore){
        int score = 0;
        score += -10000 * QtyInRange(fields, x, y, visibility, 'A');                
        if(visibility > 0)
            score = AssessSquare(fields, x, y, visibility - 1, ((score + prevScore) / 5));
        else
            score += prevScore;

        return score;
    }

    public Move move(char[][] fields)   {
        int vision = getVisionFieldsCount();
        Move bestMove = Move.STAY;
        int bestMoveScore = AssessSquare(fields, vision, vision, vision - 1, 0);

        for (Move move : Move.values()) {
            int squareScore = AssessSquare(fields, vision + move.getXOffset(), vision + move.getYOffset(), vision - 1, 0);
            if(squareScore > bestMoveScore)
            {
                bestMoveScore = squareScore;
                bestMove = move;
            }
        }
        return bestMove;
    }

    public boolean wantToFight(int[] enemyAbilities)    {
        return false;
    }
}

1
98.5% অপরিসীম। এমনকি আমার ভবিষ্যদ্বাণীগুলি গড়ে প্রায় 65% বেঁচে থাকার হার পান। হা হা। সম্পাদনা করুন: আমার ভবিষ্যদ্বাণীগুলিতে ফানকিজ্যাকের মতো একই দর্শন রয়েছে - কেবল দূরে থাকুন। আমার কাছে যদিও 10 ভিশন এবং 0 টি লড়াইয়ের পরিসংখ্যান রয়েছে।
মার্ক গ্যাব্রিয়েল

3

LazyBee

আমি একটি চতুর মৌমাছির বর্গ তৈরির চেষ্টা শুরু করেছিলাম যা প্যাটার্ন আন্দোলন এবং কর্তনমূলক যুক্তি ব্যবহার করে, তবে তখন আমার ঘুম আসে, তাই আমি এর নাম রাখলাম লাজিবি এবং এটিকে একটি রাত বলেছিলাম। তিনি আসলে আমার পরীক্ষাগুলিতে বেশ ভাল পারফরম্যান্স করছেন বলে মনে হচ্ছে (গিথাবের এলিয়েনদের সাথে গড়ে ~ 1645)।

package alien;

import planet.Move;
public class LazyBee extends Alien{

    private static final int LIFE = 0;
    private static final int STRENGTH = 1;

    // Ran trials to figure out what stats were doing  best in sims
    // Lazily assumed that:
        // - Defense is negligeble compared to health
        // - Vision doesn't matter if I'm running east all the time
        // - Cleverness will be canceled out because dumb aliens (yum) won't care
            // and smart aliens probably account for it somehow
    public static float DARWINISM = 4.5f;
    public void setAbilityPoints(float[] abilities){
        abilities[LIFE] = DARWINISM;  
        abilities[STRENGTH] = 10f-DARWINISM;  
    }

    // If bananapeel is fine without trying to move cleverly, I probably am too
    public Move move(char[][] fields)
    {
        return Move.EAST; // This was giving me the best score of all arbitrary moves, for some reason
    }

    // inspired by ChooseYourBattles, tried to do some math, not sure if it worked
        // it seemed that Bee was doing better by being more selective
        // not accounting for cleverness because eh
    public boolean wantToFight(int[] enemyAbilities){
        // chance of hit (h) = (1-(1/((50/deflvl)+1)))) = 50/(deflvl+50)
        double my_h = 50.0/(this.getDefenseLvl() + 50), 
                their_h = (50.0 - enemyAbilities[STRENGTH])/50.0;
        // expected damage (d) = h * (strlvl+1)
        double my_d = /* long and thick */ my_h * (this.getStrengthLvl() + 1),
                their_d = their_h * (enemyAbilities[STRENGTH]); 
        // turns to die (t) = currhp / d
        double my_t = (this.getCurrentHp() / their_d),
                their_t = ((enemyAbilities[LIFE] * 5 + 10) / my_d); // Assume they're at full health because eh
        // worth it (w) = i outlast them by a decent number of turns
            // = my_t - their_t > threshold
            // threshold = 4.5
        boolean w = my_t - their_t > 4.5;

        return w;
    }
}

1
চমৎকার কাজ! আমি খুব অবাক হয়েছি আপনি হার্ডকডযুক্ত দিক দিয়ে এত ভাল স্কোর করেছেন।
মাইকেল

@ মিশেল আপনার জানা নেই যে আমি যখন খুঁজে পেলাম তখন আমি কতটা আনন্দিতভাবে অবাক হয়েছিল! আমি মুভমেন্ট মুভিতে প্রচুর প্রচেষ্টা করেছি, তারপরে আমি এটি হোল্ডের বিরুদ্ধে একধরনের নিয়ন্ত্রণ গ্রুপ হিসাবে দৌড়াতে পেরেছিলাম। তখন আমি বুঝতে পারি কন্ট্রোল গ্রুপটি লাথি মারছে, তাই আমি অলসতার বিভিন্ন শেডের সাথে পরীক্ষা শুরু করলাম!
থিস্টিস্টোফার

3

নতুন লোক

প্রারম্ভিক কৃষিকাজের জন্য "সহজ" লক্ষ্যগুলিকে জড়িত করার চেষ্টা করে। অন্যথায়, কেবল বিক্ষিপ্তভাবে সরান।

package alien;

import planet.Move;

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

    public void setAbilityPoints(float[] abilities) {
        abilities[LIFE] = 5;
        abilities[STR] = 5;
    }

    public Move move(char[][] fields) {
        // Very rudimentary movement pattern. Tries to engage all "easy" peaceful aliens.
        // Programmer got lazy, so he doesn't run away from danger, decreasing his odds of survival.
        // Afterall, if his species dies, that's one fewer specie that humans have to contend with.

        int vision = getVisionFieldsCount(); //count of fields / middle
        char me = fields[vision][vision]; //middle of fields
        for (Move move : Move.values()) {
            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());
                char alienType = fields[fieldX][fieldY];

                if (alienType == 'E' || alienType == 'H' || alienType == 'T' || alienType == 'W') {
                    return move;
                }
            }
        }

        return Move.getRandom();
    }

    public boolean wantToFight(int[] enemyAbilities) {
        if (isWhale(enemyAbilities)) {
            return true;
        } else if (isCow(enemyAbilities)) {
            return false; // Cows hit hard!
        } else if (isTurtle(enemyAbilities)) {
            return true;
        } else if (isEagle(enemyAbilities)) {
            return true;
        } else if (isHuman(enemyAbilities)) {
            if (enemyAbilities[STR] < 3) {
                return true;
            }
        }

        return false;
    }

    public boolean isWhale(int[] enemyAbilities) {
        return enemyAbilities[LIFE] == 10 && totalAbilityPoints(enemyAbilities) == 10;
    }

    public boolean isCow(int[] enemyAbilities) {
        return enemyAbilities[STR] == 10 && totalAbilityPoints(enemyAbilities) == 10;
    }

    public boolean isTurtle(int[] enemyAbilities) {
        return enemyAbilities[DEF] == 10 && totalAbilityPoints(enemyAbilities) == 10;
    }

    public boolean isEagle(int[] enemyAbilities) {
        return enemyAbilities[VIS] == 10 && totalAbilityPoints(enemyAbilities) == 10;
    }

    public boolean isHuman(int[] enemyAbilities) {
        return !(isWhale(enemyAbilities) || isCow(enemyAbilities) || isTurtle(enemyAbilities)) && totalAbilityPoints(enemyAbilities) >= 10;
    }

    public int totalAbilityPoints(int[] enemyAbilities) {
        return enemyAbilities[LIFE] + enemyAbilities[STR] + enemyAbilities[DEF] + enemyAbilities[VIS];
    }
}

শর্তের return true;কারণে সেই ভাসমান রেখাটি অতিরিক্তহীন বলে মনে হচ্ছে else
কাইল কানোজ

পছন্দ করুন ইস্যু সম্বোধন।
ফ্রিএএসআইনবিয়ার

আপনার isman () পরীক্ষাটি বেশ সঠিক দেখাচ্ছে না। সমান স্তরযুক্ত এলিয়েনও কি খুঁজে পাবে না?
চার্লস

@ চার্লস আপনি ঠিক বলেছেন 'চতুরতা' যান্ত্রিক যেভাবে কাজ করে এবং যে লড়াইয়ের জিজ্ঞাসার সময় আমরা চতুরতা নির্ধারণ করতে পারি না তার কারণে শত্রু হিউম্যান, বা একটি সমতল বিদেশী কিনা তা খুঁজে পাওয়া কঠিন (অসম্ভব?)? এমনকি কিছু মৌলিক গণিত ব্যবহার করেও এটি সম্ভবত একজন মানুষ কিনা ভুল হবে না এ সম্পর্কে সম্ভবত একটি শিক্ষিত অনুমান। আমার ধারণা আমি তাকে বদলে দেব মানুষের কাছ থেকে পালানোর জন্য।
ফ্রিএএসআইনবিয়ার

আপনার ইস্পেসি-পরীক্ষাগুলি দেখতে দুর্দান্ত লাগছে, তবে এমনকি লড়াইয়ের শিকার এবং শীঘ্রই এই পরীক্ষাগুলি ব্যর্থ হবে ...
কমনগ্যু

2

পাহারা

জীবন, বাফ শক্তি এবং প্রতিরক্ষা স্ট্যাক, তারপরে রাখুন। প্রতিপক্ষকে আক্রমণাত্মক বলে মনে হলেই আক্রমণ করুন ( strength2 এর চেয়ে বেশি হিসাবে সংজ্ঞায়িত ):

public class Guard extends Alien{
    public void setAbilityPoints(float[] abilities){
        abilities[0] = 6;  // life
        abilities[1] = 2;  // str
        abilities[2] = 2;  // def
        abilities[3] = 0;  // vis
        abilities[4] = 0;  // clv
    }

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

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

2

বুলি এলিয়েন

বুলি এলিয়েন শত্রুদের উপেক্ষা করার সময় অবধি ঘুরে বেড়াবেন যতক্ষণ না তিনি কারও সাথে জগতে দুর্বল হন।

package alien;

import planet.Move;

public class BullyAlien extends Alien {

    @Override
    public void setAbilityPoints(float[] abilities) {
        abilities[0] = 2;
        abilities[1] = 8;
        abilities[2] = 0;
        abilities[3] = 0;
        abilities[4] = 0;
    }

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

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

2
ওহ, বোকা এলিয়েন কেবল বন্ধু হতে চায়।
ব্যবহারকারী 3334871

3
@ ব্যবহারকারী 3334871 আরও পছন্দ করুন: "বুলি এলিয়েন কেবল একটি সিনট্যাক্স ত্রুটি থাকতে চায়"
জাস্টিন

টোফাইটকে শত্রুদের ক্ষমতার দিকে নজর দেওয়া উচিত নয়?
ইনগো বার্ক

@ ইনগোবার্ক এটি ইতিমধ্যে আপনার মন্তব্য করার সময় দিয়েছিল
উইলিয়াম বার্বোসা

থ্রেডের মাধ্যমে স্ক্রোল করতে অবশ্যই আমাকে অনেক বেশি সময় নিয়েছে। :)
ইনগো বার্ক

2

BlindBully

কে বা এর চারপাশে কী আছে তা যত্নশীল করে না, কেবল সিদ্ধান্ত নেওয়ার চেষ্টা করে যে এই মুহূর্তে যে এলিয়েনের মুখোমুখি হচ্ছে এটি নিজের চেয়ে শক্তিশালী বা দুর্বল কিনা এবং যারা দুর্বল তাদের আক্রমণ করে।

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

public class BlindBully extends Alien {

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

    private Random rand = new Random();

    @Override
    public void setAbilityPoints(float[] abilities) {
        abilities[LIFE] = 6;
        abilities[STRENGTH] = 2;
        abilities[DEFENSE] = 2;
        abilities[VISION] = 0;
        abilities[CLEVERNESS] = 0;
    }

    @Override
    public Move move(char[][] fields) {
        // Go west! To meet interesting people, and kill them
        switch (rand.nextInt(3)) {
            case 0:
                return Move.NORTHWEST;
            case 1:
                return Move.SOUTHWEST;
            default:
                return Move.WEST;
        }
    }

    @Override
    public boolean wantToFight(int[] enemyAbilities) {
        int myFightRating = getLifeLvl() + getStrengthLvl() + getDefenseLvl();
        int enemyFightRating = enemyAbilities[LIFE] + enemyAbilities[STRENGTH] + enemyAbilities[DEFENSE];
        return myFightRating >= enemyFightRating;
    }

}

2

SecretWeapon2

package alien;

import planet.Move;

/**
 * Created by Vaibhav on 02/07/14.
 */
public class SecretWeapon2 extends Alien {

   private final static byte LIFE=0, STR=1, DEF=2, VIS=3, CLV=4;

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

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

public boolean wantToFight(int[] enemyAbilities)    {

    return enemyAbilities[1] < 4;
  }
}

তাহলে এই সেরা? হাহা
justhalf
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.