Vwwxrf

I wrote a program in pygame that basically acts as a physics engine for a ball. You can hit the ball around and your strokes are counted, as well as an extra stroke for going out of bounds. If I do further develop this, I'd make the angle and power display toggleable, but I do like showing them right now:

import pygame as pg
import math

SCREEN_WIDTH = 1500
SCREEN_HEIGHT = 800
WINDOW_COLOR = (100, 100, 100)
BALL_COLOR = (255, 255, 255)
BALL_OUTLINE_COLOR = (255, 0, 0)
LINE_COLOR = (0, 0, 255)
ALINE_COLOR = (0, 0, 0)
START_X = int(.5 * SCREEN_WIDTH)
START_Y = int(.99 * SCREEN_HEIGHT)
POWER_MULTIPLIER = .85
SPEED_MULTIPLIER = 2
BALL_RADIUS = 10

pg.init()
pg.display.set_caption('Golf')
window = pg.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
pg.event.set_grab(True)
pg.mouse.set_cursor((8, 8), (0, 0), (0, 0, 0, 0, 0, 0, 0, 0), (0, 0, 0, 0, 0, 0, 0, 0))

strokeFont = pg.font.SysFont("monospace", 50)
STROKECOLOR = (255, 255, 0)

powerFont = pg.font.SysFont("arial", 15, bold=True)
POWERCOLOR = (0, 255, 0)

angleFont = pg.font.SysFont("arial", 15, bold=True)
ANGLECOLOR = (0, 255, 0)

penaltyFont = pg.font.SysFont("georgia", 40, bold=True)
PENALTYCOLOR = (255, 0, 0)


class Ball(object):
 def __init__(self, x, y, rad, c, oc):
 self.x = x
 self.y = y
 self.radius = rad
 self.color = c
 self.outlinecolor = oc

 def show(self, window):
 pg.draw.circle(window, self.outlinecolor, (self.x, self.y), self.radius)
 pg.draw.circle(window, self.color, (self.x, self.y), self.radius - int(.4 * self.radius))

 @staticmethod
 def path(x, y, p, a, t):
 vx, vy = p * math.cos(a), p * math.sin(a) #Velocities
 dx, dy = vx * t, vy * t - 4.9 * t ** 2 #Distances Traveled
 print(' x-pos: %spx' % str(round(dx + x)))
 print(' y-pos: %spx' % str(round(abs(dy - y))))

 return round(dx + x), round(y - dy)

 @staticmethod
 def quadrant(x,y,xm,ym):
 if ym < y and xm > x:
 return 1
 elif ym < y and xm < x:
 return 2
 elif ym > y and xm < x:
 return 3
 elif ym > y and xm > x:
 return 4
 else:
 return False


def draw_window():
 window.fill(WINDOW_COLOR)
 ball.show(window)
 if not shoot:
 arrow(window, ALINE_COLOR, ALINE_COLOR, aline[0], aline[1], 5)
 arrow(window, LINE_COLOR, LINE_COLOR, line[0], line[1], 5)

 stroke_text = 'Strokes: %s' % strokes
 stroke_label = strokeFont.render(stroke_text, 1, STROKECOLOR)
 if not strokes:
 window.blit(stroke_label, (SCREEN_WIDTH - .21 * SCREEN_WIDTH, SCREEN_HEIGHT - .985 * SCREEN_HEIGHT))
 else:
 window.blit(stroke_label, (SCREEN_WIDTH - (.21+.02*math.floor(math.log10(strokes))) * SCREEN_WIDTH, SCREEN_HEIGHT - .985 * SCREEN_HEIGHT))

 power_text = 'Shot Strength: %sN' % power_display
 power_label = powerFont.render(power_text, 1, POWERCOLOR)
 if not shoot: window.blit(power_label, (cursor_pos[0] + .008 * SCREEN_WIDTH, cursor_pos[1]))

 angle_text = 'Angle: %s°' % angle_display
 angle_label = angleFont.render(angle_text, 1, ANGLECOLOR)
 if not shoot: window.blit(angle_label, (ball.x - .06 * SCREEN_WIDTH, ball.y - .01 * SCREEN_HEIGHT))

 if Penalty:
 penalty_text = 'Out of Bounds! +1 Stroke'
 penalty_label = penaltyFont.render(penalty_text, 1, PENALTYCOLOR)
 penalty_rect = penalty_label.get_rect(center=(SCREEN_WIDTH/2, .225*SCREEN_HEIGHT))
 window.blit(penalty_label, penalty_rect)

 pg.display.flip()


def angle(cursor_pos):
 x, y, xm, ym = ball.x, ball.y, cursor_pos[0], cursor_pos[1]
 if x-xm:
 angle = math.atan((y - ym) / (x - xm))
 elif y > ym:
 angle = math.pi/2
 else:
 angle = 3*math.pi/2

 q = ball.quadrant(x,y,xm,ym)
 if q: angle = math.pi*math.floor(q/2) - angle

 if round(angle*180/math.pi) == 360:
 angle = 0

 if x > xm and round(angle*180/math.pi) == 0:
 angle = math.pi

 return angle


def arrow(screen, lcolor, tricolor, start, end, trirad):
 pg.draw.line(screen, lcolor, start, end, 2)
 rotation = math.degrees(math.atan2(start[1] - end[1], end[0] - start[0])) + 90
 pg.draw.polygon(screen, tricolor, ((end[0] + trirad * math.sin(math.radians(rotation)),
 end[1] + trirad * math.cos(math.radians(rotation))),
 (end[0] + trirad * math.sin(math.radians(rotation - 120)),
 end[1] + trirad * math.cos(math.radians(rotation - 120))),
 (end[0] + trirad * math.sin(math.radians(rotation + 120)),
 end[1] + trirad * math.cos(math.radians(rotation + 120)))))


def distance(x,y):
 return math.sqrt(x**2 + y**2)


x, y, time, power, ang, strokes = 0, 0, 0, 0, 0, 0
xb, yb = None, None
shoot, Penalty = False, False
p_ticks = 0

ball = Ball(START_X, START_Y, BALL_RADIUS, BALL_COLOR, BALL_OUTLINE_COLOR)
quit = False
BARRIER = 1

try:
 while not quit:
 seconds=(pg.time.get_ticks()-p_ticks)/1000
 if seconds > 1.2: Penalty = False

 cursor_pos = pg.mouse.get_pos()
 line = [(ball.x, ball.y), cursor_pos]
 line_ball_x, line_ball_y = cursor_pos[0] - ball.x, cursor_pos[1] - ball.y

 aline = [(ball.x, ball.y), (ball.x + .015 * SCREEN_WIDTH, ball.y)]

 if not shoot:
 power_display = round(
 distance(line_ball_x, line_ball_y) * POWER_MULTIPLIER / 10)

 angle_display = round(angle(cursor_pos) * 180 / math.pi)

 if shoot:
 if ball.y < SCREEN_HEIGHT:
 if BARRIER < ball.x < SCREEN_WIDTH:
 time += .3 * SPEED_MULTIPLIER
 print('n time: %ss' % round(time, 2))
 po = ball.path(x, y, power, ang, time)
 ball.x, ball.y = po[0], po[1]
 else:
 print('Out of Bounds!')
 Penalty = True
 p_ticks = pg.time.get_ticks()
 strokes += 1
 shoot = False
 if BARRIER < xb < SCREEN_WIDTH:
 ball.x = xb
 else:
 ball.x = START_X
 ball.y = yb
 else:
 shoot = False
 ball.y = START_Y

 for event in pg.event.get():
 if event.type == pg.QUIT:
 quit = True
 if event.type == pg.KEYDOWN:
 if event.key == pg.K_ESCAPE:
 quit = True
 if event.type == pg.MOUSEBUTTONDOWN:
 if not shoot:
 shoot = True
 x, y = ball.x, ball.y
 xb, yb = ball.x, ball.y
 time, power = 0, (
 distance(line_ball_x, line_ball_y)) * POWER_MULTIPLIER / 10
 print('nnBall Hit!')
 print('npower: %sN' % round(power, 2))
 ang = angle(cursor_pos)
 print('angle: %s°' % round(ang * 180 / math.pi, 2))
 print('cos(a): %s' % round(math.cos(ang), 2)), print('sin(a): %s' % round(math.sin(ang), 2))
 strokes += 1

 draw_window()

 print("nShutting down...")
 pg.quit()

except Exception as error:
 print(f'A fatal error (error) has occurred. The program is shutting down.')
 pg.quit()

Critique away!