জল বেলুন যুদ্ধসমূহ


12

এই কিং-অফ-হিলি খেলাটি একটি কৌশল খেলা যা আপনাকে অবশ্যই একটি জলের বেলুনের চারপাশে নিক্ষেপ করতে হবে এবং জলে ছড়িয়ে পড়া এড়াতে হবে। সর্বাধিক পয়েন্ট অর্জন লক্ষ্য। আপনাকে মাঠের একটি মানচিত্র এবং জলের বেলুনের অবস্থান দেওয়া হবে। আপনি হয় প্রত্যাবর্তন করতে পারেন যে আপনি জলের বেলুনটি (যদি আপনি যথেষ্ট কাছাকাছি থাকলে) কোনও নির্দিষ্ট দিকে আঘাত করতে চান বা আপনি কোনও নির্দিষ্ট দিকে যেতে চান।

বিশেষত: জলের বেলুনটি (0, 0)30 ইউনিট উচ্চ এবং ড্রপ থেকে শুরু হবে । যদি জলের বেলুনটি মাটিতে আঘাত করে তবে একজন খেলোয়াড় এলোমেলোভাবে 4 পয়েন্ট হারাতে বেছে নেওয়া হবে, যারা বেলুনের কাছাকাছি তাদের আরও বেশি ওজন দেওয়া হবে। তদতিরিক্ত, যে প্লেয়ারটি সর্বশেষে বেলুনটি আঘাত করেছে এটি 3 পয়েন্ট অর্জন করবে। অতএব, আপনি যদি সরাসরি বেলুনটি আঘাত করেন তবে আপনি সম্ভবত 1 পয়েন্ট হারাবেন।

আপনি প্রসারিত একটি ক্লাস লিখবেন Player। আপনার কনস্ট্রাক্টর প্রয়োগ করতে হবে। নির্মাতা দেখতে পাবেন:

public Player1() {
    super(/* Some numbers */ 3, 3, 4)
}

এই সংখ্যাগুলি doubleএস। প্রথম সংখ্যাটি প্লেয়ারের গতির প্রতিনিধিত্ব করে, দ্বিতীয়টি শক্তিটিকে উপস্থাপন করে এবং তৃতীয়টি ভাগ্যের প্রতিনিধিত্ব করে। সংখ্যাগুলি অবশ্যই 10 বা তার বেশি যোগ করতে হবে এবং কোনও সংখ্যা শূন্যের চেয়ে কম বা সমান হতে পারে না ।

দ্বিতীয়ত, আপনাকে অবশ্যই moveপদ্ধতিটি প্রয়োগ করতে হবে । এটি একটি উদাহরণ moveপদ্ধতি:

@Override
protected Action move(Map<Player, Point2D> map, Balloon b) {
    // Get my own location
    Point2D myself = map.get(this);
    // If I'm close enough to the balloon
    // then hit the balloon
    if (myself.distanceSq(b.getLocation()) <= 16) {
        double d = (r.nextDouble() - 0.5) * 3;
        // Random y direction, z direction is what's left 
        return new Hit(0, d, Math.sqrt(9 - d*d));
    } else {
        double diffX = b.getLocation().getX() - myself.getX(),
                diffY = b.getLocation().getY() - myself.getY();
        // Move towards the balloon
        return new Movement(Math.signum(diffX)*3/Math.sqrt(2), Math.signum(diffY)*3/Math.sqrt(2));
    }
}

এখানে বেশ কয়েকটি গুরুত্বপূর্ণ বিষয় রয়েছে। প্রথমে লক্ষ্য করুন যে ক্ষেত্রটি a হিসাবে উত্তীর্ণ হয়েছে Map<Player, Point2D>। ক্ষেত্রটি অসীম - আপনি কতদূর যেতে পারবেন তার সীমা নেই। এটি 2-মাত্রিক অ্যারে বা এর মতো কিছু নয়। তদতিরিক্ত, এর অর্থ হ'ল আপনার অবস্থান হিসাবে আপনার অ-পূর্ণসংখ্যা স্থানাঙ্ক হবে। এটা পুরোপুরি ঠিক আছে।

আরেকটি পরিণতি হ'ল প্লেয়ার এবং বেলুনটি ওভারল্যাপ হতে পারে। আসলে দুই খেলোয়াড় হুবহু একই জায়গায় থাকতে পারে!

বেলুনের একটি নির্দিষ্ট বেগ এবং দিক রয়েছে। সাধারণভাবে, এটি 3 ইউনিট / পদক্ষেপের হারে নেমে আসবে। এটি একটি xদিক এবং yদিকের দিকেও অগ্রসর হয় । আপনি যখন ফিরে আসেন Hit, আপনি বেলুনটি চাপছেন এমন x, y এবং z দিকগুলি পাস করুন। আপনি একটি বেলুন আপনি (মাত্র দুটি মাত্রা দিকে) থেকে যার উচ্চতা 10 থেকে বড় বা কার দূরত্ব 4. বেশি অতিরিক্ত মারতে পারেন না, যদি সত্যি যে x^2 + y^2 + z^2 > s^2যেখানে sআপনার শক্তি, এবং x, yএবং zনির্দেশাবলী যে তোমাকে আঘাত দ্বারা , আপনার ক্রিয়াটি বাতিল করা হয়েছে। আপনার হিটের শক্তিটি এলোমেলো সংখ্যার মধ্যে 0এবং এর মধ্য দিয়ে প্রশস্ত হয় luck(যার অর্থ আপনার ভাগ্য কম থাকলে এটি নামতে পারে)।

একইভাবে, আপনি যদি একটি আসতে পারেন Movementসঙ্গে xএবং yস্থানাঙ্ক যে আপনি (মনে রাখবেন আপনি বাতাসে লাফ করা যাবে না) সরিয়ে নিয়ে যাচ্ছি। যদি আপনার গতি x^2 + y^2 > s^2কোথায় থাকে sতবে আপনার ক্রিয়াটি বাতিল করা হবে।

যদি জলের বেলুনটি মাটিতে আঘাত করে তবে একটি এলোমেলো খেলোয়াড় বেছে নেওয়া হয়, যাদের নিকটতম তাদের বেশি ওজন দেওয়া হয় - তবে যাদের ভাগ্য বেশি তাদের ওজনও কম থাকে। নির্বাচিত খেলোয়াড়টি 4 পয়েন্ট হারায়।

নিয়ামক: https://github.com/prakol16/water-balloon-wars/tree/master

গেমটি 1000 ধাপে স্থায়ী হয়। শেষে, একটি ফাইল কল হবে log.out। গেমটি দেখার জন্য এই ফ্রিডিতে ডেটা অনুলিপি করুন এবং আটকান: https://jsfiddle.net/prankol57/s2x776dt/e এমবেডড / রেজাল্ট /

বা আরও ভাল, এটি 3D তে দেখুন: http://www.brianmacintosh.com/waterballoonwars (বিএমএকে ধন্যবাদ)

100 এর পরে সর্বোচ্চ স্কোরের খেলোয়াড় (আরও বেশি হতে পারে তবে কম নয়) গেমস জিততে পারে।

আপনি যদি কোনও সমাধান জমা দিতে চান তবে আপনি https://github.com/prakol16/water-balloon-wars/tree/master- এ সত্যই নির্দিষ্ট বিশদটি পড়তে চাইতে পারেন ।

3/8 সম্পাদনা করুন :

এগুলি এখনকার চূড়ান্ত স্কোর (১ হাজার এবং ২ জন খেলোয়াড়কে বাদ দিয়ে 1000 পুনরাবৃত্তি)। আপনি যদি আপনার পোস্ট সম্পাদনা করেন, আপনি মন্তব্য করতে পারেন, এবং আমি স্কোরগুলি আবার করব:

{
    class players.BackAndForth=-75.343,
    class players.Hydrophobe=-0.800,
    class players.KeepAway=-53.064,
    class players.Weakling=39.432,
    class players.Repeller=21.238,
    class players.LuckyLoser=-30.055,
    class players.AngryPenguin=-49.310
}

বিজয়ীর Weaklingগড় ৩৯ পয়েন্ট ছিল। ২ য় স্থান ছিল Repeller২১ পয়েন্টের সাথে।


1
আপনি বেলুনটি আঘাত করলে কী হবে? কীভাবে চলবে? যদি একাধিক লোক এটি আঘাত করে?
কিথ র্যান্ডাল

জিসফিলের সাথে অ্যানিমেশনটি সত্যিই দুর্দান্ত!
কমনগ্যুই

যাইহোক, আপনার প্লেয়ার শ্রেণির চূড়ান্ত পদ্ধতিগুলি করা উচিত, অন্যথায় জমাগুলি সেগুলি ওভাররাইড করতে পারে।
কমনগ্যুই

2
আপনি বিপরীত speedএবং strengthপ্লেয়ার কনস্ট্রাক্টর মধ্যে।
থ্রাক্স

@ কিথরান্ডল দ্য dirX, dirYএবং dirZ(আপনার ভাগ্য দ্বারা প্রশস্ত) কেবল বেলুনের বেগগুলিতে যুক্ত করা হয়েছে। যদি একাধিক লোক এটি হিট করে (কিছুটা অসম্ভব) তবে প্লেয়ার যিনি তিন পয়েন্ট পেতে পারেন তার ভাগ্য সম্পর্কে সিদ্ধান্ত নেওয়া হয়েছে (নির্দিষ্ট বিবরণ দেখুন)
soktinpk

উত্তর:


7

সিমুলেটার

আমি আশা করি এটি ঠিক আছে, যেহেতু এটি আসলে কোনও প্রবেশ নয়। আমি ভিজ্যুয়াল সিমুলেটারের ধারণাটি সত্যিই পছন্দ করেছি এবং আমি নিজের তৈরি করতে চেয়েছিলাম যা একবারে (ফুল 3 ডি) সবকিছু দেখতে কিছুটা সহজ করে তুলবে।

2/28 9:06 AM PST : অনুসরণ নিয়ন্ত্রণ, রঙের সাথে আপডেট করুন

3/4 8:47 AM PST : সিমুলেশন গতির জন্য স্লাইডারের সাহায্যে আপডেট করুন এবং নতুন গেম শুরু করার ফলে পৃষ্ঠাটি রিফ্রেশ না করেই কাজ করা হবে (ক্যাশেড স্ক্রিপ্টটি পুনরায় লোড করতে Ctrl-F5 ব্যবহার করুন)

অনলাইন থ্রিজেএস ভিজ্যুয়ালাইজার

এখানে চিত্র বর্ণনা লিখুন


3
+1000 এটি আশ্চর্যজনক। আপনাকে ধন্যবাদ
soktinpk

আপনি কি Ctrl + F5 বলতে চাইছেন না, Shift + F5 নয়?
টিমটেক

দেখে মনে হচ্ছে ক্রোমে দুজনেই কাজ করে।
BMac

7

BackAndForth

এই বটটি কাছাকাছি যাওয়ার চেষ্টা করে এবং এর উচ্চতা খুব কম না হওয়া পর্যন্ত বেলুনটিকে আঘাত করে এবং এটি দূরে সরে যাওয়ার চেষ্টা করে।

package players;

import java.awt.geom.Point2D;
import java.util.Map;

import balloon.Action;
import balloon.Balloon;
import balloon.Player;
import balloon.Action.Hit;
import balloon.Action.Movement;

public class BackAndForth extends Player {

    static int round = 0;
    static int speed = 3;
    static int strength = 1;
    static boolean hit = false;
    static double previousHeight = 30.0;

    public BackAndForth() {
        super(speed, strength, 10 - speed - strength);
    }

    @Override
    protected Action move(Map<Player, Point2D> map, Balloon b) {

        round++;

        Point2D me = map.get(this);
        Point2D balloon = b.getLocation();

        double distanceX = balloon.getX() - me.getX();
        double distanceY = balloon.getY() - me.getY();
        double distance = Math.sqrt(Math.pow(distanceX, 2) + Math.pow(distanceY, 2));

        double maxX = speed * distanceX / distance;
        double maxY = speed * distanceY / distance;

        if (previousHeight < b.getHeight())
            hit = false;

        if (hit || b.getHeight() < 3) {
            previousHeight = b.getHeight();
            return new Movement(-maxX, -maxY);
        } else {
            if (distance < 4 && b.getHeight() < 10) {
                hit = true;
                return new Hit(0, 0, strength);
            } else {
                if (Math.pow(distance, 2) <= Math.pow(speed, 2)) {
                    return new Movement(distanceX, distanceY);
                } else {
                    return new Movement(maxX, maxY);
                }
            }
        }

    }

}

দেখে মনে হচ্ছে আপনার বট অবৈধ পদক্ষেপগুলি করে এবং এভাবে যখন কিছুই করে না তখন।
মোগি

@ সোক্তিনপেক আমি আমার জমাটি স্থির করেছি, এটি এখন আরও ভাল করা উচিত। ধন্যবাদ মোগিকেও!
থ্রাক্স

আমি এখনও খুঁজে পাচ্ছি যে আপনার বটটি যা সম্ভব তার বাইরে চলাফেরার জন্য জিজ্ঞাসা করছে। আমি আপনার পোস্টের একটি সম্পাদনা পর্যালোচনা জন্য রেখেছি। মূলত আপনি বেলুনের অবস্থানটিকে চলন হিসাবে ব্যবহার করছিলেন।
মুগি

@ মোগি ঠিক আছে, অনেক ধন্যবাদ!
থ্রাক্স

সাহায্য করে আনন্দ পেলাম. ইতিবাচক স্কোর পেতে আপনার বটটি বেশ ভাল। সাবাশ!
মুগি

5

AngryPenguin

এই পেঙ্গুইন রাগ করেছে কারণ সে বেলুন পর্যন্ত উড়তে পারে না, তাই সে তার চারপাশে দাঁড়িয়ে থাকা লোকদের মুখে বেলুনটি আঘাত করার চেষ্টা করে।

package players;

import java.awt.geom.Point2D;
import java.util.Map;
import java.util.Map.Entry;

import balloon.Action;
import balloon.Action.Hit;
import balloon.Action.Movement;
import balloon.Balloon;
import balloon.Player;

public class AngryPenguin extends Player {
    private static final double HIT_Z = 3;
    public AngryPenguin() {
        super(4, 4, 2);
    }

    @Override
    protected Action move(Map<Player, Point2D> map, Balloon balloon) {
        Point2D myself = map.get(this);

        double distanceX = balloon.getLocation().getX() - myself.getX();
        double distanceY = balloon.getLocation().getY() - myself.getY();
        double distance = Math.sqrt(Math.pow(distanceX, 2) + Math.pow(distanceY, 2));

        if (balloon.getHeight() < 2) {
            double[] xy = shrink(distanceX, distanceY, Math.pow(getSpeed(),2));
            return new Movement(-xy[0], -xy[1]);
        } else if (distance <= 4 && balloon.getHeight() <= 10) {
            double lowestDistance = Double.MAX_VALUE;
            Point2D nearestPlayerLoc = null;
            for (Entry<Player, Point2D> e : map.entrySet()) {
                if (e.getKey() != this) {
                    double d = e.getValue().distanceSq(myself);
                    if (d < lowestDistance) {
                        lowestDistance = d;
                        nearestPlayerLoc = e.getValue();
                    }
                }
            }
            double dX = nearestPlayerLoc.getX() - myself.getX();
            double dY = nearestPlayerLoc.getY() - myself.getY();
            double d = Math.pow(getStrength() - HIT_Z, 2);
            double[] xy = shrink(dX, dY, d);
            return new Hit(xy[0], xy[1], -HIT_Z);
        } else {
            double[] xy = shrink(distanceX, distanceY, Math.pow(Math.min(getSpeed(), distance), 2));
            return new Movement(xy[0], xy[1]);          
        }
    }

    private double[] shrink(double x, double y, double totalPow) {
        double[] xy = new double[2];
        double ratio = y == 0 ? 0 : 
                       x == 0 ? 1 : Math.abs(x) / Math.abs(y);
        if (ratio > 1)
            ratio = 1/ratio;
        xy[1] = totalPow * ratio;
        xy[0] = totalPow - xy[1];
        xy[0] = x < 0 ? -Math.sqrt(xy[0]) : Math.sqrt(xy[0]);
        xy[1] = y < 0 ? -Math.sqrt(xy[1]) : Math.sqrt(xy[1]);
        return xy;
    }

}

এটাই মারতে হবে।
কেভিন ওয়ার্কম্যান

5

কেবলরাম

এই বটটি কেবল বেলুনটিকে স্পর্শ করতে পারে কারণ এটি এতটা দুর্বল, পরিবর্তে এটি কেবল তার উচ্চ ভাগ্যের উপর নির্ভর করে। এটি লাকী লসারের অনুরূপ সম্পাদন করে (যা থেকে এই বটটি অনুপ্রাণিত হয়)।

তিনি রিপেলার সহ বর্তমান সমস্ত বটগুলি সম্পাদন করেছেন বলে মনে হয়।

package players;
import java.awt.geom.Point2D;
import java.util.Map;
import balloon.Action;
import balloon.Balloon;
import balloon.Player;
import balloon.Action.Hit;
import balloon.Action.Movement;

public class Weakling extends Player {

    static final private double STRENGTH = Double.MIN_VALUE;
    static final private double SPEED = 1.5;
    static final private double LUCK = 8.5;
    public Weakling() {
        super(SPEED,STRENGTH,LUCK);
    }

    protected Action move(Map<Player, Point2D> map, Balloon b) {
        Point2D start = map.get(this);
        Point2D balloon = b.getLocation();
        double distance = start.distance(balloon)+Double.MIN_VALUE;
        if(distance<=4 && b.getHeight()<=10){

            // just touch it :P
            return new Hit(0,0,0);
        }
        double x = start.getX()-balloon.getX();
        double y = start.getY()-balloon.getY();
        x /= distance;
        y /= distance;

        // move to directly underneath balloon
        x*=Math.min(SPEED, distance);
        y*=Math.min(SPEED, distance);
        return new Movement(-x, -y);
    }
}

সম্পাদনা: ভাগ্যের পক্ষে গতি কমেছে


3

Hydrophobe

এটি সম্ভাব্যতম সহজ বটগুলির মধ্যে একটি তবে এটি প্রতিযোগিতামূলক হিসাবে আমি এটি পোস্ট করব।

কৌশল: ভাল ... এই বটগুলি জল ঘৃণা করে তাই এটি কেবল চলে যায়।

যেহেতু বটটি খুব কমই স্প্ল্যাশ হবে এটি গড় 0 পয়েন্টের নিচে সামান্য স্কোর করবে। সমস্ত বটের স্কোরগুলির যোগফল হ'ল হাইড্রোফোব গড়ের চেয়েও বেশি স্কোর so

package players;
import java.awt.geom.Point2D;
import java.util.Map;
import balloon.*;

public class Hydrophobe extends Player {
    public Hydrophobe() {super(8, 1, 1);}
    @Override
    protected Action move(Map<Player, Point2D> map, Balloon balloon) {
        return new Action.Movement(5.65,5.65);
    }
}

3

দূরে থাকুন

এই প্লেয়ার দীর্ঘ তার উচ্চতা হিসাবে> 2. যত তাড়াতাড়ি এটা বেলুন মারতে পারেন, এটা বেলুন হিট হিসাবে বেলুন chases থেকে দূরে নিকটতম প্লেয়ার। যখন বেলুনের উচ্চতা <2 হয়, তখন এই প্লেয়ার পালিয়ে যায়।

package players;

import java.awt.geom.Point2D;
import java.util.Map;

import balloon.Action;
import balloon.Balloon;
import balloon.Player;
import balloon.Action.Hit;
import balloon.Action.Movement;

public class KeepAway extends Player{

    public KeepAway() {
        super(5, 3, 2);
    }

    @Override
    protected Action move(Map<Player, Point2D> map, Balloon b) {

        Point2D myself = map.get(this);

        //if balloon is high up, run towards it
        if(b.getHeight() > 2){
            Point2D closest = getClosestPlayer(map);

            boolean canHit = b.getHeight() <= 10 && myself.distance(b.getLocation()) <= 4;

            //hit it when you can
            if(canHit){

                Point2D normHit = normalize(new Point2D.Double(myself.getX() - closest.getX(), myself.getY() - closest.getY()));
                Point2D forceHit = new Point2D.Double(normHit.getX() * getStrength(), normHit.getY() * getStrength());

                return new Hit(forceHit.getX(), forceHit.getY(), 0);
            }
            //if you can't hit it, keep running towards it
            else {

                Point2D normRun = normalize(new Point2D.Double(myself.getX() - b.getLocation().getX(), myself.getY() - b.getLocation().getY()));
                Point2D forceRun = new Point2D.Double(-normRun.getX() * getSpeed(), -normRun.getY() * getSpeed());
                return new Movement(forceRun.getX(), forceRun.getY());
            }
        }
        //if the balloon is low, run away
        else{
            Point2D normRun = normalize(new Point2D.Double(myself.getX() - b.getLocation().getX(), myself.getY() - b.getLocation().getY()));
            Point2D forceRun = new Point2D.Double(normRun.getX() * getSpeed(), normRun.getY() * getSpeed());
            return new Movement(forceRun.getX(), forceRun.getY());
        }

    }

    private Point2D getClosestPlayer(Map<Player, Point2D> map){

        double minDistance = Double.MAX_VALUE;
        Point2D closestPoint = null;
        Point2D myPoint = map.get(this);

        for(Player p : map.keySet()){
            if(this != p){

                if(myPoint.distance(map.get(p)) < minDistance){
                    minDistance = myPoint.distance(map.get(p));
                    closestPoint = map.get(p);
                }
            }
        }

        return closestPoint;
    }

    private Point2D normalize(Point2D p){
        double d = p.distance(0, 0);

        if(d == 0){
            return new Point2D.Double(0, 0);
        }

        return new Point2D.Double(p.getX()/d, p.getY()/d);
    }

}

সম্পাদনা: আমি প্লেয়ার 1 এবং প্লেয়ার 2 এর সাথে খেলছিলাম included এই প্লেয়ারটি সেই ক্ষেত্রে জিততে পারে তবে আমি যখন তাদের বাইরে নিয়ে যাই তখন হেরে যায়। Booooo।


3

ভাগ্যবান হারানো

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

package players;
import java.awt.geom.Point2D;
import java.util.Map;

import balloon.Action;
import balloon.Balloon;
import balloon.Player;
import balloon.Action.Hit;
import balloon.Action.Movement;

public class LuckyLoser extends Player {
    public LuckyLoser() {
        super(1,1,8);
    }

    protected Action move(Map<Player, Point2D> map, Balloon b) {
        Point2D start = map.get(this);
        Point2D bLocation = b.getLocation();
        double distance = start.distance(bLocation);
        if(distance<=4){
            boolean foundMe = false;
            int numPlayersInRange=0;
            for(Point2D point:map.values()){
                if( !foundMe && point.equals(start))
                {
                    foundMe=true;
                    continue;
                }
                if(point.distance(bLocation)<=4)
                    numPlayersInRange++;                
            }
            if(numPlayersInRange>1)
                return new Hit(0,0,-1);
            else
                return new Hit(0,0,1);
        }
        double x = start.getX()-bLocation.getX();
        double y = start.getY()-bLocation.getY();
        x /= distance;
        y /= distance;
        return new Movement(-x, -y);
    }
}

সম্পাদনা: ফিক্সড মুভিং বাগ যা আমাকে বেলুনের দিকে না ফেলে দৌড়ে পালিয়েছে> _ <এখন আমি যদি সরাসরি আঘাত করতে না পারি তবে আমি সরাসরি বেলুনের দিকে ছুটে যাই।


3

মতও

এই বটটি নির্ভর করে কেবল একটি আসল পদক্ষেপ এবং তা হ'ল বেলুনটিকে নিজের থেকে দূরে সরিয়ে রাখা। অর্থাত্ বেলুনটি repells।

মনে হচ্ছে বর্তমান বটগুলির (লাকী লজার, অ্যাংরিপেনগুইন, হাইড্রোফোব, ব্যাকএন্ডফোর্ড) প্রায় সবসময়ই জয়ের বিপরীতে ভাল পারফরম্যান্স রয়েছে। তবে হাইড্রোফোব নিষ্ক্রিয় হয়ে সর্বদা জয়ের জন্য প্রস্তুত থাকে যদি অন্য বটগুলি সকলেই নেতিবাচক স্কোর অর্জন করতে পারে: পি

package players;
import java.awt.geom.Point2D;
import java.util.Map;

import balloon.Action;
import balloon.Balloon;
import balloon.Player;
import balloon.Action.Hit;
import balloon.Action.Movement;

public class Repeller extends Player {

    static final private double STRENGTH = 3.5;
    static final private double SPEED = 2.5;
    static final private double LUCK = 4;
    public Repeller() {
        super(SPEED,STRENGTH,LUCK);
    }

    protected Action move(Map<Player, Point2D> map, Balloon b) {
        Point2D start = map.get(this);
        Point2D balloon = b.getLocation();
        double distance = start.distance(balloon)+Double.MIN_VALUE;
        if(distance<=4 && b.getHeight()<=10){
            double x = start.getX()-balloon.getX();
            double y = start.getY()-balloon.getY();
            x /= distance;
            y /= distance;
            x*=STRENGTH;
            y*=STRENGTH;

            // push the balloon away with all our strength
            return new Hit(-x,-y,0);
        }
        double x = start.getX()-balloon.getX();
        double y = start.getY()-balloon.getY();
        x /= distance;
        y /= distance;

        // if we are directly underneath then move away from balloon
        distance=distance<1?-1:distance;

        // if we are just off of directly underneath then stay put
        distance=distance<2?0:distance;

        // move to the desired location
        x*=Math.min(SPEED, distance);
        y*=Math.min(SPEED, distance);
        return new Movement(-x, -y);
    }
}
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.