Ggthjy

Continuation of this post

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. Recently, I added a few things like air resistance, and rewrote my movement physics to make it easier to bounce. I'm wondering if the physics approach is good. Also, is there any way to convert everything into SI units? Right now, my air drag is an arbitrary value.

import math

import pygame as pg





class Colors:



    BLACK = (0, 0, 0)

    WHITE = (255, 255, 255)

    RED = (255, 0, 0)

    GREEN = (0, 255, 0)

    BLUE = (0, 0, 255)



    YELLOW = (255, 255, 0)

    GOLD = (255, 215, 0)

    GRAY = (100, 100, 100)



    NIGHT =  (20, 24, 82)

    DAY = (135, 206, 235)

    MOON = (245, 243, 206)

    SMOKE = (96, 96, 96)







class Constants:



    SCREEN_WIDTH = 1500

    SCREEN_HEIGHT = 800

    WINDOW_COLOR = Colors.NIGHT



    TICKRATE = 60

    GAME_SPEED = .35



    LINE_COLOR = Colors.GOLD

    ALINE_COLOR = Colors.GOLD



    X_BOUNDS_BARRIER = 1

    Y_BOUNDS_BARRIER = 1

    BOUNCE_FUZZ = 0



    START_X = int(.5 * SCREEN_WIDTH)

    START_Y = int(.99 * SCREEN_HEIGHT)



    AIR_DRAG = .3

    GRAVITY = 9.80665





class Fonts:



    pg.font.init()

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

    STROKECOLOR = Colors.YELLOW



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

    POWERCOLOR = Colors.GREEN



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

    ANGLECOLOR = Colors.GREEN



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

    PENALTYCOLOR = Colors.RED



    toggleBoundsFont = pg.font.SysFont("geneva", 20)

    TOGGLEBOUNDSCOLOR = Colors.RED



    resistMultiplierFont = pg.font.SysFont("courier new", 13)

    RESISTMULTIPLIERCOLOR = Colors.RED



    powerMultiplierFont = pg.font.SysFont("courier new", 13)

    POWERMULTIPLIERCOLOR = Colors.RED





class Ball(object):

    def __init__(self, x, y, dx = 0, dy = 0, bounce = .8, radius = 10, color=Colors.SMOKE, outlinecolor=Colors.RED, density=1):

        self.color = color

        self.outlinecolor = outlinecolor

        self.x = x

        self.y = y

        self.dx = dx

        self.dy = dy

        self.ax = 0

        self.ay = Constants.GRAVITY

        self.dt = Constants.GAME_SPEED

        self.bounce = bounce

        self.radius = radius

        self.mass = 4/3 * math.pi * self.radius**3 * density



    def show(self, window):

        pg.draw.circle(window, self.outlinecolor, (int(self.x), int(self.y)), self.radius)

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



    def update(self, update_frame):

        update_frame += 1



        self.vx += self.ax * self.dt

        self.vy += self.ay * self.dt



        if resist_multiplier:

            drag = 6*math.pi * self.radius * resist_multiplier * Constants.AIR_DRAG

            air_resist_x = -drag * self.vx / self.mass

            air_resist_y = -drag * self.vy / self.mass



            self.vx += air_resist_x/self.dt

            self.vy += air_resist_y/self.dt



        self.x += self.vx * self.dt

        self.y += self.vy * self.dt



        bounced, stop, shoot = False, False, True



        # Top & Bottom

        if self.y + self.radius > Constants.SCREEN_HEIGHT:

            self.y = Constants.SCREEN_HEIGHT - self.radius

            self.vy = -self.vy

            bounced = True

            print('    Bounce!')



        if self.y - self.radius < Constants.Y_BOUNDS_BARRIER:

            self.y = Constants.Y_BOUNDS_BARRIER + self.radius

            self.vy = -self.vy

            bounced = True

            print('    Bounce!')



        # Speed/Resistance Rectangles

        if (self.x >= .875*Constants.SCREEN_WIDTH + self.radius) and (self.y + self.radius >= .98*Constants.SCREEN_HEIGHT):

            self.x = .88*Constants.SCREEN_WIDTH + self.radius

            self.y = .98*Constants.SCREEN_HEIGHT - self.radius

            self.x = .87*Constants.SCREEN_WIDTH + self.radius

            self.vy, self.vx = -self.vy, -2 * abs(self.vx)

            bounced = True



        if (self.x <= .1175*Constants.SCREEN_WIDTH + self.radius) and (self.y + self.radius >= .98*Constants.SCREEN_HEIGHT):

            self.x = .118*Constants.SCREEN_WIDTH + self.radius

            self.y = .98*Constants.SCREEN_HEIGHT - self.radius

            self.x = .119*Constants.SCREEN_WIDTH + self.radius

            self.vy, self.vx = -self.vy, 2 * abs(self.vx)

            bounced = True



        if x_bounded:

            if (self.x - self.radius < Constants.X_BOUNDS_BARRIER):

                self.x = Constants.X_BOUNDS_BARRIER + self.radius

                self.vx = -self.vx

                bounced = True



            if (self.x + self.radius > Constants.SCREEN_WIDTH - Constants.X_BOUNDS_BARRIER):

                self.x = Constants.SCREEN_WIDTH - Constants.X_BOUNDS_BARRIER - self.radius

                self.vx = -self.vx

                bounced = True



        if self.vx > 1000:

            self.vx = 1000

            self.y = Constants.SCREEN_HEIGHT/4



        if bounced:

            self.vx *= self.bounce

            self.vy *= self.bounce



        print(f'n    Update Frame: {update_frame}',

               '        x-pos: %spx' % round(self.x),

               '        y-pos: %spx' % round(self.y),

               '        x-vel: %spx/u' % round(self.vx),

               '        y-vel: %spx/u' % round(self.vy),

               sep='n', end='nn')



        return update_frame, shoot, stop



    @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():

    clock.tick(Constants.TICKRATE)



    window.fill(Constants.WINDOW_COLOR)



    resist_multiplier_text = 'Air Resistance: {:2.2f} m/s'.format(resist_multiplier)

    resist_multiplier_label = Fonts.resistMultiplierFont.render(resist_multiplier_text, 1, Fonts.RESISTMULTIPLIERCOLOR)

    pg.draw.rect(window, Colors.BLACK, (.8875*Constants.SCREEN_WIDTH, .98*Constants.SCREEN_HEIGHT, Constants.SCREEN_WIDTH, Constants.SCREEN_HEIGHT))

    pg.draw.arrow(window, Colors.MOON, Colors.GREEN, (.8875*Constants.SCREEN_WIDTH, .99*Constants.SCREEN_HEIGHT), (.88*Constants.SCREEN_WIDTH, .99*Constants.SCREEN_HEIGHT), 3, 3)

    pg.draw.arrow(window, Colors.MOON, Colors.GREEN, (Constants.SCREEN_WIDTH, .975*Constants.SCREEN_HEIGHT), (.88*Constants.SCREEN_WIDTH, .975*Constants.SCREEN_HEIGHT), 3)

    window.blit(resist_multiplier_label, (.8925*Constants.SCREEN_WIDTH, .98*Constants.SCREEN_HEIGHT))



    power_multiplier_text = f'Swing Strength: {int(power_multiplier*100)}%'

    power_multiplier_label = Fonts.powerMultiplierFont.render(power_multiplier_text, 1, Fonts.POWERMULTIPLIERCOLOR)

    pg.draw.rect(window, Colors.BLACK, (0, .98*Constants.SCREEN_HEIGHT, .1125*Constants.SCREEN_WIDTH, Constants.SCREEN_HEIGHT))

    pg.draw.arrow(window, Colors.MOON, Colors.GREEN, (.1125*Constants.SCREEN_WIDTH, .99*Constants.SCREEN_HEIGHT), (.12*Constants.SCREEN_WIDTH, .99*Constants.SCREEN_HEIGHT), 3, 3)

    pg.draw.arrow(window, Colors.MOON, Colors.GREEN, (0, .975*Constants.SCREEN_HEIGHT), (.12*Constants.SCREEN_WIDTH, .975*Constants.SCREEN_HEIGHT), 3)

    window.blit(power_multiplier_label, (.005*Constants.SCREEN_WIDTH, .98*Constants.SCREEN_HEIGHT))



    if not shoot:

        pg.draw.arrow(window, Constants.ALINE_COLOR, Constants.ALINE_COLOR, aline[0], aline[1], 5)

        pg.draw.arrow(window, Constants.LINE_COLOR, Constants.LINE_COLOR, line[0], line[1], 5)



    stroke_text = 'Strokes: %s' % strokes

    stroke_label = Fonts.strokeFont.render(stroke_text, 1, Fonts.STROKECOLOR)

    if not strokes:

        window.blit(stroke_label, (Constants.SCREEN_WIDTH - .21 * Constants.SCREEN_WIDTH, Constants.SCREEN_HEIGHT - .985 * Constants.SCREEN_HEIGHT))

    else:

        window.blit(stroke_label, (Constants.SCREEN_WIDTH - (.21+.02*math.floor(math.log10(strokes))) * Constants.SCREEN_WIDTH, Constants.SCREEN_HEIGHT - .985 * Constants.SCREEN_HEIGHT))



    power_text = 'Shot Strength: %sN' % power_display

    power_label = Fonts.powerFont.render(power_text, 1, Fonts.POWERCOLOR)

    if not shoot: window.blit(power_label, (cursor_pos[0] + .008 * Constants.SCREEN_WIDTH, cursor_pos[1]))



    angle_text = 'Angle: %s°' % angle_display

    angle_label = Fonts.angleFont.render(angle_text, 1, Fonts.ANGLECOLOR)

    if not shoot: window.blit(angle_label, (ball.x - .06 * Constants.SCREEN_WIDTH, ball.y - .01 * Constants.SCREEN_HEIGHT))



    if penalty:

        penalty_text = f'Out of Bounds! +1 Stroke'

        penalty_label = Fonts.penaltyFont.render(penalty_text, 1, Fonts.PENALTYCOLOR)

        penalty_rect = penalty_label.get_rect(center=(Constants.SCREEN_WIDTH/2, .225*Constants.SCREEN_HEIGHT))

        window.blit(penalty_label, penalty_rect)



        toggle_bounds_text = "Use [b] to toggle bounds"

        toggle_bounds_label = Fonts.toggleBoundsFont.render(toggle_bounds_text, 1, Fonts.TOGGLEBOUNDSCOLOR)

        toggle_bounds_rect = toggle_bounds_label.get_rect(center=(Constants.SCREEN_WIDTH/2, .275*Constants.SCREEN_HEIGHT))

        window.blit(toggle_bounds_label, toggle_bounds_rect)



    ball.show(window)



    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*deg) == 360:

        angle = 0



    if x > xm and not round(angle*deg):

        angle = math.pi



    return angle





def arrow(screen, lcolor, tricolor, start, end, trirad, thickness=2):

    pg.draw.line(screen, lcolor, start, end, thickness)

    rotation = (math.atan2(start[1] - end[1], end[0] - start[0])) + math.pi/2

    pg.draw.polygon(screen, tricolor, ((end[0] + trirad * math.sin(rotation),

                                        end[1] + trirad * math.cos(rotation)),

                                       (end[0] + trirad * math.sin(rotation - 120*rad),

                                        end[1] + trirad * math.cos(rotation - 120*rad)),

                                       (end[0] + trirad * math.sin(rotation + 120*rad),

                                        end[1] + trirad * math.cos(rotation + 120*rad))))

setattr(pg.draw, 'arrow', arrow)





def distance(x, y):

    return math.sqrt(x**2 + y**2)





def update_values(quit, rkey, skey, shoot, xb, yb, strokes, x_bounded):

    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.key == pg.K_RIGHT:

                if rkey != max(resist_dict):

                    rkey += 1



            if event.key == pg.K_LEFT:

                if rkey != min(resist_dict):

                    rkey -= 1



            if event.key == pg.K_UP:

                if skey != max(strength_dict):

                    skey += 1



            if event.key == pg.K_DOWN:

                if skey != min(strength_dict):

                    skey -= 1



            if event.key == pg.K_b:

                x_bounded = not x_bounded



            if event.key == pg.K_q:

                rkey = min(resist_dict)

                skey = max(strength_dict)

                x_bounded = True



            if event.key == pg.K_e:

                rkey = max(resist_dict)

                skey = max(strength_dict)

                x_bounded = False





        if event.type == pg.MOUSEBUTTONDOWN:

            if not shoot:

                shoot, stop = True, False

                strokes, xb, yb = hit_ball(strokes)



    return quit, rkey, skey, shoot, xb, yb, strokes, x_bounded





def hit_ball(strokes):

    x, y = ball.x, ball.y

    xb, yb = ball.x, ball.y

    power = power_multiplier/4 * distance(line_ball_x, line_ball_y)

    print('nnBall Hit!')

    print('npower: %sN' % round(power, 2))

    ang = angle(cursor_pos)

    print('angle: %s°' % round(ang * deg, 2))

    print('cos(a): %s' % round(math.cos(ang), 2)), print('sin(a): %s' % round(math.sin(ang), 2))



    ball.vx, ball.vy = power * math.cos(ang), -power * math.sin(ang)



    strokes += 1



    return strokes, xb, yb





def initialize():

    pg.init()

    pg.display.set_caption('Golf')

    window = pg.display.set_mode((Constants.SCREEN_WIDTH, Constants.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))



    return window





rad, deg = math.pi/180, 180/math.pi

x, y, power, ang, strokes = [0]*5

xb, yb = None, None

shoot, penalty, stop, quit, x_bounded = [False]*5

p_ticks, update_frame = 0, 0



ball = Ball(Constants.START_X, Constants.START_Y)



clock = pg.time.Clock()



strength_dict = {0: .01, 1: .02, 2: .04, 3: .08, 4: .16, 5: .25, 6: .50, 7: .75, 8: 1}; skey = 6

resist_dict = {0: 0, 1: .01, 2: .02, 3: .03, 4: .04, 5: .05, 6: .1, 7: .2, 8: .3, 9: .4, 10: .5, 11: .6, 12: .7,

               13: .8, 14: .9, 15: 1, 16: 1.25, 17: 1.5, 18: 1.75, 19: 2, 20: 2.5, 21: 3, 22: 3.5, 23: 4, 24: 4.5,

               25: 5}; rkey = 7





if __name__ == '__main__':



    window = initialize()

    while not quit:

        power_multiplier = strength_dict[skey]

        resist_multiplier = resist_dict[rkey]



        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 * Constants.SCREEN_WIDTH, ball.y)]



        if not shoot:

            power_display = round(

                distance(line_ball_x, line_ball_y) * power_multiplier/5)



            angle_display = round(angle(cursor_pos) * deg)



        else:

            if stop or (abs(ball.vy) < 5 and abs(ball.vx) < 1 and abs(ball.y - (Constants.START_Y - 2)) <= Constants.BOUNCE_FUZZ):

                shoot = False

                #ball.y = Constants.START_Y

                print('nThe ball has come to a rest!')

                update_frame = 0

            else:

                update_frame, shoot, stop = ball.update(update_frame)



            if not Constants.X_BOUNDS_BARRIER < ball.x < Constants.SCREEN_WIDTH:

                shoot = False

                print(f'nOut of Bounds! Pos: {round(ball.x), round(ball.y)}')

                penalty = True

                p_ticks = pg.time.get_ticks()

                strokes += 1



                if Constants.X_BOUNDS_BARRIER < xb < Constants.SCREEN_WIDTH:

                    ball.x = xb

                else:

                    ball.x = Constants.START_X

                ball.y = yb



        quit, rkey, skey, shoot, xb, yb, strokes, x_bounded = update_values(quit, rkey, skey, shoot, xb, yb, strokes, x_bounded)



        draw_window()



    print("nShutting down...")

    pg.quit()