как не допустить случайного взлома бота разногласий

Question

У меня бот-дискорд, он запускает установленную программу при вызове.Если в программе есть какая-либо ошибка, если она вызывается снова, она случайным образом сохранит значения от последнего использования или ответит сама себе, нарушая код еще раз.вот код.

from planetlists import planet_cap,planet_lvl,transfer,temp,credit_per_hour,planet_cost,max_levels_planet
import time
import discord
import asyncio

style.use("fivethirtyeight")

client = discord.Client()
TOKEN = '-----------------'  


async def get_input_of_type(func):
    while True:
        try:
            msg = await client.wait_for('message')
            return func(msg.content)
        except ValueError:
            continue

@client.event  # event decorator/wrapper
async def on_ready():
    global sentdex_guild
    print(f"We have logged in as {client.user}")


@client.event
async def on_message(message):
    global sentdex_guild

    print(f"{message.channel}: {message.author}: {message.author.name}: {message.content}")


    if "hadescalc.logout()" == message.content.lower():
        await client.close()

    elif "hadescalc.planet()" == message.content.lower():
        await message.channel.send("What is the first number?")
        firstnum = await get_input_of_type(int)
        firstnum = firstnum + 3
        await message.channel.send("What is the second number?")
        secondnum = await get_input_of_type(int)
        await message.channel.send(f"{firstnum} + {secondnum} = {firstnum+secondnum}")


    elif message.content.startswith('$planet_cap'):
        channel = message.channel
        try:
            class Planet:
                def __init__(self,level = 0,storage = 0,credit_per_hour = 0,cost = 0,types = 'desert',tier = 1):
                    self.level = level
                    self.storage = storage
                    self.credit_per_hour = credit_per_hour
                    self.cost = cost
                    self.types = types
                    self.tier = tier

                def __str__ (self):
                    return ('level: '+ self.level + ', storage cap: ' + self.storage + ', credits per hour: ' + self.credit_per_hour + ', cost to upgrade: ' + self.cost + ', Planet type: ' + self.types + ', planet tier: ' + self.tier)

                def set_planet_lvl(self,level):
                    self.level = level
                def get_planet_lvl(self):
                    return(self.level)
                def set_planet_cost(self,cost):
                    self.cost = cost
                def get_planet_cost(self):
                    return(self.cost)
                def set_planet_storage(self,storage):
                    self.storage = storage
                def get_planet_storage(self):
                    return(self.storage)
                def set_planet_credit_per_hour(self,credit_per_hour):
                    self.credit_per_hour = credit_per_hour
                def get_planet_credit_per_hour(self):
                    return(self.credit_per_hour)
                def get_planet_types(self):
                    return(self.types)
                def get_planet_tier(self):
                    return(self.tier)

            planet_list = {}


            await channel.send('how many planets do you have?')
            number = await get_input_of_type(int)
            await channel.send('for planet type, choose from desert,fire,water,terran,gas, and ice\n   ')
            await channel.send('for planet tier you can only do the folowing...\n \ndesert- 1,3,4\nfire- 1,3,4\nwater- 1,3,4\nterrran- 1,3,4\ngas- 2,4\nice- 4')
            for i in range(number):  
                await channel.send('level for the {} planet: '.format(i+1))
                levels = await get_input_of_type(str)
                print(levels)
                credit_cap = planet_cap(levels)
                print(credit_cap)

                await channel.send('planet type for the {} planet: '.format(i+1))
                planet_type = await get_input_of_type(str)

                await channel.send('planet tier for the {} planet: '.format(i+1))

                teirlvl = await get_input_of_type(str)
                credits_per_hour = credit_per_hour(planet_type,levels,teirlvl)

                cost = planet_cost(levels)

                planet_list[i] = (Planet(levels,credit_cap,credits_per_hour,cost,planet_type,teirlvl))

            orig_planet_lvl = []
            for i in planet_list:
                orig_planet_lvl.append(planet_list[i].get_planet_lvl())

            cost_list = []
            increase_in_cap = []
            increase_in_income = []
            decider = []
            temp_planets = planet_list.copy()

            current_storage = 0


            for i in temp_planets:
                storage = int(temp_planets[i].get_planet_storage())
                print(storage)
                current_storage += storage

            await channel.send(('Your starting storage is: ',current_storage))

            await channel.send('what is your credit cap goal: ')

            cap_goal = await get_input_of_type(int)

            max_levels = []

            for i in planet_list:
                max_levels.append(max_levels_planet(temp_planets[i].get_planet_types(),temp_planets[i].get_planet_tier()))

            while cap_goal >= current_storage:

                for i in temp_planets:

                    storage = temp_planets[i].get_planet_storage()
                    planet_lvl = temp_planets[i].get_planet_lvl()
                    credit_per_hours = temp_planets[i].get_planet_credit_per_hour()
                    planet_type = temp_planets[i].get_planet_types()
                    planet_tier = temp_planets[i].get_planet_tier()
                    new_lvl = str((int(planet_lvl) + 1))

                    if planet_lvl == max_levels[i]:
                        cost_list.append(temp_planets[i].get_planet_cost())
                        increase_in_cap.append('99999')
                        increase_in_income.append('99999')

                        decider.append('99')
                    else:
                        cost_list.append(temp_planets[i].get_planet_cost())



                        increase_cap = int(planet_cap(new_lvl))- int(storage)
                        if increase_cap == 0:
                            increase_cap = 1
                        increase_in_cap.append(increase_cap)


                        new_credits_per_hour = credit_per_hour(planet_type,new_lvl,planet_tier)
                        increase_in_incomees = (str(int(new_credits_per_hour)-int(credit_per_hours)))
                        if increase_in_incomees == 0:
                            increase_in_incomees = 1
                        increase_in_income.append(increase_in_incomees)


                        decider.append(str((int(cost_list[i])/int(increase_in_cap[i])/ int(increase_in_income[i]))))


                value = min(decider)
                first = ''
                for index,item in enumerate(decider):
                    if item == value:
                        if first == '':
                            await channel.send(('planet',(index +1), '--->', (int(temp_planets[index].get_planet_lvl())+1)))
                            temp_planets[index].set_planet_lvl(str(int(temp_planets[index].get_planet_lvl())+1))
                            temp_planets[index].set_planet_cost(str(planet_cost(str(temp_planets[index].get_planet_lvl()))))
                            temp_planets[index].set_planet_storage(str(planet_cost(str(temp_planets[index].get_planet_lvl()))))
                            temp_planets[index].set_planet_credit_per_hour(str(credit_per_hour(temp_planets[index].get_planet_types(),temp_planets[index].get_planet_lvl(),temp_planets[index].get_planet_tier())))
                            current_storage += int(temp_planets[index].get_planet_storage())
                            first = '1'
                cost_list = []
                increase_in_cap = []
                increase_in_income = []
                decider = []
                await channel.send('Your storage went up to: {} '.format(current_storage))
            await channel.send('Your final storage is: {}'.format(current_storage))

            for index,item in enumerate(planet_list):
                await channel.send(('{} planet whent from lvl'.format(index+1),orig_planet_lvl[index], 'to lvl',temp_planets[index].get_planet_lvl()))
        except (Exception, ValueError) as e:
            print(str(e))




client.run(TOKEN)

он ждет ввода пользователя, и если вы введете что-то неправильно, он просто сломается полностью, я попытался использовать try и кроме блоков, но он также не распознает его (я мог бы использоватьэто неправильно). Если у кого-то есть решение или что-то, что было бы замечательно!

Answer 1

Ваш код слишком запутан, чтобы понять, что вы хотите сделать.Я рекомендую сначала очистить код и переписать вопрос.Ниже приведены проблемы, с которыми сталкивается ваш код.

1

Используйте check вместо get_input_of_type().Возможно get_input_of_type() работает нормально, но уже существует функция для проверки ввода сообщений пользователя.Ваш код, кажется, использует это много раз, поэтому хорошо определить функцию для более короткого кода.

def is_number(msg):
    return msg.content.isdigit()

@client.event
async def on_message(message):
    if "hadescalc.planet()" == message.content.lower():
        await client.send_message("What is the first number?")
        firstnumber = await client.wait_for_message(
            author=message.author,
            channel=message.channel,
            check=is_number)
        firstnumber += 3
        await client.send_message("What is the second number?")
        secondnumber = await client.wait_for_message(
            author=message.author,
            channel=message.channel,
            check=is_number)
        await client.send_message("{} + {} = {}".format(
            firstnumber, secondnumber, firstnumber+secondnumber))

2

Не определять class в функции.Лучше определить Planet из on_message.И вместо set_*** и get_*** используйте @property и @setter.

class Planet:
    def __init__(self, level, ___):
        self._level = level
        # blah
        pass

    @property
    def level(self):
        return self._level

    @level.setter
    def level(self, new_level):
        self._level = new_level

3

Вы используете int и str слишком много раз, но это не хорошо.Например, все значения **_lvl равны int и нет необходимости приводить str.Удалите все ненужные типы приведения.Кроме того, я не могу понять, что делает decider, но это может работать не так, как вы хотите.decider - это list из str (в действительности все int), поэтому min(decider) находит буквенное минимальное значение, а не числовое минимальное значение.Если вы измените **_lvl на тип int, он вернет числовое минимальное значение, как ожидалось.