Game Python Postgres with Sprite Intelligence

# use Python's arcade framework
import arcade

# See past parts of this lesson for step-by-step directions for:
    # Set up screen with dimension variables.
    # Open the window. Set title and x/y dimensions.
    # Set the screen bkg color.

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

# Change the x/y coordinates for that Sprite.
arcade.PlayerSprite.set_position(player_x, player_y)

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

if player_y > y:
    y += 2
if player_x > x:
    x += 2
if player_y < y:
    y -= 2
if player_x < x:
    x -= 2

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 globals
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 columns for first row/
    #   screen using "select top 1"
    s = ""
    s += "SELECT TOP 1"
    s += " id"
    s += ", t_color"
    s += ", t_title"
    s += ", i_height"
    s += ", i_width"
    s += " FROM tbl_screens"
    s += " ORDER BY i_order ASCENDING"
    try:
        db_cursor.execute(s)
        id_screen = db_cursor.fetch("id")
        t_color_screen = db_cursor.fetch("t_color")
        t_title = db_cursor.fetch("t_title")
        i_height = db_cursor.fetch("i_height")
        i_width = db_cursor.fetch("i_width")
    except psycopg2.Error as e:
        t_msg = "SQL error: " + e + "/n SQL: " + s
        return render_template("error.html", t_msg = t_msg)
    db_cursor.close

def getObjectsFromDB():
    # Get objects data from tbl_screens_objects in Postgres
    s = ""
    s += "SELECT"
    s += " id"
    s += ", t_obj_name"
    s += ", t_obj_type"
    s += ", t_obj_img_URL"
    s += ", i_y"
    s += ", i_x"
    s += ", t_color_hit"
    s += ", t_properties"
    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_msg = "SQL error: " + e + "/n SQL: " + s
        return render_template("error.html", t_msg = t_msg)

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)

    # Give our window a background color.
    arcade.set_background_color(arcade.color.t_color_screen)

    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 spritelist to track objects like walls.
    # This type of object only stops player motion.
    self.ListSpriteObjects = arcade.SpriteList()

    # Initialize a spritelist to track monsters/enemies.
    # These objects cause damage to i_hit_points.
    self.ListSpriteEnemies = arcade.SpriteList()

    # Initialize a spritelist to track powerups.
    # These objects give points to the player when a collision occurs.
    self.ListSpritePowerUps = arcade.SpriteList()

    # Get data from the database into the 3 lists above.
    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_y = db_row.fetch("i_y")
        i_x = db_row.fetch("i_x")
        t_properties[i] = db_row.fetch("t_properties")
        t_color_hit[i] = db_row.fetch("t_color_hit")
        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 the current sprite in db_row
        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 counter
        i += 1

def enemyMovement():
    # Iterate through enemy sprites.
    # In this case, there are only 2 enemies but we designed this so
    # you can add as many as you want to add to the database.
    # THEN we give them a random direction out of eight
    #   possible directions.
    # FINALLY we add our new-for-this-part "intelligent" direction to
    #   the random one.
    for currentSprite in self.ListSpriteEnemies:
        x = currentSprite.position[0]
        y = currentSprite.position[1]

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

        # NEW "intelligent" movement.
        if player_y > y:
            y += 2
        if player_x > x:
            x += 2
        if player_y < y:
            y -= 2
        if player_x < x:
            x -= 2

        # Set the current monster's position.
        currentSprite.set_position(x, y)

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

    # Set new position based on the "player_x" and "player_y" variables.
    self.SpritePlayer.set_position(self.player_x, self.player_y)
    # Call function to move all monster Sprites.
    enemyMovement()
    self.ListSpriteObjects.update()
    self.ListSpriteEnemies.update()
    self.ListSpritePowerUps.update()

    # Did the user collide with 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]
            # Graphical changes (like explosion or something) and
            #   sound code to show crash will go 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 the user collide with 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 and sound code to show
            #   powerup hit will go here.
        i +=1

    # Did the user collide with 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
            # half player movement
            self.right = false
            self.left = false
            self.up = false
            self.down = false
            # Sound and graphics code to show object collision
            #   here in a future part of this lesson.
        # increment our "index", which will be used in a future part.
        i += 1

def on_key_press(self, symbol, modifiers):
    # When 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):
    # When 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)
    enemyMovement()
    arcade.run()