PyMario/mario.py at main · clonetron/PyMario · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
import pygame as pg
from vector import Vector
from pygame.sprite import Sprite
from timer import Timer
from sound import Sound
from coords import Coords


class Mario(Sprite):
    mario_sheet = "images/mario1.png"


    def __init__(self, game):
        super().__init__()
        self.colliding = False
        self.game = game
        self.screen = game.screen
        self.settings = game.settings

        self.mario_running_forward = [pg.transform.rotozoom(self.game.spritesheet.image_at(Coords.coords["L_M_F2"]), 0, 3),
                                 pg.transform.rotozoom(self.game.spritesheet.image_at(Coords.coords["L_M_F3"]), 0, 3),
                                 pg.transform.rotozoom(self.game.spritesheet.image_at(Coords.coords["L_M_F4"]), 0, 3),
                                pg.transform.rotozoom(self.game.spritesheet.image_at(Coords.coords["L_M_F3"]), 0, 3)]
        self.mario_running_backward = [
            pg.transform.flip(pg.transform.rotozoom(self.game.spritesheet.image_at(Coords.coords["L_M_F2"]), 0, 3), True, False),
            pg.transform.flip(pg.transform.rotozoom(self.game.spritesheet.image_at(Coords.coords["L_M_F3"]), 0, 3), True, False),
            pg.transform.flip(pg.transform.rotozoom(self.game.spritesheet.image_at(Coords.coords["L_M_F4"]), 0, 3), True, False),
            pg.transform.flip(pg.transform.rotozoom(self.game.spritesheet.image_at(Coords.coords["L_M_F3"]), 0, 3), True, False)]

        self.image = pg.image.load(self.mario_sheet).convert_alpha()

        self.rect = self.image.get_rect()
        self.rect.w *= 3
        self.rect.h *= 3
        self.screen_rect = self.screen.get_rect()
        self.center_bottom()
        self.v = Vector()
        self.movingForward = False
        self.movingBackward = False
        self.wasForward = False
        self.wasBackward = False
        self.isJumping = False
        self.sound = Sound()
        self.y_gravity = 2
        self.jump_height = 30
        self.vel_y = self.jump_height
        self.onGround = False

        self.forward_timer = Timer(image_list=self.mario_running_forward, delay=100, start_index=0, is_loop=True)

        self.backward_timer = Timer(image_list=self.mario_running_backward, delay=100, start_index=0, is_loop=True)

    def center_bottom(self):
        self.rect.centerx = self.screen_rect.centerx - 400
        # self.rect.bottom = self.screen_rect.bottom
        self.rect.centery = self.screen_rect.centery + 195

        self.center = Vector(self.rect.centerx, self.rect.centery)

    def inc_add(self, other):
        self.v += other


    def clamp(self):
        rw, rh = self.rect.width, self.rect.height
        srw, srb = self.screen_rect.width, self.screen_rect.bottom
        x, y = self.center.x, self.center.y

        self.center.x = min(max(x, rw / 2), srw - rw / 2)
        self.center.y = min(max(y, rh / 2), srb - rh / 2)

    def update(self):
        self.enemies = self.game.enemies
        self.entities = self.game.entities

        if self.isJumping:
            self.center.y -= self.vel_y
            self.vel_y -= self.y_gravity
            if self.vel_y < -self.jump_height:
                self.isJumping = False
                self.vel_y = self.jump_height


        self.center += self.v * self.settings.mario_speed_factor
        self.clamp()
        self.rect.centerx, self.rect.centery = self.center.x, self.center.y
        # print(f'x: {self.rect.centerx}      y: {self.rect.centery}')

    def draw(self):

        running_forward = self.forward_timer.image()
        running_backward = self.backward_timer.image()
        stand_forward = pg.transform.rotozoom(self.game.spritesheet.image_at(Coords.coords["L_M_FSTAND"]), 0, 3)
        stand_backward = pg.transform.flip(pg.transform.rotozoom(self.game.spritesheet.image_at(Coords.coords["L_M_BSTAND"]), 0, 3), False, False)
        jump_forward = pg.transform.rotozoom(self.game.spritesheet.image_at(Coords.coords["L_M_FJUMP"]), 0, 3)
        jump_backward = pg.transform.rotozoom(self.game.spritesheet.image_at(Coords.coords["L_M_BJUMP"]), 0, 3)

        # print("moving Forward")
        # print(self.wasForward)
        # print(self.wasBackward)
        # print(running_backward)

        if self.isJumping:
            if self.wasBackward:
                self.screen.blit(jump_backward, self.rect)
            else:
                self.screen.blit(jump_forward, self.rect)
        elif self.movingForward:
            self.screen.blit(running_forward, self.rect)
        elif self.movingBackward:
            self.screen.blit(running_backward, self.rect)
        elif self.wasBackward:
            self.screen.blit(stand_backward, self.rect)
        else:
            self.screen.blit(stand_forward, self.rect)

        # pg.draw.rect(self.screen, (255, 255, 255), self.rect)