Game Python Postgres with Sprite Collisions

# use Python's arcade framework
import arcade

# See past articles for step-by-step lessons in the following:
    # Set up screen dimensions variables
    # Open/create the window. Set size and title
    # Set window bkg color

# Set up player's sprite
arcade.PlayerSprite = arcade.Sprite("game-graphics/icon-player.png")

# Change the coordinates of our player Sprite
arcade.PlayerSprite.set_position(player_x, player_y)

# Keep up the game window until the user taps close
arcade.run()

direction = random.randint(1, 8)
if direction == 1:
    y += 1
if direction == 2:
    x += 1
    y += 1
if direction == 3:
    x +=1
if direction == 4:
    x += 1
    y -= 1
if direction == 5:
    y -= 1
if direction == 6:
    y -= 1
    x -= 1
if direction == 7:
    x -= 1
if direction == 8:
    x -= 1

import arcade
import psycopg2
import random
from flask import Flask
from flask import render_template

# connect to database
t_host = "PostgreSQL database host address"
t_port = "5432"
t_dbname = "database name"
t_user = "database user name"
t_pw = "password"
db_conn = psycopg2.connect(host=t_host, port=t_port, dbname=t_dbname, user=t_user, password=t_pw)
db_cursor = db_conn.cursor()

# initialize global variables
id_screen = 0
t_title = ""
i_width = 0
i_height = 0
t_color = ""
i_enemy_hit = 0
i_hit_points = 100
i_points = 0
i_lives = 3

@app.route("/main")

def getScreenFromDB():
    # Get window ID, title, color, width, and height from Postgres
    #   for first screen (select top 1)
    s = ""
    s += "SELECT TOP 1"
    s += " id"
    s += ", t_title"
    s += ", t_color"
    s += ", i_width"
    s += ", i_height"
    s += " FROM tbl_screens"
    s += " ORDER BY i_order"
    try:
        db_cursor.execute(s)
        id_screen = db_cursor.fetch("id")
        t_title = db_cursor.fetch("t_title")
        i_width = db_cursor.fetch("i_width")
        i_height = db_cursor.fetch("i_height")
        t_color = db_cursor.fetch("t_color")
    except psycopg2.Error as e:
        t_message = "Database error: " + e + "/n SQL: " + s
        return render_template("error.html", t_message = t_message)
    db_cursor.close

def getObjectsFromDB():
    # Get data from tbl_screens_objects
    s = ""
    s += "SELECT"
    s += " id"
    s += ", t_obj_name"
    s += ", t_obj_type"
    s += ", t_obj_img_URL"
    s += ", i_x"
    s += ", i_y"
    s += ", t_color_hit"
    s += ", t_properties"
    s += ", t_hit_sound"
    s += ", t_hit_action"
    s += ", b_hit_possible"
    s += ", b_hit_destroys_it"
    s += ", b_hit_awards"
    s += ", n_hit_awards"
    s += ", n_hit_damage"
    s += " FROM tbl_screens_objects"
    s += " WHERE ("
    s += " id_screen = " + id_screen
    s += ")"
    s += " ORDER BY i_order"
    try:
        db_cursor.execute(s)
        return db_cursor
    except psycopg2.Error as e:
        t_message = "Database error: " + e + "/n SQL: " + s
        return render_template("error.html", t_message = t_message)

class gameWindow(arcade.Window):
    def__init__(self, i_width, i_height, t_title):
    super().__init__(width, height, title, resizable=false)
    self.set_location(100, 100)

    arcade.set_background_color(arcade.color.t_color)

    self.player_x = 100
    self.player_y = 200
    self.player_speed = 250

    self.right = false
    self.left = false
    self.up = false
    self.down = false

    # Initialize a sprite list to store objects like walls.
    # This object type does no damage; only stops player motion.
    self.ListSpriteObjects = arcade.SpriteList()

    # Initialize a sprite list to store enemies.
    # These objects cause damage to i_hit_points.
    self.ListSpriteEnemies = arcade.SpriteList()

    # Initialize a sprite list to store powerups.
    # These objects award points to the player when hit.
    self.ListSpritePowerUps = arcade.SpriteList()

    # Pull data from Postgres into the 3 lists above, as well as player data.
    i = 0
    for each db_row in db_cursor:
        id_screen = db_row.fetch("id")
        t_obj_name[i] = db_row.fetch("t_obj_name")
        t_obj_type[i] = db_row.fetch("t_obj_type")
        t_obj_img_URL = db_row.fetch("t_obj_img_URL")
        i_x = db_row.fetch("i_x")
        i_y = db_row.fetch("i_y")
        t_color_hit[i] = db_row.fetch("t_color_hit")
        t_properties[i] = db_row.fetch("t_properties")
        t_hit_sound[i] = db_row.fetch("t_hit_sound")
        t_hit_action[i] = db_row.fetch("t_hit_action")
        b_hit_possible[i] = db_row.fetch("b_hit_possible")
        b_hit_destroys_it[i] = db_row.fetch("b_hit_destroys_it")
        b_hit_awards[i] = db_row.fetch("b_hit_awards")
        n_hit_awards[i] = db_row.fetch("n_hit_awards")
        n_hit_damage[i] = db_row.fetch("n_hit_damage")
        # draw each sprite in db_row to screen
        #  ignoring if player because we already created player as sprite1 above.
        #  This assumes we didn't filter out "player" by changing our SQL WHERE clause.
        if t_object_type == "obstacle":
            self.SpriteObject = arcade.Sprite(t_object_image_URL, i_x, i_y)
            # add current obstacle to growing list of Sprites (SpriteList)
            self.ListSpriteObjects.append(self.SpriteObject)
        elif t_object_type == "enemy":
            self.SpriteObstacle = arcade.Sprite(t_object_image_URL, i_x, i_y)
            # add current enemy (sprite) to growing list of Sprites (SpriteList)
            self.SpriteEnemies.append(self.SpriteObject)
        elif t_object_type == "powerup":
            self.SpriteObstacle = arcade.Sprite(t_object_image_URL, i_x, i_y)
            # add current PowerUp to growing list of Sprites (SpriteList)
            self.SpritePowerUps.append(self.SpriteObject)
        elif t_object_type == "Player":
            self.SpritePlayer = arcade.Sprite(t_object_image_URL, i_x, i_y)
        # increment the loop counter
        i += 1

def enemyMovement():
    # Loop through all enemy sprites (in this case, 2)
    #   and give them a random direction out of the 8 possible directions
    for currentSprite in self.ListSpriteEnemies:
        x = currentSprite.position[0]
        y = currentSprite.position[1]
        direction = random.randint(1, 8)
        if direction == 1:
            y += 1
        if direction == 2:
            x += 1
            y += 1
        if direction == 3:
            x +=1
        if direction == 4:
            x += 1
            y -= 1
        if direction == 5:
            y -= 1
        if direction == 6:
            y -= 1
            x -= 1
        if direction == 7:
            x -= 1
        if direction == 8:
            x -= 1
            y += 1
        # set new position for each sprite
        currentSprite.set_position(x, y)
        # note: These Sprites probably won't move very far since
        #   they will be changing their direction constantly.add()
        #   In the next lesson we will address this by giving them
        #   more "intelligence".

def on_draw(self):
    self.SpritePlayer.draw()
    self.ListSpriteObjects.draw()
    self.ListSpriteEnemies.draw()
    self.ListSpritePowerUps.draw()

def on_update(self, delta_time):
    # delta_time is last time same function was run;
    #   used to scale movement to processing speed
    if self.right = true:
        self.player_x += self.player_speed * delta_time
    if self.left = true:
        self.player_x -= self.player_speed * delta_time
    if self.up = true:
        self.player_y += self.player_speed * delta_time
    if self.down = true:
        self.player_y -= self.player_speed * delta_time

    self.SpritePlayer.set_position(self.player_x, self.player_y)
    # call function to move all enemy Sprites
    enemyMovement()
    self.ListSpriteObjects.update()
    self.ListSpriteEnemies.update()
    self.ListSpritePowerUps.update()

    # Did player hit an enemy?
    i = 0
    for SpriteEnemy in self.ListSpriteEnemies:
        b_collision = arcade.check_for_collision(SpriteEnemy, self.SpritePlayer)
        if b_collision:
            i_enemy_hit = i
            i_hit_points -= n_hit_damage[i_enemy_hit]
            # graphics / sound code to show crash here
            if i_hit_points < 1:
                i_lives -= 1
                if i_lives < 1:
                    # Dead - Next lesson we will write code to handle this event
                    # For now, the player lives forever.
                i_hit_points = 100
        i +=1

    # Did player hit a power-up?
    i = 0
    for SpritePowerUp in self.ListSpritePowerUps:
        b_collision = arcade.check_for_collision(SpritePowerUp, self.SpritePlayer)
        if b_collision:
            i_pu_hit = i
            i_points += n_hit_awards[i_pu_hit]
            # graphics / sound code to show powerup collision here
        i +=1

    # Did player hit an obstacle?
    i = 0
    for SpritePowerUp in self.ListSpritePowerUps:
        b_collision = arcade.check_for_collision(SpritePowerUp, self.SpritePlayer)
        if b_collision:
            i_pu_hit = i
            # stop player movement
            self.right = false
            self.left = false
            self.up = false
            self.down = false
            # graphics / sound code to show object collision here - future lesson.
        i +=1

def on_key_press(self, symbol, modifiers):
    # every time a key is pressed, this function is called
    if symbol == arcade.key.right:
        self.right = true
    if symbol == arcade.key.left:
        self.left = true
    if symbol == arcade.key.up:
        self.up = true
    if symbol == arcade.key.down:
        self.down = true

def on_key_release(self, symbol, modifiers):
    # every time a key is released, this function is called
    if symbol == arcade.key.right:
        self.right = false
    if symbol == arcade.key.left:
        self.left = false
    if symbol == arcade.key.up:
        self.up = false
    if symbol == arcade.key.down:
        self.down = false

Def main():
    getScreenFromDB()
    db_cursor = getObjectsFromDB()
    gameWindow(i_width, i_height, t_title)
    arcade.run()