Created
March 1, 2025 05:47
-
-
Save Horizon733/1063d37bffe5eb31a748d53c77cb602f to your computer and use it in GitHub Desktop.
TCET python game full code
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| import pygame | |
| import random | |
| # Initialize pygame | |
| pygame.init() | |
| # Game Constants | |
| WIDTH, HEIGHT = 800, 1000 | |
| WHITE = (255, 255, 255) | |
| PLAYER_BASE_SPEED = 6 # Initial player speed | |
| ENEMY_BASE_SPEED_MIN = 4 # Initial min speed for enemies | |
| ENEMY_BASE_SPEED_MAX = 8 # Initial max speed for enemies | |
| SPAWN_INTERVAL = 60 # Frames between enemy spawns | |
| SPEED_INCREASE_RATE = 0.006 # Gradual speed increase rate | |
| # Load Images | |
| road_img = pygame.image.load("assets/road.jpg") | |
| player_car_img = pygame.image.load("assets/player_car.png") | |
| enemy_car_img = pygame.image.load("assets/enemy_car.png") | |
| # Flip the enemy car vertically | |
| enemy_car_img = pygame.transform.flip(enemy_car_img, False, True) | |
| # Resize Images | |
| player_car_img = pygame.transform.scale(player_car_img, (50, 100)) | |
| enemy_car_img = pygame.transform.scale(enemy_car_img, (50, 100)) | |
| road_img = pygame.transform.scale(road_img, (WIDTH, HEIGHT)) | |
| # Create Game Window | |
| screen = pygame.display.set_mode((WIDTH, HEIGHT)) | |
| pygame.display.set_caption("One-Lane Vertical Racing") | |
| # Car Class | |
| class Car: | |
| def __init__(self, x, y, image, speed): | |
| self.x = x | |
| self.y = y | |
| self.image = image | |
| self.width = 50 | |
| self.height = 100 | |
| self.speed = speed | |
| def draw(self, screen): | |
| screen.blit(self.image, (self.x, self.y)) | |
| # Player Car | |
| class PlayerCar(Car): | |
| def __init__(self, x, y): | |
| super().__init__(x, y, player_car_img, PLAYER_BASE_SPEED) | |
| def move_left(self): | |
| if self.x > WIDTH // 2 - 80: | |
| self.x -= self.speed | |
| def move_right(self): | |
| if self.x < WIDTH // 2 + 20: | |
| self.x += self.speed | |
| def move_up(self): | |
| if self.y > 50: | |
| self.y -= self.speed | |
| def move_down(self): | |
| if self.y < HEIGHT - self.height - 20: | |
| self.y += self.speed | |
| # Enemy Car (Coming From the Front) | |
| class EnemyCar(Car): | |
| def __init__(self, x, y, speed): | |
| super().__init__(x, y, enemy_car_img, speed) | |
| def move(self): | |
| self.y += self.speed | |
| if self.y > HEIGHT: | |
| self.reset() | |
| def reset(self): | |
| self.y = -self.height # Reset to top | |
| self.speed = random.randint(ENEMY_BASE_SPEED_MIN, ENEMY_BASE_SPEED_MAX) # New speed | |
| # Enemy Manager (Ensures No Overlapping) | |
| class EnemyManager: | |
| def __init__(self): | |
| self.enemies = [] | |
| self.last_spawn_time = 0 | |
| def spawn_enemy(self, frame_count, speed_factor): | |
| """Spawns an enemy in either the same lane or opposite lane, avoiding vertical overlaps""" | |
| if frame_count - self.last_spawn_time < SPAWN_INTERVAL: | |
| return | |
| possible_x_positions = [WIDTH // 2 - 70, WIDTH // 2 + 40] | |
| random.shuffle(possible_x_positions) | |
| for x in possible_x_positions: | |
| y_position = random.randint(-300, -100) | |
| if not self.is_overlapping(x, y_position): | |
| enemy_speed = random.randint( | |
| int(ENEMY_BASE_SPEED_MIN * speed_factor), | |
| int(ENEMY_BASE_SPEED_MAX * speed_factor) | |
| ) | |
| enemy = EnemyCar(x, y_position, enemy_speed) | |
| self.enemies.append(enemy) | |
| self.last_spawn_time = frame_count | |
| break | |
| def is_overlapping(self, new_x, new_y): | |
| """Ensures a new enemy is not too close to an existing one""" | |
| for enemy in self.enemies: | |
| if abs(enemy.x - new_x) < 120 and abs(enemy.y - new_y) < 150: | |
| return True | |
| return False | |
| def update(self): | |
| for enemy in self.enemies: | |
| enemy.move() | |
| self.enemies = [enemy for enemy in self.enemies if enemy.y < HEIGHT] | |
| def draw(self, screen): | |
| for enemy in self.enemies: | |
| enemy.draw(screen) | |
| # Game Loop | |
| def main(): | |
| clock = pygame.time.Clock() | |
| running = True | |
| # Background Scrolling | |
| road_y1 = 0 | |
| road_y2 = -HEIGHT | |
| road_speed = 5 | |
| # Create Player and Enemy Manager | |
| player = PlayerCar(WIDTH // 2 - 25, HEIGHT - 150) | |
| enemy_manager = EnemyManager() | |
| frame_count = 0 | |
| speed_factor = 1.0 | |
| while running: | |
| frame_count += 1 | |
| # Gradually increase speed factor | |
| speed_factor += SPEED_INCREASE_RATE | |
| if speed_factor > 2.5: | |
| speed_factor = 2.5 | |
| # Increase player speed over time | |
| player.speed = PLAYER_BASE_SPEED * speed_factor | |
| road_y1 += road_speed | |
| road_y2 += road_speed | |
| if road_y1 >= HEIGHT: | |
| road_y1 = -HEIGHT | |
| if road_y2 >= HEIGHT: | |
| road_y2 = -HEIGHT | |
| for event in pygame.event.get(): | |
| if event.type == pygame.QUIT: | |
| running = False | |
| keys = pygame.key.get_pressed() | |
| if keys[pygame.K_LEFT]: | |
| player.move_left() | |
| if keys[pygame.K_RIGHT]: | |
| player.move_right() | |
| if keys[pygame.K_UP]: | |
| player.move_up() | |
| if keys[pygame.K_DOWN]: | |
| player.move_down() | |
| # Enemy Spawning (Every SPAWN_INTERVAL frames) | |
| enemy_manager.spawn_enemy(frame_count, speed_factor) | |
| enemy_manager.update() | |
| screen.blit(road_img, (0, road_y1)) | |
| screen.blit(road_img, (0, road_y2)) | |
| player.draw(screen) | |
| enemy_manager.draw(screen) | |
| for enemy in enemy_manager.enemies: | |
| if ( | |
| player.x < enemy.x + enemy.width | |
| and player.x + player.width > enemy.x | |
| and player.y < enemy.y + enemy.height | |
| and player.y + player.height > enemy.y | |
| ): | |
| print("Game Over!") | |
| running = False | |
| pygame.display.update() | |
| clock.tick(30) | |
| pygame.quit() | |
| # Run the Game | |
| if __name__ == "__main__": | |
| main() |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment