নিজের জন্য শেষ বুলেটটি সংরক্ষণ করুন


51

প্রতিযোগিতা এখন শেষ। কাপুরুষ বিজয়ী। আপনি এখানে শেষ ম্যাচটি দেখতে পারেন ।

হঠাৎ জম্বি হাজির! ওহ না!

এই কিং-অফ-হিলি চ্যালেঞ্জে আপনাকে জম্বি অ্যাপোক্যালাইপস থেকে বাঁচতে অবশ্যই একটি বট তৈরি করতে হবে। বা কমপক্ষে, যতদিন সম্ভব সম্ভব জন্য রাখা।

গেমের শুরুতে, প্রতিটি প্রবেশের 50 টি দৃষ্টান্ত এলোমেলোভাবে একটি বড় টরোডিয়াল প্লে অঞ্চলে স্থাপন করা হবে - এটি বর্গক্ষেত্র হিসাবে উপস্থিত বলে মনে হয় তবে চারপাশে মোড়ানো। খেলার ক্ষেত্রের আকারটি এন্ট্রিগুলির সংখ্যার উপর নির্ভর করে পরিবর্তিত হবে, তবে প্রাথমিকভাবে 6% স্কোয়ার দখল করা হবে। প্রতিটি প্রতিযোগী 3 টি বুলেট দিয়ে শুরু হয়।

প্রতিটি পালা শুরুতে, একটি জম্বি এলোমেলো স্থানে স্থল থেকে উঠবে এবং তার উপরে যা ছিল তা ধ্বংস করে দেবে। যে কোনও খেলোয়াড় তাদের পালা শুরুর শুরুতে একটি জম্বি পাশে থাকবে জম্বি হয়ে যাবে।

প্রতিটি জীবিত খেলোয়াড়ের জন্য, তাদের কোডটি তখন কল করা হবে। এটি একটি প্লেয়ার কনটেক্সট অবজেক্ট গ্রহণ করবে , যার বর্তমান অবস্থা এবং তাদের চারপাশের তথ্য রয়েছে। প্রতিটি খেলোয়াড় যে কোনও দিকে 8 স্কোয়ারের জন্য দেখতে পাবে।

খেলোয়াড়কে অবশ্যই চলন্ত বেছে নিতে হবে (এখনও স্থির থাকা একটি বৈধ আন্দোলন), একটি ফেরত Moveপাঠিয়ে অথবা নিকটস্থ কোনও ব্যক্তিকে বা জম্বিটিকে গুলি করে, একটি এনে দিয়ে Shoot। আপনার বন্দুকের সর্বাধিক 5 স্কোয়ার রয়েছে। যেহেতু আপনি আপনার বন্দুকের সীমার মধ্যে রয়েছেন তাই আপনি নিজেকে গুলি করতে পারেন তবে শর্ত আছে যে আপনার কাছে গুলি রয়েছে। দুজন খেলোয়াড় একে অপরকে গুলি করলে তারা দুজনেই মারা যায়।

যদি দু'জন খেলোয়াড় একই স্কোয়ারের দিকে যাওয়ার চেষ্টা করে তবে তারা ব্যর্থ হবে এবং দু'জনেই তারা যে স্কোয়ার থেকে শুরু করেছিল সেটিতে ফিরে আসবে। এখনও যদি দ্বন্দ্ব থাকে, তবে কোনও বিরোধ না হওয়া পর্যন্ত এটি পুনরাবৃত্তি হবে, যার অর্থ তারা যখন শুরু করেছিলেন সেখানেই ফিরে এসেছেন।

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

কোনও খেলোয়াড় যদি জম্বি হয়ে যায়, তবে তাদের বুলেটগুলি নষ্ট হয়ে যায়। জুম্বগুলি মূর্খতার সাথে নিকটস্থ জীবিত খেলোয়াড়ের দিকে হাঁটবে।

তাদের দীর্ঘতম বেঁচে থাকা খেলোয়াড় কত দিন বেঁচে থাকে তার উপর এন্ট্রিগুলি স্কোর করা হয়।

এন্ট্রি

একটি নিয়ন্ত্রণ প্রোগ্রাম https://github.com/jamespic/zombies এ উপলব্ধ । কেবল এটি ক্লোন করুন, এবং চালান mvn compile exec:java

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

নমুনা এন্ট্রি বর্তমানে নিম্নলিখিত ভাষাগুলিতে উপলভ্য:

আপনি যদি তালিকাভুক্ত নয় এমন ভাষায় প্রতিযোগিতা করতে চান তবে আপনি এটির অনুরোধ করে একটি মন্তব্য পোস্ট করতে পারেন এবং আমি আপনার নির্বাচিত ভাষাকে নিয়ন্ত্রণ প্রোগ্রামে সংহত করার সম্ভাবনাটি তদন্ত করব। অথবা, যদি আপনি অধৈর্য হন, আপনি নিয়ন্ত্রণ প্রোগ্রামে একটি টান অনুরোধ জমা দিতে পারেন।

প্রতিটি প্রবেশের জন্য শুধুমাত্র একটি উদাহরণ (শব্দটির জাভা অর্থে) তৈরি করা হবে। এই জাভা দৃষ্টান্তটি প্রতি বারের জন্য একাধিকবার বলা হবে - প্রতিটি বেঁচে থাকা খেলোয়াড়ের জন্য একবার।

এপিআই

package zombie

// You implement this. Your entry should be in package `player`
interface Player {
    Action doTurn(PlayerContext context)
}

// These already exist
class PlayerContext {
    // A square array, showing the area around you, with you at the centre
    // playFields is indexed by x from West to East, then y from North to South
    PlayerId[][] getPlayField()
    int getBullets() // Current bullets available
    int getGameClock() // Current turn number
    PlayerId getId() // Id of the current player instance
    int getX() // Your current x co-ordinate
    int getY() // Your current y co-ordinate
    int getBoardSize() // The size of the current playing field
    Set<PlayerId> shootablePlayers() // A helper function that identifies players in range.
}

class PlayerId {
    String getName() // The name of the entrant that owns this player
    int getNumber() // A unique number, assigned to this player
}

// Don't implement this. Use either `Move` or `Shoot`
interface Action {}

enum Move implements Action {
    NORTHWEST, NORTH, NORTHEAST,
    EAST, STAY, WEST,
    SOUTHEAST, SOUTH, SOUTHWEST;
    static move randomMove();
}

class Shoot implements Action {
    Shoot(PlayerId target);
}

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

নিয়ন্ত্রণ প্রোগ্রামের সাথে সঠিকভাবে কাজ করতে প্রতিটি প্রবেশের একটি অনন্য নাম থাকতে হবে।

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

খেলোয়াড়দের মধ্যে যোগাযোগের অনুমতি রয়েছে।

বিজয়ী হলেন প্রবেশকারী যার বট একটি টেস্টে আমি সর্বোচ্চ স্কোর পেয়েছি ২০১৪ সালের ৩ রা আগস্ট আমি চালাব।

চূড়ান্ত ফলাফল

চূড়ান্ত ফলাফল! কাপুরুষ বিজয়ী!

২ রা আগস্ট, আমি কন্ট্রোল প্রোগ্রামের 19 রাউন্ড দৌড়েছি এবং প্রতিটি খেলোয়াড়কে তাদের মধ্যম স্কোর অনুসারে স্থান দিয়েছি। ফলাফলগুলি নিম্নরূপ ছিল:

Coward: 4298
Fox: 3214
Shotguneer: 2471
Cocoon: 1834
JohnNash: 1240
HuddleWolf: 1112
Sokie: 1090
SOS: 859
GordonFreeman: 657
Jack: 657
Waller: 366
SuperCoward: 269
MoveRandomly: 259
StandStill: 230
Vortigaunt: 226
ThePriest: 223
Bee: 61
HideyTwitchy: 52
ZombieHater: 31
Gunner: 20
ZombieRightsActivist: 16
SunTzu: 11
EmoWolfWithAGun: 0

শেষ রাউন্ডটি এখানে দেখার জন্য উপলব্ধ ।

রান-বাই-রানের ফলাফল

১৯ রানের প্রতিটিটির পৃথক ফলাফল ছিল:

#Run at 03-Aug-2014 14:45:35#
Bee: 21
Cocoon: 899
Coward: 4608
EmoWolfWithAGun: 0
Fox: 3993
GordonFreeman: 582
Gunner: 18
HideyTwitchy: 37
HuddleWolf: 2836
Jack: 839
JohnNash: 956
MoveRandomly: 310
SOS: 842
Shotguneer: 2943
Sokie: 937
StandStill: 250
SunTzu: 3
SuperCoward: 318
ThePriest: 224
Vortigaunt: 226
Waller: 258
ZombieHater: 41
ZombieRightsActivist: 10

#Run at 03-Aug-2014 14:56:48#
Bee: 97
Cocoon: 3073
Coward: 5699
EmoWolfWithAGun: 0
Fox: 4305
GordonFreeman: 1252
Gunner: 24
HideyTwitchy: 25
HuddleWolf: 3192
Jack: 83
JohnNash: 1195
MoveRandomly: 219
SOS: 884
Shotguneer: 3751
Sokie: 1234
StandStill: 194
SunTzu: 69
SuperCoward: 277
ThePriest: 884
Vortigaunt: 564
Waller: 1281
ZombieHater: 10
ZombieRightsActivist: 2

#Run at 03-Aug-2014 15:01:37#
Bee: 39
Cocoon: 2512
Coward: 2526
EmoWolfWithAGun: 0
Fox: 2687
GordonFreeman: 852
Gunner: 21
HideyTwitchy: 91
HuddleWolf: 1112
Jack: 1657
JohnNash: 944
MoveRandomly: 312
SOS: 660
Shotguneer: 1067
Sokie: 1356
StandStill: 169
SunTzu: 8
SuperCoward: 351
ThePriest: 223
Vortigaunt: 341
Waller: 166
ZombieHater: 25
ZombieRightsActivist: 47

#Run at 03-Aug-2014 15:08:27#
Bee: 27
Cocoon: 2026
Coward: 3278
EmoWolfWithAGun: 0
Fox: 2677
GordonFreeman: 611
Gunner: 16
HideyTwitchy: 11
HuddleWolf: 1694
Jack: 600
JohnNash: 1194
MoveRandomly: 48
SOS: 751
Shotguneer: 5907
Sokie: 1233
StandStill: 62
SunTzu: 9
SuperCoward: 252
ThePriest: 173
Vortigaunt: 107
Waller: 276
ZombieHater: 53
ZombieRightsActivist: 38

#Run at 03-Aug-2014 15:14:01#
Bee: 26
Cocoon: 1371
Coward: 5121
EmoWolfWithAGun: 0
Fox: 3878
GordonFreeman: 464
Gunner: 29
HideyTwitchy: 130
HuddleWolf: 955
Jack: 101
JohnNash: 698
MoveRandomly: 269
SOS: 1314
Shotguneer: 2444
Sokie: 3217
StandStill: 233
SunTzu: 10
SuperCoward: 269
ThePriest: 318
Vortigaunt: 266
Waller: 494
ZombieHater: 49
ZombieRightsActivist: 9

#Run at 03-Aug-2014 15:19:43#
Bee: 25
Cocoon: 2098
Coward: 4855
EmoWolfWithAGun: 0
Fox: 4081
GordonFreeman: 227
Gunner: 43
HideyTwitchy: 28
HuddleWolf: 2149
Jack: 1887
JohnNash: 1457
MoveRandomly: 117
SOS: 1068
Shotguneer: 4272
Sokie: 636
StandStill: 53
SunTzu: 9
SuperCoward: 209
ThePriest: 220
Vortigaunt: 227
Waller: 366
ZombieHater: 19
ZombieRightsActivist: 49

#Run at 03-Aug-2014 15:24:03#
Bee: 46
Cocoon: 682
Coward: 3588
EmoWolfWithAGun: 0
Fox: 4169
GordonFreeman: 764
Gunner: 13
HideyTwitchy: 21
HuddleWolf: 842
Jack: 1720
JohnNash: 1260
MoveRandomly: 259
SOS: 636
Shotguneer: 777
Sokie: 586
StandStill: 75
SunTzu: 6
SuperCoward: 390
ThePriest: 189
Vortigaunt: 208
Waller: 334
ZombieHater: 61
ZombieRightsActivist: 20

#Run at 03-Aug-2014 15:29:49#
Bee: 90
Cocoon: 516
Coward: 4298
EmoWolfWithAGun: 0
Fox: 1076
GordonFreeman: 581
Gunner: 8
HideyTwitchy: 87
HuddleWolf: 4298
Jack: 4715
JohnNash: 727
MoveRandomly: 102
SOS: 859
Shotguneer: 2471
Sokie: 2471
StandStill: 427
SunTzu: 24
SuperCoward: 159
ThePriest: 359
Vortigaunt: 94
Waller: 398
ZombieHater: 54
ZombieRightsActivist: 21

#Run at 03-Aug-2014 15:36:50#
Bee: 18
Cocoon: 3127
Coward: 3124
EmoWolfWithAGun: 0
Fox: 5094
GordonFreeman: 255
Gunner: 43
HideyTwitchy: 17
HuddleWolf: 1078
Jack: 272
JohnNash: 1270
MoveRandomly: 55
SOS: 723
Shotguneer: 3126
Sokie: 1388
StandStill: 179
SunTzu: 7
SuperCoward: 45
ThePriest: 519
Vortigaunt: 172
Waller: 200
ZombieHater: 45
ZombieRightsActivist: 8

#Run at 03-Aug-2014 15:40:59#
Bee: 78
Cocoon: 1834
Coward: 4521
EmoWolfWithAGun: 0
Fox: 1852
GordonFreeman: 657
Gunner: 7
HideyTwitchy: 2
HuddleWolf: 969
Jack: 895
JohnNash: 1596
MoveRandomly: 277
SOS: 694
Shotguneer: 1397
Sokie: 844
StandStill: 325
SunTzu: 7
SuperCoward: 192
ThePriest: 148
Vortigaunt: 369
Waller: 232
ZombieHater: 16
ZombieRightsActivist: 17

#Run at 03-Aug-2014 15:44:22#
Bee: 23
Cocoon: 2638
Coward: 2269
EmoWolfWithAGun: 0
Fox: 2067
GordonFreeman: 730
Gunner: 21
HideyTwitchy: 60
HuddleWolf: 763
Jack: 1469
JohnNash: 1494
MoveRandomly: 273
SOS: 3181
Shotguneer: 3181
Sokie: 653
StandStill: 450
SunTzu: 19
SuperCoward: 272
ThePriest: 215
Vortigaunt: 299
Waller: 510
ZombieHater: 62
ZombieRightsActivist: 16

#Run at 03-Aug-2014 15:48:03#
Bee: 97
Cocoon: 2009
Coward: 2798
EmoWolfWithAGun: 0
Fox: 1907
GordonFreeman: 958
Gunner: 22
HideyTwitchy: 93
HuddleWolf: 925
Jack: 288
JohnNash: 476
MoveRandomly: 422
SOS: 3723
Shotguneer: 2076
Sokie: 1090
StandStill: 134
SunTzu: 92
SuperCoward: 141
ThePriest: 470
Vortigaunt: 216
Waller: 340
ZombieHater: 32
ZombieRightsActivist: 20

#Run at 03-Aug-2014 16:03:38#
Bee: 121
Cocoon: 501
Coward: 9704
EmoWolfWithAGun: 0
Fox: 3592
GordonFreeman: 588
Gunner: 20
HideyTwitchy: 54
HuddleWolf: 749
Jack: 1245
JohnNash: 1345
MoveRandomly: 451
SOS: 835
Shotguneer: 1548
Sokie: 589
StandStill: 166
SunTzu: 11
SuperCoward: 158
ThePriest: 93
Vortigaunt: 246
Waller: 1350
ZombieHater: 18
ZombieRightsActivist: 11

#Run at 03-Aug-2014 16:10:24#
Bee: 66
Cocoon: 1809
Coward: 3295
EmoWolfWithAGun: 0
Fox: 3214
GordonFreeman: 1182
Gunner: 15
HideyTwitchy: 52
HuddleWolf: 1514
Jack: 101
JohnNash: 745
MoveRandomly: 211
SOS: 862
Shotguneer: 6335
Sokie: 1504
StandStill: 384
SunTzu: 14
SuperCoward: 259
ThePriest: 244
Vortigaunt: 262
Waller: 1356
ZombieHater: 24
ZombieRightsActivist: 20

#Run at 03-Aug-2014 16:28:05#
Bee: 61
Cocoon: 692
Coward: 11141
EmoWolfWithAGun: 0
Fox: 1955
GordonFreeman: 1234
Gunner: 42
HideyTwitchy: 24
HuddleWolf: 1862
Jack: 609
JohnNash: 1579
MoveRandomly: 167
SOS: 958
Shotguneer: 11141
Sokie: 284
StandStill: 422
SunTzu: 66
SuperCoward: 121
ThePriest: 207
Vortigaunt: 128
Waller: 259
ZombieHater: 22
ZombieRightsActivist: 7

#Run at 03-Aug-2014 16:32:10#
Bee: 207
Cocoon: 4414
Coward: 2670
EmoWolfWithAGun: 0
Fox: 978
GordonFreeman: 620
Gunner: 19
HideyTwitchy: 135
HuddleWolf: 962
Jack: 657
JohnNash: 1200
MoveRandomly: 147
SOS: 687
Shotguneer: 2258
Sokie: 2433
StandStill: 249
SunTzu: 49
SuperCoward: 1056
ThePriest: 602
Vortigaunt: 326
Waller: 593
ZombieHater: 31
ZombieRightsActivist: 10

#Run at 03-Aug-2014 16:38:56#
Bee: 265
Cocoon: 2231
Coward: 4228
EmoWolfWithAGun: 0
Fox: 4737
GordonFreeman: 532
Gunner: 9
HideyTwitchy: 75
HuddleWolf: 2375
Jack: 1237
JohnNash: 1249
MoveRandomly: 109
SOS: 860
Shotguneer: 6470
Sokie: 1096
StandStill: 126
SunTzu: 15
SuperCoward: 393
ThePriest: 133
Vortigaunt: 184
Waller: 257
ZombieHater: 32
ZombieRightsActivist: 12

#Run at 03-Aug-2014 16:52:16#
Bee: 67
Cocoon: 1534
Coward: 9324
EmoWolfWithAGun: 0
Fox: 2458
GordonFreeman: 1019
Gunner: 24
HideyTwitchy: 72
HuddleWolf: 601
Jack: 399
JohnNash: 1366
MoveRandomly: 275
SOS: 506
Shotguneer: 1007
Sokie: 475
StandStill: 230
SunTzu: 135
SuperCoward: 361
ThePriest: 61
Vortigaunt: 112
Waller: 4106
ZombieHater: 12
ZombieRightsActivist: 22

#Run at 03-Aug-2014 17:03:04#
Bee: 26
Cocoon: 1159
Coward: 7796
EmoWolfWithAGun: 0
Fox: 3948
GordonFreeman: 878
Gunner: 3
HideyTwitchy: 17
HuddleWolf: 1490
Jack: 513
JohnNash: 1240
MoveRandomly: 487
SOS: 1460
Shotguneer: 1481
Sokie: 832
StandStill: 457
SunTzu: 8
SuperCoward: 480
ThePriest: 527
Vortigaunt: 171
Waller: 3729
ZombieHater: 30
ZombieRightsActivist: 10

1
@ পিফেরেফেরেট ফ্রেইজ কোডটিতে একটি ফ্রিজ ফাইল রয়েছে যা গিথুব . com / jamespic / zombies / blob / master / src / main / frege- bindings/ , এবং একটি জাভা সহায়ক শ্রেণীর উপরের বাইথিংগুলিতে থাকে যা github.com/jamespicফ্রেজে কল করে / জম্বি / ব্লব / মাস্টার / এসসিআর / প্রধান / জাভা / জম্বি /… । আপনি যদি রেপো ক্লোন করতে পারেন (বা এটি github.com/jamespic/zombies/archive/master.zip থেকে জিপ হিসাবে ডাউনলোড করতে পারেন ) তবে মাভেন আপনার জন্য বিল্ডটি পরিচালনা করবে।
জেমস_পিক

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

1
@ সোকি এটি ঠিক বলে মনে হচ্ছে - কিছু এন্ট্রি ইতিমধ্যে এমন কিছু করেছে এবং আমি যখন অনুভূতিটি স্থির করেছিলাম যে কিছু প্রবেশকারীরা তাদের বটগুলি কোথাও কোথাও রেন্ডেজ-বাউস বা তার আশপাশের সম্পর্কে তথ্য বিনিময় করতে চায়। আমরা বলব যে খেলোয়াড়রা ওয়াকি টকিজ পেয়েছে।
জেমস_পিক

2
@ জেমস_পিক আমি এই কোডটি গেম.জাভাতে আমার স্থানীয় অনুলিপি ( পেস্টবিন .com/পুটপন ৯ফ) এ যুক্ত করেছি যাতে আমি খেলায় এগিয়ে এবং পিছনে যেতে তীরচিহ্নগুলি ব্যবহার করতে পারি।
ভেবেছিলেন

2
কিছুটা হতাশার কারণ যে বিজয়ী আত্মহত্যা না করে নিজেকে কিছুটা ঝাঁকুনির শিকার করে।
স্পার

উত্তর:


15

ভীরু

কাপুরুষতার নিয়ম।

  1. আপনি যদি পালাতে না পারেন তবে আতঙ্কিত হন এবং আপনি জানেন না এমন সমস্ত কিছু গুলি চালান।
  2. চালান !!!
  3. দৌড়ানোর সময়, আপনি কিছু গুলি পছন্দ করতে পারেন। গভীরভাবে আপনি জানেন আপনি চিরকাল চলতে পারবেন না।
  4. দৌড়ানোর সময়, অন্যান্য কাপুরুষদের সন্ধান করুন। দুর্ভাগ্য সঙ্গকে ভালবাসে। এবং তারা প্রথমে অন্য লোকটিকে খেতে পারে।
package player;

import java.lang.Math.*;
import java.util.Set;
import java.util.HashSet;
import zombie.*;
import static zombie.Constants.*;

public class Coward implements Player {

    private static final Set<PlayerId> killed = new HashSet<>();
    private static final Set<PlayerId> looted = new HashSet<>();

    @Override
    public Action doTurn(PlayerContext context) {

        PlayerId[][] field = context.getPlayField();

        // Panic and shoot
        if (context.getBullets() > 0) {
            int distEnemy = VISION_WIDTH;
            int distZombie = VISION_WIDTH;
            PlayerId targetEnemy = null;
            PlayerId targetZombie = null;
            for (int x = CENTRE_OF_VISION - SHOOT_RANGE; x <= CENTRE_OF_VISION + SHOOT_RANGE; x++) {
                for (int y = CENTRE_OF_VISION - SHOOT_RANGE; y <= CENTRE_OF_VISION + SHOOT_RANGE; y++) {
                    PlayerId player = field[x][y];
                    if (player != null && !killed.contains(player)) {
                        int dist = getDistance(x, y);
                        if (player.getName().equals("Zombie")) {
                            if( dist < distZombie ) {
                                distZombie = dist;
                                targetZombie = player;
                            }
                        } else if (isEnemy(player.getName()) && dist <= distEnemy ) {
                            distEnemy = dist;
                            targetEnemy = field[x][y];
                        }
                    }
                }
            }

            if (targetZombie != null && distZombie <= 3) {
                killed.add(targetZombie);
                return new Shoot( targetZombie );
            } else if (targetEnemy != null && distEnemy <= 5 ) {
                killed.add(targetEnemy);
                return new Shoot( targetEnemy );
            }
        }

        // Looted?
        for( int xx = CENTRE_OF_VISION-VISION_RANGE+1; xx <= CENTRE_OF_VISION+VISION_RANGE-1; xx++ ) {
            for( int yy = CENTRE_OF_VISION-VISION_RANGE+1; yy <= CENTRE_OF_VISION+VISION_RANGE-1; yy++ ) {
                PlayerId player = field[xx][yy];
                if( player != null && !player.getName().equals("Zombie") && !player.getName().equals("DeadBody")) {
                    for( int x = -1; x <= 1; x++ ) {
                        for( int y = -1; y <= 1; y++ ) {
                            PlayerId loot = field[xx+x][yy+y];
                            if( loot != null && !looted.contains(loot) && loot.getName().equals("DeadBody")) {
                                looted.add(loot);
                            }
                        }
                    }
                }
            }
        }

        // Run away
        int bestScore = -10000000;
        Move bestMove = Move.randomMove();

        for( int x = -1; x <= 1; x++ ) {
            for( int y = -1; y <= 1; y++ ) {
                PlayerId center = field[CENTRE_OF_VISION+x][CENTRE_OF_VISION+y];
                if( center == null ) {
                    int thisScore = 0;
                    for( int xx = CENTRE_OF_VISION+x-VISION_RANGE+1; xx < CENTRE_OF_VISION+x+VISION_RANGE; xx++ ) {
                        for( int yy = CENTRE_OF_VISION+y-VISION_RANGE+1; yy < CENTRE_OF_VISION+y+VISION_RANGE; yy++ ) {
                            PlayerId player = field[xx][yy];
                            if( player != null) {
                                int dist = getDistance(xx-x,yy-y);

                                if( player.getName().equals("Coward")) { // Prefer lose groups
                                    thisScore += (int)Math.pow( 2, ( 6 - Math.abs( dist - 5 )));
//                                    if( dist >= 3 && dist <= 6 ) {
//                                        thisScore += 32;
//                                    } else if( dist > 3 ) {
//                                        thisScore += 16;
//                                    }
                                } else if( player.getName().equals("DeadBody")) { // Visit dead bodies on the route
                                    if( !looted.contains(player)) {
                                        thisScore += (32+VISION_RANGE-dist)*(VISION_RANGE-dist);
                                    }
                                } else if( player.getName().equals("Zombie")) { // Avoid zombies
                                    if( dist <= 5 ) {
                                        thisScore -= (int)Math.pow( 10, ( 6 - dist ));
                                    }
//                                    if( dist <= 2 ) {
//                                        thisScore -= 10000;
//                                    } else if( dist <= 3 ) {
//                                        thisScore -= 1000;
//                                    } else if( dist <= 4 ) {
//                                        thisScore -= 100;
//                                    }
                                } else if( isEnemy(player.getName())) { // Avoid strangers
                                    thisScore -= (int)Math.pow( 10, ( 9 - dist ));
//                                    if( dist == 7 ) {
//                                        thisScore -= 100;
//                                    } else if( dist <= 6 ) {
//                                        thisScore -= 1000;
//                                    }
                                }
                            }
                        }
                    }
                    if( thisScore > bestScore ) {
                        bestScore = thisScore;
                        bestMove = Move.inDirection( x, y );
                    }
                }
            }
        }

        return bestMove;
    }

    private boolean isEnemy(String name) {
        switch (name) {
            case "Coward":
            case "DeadBody":
            case "GordonFreeman":
            case "EmoWolfWithAGun":
            case "HuddleWolf":
            case "ThePriest":
            case "Shotguneer":
            case "Vortigaunt":
            case "Fox":
            case "Cocoon":
            case "SuperCoward":
            case "SOS":
            case "JohnNash":
            case "MoveRandomly":
                return false;
            default:
                return true;
        }
    }

    private int getDistance(int x, int y) {
        return Math.max(Math.abs(CENTRE_OF_VISION - x), Math.abs(CENTRE_OF_VISION - y));
    }
}

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

ওহ, এবং আপনি কী হত্যা করেছেন সে সম্পর্কে আপনার নজর রাখার দরকার নেই। এটি DeadBodyআগে যা ছিল তার চেয়ে আলাদা আইডি সহ এটি প্রদর্শিত হবে।
জেমস_পিক

1
এটি ট্র্যাক রাখার জন্য নয়, একই রাউন্ডে দু'বার একই জিনিসটির শুটিং না করার জন্য।
থাইলন

1
মেড বিভিন্ন পরিবর্তন, শ্রেষ্ঠ একটি মহাকাব্য শোডাউন দিয়ে চালানো ছিল 2681. এ dl.dropboxusercontent.com/u/13918324/2681.html
Thaylon

1
@ থাইলন আপনার জন্য সর্বশেষতম কোড কোড ফর্ম্যাট করেছে। পেস্টবিন.
com

44

ইমো ওল্ফ উইথ এ বন্দুক

সে ফিরে এসেছে । তিনি জম্বিদের ঘৃণা করেন। তিনি এখনও জাভা ঘৃণা করেন। কোন কপিরাইট লঙ্ঘন উদ্দেশ্যে।

package player;

import zombie.*;

public class EmoWolfWithAGun implements Player {

    @Override
    public Action doTurn(PlayerContext context) {
        PlayerId myself = context.getId();
        return new Shoot(myself);
    }

}


13

বোকচন্দর অধিকার কর্মী

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

package player;
import zombie.*;
import static zombie.Constants.*;
import static java.lang.Math.*;

public class ZombieRightsActivist implements Player {

@Override
public Action doTurn(PlayerContext context) {
    if (context.getBullets() > 0) {
        for (PlayerId player: context.shootablePlayers()) {
            switch(player.getName()) {
                case "ZombieRightsActivist":
                case "DeadBody":
                case "Zombie":   
                    break;
                default:
                    return new Shoot(player);//Kill the non-believers
            }
        }
    }
    double farthest=0;
    Move move=Move.randomMove();
    for (int x = 0; x < VISION_WIDTH; x++) {//Find a lonely zombie and give it a hug
        for (int y = 0; y < VISION_WIDTH; y++) {
            PlayerId friend = context.getPlayField()[x][y];
            if (friend!= null && (friend.getName().equals("Zombie"))) {
                double distance=sqrt(pow(x-context.getX(),2)+pow(y-context.getY(),2));
                if (distance>farthest){
                    farthest = distance;
                    move = Move.inDirection(x - CENTRE_OF_VISION, y -CENTRE_OF_VISION);
                }
            }
        }
    }
    return move;
}

}

12

হডলওল্ফ - জাভা

বিধি 8 : গ্রুপে ভ্রমণ

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

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

package player;

import zombie.*;
import static zombie.Constants.*;
import static java.lang.Math.*;

public class HuddleWolf implements Player {

    @Override
    public Action doTurn(PlayerContext context) {
        if (context.getBullets() > 0) {
            for (PlayerId player: context.shootablePlayers()) {
                if (isEnemy(player.getName())) {
                    return new Shoot(player);
                }
            }
        }
        Move bestDirection = Move.NORTHEAST;
        int bestDistance = Integer.MAX_VALUE;
        bool foundACoward = false;
        for (int x = 0; x < VISION_WIDTH; x++) {
            for (int y = 0; y < VISION_WIDTH; y++) {
                int distance = max(abs(x - CENTRE_OF_VISION), abs(y - CENTRE_OF_VISION));
                PlayerId playerAtLocation = context.getPlayField()[x][y];
                if (playerAtLocation != null
                        && !(isEnemy(playerAtLocation.getName()))
                        && !(playerAtLocation.equals(context.getId()))
                        && distance < bestDistance
                        && (!foundACoward || playerAtLocation.getName().equals("Coward"))) {
                    if (playerAtLocation.getName().equals("Coward"))
                    {
                        foundACoward = true;
                    }
                    bestDistance = distance;
                    bestDirection = Move.inDirection(x - CENTRE_OF_VISION, y -CENTRE_OF_VISION);
                }
            }
        }
        return bestDirection;
    }

    private boolean isEnemy(String name) {
        switch(name) {
            case "ZombieRightsActivist":
            case "ZombieHater":
            case "HideyTwitchy" :
            case "Gunner":
            case "Zombie" :
                return true;
            default:
                return false;
        }
    }
}

হাডল ওল্ফ: এখন গানারদের মেরে
হডল ওল্ফ

আপনি && !(playerAtLocation.equals(context.getId()))আপনার হডিং শর্তে যোগ করতেও পারেন । এই মুহুর্তে, এটি নিকটতম খেলোয়াড়ের দিকে অগ্রসর হয় - নিকটতম প্লেয়ারটি বাদে আপনি, তাই এটি স্থির থাকে।
জেমস_পিক

আপনি কি বিধি 8 মানে ? ....
পিওরফেরেট

@ পিয়ারফেরেট: আপনি ঠিক বলেছেন। আমার আসল অনুপ্রেরণা ছিল জম্বলল্যান্ড কামান নয়।
হডলওল্ফ

এফওয়াইআই জুম্বোহ্যাটারের দিকে তাকান। আমার মনে হয় না সে আসলে জম্বিদের ঘৃণা করে। সে কেবল আমাদের সকলকে বন্দুকের মতো গুলি করে। আপনার সম্ভবত সম্ভবত বাধ্যতামূলক লক্ষ্যগুলির তালিকায় যুক্ত করা উচিত।
কেইন

11

শিয়াল

শিয়ালের জন্য একটি শিয়াল হোল দরকার।

আমার কাপওয়ার একটি ভাল অংশ ব্যবহার করে তবে একটি ভিন্ন কৌশল অনুসরণ করে। আপনি যদি (উপ) মিশনটি গ্রহণ করতে চান, শিয়াল একটি শিয়াল তৈরি করতে বেছে নেবে।

package player;

import java.lang.Math.*;
import java.util.Set;
import java.util.HashSet;
import zombie.*;
import static zombie.Constants.*;

public class Fox implements Player {

    private static int lastround = -1;
    private static final Set<PlayerId> killed = new HashSet<>();
    private static final Set<PlayerId> looted = new HashSet<>();

    @Override
    public Action doTurn(PlayerContext context) {

        PlayerId[][] field = context.getPlayField();

        // Cleanup
        if (context.getGameClock() > lastround) {
            lastround = context.getGameClock();
            killed.clear();
        }

        // Snipe
        if (context.getBullets() > 0) {
            int distEnemy = 1;
            PlayerId targetEnemy = null;
            for (int x = CENTRE_OF_VISION - SHOOT_RANGE; x <= CENTRE_OF_VISION + SHOOT_RANGE; x++) {
                for (int y = CENTRE_OF_VISION - SHOOT_RANGE; y <= CENTRE_OF_VISION + SHOOT_RANGE; y++) {
                    PlayerId player = field[x][y];
                    if (player != null && !killed.contains(player)) {
                        int dist = getDistance(x, y);
                        if (!player.getName().equals("Zombie") && isEnemy(player.getName()) && dist >= distEnemy ) {
                            distEnemy = dist;
                            targetEnemy = field[x][y];
                        }
                    }
                }
            }
            if (targetEnemy != null) {
                killed.add(targetEnemy);
                return new Shoot( targetEnemy );
            }
        }

        // Check Foxhole
        int foxhole = 0;
        PlayerId target = null;

        for( int x = -2; x <= 2; x++ ) {
            for( int y = -2; y <= 2; y++ ) {
                PlayerId player = field[CENTRE_OF_VISION+x][CENTRE_OF_VISION+y];
                if (player != null && getDistance(CENTRE_OF_VISION+x,CENTRE_OF_VISION+y) == 2) {
                    if (player.getName().equals("DeadBody") || player.getName().equals("Fox")) {
                        foxhole++;
                    }
                    if( player.getName().equals("Zombie")) {
                        target = player;
                    }
                }
            }
        }

        if (context.getBullets() + foxhole >= 16) {
            if (target!=null) {
                return new Shoot( target );
            } else {
                return Move.STAY;
            }
        }

        // Looted?
        for( int xx = CENTRE_OF_VISION-VISION_RANGE+1; xx <= CENTRE_OF_VISION+VISION_RANGE-1; xx++ ) {
            for( int yy = CENTRE_OF_VISION-VISION_RANGE+1; yy <= CENTRE_OF_VISION+VISION_RANGE-1; yy++ ) {
                PlayerId player = field[xx][yy];
                if( player != null && !player.getName().equals("Zombie") && !player.getName().equals("DeadBody")) {
                    for( int x = -1; x <= 1; x++ ) {
                        for( int y = -1; y <= 1; y++ ) {
                            PlayerId loot = field[xx+x][yy+y];
                            if( loot != null && !looted.contains(loot) && loot.getName().equals("DeadBody")) {
                                looted.add(loot);
                            }
                        }
                    }
                }
            }
        }

        // Collect bullets
        int bestScore = -10000000;
        Move bestMove = Move.randomMove();

        for( int x = -1; x <= 1; x++ ) {
            for( int y = -1; y <= 1; y++ ) {
                PlayerId center = field[CENTRE_OF_VISION+x][CENTRE_OF_VISION+y];
                if( center == null ) {
                    int thisScore = 0;
                    for( int xx = CENTRE_OF_VISION+x-VISION_RANGE+1; xx < CENTRE_OF_VISION+x+VISION_RANGE; xx++ ) {
                        for( int yy = CENTRE_OF_VISION+y-VISION_RANGE+1; yy < CENTRE_OF_VISION+y+VISION_RANGE; yy++ ) {
                            PlayerId player = field[xx][yy];
                            if( player != null) {
                                int dist = getDistance(xx-x,yy-y);

                                if( player.getName().equals("DeadBody")) {
                                    if( !looted.contains(player)) {
                                        thisScore += (32+VISION_RANGE-dist)*(VISION_RANGE-dist);
                                    }
                                } else if( player.getName().equals("Zombie")) {
                                    if( dist <= 5 ) {
                                        thisScore -= (int)Math.pow( 10, ( 6 - dist ));
                                    }
                                }
                            }
                        }
                    }
                    if( thisScore > bestScore ) {
                        bestScore = thisScore;
                        bestMove = Move.inDirection( x, y );
                    }
                }
            }
        }

        return bestMove;
    }

    private boolean isEnemy(String name) {
        switch (name) {
            case "Fox":
            case "Coward":
            case "DeadBody":
            case "GordonFreeman":
            case "EmoWolfWithAGun":
            case "HuddleWolf":
            case "ThePriest":
            case "Shotguneer":
            case "Vortigaunt":
            case "Cocoon":
            case "SuperCoward":
            case "SOS":
            case "JohnNash":
            case "MoveRandomly":
                return false;
            default:
                return true;
        }
    }

    private int getDistance(int x, int y) {
        return Math.max(Math.abs(CENTRE_OF_VISION - x), Math.abs(CENTRE_OF_VISION - y));
    }
}

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

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

10

ওয়ালার - জাভা

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

আদর্শ ওয়াল

ওয়ালারটি প্রাচীর দ্বারা চারপাশে সমাপ্ত হয় যেখানে আদর্শ প্রাচীর:

   DDD 
   DWD 
   DDD

মারা যাওয়ার একমাত্র উপায় হ'ল শট নেওয়া বা একটি জম্বি আপনার নীচে বা আপনার প্রতিবেশী হয়ে থাকে। এগুলি এড়ানোর পক্ষে এটি সর্বোত্তম সম্ভাবনা।

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


অ্যালগরিদম তুলনামূলকভাবে সহজ

  1. কামড় দেওয়ার মতো কোনও জুম্বি কি আছে? তাদের গুলি কর.
  2. দেখার ক্ষেত্রের ক্ষেত্রে প্রাচীরের সেরা অবস্থান (স্কোর 0 - 8) সন্ধান করুন
  3. সেই অবস্থানের সবচেয়ে সংক্ষিপ্ত পথটি খুঁজে এটির দিকে দৌড়ান!
  4. প্রাচীর বাড়ানোর চেষ্টা করুন
  5. অপেক্ষা করুন ...

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


পরিবর্তণের:

  • প্রাচীর সন্ধান / বিল্ডিংয়ের আগে প্রথম কয়েক টার্নের জন্য অপেক্ষা করা এবং আক্রমণাত্মক খেলোয়াড়দের এড়িয়ে প্রাথমিক গেমের পারফরম্যান্স উন্নত করার চেষ্টা করা হয়েছিল।

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

  • কোনও দখলকৃত পয়েন্টে শেষ হওয়া পথ সন্ধান সহ স্থির সমস্যাগুলি

  • আরও পরিষ্কার কোড। কেবল প্রতিবেশী দেয়ালগুলির চেয়ে কোনও অবস্থান অর্জন করতে আরও প্রাচীর যুক্ত করা হয়েছে Added ওয়ালার তার প্রাচীরটি কতদূর প্রসারিত করবে প্রসারিত।

  • কোডটি কিছুটা সাফ করা হয়েছে। একই পালা চলাকালীন দুটি ওয়ালার একই প্লেয়ারের শুটিং এড়াতে শ্যুটিং রেজিস্ট্রি কার্যকর করা হয়েছে (থাইলনের দ্বারা অনুপ্রাণিত)

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


সমস্যা

  • ওয়ালার ভাল অবস্থানে থাকতে পারে তবে প্রাচীরের আরও ভাল অবস্থান দেখে। তারা জুম্বি-আক্রান্ত জমিতে সেই নির্ধারিত জায়গায় পৌঁছতে মূর্খতা পাবে। (আমি এটি নিরুৎসাহিত করা প্রয়োজন)

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

  • একই অবস্থানগুলিতে ওয়ালারদের মধ্যে কোনও যোগাযোগ নেই। সর্বোত্তম প্রাচীর তৈরিতে তাদের একসাথে কাজ করা দরকার।


কোডটি এখানে, আমি জাভা প্রোগ্রামার নই (সি #) সুতরাং আমার জাভা ত্রুটিগুলি ক্ষমা করুন।

package player;

import java.lang.Math.*;
import java.util.Set;
import java.util.HashSet;
import java.util.Hashtable;
import java.util.ArrayList;
import java.util.List;
import java.util.LinkedList;
import java.util.Collections;
import java.util.Comparator;
import zombie.*;
import static zombie.Constants.*;

public class Waller implements Player {

    private static final int MaximumDistanceToShootZombie = 2;
    private static final int PointsPerWall = 3;
    private static final int PointsPerLoot = 3;
    private static final int PointsPerZombie = -500;
    private static final int PointsPerAggressor = -500;  

    private static final Set<PlayerId> shooting = new HashSet<PlayerId>();
    private static final Set<PlayerId> dontLoot = new HashSet<PlayerId>();
    private static final Set<Point> zombieLocations = new HashSet<Point>();
    private Point CurrentLocation = new Point(CENTRE_OF_VISION, CENTRE_OF_VISION);

    private static int _lastGameTurn = -1;

    // DEBUG
    private static boolean _DEBUG = true;
    private static int agressiveKills;
    private static int zombieKills;
    private static int wallsBuilt;
    ////////

    private static class Point{
        public int X;
        public int Y;
        public PlayerId Player;
        public int Distance;

        public Point(int x, int y) {
            X = x;
            Y = y;
        }

        public Point(int x, int y, PlayerId player) {
            X = x;
            Y = y;
            Player = player;
        }

        public boolean SameLocation(Point otherPoint) {
            return X == otherPoint.X && Y == otherPoint.Y;
        }

        public List<Point> getAdjacentPoints(PlayerId[][] field, int distance, boolean includeSelf) {
            List<Point> points = new ArrayList<Point>();
            for(int x = X - distance; x <= X + distance; x++) {
                for(int y = Y - distance; y <= Y + distance; y++) { 
                    if(!includeSelf && x == X && y == Y)
                        continue;
                    Point pointToAdd = new Point(x, y);                 
                    if(pointToAdd.isValid()) {
                        pointToAdd.Player = field[x][y];
                        points.add(pointToAdd);
                    }
                }
            }                   
            return points;
        }

        public int GetDistance(Point point) {
            return Math.max(Math.abs(X - point.X), Math.abs(Y - point.Y));
        }

        private boolean isValid() { 
            return X >= 0 && X < VISION_WIDTH && Y >= 0 && Y < VISION_WIDTH;
        }

        @Override
        public int hashCode() {
            return (X*100) + Y;  
        }

        @Override
        public boolean equals(Object obj) {
            if (!(obj instanceof Point))
                return false;
            if (obj == this)
                return true;

            return SameLocation((Point) obj);       
        }

        @Override
        public String toString(){
            return "("+X+","+Y+")";
        }           
    }

    @Override
    public Action doTurn(PlayerContext context) {   
        int gameTurn = context.getGameClock();  

        if(gameTurn != _lastGameTurn){
            _lastGameTurn = gameTurn;               
        }

        PlayerId[][] field = context.getPlayField();         
        int bullets = context.getBullets();

        // Mark all adjacent dead players as already been looted
        for(Point point : getSurrounding(field, CENTRE_OF_VISION, CENTRE_OF_VISION, 1)){
            if(point.Player.getName().equals("DeadBody")) 
                dontLoot.add(point.Player);  
        }

        int x = context.getX();
        int y = context.getY();
        int boardSize = context.getBoardSize();
        List<Point> newZombies = new ArrayList<Point>();
        for(Point point : getSurrounding(field, CENTRE_OF_VISION, CENTRE_OF_VISION, VISION_RANGE)){     
            Point absolutePoint = GetNewTorusPoint(x + point.X - CENTRE_OF_VISION , y + point.Y - CENTRE_OF_VISION, boardSize);         
            if(point.Player.getName().equals("DeadBody") && zombieLocations.contains(absolutePoint)) 
                dontLoot.add(point.Player);  // new zombie kill
            if(isZombie(point.Player))
                newZombies.add(absolutePoint);
        }
        zombieLocations.clear();
        zombieLocations.addAll(newZombies);

        Action action;  

        // 1) Handle immediate threats to life, have to be dealt before anything else
        action = AssessThreats(field, bullets);
        if(action != null) return action;

        //2) Early turn avoidance
        if(gameTurn < 5) {
            action = EarlyTurn(field, bullets, context);
            if(action != null) return action;
        }

        int currentWallCount = countNumberOfSurroundingWalls(field, CENTRE_OF_VISION, CENTRE_OF_VISION);

        switch(currentWallCount) {  
            case 8:     
                action = ShootAgressivePlayers(field, bullets);
                if(action != null) return action; 
                return Move.STAY; // no more moving                 
            case 7:     
                action = ExpandWall(field, bullets, 1);
                if(action != null) return action;
                action = ShootAgressivePlayers(field, bullets);
                if(action != null) return action;                   
            case 6: 
            case 5:              
            case 4: 
                // action = ExpandWall(field, bullets, 2);
                // if(action != null) return action; 
                // break;
            case 2: 
            case 1: 
            default:                                    
                break;
        }                       

        // 2) Score each possible square and find the best possible location(s)
        Set<Point> optimalLocations = scoreSquares(field);  

        action = findShortestPath(field, CurrentLocation, optimalLocations);
        if(action != null) return action;

        action = ShootAgressivePlayers(field, bullets);
        if(action != null) return action;   

        action = ExpandWall(field, bullets, 1);
        if(action != null) return action;    

        // Stay still if nothing better to do
        return Move.STAY;
    }

    private Action EarlyTurn(PlayerId[][] field, int bullets, PlayerContext context) {
        Point bestPoint = CurrentLocation;
        double bestScore = 1000000;

        for(Point futurePoint : CurrentLocation.getAdjacentPoints(field, 1, true)) {            
            double score = 0;
            for(Point adjacentPoint : futurePoint.getAdjacentPoints(field, VISION_RANGE, false)) {
                if(isAgressive(adjacentPoint.Player)){
                    int dist = futurePoint.GetDistance(adjacentPoint);          
                    if(dist > 6){
                        score += 1;             
                    } else {
                        score += 10000;
                    }
                } else if(isZombie(adjacentPoint.Player)) {
                    int dist = futurePoint.GetDistance(adjacentPoint);      
                    if (dist <= 3)
                        score += 10000;
                } else if(isWall(adjacentPoint.Player)) {
                    score -= 2;
                }
            }   
            if(score < bestScore) {
                bestScore = score;
                bestPoint = futurePoint;
            }
        }                           

        //if(_DEBUG) System.out.println("["+_lastGameTurn+"] Best Score: "+bestScore +" point: "+context.getX()+","+context.getY());

        if(bestPoint == CurrentLocation) {
            Action action = ShootAgressivePlayers(field, bullets);
            if(action != null) return action;   
            return Move.STAY;
        }

        if(bestScore >= 1000) {
            Action action = ShootAgressivePlayers(field, bullets);
            if(action != null) return action;   
        }

        return Move.inDirection(bestPoint.X - CurrentLocation.X, bestPoint.Y - CurrentLocation.Y);      
    }

    private Action ShootAgressivePlayers(PlayerId[][] field, int bullets) {
        if(bullets > 0) {       
            for(Point point : getSurrounding(field, CENTRE_OF_VISION, CENTRE_OF_VISION, SHOOT_RANGE)) {
                PlayerId player = point.Player;
                if(isAgressive(player) && shouldShoot(player)) {
                    if(_DEBUG) System.out.println("["+_lastGameTurn+"] Killing Aggressive: "+(++agressiveKills));       
                    return new Shoot(player);
                }           
            }   
        }
        return null;
    }

    private Action ExpandWall(PlayerId[][] field, int bullets, int distance) {
        if(bullets > 0) {
            for(Point point : getSurrounding(field, CENTRE_OF_VISION, CENTRE_OF_VISION, distance)) {
                PlayerId player = point.Player;
                if(!isWall(player) && isEnemy(player) && !isZombie(player) && shouldShoot(player)) {
                    if(_DEBUG) System.out.println("["+_lastGameTurn+"] Expanding Wall: "+(++wallsBuilt)+" Dist: "+CurrentLocation.GetDistance(point));          
                    return new Shoot(player);
                }           
            }
        }
        return null;
    }

    private boolean shouldShoot(PlayerId player) {
        boolean result = shooting.add(player);
        if(result && isZombie(player)){
            dontLoot.add(player);           
        }       
        return result;      
    }

    private boolean canShoot(PlayerId player) {
        return !shooting.contains(player);      
    }

    private Action AssessThreats(PlayerId[][] field, int bullets){ 
        // Find the most threatening zombie     
        List<Point> bestZombies = new ArrayList<Point>();
        int smallestDistance = MaximumDistanceToShootZombie+1;      
        for(Point point : getSurrounding(field, CENTRE_OF_VISION, CENTRE_OF_VISION, MaximumDistanceToShootZombie)) {
            PlayerId zombie = point.Player;
            if(isZombie(zombie)) {              
                LinkedList<Point> path = findShortestPath_astar(field, CurrentLocation, point, false, false);               
                if(path.isEmpty()) 
                    continue;  
                if(path.size() <= smallestDistance && canShoot(zombie)) {
                    if(path.size() < smallestDistance) {
                        smallestDistance = path.size();
                        bestZombies.clear();
                    }
                    bestZombies.add(point);                                                                                            
                }    
            }
        }

        // No zombies to worry about
        if(bestZombies.isEmpty())
            return null;

        if(bestZombies.size() > 1) {
            if(_DEBUG) System.out.println("["+_lastGameTurn+"] Multiple Zombies in striking range, wait them out?");        
            return MoveToBestSpot(field);   
        }

        Point zombie = bestZombies.get(0);

        // Do we have ammo?
        if(bullets > 0 && shouldShoot(zombie.Player)) { 
            if(_DEBUG) System.out.println("["+_lastGameTurn+"] Shooting Zombie: "+(++zombieKills));             
            return new Shoot(zombie.Player);
        } 

        if(_DEBUG) System.out.println("["+_lastGameTurn+"] No Bullets to Shoot Zombie! Should flee");           
        return MoveInDirection(field, CENTRE_OF_VISION - zombie.X, CENTRE_OF_VISION - zombie.Y);    
    }

    private Action MoveToBestSpot(PlayerId[][] field) { 
        int leastZombies = 100000;
        Point bestPoint = CurrentLocation;
        for(Point point : CurrentLocation.getAdjacentPoints(field, 1, false)) {
            if(point.Player == null) {
                int zombies = countNumberOfSurroundingZombies(field, point.X, point.Y);
                if(zombies < leastZombies) {
                    leastZombies = zombies;
                    bestPoint = point;
                }
            }
        }
        return Move.inDirection(bestPoint.X - CurrentLocation.X, bestPoint.Y - CurrentLocation.Y);
    }

    private Action MoveInDirection(PlayerId[][] field, int x, int y) {
        x = (int)Math.signum(x);
        y = (int)Math.signum(y);

        if(y == 0){
            if(field[CENTRE_OF_VISION+x][CENTRE_OF_VISION] != null)
                return Move.inDirection(x,0);
            if(field[CENTRE_OF_VISION+x][CENTRE_OF_VISION-1] != null)
                return Move.inDirection(x,-1);
            if(field[CENTRE_OF_VISION+x][CENTRE_OF_VISION+1] != null)
                return Move.inDirection(x,1);   
        } else if(x == 0){
            if(field[CENTRE_OF_VISION][CENTRE_OF_VISION+y] != null)
                return Move.inDirection(0,y);
            if(field[CENTRE_OF_VISION-1][CENTRE_OF_VISION+y] != null)
                return Move.inDirection(-1,y);
            if(field[CENTRE_OF_VISION+1][CENTRE_OF_VISION+y] != null)
                return Move.inDirection(1,y);   
        } else {        
            if(field[CENTRE_OF_VISION+x][CENTRE_OF_VISION+y] != null)
                return Move.inDirection(x,y);
            if(field[CENTRE_OF_VISION+x][CENTRE_OF_VISION] != null)
                return Move.inDirection(x,0);
            if(field[CENTRE_OF_VISION][CENTRE_OF_VISION+y] != null)
                return Move.inDirection(0,y);   
        }

        return Move.inDirection(0,0);   
    }

    // Implementation of the A* path finding algorithm
    private LinkedList<Point> findShortestPath_astar(PlayerId[][] field, Point startingPoint, Point finalPoint, boolean includeWeights, boolean considerPlayersAsWalls) {   
        LinkedList<Point> foundPath = new LinkedList<Point>();
        Set<Point> openSet = new HashSet<Point>();
        Set<Point> closedSet = new HashSet<Point>();
        Hashtable<Point, Integer> gScores = new Hashtable<Point, Integer>();
        Hashtable<Point, Point> cameFrom = new Hashtable<Point, Point>();

        gScores.put(startingPoint, 0);
        openSet.add(startingPoint);
        Point currentPoint = startingPoint;

        while(!openSet.isEmpty()) {

            // Find minimum F score
            int minF = 10000000;
            for(Point point : openSet) {
                int g = gScores.get(point);
                int h = point.GetDistance(finalPoint); // Assumes nothing in the way                
                int f = g + h;
                if(f < minF) {
                    minF = f;               
                    currentPoint = point;
                }           
            }

            // Found the final point
            if(currentPoint.SameLocation(finalPoint)) {                 
                Point curr = finalPoint;
                while(!curr.SameLocation(startingPoint)) {
                    foundPath.addFirst(curr);
                    curr = cameFrom.get(curr);
                }
                return foundPath;
            }

            openSet.remove(currentPoint);
            closedSet.add(currentPoint);            

            // Add neighbouring squares
            for(Point pointToAdd : currentPoint.getAdjacentPoints(field, 1, false)){                            
                if(closedSet.contains(pointToAdd) || isWall(pointToAdd.Player) || (considerPlayersAsWalls && pointToAdd.Player != null && !pointToAdd.SameLocation(finalPoint) )) 
                    continue;

                int gScore = gScores.get(currentPoint) + 1; // distance should always be one (may change depending on environment)  
                // if(includeWeights){
                    // gScore += (int)-getScore(field,pointToAdd.X,pointToAdd.Y);
                // }   

                boolean distIsBetter = false;   

                if(!openSet.contains(pointToAdd)) {
                    openSet.add(pointToAdd);
                    distIsBetter = true;
                } else if(gScore < gScores.get(pointToAdd)){                    
                    distIsBetter = true;
                }
                if(distIsBetter) {
                    gScores.put(pointToAdd, gScore);
                    cameFrom.put(pointToAdd, currentPoint);                     
                }
            }  
        }

        return foundPath;   
    }

    private Action findShortestPath(PlayerId[][] field, Point startingPoint, Set<Point> finalPoints) {    
        if(finalPoints.isEmpty())
            return null;
        int smallestPath = 10000;       
        Point pointToMoveTo = startingPoint;  

        for(Point finalPoint : finalPoints) {  
            if(finalPoint == startingPoint)
                return null;
            LinkedList<Point> path = findShortestPath_astar(field, startingPoint, finalPoint, true, true);

            // No path between the two points
            if(path.isEmpty()){
                continue;
            }

            // Check if this is the smallest path
            if(path.size() < smallestPath) {                
                smallestPath = path.size();             
                pointToMoveTo = path.getFirst();                
            }           
        }       

        if(pointToMoveTo == startingPoint)
            return null;

        double score = getScore(field, pointToMoveTo.X, pointToMoveTo.Y);
        if(score < -200) {
            if(_DEBUG) System.out.println("["+_lastGameTurn+"] Best Path leads to a bad spot: "+score);     
            return null;
        }

        return Move.inDirection(pointToMoveTo.X - startingPoint.X, pointToMoveTo.Y - startingPoint.Y);          
    }

    private Set<Point> scoreSquares(PlayerId[][] field) {
        double bestScore = getScore(field, CENTRE_OF_VISION, CENTRE_OF_VISION) + 1; // plus one to break ties, and would rather stay
        Set<Point> bestLocations = new HashSet<Point>();
        if(bestScore >= 0) {
            bestLocations.add(CurrentLocation);         
        } else {
            bestScore = 0;
        }

        for(int x = 0; x < VISION_WIDTH; x++){
            for(int y = 0; y < VISION_WIDTH; y++){   
                if(x == CENTRE_OF_VISION && y == CENTRE_OF_VISION) continue;
                if(field[x][y] == null) {                                 
                    double score = getScore(field, x, y);           
                    if(score >= bestScore){
                        if(score > bestScore) {
                            bestLocations.clear();
                            bestScore = score;   
                        }
                        bestLocations.add(new Point(x, y));                      
                    }
                }
            }
        }       
        return bestLocations;
    }

    private double getScore(PlayerId[][] field, int x, int y) {
        int walls = countNumberOfSurroundingWalls(field, x, y); 
        double score = Math.pow(PointsPerWall, walls);      
        int aggressors = countNumberOfSurroundingAggressions(field, x, y);
        score += aggressors * PointsPerAggressor;   
        int zombies = countNumberOfSurroundingZombies(field, x, y);
        score += zombies * PointsPerZombie;
        int loots = countNumberOfSurroundingLoots(field, x, y);
        score += Math.pow(PointsPerLoot, loots);        
        return score;       
    }

    private int countNumberOfSurroundingZombies(PlayerId[][] field, int x, int y) {     
        int zombies = 0;
        Point currentPoint = new Point(x,y);
        for(Point point : getSurrounding(field, x, y, MaximumDistanceToShootZombie+1)){         
            if(isZombie(point.Player)){
                LinkedList<Point> path = findShortestPath_astar(field, currentPoint, point, false, false);
                if(path.isEmpty()) 
                    continue; 
                if(path.size() < MaximumDistanceToShootZombie+1)
                    zombies++;                  
            }            
        }
        return zombies;           
    }

    private int countNumberOfSurroundingLoots(PlayerId[][] field, int x, int y) {     
        int loots = 0;  
        for(Point point : getSurrounding(field, x, y, 1)){
            PlayerId player = point.Player;
            if(isWall(player) && !dontLoot.contains(player)){   
                loots++;                    
            }            
        }
        return loots;   
    }

    private int countNumberOfSurroundingAggressions(PlayerId[][] field, int x, int y) {     
        int aggressors = 0; 
        for(Point point : getSurrounding(field, x, y, SHOOT_RANGE+1)){
            if(isAgressive(point.Player)){
                aggressors++;                   
            }            
        }
        return aggressors;           
    }

    private int countNumberOfSurroundingWalls(PlayerId[][] field, int x, int y) {
        int walls = 0;      
        for(Point point : getSurrounding(field, x, y, 1)){
            if(isWall(point.Player)){
                walls++;                    
            }            
        }
        return walls;
    }

    private static boolean isZombie(PlayerId player) {
        return player != null && player.getName().equals("Zombie");
    }

    private static boolean isWall(PlayerId player) {
        return player != null && player.getName().equals("DeadBody");       
    }

    private static boolean isEnemy(PlayerId player) {
        if(player == null)
            return false;
        switch (player.getName()) {  
            case "Waller":
            case "DeadBody": 
            case "EmoWolfWithAGun":
                return false;
            default:
                return true;
        }
    }

    private static boolean isAgressive(PlayerId player) {
        if(player == null)
            return false;
        switch (player.getName()) {  
            case "Waller":
            case "DeadBody":   
            case "EmoWolfWithAGun":
            case "GordonFreeman":
            case "Vortigaunt": 
            case "StandStill":
            case "MoveRandomly":
            case "Zombie":
                return false;
            default:
                return true;
        }
    }

    // Helper Functions 

    private List<Point> getSurrounding(PlayerId[][] field, int x, int y, int maxDistance) {      
        final Point currentPoint = new Point(x,y);

        List<Point> players = new ArrayList<Point>();
        int minX = coercePoint(x - maxDistance);
        int maxX = coercePoint(x + maxDistance);
        int minY = coercePoint(y - maxDistance);
        int maxY = coercePoint(y + maxDistance);
        for(int i = minX; i <= maxX; i++){
            for(int j = minY; j <= maxY; j++) {
                if(i == x && j == y) continue;
                if(field[i][j] != null) {                
                    Point point = new Point(i,j,field[i][j]);
                    point.Distance = currentPoint.GetDistance(point);
                    players.add(point);
                }
            }
        }           

        Collections.sort(players, new Comparator<Point>() {
            public int compare(Point p1, Point p2) {
                return Integer.compare(p1.Distance, p2.Distance);          
            }});        

        return players;
    }

    private static int coercePoint(int value) {
        if(value < 0)
            return 0;
        if(value >= VISION_WIDTH)
            return VISION_WIDTH-1;
        return value;
    }

    public static Point GetNewTorusPoint(int x, int y, int boardSize) {
        if(x >= boardSize)
            x = boardSize - x;
        if(y >= boardSize)
            y = boardSize - y;
        return new Point(x,y);
    }

    private static int getDistance(int x1, int y1, int x2, int y2) {
        return Math.max(Math.abs(x1 - x2), Math.abs(y1 - y2));
    }
}

ওহ, এটি দুর্দান্ত। আমি আশা করছিলাম যে কেউ অ্যালগরিদম সন্ধানের জন্য সত্যিকারের পথ দিয়ে কিছু করবেন - আমি ডিজকস্ট্রার সাথে একটু খেলছিলাম, তবে এটি দেখে মনে হচ্ছে এটি আমার কাজকে অচল করে দিতে পারে।
জেমস_পিক

@ জামেস_পিক ধন্যবাদ, আমি আজ রাতের সাথে তার সাথে অনেক খেলছিলাম। আপনার কাছে যখন পথের সন্ধান হয় তখন করণীয় অনেক আকর্ষণীয় কাজ। আমার প্রাথমিক পরীক্ষাগুলি তাকে কাউয়ার্ড এবং শটগুনিয়ারের তৃতীয় স্থানে রেখেছিল।
মওল

এটি সম্পর্কে যে কেউ কিছু করতে পারে তা নয়, তবে ফাই, জম্বিগুলি কেবল খালি মাঠ বা খেলোয়াড়গুলিতেই নয় ডেডবডির পাশাপাশি কাজ করতে পারে।
থাইলন

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

স্ট্যান্ড স্টিলকে প্রাচীর হিসাবে আচরণ করা ভুল হতে পারে। অবশ্যই, এটি সরবে না, তবে এটি কোনও
জম্বির

8

গর্ডন ফ্রিম্যান

গর্ডন ফ্রিম্যান জম্বিদের ঘৃণা করে, তাই সে কখনই নিজেকে মেরে ফেলবে না, তবে আরও বেশি জম্বি গুলি চালানোর জন্য আরও বেশি গোলাবারুদ কাটাতে তার কোন কোয়ালিটি নেই।

package player;

import zombie.*;
import static zombie.Constants.*;
import static java.lang.Math.*;

public class GordonFreeman implements Player {
    @Override
    public Action doTurn(PlayerContext context){
        int ammo = context.getBullets();
        // if I have bullets, shoot some zombies
        if(ammo > 0){
            for(PlayerId player: context.shootablePlayers()){
                switch(player.getName()){
                    case "Zombie":
                       return new Shoot(player);
                    default:
                       break;
                }
            }
        }
        // if no bullets, find a dead body and scavenge
        Move bestDirection = Move.STAY;
        int bestDistance = Integer.MAX_VALUE;
        for(int y = 1; y < VISION_WIDTH - 1; y++) {
            for(int x = 1; x < VISION_WIDTH - 1; x++) {

                PlayerId playerAtLocation = context.getPlayField()[x][y];
                // find a dead body
                if((playerAtLocation != null) && "DeadBody".equals(playerAtLocation.getName())){
                    // check adjacent squares for an empty square
                    for(int yy=-1; yy <= +1; yy++){
                        for(int xx=-1; xx <= +1; xx++){
                            PlayerId playerNearby = context.getPlayField()[x + xx][y + yy];
                            if(playerNearby == null){
                                int distance = max(abs(xx + x - CENTRE_OF_VISION), abs(yy + y - CENTRE_OF_VISION));
                                if(distance < bestDistance){
                                    bestDistance = distance;
                                    bestDirection = Move.inDirection(xx + x - CENTRE_OF_VISION, yy + y - CENTRE_OF_VISION);
                                }
                            }
                        }
                    }
                }
            }
        }
        return bestDirection;
    }
}

আমি আশা করি আপনার আপত্তি নেই, তবে আমি আপনার কোডটিতে এটি সংকলিত করার জন্য বেশ কয়েকটি ছোটখাটো সম্পাদনা করেছি এবং কয়েকটি নাল পয়েন্টার বা অ্যারে সূচক বাগগুলি সংশোধন করেছি, যা রান-টাইমে এটিকে ত্রুটি করে তোলে। আমি যুক্তি পরিবর্তন করি নি।
জেমস_পিক

@ জেমস_পিক: আমি এই সংশোধনগুলির প্রশংসা করি, আমি কমপক্ষে জাভা প্রোগ্রামার নই, যদিও আমি ভাবতে চাই যে এই কোটএইচ চ্যালেঞ্জগুলির জন্য আমি যথেষ্ট ভাল করছি: ডি।
কাইল কানোজ

আপনি শেষ ম্যাচের রিপ্লেটি একবার দেখতে চান , jamespic.github.io/zombies/2014-07-21/0.html এ । দেখে মনে হচ্ছে ডঃ ফ্রিম্যান সর্বদা উত্তর-পশ্চিম দিকে হাঁটেন, যা তাঁর অসামঞ্জস্যপূর্ণ অভিনয়টি ব্যাখ্যা করতে পারে।
জেমস_পিক

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

1
আপনাকে ধন্যবাদ :) আমি যখন পারি তখন কোডটি পুনরায় ব্যবহার করতে চাই, তবে আমি যখন তা আমার না হই তখন স্বীকৃতি দিতে পছন্দ করি।
সোকি

7

পুরোহিত

আপনার যদি বিশ্বাস থাকে, আপনার চালানো বা গুলি করার দরকার নেই।

package player;

import zombie.*;
import static zombie.Constants.*;
import static java.lang.Math.*;

public class ThePriest implements Player {

    @Override
    public Action doTurn(PlayerContext context) {
        return Move.NORTH;
    }
}

4
HuddleWolf.... আমি সেখানে আপনি কী করেছেন তা দেখতে পাচ্ছি;)
কাইল কানোস

আমি আশঙ্কা করছি HuddleWolfযে আপনার নামটি ইতিমধ্যে নেওয়া হয়েছে বলে আপনার ক্লাসের নাম দেওয়ার দরকার আছে
জেমস_পিক

6

ZombieHater

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

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

package player;

import java.awt.Point;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import zombie.*;
import static zombie.Constants.*;

public class ZombieHater implements Player {
    private static final Set<PlayerId> emptyDeadBodies = new HashSet<>();
    private static final Map<PlayerId, Point> lastPos = new HashMap<>();

    @Override
    public Action doTurn(PlayerContext context) {
        PlayerId[][] field = context.getPlayField();
        Point myPos = new Point(context.getX(), context.getY());
        PlayerId myId = context.getId();

        // update dead bodies with the new empty ones
        addEmptyBodies(field);

        // shoot nearest zombie if possible
        if (context.getBullets() > 0) {
            PlayerId nearestZombie = getNearestEnemy(field);
            if (nearestZombie != null) {
                lastPos.remove(myId);
                return new Shoot(nearestZombie);
            }
        }

        // stuck, mostly because of dead body
        if (lastPos.containsKey(myId) && lastPos.get(myId).equals(myPos)) {
            return Move.randomMove();
        }

        // walk towards dead bodies
        Point nearestDeadBody = getNearestDeadBody(field);
        if (nearestDeadBody != null) {
            Move move = Move.inDirection(nearestDeadBody.x - CENTRE_OF_VISION, nearestDeadBody.y - CENTRE_OF_VISION);
            lastPos.put(myId, myPos);
            return move;
        }

        lastPos.remove(myId);
        return Move.randomMove();
    }

    // add surrounding dead bodies to empty bodies
    private void addEmptyBodies(PlayerId[][] field) {
        for (Move move : Move.values()) {
            PlayerId player = field[CENTRE_OF_VISION + move.x][CENTRE_OF_VISION + move.y];
            if (player != null && "DeadBody".equals(player.getName())) {
                emptyDeadBodies.add(player);
            }
        }
    }

    // distance from centre, for example 5 if x=7 and y=3
    private int distanceFromCentre(int x, int y) {
        int dx = Math.abs(CENTRE_OF_VISION - x);
        int dy = Math.abs(CENTRE_OF_VISION - y);
        return Math.max(dx, dy);
    }

    // return nearest enemy or null if none exists
    private PlayerId getNearestEnemy(PlayerId[][] field) {
        int minOffset = Integer.MAX_VALUE;
        PlayerId nearestEnemy = null;
        for (int x = CENTRE_OF_VISION - SHOOT_RANGE; x <= CENTRE_OF_VISION + SHOOT_RANGE; x++) {
            for (int y = CENTRE_OF_VISION - SHOOT_RANGE; y <= CENTRE_OF_VISION + SHOOT_RANGE; y++) {
                int offset = distanceFromCentre(x, y);
                PlayerId player = field[x][y];
                if (player != null && isEnemy(player.getName()) && offset < minOffset) {
                    minOffset = offset;
                    nearestEnemy = field[x][y];
                }
            }
        }
        return nearestEnemy;
    }

   // return nearest dead body or null if none exists
    private Point getNearestDeadBody(PlayerId[][] field) {
        int minOffset = Integer.MAX_VALUE;
        Point nearestDeadBody = null;
        for (int x = CENTRE_OF_VISION - SHOOT_RANGE; x <= CENTRE_OF_VISION + SHOOT_RANGE; x++) {
            for (int y = CENTRE_OF_VISION - SHOOT_RANGE; y <= CENTRE_OF_VISION + SHOOT_RANGE; y++) {
                int offset = distanceFromCentre(x, y);
                PlayerId player = field[x][y];
                if (player != null && "DeadBody".equals(player.getName()) && offset < minOffset && 
                        !emptyDeadBodies.contains(player)) {
                    minOffset = offset;
                    nearestDeadBody = new Point(x, y);
                }
            }
        }
        return nearestDeadBody;
    }

    private boolean isEnemy(String name) {
        switch (name) {
            case "ZombieHater":
            case "DeadBody":
            case "EmoWolfWithGun": // don't bother shooting him
                return false;
            default:
                return true;
        }
    }
}

-1। বাস্তবায়নের ক্ষেত্রে আলাদা থাকাকালীন, এটি আমার গর্ডন ফ্রিম্যানের মতোই একই রকম ....
কাইল কানোস

2
@KyleKanos। এটি একই ধারণা, তবে প্রয়োগের বিশদ গণনা করে। উদাহরণস্বরূপ, মৃতদেহগুলির মধ্যে কোনটি লুটে গেছে তার খোঁজ রাখা একটি উদ্ভাবন।
জেমস_পিক

ওহ, এবং লুণ্ঠন ট্র্যাকিং বিষয়, PlayerIdএকজন যথাযথ বাস্তবায়নের হয়েছে equalsএবং hashCodeআর একটি প্লেয়ার এর "জীবন" সর্বত্র অবশেষ একই (এটি শুধুমাত্র পরিবর্তন যখন তারা মারা বা চালু), তাই আপনি এটি সহজ রাখার খুঁজে পেতে পারেন PlayerIdএ গুলি emptyDeadBodiesপরম চেয়ে অবস্থান।
জেমস_পিক

@ কাইলকানোস আপনার যুক্তিটি অনুলিপি করা কখনই আমার উদ্দেশ্য ছিল না। আমি যা করেছি তা হ'ল আমার নিজের বটটি তৈরি করা যা আমি মনে করি এটি সবচেয়ে ভাল করবে।
কমনগ্যুই

1
দুর্দান্ত মোডস! আমি ভাবতে শুরু করেছিলাম যে বেশিরভাগ কৌশলগুলি মূলত একই ছিল, তবে সেই আন্দোলনের এলোমেলোভাবে আপনাকে একটি বিশাল উত্সাহ দিয়েছে!
জেমস_পিক

6

ভোরটিগ্যান্ট

ডক্টর গর্ডন ফ্রিম্যানকে সর্বদা অনুসরণ করবে, বা যদি সে একই মাত্রায় না থাকে তবে নিরপেক্ষভাবে ঘুরে বেড়াবে।

package player;

import java.util.ArrayList;

import zombie.*;

public class Vortigaunt implements Player {
    class PlayerLocation {
        private int x;
        int y;
        PlayerId player;

        public PlayerLocation(int x, int y, PlayerId id) {
            this.x = x;
            this.y = y;
            this.player = id;
        }

        public int getX() {
            return x;
        }

        public int getY() {
            return y;
        }

        public PlayerId getPlayer() {
            return player;
        }
    }
    @Override
    public Action doTurn(PlayerContext context) {
        PlayerId[][] field = context.getPlayField();
        PlayerLocation me = new PlayerLocation(context.getX(), context.getY(), context.getId());
        ArrayList<PlayerLocation> freemans = findFreeman(field);
        PlayerLocation nearestFreeman = getNearestFreeman(freemans, me);
        if (nearestFreeman == null) {
            return Move.randomMove();
        } else {
            return Move.inDirection(nearestFreeman.getX(), nearestFreeman.getY());
        }
    }

    private PlayerLocation getNearestFreeman(ArrayList<PlayerLocation> freemans, PlayerLocation me) {
        double nearestDistance = Integer.MAX_VALUE;
        PlayerLocation nearestFreeman = null;
        for (PlayerLocation freeman : freemans) {
            int x = freeman.getX() - me.getX();
            int y = freeman.getY() - me.getY();
            double distance = (int)Math.sqrt((double)(x * x + y * y));
            if (distance < nearestDistance) {
                nearestDistance = distance;
                nearestFreeman = freeman;
            }
        }
        return nearestFreeman;
    }

    private ArrayList<PlayerLocation> findFreeman(PlayerId[][] field) {
        ArrayList<PlayerLocation> freemans = new ArrayList<PlayerLocation>();
        for (int x = field.length; x >= 0; x -= 1) {
            for (int y = field[x].length; y >= 0; y -= 1) {
                if (field[x][y].getName().equals("GordonFreeman")) {
                    freemans.add(new PlayerLocation(x, y, field[x][y]));
                }
            }
        }
        return freemans;
    }

}

সুতরাং আপনি অঙ্কুর না ... কিন্তু কেউ কী পাসে বিদ্ধ ... যদি এই পেতে ফ্রিম্যান নিহত আমি বলতে পারবো না কিন্তু এই বোকচন্দর জনগোষ্ঠী জন্য ভয়ঙ্কর হতে হবে ...
kaine

6

কোকুন - ফ্রিজ

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

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

আপডেট করা হয়েছে

কোকুন এখন এমন রাস্তাগুলি উপেক্ষা করে যা এটির রাউটিং অ্যালগরিদমে জম্বিগুলির আকর্ষণীয় দূরত্বের মধ্যে নিয়ে যায় এবং জম্বিগুলি যখন 3 টি (স্কোর কোকুন তৈরির জন্য) পরিবর্তে 2 স্কোয়ারের মধ্যে থাকে তখন গুলি করে।

module player.Cocoon where
  import zombie.FregeBindings
  import frege.data.TreeMap
  import Data.List(sortBy)
  import Data.Foldable(minimumBy, maximumBy)

  instance Ord PlayerId where
    a <=> b = case a.getName <=> b.getName of
      Eq -> a.getNumber <=> b.getNumber
      x -> x

  instance Show Action where
    show action = action.toString

  -- Dijkstras shortest path algorithm
  data DijkstraNode = Green {d :: Int, pos :: (Int, Int)} | Red {pos :: (Int, Int)} | Yellow {d :: Int, pos :: (Int, Int)}
  data DijkstraState = DijkstraState {board :: Tree (Int, Int) DijkstraNode, yellows :: TreeSet DijkstraNode}
  derive Eq DijkstraNode
  derive Ord DijkstraNode
  derive Show DijkstraNode
  derive Show DijkstraState

  updateState :: Int -> DijkstraState -> (Int, Int) -> DijkstraState
  updateState d (oldState@DijkstraState {board, yellows}) pos  = case (lookup board pos) of
    Nothing -> oldState
    Just Green {d, pos} -> oldState
    Just Red {pos} -> let
        newYellow = Yellow d pos
        newYellows = insert yellows newYellow ()
        newBoard = update board pos newYellow
      in DijkstraState {board = newBoard, yellows = newYellows}
    Just (oldYellow@Yellow {d = oldD, pos = oldPos})
          | oldD <= d = oldState
          | true = let
              newYellow = Yellow d pos
              newYellows = insert (delete yellows oldYellow) newYellow ()
              newBoard = insert board pos newYellow
            in DijkstraState {board = newBoard, yellows = newYellows}

  neighbours :: (Int, Int) -> [(Int, Int)]
  neighbours (x,y) = [(x1 + x, y1 + y) | x1 <- [-1 .. 1], y1 <- [-1 .. 1], x1 != 0 || y1 != 0]

  moveRegion = [(x, y) | x <- [-1 .. 1], y <- [-1 .. 1]]

  findMove :: DijkstraState -> Maybe Move
  findMove DijkstraState {board, yellows}
     | null yellows = Nothing
     | true = let
         tip@Yellow{d, pos} = head (keys yellows)
         rest = delete yellows tip
         newBoard = insert board pos (Green d pos)
         intermediateState = DijkstraState {board = newBoard, yellows = rest}
         neighbourhood = [node | pos <- moveRegion , node <- lookup board pos]
       in if tip.pos == (0, 0)
          then case minimum neighbourhood of
            _ | null neighbourhood = Nothing
            Green {d, pos = (x,y)} -> Just (Move.inDirection x y)
            _ -> Nothing
          else findMove (fold (updateState (d + 1)) intermediateState (neighbours pos))

  insertRed :: Tree (Int, Int) DijkstraNode -> (Int, Int) -> Tree (Int, Int) DijkstraNode
  insertRed board pos = insert board pos (Red {pos})

  removeZombieTerritory :: PlayerContext -> Tree (Int, Int) DijkstraNode -> Tree (Int, Int) DijkstraNode
  removeZombieTerritory ctx board =
    let
      zombies = [pos | pos@(x,y) <- v2, pid <- ctx.lookAround x y, pid.getName == "Zombie"]
      zombieTerritory = [(x + xx, y + yy) | (x,y) <- zombies, xx <- [-2..2], yy <- [-2..2]]
    in fold Tree.delete board zombieTerritory

  v = [-visionRange .. visionRange]
  v2 = sortBy (comparing dist) [(x,y) | x <- v, y <- v]

  shootable = sortBy (comparing dist) [(x, y) | x <- [-shootRange .. shootRange], y <- [-shootRange .. shootRange]]

  moveTo :: (Int, Int) -> PlayerContext -> Maybe Move
  moveTo pos ctx =
    let
      rawBoard = fold insertRed Tree.empty ([p | p@(x, y) <- v2,
                                                  ctx.lookAround x y == Nothing] ++ [(0,0)])
      board = removeZombieTerritory ctx rawBoard
      yellows = Tree.insert Tree.empty (Yellow {d = 0, pos}) ()
    in findMove (DijkstraState {board, yellows})

  dist :: (Int, Int) -> Int
  dist (x,y) = max (abs x) (abs y)

  findBullets :: PlayerContext -> TreeSet PlayerId -> Maybe Action
  findBullets ctx emptyBodies =
    if (ctx.getBullets > 0) then Nothing
    else
      let
        viableBodies = [pos | pos@(x,y) <- v2, pid <- (ctx.lookAround x y), pid.getName == "DeadBody", lookup emptyBodies pid == Nothing]
      in case viableBodies of
         target : _ -> moveTo target ctx
         _ -> Nothing

  isThreat :: String -> (Int, Int) -> Bool
  isThreat name pos = case (name, pos) of
    ("Zombie", pos) | dist pos <= 2 -> true
    ("HideyTwitchy", _) -> true
    ("ZombieHater", _) -> true
    ("ZombieRightsActivist", _) -> true
    ("Gunner", _) -> true
    _ -> false

  shootThreats :: PlayerContext -> Maybe Action
  shootThreats ctx =
    let
      threats = [pid | pos@(x, y) <- shootable, pid <- ctx.lookAround x y, isThreat (pid.getName) pos]
    in case threats of
      target:_ | ctx.getBullets == 0 = Nothing
               | true = Just (Shoot.new target)
      _ -> Nothing

  coziness :: PlayerContext -> (Int, Int) -> Int
  coziness ctx (x,y) =
    let
      wallScores = [3 - dist (xx, yy) | xx <- [-2 .. 2],
                                        yy <- [-2 .. 2],
                                        xx != 0 || yy != 0,
                                        pid <- ctx.lookAround (x + xx) (y + yy),
                                        pid.getName == "DeadBody"]
    in 3 * sum wallScores - dist (x,y)

  gotoCoziest :: PlayerContext -> Maybe Action
  gotoCoziest ctx =
    let
      emptySquares = [pos | pos@(x, y) <- v2, ctx.lookAround x y == Nothing] ++ [(0,0)]
      coziest = maximumBy (comparing (coziness ctx)) emptySquares
    in if null emptySquares then Nothing
       else moveTo coziest ctx

  updateEmptyBodies :: PlayerContext -> TreeSet PlayerId -> TreeSet PlayerId
  updateEmptyBodies ctx current =
    let
      nearbyBodies = [pid | (x,y) <- neighbours (0,0), pid <- ctx.lookAround x y, pid.getName == "DeadBody"]
    in fold (\x -> \y -> insert x y ()) current nearbyBodies

  doStep :: TreeSet PlayerId -> PlayerContext -> Continue
  doStep !bodies ctx =
    let
      emptyBodies = updateEmptyBodies ctx bodies
      plan = (findBullets ctx emptyBodies) `mplus` (shootThreats ctx) `mplus` (gotoCoziest ctx)
    in case plan of
      Just action -> Continue {result = action, andThen = doStep emptyBodies}
      Nothing -> Continue {result = Move.stay, andThen = doStep emptyBodies}

  doTurn = doStep Tree.empty

4

গনার - জাভা

আপনাকে অবরুদ্ধ করার জন্য এখানে একটি উদাহরণ। তিনি যা কিছু দেখেন তাকে অঙ্কুর করে দেয় বা আশেপাশে কিছু না থাকলে বা উদ্দেশ্যহীনভাবে ঘোরাফেরা করে, বা তার কোনও বুলেট নেই।

package player;

import zombie.*;

public class Gunner implements Player {

    @Override
    public Action doTurn(PlayerContext context) {
        if (context.getBullets() > 0) {
            for (PlayerId player: context.shootablePlayers()) {
                switch(player.getName()) {
                    case "Gunner":
                    case "DeadBody":
                        break;
                    default:
                        return new Shoot(player);
                }
            }
        }
        return Move.randomMove();
    }

}

যদি আপনার কোন ভাল করতে পারি?


3

HideyTwitchy

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

package player;

import static java.lang.Math.*;
import java.awt.Point;
import java.util.HashSet;
import java.util.Set;

import zombie.*;
import static zombie.Constants.*;

public class HideyTwitchy implements Player {

    private Set<Integer> lootedCorpseIds = new HashSet<Integer>();

    @Override
    public Action doTurn(PlayerContext context) {
        Action action = null;

        Point playerP = getClosestPlayerPoint(context);
        Point corpseP = getClosestCorpsePoint(context); 
        Point enemyP = getClosestEnemyPoint(context);

        if (isWithinArea(playerP, Constants.SHOOT_RANGE, Constants.SHOOT_RANGE)) {
            //player spotted within 5x5
            if (context.getBullets() > 0) {
                action = getShootAction(playerP, context); //shoot!
            } else {
                action = getMoveAwayFromPoint(playerP); //run!
            }
        } else if (isWithinArea(enemyP, Constants.VISION_RANGE, Constants.VISION_RANGE)) {
            //players or zombie spotted within 8x8
            action = getMoveAwayFromPoint(enemyP); //run!
        } else if (isWithinArea(corpseP, Constants.VISION_RANGE, Constants.VISION_RANGE)) {
            //corpse spotted within 8x8

            int uniqueCorpseId = getPlayerIdAtPoint(context, corpseP).getNumber();
            if (isWithinArea(corpseP, 1, 1)) {
                //loot the corpse and get the heck away from it
                lootedCorpseIds.add(uniqueCorpseId);
                action = getMoveAwayFromPoint(corpseP);
            } else if (context.getBullets() == 0 && !lootedCorpseIds.contains(uniqueCorpseId)) {
                action = getMoveTowardsPoint(corpseP); //loot corpse if not looted!
            } 
        } else {
            //randomly move
            action = Move.randomMove();
        }

        return action;
    }

    private PlayerId getPlayerIdAtPoint(PlayerContext context, Point p) {
        return context.getPlayField()[(int) p.getX()][(int) p.getY()];
    }

    private Move getMoveTowardsPoint(Point p) {
        return Move.inDirection((int)p.getX() - CENTRE_OF_VISION, (int)p.getY() - CENTRE_OF_VISION);
    }

    private Move getMoveAwayFromPoint(Point p) {
        return Move.inDirection(CENTRE_OF_VISION - (int)p.getX(), CENTRE_OF_VISION - (int)p.getY());
    }

    private Shoot getShootAction(Point p, PlayerContext context) {
        PlayerId id = context.getPlayField()[(int) p.getX()][(int) p.getY()];
        Shoot shootAction = new Shoot(id);

        return shootAction;
    }

    private boolean isWithinArea(Point p, int x, int y) {
        return p != null 
                && abs(CENTRE_OF_VISION - p.getX()) <= x
                && abs(CENTRE_OF_VISION - p.getY()) <= y;
    }

    private Point getClosestEnemyPoint(PlayerContext context) {
        String[] lookFor = {};
        String[] avoid = {Dead.DEADBODYNAME};
        Point p = getClosestEntity(context, lookFor, avoid);

        return p;
    }

    private Point getClosestPlayerPoint(PlayerContext context) {
        String[] lookFor = {};
        String[] avoid = {Dead.DEADBODYNAME, Dead.ZOMBIENAME};
        Point p = getClosestEntity(context, lookFor, avoid);

        return p;
    }

    private Point getClosestCorpsePoint(PlayerContext context) {
        String[] lookFor = {Dead.DEADBODYNAME};
        String[] avoid = {Dead.ZOMBIENAME};
        Point p = getClosestEntity(context, lookFor, avoid);

        return p;
    }

    private Point getClosestEntity(PlayerContext context, String[] lookFor, String[] avoid) {

        int bestDistance = Integer.MAX_VALUE;
        Point closestPoint = null;

        for (int x = 0; x < VISION_WIDTH; x++) {
            for (int y = 0; y < VISION_WIDTH; y++) {


                PlayerId playerAtLocation = context.getPlayField()[x][y];

                if (playerAtLocation != null && !playerAtLocation.equals(context.getId())) {
                    //not empty and not me

                    boolean conditionsMet = true;
                    for (String lookForName : lookFor) {
                        conditionsMet |= playerAtLocation.getName().equals(lookForName);
                    }

                    for (String avoidName : avoid) {
                        conditionsMet &= !playerAtLocation.getName().equals(avoidName);
                    }

                    if (conditionsMet) {
                        int distance = max(abs(x - CENTRE_OF_VISION), abs(y - CENTRE_OF_VISION));
                        if (distance < bestDistance) {
                            bestDistance = distance;
                            closestPoint = new Point(x, y);
                        }
                    }
                }
            }
        }

        return closestPoint;
    }
}

3

সুপারকার্ড - জাভা আমি দ্বৈত জমা দেওয়ার বিষয়ে জানি তবে আমি কেবল প্রতিরোধ করতে পারিনি। আমার এটি অপসারণ করা উচিত কিনা দয়া করে আমাকে বলুন।

কাকে কী ধরনের কাপুরুষ সে গুলি করে মারামারি করে? আপনাকে সুপার কাউয়ার্ড উপস্থাপন করে , তিনি কে শত্রু এবং জম্বি বলে মনে করেন এড়াতে চেষ্টা করে মাঠে নামবেন। সে নিরাপদে থাকার চেষ্টা করে এবং বাধা এড়ায়। যদি তিনি কোনও ভাল রুট না পান তবে আতঙ্ক এবং স্থানে থাকে

package player;

import zombie.*;
import static zombie.Constants.*;

import static java.lang.Math.abs;
import static java.lang.Math.max;

import java.awt.Point;

public class SuperCoward implements Player {

    private enum DANGER{
        SAFE(0),PROBABLY_SAFE(1),UNSAFE(2),DANGER(3);

        private int value;
        private DANGER(int value){
            this.value = value;
        }
    }

    private final int PLAYER_X = 8;
    private final int PLAYER_Y = 8;

    @Override
    public Action doTurn(PlayerContext context) {

        DANGER danger = DANGER.DANGER;
        Point position = null;
        for(int i=-1;i<1;i++){
            for(int j=-1;j<1;j++){
                DANGER positionDanger = isDangerous(context,PLAYER_X+i,PLAYER_Y+j);
                if(positionDanger.value < danger.value){
                    if(canMove(context,PLAYER_X+i,PLAYER_Y+j)){
                        position = new Point(PLAYER_X+i, PLAYER_Y+j);
                    }
                }
            }
        }

        if(position != null){
            return Move.inDirection(position.x, position.y);
        }else{
            return Move.STAY;
        }
    }

    private boolean canMove(PlayerContext context,int posX, int posY){
         PlayerId playerAtLocation = context.getPlayField()[posX][posY];
        if(playerAtLocation == null){
            return true;
        }else{
            return false;
        }
    }

    private DANGER isDangerous(PlayerContext context,int posX, int posY){
        DANGER danger = DANGER.SAFE;

          for (int x = 0; x < VISION_WIDTH; x++) {
                for (int y = 0; y < VISION_WIDTH; y++) {
                     PlayerId playerAtLocation = context.getPlayField()[x][y];

                     if(playerAtLocation != null && isEnemy(playerAtLocation.getName())){
                         int distanceToPlayer = max(abs(x - posX), abs(y - posY));
                         if(playerAtLocation.getName().equals("Zombie")){
                             DANGER currentDanger = null;
                             if(distanceToPlayer <=3){
                                 currentDanger = DANGER.DANGER;
                             }else if(distanceToPlayer <=5){
                                 currentDanger = DANGER.PROBABLY_SAFE;
                             }else if(distanceToPlayer >5){
                                 currentDanger = DANGER.SAFE;
                             }
                             if(currentDanger.value > danger.value){
                                 danger = currentDanger;
                             }
                         }else{
                             DANGER currentDanger = null;
                             if(distanceToPlayer <=5){
                                 currentDanger = DANGER.DANGER;
                             }else if(distanceToPlayer >5){
                                 currentDanger = DANGER.PROBABLY_SAFE;
                             }
                             if(currentDanger.value > danger.value){
                                 danger = currentDanger;
                             }
                         }
                     }
                }
          }
        return danger;
    }

    private boolean isEnemy(String name){
         switch(name) {
            case "DeadBody":
            case "GordonFreeman":
            case "EmoWolfWithAGun":
            case "HuddleWolf":
            case "ThePriest":
            case "Shotguneer":
            case "SuperCoward":
                return false;
            default:
                return true;
         }
    }
}

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

3
+1 এর জন্যDANGER danger = DANGER.DANGER;
আন্দ্রে কোস্টায়রকা

3

Shotguneer

আমি স্বীকার করব যে আমার মূল লক্ষ্যটি গনারকে গুলি করা।

package player;

import zombie.*;
import static zombie.Constants.*;
import static java.lang.Math.*;

public class Shotguneer implements Player {

    @Override
    public Action doTurn(PlayerContext context) {

        double sdistance=1000;

        if (context.getBullets() > 0) {
            for (PlayerId player: context.shootablePlayers()) {
                switch(player.getName()) {
                    case "Gunner":
                    case "ZombieRightsActivist":
                    case "HideyTwitchy":
                    case "ZombieHater":
                    case "Waller";
                    case "Bee";
                    case "SunTzu";
                    //case "Fox":
                    //case "Coward":
                        return new Shoot(player);
                    default:
                        break;
                }
            }
            boolean zombies=false;
            PlayerId TargetZombie = context.getId();
            for (int x = -3; x < +4; x++) {
            for (int y = -3; y < +4; y++) {
                double distance = sqrt(pow(x,2)+pow(y,2));
                PlayerId playerAtLocation = context.getPlayField()[x + CENTRE_OF_VISION][y + CENTRE_OF_VISION];
                if (playerAtLocation != null && playerAtLocation.getName().equals("Zombie") && (distance < sdistance ||zombies==false)) {
                    sdistance = distance;
                    zombies=true;
                    TargetZombie=playerAtLocation;
                }
                //if (playerAtLocation != null && playerAtLocation.getName().equals("Priest") && distance < 2 &&zombies==false) {
                    //TargetZombie=playerAtLocation;
                    //sdistance=distance;
                //}
            }}
            if (zombies || sdistance<3) {
                return new Shoot(TargetZombie);
            }
        }

        if (context.getPlayField()[CENTRE_OF_VISION-1][CENTRE_OF_VISION-1]==null){
            return Move.NORTHWEST;  
        } else if (context.getPlayField()[CENTRE_OF_VISION][CENTRE_OF_VISION-1]==null){
            return Move.NORTH;
        } else {
            return Move.WEST;
        }

    }

}

@ বেনি আপনি কীভাবে এটি করতে পারেন যাতে আপনাকে আর সম্পাদনা করতে হবে না?
কেইন

যেমন এটি দাঁড়িয়েছে, এটি সংকলন করে না। আমি এটি ঠিক করতে গিয়েছিলাম, তবে কয়েকটি জায়গা রয়েছে যেখানে কোডটির মূল অভিপ্রায়টি কী ছিল তা আমি বুঝতে পারি না (উদাহরণস্বরূপ, সংকলকটি অভিযোগ করেছে যা TargetZombieআরম্ভ করা হতে পারে না, এবং আমি নিশ্চিত না যে কি আপনি করতে চান)। আপনি কি এটিতে অন্য দোল নিতে চান?
জেমস_পিক

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

আমি এটিকে ঠিক করে রেখেছি যাতে এটি ত্রুটি ছাড়াই সংকলন ও চালিত হয় - বেশিরভাগই "বাই দ্বারা CENTRE_OF_VISION" ত্রুটিগুলি এবং কিছু এনপিইগুলি। আপনি রান ( jamespic.github.io/zombies/2014-07-23/0.html ) একবার দেখে নিতে পারেন এটি আপনার প্রত্যাশাটি কি করছে?
জেমস_পিক

দেখে মনে হচ্ছে আপনি গনারের আয়ু নিয়ে একটি বড় প্রভাব ফেলেছেন! আমি ভাবছি যে এটি কি শীর্ষ প্রতিযোগীদের একে অপরকে বাইরে নিয়ে যাওয়ার waveেউ ছড়িয়ে দেবে?
জেমস_পিক

2

সোকি - জাভা

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

package player;

import zombie.*;
import static zombie.Constants.*;

import static java.lang.Math.abs;
import static java.lang.Math.max;

import java.awt.Point;
import java.util.HashMap;
import java.util.Map;

public class Sokie implements Player {

    public static Map<Point, Sokie> myPack = new HashMap<>();
    private PlayerContext context;
    private Move moveDirection;
    private final int PLAYER_X = 8;
    private final int PLAYER_Y = 8;

    private enum DANGER {
        SAFE(0), PROBABLY_SAFE(1), UNSAFE(2), DANGER(3);

        private int value;

        private DANGER(int value) {
            this.value = value;
        }
    }

    @Override
    public Action doTurn(PlayerContext context) {
        Point p = new Point(context.getX(), context.getY());
        myPack.put(p, this);
        this.context = context;

        int friends = 0;
        int deadbodyDistance = Integer.MAX_VALUE;
        Move deadbodyDirection = null;
        Point deadBodyPosition = null;
        Move friendsDirection = Move.SOUTHWEST;

        // Find the closest friend to whom we can move
        int maxDistance = Integer.MAX_VALUE;
        for (Sokie bp : myPack.values()) {
            // Skip ourselves
            if (bp.context.equals(context)) {
                continue;
            }
            Point pos = bp.getPosition();
            int x = pos.x;
            int y = pos.y;
            int distance = Math.max(Math.abs(context.getX() - x),
                    Math.abs(context.getY() - y));
            if (distance < maxDistance) {
                if (canMove(context, (int) Math.signum(x), (int) Math.signum(y))
                        && !isDangerous(context, (int) Math.signum(x),
                                (int) Math.signum(y))) {
                    maxDistance = distance;
                    friendsDirection = Move.inDirection((int) Math.signum(x),
                            (int) Math.signum(y));
                } else {
                    if (canMove(context, (int) Math.signum(0),
                            (int) Math.signum(y))
                            && !isDangerous(context, (int) Math.signum(x),
                                    (int) Math.signum(y))) {
                        maxDistance = distance;
                        friendsDirection = Move.inDirection(
                                (int) Math.signum(0), (int) Math.signum(y));
                    } else if (canMove(context, (int) Math.signum(x),
                            (int) Math.signum(0))
                            && !isDangerous(context, (int) Math.signum(x),
                                    (int) Math.signum(y))) {
                        maxDistance = distance;
                        friendsDirection = Move.inDirection(
                                (int) Math.signum(x), (int) Math.signum(0));
                    }
                }
            }
        }

        // Find how many friends we have in close vicinity
        for (int x = 0; x < VISION_WIDTH; x++) {
            for (int y = 0; y < VISION_WIDTH; y++) {
                PlayerId playerAtLocation = context.getPlayField()[x][y];
                if (playerAtLocation != null
                        && playerAtLocation.getName().equals("Sokie")) {
                    friends++;
                }
            }
        }

        // Search for dead bodies
        for (int y = 1; y < VISION_WIDTH - 1; y++) {
            for (int x = 1; x < VISION_WIDTH - 1; x++) {

                PlayerId playerAtLocation = context.getPlayField()[x][y];
                // find a dead body
                if ((playerAtLocation != null)
                        && "DeadBody".equals(playerAtLocation.getName())) {
                    // check adjacent squares for an empty square
                    for (int yy = -1; yy <= +1; yy++) {
                        for (int xx = -1; xx <= +1; xx++) {
                            PlayerId playerNearby = context.getPlayField()[x
                                    + xx][y + yy];
                            if (playerNearby == null) {
                                int distance = max(abs(xx + x
                                        - CENTRE_OF_VISION), abs(yy + y
                                        - CENTRE_OF_VISION));
                                if (distance < deadbodyDistance) {
                                    deadbodyDistance = distance;
                                    deadBodyPosition = getAbsolutePosition(
                                            context, x + xx, y + yy);
                                    deadbodyDirection = Move.inDirection(xx + x
                                            - CENTRE_OF_VISION, yy + y
                                            - CENTRE_OF_VISION);
                                }
                            }
                        }
                    }
                }
            }
        }

        // If we have atleast 2 people close, stay or try to shoot
        // otherwise move randomly, try to find bodies and packs
        if (friends >= 2) {
            // Shoot anybody close
            if (context.getBullets() > 0) {
                int distEnemy = VISION_WIDTH;
                int distZombie = VISION_WIDTH;
                PlayerId targetEnemy = null;
                PlayerId targetZombie = null;
                for (int x = CENTRE_OF_VISION - SHOOT_RANGE; x <= CENTRE_OF_VISION
                        + SHOOT_RANGE; x++) {
                    for (int y = CENTRE_OF_VISION - SHOOT_RANGE; y <= CENTRE_OF_VISION
                            + SHOOT_RANGE; y++) {
                        PlayerId player = context.getPlayField()[x][y];
                        if (player != null) {
                            int dist = getDistance(x, y);
                            if (player.getName().equals("Zombie")) {
                                if (dist < distZombie) {
                                    distZombie = dist;
                                    targetZombie = player;
                                }
                            } else if (isEnemy(player.getName())
                                    && dist <= distEnemy) {
                                distEnemy = dist;
                                targetEnemy = context.getPlayField()[x][y];
                            }
                        }
                    }
                }

                if (targetZombie != null && distZombie <= 2) {
                    return new Shoot(targetZombie);
                } else if (targetEnemy != null && distEnemy <= 5) {
                    return new Shoot(targetEnemy);
                }
            }

            for (Sokie bp : myPack.values()) {
                // If someone in the pack has ammo, stay
                if (bp.getAmmo() > 0) {
                    return Move.STAY;
                }
            }

            // If there are bodies close, try to reach them
            int bodyDistance = deadbodyDistance;
            if (deadbodyDistance <= 5) {
                for (Sokie bp : myPack.values()) {
                    int distanceBody = Math.max(
                            Math.abs(deadBodyPosition.x - bp.context.getX()),
                            Math.abs(deadBodyPosition.y - bp.context.getY()));
                    if (deadbodyDistance > distanceBody) {
                        bodyDistance = distanceBody;
                    }
                }
            }
            // If we are not the closest to the body, stay
            if (bodyDistance < deadbodyDistance) {
                return Move.STAY;
            } else {
                return deadbodyDirection;
            }
        } else {
            // We try to reach our closest friend
            // If we are in danger, either fight or run
            if (areWeInDanger(context, PLAYER_X, PLAYER_Y)) {
                if (context.getBullets() > 0) {
                    int distEnemy = VISION_WIDTH;
                    int distZombie = VISION_WIDTH;
                    PlayerId targetEnemy = null;
                    PlayerId targetZombie = null;
                    for (int x = CENTRE_OF_VISION - SHOOT_RANGE; x <= CENTRE_OF_VISION
                            + SHOOT_RANGE; x++) {
                        for (int y = CENTRE_OF_VISION - SHOOT_RANGE; y <= CENTRE_OF_VISION
                                + SHOOT_RANGE; y++) {
                            PlayerId player = context.getPlayField()[x][y];
                            if (player != null) {
                                int dist = getDistance(x, y);
                                if (player.getName().equals("Zombie")) {
                                    if (dist < distZombie) {
                                        distZombie = dist;
                                        targetZombie = player;
                                    }
                                } else if (isEnemy(player.getName())
                                        && dist <= distEnemy) {
                                    distEnemy = dist;
                                    targetEnemy = context.getPlayField()[x][y];
                                }
                            }
                        }
                    }

                    if (targetZombie != null && distZombie <= 2) {
                        return new Shoot(targetZombie);
                    } else if (targetEnemy != null && distEnemy <= 5) {
                        return new Shoot(targetEnemy);
                    }
                } else {
                    DANGER danger = DANGER.DANGER;
                    Point position = null;
                    for (int i = -1; i < 1; i++) {
                        for (int j = -1; j < 1; j++) {
                            DANGER positionDanger = getDangerLevel(context,
                                    PLAYER_X + i, PLAYER_Y + j);
                            if (positionDanger.value < danger.value) {
                                if (canMove(context, PLAYER_X + i, PLAYER_Y + j)) {
                                    position = new Point(PLAYER_X + i, PLAYER_Y
                                            + j);
                                }
                            }
                        }
                    }

                    if (position != null) {
                        return Move.inDirection(position.x, position.y);
                    } else {
                        return Move.randomMove();
                    }
                }
            } else {
                return friendsDirection;
            }
        }
        return Move.randomMove();
    }

    private DANGER getDangerLevel(PlayerContext context, int posX, int posY) {
        DANGER danger = DANGER.SAFE;

        for (int x = 0; x < VISION_WIDTH; x++) {
            for (int y = 0; y < VISION_WIDTH; y++) {
                PlayerId playerAtLocation = context.getPlayField()[x][y];

                if (playerAtLocation != null
                        && isEnemy(playerAtLocation.getName())) {
                    int distanceToPlayer = max(abs(x - posX), abs(y - posY));
                    if (playerAtLocation.getName().equals("Zombie")) {
                        DANGER currentDanger = null;
                        if (distanceToPlayer <= 2) {
                            currentDanger = DANGER.DANGER;
                        } else if (distanceToPlayer <= 5) {
                            currentDanger = DANGER.PROBABLY_SAFE;
                        } else if (distanceToPlayer > 5) {
                            currentDanger = DANGER.SAFE;
                        }
                        if (currentDanger.value > danger.value) {
                            danger = currentDanger;
                        }
                    } else {
                        DANGER currentDanger = null;
                        if (distanceToPlayer <= 5) {
                            currentDanger = DANGER.DANGER;
                        } else if (distanceToPlayer > 5) {
                            currentDanger = DANGER.PROBABLY_SAFE;
                        }
                        if (currentDanger.value > danger.value) {
                            danger = currentDanger;
                        }
                    }
                }
            }
        }
        return danger;
    }

    private boolean isDangerous(PlayerContext context, int posX, int posY) {

        for (int x = 0; x < VISION_WIDTH; x++) {
            for (int y = 0; y < VISION_WIDTH; y++) {
                PlayerId playerAtLocation = context.getPlayField()[x][y];

                if (playerAtLocation != null
                        && isEnemy(playerAtLocation.getName())) {
                    int distanceToPlayer = max(abs(x - posX), abs(y - posY));
                    if (playerAtLocation.getName().equals("Zombie")) {
                        if (distanceToPlayer <= 2) {
                            return true;
                        }
                    } else {
                        if (distanceToPlayer <= 5) {
                            return true;
                        }
                    }
                }
            }
        }
        return false;

    }

    // calculates absolute position, from XY in our field of view
    private Point getAbsolutePosition(PlayerContext context, int relativeX,
            int relativeY) {
        int playerX = context.getX();
        int playerY = context.getY();

        return new Point(playerX + (relativeX - PLAYER_X), playerY
                + (relativeY - PLAYER_Y));
    }

    // Gets distance on the field
    private int getDistance(int x, int y) {
        return Math.max(Math.abs(PLAYER_X - x), Math.abs(PLAYER_Y - y));
    }

    public int getAmmo() {
        return context.getBullets();
    }

    public Point getPosition() {
        Point p = new Point(context.getX(), context.getY());
        return p;
    }

    public Move getMoveDirection() {
        return moveDirection;
    }

    // Quick check for dangers around us
    private boolean areWeInDanger(PlayerContext context, int posX, int posY) {
        for (int x = 0; x < VISION_WIDTH; x++) {
            for (int y = 0; y < VISION_WIDTH; y++) {
                PlayerId playerAtLocation = context.getPlayField()[x][y];

                if (playerAtLocation != null
                        && isEnemy(playerAtLocation.getName())) {
                    int distanceToPlayer = max(abs(x - posX), abs(y - posY));
                    if (playerAtLocation.getName().equals("Zombie")) {
                        if (distanceToPlayer <= 2) {
                            return true;
                        }
                    } else {
                        if (distanceToPlayer <= 5) {
                            return true;
                        }
                    }
                }
            }
        }
        return false;
    }

    private boolean canMove(PlayerContext context, int posX, int posY) {
        PlayerId playerAtLocation = context.getPlayField()[posX][posY];
        if (playerAtLocation == null) {
            return true;
        } else {
            return false;
        }
    }

    private boolean isEnemy(String name) {
        switch (name) {
        case "Sokie":
        case "DeadBody":
        case "GordonFreeman":
        case "EmoWolfWithAGun":
        case "HuddleWolf":
        case "ThePriest":
        case "Shotguneer":
        case "StandStill":
            return false;
        default:
            return true;
        }
    }

}

এফওয়াইআই, আপনার প্লেয়ারের নামটি আপনার ক্লাসের নামের মতো হবে (এই ক্ষেত্রে, "সোকি")। সুতরাং আমার সন্দেহ playerAtLocation.getName().equals("BetterInPacks2")হওয়া উচিত playerAtLocation.getName().equals("Sokie")
জেমস_পিক

Dang! আমি বিভিন্ন বাস্তবায়ন পরীক্ষা করার সময় কিছুটা বাকী কোড ছিল, আমি এটি কোনও সময়েই সংশোধন করব! আপনাকে ধন্যবাদ
sokie

2

মৌমাছি - পাইথন

দ্বিতীয় এন্ট্রি, তবে আমি ভেবেছিলাম অন্যরকম কিছু এবং ভিন্ন ভাষায় চেষ্টা করে দেখতে মজা হবে।

  • এখন মৌমাছিরা একই জায়গায় যাওয়া এড়াতে পারবে।
  • এখন আরও 'পাইথোনিক'
  • অনুকূল টারস আন্দোলন যাতে মৌমাছিরা রানির কাছে দ্রুত যেতে পারে (বোর্ডের আকারে অ্যাক্সেসের অনুমতি দেওয়ার জন্য জেমসকে ধন্যবাদ)

মৌমাছিরা একসাথে থাকতে পছন্দ করে, তাই তারা বেঁচে থাকা মৌমাছিদের একজনকে রানী মৌমাছি হিসাবে মনোনীত করে এবং তার দিকে ঝাঁকুনি দেয়। তারা তার কাছে যাওয়ার পথে প্রতিপক্ষকে ডানা দেবে, মানুষের চেয়ে জম্বি মাংসকে পছন্দ করবে।

from zombie import Player, Move, Shoot, PlayerRegistry, Constants

friends = ['Bee','Waller','DeadBody','ThePriest','StandStill','Vortigaunt','EmoWolfWithAGun']
MID = Constants.CENTRE_OF_VISION
BOARDSIZE = 1
sign = lambda x: (1, -1)[x<0]
isZombie = lambda player: player and player.getName() is "Zombie"
isEnemy = lambda player: player and player.getName() not in friends
isWall = lambda player: player and (player.getName() is "DeadBody" or player.getName() is "StandStill")
distance = lambda x1,y1,x2,y2: max(distance1d(x1,x2), distance1d(y1,y2))
distance1d = lambda x1,x2: min(abs(x1-x2), BOARDSIZE - abs(x1-x2))
Bees = {}
Shot = set()
MoveTo = set()  

def getDirection(x1, x2):  
    diff = x1 - x2  
    if abs(diff) > (BOARDSIZE // 2):
        return sign(diff)
    return -sign(diff)

class Bee(Player):  
    Queen = None
    QueenBeePosition = None
    X = Y = ID = 0
    LastTurn = -1   

    def doTurn(self, context): 
        global BOARDSIZE
        self.ID = context.id.number
        self.X = context.x
        self.Y = context.y
        BOARDSIZE = context.boardSize  
        self.setQueenBee(context.gameClock)                    
        action = self.sting(context)
        if action:
            return action
        return self.moveToQueenBee(context)     

    def setQueenBee(self, turn):
        if turn != Bee.LastTurn:
            Bee.LastTurn = turn     
            MoveTo.clear() # Clear the move set on new turn
        Bees[self.ID] = turn # Report In        
        if not Bee.Queen or (Bee.Queen and Bees[Bee.Queen] < turn - 1):
            Bee.Queen = self.ID
            Bee.QueenBeePosition = (self.X, self.Y)     

    def moveToQueenBee(self, context):
        if self.ID == Bee.Queen:
            return Move.randomMove()

        dist = distance(Bee.QueenBeePosition[0], Bee.QueenBeePosition[1], self.X, self.Y)
        if dist < 4:
            return Move.randomMove()

        signX = getDirection(self.X, Bee.QueenBeePosition[0])      
        signY = getDirection(self.Y, Bee.QueenBeePosition[1])      
        walls = 0
        field = context.playField
        for (deltaX, deltaY) in [(signX,signY),(signX,0),(0,signY),(signX,-signY),(-signX,signY)]:
            player = field[MID + deltaX][MID + deltaY]
            if isWall(player):
                walls += 1
            if not player:               
                point = frozenset([self.X+deltaX,self.Y+deltaY])            
                if point not in MoveTo:
                    MoveTo.add(point)                   
                    return Move.inDirection(deltaX,deltaY)
        if walls > 2:
            return Move.randomMove()
        return Move.STAY

    def sting(self, context):      

        if context.bullets < 1:
            return      
        field = context.playField
        closestZombie,closestPlayer = None,None
        closestZombieDist,bestDist = 3,5   
        for x in range(MID - 5, MID + 5):
            for y in range(MID - 5, MID + 5):
                player = field[x][y]
                if player and not isWall(player) and player not in Shot:
                    dist = distance(MID,MID,x,y)
                    if isZombie(player) and dist < closestZombieDist:   
                        closestZombieDist = dist
                        closestZombie = player
                    elif isEnemy(player) and dist < bestDist: 
                        bestDist = dist
                        closestPlayer = player

        if closestZombie:
            Shot.add(closestZombie)
            return Shoot(closestZombie)        

        if closestPlayer:
            Shot.add(closestPlayer)
            return Shoot(closestPlayer)        

PlayerRegistry.registerPlayer("Bee", Bee())

1
রাম রাম! আমি ভাবছিলাম যে এই প্রতিযোগিতায় জাভা ছাড়া আর কিছুই থাকবে না be
জেমস_পিক

হ্যাঁ, এবং প্রথম এন্ট্রি যা বিশ্বজুড়ে ক্ষেত্র অনুসন্ধান করে, যা আমার মনে হয় একটি ঝরঝরে বৈশিষ্ট্য।
মওপ

আপনি যে জিনিসটি দরকারী খুঁজে পেতে পারেন তা হ'ল জাইথন ​​স্বয়ংক্রিয়ভাবে জাভাবীনের বৈশিষ্ট্য হিসাবে উপলভ্য এবং সেটটার তৈরি করে। উদাহরণস্বরূপ, আপনি context.gameClockপরিবর্তে ব্যবহার করতে পারেন context.getGameClock()
জেমস_পিক

@ জামেস_পিক টিপটির জন্য ধন্যবাদ, এটি জানতেন না।
Moop

2

মিঃ অ্যাসেসিন

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

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

package player;
import zombie.*;
import static zombie.Constants.*;
//import static java.lang.Math.*;

public class Jack implements Player {
    @Override
    public Action doTurn(PlayerContext context) {
        int[] Ideal = {1,5,8,7,2,2,7,2,1,5,1,2,1,1,7,2,7,7,7,0,2,3,1,7};
        int[] Threat = {1,4,8,8,1,1,7,1,2,2,2,1,2,0,6,2,6,6,6,1,1,2,6,6};
        int[] Importance = {1,2,4,4,1,1,1,1,3,1,3,1,3,3,1,2,1,1,1,10,2,2,3,2};

        PlayerId Target = context.getId();
        int[][] Bob = {{800-2*Math.max(0,context.getGameClock()),400-Math.max(0,context.getGameClock()),800-Math.max(0,context.getGameClock())},{0,0,0},{0,0,0}};
        double maxDanger=0;
        int zombies=0;

        for (int x = -8; x < +8; x++) {
        for (int y = -8; y < +8; y++) {
            PlayerId playerAtLocation = context.getPlayField()[x + CENTRE_OF_VISION][y + CENTRE_OF_VISION];
            if (playerAtLocation != null && x*y+x+Math.abs(y) != 0){
                if (Math.abs(x)*Math.abs(y)==1 || Math.abs(x) + Math.abs(y)==1){
                    Bob[x+1][y+1]-=100000;
                }
                int dist = Math.max(Math.abs(x),Math.abs(y));
                int Ident = Dats(playerAtLocation);
                double Danger = (Threat[Ident]-dist)*Importance[Ident];
                if(Ident==1 && dist<Threat[Ident]){
                    zombies++;
                    if(context.getPlayField()[TFSAE(x)-1 + CENTRE_OF_VISION][TFSAE(y) -1+ CENTRE_OF_VISION]!=null){ 
                    Danger=0;
                                } else if(dist==2){Danger+=4;} 
                }
                if(Danger>maxDanger && dist<6){
                    maxDanger=Danger;
                    Target=playerAtLocation;
                }
                if(dist != Ideal[Ident]){

                    Bob[TFSAE(x)][TFSAE(y)] += Math.round(200*Importance[Ident]/(dist-Ideal[Ident]));

                    if(TFSAE(x) ==1) {
                        Bob[0][TFSAE(y)] += Math.round(100*Importance[Ident]/(dist-Ideal[Ident]));
                        Bob[2][TFSAE(y)] += Math.round(100*Importance[Ident]/(dist-Ideal[Ident]));
                    } else {
                        Bob[1][TFSAE(y)] += Math.round(100*Importance[Ident]/(dist-Ideal[Ident]));
                    }

                    if(TFSAE(y) ==1) {
                        Bob[TFSAE(x)][0] += Math.round(100*Importance[Ident]/(dist-Ideal[Ident]));
                        Bob[TFSAE(x)][2] += Math.round(100*Importance[Ident]/(dist-Ideal[Ident]));
                    } else {
                        Bob[TFSAE(x)][1] += Math.round(100*Importance[Ident]/(dist-Ideal[Ident]));
                    }
                }
            }
        }}

        if (context.getBullets()>1 && maxDanger>0){
            return new Shoot(Target);
        } else if (context.getBullets()==1 && zombies>3){
            return new Shoot(context.getId());
        } else if (context.getBullets()==1 && maxDanger>7){
            return new Shoot(Target);
        }

        int Xmax=0;
        int Ymax=0;

        for (int x = 0; x < 3; x++) {
        for (int y = 0; y < 3; y++) {
            if (Bob[x][y]>=Bob[Xmax][Ymax]){
                Xmax=x;
                Ymax=y;
            }
        }}
        return Move.inDirection(Xmax-1, Ymax-1);

    }

    private int Dats (PlayerId WhoDat){
        switch (WhoDat.getName()){
            case "DeadBody": return 0;
            case "Zombie": return 1;
            case "Fox": return 2;
            case "Coward": return 3;
            case "Shotguneer": return 4;
            case "HuddleWolf": return 5;
            case "Sokie": return 6;
            case "GordonFreeman": return 7;
            case "Vortigaunt": return 8;
            case "SuperCoward": return 9;
            case "StandStill": return 10;
            case "JohnNash": return 11;
            case "MoveRandomly": return 12;
            case "Waller": return 13;
            case "HideyTwitchy": return 14;
            case "Bee": return 15;
            case "ZombieHater": return 16;
            case "ZombieRightsActivist": return 17;
            case "Gunner": return 18;
            case "EmoWolfWithAGun": return 19;
            case "Jack": return 20;
              case "SOS": return 21;
              case "SunTzu": return 22;
            default: return 23;
        }

    }
    private int TFSAE(int TBN){
        if(TBN==0){return 1;
        } else if(TBN>0){return 2;}

        return 0;
    }
}

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

@ জেমস_পিক এটি গেমটিতে কাজ করেছে (যদিও এর আগের সংস্করণটি আমি কয়েকদিন আগে ক্লোন করেছি)। এটি কাজ করা উচিত. যদি তা আমাকে না দেয়। যদি এটি রবিবার না হয় তবে এটি মুছুন।
কেইন

কোডটির বর্তমান সংস্করণে এটি ঠিক আছে বলে মনে হচ্ছে। আমি আজকে পরে এটি একটি পরীক্ষায় অন্তর্ভুক্ত করব।
জেমস_পিক

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

বেশ জটিল এবং, আমি ধরে নিই, হাতের মুঠোয় হুমকি / দূরত্ব / অগ্রাধিকার ব্যবস্থাপনা।
থাইলন 21

1

এসওএস (দৃষ্টিতে অঙ্কুরিত)

package player;

import zombie.*;
import static zombie.Constants.*;
import static java.lang.Math.*;

public class SOS implements Player {

    @Override
    public Action doTurn(PlayerContext context) {
        if (context.getBullets() > 0) {
            for (PlayerId player: context.shootablePlayers()) {
                switch(player.getName()) {
                    case "Gunner":
                    case "Zombie":
                    case "ZombieRightsActivist":
                        return new Shoot(player);
                    default:
                        break;
                }
            }
        }
        Move bestDirection = Move.NORTH;
        int bestDistance = Integer.MAX_VALUE;
        for (int x = 0; x < VISION_WIDTH; x++) {
            for (int y = 0; y < VISION_WIDTH; y++) {
                int distance = max(abs(x - CENTRE_OF_VISION), abs(y - CENTRE_OF_VISION));
                PlayerId playerAtLocation = context.getPlayField()[x][y];
                if (playerAtLocation != null
                        && !(playerAtLocation.getName().equals("Zombie"))
                        && !(playerAtLocation.getName().equals("Gunner"))
                        && !(playerAtLocation.getName().equals("ZombieRightsActivist"))
                        && !(playerAtLocation.getName().equals("ZombieHater"))
                        && !(playerAtLocation.equals(context.getId()))
                        && distance < bestDistance) {
                    bestDistance = distance;
                    bestDirection = Move.inDirection(x - CENTRE_OF_VISION, y -CENTRE_OF_VISION);
                }
            }
        }
        return bestDirection;
    }
}

1

জন ন্যাশ - জাভাস্ক্রিপ্ট

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

জন ন্যাশ কেবল "চম্প" গুলি চালান - এমন বিরোধী যারা ইতিমধ্যে তাদের মন তৈরি করেছেন। অর্থাত্, তিনি সর্বদা গুলি চালানো শত্রুদের বা গুলি করেন না এমন শত্রুরা never বিরোধীদের আরও জটিল যুক্তি থাকলে তিনি একাই ছেড়ে যান।

যখন তিনি শুটিং করছেন না, তখন তিনি গুলি চালাচ্ছেন বা দক্ষিণে যাচ্ছেন।

var Constants = Packages.zombie.Constants
var Shoot = Packages.zombie.Shoot
var Move = Packages.zombie.Move
var Player = Packages.zombie.Player
var PlayerRegistry = Packages.zombie.PlayerRegistry

function mkSet() {
    var s = {}
    for (var i = 0; i < arguments.length; i++) {
        s[arguments[i]] = true
    }
    return s
}

var chumps = mkSet(
                "GordonFreeman",
                "HideyTwitchy",
                "Gunner",
                "MoveRandomly",
                "StandStill",
                "ThePriest",
                "Vortigaunt",
                "ZombieHater",
                "ZombieRightsActivist",
                "Bee",
                "Zombie",
                "SuperCoward"
              )

function dist(x, y) {
    return Math.max(Math.abs(x - Constants.CENTRE_OF_VISION), Math.abs(y - Constants.CENTRE_OF_VISION))
}

function range(width, offset) {
    var x = []
    for (var i = -width; i <= width; i++) {
        for (var j = -width; j <= width; j++) {
            if (i != 0 || j != 0) x.push([i + offset,j + offset])
        }
    }
    return x
}

function JohnNash() {
    var looted = {}
    this.doTurn = function(context) {
        var field = context.getPlayField()
        // Save looted bodies
        range(1, Constants.CENTRE_OF_VISION).forEach(function(p) {
            var x = p[0], y = p[1]
            var playerId = field[x][y]
            if (playerId && playerId.getName() == "DeadBody") {
                looted[playerId] = true
            }
        })

        // Shoot any nearby chumps
        if (context.getBullets() > 0) {
            var shootableIterator = context.shootablePlayers().iterator();
            while (shootableIterator.hasNext()) {
                var shootable = shootableIterator.next()
                if (chumps[shootable.getName()]) return new Shoot(shootable)
            }
        }

        // Helper function - everyone loves closures
        function moveTowards(x, y) {
            var tryMove = Move.inDirection(
                    x - Constants.CENTRE_OF_VISION,
                    y - Constants.CENTRE_OF_VISION
            )
            if (!(field[Constants.CENTRE_OF_VISION + tryMove.x][Constants.CENTRE_OF_VISION + tryMove.y])) {
                return tryMove
            } else {
                // If your path is blocked, take a random move
                return Move.randomMove()
            }
        }

        // Loot
        var bestX, bestY, bestDist = Infinity
        range(Constants.VISION_RANGE, Constants.CENTRE_OF_VISION).forEach(function(p) {
            var x = p[0], y = p[1]
            var playerId = field[x][y]
            if (playerId
                    && playerId.getName() == "DeadBody"
                    && !looted[playerId]
                    && dist(x, y) < bestDist) {
                bestDist = dist(x,y)
                bestX = x
                bestY = y
            }
        })

        if (bestDist < Infinity) {
            return moveTowards(bestX, bestY)
        }
        else return Move.SOUTH
    }
}

PlayerRegistry.registerPlayer("JohnNash", new Player(new JohnNash()))

মুভআর্যান্ডম এলোমেলোভাবে সরানো ছাড়াও কিছু করে?
থাইলন

@ থাইলন নাহ, এটি টিনে যা বলেছে ঠিক তা করে। তিনি প্রকল্পটিতে প্রেরিত একটি টান অনুরোধের মধ্যে মুুপ এটি অন্তর্ভুক্ত করেছেন। টান অনুরোধের মূল উদ্দেশ্যটি এইচটিএমএল আউটপুটটি উন্নত করা ছিল, তবে মুভর্যান্ডমালি অন্তর্ভুক্ত ছিল এবং আমি অনুভব করেছি যে পরীক্ষায় কী ঘটে যায় তা দেখার জন্য আমি পরীক্ষায় মুভর্যান্ডমালি অন্তর্ভুক্ত করেছিলাম।
জেমস_পিক

আমি আপনার গিথুব থেকে সর্বশেষতম টানলাম এবং সংকলন করতে জন-ন্যাশন.জেএস পেতে পারিনি
মুপ

@ মুপ আমি একই পেলাম।
পিওরফেরেট 16

ঠিক কর. আমি এটি কেবল জাভা against এর বিপরীতে পরীক্ষা করেছি It এটি এখন 8
তেও

1

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

“সুতরাং আমরা জানি যে জয়ের জন্য পাঁচটি প্রয়োজনীয় জিনিস রয়েছে:
১. তিনি কখনই লড়াই করবেন এবং কখন লড়াই করবেন না কে জানে।
২. তিনি জিতবেন যে কে জানে উন্নত ও নিকৃষ্ট উভয় বাহিনীকে পরিচালনা করতে হয়।
৩. তিনি বিজয়ী হবেন যার সেনাবাহিনী এর সমস্ত পদক্ষেপে একই আত্মা দ্বারা অ্যানিমেটেড।
৪. তিনি জিতবেন, যিনি নিজেকে প্রস্তুত করেছেন, অপ্রত্যাশিতভাবে শত্রুকে নিয়ে যাওয়ার জন্য অপেক্ষা করেন।
৫. তিনি বিজয়ী হবেন যার সামরিক ক্ষমতা আছে এবং সার্বভৌম কর্তৃক তাকে হস্তক্ষেপ করা হবে না। ”

package player;

import static zombie.Constants.CENTRE_OF_VISION;
import static zombie.Constants.SHOOT_RANGE;
import static zombie.Constants.VISION_RANGE;

import java.awt.Point;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.Set;
import java.util.TreeSet;

import zombie.Action;
import zombie.Move;
import zombie.Player;
import zombie.PlayerContext;
import zombie.PlayerId;
import zombie.Shoot;

import com.google.common.base.Function;
import com.google.common.base.Predicate;
import com.google.common.collect.Collections2;
import com.google.common.collect.Table.Cell;
import com.google.common.collect.TreeBasedTable;

    public class SunTzu implements Player {
        private TreeBasedTable<Integer, Integer, Integer> dangerZone;
        private final static int IN_ENEMY_RANGE = 5;
        private static final int IN_LOOTED_RANGE = 4;
        private static final int FULL_MAGAZINE = 10;
        private static final int IN_ZOMBIE_RANGE = 10;
        private static final int NUM_PLAYERS = 40;
        private LinkedHashSet<Point> safeSpots;
        private PlayerId[][] localAreas;
        private Set<PlayerId> looted= new HashSet<>(50*NUM_PLAYERS);
        private int ammo;
        PlayerId biggestThreat;
        private Set<PlayerId> shootable;
        private PlayerId myId;
        @SuppressWarnings("unused")
        @Override
        public Action doTurn(PlayerContext context) {
            ammo = context.getBullets();
            int gameTurn =context.getGameClock();
            int boardSize = context.getBoardSize();
            myId = context.getId();
            localAreas = context.getPlayField();
            dangerZone = TreeBasedTable.create();
            shootable = context.shootablePlayers();
            updateAdjacentBodyState();

            for (int x = CENTRE_OF_VISION - SHOOT_RANGE; x <= CENTRE_OF_VISION + SHOOT_RANGE; x++) {
                for (int y = CENTRE_OF_VISION - SHOOT_RANGE; y <= CENTRE_OF_VISION + SHOOT_RANGE; y++) {
                    PlayerId playerId = localAreas[x][y];
                    if (playerId != null) {
                        calculateDangerZone(x,y,playerId);
                    }
                }
            }
            Action myAction = null;
            Iterator<Point> pIt = safeSpots.iterator();
            if (ammo>0&&!pIt.hasNext()&&getBiggestThreat()!=null) {
                return new Shoot(getBiggestThreat());
            } else if (pIt.hasNext()){
                Point p=pIt.next();
                return Move.inDirection(p.x, p.y);
            }else{
                return Move.randomMove();
            }
        }

        private PlayerId getBiggestThreat() {
            return biggestThreat==null?shootable.iterator().next():biggestThreat;
        }

        public void setBiggestThreat(PlayerId biggestThreat) {
            this.biggestThreat = biggestThreat;
        }
        private void updateAdjacentBodyState() {

            for( int x = -1; x <= 1; x++ ) {
                for( int y = -1; y <= 1; y++ ) {
                    PlayerId adjPlayerId = localAreas[CENTRE_OF_VISION+x][CENTRE_OF_VISION+y];
                    if( adjPlayerId != null && (!looted.contains(adjPlayerId) && adjPlayerId.getName().equals("DeadBody"))) {
                        looted.add(adjPlayerId);
                    }       
                }
            }
        }

        private void calculateDangerZone(int x, int y, PlayerId playerId) {
            deriveDanger(playerId, x, y);
            safeSpots = getSafeSpots();
        }

        @SuppressWarnings("rawtypes")
        private LinkedHashSet<Point> getSafeSpots() {
            LinkedHashSet<Point> safeSpots = new LinkedHashSet<>();
            TreeSet<Cell> spots = new TreeSet<>(cellValueComparator());
            for (Cell<Integer, Integer, Integer> cell : dangerZone.cellSet()) {
                spots.add(cell);
            }
            final Cell safeCell = spots.isEmpty()?null:Collections.min(spots,cellValueComparator());
            Function<Cell,Point> pointFromCell = new Function<Cell,Point>() {
                public Point apply(final Cell arg0) {return new Point((int)arg0.getRowKey(), (int)arg0.getColumnKey());};
            };

            if (safeCell!=null) {
                safeSpots.addAll(Collections2.transform(
                        Collections2.filter(spots, sameCellValuePredicate(safeCell)), pointFromCell));
            }
            return safeSpots;
        }

        @SuppressWarnings("rawtypes")
        private Predicate<Cell> sameCellValuePredicate(final Cell safeCell) {
            return new Predicate<Cell>() {

                @Override
                public boolean apply(Cell arg0) {
                    return (arg0.getValue() == safeCell.getValue());
                }
            };
        }

        @SuppressWarnings("rawtypes")
        private Comparator<Cell> cellValueComparator() {
            return new Comparator<Cell>() {
                @Override
                public int compare(Cell o1, Cell o2) {
                    return (int)o1.getValue()- (int)o2.getValue();
                }
            };
        }

        private void deriveDanger(PlayerId playerId, int x, int y) {
            switch (playerId.getName()) {
            case "Gunner":
            case "Fox":
            case "HideyTwitchy":
            case "Shotguneer":
            case "ZombieRightsActivist":
            case "ZombieHater":
            case "SuperCoward":
            case "Sokie":
                updateDangerZoneWithEnemy(x, y);
                break;
            case "DeadBody":
            case "Zombie":
                updateDangerZoneWithBodies(x,y);
                break;
            default:
                break;
            }
        }

        private void updateDangerZoneWithBodies(int x, int y) {
            int dangerLevel=0;
            if(localAreas[x][y].getName().equalsIgnoreCase("Zombie")){
                dangerLevel = IN_ZOMBIE_RANGE;
            }
            else if(looted.contains(localAreas[x][y])){
                dangerLevel = IN_LOOTED_RANGE;
            }else{
                dangerLevel = Math.min(-1,-FULL_MAGAZINE+ammo);
            }
            for (int i = x-1; i < x+1; i++) {
                for (int j = y-1; j < y+1; j++) {
                    Integer previousDangerLevel = dangerZone.get(i, j) ;
                    int currentDangerLevel = dangerLevel;
                    if (previousDangerLevel != null) {
                        currentDangerLevel = previousDangerLevel+dangerLevel;
                    } 
                    dangerZone.put(x, y, currentDangerLevel);
                }
            }
        }

        private void updateDangerZoneWithEnemy(int x, int y) {
            int dangerLevel = IN_ENEMY_RANGE;
            playerShieldFound:
                for (int i = Math.max(x-SHOOT_RANGE, 0); i < Math.min(SHOOT_RANGE+x,VISION_RANGE); i++) {
                    for (int j = Math.max(y-SHOOT_RANGE, 0); j < Math.min(SHOOT_RANGE+y,VISION_RANGE); j++) {
                        int cardinalityFactor = (i+1)+(j+1);
                        Integer previousDangerLevel = dangerZone.get(i, j);
                        int currentDangerLevel = dangerLevel*cardinalityFactor;
                        PlayerId enemy = localAreas[x][y];
                        PlayerId target = localAreas[i][j];
                        if (target!=null) {
                            if (target != enemy) {
                                break playerShieldFound;
                            } else if (target.equals(myId)) {
                                setBiggestThreat(enemy);
                            }
                        }
                        if (previousDangerLevel != null) {
                            currentDangerLevel = Math.max(previousDangerLevel, dangerLevel);
                        } 
                        dangerZone.put(i, j, currentDangerLevel );
                    }
                }
        }

    }

বর্তমান সমস্যাগুলি হ'ল ড্রেজজোনটি সঠিকভাবে তৈরি হয় না এবং আমি মনে করি না যে বৃহত্তমতম দেশটি সঠিকভাবে বসানো হচ্ছে।


পেয়ারা থেকে ক্লাস ব্যবহারের জন্য +1। আমি এটি ভুলে গিয়েছিলাম যে আমি এটি নিয়ন্ত্রণ প্রোগ্রামে ব্যবহার করেছি, তবে স্পষ্টত এই ধরণের জিনিসটির জন্য এতে প্রচুর দরকারী ক্লাস রয়েছে।
জেমস_পিক

1
@ জেমস_পিক টিবিএইচ, আমি অ্যাপাচি সমপরিমাণের জন্য বিক্রি করব। মনে হচ্ছে আমি এটির একটি হ্যাশ তৈরি করেছি।
পিওফেরেরেট

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

জিনিসটি হ'ল, @ জেমস_পিক আমি খুব সহজেই এটি ম্যাভেন দিয়ে তৈরি করতে পেরেছিলাম কারণ আমি সত্যিই বুঝতে পারি না ... আমি বরং অন্যের সাথে কাজ করব তবে আরও কাজ করবো।
পিওরফেরেট

1

টাইজয়েড - আমার কিছুটা বোবা রোবট

package player;

import java.util.ArrayList;

import zombie.Action;
import zombie.Move;
import zombie.Player;
import zombie.PlayerContext;
import zombie.PlayerId;
import zombie.Shoot;

public class Tyzoid implements Player {
    private static final int minPathDistance = 7;
    private static final int pathLength = 10;
    private static final boolean debug = false;
    private static final int max_iterations = 5000;

    private int current_iterations = 0;

    private class Situation {
        public int hostiles = 0;
        public int scores[][] = new int[21][21];
        public ArrayList<Coordinate> path = new ArrayList<Coordinate>();
        public int distanceToHostile = 10;
        public Coordinate nearestHostile = new Coordinate(0,0);
        public boolean seriousHostile = false;

        // Minimum path score allowed to move under normal circumstances
        public int pathScore = -40;

        public int bulletsLeft = 0;

        public Situation(){
            path.add(new Coordinate(10,10));
        }
    }

    public class Coordinate {
        public int x = 0;
        public int y = 0;

        public Coordinate(int x, int y) {
            this.x = x;
            this.y = y;
        }
    }

    @Override
    public Action doTurn(PlayerContext context) {
        try {
            Situation currentSituation = this.evaluateSituation(context);
            return this.makeDecision(currentSituation, context);
        } catch (Exception e) {
            if (debug) e.printStackTrace();
            return Move.STAY;
        }
    }

    private Situation evaluateSituation(PlayerContext context) {
        Situation situation = new Situation();

        for (int i = 0; i < 21; i++) {
            for (int j = 0; j < 21; j++) {
                situation.scores[i][j] = -3;
            }
        }

        situation.bulletsLeft = context.getBullets();

        PlayerId[][] visibleBoard = context.getPlayField();

        for (int bx = 0; bx < visibleBoard.length; bx++) {
            for (int by = 0; by < visibleBoard[bx].length; by++) {
                if (visibleBoard[bx][by] == null) {
                    continue;
                }

                if (this.isHostile(visibleBoard[bx][by].getName(), false)) {
                    situation.hostiles++;

                    this.hostileDetected(situation, bx, by, context);
                } else if (visibleBoard[bx][by].getName().equals("DeadPlayer")) {
                    this.friendlyDetected(situation, bx, by);
                    // OVER 9000!!! (there's an obstacle)
                    situation.scores[bx + 2][by + 2] = -9001;
                }
            }
        }

        return situation;
    }

    private Action makeDecision(Situation currentSituation, PlayerContext context) {
        if ((currentSituation.distanceToHostile < 3 || currentSituation.seriousHostile) && currentSituation.bulletsLeft > 0){
            // Shoot! (And possibly create opening!)
            PlayerId[][] visibleBoard = context.getPlayField();

            if (debug) System.out.println("Shooting!");

            return new Shoot(visibleBoard[currentSituation.nearestHostile.x-2][currentSituation.nearestHostile.y-2]);
        }

        if (currentSituation.hostiles > 6) {
            // Code red: get out of here! Trample over hostiles if necessary.
            // Guarantee path will generate, without hitting anything dead.
            currentSituation.pathScore = -9000;
        }

        findSafePath(currentSituation);

        Coordinate next = currentSituation.path.get(0);

        if (next.x == 10 && next.y == 10){
            if (debug) System.out.println("Staying Put.");
            return Move.STAY;
        }

        if (debug) System.out.println("Moving!");

        return Move.inDirection(next.x-2, next.y-2);
    }

    private void findSafePath(Situation currentSituation) {
        int x = 10;
        int y = 10;

        // Since we have a finite number of tiles, and we won't consider
        // backtracking, Let's consider every possible path to optimize the
        // safest path.

        current_iterations = 0;

        pathIteration(currentSituation, new ArrayList<Coordinate>(), x, y, 0);
    }

    private void pathIteration(Situation s, ArrayList<Coordinate> currentPath, int x, int y, int steps) {
        // If we've reached an end state,
        // Update situation if the currentPath has a higher (less negative) score than the current path.
        // As well as if we moved the minimum amount

        // Compute Score
        int score = 0;
        for (Coordinate c : currentPath) {
            score += s.scores[c.x][c.y];
        }

        int distanceTraveled = (Math.abs(10 - x) + Math.abs(10 - y));

        // Return if the currentPath has a lower score than the current path.
        if (score < s.pathScore || s.pathScore == 0 || current_iterations > max_iterations) return;

        if (debug) System.out.println("debug: step " + steps + " (" + score + " : " + s.pathScore + ") Distance: " + distanceTraveled);

        // Prevent my algorithm from blowing up the whole works
        current_iterations++;

        if (steps == pathLength) {
            if (distanceTraveled >= minPathDistance) {
                if (score > s.pathScore) {
                    s.path = currentPath;
                    s.pathScore = score;
                }
            }

            return;
        }

        ArrayList<Coordinate> searched = new ArrayList<Coordinate>();
        for (int index = 0; index < 9; index++){
            int minx = 0, miny = 0;
            int minscore = -1000;

            for (int i = -1; i < 2; i++) {
                for (int j = -1; j < 2; j++) {
                    if (searched.contains(new Coordinate(x+i, y+j)) || currentPath.contains(new Coordinate(x+i, y+j))){
                        continue;
                    }

                    if (steps > 1){
                        Coordinate c0 = currentPath.get(steps-2);
                        Coordinate c1 = currentPath.get(steps-1);

                        int dx = c1.x-c0.x;
                        int dy = c1.y-c0.y;

                        // Disable turning more than 45 degrees
                        if (dy != j && dx != i) continue;
                    }

                    if (s.scores[x+i][y+j] > minscore){
                        minx = x+i;
                        miny = y+j;
                        minscore = s.scores[x+i][y+j];
                    }
                }
            }

            if (!currentPath.contains(new Coordinate(minx, miny))) {
                ArrayList<Coordinate> newPath = (ArrayList<Coordinate>) currentPath.clone();
                newPath.add(new Coordinate(minx, miny));
                pathIteration(s, newPath, minx, miny, steps + 1);
            }

            searched.add(new Coordinate(minx, miny));
        }
    }

    private void hostileDetected(Situation seriousSituation, int bx, int by, PlayerContext context) {
        boolean verySerious = false;
        if (this.isHostile(context.getPlayField()[bx][by].getName(), true) && context.shootablePlayers().contains(context.getPlayField()[bx][by])){
            seriousSituation.seriousHostile = true;
            verySerious = true;
        }

        for (int i = -4; i < 5; i++) {
            for (int j = -4; j < 5; j++) {
                // Prevent from overflowing the path matrix.
                if (i + bx + 2 < 0 || i + bx + 2 > 20 || j + by + 2 < 0 || j + by + 2 > 20) continue;

                int separationLevels = Math.max(Math.abs(i), Math.abs(j));
                seriousSituation.scores[bx + i + 2][by + j + 2] += separationLevels*2 - 10;
            }
        }

        int distanceToHostile = Math.abs(10 - (bx + 2)) + Math.abs(10 - (by + 2));
        if ((distanceToHostile < seriousSituation.distanceToHostile && !seriousSituation.seriousHostile) || verySerious){
            seriousSituation.nearestHostile = new Coordinate(bx + 2, by + 2);
            seriousSituation.distanceToHostile = distanceToHostile;
        }
    }

    private void friendlyDetected(Situation lessBleakSituation, int bx, int by) {
        for (int i = -4; i < 5; i++) {
            for (int j = -4; j < 5; j++) {
                // Prevent overflowing the path matrix.
                if (i + bx < 0 || i + bx > 20 || j + by < 0 || j + by > 20) continue;

                int separationLevels = Math.max(Math.abs(i), Math.abs(j));
                lessBleakSituation.scores[bx + i + 2][by + j + 2] += 4 - separationLevels;
            }
        }
    }

    private boolean isHostile(String name, boolean serious){
        // Generated from a list of players who shot me during testing.
        // If anyone adds me as a 'friendly', I'd be happy to reciprocate.
        switch(name){
            case "Bee":
            case "Coward":
            case "Fox":
            case "Gunner":
            case "HideyTwitchy":
            case "Sokie":
            case "ZombieHater":
            case "ZombieRightsActivist":
                return true;
            default:
                return (!serious && name.equals("Zombie")); // Zombies don't shoot
        }
    }
}

আমি আশঙ্কা করছি আপনি জয়ের সুযোগ নিয়ে আসতে খুব বেশি দেরী করেছেন, তবে পরে যদি সুযোগ পান তবে আপনার ভাড়া কী হবে তা দেখার জন্য আমি আপনার এন্ট্রি অন্তর্ভুক্ত করে আরও একটি রান করব।
জেমস_পিক

হ্যাঁ, আমি অনুগ্রহের সময়সীমার উপর ভিত্তি করে আমার জমাটি বিচার করেছি: / - যদিও আমি ওয়াইনের কাছাকাছি হওয়ার আশা করি না ... বটটি খুব ভাল নয়।
টাইজয়েড

1
এর জন্য দুঃখিত, এই উদ্বোধনটি 3 শে আগস্টের নির্ধারিত তারিখের পরে সময়সীমা নির্ধারণ করা হয়েছিল যাতে আমি আজ 4 ই আগস্ট পুরষ্কার দিতে পারি। (এটা বলা হচ্ছে যে আপনি আমার চরিত্রের যে কোনও একটিকেই শুটিং করেছেন যাতে আমার টাইজয়েডের জন্য মূল হওয়া উচিত))
কেইন
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.