CoinTex: Cross-platform Multi-Level Game created in Python using Kivy

Overview

CoinTex: Cross-platform Multi-Level Game created in Python using Kivy

CoinTex is a multi-level adventure game created using the Kivy cross-platform Python framework. The game is successfully tested in Linux, Windows, and Android and working on all of these platforms without even changing a single line of code. Here is a simple description of it.

Game Description

The game is multi-level. Once it is opened, the main screen appears that shows a matrix of all game levels, which are 24 up to this time. The main screen is given in the next figure.

1

There will be only 1 level activated which is level 1. Once level x is completed, the level x+1 will be activated until reaching the last level. Information about the latest level completed is stored in a file named "game_info". This file is created once level 1 is completed. If this file is removed, the game will return back to the initial state in which only level 1 is activated. By pressing a level, the user is directed to another screen where the player can start playing the game. The screen of level 1 is given below.

1

Supposing that level 1 is completed successfully, level 2 will be activated on the main screen as given below.

1

The game has a character that moves freely according to the touch position on the screen. The player has a time-unlimited mission which is collecting a number of coins that are randomly distributed on the screen. A coin is collected when there is a collision with it and the character. As shown in the previous figure, a text at the top-left of the screen shows the number of collected coins and the total number of coins at the current level.

The first level has just 5 coins. The next figure shows how it looks like after 2 coins are collected. Once all coins are collected, the level completes and the user is directed to the main screen where the next level is active for being played.

1

Collecting the coins is not that easy because there are monsters and thrown fire that struggles the player's way of completing the level. Their motion is not expected and thus it tests the player's ability to do fast reactions in order to avoid their collision.

Some levels might have only monsters, others may only have fire, and others may have a combination. When the player collides a monster or a fire, its health reduces by a percentage that is proportional to the collision time. There is a red bar at the top of the screen that reflects the current health of the player. he next figure shows the red bar after a collision occurs.

1

The much time the player collides with a monster or a fire the much reduction in its health. When the health is zero, the player dies as given below.

1

Note that the game includes some sound effects. There is also background music running while the main screen is open or any level is being played.

Running the Project for Developers

Before running the game, you have to make sure Kivy is installing and running successfully. To get started with Kivy, check the resources given below:

Tutorial: Python for Android: Start Building Kivy Cross-Platform Applications

This tutorial titled Python for Android: Start Building Kivy Cross-Platform Applications covers the steps for creating an Android app out of the Kivy app.

Kivy-Tutorial

Book: Building Android Apps in Python Using Kivy with Android Studio

To get started with Kivy app development and how to built Android apps out of the Kivy app, check the book titled Building Android Apps in Python Using Kivy with Android Studio. This book documents the CoinTex game from A to Z in chapters 5 and 6.

kivy-book

After making sure Kivy is running, just use the next terminal command to run the main file of the game main.py. The game is developed in Python 3 and so the terminal command python3 is used for Linux/Mac.

[email protected]:~/Desktop/CoinTex$ python3 main.py

For Android, the APK file is built using Buildozer and this is why the buildozer.spec file exists in the project. Just use this terminal command for exporting the APK file.

After it runs successfully, the APK file will be exported. For more information about installing Buildozer, generating, and locating the APK file, you can read the tutorial and chapter 8 of the book mentioned above.

ahmed-ga[email protected]:~/Desktop/CoinTex$ buildozer android release deploy run

Running the Game for End Users

The game is already distributed for end-user to download and run easily for Android and Linux. For Linux, it is available at this link.

For Android, it is available at Google Play.

Game Documentation

The CoinTex game is 100% documented in chapters 5 and 6 of the book titled Building Android Apps in Python Using Kivy with Android Studio. It starts from a hello world app until building CoinTex.

kivy-book

For Contacting the Author

You might also like...
Ice-Walker-Game - This repository is about the Ice Walker game made in Python.

Ice-Walker-Game Ce dépot contient le jeu Ice Walker programmé en Python. Les différentes grilles du jeu sont contenues dans le sous-dossier datas. Vou

Game-of-life - A simple python program to simulate and visualise the Conway's Game of life
Game-of-life - A simple python program to simulate and visualise the Conway's Game of life

Conway's game of life A simple python program to simulate and visualise the Conw

Snake game mixed with Conway's Game of Life
Snake game mixed with Conway's Game of Life

SnakeOfLife Snake game mixed with Conway's Game of Life The rules are the same than a normal snake game but you have to avoid cells created by Conway'

Lint game data metafiles against GTA5.xsd for Rockstar's game engine (RAGE)
Lint game data metafiles against GTA5.xsd for Rockstar's game engine (RAGE)

rage-lint Lint RAGE (only GTA5 at the moment) meta/XML files for validity based off of the GTA5.xsd generated from game code. This script accepts a se

HTTP API for FGO game data. Transform the raw game data into something a bit more manageable.

FGO game data API HTTP API for FGO game data. Transform the raw game data into something a bit more manageable. View the API documentation here: https

A near-exact clone of google chrome's no internet game, or the "google dinosaur game", with some additions and extras.

dinoGame A near-exact clone of google chrome's no internet game, or the "google dinosaur game", with some additions and extras. Installation Download

Quantum version of the classical Nim game. An automatic opponent allows to game to not be as easy as it seems.

Nim game Running the game To run the program just launch : python3 game.py Rules This game is inspiring from the Nim game. You are 2 players face to f

Deal Or No Deal was a very popular game show. Even now, for a family party, it's a fun game to pass time

Deal Or No Deal was a very popular game show. Even now, for a family party, it's a fun game to pass time. I made a code to play the game right in your terminal/console. This isn't made to be a game which can be installed by everyone and played, I just made it as a fun project as I just started out with python. So if you have python installed and wanna have some fun, or just curious to see how I did this, feel free to check the code out!

Mastermind-Game - A game to test programming and logical skills

Bem vindo ao jogo Mastermind! O jogo consiste em adivinhar uma senha que será ge

Comments
  • Main.py Suggestions

    Main.py Suggestions

    I am not trying to be a jerk, just some pointers.

    Here is the complete main.py file with my suggested code: `import kivy.app import kivy.uix.screenmanager import kivy.uix.image import random import kivy.core.audio import os import functools import kivy.uix.behaviors import pickle

    class TestApp(kivy.app.App): # Class Property music_dir = os.getcwd() + "/music/"

    def __init__(self):
        self.char_death_sound = kivy.core.audio.SoundLoader.load(self.music_dir + "char_death_flaute.wav")
        self.level_completed_sound = kivy.core.audio.SoundLoader.load(self.music_dir + "level_completed_flaute.wav")
        self.coin_sound = kivy.core.audio.SoundLoader.load(self.music_dir + "coin.wav")
        self.bg_music = kivy.core.audio.SoundLoader.load(self.music_dir + "bg_music_piano.wav")
        self.main_bg_music = kivy.core.audio.SoundLoader.load(self.music_dir + "bg_music_piano_flute.wav")
    
    def on_start(self):
        self.main_bg_music.loop = True
        self.main_bg_music.play()
    
        next_level_num, congrats_displayed_once = self.read_game_info()
        self.activate_levels(next_level_num, congrats_displayed_once)
    
    def read_game_info(self):
        try:
            game_info_file = open("game_info", 'rb')
            game_info = pickle.load(game_info_file)
            return game_info[0]['lastlvl'], game_info[0]['congrats_displayed_once']
            game_info_file.close()
        except:
            print("CoinTex FileNotFoundError: Game info file is not found. Game starts from level 1.")
            return 1, False
    
    def activate_levels(self, next_level_num, congrats_displayed_once):
        num_levels = len(self.root.screens[0].ids['lvls_imagebuttons'].children)
    
        levels_imagebuttons = self.root.screens[0].ids['lvls_imagebuttons'].children
        for i in range(num_levels - next_level_num, num_levels):
            levels_imagebuttons[i].disabled = False
            levels_imagebuttons[i].color = [1, 1, 1, 1]
    
        for i in range(0, num_levels - next_level_num):
            levels_imagebuttons[i].disabled = True
            levels_imagebuttons[i].color = [1, 1, 1, 0.5]
    
        if next_level_num == (num_levels + 1) and congrats_displayed_once == False:
            self.root.current = "alllevelscompleted"
    
    def screen_on_pre_leave(self, screen_num):
        curr_screen = self.root.screens[screen_num]
        for i in range(curr_screen.num_monsters): curr_screen.ids[
            'monster' + str(i + 1) + '_image_lvl' + str(screen_num)].pos_hint = {'x': 0.8, 'y': 0.8}
        curr_screen.ids['character_image_lvl' + str(screen_num)].pos_hint = {'x': 0.0, 'y': 0.0}
    
        next_level_num, congrats_displayed_once = self.read_game_info()
        self.activate_levels(next_level_num, congrats_displayed_once)
    
    def screen_on_pre_enter(self, screen_num):
        curr_screen = self.root.screens[screen_num]
        curr_screen.character_killed = False
        curr_screen.num_coins_collected = 0
        curr_screen.ids['character_image_lvl' + str(screen_num)].im_num = curr_screen.ids[
            'character_image_lvl' + str(screen_num)].start_im_num
        for i in range(curr_screen.num_monsters): curr_screen.ids[
            'monster' + str(i + 1) + '_image_lvl' + str(screen_num)].im_num = curr_screen.ids[
            'monster' + str(i + 1) + '_image_lvl' + str(screen_num)].start_im_num
        curr_screen.ids['num_coins_collected_lvl' + str(screen_num)].text = "Coins 0/" + str(curr_screen.num_coins)
        curr_screen.ids['level_number_lvl' + str(screen_num)].text = "Level " + str(screen_num)
    
        curr_screen.num_collisions_hit = 0
        remaining_life_percent_lvl_widget = curr_screen.ids['remaining_life_percent_lvl' + str(screen_num)]
        remaining_life_percent_lvl_widget.size_hint = (
        remaining_life_percent_lvl_widget.remaining_life_size_hint_x, remaining_life_percent_lvl_widget.size_hint[1])
    
        for i in range(curr_screen.num_fires): curr_screen.ids[
            'fire' + str(i + 1) + '_lvl' + str(screen_num)].pos_hint = {'x': 1.1, 'y': 1.1}
    
        for key, coin in curr_screen.coins_ids.items():
            curr_screen.ids['layout_lvl' + str(screen_num)].remove_widget(coin)
        curr_screen.coins_ids = {}
    
        coin_width = 0.05
        coin_height = 0.05
    
        curr_screen = self.root.screens[screen_num]
    
        section_width = 1.0 / curr_screen.num_coins
        for k in range(curr_screen.num_coins):
            x = random.uniform(section_width * k, section_width * (k + 1) - coin_width)
            y = random.uniform(0, 1 - coin_height)
            coin = kivy.uix.image.Image(source="coin.png", size_hint=(coin_width, coin_height),
                                        pos_hint={'x': x, 'y': y}, allow_stretch=True)
            curr_screen.ids['layout_lvl' + str(screen_num)].add_widget(coin, index=-1)
            curr_screen.coins_ids['coin' + str(k)] = coin
    
    def screen_on_enter(self, screen_num):
        self.bg_music.loop = True
    
        self.bg_music.play()
    
        curr_screen = self.root.screens[screen_num]
        for i in range(curr_screen.num_monsters):
            monster_image = curr_screen.ids['monster' + str(i + 1) + '_image_lvl' + str(screen_num)]
            new_pos = (random.uniform(0.0, 1 - monster_image.size_hint[0] / 4),
                       random.uniform(0.0, 1 - monster_image.size_hint[1] / 4))
            self.start_monst_animation(monster_image=monster_image, new_pos=new_pos,
                                       anim_duration=random.uniform(monster_image.monst_anim_duration_low,
                                                                    monster_image.monst_anim_duration_high))
    
        for i in range(curr_screen.num_fires):
            fire_widget = curr_screen.ids['fire' + str(i + 1) + '_lvl' + str(screen_num)]
            self.start_fire_animation(fire_widget=fire_widget, pos=(0.0, 0.5), anim_duration=5.0)
    
    def start_monst_animation(self, monster_image, new_pos, anim_duration):
        monst_anim = kivy.animation.Animation(pos_hint={'x': new_pos[0], 'y': new_pos[1]},
                                              im_num=monster_image.end_im_num, duration=anim_duration)
        monst_anim.bind(on_complete=self.monst_animation_completed)
        monst_anim.start(monster_image)
    
    def monst_animation_completed(self, *args):
        monster_image = args[1]
        monster_image.im_num = monster_image.start_im_num
    
        new_pos = (random.uniform(0.0, 1 - monster_image.size_hint[0] / 4),
                   random.uniform(0.0, 1 - monster_image.size_hint[1] / 4))
        self.start_monst_animation(monster_image=monster_image, new_pos=new_pos,
                                   anim_duration=random.uniform(monster_image.monst_anim_duration_low,
                                                                monster_image.monst_anim_duration_high))
    
    def monst_pos_hint(self, monster_image):
        screen_num = int(monster_image.parent.parent.name[5:])
        curr_screen = self.root.screens[screen_num]
        character_image = curr_screen.ids['character_image_lvl' + str(screen_num)]
    
        character_center = character_image.center
        monster_center = monster_image.center
    
        gab_x = character_image.width / 2
        gab_y = character_image.height / 2
        if character_image.collide_widget(monster_image) and abs(
                character_center[0] - monster_center[0]) <= gab_x and abs(
                character_center[1] - monster_center[1]) <= gab_y:
            curr_screen.num_collisions_hit = curr_screen.num_collisions_hit + 1
            life_percent = float(curr_screen.num_collisions_hit) / float(curr_screen.num_collisions_level)
    
            #            life_remaining_percent = 100-round(life_percent, 2)*100
            #            remaining_life_percent_lvl_widget.text = str(int(life_remaining_percent))+"%"
            remaining_life_percent_lvl_widget = curr_screen.ids['remaining_life_percent_lvl' + str(screen_num)]
            remaining_life_size_hint_x = remaining_life_percent_lvl_widget.remaining_life_size_hint_x
            remaining_life_percent_lvl_widget.size_hint = (
            remaining_life_size_hint_x - remaining_life_size_hint_x * life_percent,
            remaining_life_percent_lvl_widget.size_hint[1])
    
            if curr_screen.num_collisions_hit == curr_screen.num_collisions_level:
                self.bg_music.stop()
                self.char_death_sound.play()
                curr_screen.character_killed = True
    
                kivy.animation.Animation.cancel_all(character_image)
                for i in range(curr_screen.num_monsters): kivy.animation.Animation.cancel_all(
                    curr_screen.ids['monster' + str(i + 1) + '_image_lvl' + str(screen_num)])
                for i in range(curr_screen.num_fires): kivy.animation.Animation.cancel_all(
                    curr_screen.ids['fire' + str(i + 1) + '_lvl' + str(screen_num)])
    
                character_image.im_num = character_image.dead_start_im_num
                char_anim = kivy.animation.Animation(im_num=character_image.dead_end_im_num, duration=1.0)
                char_anim.start(character_image)
                kivy.clock.Clock.schedule_once(functools.partial(self.back_to_main_screen, curr_screen.parent), 3)
    
    def change_monst_im(self, monster_image):
        monster_image.source = str(int(monster_image.im_num)) + ".png"
    
    def touch_down_handler(self, screen_num, args):
        curr_screen = self.root.screens[screen_num]
        if curr_screen.character_killed == False:
            self.start_char_animation(screen_num, args[1].spos)
    
    def start_char_animation(self, screen_num, touch_pos):
        curr_screen = self.root.screens[screen_num]
        character_image = curr_screen.ids['character_image_lvl' + str(screen_num)]
        character_image.im_num = character_image.start_im_num
        char_anim = kivy.animation.Animation(pos_hint={'x': touch_pos[0] - character_image.size_hint[0] / 2,
                                                       'y': touch_pos[1] - character_image.size_hint[1] / 2},
                                             im_num=character_image.end_im_num, duration=curr_screen.char_anim_duration)
        char_anim.bind(on_complete=self.char_animation_completed)
        char_anim.start(character_image)
    
    def char_animation_completed(self, *args):
        character_image = args[1]
        character_image.im_num = character_image.start_im_num
    
    def char_pos_hint(self, character_image):
        screen_num = int(character_image.parent.parent.name[5:])
        character_center = character_image.center
    
        gab_x = character_image.width / 3
        gab_y = character_image.height / 3
        coins_to_delete = []
        curr_screen = self.root.screens[screen_num]
    
        for coin_key, curr_coin in curr_screen.coins_ids.items():
            curr_coin_center = curr_coin.center
            if character_image.collide_widget(curr_coin) and abs(
                    character_center[0] - curr_coin_center[0]) <= gab_x and abs(
                    character_center[1] - curr_coin_center[1]) <= gab_y:
                self.coin_sound.play()
                coins_to_delete.append(coin_key)
                curr_screen.ids['layout_lvl' + str(screen_num)].remove_widget(curr_coin)
                curr_screen.num_coins_collected = curr_screen.num_coins_collected + 1
                curr_screen.ids['num_coins_collected_lvl' + str(screen_num)].text = "Coins " + str(
                    curr_screen.num_coins_collected) + "/" + str(curr_screen.num_coins)
                if curr_screen.num_coins_collected == curr_screen.num_coins:
                    self.bg_music.stop()
                    self.level_completed_sound.play()
                    kivy.clock.Clock.schedule_once(functools.partial(self.back_to_main_screen, curr_screen.parent), 3)
                    for i in range(curr_screen.num_monsters): kivy.animation.Animation.cancel_all(
                        curr_screen.ids['monster' + str(i + 1) + '_image_lvl' + str(screen_num)])
                    for i in range(curr_screen.num_fires): kivy.animation.Animation.cancel_all(
                        curr_screen.ids['fire' + str(i + 1) + '_lvl' + str(screen_num)])
    
                    next_level_num, congrats_displayed_once = self.read_game_info()
                    if (screen_num + 1) > next_level_num:
                        game_info_file = open("game_info", 'wb')
                        pickle.dump([{'lastlvl': screen_num + 1, "congrats_displayed_once": False}], game_info_file)
                        game_info_file.close()
                    else:
                        game_info_file = open("game_info", 'wb')
                        pickle.dump([{'lastlvl': next_level_num, "congrats_displayed_once": True}], game_info_file)
                        game_info_file.close()
    
        if len(coins_to_delete) > 0:
            for coin_key in coins_to_delete:
                del curr_screen.coins_ids[coin_key]
    
    def change_char_im(self, character_image):
        character_image.source = str(int(character_image.im_num)) + ".png"
    
    def start_fire_animation(self, fire_widget, pos, anim_duration):
        fire_anim = kivy.animation.Animation(pos_hint=fire_widget.fire_start_pos_hint,
                                             duration=fire_widget.fire_anim_duration) + kivy.animation.Animation(
            pos_hint=fire_widget.fire_end_pos_hint, duration=fire_widget.fire_anim_duration)
        fire_anim.repeat = True
        fire_anim.start(fire_widget)
    
    def fire_pos_hint(self, fire_widget):
        screen_num = int(fire_widget.parent.parent.name[5:])
        curr_screen = self.root.screens[screen_num]
        character_image = curr_screen.ids['character_image_lvl' + str(screen_num)]
    
        character_center = character_image.center
        fire_center = fire_widget.center
    
        gab_x = character_image.width / 3
        gab_y = character_image.height / 3
        if character_image.collide_widget(fire_widget) and abs(character_center[0] - fire_center[0]) <= gab_x and abs(
                character_center[1] - fire_center[1]) <= gab_y:
            curr_screen.num_collisions_hit = curr_screen.num_collisions_hit + 1
            life_percent = float(curr_screen.num_collisions_hit) / float(curr_screen.num_collisions_level)
    
            remaining_life_percent_lvl_widget = curr_screen.ids['remaining_life_percent_lvl' + str(screen_num)]
            #            life_remaining_percent = 100-round(life_percent, 2)*100
            #            remaining_life_percent_lvl_widget.text = str(int(life_remaining_percent))+"%"
    
            remaining_life_size_hint_x = remaining_life_percent_lvl_widget.remaining_life_size_hint_x
            remaining_life_percent_lvl_widget.size_hint = (
            remaining_life_size_hint_x - remaining_life_size_hint_x * life_percent,
            remaining_life_percent_lvl_widget.size_hint[1])
    
            if curr_screen.num_collisions_hit == curr_screen.num_collisions_level:
                self.bg_music.stop()
                self.char_death_sound.play()
                curr_screen.character_killed = True
    
                kivy.animation.Animation.cancel_all(character_image)
                for i in range(curr_screen.num_monsters): kivy.animation.Animation.cancel_all(
                    curr_screen.ids['monster' + str(i + 1) + '_image_lvl' + str(screen_num)])
                for i in range(curr_screen.num_fires): kivy.animation.Animation.cancel_all(
                    curr_screen.ids['fire' + str(i + 1) + '_lvl' + str(screen_num)])
    
                character_image.im_num = character_image.dead_start_im_num
                char_anim = kivy.animation.Animation(im_num=character_image.dead_end_im_num, duration=1.0)
                char_anim.start(character_image)
                kivy.clock.Clock.schedule_once(functools.partial(self.back_to_main_screen, curr_screen.parent), 3)
    
    def back_to_main_screen(self, screenManager, *args):
        screenManager.current = "main"
    
    def main_screen_on_enter(self):
        self.main_bg_music.play()
    
    def main_screen_on_leave(self):
        self.main_bg_music.stop()
    

    class ImageButton(kivy.uix.behaviors.ButtonBehavior, kivy.uix.image.Image): pass

    class MainScreen(kivy.uix.screenmanager.Screen): pass

    class AboutUs(kivy.uix.screenmanager.Screen): pass

    class AllLevelsCompleted(kivy.uix.screenmanager.Screen): pass

    class Level1(kivy.uix.screenmanager.Screen): character_killed = False num_coins = 5 num_coins_collected = 0 coins_ids = {} char_anim_duration = 1.0 num_monsters = 1 num_fires = 0 num_collisions_hit = 0 num_collisions_level = 20

    class Level2(kivy.uix.screenmanager.Screen): character_killed = False num_coins = 8 num_coins_collected = 0 coins_ids = {} char_anim_duration = 1.1 num_monsters = 1 num_fires = 0 num_collisions_hit = 0 num_collisions_level = 30

    class Level3(kivy.uix.screenmanager.Screen): character_killed = False num_coins = 12 num_coins_collected = 0 coins_ids = {} char_anim_duration = 1.2 num_monsters = 1 num_fires = 0 num_collisions_hit = 0 num_collisions_level = 30

    class Level4(kivy.uix.screenmanager.Screen): character_killed = False num_coins = 10 num_coins_collected = 0 coins_ids = {} char_anim_duration = 1.2 num_monsters = 1 num_fires = 1 num_collisions_hit = 0 num_collisions_level = 20

    class Level5(kivy.uix.screenmanager.Screen): character_killed = False num_coins = 15 num_coins_collected = 0 coins_ids = {} char_anim_duration = 1.3 num_monsters = 1 num_fires = 2 num_collisions_hit = 0 num_collisions_level = 20

    class Level6(kivy.uix.screenmanager.Screen): character_killed = False num_coins = 12 num_coins_collected = 0 coins_ids = {} char_anim_duration = 1.3 num_monsters = 1 num_fires = 3 num_collisions_hit = 0 num_collisions_level = 20

    class Level7(kivy.uix.screenmanager.Screen): character_killed = False num_coins = 10 num_coins_collected = 0 coins_ids = {} char_anim_duration = 1.4 num_monsters = 3 num_fires = 0 num_collisions_hit = 0 num_collisions_level = 25

    class Level8(kivy.uix.screenmanager.Screen): character_killed = False num_coins = 15 num_coins_collected = 0 coins_ids = {} char_anim_duration = 1.4 num_monsters = 2 num_fires = 0 num_collisions_hit = 0 num_collisions_level = 25

    class Level9(kivy.uix.screenmanager.Screen): character_killed = False num_coins = 12 num_coins_collected = 0 coins_ids = {} char_anim_duration = 1.5 num_monsters = 2 num_fires = 0 num_collisions_hit = 0 num_collisions_level = 25

    class Level10(kivy.uix.screenmanager.Screen): character_killed = False num_coins = 14 num_coins_collected = 0 coins_ids = {} char_anim_duration = 1.5 num_monsters = 3 num_fires = 0 num_collisions_hit = 0 num_collisions_level = 30

    class Level11(kivy.uix.screenmanager.Screen): character_killed = False num_coins = 15 num_coins_collected = 0 coins_ids = {} char_anim_duration = 1.6 num_monsters = 2 num_fires = 1 num_collisions_hit = 0 num_collisions_level = 30

    class Level12(kivy.uix.screenmanager.Screen): character_killed = False num_coins = 12 num_coins_collected = 0 coins_ids = {} char_anim_duration = 1.6 num_monsters = 2 num_fires = 1 num_collisions_hit = 0 num_collisions_level = 30

    class Level13(kivy.uix.screenmanager.Screen): character_killed = False num_coins = 10 num_coins_collected = 0 coins_ids = {} char_anim_duration = 1.7 num_monsters = 2 num_fires = 2 num_collisions_hit = 0 num_collisions_level = 20

    class Level14(kivy.uix.screenmanager.Screen): character_killed = False num_coins = 15 num_coins_collected = 0 coins_ids = {} char_anim_duration = 1.7 num_monsters = 0 num_fires = 6 num_collisions_hit = 0 num_collisions_level = 30

    class Level15(kivy.uix.screenmanager.Screen): character_killed = False num_coins = 16 num_coins_collected = 0 coins_ids = {} char_anim_duration = 1.8 num_monsters = 2 num_fires = 3 num_collisions_hit = 0 num_collisions_level = 30

    class Level16(kivy.uix.screenmanager.Screen): character_killed = False num_coins = 15 num_coins_collected = 0 coins_ids = {} char_anim_duration = 1.8 num_monsters = 3 num_fires = 2 num_collisions_hit = 0 num_collisions_level = 35

    class Level17(kivy.uix.screenmanager.Screen): character_killed = False num_coins = 10 num_coins_collected = 0 coins_ids = {} char_anim_duration = 1.3 num_monsters = 0 num_fires = 4 num_collisions_hit = 0 num_collisions_level = 30

    class Level18(kivy.uix.screenmanager.Screen): character_killed = False num_coins = 15 num_coins_collected = 0 coins_ids = {} char_anim_duration = 1.5 num_monsters = 3 num_fires = 4 num_collisions_hit = 0 num_collisions_level = 30

    class Level19(kivy.uix.screenmanager.Screen): character_killed = False num_coins = 12 num_coins_collected = 0 coins_ids = {} char_anim_duration = 1.2 num_monsters = 0 num_fires = 6 num_collisions_hit = 0 num_collisions_level = 30

    class Level20(kivy.uix.screenmanager.Screen): character_killed = False num_coins = 15 num_coins_collected = 0 coins_ids = {} char_anim_duration = 1.1 num_monsters = 0 num_fires = 8 num_collisions_hit = 0 num_collisions_level = 30

    class Level20(kivy.uix.screenmanager.Screen): character_killed = False num_coins = 20 num_coins_collected = 0 coins_ids = {} char_anim_duration = 1.1 num_monsters = 2 num_fires = 4 num_collisions_hit = 0 num_collisions_level = 30

    class Level21(kivy.uix.screenmanager.Screen): character_killed = False num_coins = 18 num_coins_collected = 0 coins_ids = {} char_anim_duration = 1.3 num_monsters = 2 num_fires = 4 num_collisions_hit = 0 num_collisions_level = 30

    class Level22(kivy.uix.screenmanager.Screen): character_killed = False num_coins = 20 num_coins_collected = 0 coins_ids = {} char_anim_duration = 1.3 num_monsters = 2 num_fires = 4 num_collisions_hit = 0 num_collisions_level = 30

    class Level23(kivy.uix.screenmanager.Screen): character_killed = False num_coins = 25 num_coins_collected = 0 coins_ids = {} char_anim_duration = 1.1 num_monsters = 2 num_fires = 2 num_collisions_hit = 0 num_collisions_level = 30

    class Level24(kivy.uix.screenmanager.Screen): character_killed = False num_coins = 20 num_coins_collected = 0 coins_ids = {} char_anim_duration = 1.1 num_monsters = 3 num_fires = 2 num_collisions_hit = 0 num_collisions_level = 30

    app = TestApp(title="CoinTex") app.run() `

    opened by tommyready 0
  • Agent ignores its own position, and hazards in its path

    Agent ignores its own position, and hazards in its path

    Seems to me from the code and the video demo that the agent exhibits two behaviours.

    • Find position closest to the first coin in dictionary
    • Subject to constraint that it is not contained in a .3x.3 bounding box of any hazards

    So if there is a monster at the midpoint of the player and the coin, but displaced from the coin by at least .3 in either direction, the agent will run directly into the monster because it only cares about danger at the destination but not the path. This seems to happen in the demo.

    Some ideas are to (i) only consider solutions in the neighbourhood of the player (relative vector with bounds), or to (ii) change the fitness function to measure distance from the segment with endpoints at player and coin and (iii) consider the coin closest to the solution.

    As it is the agent is exhibiting behaviour that could be easily found using simple path finding rather than GA.

    opened by Game4Move78 0
Releases(1.2)
Owner
Ahmed Gad
Ph.D. Student at uOttawa // Machine Learning Researcher & Technical Author https://amazon.com/author/ahmedgad
Ahmed Gad
Mastermind-Game - A game to test programming and logical skills

Bem vindo ao jogo Mastermind! O jogo consiste em adivinhar uma senha que será ge

Marcelo Daros 0 Jan 27, 2022
A basic quiz game using Python

QuizGame A basic quiz game using Python Passwords for quizzes (NO CAPS LOCK!): -ryzermattishandsome -canisleepwithyou Before using this, please make s

Austin 1 Nov 12, 2021
A "guess the number" game on a GUI interface using Tkinter library🙂

A "guess the number" game on a GUI interface using Tkinter library🙂

Arsalan 2 Feb 01, 2022
General Crossy Road Game using Python code

Python-Game General Crossy Road Game using Python code Using code such as function and while using turtle, I was able to recreate a beginner version o

Jacob Paquette 1 Dec 19, 2021
Projeto Flappy Bird temática doom, projeto python e pygame

Doom-Bird Tecnologias usadas Requisitos para inicializar o jogo: Python faça o download em: https://www.python.org/downloads/ Após instalar o Python d

João Guilherme 1 Dec 08, 2021
Given some input, spit out the possible words for a Wordle puzzle

Wordle Helper, because why not. Given some input, spit out the possible words for a Wordle puzzle First time setup # Download the dictionary to a file

Richard Duarte 1 Jan 25, 2022
A shooter game.

Screenshots Installation GNU/Linux Go to the Releases tab. Download InfiniteShooter.flatpak from the latest version of InfiniteShooter Open the termin

PastThePixels 13 Dec 01, 2022
This a secret santa game organizer that assigns secret santa randomly to each participant and then sends an automated mail to each santa with details of his/her secret santa child.

Before executing the script, make sure to turn on 'Less Secure App access' option from your gmail ID that will be used to send out the mails to all participants of the game. To do so, get going with

DEV_FINWIZ 10 Dec 06, 2022
Rock Paper Scissors Game with PyQt5

Rock-Paper-Scissors-Game rock paper scissors is a old game that all of us played it but this time let's play with computer Description This is Rock Pa

MohammadAli.HBA 4 Nov 11, 2021
This is a text-based snake and ladder game .

This is a text-based snake and ladder game .

AKSHAI KRISHNA A 1 Nov 01, 2021
Flappy Bird Game using Pygame in Python

Flappy Bird Game using Pygame in Python Demo Pages Hello dear, hope you are very well! I created Flappy Bird Game using Pygame ( Pygame is a cross-pla

Datt Panchal 3 Feb 05, 2022
A Higher-Lower web game made in Python using Flask framework.

Higher Lower Web Game Guess the random number from 0 to 9 in this web game made with Python and Flask Framework Modules that were used Random Flask In

Yago Goltara 1 Oct 27, 2021
Automatic game data translator for RPGMaker-MV

RPGMaker-MV Translator 🕹️ 🎮 Use AI to translate all the dialogs and texts of your RPGMaker automatically. 👊 You worked hard to make your game, now

Davide Liu 11 Dec 26, 2022
CTF (Capture The Flag) started from DEFCON CTF, a competitive game among computer security enthusiasts

CTF Wiki 中文 English Welcome to CTF Wiki! CTF (Capture The Flag) started from DEFCON CTF, a competitive game among computer security enthusiasts, origi

CTF Wiki 6.4k Jan 03, 2023
Disables the chat in League of Legends for Windows.

Disables the chat in League of Legends for Windows. If you simply can't stop yourself from typing LeagueStop will play KEKW.mp3 each time you try. The sound will stack & becomes horribly annoying.

1 Nov 24, 2021
A playable version of Chess – classic two-player, various AI levels, and the crazyhouse variant! Written in Python 3

A playable version of Chess – classic two-player, various AI levels, and the crazyhouse variant! Written in Python 3. Requires the installation of PIL/Pillow and Requests

1 Dec 24, 2021
This is a two player snake game

Trake This is a two player snake game How to play the game There is food and two players. You try to eat food to become large and gain points. Player

Grrub 1 Dec 19, 2021
Implementation of Conway's game of life in python.

👾 👨🏻‍💻 Conway's Game of Life 👨🏻‍💻 👾 by FranciscoCharles An interactive simulator that implements the standard Conway Game of Life with a simpl

3 Oct 01, 2021
Utility to find games owned by all (or at least some) of the passed players.

SteamCommonGameFinder Utility to find games that are owned by all (or at least some) of the players you pass into this programm. You can already find

Daniel O'Grady 4 Jan 04, 2022
Deliver buycraft orders to players across the map in minecraft servers using baritone

Deliver buycraft orders to players across the map in minecraft servers using baritone

synthels 1 Nov 14, 2021