Discord Bot Kodları Düello Oyun Komutu

Discord Bot Kodları Düello Oyun Komutu

Bu yazımda başlıktan'da anlayacağınız üzere discord botunuz için bir oyun kodlarını paylaşacağım. Düello veya 1v1 komutu olarak'ta bilinen bu kod ile discord sunucunuzdaki herhangi bir kullanıcı ile karşılıklı bir nevi savaş oyununa benzer bir oyun oynaya bileceksiniz.

Botun içerisine ekleyeceğiniz bu kod ile kullanıcılar arasında botu ayarlayacağı rastgele bir atak ve alınan hasar gibi kullanıcıların birbirlerine verdiği artı ve eksi puan şeklinde çalışan bir oyun sistemidir bu oyun sisteminde de tabi stratejinizde önemlidir. Fazla uzatmadan kod paylaşımlarına geçeyim.

Kurulum için adımları izleyin:

Kod projenizde komutlar klasörüne atılacaktır. Ayrıca util/Util.js adında ek bir dosya kodlarına ihtiyacı vardır. Eğer Util.js dosyanız botunuzda yoksa aşağıda Util.js kodlarınıda vereceğim oradan ekleyiniz. Komut eklemeyi bilmiyorsan buradaki yazımızı okuyarak öğrenebilirsin.
Komut içerisindeki gerekli yerleri kendinize göre düzenleyin.
Modüller için "common-tags" modüllerini eklemeniz gerekmektedir. Ayrıca ek olarak util/Util.js kodlarını eklemeniz gerekmekde. Util.js kodları için gereken modüller "node-superfetch" ve "crypto" eklemeniz gerekmekte.

const Discord = require('discord.js');
const { stripIndents } = require('common-tags');
const { randomRange, verify } = require('../util/Util.js');

exports.run = async (client, message, args) => {
  
  this.fighting = new Set();
  
 let opponent = message.mentions.users.first()
 if (!opponent) return message.reply("Oynamak istediğin kişiyi etiketlemelisin!")
  
  if (opponent.bot) return message.reply('Botlar ile oynayamazsın!');
  if (opponent.id === message.author.id) return message.reply('Kendin ile düello atamazsın!');
  if (this.fighting.has(message.channel.id)) return message.reply('Kanal başına sadece bir düello meydana gelebilir.');
  this.fighting.add(message.channel.id);
  try {
   if (!opponent.bot) {
                await message.channel.send(`${opponent}, düello isteği geldi. Düello'yu kabul ediyor musun? (\`evet\` veya \`hayir\` olarak cevap veriniz.)`);
    const verification = await verify(message.channel, opponent);
    if (!verification) {
     this.fighting.delete(message.channel.id);
     return message.channel.send(`Düello kabul edilmedi...`);
    }
   }
   let userHP = 500;
   let oppoHP = 500;
   let userTurn = false;
   let guard = false;
   const reset = (changeGuard = true) => {
    userTurn = !userTurn;
    if (changeGuard && guard) guard = false;
   };
   };
   const forfeit = () => {
    if (userTurn) userHP = 0;
    else oppoHP = 0;
   };
   while (userHP > 0 && oppoHP > 0) { // eslint-disable-line no-unmodified-loop-condition
    const user = userTurn ? message.author : opponent;
    let choice;
    if (!opponent.bot || (opponent.bot && userTurn)) {
     await message.channel.send(stripIndents`
      ${user}, ne yapmak istersin? \`saldır\`, \`savun\`, \`ultra güç\`, veya \`kaç\`?
      **${message.author.username}**: ${userHP} :heartpulse:
      **${opponent.username}**: ${oppoHP} :heartpulse:
     `);
     const filter = res =>
      res.author.id === user.id && ['saldır', 'savun', 'ultra güç', 'kaç'].includes(res.content.toLowerCase());
     const turn = await message.channel.awaitMessages(filter, {
      max: 1,
      time: 30000
     });
     if (!turn.size) {
      await message.reply(`Üzgünüm ama, süre doldu!`);
      reset();
      continue;
     }
     choice = turn.first().content.toLowerCase();
    } else {
     const choices = ['saldır', 'savun', 'ultra güç'];
     choice = choices[Math.floor(Math.random() * choices.length)];
    }
    if (choice === 'saldır') {
     const damage = Math.floor(Math.random() * (guard ? 10 : 100)) + 1;
     await message.channel.send(`${user}, **${damage}** hasar vurdu!`);
     dealDamage(damage);
     reset();
    } else if (choice === 'savun') {
     await message.channel.send(`${user}, kendisini süper kalkan ile savundu!`);
     guard = true;
     reset(false);
    } else if (choice === 'ultra güç') {
     const miss = Math.floor(Math.random() * 4);
     if (!miss) {
      const damage = randomRange(100, guard ? 150 : 300);
      await message.channel.send(`${user}, Çoook uzak galaksilerden gelen ultra sonik enerjiyi yeterki miktarda topladın ve **${damage}** hasar vurdun!!`);
      dealDamage(damage);
     } else {
      await message.channel.send(`${user}, Çoook uzak galaksilerden gelen ultra sonik enerjiyi yeterli miktarda toplayamadığın için ulta güç kullanamadın!`);
     }
     reset();
    } else if (choice === 'kaç') {
     await message.channel.send(`${user}, kaçtı! Korkak!`);
     forfeit();
     break;
    } else {
     await message.reply('Ne yapmak istediğini anlamadım.');
    }
   }
   this.fighting.delete(message.channel.id);
            const winner = userHP > oppoHP ? message.author : opponent;
   return message.channel.send(`Oyun bitti! Tebrikler, **${winner}** kazandı! \n**${message.author.username}**: ${userHP} :heartpulse: \n**${opponent.username}**: ${oppoHP} :heartpulse:`);
  } catch (err) {
   this.fighting.delete(message.channel.id);
   throw err;
  }
  }

exports.conf = {
  enabled: true,
  guildOnly: false,
  aliases: ['1vs1', '1v1', 'savaş'],
  permLevel: `Yetki gerekmiyor.`
};

exports.help = {
  name: 'duello',
  category: "eğlence",
  description: 'İstediğiniz bir kişi ile düello atarsınız!',
  usage: 'duello <@kullanıcı>'
};

Aşağıdaki Kodları util/Util.js İçerisine ekleyin.

const request = require('node-superfetch');
const crypto = require('crypto');
const { IMGUR_KEY } = process.env;
const yes = ['evet'];
const no = ['hayır']

const deleteCommandMessages = function (msg, client) { // eslint-disable-line consistent-return
 if (msg.deletable && client.provider.get('global', 'deletecommandmessages', false)) {
   return msg.delete();
 }
  };

class Util {
 static wait(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
 }

 static shuffle(array) {
  const arr = array.slice(0);
  for (let i = arr.length - 1; i >= 0; i--) {
   const j = Math.floor(Math.random() * (i + 1));
   const temp = arr[i];
   arr[i] = arr[j];
   arr[j] = temp;
  }
  return arr;
 }

 static list(arr, conj = 'and') {
  const len = arr.length;
  return `${arr.slice(0, -1).join(', ')}${len > 1 ? `${len > 2 ? ',' : ''} ${conj} ` : ''}${arr.slice(-1)}`;
 }

 static shorten(text, maxLen = 2000) {
  return text.length > maxLen ? `${text.substr(0, maxLen - 3)}...` : text;
 }

 static duration(ms) {
  const sec = Math.floor((ms / 1000) % 60).toString();
  const min = Math.floor((ms / (1000 * 60)) % 60).toString();
  const hrs = Math.floor(ms / (1000 * 60 * 60)).toString();
  return `${hrs.padStart(2, '0')}:${min.padStart(2, '0')}:${sec.padStart(2, '0')}`;
 }

 static randomRange(min, max) {
  return Math.floor(Math.random() * (max - min + 1)) + min;
 }

 static trimArray(arr, maxLen = 10) {
  if (arr.length > maxLen) {
   const len = arr.length - maxLen;
   arr = arr.slice(0, maxLen);
   arr.push(`${len} more...`);
  }
  return arr;
 }

 static base64(text, mode = 'encode') {
  if (mode === 'encode') return Buffer.from(text).toString('base64');
  if (mode === 'decode') return Buffer.from(text, 'base64').toString('utf8') || null;
  throw new TypeError(`${mode} is not a supported base64 mode.`);
 }

 static hash(text, algorithm) {
  return crypto.createHash(algorithm).update(text).digest('hex');
 }

 static async randomFromImgurAlbum(album) {
  const { body } = await request
   .get(`https://api.imgur.com/3/album/${album}`)
   .set({ Authorization: `Client-ID ${IMGUR_KEY}` });
  if (!body.data.images.length) return null;
  return body.data.images[Math.floor(Math.random() * body.data.images.length)].link;
 }

 static today(timeZone) {
  const now = new Date();
  if (timeZone) now.setUTCHours(now.getUTCHours() + timeZone);
  now.setHours(0);
  now.setMinutes(0);
  now.setSeconds(0);
  now.setMilliseconds(0);
  return now;
 }

 static tomorrow(timeZone) {
  const today = Util.today(timeZone);
  today.setDate(today.getDate() + 1);
  return today;
 }

 static async awaitPlayers(msg, max, min, { text = 'join game', time = 30000 } = {}) {
  const joined = [];
  joined.push(msg.author.id);
  const filter = res => {
   if (msg.author.bot) return false;
   if (joined.includes(res.author.id)) return false;
   if (res.content.toLowerCase() !== text.toLowerCase()) return false;
   joined.push(res.author.id);
   return true;
  };
  const verify = await msg.channel.awaitMessages(filter, { max, time });
  verify.set(msg.id, msg);
  if (verify.size < min) return false;
  return verify.map(message => message.author);
 }

 static async verify(channel, user, time = 30000) {
  const filter = res => {
   const value = res.content.toLowerCase();
   return res.author.id === user.id && (yes.includes(value) || no.includes(value));
  };
  const verify = await channel.awaitMessages(filter, {
   max: 1,
   time
  });
  if (!verify.size) return 0;
  const choice = verify.first().content.toLowerCase();
  if (yes.includes(choice)) return true;
  if (no.includes(choice)) return false;
  return false;
 }
}

module.exports = Util;