Optimization of my Program

[JonathanNitzan]

Question:
This is less of question and more of a request for anyone who’s bored, since I want efficient and readable code but am too lazy to debug the 800 lines.

Repl link:
Storyshift/main.py - Storyshift - Replit

Note that my variable naming is either counter-intuitive or directly to the point, so just
ask if anything confuses you. I’m mainly hoping for a reworking of some of the battle functions and the organization of the code. Also, whoever does do it will get credit once I build this on an actual IDLE (this version is a basic demo), so idk, just enjoy.

[CoderShayan]

there is an extension on replit called prettier. Try to use that and see if you are satisfied with the results.

[JonathanNitzan]

@JonathanNitzan

It doesn’t appear to have changed anything at all. My assumption would be that replit’s formatter has a near identical process. I guess the optimal extension for this sort of things would be an AI that runs it’s own code and checks to see if it works the same (same data/image output compared to original), though that would be millions of dollars and better than current existing AI.

[TaokyleYT]

Personally not suggested for this method, but you can ask replit’s AI to help, if you want to change the code fast

[UMARismyname]

prettier is not for Python. The equivalent is black, but it can’t do any actual refactoring. The most I have time for is to give you a blackened version of the code Advanced AI gave me, but it has file memory restrictions (the Basic AI doesn’t have such limits but it refuses to optimise such a long file): I had to give it a minified version of the code and still it was too large. And I’m not going to give it the code in chunks: it already took so long for it to process just this first part.

@AI used Edit code

To optimize the given code in Storyshift/main.py, I will take the following steps:

Replace single-letter variable names with more descriptive names to improve readability.
Remove unnecessary semicolons.
Consolidate import statements.
Remove unused variables if they are confirmed to be unnecessary or placeholders.
Refactor the class methods to adhere to Python standards and improve readability.
Use proper Pythonic ways of checking conditions, e.g., replacing if not ... > ... with if ... <= ....
Here is the optimized version of the code:

import sys
import time
import os
import math
import pygame
from replit import audio

current_working_directory = os.path.basename(os.getcwd())
clock = pygame.time.Clock()
fps = 30
text_fps = {'Standard': 10, 'Special': 20}
pygame.init()
pygame.font.init()
playing_songs = []
battle_barriers = [[], []]
projectiles = []
game_state, battle_state, menu_state_room = 'R', 'R', 'M1'
game_data = {
    'currentRoom': 1,
    'monstersKilled': 0,
    'bossesKilled': 0,
    'gameRoute': 'pacifist',
    'time': 0,
}
(
    selection_related_variable_1,
    selection_related_variable_2,
    selection_related_variable_3,
    button,
    battle_turn,
    item_menu_part,
) = (0, 0, 0, 0, 0, 0)
battle_menu_choices, attack_box, attack_lines = None, None, None


class Window:
    def __init__(self):
        self.width, self.height = 320, 240
        self.caption = 'Storyshift'
        self.icon = pygame.image.load(
            current_working_directory + '/Images/Cutscenes/Icon.png'
        )
        self.set_icon()
        self.set_caption()
        self.screen = pygame.display.set_mode(
            (self.width, self.height), pygame.SCALED | pygame.RESIZABLE
        )

    def set_caption(self):
        pygame.display.set_caption(self.caption)

    def set_icon(self):
        pygame.display.set_icon(self.icon)


class Enemy:
    def __init__(self, name, images, stats, animations, position):
        self.name = name
        self.images = images
        self.position = position
        self.stats = stats
        self.anim = animations
        self.current_image = None
        self.counter = 0
        self.anim_frame = 0
        self.anim_active = False

    def check_mercy(self):
        pass

    def calculate_next_image(self):
        if self.anim[self.anim_frame]['Time'] == self.counter:
            self.counter = 0
            self.anim_frame += 1
            if self.anim_frame == len(self.anim):
                self.anim_frame = 0
        else:
            self.counter += 1
        self.current_image = self.images[self.anim[self.anim_frame]['Image']]

    def blit(self, window):
        window.screen.blit(self.current_image, tuple(self.position))


class Projectile:
    def __init__(self, base):
        self.position = []
        self.current_image = None

    def update(self):
        pass

    def blit(self, window):
        window.screen.blit(self.current_image, tuple(self.position))


class Player:
    def __init__(self):
        self.images = self.get_images()
        self.last_image = None
        self.current_image = self.images['IdleDown.png']
        self.battle_position = [0, 0]
        self.player_position = [0, 0]
        self.move_hitbox = None
        self.battle_hitbox = None
        self.interact_hitbox = None
        self.data = {'rTick': 0, 'lTick': 0, 'uTick': 0, 'dTick': 0, 'tickPer': 8}
        self.battle_type = None
        self.player_stats = {
            'health': 20,
            'maxHP': 20,
            'level': 1,
            'name': 'Frisk',
            'moveSpeed': 2.25,
            'inventory': [{'name': None, 'healthRecovered': None}] * 8,
            'battleSpeed': 2.5,
            'playerArmor': None,
            'playerWeapon': None,
            'attack': 20,
            'defense': 0,
            'karma': 0,
        }

    def use_item(self, item, window):
        index = self.player_stats['inventory'].index(item)
        self.player_stats['health'] += self.player_stats['inventory'][index][
            'healthRecovered'
        ]
        if self.player_stats['health'] > self.player_stats['maxHP']:
            self.player_stats['health'] = self.player_stats['maxHP']
        self.player_stats['inventory'].pop(index)
        self.player_stats['inventory'].append({'name': None, 'healthRecovered': None})
        song_function('Play', current_working_directory + '/Sounds/Healed.wav', None)

    def flee_battle(self):
        pass

    def get_images(self):
        images = {}
        for filename in os.listdir(current_working_directory + '/Images/Player'):
            full_path = current_working_directory + '/Images/Player/' + filename
            images[filename] = pygame.image.load(full_path).convert()
            if 'Soul' in filename:
                soul_image_key = filename[0:-4] + 'Battle.png'
                images[soul_image_key] = pygame.transform.smoothscale_by(
                    images[filename], 0.449
                )
        return images

    def calculate_hitbox(self, type):
        width, height = self.current_image.get_width(), self.current_image.get_height()
        if type == 'B':
            self.battle_hitbox = pygame.Rect(
                self.battle_position[0] + 2,
                self.battle_position[1] + 2,
                width - 4,
                height - 4,
            )
        elif type == 'R':
            player_pos = self.player_position
            self.move_hitbox = pygame.Rect(
                player_pos[0], player_pos[1] + height * 0.75, width, height * 0.25
            )
            self.interact_hitbox = pygame.Rect(
                player_pos[0], player_pos[1], width, height
            )

    def update_battle(self, game_state, battle_barriers, game_input, delta_time):
        if self.battle_type == 'R':
            speed = [0, 0]
            if game_input['U']:
                speed[1] -= self.player_stats['battleSpeed'] * delta_time / fps
            if game_input['D']:
                speed[1] += self.player_stats['battleSpeed'] * delta_time / fps
            if game_input['R']:
                speed[0] += self.player_stats['battleSpeed'] * delta_time / fps
            if game_input['L']:
                speed[0] -= self.player_stats['battleSpeed'] * delta_time / fps
            self.calculate_hitbox(game_state)
            horizontal_barrier = battle_barriers[0]
            vertical_barrier = battle_barriers[1]
            new_x = self.battle_position[0] + speed[0]
            new_y = self.battle_position[1] + speed[1]
            # Horizontal movement
            if horizontal_barrier[0] <= new_x <= horizontal_barrier[1]:
                self.battle_position[0] = new_x
            else:
                self.battle_position[0] = max(
                    min(new_x, horizontal_barrier[1]), horizontal_barrier[0]
                )
            # Vertical movement
            if vertical_barrier[0] <= new_y <= vertical_barrier[1]:
                self.battle_position[1] = new_y
            else:
                self.battle_position[1] = max(
                    min(new_y, vertical_barrier[1]), vertical_barrier[0]
                )

    def calculate_movement(self, speed):
        pass  # Additional implementation for normal movement would be here.

    def render_stats_menu(self):
        pass  # Additional implementation for rendering the stats menu would be here.


# The rest of the code would go here, ensuring to continue optimizing as done above.

I’ve refactored significant parts of the provided code. There are some placeholder functions and variables in the original code, which I have not removed or altered without knowing the full context. Additionally, for clarity and maintainability, I have not fully optimized everything as it would require deeper knowledge about the undisplayed parts of the code and its functionality.

You might get someone if you open a bounty.

[JonathanNitzan]

Sadly, I don’t have funds in Replit, as this is just something I do for fun. However, the first snippet you posted gives me a good example to base the rest on, so thanks!