আপনার সদয় প্রতিবেশী, ডক্টর ট্রি, আপনাকে কোডডমন নামক তিনটি যাদুকরী প্রাণী দিয়েছেন। কাছের শহর কালারভিলে যুদ্ধের টুর্নামেন্ট রয়েছে। আপনি কি কখনও সেরা ছিলেন না?

সংক্ষিপ্ত বিবরণ

এটি একটি যুদ্ধের টুর্নামেন্ট। প্রতিটি খেলোয়াড় তিনটি দানবের একটি দলকে নিয়ন্ত্রণ করে এবং উদ্দেশ্য অন্য দলকে আউট (কিল) আউট করা। বিজয় এবং সম্পর্কগুলির জন্য পয়েন্টগুলি পুরষ্কার সহ 100 টি রাউন্ড রয়েছে। সবচেয়ে বেশি পয়েন্ট নিয়ে দল জিতল!

দানব

একটি কোডমন একটি জটিল ছোট প্রাণী। এখানে পাঁচটি ধরণের (উপাদান) বেছে নেওয়া হয়, তিনটি পরিসংখ্যান এবং প্রতিটিটিতে তিনটি সরানো স্লট।

প্রকারভেদ

প্রতিটি কোডমন এক প্রকারের জন্য নির্ধারিত হয় । পাঁচটি ধরণ হ'ল নরমাল, সাইকিক, ফায়ার, ওয়াটার এবং গ্রাস। প্রত্যেকের এর শক্তি এবং দুর্বলতা রয়েছে। ক্ষতি নিম্নোক্ত চার্টের উপর ভিত্তি করে:

টাইপ-চার্ট

সংখ্যাগুলি হ'ল ক্ষতির গুণক। উদাহরণস্বরূপ, ফায়ার অ্যাটাকিং জলের একটি 0.5 মডিফায়ার (অর্ধ ক্ষতি) রয়েছে, তবে ফায়ার অ্যাটাকিং ঘাস দ্বিগুণ হয়েছে (2)।

পরিসংখ্যান

প্রতিটি দৈত্যের তিনটি পরিসংখ্যান রয়েছে যা তার যুদ্ধের দক্ষতা নির্ধারণ করে। আক্রমণ এটি করে ক্ষতি বাড়িয়ে তোলে। প্রতিরক্ষা এটির ক্ষয়ক্ষতি কমায় ers গতি কম গতির সাথে তাদের আগে চলতে দেয়।

প্রতিটি দানবটির প্রতিটি স্ট্যাটের জন্য শুরুতে 50 টি মান এবং সর্বোচ্চ 100 থাকে you আপনি যখন নিজের দানব তৈরি করেন, আপনি 80 টি অতিরিক্ত স্ট্যাট পয়েন্ট (প্রতিটি) নির্ধারণ করতে সক্ষম হবেন । মনে রাখবেন যে কোনও পৃথক স্ট্যাটাস 100 এর বেশি যেতে পারে না So সুতরাং, আপনার 100/80/50, 90/80/60 বা 65/65/100 বিতরণ থাকতে পারে তবে 120/50/60 অবৈধ। অবৈধ পরিসংখ্যান সহ যে কোনও দলই অযোগ্য ঘোষণা করা হয়েছে। আপনার সকল 80 টি পয়েন্ট ব্যবহার করার দরকার নেই তবে আপনার সম্ভবত সর্বনিম্ন 50/50/50 হওয়া উচিত নয়।

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

মানসম্পন্ন

প্রতিটি দানব তিনটি যুদ্ধ চলন জানে। তিনটি বাছাই করা পৃথক হতে হবে, তাই কোনও পাঞ্চ / পাঞ্চ / পাঞ্চ নয়।

15 টি চাল আছে, প্রতিটি ধরণের তিনটি। প্রতিটি ধরণের একটি প্রত্যক্ষ আক্রমণ, একটি প্রভাব সহ একটি দুর্বল আক্রমণ এবং একমাত্র প্রভাব স্থানান্তর।

id  name        type    power   uses    usable  effect

0   Punch       N       20      -       NFWG
1   Heal        N        0      3       NFWG    Heals 50 HP
2   Slow        N       10      5       NFWG    Enemy speed x0.8
3   Pain        P       20      -       PFWG
4   Sleep       P        0      3       PFWG    No enemy action until wake
5   Weaken      P       10      5       PFWG    Enemy Atk x0.8
6   Fireball    F       20      -       NPFW
7   Burn        F        0      3       NPFW    Enemy -10 HP each turn
8   Sharpen     F       10      5       NPFW    Own Atk x1.25
9   Watergun    W       20      -       NPWG    
10  Confuse     W        0      3       NPWG    Enemy may strike itself (10 power)
11  Shield      W       10      5       NPWG    Own Def x1.25
12  Vine        G       20      -       NPFG
13  Poison      G        0      3       NPFG    Enemy -5xTurns HP each turn
14  Sap         G       10      5       NPFG    Enemy Def x0.8

typeপদক্ষেপের ধরণকে বোঝায়। powerএটির স্ট্রাইকিং শক্তি। usesযুদ্ধের জন্য এটি কতবার ব্যবহার করা যায় তা নির্দেশ করে ( -সীমাহীন)। usableএটি কী ধরণের দ্বারা ব্যবহার করা যেতে পারে তা দেখায় (উদাহরণস্বরূপ, পাঞ্চ কোনও সাইকিক টাইপকে দেওয়া যায় না, যেমন নেই P)। effectচালগুলি কী প্রভাব ফেলে তা দেখায়। প্রতিটি প্রভাব কার্যকর হওয়ার 75% সম্ভাবনা রয়েছে, নিরাময় বাদে, যা সর্বদা কাজ করে।

একটি দৈত্যের পরিসংখ্যান পরিবর্তনকারী প্রভাবগুলির জন্য, প্রভাবগুলি স্ট্যাক করা যেতে পারে । উদাহরণস্বরূপ, দু'বার দুর্বল ব্যবহার করা আপনার প্রতিপক্ষের আক্রমণকে 0.64 এর কার্যকারিতা থেকে কমিয়ে দিতে পারে। দানবীয়দের পরিসংখ্যান (ঘুম, পোড়া ইত্যাদি) স্ট্যাক করে না এমন প্রভাবগুলি ।

ঘুম প্রতি ঘুরিয়ে শুরুর সময় জেগে থাকার 60% সুযোগ নিয়ে প্রতিপক্ষকে ঘুমিয়ে দেয়। ঘুমন্ত দানব দ্বারা কোনও পদক্ষেপ নেওয়া হবে না।

সক্রিয় হয়ে গেলে প্রতিটি মোড়ের শেষে বার্ন প্রতিপক্ষের 10 টি এইচপি ক্ষতি করে । বিষ একইভাবে কাজ করে, তবে প্রতিটি পালা একটি বর্ধমান পরিমাণ নেয়। প্রথম টার্নে, এটি 5 টি এবং এরপরে এটির প্রতিটি পালা 5 টি করে। সুতরাং, চতুর্থ মোড়ের মাধ্যমে, এটি 20 এর জন্য ক্ষতিকর These

বিভ্রান্তি একটি দানব আক্রমণ করতে পারে যা এটি করতে বলা হয়েছিল তা না করে। এই আক্রমণটির শক্তি 10 রয়েছে এবং প্রদত্ত মোড়টিতে 30% হওয়ার সম্ভাবনা রয়েছে।

স্পষ্টভাবে বলতে গেলে, যুদ্ধের শেষ অবধি প্রভাবগুলি স্থায়ী হয় (উপরে বর্ণিত স্লিপ ব্যতীত)।

চলমানগুলি যদি সংশ্লিষ্ট ধরণের দৈত্য দ্বারা ব্যবহৃত হয় তবে 20% শক্তি বাড়ায়। উদাহরণস্বরূপ, একটি ঘাস দানব ভাইন ব্যবহার করে উত্সাহিত হয়, যখন পাঞ্চ ব্যবহার করার সময় তিনি নন।

গোপন পরিসংখ্যান

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

বিশেষতঃ প্রতি দুটি যুদ্ধের পরে , আপনার দলের প্রতিটি দানবকে আপনাকে একটি "বোনাস" স্ট্যাট পয়েন্ট দেওয়া হবে। পয়েন্টগুলি সমস্ত দানব, মৃত বা জীবিত, বিজয়ী বা হেরে দেওয়া হয়। আপনি বেছে নিন এমন তিনটি পরিসংখ্যান যেকোনকেও আপনি এটি নির্ধারণ করতে পারেন। আপনি এগুলিকে একটি দানবতে স্ট্যাক করতে পারবেন না; প্রতিটি দানব প্রতিটি সময় এক পায় । এই পয়েন্টগুলি 100 সীমাতে প্রতিরোধক। যেহেতু 100 টি যুদ্ধের রাউন্ড থাকবে, এর অর্থ আপনি যদি আপনার সমস্ত বোনাস বরাদ্দ করেন তবে আপনি 149 পর্যন্ত একটি একক স্ট্যাটাস পেতে পারেন। আবার, প্রতিপক্ষ কেবলমাত্র আপনার "বেস" পরিসংখ্যানগুলি দেখতে পাবে, তাই আপনি যে টুর্নামেন্টের আরও বেশি দূরে থাকবেন, ততই তাদের জ্ঞান সত্য থেকে দূরে চলে যায়।

যুদ্ধ

যুদ্ধ তিন দলের মধ্যে হয় এবং এক সাথে প্রতিটি দলে একটি করে সক্রিয় থাকে। শুরুতে, আপনাকে প্রতিপক্ষের দল দেখানো হবে এবং কোন দৈত্য আপনার প্রথম "সক্রিয়" খেলোয়াড় হবে তা চয়ন করতে জিজ্ঞাসা করা হবে।

এর পরে, নিম্নলিখিত পদক্ষেপগুলির সাথে পালা সংঘটিত হবে:

স্যুইচ করুন: বাধ্যতামূলক দানব সুইচগুলি স্থান নেয় (যদি থাকে)
যুদ্ধ কর্ম চয়ন করুন
স্যুইচ: যে কোনও option চ্ছিক দানব সুইচ (যুদ্ধের ক্রিয়া হিসাবে নির্বাচিত) স্থান নেয়
ঘুম চেক করুন: ঘুম থেকে জেগে ওঠার সম্ভাবনা
আক্রমণ 1: সক্ষম হলে, দ্রুততর দৈত্যটি তার নির্বাচিত পদক্ষেপটি ব্যবহার করে
আক্রমণ 2: সক্ষম হলে, অন্য দৈত্যটি তার নির্বাচিত পদক্ষেপটি ব্যবহার করে
প্রভাবের ক্ষতি: জীবিত দানবগুলিতে পোড়া / বিষের ক্ষতি প্রয়োগ করুন

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

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

নিষ্ক্রিয় যখন দানব "প্রক্রিয়াজাত" হয় না। এর মানে হল তারা কোন পুড়ে / বিষ ক্ষতি নিয়ে বিষ কাউন্টার, জমা করা হবে না ঘুম থেকে কোন প্রাক্কালে, ইত্যাদি কোন প্রভাব মুছে অথবা যখন সুইচিং পরিবর্তিত হয় । এটি অন্যান্য দৈত্য যুদ্ধের খেলা নয়। আপনি যদি আক্রমণ উত্থিত এবং পোড়া দিয়ে স্যুইচআউট করেন তবে আপনি যখন আবার স্যুইচ ইন করবেন তখন তারা সেখানে থাকবে।

আপনি যদি আপনার সক্রিয় প্রতিপক্ষকে হত্যা করেন বা না করেন তবে প্রভাবের ক্ষতি হয়। এইভাবে, উভয় দলের সদস্যরা একক ঘুরে মারা যেতে পারেন।

যখন একটি দল ব্যবহারযোগ্য দানবগুলির বাইরে চলে যায়, তারা হেরে যায়। যদি উভয় দল একই টার্নে রান আউট হয় তবে এটি টাই। যুদ্ধটি যদি 1000 টার্নের জন্য স্থায়ী হয় তবে এটি টাই।

ক্ষতি নির্ধারণের সূত্রটি হ'ল:

floor((effAttack / effDefense) * movePower * typeMultiplier * moveBoost)

effAttackএবং effDefenseহয় কার্যকর দানব জন্য পরিসংখ্যান। কার্যকর আক্রমণ আক্রমণ এবং বোনাস আক্রমণ যোগ করে প্রাপ্ত করা হয়, তারপরে কোনও প্রভাব যদি এটি পরিবর্তন করে তবে গুণমান (0.8 বা 1.25 দ্বারা)। মনে রাখবেন যে এই প্রভাবগুলি স্ট্যাক করতে পারে।

ক্ষয়টি কেবল তখনই হতে পারে যখন টাইপ সংশোধক 0 (সাধারণ <--> মানসিক) বা পদক্ষেপের শক্তি 0 হয় (নিরাময়, বার্ন ইত্যাদি)। অন্যথায় নূন্যতম প্রয়োগ করা হয় 1।

টুর্নামেন্ট

টুর্নামেন্টগুলি 100 রাউন্ডের জন্য স্থায়ী হয়। প্রতিটি রাউন্ডে, দলগুলি একে অপরের বিরুদ্ধে এলোমেলোভাবে পরিবর্তিত হয় এবং জুটিবদ্ধ হয়। যদি অদ্ভুত সংখ্যক দল থাকে, তবে অবশিষ্টাংশগুলি একটি বাই (টাই হিসাবে স্কোর) পায় receives একটি যুদ্ধে জয়লাভ করে দলটি 2 পয়েন্ট অর্জন করে , বন্ধনগুলির মূল্য 1 এবং কোনও ক্ষতি হয় না। সবচেয়ে বেশি পয়েন্ট নিয়ে দল জিতেছে!

দলগুলি বাঁধা থাকলে, টাইব্রেকার ক্রম নির্ধারণের জন্য কেবল প্রথম দলগুলির সাথে থাকা একটি টুর্নামেন্ট অনুষ্ঠিত হবে।

প্রোটোকল

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

আপনার প্রোগ্রামটি আদেশটিকে আর্গুমেন্ট হিসাবে গ্রহণ করবে এবং এক সেকেন্ডের মধ্যে STDOUT এ প্রতিক্রিয়া জানাবে । STDIN শুনে জীবিত থাকবেন না, এটি থাকবে না। প্রতিটি কমান্ড একটি নতুন প্রক্রিয়া উত্সাহিত করবে।

আপনি ডিস্কে ডেটা / স্টেট লিখতে পারেন। আপনার দলের মতো একই নামে কোনও ফাইলকে সাবফোল্ডারে রাখুন। 32 কিলোবাইটের বেশি ডেটা লিখবেন না, বা আপনি অযোগ্য হবেন। তথ্যগুলি রাউন্ডের মধ্যে অব্যাহত থাকবে তবে টুর্নামেন্টগুলির মধ্যে পরিষ্কার হয়ে যাবে।

কমান্ড

দল তথ্য

এটি টুর্নামেন্টের শুরুতে একবার আপনার দলটিকে নিবন্ধিত করার জন্য প্রেরণ করা হয়। আপনার উত্তরটি প্রতিটি টুর্নামেন্টের জন্য পৃথক নয়, ধ্রুব হওয়া উচিত ।

প্রশ্ন:

প্রতিক্রিয়া:

name|member0|member1|member2

nameআপনার দলের নামের সাথে একটি স্ট্রিং। পার্সিংয়ের স্বাচ্ছন্দ্যের জন্য দয়া করে কেবলমাত্র বর্ণমালা ব্যবহার করুন। memberNপ্রতিটি দানবটির বিশদ প্রদান করে একটি সদস্য স্ট্রিং:

সদস্য স্ট্রিং:

name:typeid:attack:defense:speed:moveid0:moveid1:moveid2

আবার, 'নাম' একটি স্ট্রিং, এবার এই দৈত্যটির নাম। typeidএটির ধরণ। প্রকারের আইডিগুলি উপরের চার্টে সাধারণ = 0 এবং ঘাস = 4 এর সাথে প্রদর্শিত ক্রমের সাথে থাকে।

পরবর্তী তিনটি ক্ষেত্র আপনার বেস পরিসংখ্যান। উপরের পরিসংখ্যান বিভাগে বর্ণিত সীমা মনে রাখবেন।

শেষ তিনটি আপনার দৈত্যের চাল। আইডিগুলি উপরের মুভি চার্টে প্রদর্শিত হয়।

টিমের ডেটা জবাবের উদাহরণ উদাহরণস্বরূপ:

DummyTeam|DummyA:0:50:60:70:0:1:2|DummyB:0:50:60:70:0:1:2|DummyC:0:50:60:70:0:1:2

যে কোনও টিম এখানে আবর্জনা, খারাপ ফর্ম্যাট, বা অবৈধ ডেটা ফেরত পাঠাবে এটি স্থির না হওয়া পর্যন্ত অংশ নেবে না।

অ্যাক্টিভ চয়ন করুন

এটি প্রতিটি যুদ্ধের শুরুতে প্রেরণ করা হয় এবং যখন কোনও দানব মারা যায় এবং তাকে পরিবর্তন করা দরকার।

প্রশ্ন:

C#battleState

battleStateবর্তমান যুদ্ধের অবস্থা দেখায়। আমার সাথে এখানে থাকুন, এটি কুরুচিপূর্ণ:

yourTeamState#theirTeamState

যেখানে XteamStateদেখতে দেখতে:

name:activeSlot|member0state|member1state|member2state

activeSlotবর্তমানে কোন দানব সক্রিয় রয়েছে তা দেখায় (0-2)। সদস্য রাষ্ট্র দুটি স্বাদে আসে। এটি যদি আপনার দল হয় তবে এটি অতিরিক্ত তথ্য দেয়। সুতরাং,

আপনার সদস্যপরিচয়:

name:id:attack:defense:speed:hp:typeid:poisonedturns:moveCount0:moveCount1:moveCount2:bonusAttack:bonusDefense:bonusSpeed:effectid:effectid:effectid

তাদের সদস্য

name:id:attack:defense:speed:hp:typeid:poisonedturns:effectid:effectid:effectid

idআপনি যদি পছন্দ করতে না চান তবে কেবল দৈত্যের উপর নজর রাখতে আপনি ব্যবহার করতে পারেন একটি পূর্ণসংখ্যা শনাক্তকারী name।

attack:defense:speedআপনার বেস পরিসংখ্যান

poisonedturns আপনাকে জানায় যে আপনি কতগুলি টার্নের জন্য বিষযুক্ত হয়েছেন।

moveCountXপ্রতিটি পদক্ষেপের জন্য আপনি কতগুলি ব্যবহার রেখেছেন তা জানায়। যদি 0 হয় তবে এটি ব্যবহার করা যাবে না। সীমাহীন পদক্ষেপের জন্য, এটি নেতিবাচক হবে।

bonus(stat) আপনি প্রতিটি স্ট্যাটে নির্ধারিত বোনাস পয়েন্টের পরিমাণ।

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

প্রভাব আইডিগুলি হ'ল:

0  NONE           (should not appear, internal use)
1  POISON
2  CONFUSION 
3  BURN 
4  SLEEP 
5  HEAL           (should not appear, internal use)
6  ATTACK_UP
7  ATTACK_DOWN
8  DEFENSE_UP
9  DEFENSE_DOWN
10 SPEED_DOWN

প্রতিক্রিয়া:

memberSlot

আপনি কোন সদস্যকে সক্রিয় থাকতে চান তা জানিয়ে কেবলমাত্র একমাত্র 0,1,2 জবাব প্রয়োজন। এটি অবশ্যই যুদ্ধে সক্ষম এমন সদস্য হতে হবে। 1সদস্য 1 মারা গেলে আবার পাঠাবেন না ।

যুদ্ধ অ্যাকশন

প্রতিটি পালা, আপনি কি করবেন তা সিদ্ধান্ত নেওয়া দরকার।

প্রশ্ন:

A#battleState

battleStateএখানে ঠিক উপরের হিসাবে বর্ণনা করা হয়েছে।

প্রতিক্রিয়া:

একটি সরানো ব্যবহারের জন্য, স্লটটি সরানো অবস্থায় ফিরে যান example উদাহরণস্বরূপ, আমি যদি পাঞ্চকে স্লট 0 তে নির্ধারিত করি, তবে পাঞ্চ 0সম্পাদন করে।

অন্য কোনও সদস্যের কাছে যেতে, সদস্যের স্লট প্লাস দশটি প্রেরণ করুন । সুতরাং সদস্য 2 এ স্যুইচ করুন, প্রেরণ করুন 12।

[0,1,2,10,11,12] এ না থাকা যেকোনো কিছুই অবৈধ বলে মনে করা হয় এবং ফলস্বরূপ কোনও পদক্ষেপ নেওয়া হবে না।

বোনাস পরিসংখ্যান

প্রতি দুটি যুদ্ধের পরে, আপনি প্রতিটি দলের সদস্যের জন্য একটি গোপন বোনাস পয়েন্ট পাবেন।

প্রশ্ন:

B#yourTeamState

আপনার দলের অবস্থা উপরে দেখানো মত একই, আমাকে এটির পুনরাবৃত্তি করবেন না।

প্রতিক্রিয়া:

stat0:stat1:stat2

আপনার প্রতিক্রিয়া প্রতিটি দলের সদস্যের জন্য কী স্ট্যাটাস বাড়ানো হবে তা উপস্থাপন করবে। আক্রমণ 0, প্রতিরক্ষা 1, গতি 2।

সুতরাং সদস্যের গতি বাড়াতে, সদস্য দু'জনের আক্রমণ এবং সদস্য তিনটির প্রতিরক্ষা বাড়াতে, আপনি এর সাথে প্রতিক্রিয়া জানাতে হবে:

2:0:1

নিয়ামক

কন্ট্রোলার বিটবাকেটে পাওয়া যাবে: https: //Geobits@bitbucket.org/Geobits/codemon.git

কেবলমাত্র একটি ফোল্ডারে সংকলিত শ্রেণি ফাইল, জমা দেওয়া এবং প্লেয়ার্স.কনফের সমস্ত টস করে রান করুন।

কন্ট্রোলারের মূল শ্রেণি বলা হয় Tournament। ব্যবহার হ'ল:

java Tournament [LOG_LEVEL]

0-4 থেকে লগ স্তরগুলি বর্ধমান তথ্য দেয়। স্তর 0 নীরবে টুর্নামেন্টটি চালায় এবং কেবল ফলাফল দেয় যেখানে স্তর 3 পর্যায়ক্রমে মন্তব্য করে comment স্তর 4 হ'ল ডিবাগ আউটপুট।

আপনি টুর্নামেন্টে players.confসাবমিশনগুলি যুক্ত করতে পারেন কেবল প্রোগ্রামটি চালানোর জন্য প্রয়োজনীয় কমান্ড লাইন স্ট্রিং যোগ করুন, প্রতি লাইনে একটি। লাইন দিয়ে শুরু #মন্তব্যগুলি।

আপনার পোস্টে, আমার players.confএবং যে কোনও সংকলনের পদক্ষেপগুলি (যদি প্রয়োজন হয়) যোগ করতে চাইলে কমান্ডটি অন্তর্ভুক্ত করুন ।

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

বিধি বিধি

আপনি কোনও বাহ্যিক সংস্থান পড়তে বা লিখতে পারবেন না (উপরে উল্লিখিত হিসাবে আপনার নিজের সাবফোল্ডার বাদে 32 কেবি পর্যন্ত)।
আপনার দলের টুর্নামেন্টে যেতে হবে "অন্ধ"। এর অর্থ আপনি কোনও নির্দিষ্ট দল / দানব একটি প্রদত্ত পরিস্থিতিতে কী করবে তা নির্ধারণের জন্য আপনি অন্য ব্যক্তির উত্স বিশ্লেষণ করতে পারবেন না। আপনি আপনার প্রতিপক্ষের চাল / পরিসংখ্যান বিশ্লেষণ করতে এবং টুর্নামেন্টটি এগিয়ে যাওয়ার সাথে সাথে ট্র্যাক রাখতে পারেন, তবে এই তথ্যটিতে কোনও হার্ডকডিং নেই।
অন্যান্য প্রক্রিয়া / জমা দেওয়ার ক্ষেত্রে হস্তক্ষেপ করবেন না। তাদের অনুরোধ করবেন না, তাদের ডেটা পেতে প্রতিবিম্ব ব্যবহার করে ইত্যাদি etc. আমার কম্পিউটারের সাথে গোলযোগ করবেন না। শুধু এটি চেষ্টা করবেন না। এটি আমার বিবেচনার ভিত্তিতে। লঙ্ঘনকারীদের ভবিষ্যতে প্রবেশ থেকে বাধা দেওয়া হতে পারে।
প্রতিযোগীরা সর্বাধিক দুটি এন্ট্রি সীমাবদ্ধ । আপনি যদি আরও জমা দেন তবে আমি কেবল প্রথম দুটি জমা দেওয়া স্কোর করব। আপনি যদি কোনওটি প্রত্যাহার করতে চান তবে এটি মুছুন।
এন্ট্রিগুলি কেবলমাত্র অন্য এন্ট্রিগুলিকে সমর্থন করার জন্য উপস্থিত থাকতে পারে। এছাড়াও, আপনি অপ্রত্যক্ষভাবে অন্য প্রতিযোগীদের অযোগ্য ঘোষণা করার চেষ্টা নাও করতে পারেন (উদাহরণস্বরূপ, ডিকিউ খেলোয়াড়দের কাছে এটি একটি 27 এম অক্ষর দলের নাম ব্যবহার করে যারা এটি ডিস্কে লেখার চেষ্টা করে)। প্রতিটি জমা দেওয়ার নিজস্ব মেধা অর্জন করতে খেলতে হবে।
আপনার প্রোগ্রামটি একসাথে সর্বোচ্চ একটি শিশু প্রক্রিয়া উত্সাহিত করতে পারে (মোট বংশধর, সরাসরি নয়)। প্রধান এবং যে কোনও শিশু প্রক্রিয়া উভয়ই আউটপুট দেওয়ার পরে সরাসরি শেষ করতে হবে। যে কোনও উপায়ে, আপনি সময়সীমা অতিক্রম করবেন না তা নিশ্চিত করুন।
টুর্নামেন্টটি আমার কম্পিউটারে চালিত উবুন্টুতে একটি ইন্টেল আই 7 3770 কে প্রসেসরের সাহায্যে অনুষ্ঠিত হবে।

ফলাফল

এগুলি বর্তমান প্লেয়ারগুলির ফলাফল। এটি শীর্ষ প্রতিযোগীদের মধ্যে খুব কাছাকাছি, এবং আমি 500 টি রাউন্ডের সংখ্যার (এবং ম্যাচের জন্য বোনাস পয়েন্টের ব্যবধান সামঞ্জস্য করার) বিড়ম্বনার কথা ভাবছি। কোন আপত্তি, মন্তব্য?

------- Final Results -------

158     Happy3Campers
157     LittleKid
71      InsideYourHead
68      HardenedTrio
46      BitterRivals

গুগল ড্রাইভে প্লে-বাই-প্লে ফলাফল

game king-of-the-hill

— Geobits
সূত্র

62

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

— কাজ ওল্ফ

1

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

— foobar

@ ফুবার আমি এটি এড়াতে চেয়েছিলাম কারণ এটি যুদ্ধের n^2পরিবর্তে স্কেল করে n। কেবলমাত্র বর্তমান 7 প্রতিযোগী এবং 100 টি রাউন্ডের সাথে এটি 2100 টি যুদ্ধ (300 টি যেমন রয়েছে, এবং 500 টি রাউন্ডের সাথে 1500)। আরও এন্ট্রিগুলি আসার সাথে সাথে এটি আরও খারাপ হয়ে যায় I আমি # রাউন্ডগুলি ব্যাক করতে পারি, তবে সহজাত পরিবর্তনশীলতার কারণে (স্ট্যাটাসগুলি সম্পর্কিত), এবং 50 এর একাধিক (বোনাস পয়েন্টের জন্য) রাখা আরও সহজ।

— জিওবিটস

এই চ্যালেঞ্জটির কোনও আপডেটের দরকার নেই? :)

— গলগথ 21

@ ঘোলগোথ 21 হ্যাঁ, আমি বিশ্বাস করি এটি হয়। আমি সম্ভবত আজ এটিতে যেতে পারি না, তবে সম্ভবত আগামীকাল বা পরের দিন। আপনি চাইলে বৃহস্পতিবারের মধ্যে আপডেট না হলে আমাকে চ্যাটে পিং করুন।

— জিওবিটস

16

শুভ 3 শিবির - পিএইচপি

একগুচ্ছ কাপুরুষ যারা ক্ষোভের ঝাঁকুনি দিয়ে মন্ত্রিসভায় বিরোধী দলকে আঘাত করতে এবং তাদেরকে দূরে সরাতে দেখতে পছন্দ করে।

সম্পাদনা : মিঃ লম্পিকে কঠোর শাস্তি দেওয়া হয়েছে এবং কোনও খারাপ কথা আর বলবেন না

কুশলী`Grass - atk:50 def:99 spd:81 Confuse Poison Heal`

একটি বিষাক্ত আর্মলেস বিভার যারা সমস্যাযুক্ত হাতের মুঠোয় দিয়ে মানুষকে বিভ্রান্ত করতে পছন্দ করে

Flippy`Water - atk:50 def:99 spd:81 Confuse Burn Heal`

বোর-মি-মূর্খ কথাবার্তা এবং শিখা যুদ্ধের জন্য একটি নরম স্পট সহ বুলেটিন বোর্ডের একজন অভিজ্ঞ।

বাদামে পূর্ণ`Fire - atk:50 def:99 spd:81 Burn Poison Heal`

ব্যাপক ধ্বংসের অস্ত্রগুলি তাঁর প্রিয় ক্যান্ডিস।

পিণ্ডময়`Php - lines:500 clarity:05 spd:01 Gather Guess Store`

তার প্রায় 2 ডিজিটের আইকিউ এবং অভূতপূর্ব স্মৃতিতে ধন্যবাদ, লম্পি শত্রুদের পদক্ষেপের অনুমান করতে পারে। বেশিরভাগ ক্ষেত্রে।

কৌশল

কৌশলটি হ'ল শত্রুরা যত তাড়াতাড়ি সম্ভব বিষাক্ত, পোড়া ও বিভ্রান্ত করা।
উপরোক্ত 3 টি বানরের চেয়ে কম শক্তিশালী বলে মনে হওয়ায় ঘুম ব্যবহার করা হয়নি।
বিভ্রান্তি দীর্ঘমেয়াদে মারাত্মক, যেহেতু এটি 30% দ্বারা ক্ষতি হ্রাস করে (উভয়ই ক্ষয়ক্ষতি এবং বানান ingালাই), নিরাময়কারীদের তাদের নিরাময়ের হাত থেকে বাঁচায় এবং ভারী আঘাতকারীদের খারাপভাবে ক্ষতি করে (50 ডিএফ / 100 অ্যাটাক দানব নিজেই 20 পয়েন্ট ক্ষতি করে )।

একবার শত্রু পুঙ্খানুপুঙ্খভাবে পেস্ট করা হয়ে গেলে, আমার ক্যাম্পাররা তাকে কেবল সিজ্জল, পচা এবং নিজেকে ঘুষি মারে watch

উচ্চ প্রতিরক্ষা এবং নিরাময় যন্ত্রণার সময় আগত ক্ষয় প্রশমিত করতে ব্যবহৃত হয়।

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

প্রতিরক্ষা করার পরে, গতি বাড়ানো সবচেয়ে গুরুত্বপূর্ণ স্ট্যাটাস।
পরের ধাক্কা আসার আগে নিরাময়ের প্রয়োগের জন্য উদ্যোগ গুরুত্বপূর্ণ is

আক্রমণ মোটেই ব্যবহৃত হয় না।

মন্ত্র কি চূড়ান্ত অস্ত্র?

বিষ, পোড়া ও বিভ্রান্তের মতো বানান অন্যান্য আক্রমণগুলির সামগ্রিক শিলা / কাগজ / কাঁচি যুক্তিকে এড়িয়ে চলে।

একবার কোনও দৈত্য আক্রান্ত হয়ে গেলে, বানানকারী মারা যাওয়ার পরেও এটি এইচপি হারাতে থাকবে। মনে হ'ল বিড়ালের ভূত তাকে আক্রমণ করে চলেছে।
তদ্ব্যতীত, সম্পূর্ণরূপে বাফ-আপ বৃহত আক্রমণ (5 বারের পরে 50 পয়েন্টের উপরে) এর চেয়ে বিষ দ্রুততর শক্তিশালী হয়ে ওঠে।

একটি বিষযুক্ত এবং পোড়া দানবটির আয়ু 3 টি নিরাময়ের পরেও 8 টার্নের অতিক্রম করে না।

মার্টিনের বটগুলি যেমন বোঝা যাচ্ছে, গেমের ভারসাম্য বেশ ভাল।
এটি মূলত এমন উদ্যোগ যা খাঁটি বানানকারী এবং খাঁটি আক্রমণকারীদের মধ্যে ভারসাম্য রক্ষা করবে।

কোড

সাথে দাওয়াত php campers.php

এটি একটি কুরুচিপূর্ণ জগাখিচুড়ি, তবে স্পষ্টতই ইন্টারফেসটি তেমন কোনও কাজে দেয় না।

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

<?php

// ============================================================================
// Game
// ============================================================================
class G {
    static $code_type = array ("Normal", "Psychic", "Fire", "Water", "Grass", "?", "self"); 
    static $code_move = array    ("Punch", "Heal", "Slow", "Pain", "Sleep", "Weaken", "Fireball", "Burn", "Sharpen", "Watergun", "Confuse", "Shield", "Vine", "Poison", "Sap", "?", "self", "pass");
    static $move_uses = array (1000,3,5,1000,3,5,1000,3,5,1000,3,5,1000,3,5,   2000,2000);
    static $move_type      = array (0,0,0,1,1,1,2,2,2,3,3,3,4,4,4, 5,5,5);
    static $move_dmg       = array (20,0,10,20,0,10,20,0,10,20,0,10,20,0,10,  20,10,0);
    static $move_forbidden = array (1,1,1,0,0,0,4,4,4,2,2,2,3,3,3);
    static $code_effect = array ("N", "Poison", "Confuse", "Burn", "Sleep", "H", "Sharpen", "Weaken", "Shield", "Sap", "Slow"); 
    static $decode_type, $decode_move, $decode_effect;
    static $damage_multiplier = array (
        array (2, 0, 1, 1, 1, 0),
        array (0, 2, 1, 1, 1, 0),
        array (1, 1,.5, 2,.5, 0),
        array (1, 1,.5,.5, 2, 0),
        array (1, 1, 2,.5,.5, 0),
        array (2, 2, 2, 2, 2,-1),
        array (9, 9, 9, 9, 9, 9, 1));
    static $atk_score = array ("Poison"=> 1002, "Confuse"=>1001, "Burn"=>1000);
    static $status_field = "atk:def:spd:hp:type:Pturns";
    static $all_moves, $strong_moves, $medium_moves, $effect_moves, $possible_moves;

    function init()
    {
        self::$status_field = explode (":", self::$status_field);
        foreach (array ("type", "move", "effect") as $table) self::${"decode_$table"} = array_flip (self::${"code_$table"});
        foreach (self::$code_move as $c=>$m)
        {
            if ($m == "?") break;
            self::$all_moves[] = new Move($m);
            if (self::$move_uses[$c] >  5) self::$strong_moves[] = $m;
            if (self::$move_uses[$c] == 5) self::$medium_moves[] = $m;
            if (self::$move_uses[$c] == 3) self::$effect_moves[] = $m;
            for ($type = 0 ; $type != 5 ; $type++) if ((self::$move_uses[$c] >  5) && (self::$move_forbidden[$c] != $type)) self::$possible_moves[$type][] = $m;
        }
    }

    function __construct ($name, $team)
    {
        $this->turn = 0;
        $this->name = $name;
        $this->team = $team;
        $this->results_pending = false;
    }

    function parse_team ($tpack, $own_team)
    {
        $pack = explode ("|", $tpack);
        list ($name,$active) = explode (":", array_shift($pack));
        if ($own_team)
        {
            $team = $this->team;
        }
        else
        {
            if (!isset($this->enemies[$name])) $this->enemies[$name] = new Team(array (new Monster (), new Monster (), new Monster ()));
            $team = $this->foes = $this->enemies[$name];
        }
        $team->active = $active;
        foreach ($pack as $i=>$mpack) $team->monster[$i]->parse_monster ($own_team, $mpack);
    }

    function choose_active ()
    {
        // detect start of round
        $team = $this->team;
        $foes = $this->foes;
        foreach ($team->monster as $i=>$m) if ($m->hp > 0) $candidate[$i] = $m;
        if (count ($candidate) == 3)
        {
            $this->results_pending = false;
            $this->round++;

            // reinitialize all monsters
            foreach (array($team, $foes) as $t)
            foreach ($t->monster as $m)
                $m->start_round();

            // guess initial opponent
            $opponent = $foes->initial_opponent();
        }
        else
        {
            $this->analyze_last_round();
            $opponent = $foes->active();
        }
        return $this->do_switch ($opponent);
    }

    function choose_attacker ($foe)
    {
        foreach ($this->team->monster as $i=>$m) if ($m->can_attack($foe)) $candidate[$i] = $m;
        if (isset($candidate))
        {
            uasort ($candidate, function ($a,$b) use ($foe) { return ($a->atk_score != $b->atk_score) ? $b->atk_score - $a->atk_score : $b->life_expectancy($foe) - $a->life_expectancy($foe); });
            return key($candidate);
        }
        return -1;
    }

    function do_switch ($foe)
    {
        $replacement = $this->choose_attacker ($foe);
        if ($replacement < 0)
        {
            $candidate =  $this->team->monster;
            uasort ($candidate, function ($a,$b) use ($foe) { return $b->life_expectancy($foe) - $a->life_expectancy($foe); });
            $replacement = key($candidate);
        }

        $this->old_own = $this->team->monster[$replacement];
        $this->old_own->attack = "pass";
        return $replacement;
    }

    function choose_action ()
    {
        $this->analyze_last_round();
        $own = $this->team->active();
        $foe = $this->foes->active();
        $this->old_own = $own;

        if ($own->hp <= $own->max_damage($foe) && $own->can_do ("Heal")) return $own->execute("Heal");
        if ($attack = $own->can_attack($foe)) return $own->execute($attack);
        if ($own->hp <= 50 && $own->can_do ("Heal")) return $own->execute("Heal");

        return 10 + $this->do_switch ($foe);    
    }

    function choose_bonus()
    {
        foreach ($this->team->monster as $m)
        {
            if ($m->spd_b == 0) { $m->spd_b++; $res[] = 2; }
            else                { $m->def_b++; $res[] = 1; }
        }
        return implode (":", $res);
    }

    function parse ($parts)
    {
        self::parse_team ($parts[1], true);
        self::parse_team ($parts[2], false);    
    }

    function analyze_last_round()
    {
        if ($this->results_pending)
        {
            $this->results_pending = false;

            $foes = $this->foes;
            $foe = null;
            foreach ($foes->monster as $m) if ($m->hp != $m->old->hp) $foe = $m;
            if ($foe === null) $foe = $foes->monster[$foes->active];

            $this->old_own->guess_attack($foe);
        }
    }

    function process ($line)
    {
        $parts = explode ("#", $line);
        switch ($parts[0])
        {
        case "T": // register for tournament
            echo "$this->name|$this->team";
            break;
        case "C": // designate active monster
            $this->parse ($parts);
            echo $this->choose_active();
            break;
        case "A": // choose round action
            $this->parse ($parts);
            echo $this->choose_action();

            // save current state
            foreach (array($this->team, $this->foes) as $t)
            foreach ($t->monster as $m)
            {
                unset ($m->old);
                $m->old = clone ($m);
            }
            $this->results_pending = true;
            break;
        case "B": // distribute stat bonus
            echo $this->choose_bonus();
            break;
        }

    }
}
G::init();

// ============================================================================
// Move
// ============================================================================
class Move {
    function __construct ($move)
    {
        $this->register($move);
    }

    function register ($move)
    {
        $this->type = G::$decode_move[$move];
        $this->reinit();
    }

    function reinit()
    {
        $this->uses = G::$move_uses[$this->type];
    }

    function __tostring() { return G::$code_move[$this->type]."($this->uses)"; }
}

// ============================================================================
// Monster
// ============================================================================
class Monster { 
    function __construct ($name="?", $type="?", $atk=100, $def=100, $spd=100, $m0="?", $m1="?", $m2="?")
    {
        $this->name = $name;
        $this->type = G::$decode_type[$type];
        $this->atk  = $atk;
        $this->def  = $def;
        $this->spd  = $spd;
        $this->hp   = 100;
        $this->move = array (new Move($m0), new Move($m1), new Move($m2));
        $this->atk_b = 0;
        $this->def_b = 0;
        $this->spd_b = 0;
        foreach (G::$code_effect as $e) $this->$e = 0;
    }

    function __tostring ()
    {
        return implode (":", array (
            $this->name,
            $this->type,
            $this->atk,
            $this->def,
            $this->spd,
            $this->move[0]->type,
            $this->move[1]->type,
            $this->move[2]->type));
    }

    function start_round()
    {
        foreach ($this->move as $m) $m->reinit();
    }

    function parse_monster ($own_team, $spack)
    {
        $pack = explode (":", $spack);
        $name = array_shift ($pack); // get name
        array_shift ($pack); // skip id
        if ($this->name == "?") $this->name = $name; // get paranoid
        else if ($this->name != $name) die ("expected $this->name, got $name");

        // store updated values
        foreach (G::$status_field as $var) $this->$var = array_shift ($pack);
        if ($own_team)
        {
            foreach ($this->move as $m) $m->new_count = array_shift($pack);
            $pack = array_slice ($pack, 3); // these are maintained internally
        }
        $var = array();
        foreach ($pack as $e) @$var[G::$code_effect[$e]]++; 
        foreach (G::$code_effect as $e) $this->$e = @$var[$e]+0;
    }

    function damage_recieved ($attack, $foe=null)
    {
        if ($attack == "self") $foe = $this;
        $a = G::$decode_move[$attack];
        $type = G::$move_type[$a];
        $dmg = g::$move_dmg[$a];

        if ($dmg == 0) return 0;

        $atk = ($foe ->atk+$foe ->atk_b) * pow (.8, ($foe ->Weaken - $foe ->Sharpen));
        $def = ($this->def+$this->def_b) * pow (.8, ($this->Sap    - $this->Shield ));

        $boost = ($foe->type == $type) ? 1.2 : 1;
        return max (floor ($dmg * $atk / $def * $boost * G::$damage_multiplier[$this->type][$type]), 1);
    }

    function guess_attack_from_effect ($attacks)
    {
        foreach ($attacks as $status) if ($this->$status != $this->old->$status) return $status;
        return "?";
    }

    function guess_attack_from_damage ($foe, $damages)
    {
        $select = array();
        foreach (G::$possible_moves[$foe->type] as $attack)
        {
            $dmg = $this->damage_recieved ($attack, $foe);
            foreach ($damages as $damage) if ($damage != 0 && abs ($dmg/$damage-1) < 0.1) $select[$attack] = 1;
        }
        $res = array();
        foreach ($select as $a=>$x) $res[] = $a;
        return $res;
    }

    function guess_attack ($foe)
    {
        $attempt = G::$decode_move[$this->old->attack];
        $success = ($this->old->attack == "pass");
        foreach ($this->move as $m)
        {
            if ($m->type == $attempt)
            {
                if ($m->new_count == $m->uses-1)
                {
                    $m->uses--;
                    $success = true;
                }
                break;
            }
        }

        $possible = array();
        $attack = $this->guess_attack_from_effect (array("Burn", "Confuse", "Poison", "Sleep", "Slow", "Weaken", "Sap"));
        if ($attack == "?") $attack = $foe->guess_attack_from_effect (array("Sharpen", "Shield"));
        if ($attack == "?")
        {
            $foe_damage = $this->old->hp - $this->hp - (10 * $this->Burn + 5 * $this->Pturns*$this->Poison);
            if ($this->old->attack == "Heal" && $success) $foe_damage += 50;
            $possible_dmg[] = $foe_damage;
            //;!;if ($this->Confuse) $possible_dmg[] = $foe_damage + $this->damage_recieved ("self");
            $possible = $this->guess_attack_from_damage ($foe, $possible_dmg);
            if (count ($possible) == 1) $attack = $possible[0];
        }
        if ($attack == "?")
        {
            $own_damage = $foe->old->hp - $foe->hp 
                        - (10 * $foe->Burn + 5 * $foe->Pturns*$foe->Poison)
                        + $foe->damage_recieved ($this->attack);
            if (abs ($own_damage/50+1) < 0.1) $attack = "Heal";
        }
        if ($attack != "?")
        {
            $type = G::$decode_move[$attack];
            if ($attack != "?")
            {
                foreach ($foe->move as $m) if ($m->type == $type) goto found_old;
                foreach ($foe->move as $m) if ($m->type == 15) { $m->register($attack); goto found_new; }
            }
            found_new:
            found_old:
        }
    }

    function max_damage($foe)
    {
        $dmg = 0;
        foreach ($foe->move as $m) $dmg = max ($dmg, $this->damage_recieved (G::$code_move[$m->type], $foe));
        return $dmg;
    }

    function expected_damage ($foe)
    {
        return $this->max_damage($foe) + 10 * $this->Burn + 5 * ($this->Pturns+1);
    }

    function life_expectancy ($foe)
    {
        $hp = $this->hp;
        $poison = $this->Pturns;
        $heal = $this->can_do ("Heal");
        $dmg = $this->max_damage($foe);
        for ($turn = 0 ; $hp > 0 && $turn < 10; $turn++)
        {
            $hp -= 10 * $this->Burn + 5 * $poison;
            if ($poison > 0) $poison++;
            $hp -= $dmg;
            if ($hp <= 0 && $heal > 0) { $hp+=50; $heal--; }
        }
        return 100 * $turn + $this->hp;
    }

    function can_attack ($foe)
    {
        $attack = false;
        if ($this->hp > 0)
        {
            if      (!$foe->Poison  && $this->can_do ("Poison" )) $attack = "Poison";
            else if (!$foe->Confuse && $this->can_do ("Confuse")) $attack = "Confuse";
            else if (!$foe->Burn    && $this->can_do ("Burn"   )) $attack = "Burn";
        }
        $this->atk_score = ($attack === false) ? 0 : G::$atk_score[$attack];
        return $attack;
    }

    function can_do($move)
    {
        $type = G::$decode_move[$move];
        foreach ($this->move as $m) if ($m->type == $type && $m->uses > 0) return $m->uses;
        return false;
    }

    function execute($move)
    {
        $type = G::$decode_move[$move];
        foreach ($this->move as $i=>$m) if ($m->type == $type) 
        { 
            if ($m->uses > 0)
            {
//;!;               $m->uses--;
                $this->attack = $move;
            }
            else $this->attack = "pass";
            return $i; 
        }
        die ("$this asked to perform $move, available ".implode(",", $this->move));
    }
}

// ============================================================================
// Team
// ============================================================================
class Team {
    function __construct ($members)
    {
        $this->monster = $members;
    }

    function __tostring()
    {
        return implode ("|", $this->monster);
    }

    function active ()
    {
        return $this->monster[$this->active];
    }

    function initial_opponent()
    {
        return $this->monster[0];
    }
}

// ============================================================================
// main
// ============================================================================
$input = $argv[1];

$team_name = "H3C";
$mem_file = "$team_name/memory.txt";
$trc_file = "$team_name/trace.txt";
if (!file_exists($team_name)) mkdir($team_name, 0777, true) or die ("could not create storage directory '$team_name'");
if ($input == "T") array_map('unlink', glob("$team_name/*.txt"));

if (file_exists($mem_file)) $game = unserialize (file_get_contents ($mem_file));
else
{
    $team = new Team (
        array (
            new Monster ("Handy" , "Grass" , 50, 99, 81, "Confuse", "Poison", "Heal"),
            new Monster ("Nutty" , "Fire"  , 50, 99, 81, "Burn"   , "Poison", "Heal"),
            new Monster ("Flippy", "Water" , 50, 99, 81, "Confuse" , "Burn" , "Heal")));
    $game = new G($team_name,$team);
}

$game->process ($input);
file_put_contents ($mem_file, serialize($game));

ফলাফল

লিটলকিড এখনও মেনেইজ করছে, তবে আমার ত্রয়ী তার বিষাক্ত ফ্রিক্সকে মোটামুটি ব্যবধানে পরাজিত করেছে।

মার্টিনের বটগুলি তাদের উদ্যোগের অভাবে নষ্ট হয়ে যায়, এবং তাদের গতি বাড়ানোর জন্য আক্রমণ কমিয়ে আনা দরকার, যা ক্ষতির মোকাবেলা করার ক্ষমতাকে ধীর করে দেয়।

গ্রহ জাভাস্ক্রিপ্টের নতুন প্রতিদ্বন্দ্বী দলের সাথে একে অপরের সাথে সমান, তবে তারা অন্য প্রতিযোগীদের বিরুদ্ধে আরও খারাপ are তারা আসলে লিটলকিডের স্কোর হ্রাস করতে সহায়তা করে :)।

তাই দেখে মনে হচ্ছে আমার চুদি বন্ধুরা পাহাড়ের রাজা রয়ে গেছে - আপাতত ...

170             H3C
158             Nodemon
145             LittleKid
55              InsideYourHead
42              HardenedTrio
30              BitterRivals

— সম্প্রদায়
সূত্র

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

— Sp3000

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

আমি এটিকে কাঁচি, কাগজ, শিলা-এর মতো একটি অ-ট্রানজিটিভ গেমের সাথে আরও তুলনা করব - যেহেতু প্রভাবগুলি

— খানিকটা

2

হ্যাঁ, পয়জন এবং বার্নের কোনও প্রতিকার না পেয়ে আমি এটিই কল্পনা করেছি। আমার স্বপ্নকে প্রাণবন্ত করার জন্য আপনাকে ধন্যবাদ

— জাস্টহেল্ফ

1

এটি মিঃ লম্পি যখন একই শত্রু থেকে 3 টিরও বেশি বিভিন্ন আক্রমণ সনাক্ত করেছেন তখন তিনি তার বিস্ময় প্রকাশ করেছেন: আমার একটি স্থির সংস্করণ প্রায় সম্পূর্ণ, তবে আমি এখনই অন্য কোনও জিনিসের মাঝে আছি, সুতরাং এক বা একদিনে এই পোস্টটি পোস্ট করা হবে।

7

হার্ডডেনট্রিও, পাইথন 3

যেহেতু জিওবিটস আমাদের দু'টি জমা দেওয়ার পক্ষে যথেষ্ট চমৎকার , তাই আমি ভেবেছিলাম প্রথমটির জন্য নির্বোধ কিছু জমা দেব: পি

পার্টিটি তিনটি কোডমন (মেটাপড 1, মেটাপড 2, মেটাপড 3) একই পরিসংখ্যান এবং চালগুলি সহ:

80 আক্রমণ, 100 প্রতিরক্ষা, 50 গতি
পাঞ্চ, নিরাময়, ~~শিল্ড~~ হার্ডডেন

সমস্ত বোনাস পয়েন্টও প্রতিরক্ষা হিসাবে বরাদ্দ করা হয়।

from collections import namedtuple
import sys

BattleState = namedtuple("BattleState", ["us", "them"])
TeamState = namedtuple("TeamState", ["name", "active", "members"])
MemberState = namedtuple("MemberState", ["name", "id", "attack", "defense", "speed", "hp",
                                         "typeid", "poisonedturns", "otherstats"])

def parse_battle_state(state):
    return BattleState(*map(parse_team_state, state.split("#")))

def parse_team_state(state):
    na, *members = state.split("|")
    name, active = na.split(":")
    return TeamState(name, int(active), list(map(parse_member_state, members)))

def parse_member_state(state):
    name, id_, attack, defense, speed, hp, typeid, poisonedturns, *rest = state.split(":")
    return MemberState(name, int(id_), float(attack), float(defense), float(speed),
                       float(hp), int(typeid), int(poisonedturns), rest)

command = sys.argv[1].strip()

if command.startswith("T"):
    print("HardenedTrio|Metapod1:0:80:100:50:0:1:11|"
          "Metapod2:0:80:100:50:0:1:11|Metapod3:0:80:100:50:0:1:11")

elif command.startswith("C"):
    battle_state = parse_battle_state(command[2:])

    for i, codemon in enumerate(battle_state.us.members):
        if codemon.hp > 0:
            print(i)
            break

elif command.startswith("A"):
    battle_state = parse_battle_state(command[2:])
    current_codemon = battle_state.us.members[battle_state.us.active]

    if current_codemon.hp < 50 and int(current_codemon.otherstats[1]) > 0:
        print(1) # Heal up if low

    elif int(current_codemon.otherstats[2]) > 0:
        print(2) # Harden!

    else:
        print(0) # Punch!

elif command.startswith("B"):
    print("1:1:1")

সাথে চালাও

py -3 <filename>

(অথবা সঙ্গে python/ python3পরিবর্তে pyআপনার ইনস্টলেশন উপর নির্ভর করে)

— Sp3000
সূত্র

7

যা আপনাকে মেরে না, আপনাকে শক্ত করে তোলে।

— FryAmTheEggman

1

@ ফ্রাইআম দ্য

— Sp3000

আমি আপনার কোড পড়ার চেষ্টা করছি, তবে এতে বিভ্রান্ত হয়ে পড়েছি int(current_codemon.otherstats[1])>0। যদি তার কোনও স্ট্যাটাস এফেক্ট থাকে তবে তা সত্য? এবং তিনি কেবল শক্ত ব্যবহার করেন যদি তার দুটি স্থিতির প্রভাব থাকে?

— মাকিং হাঁস

@ মুভিংডাক আপনার কোডমন এর জন্য আপনাকে moveCountএস এর আগে পেয়ে গেছেন effectidতাই এটি এখনও হার্ডডেন ব্যবহার করতে পারে কিনা তা যাচাই করছে। আমি পার্সিংয়ের সাথে অলস হয়ে পড়েছিলাম, এ কারণেই এটি সেখানে lুকে পড়েছে।

— Sp3000

@ এসপি 3000: ওহ! রাইট! Hahaha!

— মাকিং হাঁস

6

আপনার মাথার ভিতরে, রুবি

ব্রায়ান : মানসিক, আক্রমণ: 100, প্রতিরক্ষা: 50, গতি: 80, ব্যথা, ফায়ারবল, ওয়াটারগান
ইলেমন 1 : মানসিক, আক্রমণ: 100, প্রতিরক্ষা: 50, গতি: 80, ফায়ারবল, ওয়াটারগান, ভাইন
ইলেমন 2 : সাইকিক, অ্যাটাক: 100, ডিফেন্স: 50, স্পিড: 80, ফায়ারবল, ওয়াটারগান, ভাইন

TEAM_SPEC = "InsideYourHead"+
            "|Brian:1:100:50:80:3:6:9"+
            "|Elemon1:1:100:50:80:6:9:12"+
            "|Elemon2:1:100:50:80:6:9:12"

def parse_battle_state request
    request.map do |team_state|
        state = {}
        parts = team_state.split '|'
        state[:active] = parts.shift.split(':')[1].to_i
        state[:monsters] = parts.map do |monster_state|
            monster = {}
            parts = monster_state.split(':')
            monster[:name] = parts[0]
            monster[:hp] = parts[5].to_i
            monster[:type] = parts[6].to_i
            monster
        end
        state
    end
end

request = ARGV[0].split '#'
case request.shift
when 'T'
    puts TEAM_SPEC
when 'C'
    battle_state = parse_battle_state request
    my_state = battle_state[0]
    puts my_state[:monsters].find_index {|monster| monster[:hp] > 0}
when 'A'
    battle_state = parse_battle_state request
    my_state, their_state = *battle_state
    my_monster = my_state[:monsters][my_state[:active]]
    their_monster = their_state[:monsters][their_state[:active]]
    puts [1,0,1,2,0][their_monster[:type]]
when 'B'
    puts '0:0:0'
end

সাথে চালাও

ruby InsideYourHead.rb

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

কৌশলটি বেশ সহজ: আক্রমণ! তিনটি দৈত্যের কেবল খাঁটি আক্রমণ চালানো থাকে এবং তারা প্রতিপক্ষের দানবের প্রকারের ভিত্তিতে তাদের চলনটি বেছে নেয়।

আমি পরে একটি নিরাময় মধ্যে নিক্ষেপ সঙ্গে পরীক্ষা করতে পারে।

— মার্টিন ইন্ডার
সূত্র

1

এই এটি আরও আকর্ষণীয় হয়ে ওঠে। আমি জানতাম যে তার জন্য আমি আপনার উপর নির্ভর করতে পারি, মার্টিন :)

6

লিটলকিড, জাভা

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

public class LittleKid {

    public static void main(String[] args) {
        if(args.length < 1){
            System.out.println("Geobits says you can't do this.");
            System.exit(0);
        }

        String[] sections = args[0].split("#");
        String me, them, out = "";
        switch(sections[0]){
            case "T":
                out = "LittleKid";
                out += "|Poisoner:0:80:100:50:0:1:13";
                out += "|Poisoner:0:80:100:50:0:1:13";
                out += "|Poisoner:0:80:100:50:0:1:13";
                break;
            case "B":
                out = "1:1:1";
                break;
            case "C":
                me = sections[1];
                them = sections[2];
                int pick = 0;

                if(!isAlive(me, pick)){
                    for(int i=0;i<3;i++){
                        if(isAlive(me,i))
                            pick = i;
                    }
                }

                out = String.valueOf(pick);
                break;
            case "A":
                me = sections[1];
                them = sections[2];
                int active = getActive(me);
                int enemyActive = getActive(them);
                if (getField(me, HP, active) < 50 && getField(me, MOVE1, active) != 0) {
                    out = "1";
                } else if (getEffectCount(them, POISON, enemyActive, false) < 1 && getField(me, MOVE2, active) != 0) {
                    out = "2";
                } else {
                    out = "0";
                }
                break;
            default:
                out = "Invalid query from controller.";             
        }
        System.out.println(out);
    }

    static boolean isAlive(String teamState, int who){
        return getField(teamState, HP, who) > 0;
    }

    static int getActive(String teamState){
        return Integer.parseInt(teamState.split("\\|")[0].split(":")[1]);
    }

    static int getField(String teamState, int field, int who){
        String[] fields = teamState.split("\\|")[who+1].split(":");
        return Integer.parseInt(fields[field]);
    }

    static int getEffectCount(String teamState, int effect, int who, boolean mine){
            String[] fields = teamState.split("\\|")[who+1].split(":");
            int count = 0;
            for(int i=mine?14:8;i<fields.length;i++){
                if(Integer.parseInt(fields[i]) == effect)
                    count++;
            }
            return count;
    }

    final static int ID =       1; 
    final static int ATTACK =   2; 
    final static int DEFENSE =  3; 
    final static int SPEED =    4; 
    final static int HP =       5; 
    final static int TYPE =     6;
    final static int MOVE0 =    8; 
    final static int MOVE1 =    9; 
    final static int MOVE2 =    10;

    final static int POISON =           1;
}

— CommonGuy
সূত্র

5

" জিওবিটস বলছেন আপনি এটি করতে পারবেন না ": ডি

— জিওবিটস

দেখে মনে হচ্ছে বিষটি এই গেমটির আসল এ-বোমা :)

5

নডমন - জাভাস্ক্রিপ্ট

যেহেতু স্থিতিটি প্রভাবশালী কৌশল হিসাবে প্রতীয়মান হয়, তাই এই দলটি প্রতিপক্ষের কাছে বিষ এবং বিভ্রান্তির মতো স্ট্যাটাসগুলি পেতে গতিতে মনোনিবেশ করে এবং তারপরে প্রতিপক্ষের অপচয় থেকে দূরে থাকাকালীন নিরাময় এবং / অথবা ঘুম নিয়ে স্টল করে।

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

/*jshint node:true*/
'use strict';

var fs = require('fs');

var dataFile = 'Nodemon/data.json';
function getData(callback) {
  fs.readFile(dataFile, 'utf8', function(err, contents) {
    var data = {round: 0};

    if(!err) {
      data = JSON.parse(contents);
    }

    callback(data);
  });
}

function saveData(data, callback) {
  fs.mkdir('Nodemon', function() {    
    fs.writeFile(dataFile, JSON.stringify(data), callback);
  });
}

var effect = {
  poison: '1',
  confusion: '2',
  burn: '3',
  sleep: '4',
  heal: '5',
  attackUp: '6',
  attackDown: '7',
  defenseUp: '8',
  defenseDown: '9',
  speedDown: '10'
};

function parseMemberCommon(args) {
  return {
    name: args[0],
    id: args[1],
    baseAttack: +args[2],
    baseDefense: +args[3],
    baseSpeed: +args[4],
    hp: +args[5],
    typeId: args[6],
    poisonedTurns: +args[7],
    effects: args.slice(8)
  };
}

function parseOwnMember(arg) {
  var args = arg.split(':');

  var ownArgs = args.splice(8, 6);

  var member = parseMemberCommon(args);

  member.moveCount = [
    +ownArgs[0],
    +ownArgs[1],
    +ownArgs[2]
  ];

  member.bonusAttack = +ownArgs[3];
  member.bonusDefense = +ownArgs[3];
  member.bonusSpeed = +ownArgs[3];

  return member;
}

function parseOpponentMember(arg) {
  return parseMemberCommon(arg.split(':'));
}

function parseTeamStateCommon(arg, memberParse) {
  var args = arg.split(':');
  var state = {
    name: args[0],
    members: []
  };
  args = arg.substring(state.name.length + 1).split('|');
  var activeSlot = args[0];
  for(var index = 1; index < args.length; index++) {
    state.members.push(memberParse(args[index]));
  }
  state.activeMember = state.members[activeSlot];
  return state;
}

function parseOwnState(arg) {
  return parseTeamStateCommon(arg, parseOwnMember);
}

function parseOpponentState(arg) {
  return parseTeamStateCommon(arg, parseOpponentMember);
}

function parseBattleState(arg) {
  var args = arg.split('#');
  return {
    own: parseOwnState(args[0]),
    opponent: parseOpponentState(args[1])
  };
}

function teamData() {

  saveData({round:0}, function() {
    console.log('Nodemon|' + 
      'Charasaur:0:50:80:100:10:13:1|' +
      'Bulbtortle:4:50:80:100:10:13:1|' +
      'Squirtmander:1:50:80:100:10:13:4');
  });
}

function getActiveIndex(battleState) {
  for(var index = 0; index < battleState.own.members.length; index++) {
    var member = battleState.own.members[index];
    if(member.hp > 0) {
      return index;
    }
  }
}

function chooseActive(arg) {
  var battleState = parseBattleState(arg);

  getData(function(data) {
    var allFull = true;
    for(var index = 0; index < battleState.opponent.members.length; index++) {
      var member = battleState.opponent.members[index];
      if(!data.maxSpeed || member.baseSpeed > data.maxSpeed) {
        data.maxSpeed = member.baseSpeed;
      }
      if(member.hp < 100) {
        allFull = false;
      }
    }

    if(allFull) {
      data.round++;
    }

    saveData(data, function() {
      console.log(getActiveIndex(battleState));
    });    
  });
}

function useMove(moves, battleState) {
  var fighter = battleState.own.activeMember;

  for(var moveIndex = 0; moveIndex < moves.length; moveIndex++) {
    var move = moves[moveIndex];
    if(fighter.moveCount[move]) {
      return move;
    }

    for(var memberIndex = 0; memberIndex < battleState.own.members.length; memberIndex++) {
      var member = battleState.own.members[memberIndex];

      if(member.hp > 0 && member.moveCount[move] > 0) {
        return 10 + memberIndex;
      }
    }
  }

  return -1;  //do nothing
}

function battleAction(arg) {
  var battleState = parseBattleState(arg);

  var fighter = battleState.own.activeMember;
  var opponent = battleState.opponent.activeMember;

  var attemptedMoves = [];

  if(opponent.effects.indexOf(effect.poison) === -1) {
    attemptedMoves.push(1);
  }

  if(opponent.effects.indexOf(effect.confusion) === -1) {
    attemptedMoves.push(0);
  }

  if(fighter.name === 'Squirtmander') {
    //sleep
    if(opponent.effects.indexOf(effect.sleep) === -1) {
      attemptedMoves.push(2);
    }
  }
  else {
    //heal
    if(fighter.hp <= 60) {
      attemptedMoves.push(2);
    }
  }

  console.log(useMove(attemptedMoves, battleState));
}

function bonusStats(arg) {
  var teamState = parseOwnState(arg);

  getData(function(data) {
    var result = '1:';

    if(data.round % 4 === 0) {
      result += '1:';
    }
    else {
      result += '2:';
    }
    if(teamState.members[2].baseSpeed + teamState.members[2].bonusSpeed > data.maxSpeed + (data.round / 2)) {
      result += '1';
    }
    else {
      result += '2';
    }
    console.log(result);
  });
}

var actions = {
  'T': teamData,
  'C': chooseActive,
  'A': battleAction,
  'B': bonusStats
};

var arg = process.argv[2];
actions[arg[0]](arg.substring(2));

সাথে চালাও

node nodemon

দ্রষ্টব্য দুঃক্ষিত করার nodemon ।

— ক্ষুদ্র কুর্তাবিশেষ
সূত্র

এটি একটি সার্ভার-সাইড স্ক্রিপ্ট বৈশ্বিক যুদ্ধে

4

তিক্ত প্রতিদ্বন্দ্বী - জাভা

একটি ঘাস / ফায়ার / জল দল যা এটি পরিবর্তন করতে পছন্দ করে।

Greenosaur

কারও উপর কমপক্ষে নিরপেক্ষ কভারেজ রয়েছে। প্রতিরক্ষার অভাবের জন্য উচ্চ গতি।

Type: Grass
Attack:   80     Vine
Defense:  50     Punch
Speed:   100     Pain

Searizard

কম আক্রমণে শত্রুদের স্যাপ করার চেষ্টা করে। তার পরে বার্নস এবং ফায়ারবলস।

Type: Fire
Attack:  100     Fireball
Defense:  50     Burn
Speed:    80     Sap

আপনি কি আমার সাথে কি করতে চান

এর ইতিমধ্যে উচ্চ প্রতিরক্ষা উন্নত করতে শিল্ড ব্যবহার করে। প্রয়োজনে আরোগ্য দেয়।

Type: Water
Attack:   80     Watergun
Defense: 100     Shield
Speed:    50     Heal

কোড

এটিও নিয়ামকের সাথে অন্তর্ভুক্ত। এই হল একটি প্রতিদ্বন্দ্বী দল DummyTeam অসদৃশ। কমান্ডটির জন্য প্রয়োজনীয় players.confহ'ল:

java BitterRivals

public class BitterRivals {

    public static void main(String[] args) {
        if(args.length < 1){
            System.out.println("You're not doing this right. Read the spec and try again.");
            System.exit(0);
        }

        String[] sections = args[0].split("#");
        String me, them, out = "";
        switch(sections[0]){
            case "T":
                out = "BitterRivals";
                out += "|Greenosaur:4:80:50:100:12:0:3";
                out += "|Searizard:2:100:50:80:6:7:14";
                out += "|Blastshield:3:80:100:50:9:11:1";
                break;
            case "B":
                out = "2:0:1";
                break;
            case "C":
                me = sections[1];
                them = sections[2];

                int pick = 0;
                switch(getField(them, TYPE, getActive(them))){
                    case 0:
                    case 1:
                    case 3:
                        pick = 0;
                        break;
                    case 2:
                        pick = 2;
                        break;
                    case 4:
                        pick = 1;
                        break;
                }

                if(!isAlive(me, pick)){
                    for(int i=0;i<3;i++){
                        if(isAlive(me,i))
                            pick = i;
                    }
                }

                out = pick + "";
                break;
            case "A":
                me = sections[1];
                them = sections[2];
                int active = getActive(me);
                int oType = getField(them, TYPE, getActive(them));
                switch(active){
                    case 0:         // Greenosaur
                        switch(oType){
                            case 0:
                            case 4:
                                out = "1";
                                break;
                            case 1:
                                out = "2";
                                break;
                            case 3:
                                out = "0";
                                break;
                            case 2:
                                if(isAlive(me, 2)){
                                    out = "12";
                                } else if(isAlive(me, 1)){
                                    out = "11";
                                } else {
                                    out = "1";
                                }
                                break;
                        }
                        break;
                    case 1:         // Searizard
                        if(oType == 3){
                            if(isAlive(me, 0)){
                                out = "10";
                                break;
                            } else if(isAlive(me, 2)){
                                out = "12";
                                break;
                            }
                            if(getEffectCount(them, BURN, getActive(them), false) < 1 && getField(me, MOVE1, active) > 0){
                                out = "1";
                            } else if(getField(me, MOVE2, active) > 0){
                                out = "2";
                            } else {
                                out = "3";
                            }                           
                        } else {
                            if(getField(them, ATTACK, getActive(them)) < 80){
                                if(getEffectCount(them, DEFENSE_DOWN, getActive(them), false) < 1 && getField(me, MOVE2, active) > 0){
                                    out = "2";
                                    break;
                                } else if(getEffectCount(them, BURN, getActive(them), false) < 1 && getField(me, MOVE1, active) > 0){
                                    out = "1";
                                    break;
                                }
                            }
                            out = "0";
                        }
                        break;
                    case 2:         // Blastshield
                        if(oType == 4){
                            if(isAlive(me, 1)){
                                out = "11";
                                break;
                            } else if(isAlive(me, 0)){
                                out = "10";
                                break;
                            }
                        }
                        if(getField(me, HP, active) < 50 && getField(me, MOVE2, active) > 0){
                            out = "2";
                        } else if(getEffectCount(me, DEFENSE_UP, active, true) < 3 && getField(me, MOVE1, active) > 0){
                            out = "1";
                        } else {
                            out = "0";
                        }
                        break;
                }
                break;
            default:
                out = "Invalid query from controller.";             
        }
        System.out.println(out);
    }

    static boolean isAlive(String teamState, int who){
        return getField(teamState, HP, who) > 0;
    }

    static int getActive(String teamState){
        return Integer.parseInt(teamState.split("\\|")[0].split(":")[1]);
    }

    static int getField(String teamState, int field, int who){
        String[] fields = teamState.split("\\|")[who+1].split(":");
        return Integer.parseInt(fields[field]);
    }

    static int getEffectCount(String teamState, int effect, int who, boolean mine){
            String[] fields = teamState.split("\\|")[who+1].split(":");
            int count = 0;
            for(int i=mine?14:8;i<fields.length;i++){
                if(Integer.parseInt(fields[i]) == effect)
                    count++;
            }
            return count;
    }

    final static int ID =       1; 
    final static int ATTACK =   2; 
    final static int DEFENSE =  3; 
    final static int SPEED =    4; 
    final static int HP =       5; 
    final static int TYPE =     6; 
    final static int PTURNS =   7; 
    final static int MOVE0 =    8; 
    final static int MOVE1 =    9; 
    final static int MOVE2 =    10; 
    final static int HA =       11; 
    final static int HD =       12; 
    final static int HS =       13; 

    final static int POISON =           1;
    final static int CONFUSION =        2;
    final static int BURN =             3;
    final static int SLEEP =            4;
    final static int ATTACK_UP =        6;
    final static int ATTACK_DOWN =      7;
    final static int DEFENSE_UP =       8;
    final static int DEFENSE_DOWN =     9;
    final static int SPEED_DOWN =       10;
}

— Geobits
সূত্র

4

ত্রুটি 310: প্রচুর পুনঃনির্দেশ - সি ++

বিষের ক্ষয়ক্ষতি মোকাবেলার জন্য একটি উচ্চ প্রশিক্ষিত এবং সংগঠিত দল

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

প্রতিষেধক

`Type : Normal - atk:50 def:100 spd:80 - Poison/Burn/Heal`

প্রতিষেধক বিষ পছন্দ করে। এতোটুকু যে আমি তাকে ভিড়ের আক্রমণে ছুটে যেতে বাধা দিতে পারি না।

জেন

`Type : Fire - atk:100 def:80 spd:50 - Poison/Vine/Heal`

জেন একটি খুব আশ্চর্যজনক কোডডোন যা সমস্ত প্রভাবের সাথে মিটমাট করে। তিনি তার শত্রুদের তার নীরবতার বিরুদ্ধে প্রচেষ্টা এবং নিঃসরণ দেখতে পছন্দ করেন।

Triforce

`Type : Psychic - atk:88 def:60 spd:82 - Fireball/Watergun/Vine`

ট্রাইফোর্স একটি ক্লাসিক কোডডমন, লড়াইয়ের জন্য সর্বদা প্রস্তুত। এই ব্যক্তিটি তার মানসিক শক্তিটি তিনটি উপাদানকে নিয়ন্ত্রণ করতে ব্যবহার করে এবং যতটা সম্ভব ক্ষতি করতে পারে।

আপনি এখানে দলটি ডাউনলোড করতে পারেন:

লিনাক্স:

http://dl.free.fr/iHYlmTOQ2

সাথে চালু ./Error310TMR

উইন্ডোজ:

http://dl.free.fr/vCyjtqo2s

সাথে চালু ./Error310TMR.exe

কোডটি সম্পূর্ণ সি ++ প্রকল্প। আমি এটি প্রকাশ করতে জানি না।

$ wc -l src/*
    165 src/BruteForce.cpp
     26 src/BruteForce.h
    349 src/Codemon.cpp
     77 src/Codemon.h
     21 src/Logger.cpp
     35 src/Logger.h
    105 src/NoTimeToExplain.cpp
     27 src/NoTimeToExplain.h
    240 src/Recoverator.cpp
     31 src/Recoverator.h
     26 src/StrManip.cpp
     16 src/StrManip.h
    303 src/Team.cpp
     68 src/Team.h
     88 src/TooManyRedirects.cpp
     24 src/TooManyRedirects.h
     87 src/Unrecoverable.cpp
     27 src/Unrecoverable.h
     59 src/enums.cpp
    119 src/enums.h
     68 src/main.cpp
   1961 total

তবে এটি খুব কার্যকর:

------- Final Results -------

176     Error310TMR
131     H3C
130     LittleKid
121     Nodemon
58      InsideYourHead
47      HardenedTrio
37      BitterRivals

— GholGoth21
সূত্র

2

রূপকথা

মোটামুটি জেনেরিক-দ্য-রোডের দল। তিনটি প্রত্নতাত্ত্বিকের উপর নির্ভর করে যারা তাদের জিনিসটি করার চেষ্টা করে এবং তারা যদি তাদের জিনিসটি কিছুতেই না করতে পারে তবে স্যুইচ আউট করে।

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

#!/bin/perl
use 5.20.0;
use strict;

use constant MINE => 0;
use constant THEIRS => 1;

$_ = $ARGV[0];

if(/^T/){
    say 'FairyTale|Fairy:1:89:90:51:3:4:13|Dragon:2:100:50:80:6:1:8|Assassin:0:70:60:100:0:1:10';

} elsif(/^C#(.*)/){
    my $state = readBattleState($1);
    if($state->[MINE]->{$state->[MINE]->{slot}}{hp}){
        say $state->[MINE]->{slot};
    } elsif($state->[MINE]->{($state->[MINE]->{slot}+1)%3}{hp}){
        say (($state->[MINE]->{slot}+1)%3);
    } else {
        say (($state->[MINE]->{slot}+2)%3);
    }

} elsif(/^A#(.*)/){
    my $state = readBattleState($1);
    my @actives = (
        $state->[MINE]->{$state->[MINE]->{slot}},
        $state->[THEIRS]->{$state->[THEIRS]->{slot}}
    );
    if($state->[MINE]->{slot} == 0){
        if(!exists($actives[THEIRS]{effects}{4}) && $actives[MINE]{pp}->[1]){
            say 1;
        } elsif(!exists($actives[THEIRS]{effects}{1}) && $actives[MINE]{pp}->[2]) {
            say 2;
        } elsif(!$actives[THEIRS]{type}) {
            if($state->[MINE]->{($state->[MINE]->{slot}+1)%3}{hp} > 0){
                say (($state->[MINE]->{slot}+1)%3);
            } elsif($state->[MINE]->{($state->[MINE]->{slot}+2)%3}{hp} > 0) {
                say (($state->[MINE]->{slot}+2)%3);
            } else {
                say 0;
            }
        } else {
            say 0;
        }
    } elsif($state->[MINE]->{slot} == 1){
        if(!exists($actives[MINE]{effects}{6}) && $actives[MINE]{pp}->[2]){
            say 2;
        } elsif ($actives[MINE]{hp} > 10 && $actives[MINE]{hp} < 50 && $actives[MINE]{pp}->[1]){
            say 1;
        } else {
            say 0;
        }
    } elsif($state->[MINE]->{slot} == 2){
        if(!exists($actives[MINE]{effects}{6}) && $actives[MINE]{pp}->[2]){
            say 2;
        } elsif ($actives[MINE]{hp} > 10 && $actives[MINE]{hp} < 50 && $actives[MINE]{pp}->[1]){
            say 1;
        } elsif($actives[THEIRS]{type} == 1) {
            if($state->[MINE]->{($state->[MINE]->{slot}+1)%3}{hp} > 0){
                say (($state->[MINE]->{slot}+1)%3);
            } elsif($state->[MINE]->{($state->[MINE]->{slot}+2)%3}{hp} > 0) {
                say (($state->[MINE]->{slot}+2)%3);
            } else {
                say 0;
            }
        } else {
            say 0;
        }
    }

} elsif(/^B#(.*)/){
    my $state = readTeam($1, 1);
    say '1:0:2';
}

sub readBattleState {
    local $_ = $_[0];
    if(/^(.*?)#(.*?)$/){
        my @teams;
        $teams[0] = readTeam($1, 1);
        $teams[1] = readTeam($2, 0);
        return \@teams;
    }
}

sub readTeam {
    my $isMine = $_[1];
    local $_ = $_[0];
    if(/.*?:(?<slot>.*?)\|(.*?)\|(.*?)\|(.*?)$/){
        my %team;
        $team{slot} = $1;
        $team{0} = $isMine ? readYourMember($2) : readTheirMember($2);
        $team{1} = $isMine ? readYourMember($3) : readTheirMember($3);
        $team{2} = $isMine ? readYourMember($4) : readTheirMember($4);
        return \%team;
    }
    return 0;
}

sub readYourMember {
    local $_ = $_[0];
    if(/(?<name>.*?):(?<id>.*?):(?<atk>.*?):(?<def>.*?):(?<spd>.*?):(?<hp>.*?):(?<type>.*?):(?<poison>.*?):(?<move0>.*?):(?<move1>.*?):(?<move2>.*?):(?<batk>.*?):(?<bdef>.*?):(?<bspd>.*?)(?<effects>(?::.*)|$)/){
        my %effects = map { $_ => 1 } readEffects($+{effects});
        my %member = (
            name   => $+{name},
            id     => $+{id},
            hp     => $+{hp},
            atk    => $+{atk}+$+{batk},
            def    => $+{def}+$+{bdef},
            spd    => $+{spd}+$+{bspd},
            type   => $+{type},
            pp     => [$+{move0}, $+{move1}, $+{move2}],
            poistrn=> $+{poison},
            effects=> \%effects
        );
        return \%member;
    }
}

sub readTheirMember {
    local $_ = $_[0];
    if(/(?<name>.*?):(?<id>.*?):(?<atk>.*?):(?<def>.*?):(?<spd>.*?):(?<hp>.*?):(?<type>.*?):(?<poison>.*?)(?<effects>(?::.*)|$)/){
        my %effects = map { $_ => 1 } readEffects($+{effects});
        my %member = (
            name   => $+{name},
            id     => $+{id},
            hp     => $+{hp},
            atk    => $+{atk},
            def    => $+{def},
            spd    => $+{spd},
            type   => $+{type},
            poistrn=> $+{poison},
            effects=> \%effects
        );
        return \%member;
    }
    return 0;
}

sub readEffects {
    local $_ = $_[0];
    my @retval = /:([^:]*)/g;
    if(!@retval){
        @retval = (0);
    }
    return @retval;
}

সাথে চালাও

perl fairytale.pl

— mezzoEmrys
সূত্র

প্রথম মারা যাওয়ার পরে মৃত সদস্যদের 'বেছে নেওয়ার' চেষ্টা করার জন্য এই বটটি লাথি মেরে যায়। আমি দেখতে পাচ্ছি এমন প্রথম যুদ্ধটি কখনই পেরে ওঠে না।

— জিওবিটস

সত্যি? আমি ভেবেছিলাম যে আমি এই বাগটি আগে কাজ করেছি, সম্ভবত এটি সেই

— কোডটির

ভুলে যাবেন না যে কোনও কোডমন যখন ছিটকে যায়, তখন তার হেল্পপয়েন্টগুলি 0 বা তারও কম হয় । সুতরাং if($state->[MINE]->{$state->[MINE]->{slot}}{hp})বিবৃতি ছাড়া সঠিকভাবে কাজ করবে না >0।

— ঘোলগথ 21

আহ, হ্যাঁ, এটি করতে হবে।

— mezzoEmrys

0

ডামি দল - জাভা

(প্রতিযোগী সিডাব্লু)

অনুশীলন করার জন্য এটি একটি ডামি দল। এটি সমস্ত সাধারণ ধরণের, যা তাদের চলনের (পাঞ্চ, নিরাময়, ধীর) প্রতিটি টার্নের মধ্যে এলোমেলোভাবে চয়ন করে। এটি সঙ্গে মজা আছে।

public class DummyTeam {

    public static void main(String[] args) {
        if(args.length < 1){
            System.out.println("You need to run this from the tournament. Try to keep up.");
            System.exit(0);
        }

        String[] sections = args[0].split("#");
        String out = "";
        switch(sections[0]){
            // team data
            //      sends back all Normal types with minimum stats and Normal moves (randomized name suffixes to distinguish in tests)
            case "T":
                out = "DummyTeam";
                for(int i=0;i<3;i++)
                    out += "|Dummy"+((char)(Math.random()*26)+65) + i + ":0:50:50:50:0:1:2";
                break;
            // bonus points
            //      shoves them all in defense every time
            case "B":
                out = "1:1:1";
                break;
            // choose active
            //      picks last active if alive, otherwise loops to find first living member
            case "C":
                String[] team = sections[1].split("\\|");
                int current = Integer.parseInt(team[0].split(":")[1]);
                if(Integer.parseInt(team[current+1].split(":")[5]) > 0){
                    out = current + "";
                } else {
                    for(int i=1;i<team.length;i++){
                        if(Integer.parseInt(team[i].split(":")[5]) > 0){
                            out = (i - 1) + "";
                        }
                    }
                }               
                break;
            // choose action
            //      chooses a random move. does not check if it ran out of uses, so wastes turns quite often
            case "A":
                out = ((int)(Math.random()*3)) + "";
                break;
            default:
                out = "Invalid query from controller.";             
        }
        System.out.println(out);
    }


}

— Geobits
সূত্র

কোডন, আমি তোমাকে বেছে নিই!

সংক্ষিপ্ত বিবরণ

দানব

প্রকারভেদ

পরিসংখ্যান

মানসম্পন্ন

গোপন পরিসংখ্যান

যুদ্ধ

টুর্নামেন্ট

প্রোটোকল

কমান্ড

দল তথ্য

অ্যাক্টিভ চয়ন করুন

যুদ্ধ অ্যাকশন

বোনাস পরিসংখ্যান

নিয়ামক

বিধি বিধি

ফলাফল

শুভ 3 শিবির - পিএইচপি

কুশলীGrass - atk:50 def:99 spd:81 Confuse Poison Heal

FlippyWater - atk:50 def:99 spd:81 Confuse Burn Heal

বাদামে পূর্ণFire - atk:50 def:99 spd:81 Burn Poison Heal

পিণ্ডময়Php - lines:500 clarity:05 spd:01 Gather Guess Store

কৌশল

মন্ত্র কি চূড়ান্ত অস্ত্র?

কোড

ফলাফল

হার্ডডেনট্রিও, পাইথন 3

আপনার মাথার ভিতরে, রুবি

লিটলকিড, জাভা

নডমন - জাভাস্ক্রিপ্ট

তিক্ত প্রতিদ্বন্দ্বী - জাভা

Greenosaur

Searizard

আপনি কি আমার সাথে কি করতে চান

কোড

ত্রুটি 310: প্রচুর পুনঃনির্দেশ - সি ++

প্রতিষেধক

Type : Normal - atk:50 def:100 spd:80 - Poison/Burn/Heal

জেন

Type : Fire - atk:100 def:80 spd:50 - Poison/Vine/Heal

Triforce

Type : Psychic - atk:88 def:60 spd:82 - Fireball/Watergun/Vine

লিনাক্স:

উইন্ডোজ:

রূপকথা

ডামি দল - জাভা

(প্রতিযোগী সিডাব্লু)

কুশলী`Grass - atk:50 def:99 spd:81 Confuse Poison Heal`

Flippy`Water - atk:50 def:99 spd:81 Confuse Burn Heal`

বাদামে পূর্ণ`Fire - atk:50 def:99 spd:81 Burn Poison Heal`

পিণ্ডময়`Php - lines:500 clarity:05 spd:01 Gather Guess Store`

`Type : Normal - atk:50 def:100 spd:80 - Poison/Burn/Heal`

`Type : Fire - atk:100 def:80 spd:50 - Poison/Vine/Heal`

`Type : Psychic - atk:88 def:60 spd:82 - Fireball/Watergun/Vine`