81 mini game Renpy

[emilkun]

37)
Dragon and coins
viewtopic.php?f=8&t=65071

Hi! I've been playing around with this code, and my question would be: how do you add imagebuttons on the right side that work as up and down arrows when clicked/tapped? For touchscreen play or in case the up and down buttons from the keyboards don't work? I've tried everything I could think of but my attempts were vain. Thanks a lot if anyone can help!

[thexerox123]

Hi! I've been playing around with this code, and my question would be: how do you add imagebuttons on the right side that work as up and down arrows when clicked/tapped? For touchscreen play or in case the up and down buttons from the keyboards don't work? I've tried everything I could think of but my attempts were vain. Thanks a lot if anyone can help!

There's code doing similar in the Christmas Cranes minigame!

viewtopic.php?f=8&t=66003&start=30

Code: Select all

image a_right = Image("Right_Idle.png", xysize=(100,100))
image a_left = Image("Left_Idle.png", xysize=(100,100))
image a_up = Image("Up_Idle.png", xysize=(100,100))

Code: Select all

    hbox:
        xalign 0.5 yalign 0.9 spacing 100
        for btn_img in ["a_left", "a_up", "a_right"]:
            imagebutton:
                idle btn_img action Return(btn_img)
                hover Transform(btn_img, matrixcolor=TintMatrix("#10e91a"))
...
    key "input_left" action Return("a_left")
    key "input_right" action Return("a_right")
    key "input_up" action Return("a_up")

You'd want to make it a vbox rather than an hbox (vertical vs horizontal).

And then key is referenced in the part of the class that handles inputs.

(You can thank _ticlock_ for that clever bit of code, I still wouldn't know to use that trick off-hand!)

[emilkun]

Hi! I've been playing around with this code, and my question would be: how do you add imagebuttons on the right side that work as up and down arrows when clicked/tapped? For touchscreen play or in case the up and down buttons from the keyboards don't work? I've tried everything I could think of but my attempts were vain. Thanks a lot if anyone can help!

There's code doing similar in the Christmas Cranes minigame!

viewtopic.php?f=8&t=66003&start=30
[...]

Thank you for the reply, I actually looked at this exact code before asking my question but unfortunately, I never managed to make it work. The arrows just won't appear , I managed to do it once but never managed to do it again but even then, it was impossible for me to click on them...
Where in this code would you add this?

Code: Select all

init python:

    import random

    class TigerGameDisplayable(renpy.Displayable):
        def __init__(self):
            renpy.Displayable.__init__(self)
            self.key_pressed = None # This will store which key is held down

            # Set game values
            self.PLAYER_WIDTH = 250
            self.PLAYER_HEIGHT = 200
            self.COIN_WIDTH = 128
            self.COIN_HEIGHT = 128
            self.PLAYER_STARTING_LIVES = 5
            self.PLAYER_VELOCITY = 50
            self.COIN_STARTING_VELOCITY = 10
            self.COIN_ACCELERATION = 1
            self.BUFFER_DISTANCE = 100

            self.score = 0
            self.player_lives = self.PLAYER_STARTING_LIVES
            self.food_velocity = self.COIN_STARTING_VELOCITY

            # Some displayables we use.
            self.player = Image("images/minigames/tiger_right.png")
            self.food = Image("images/minigames/food.png")

            # The positions of the two displayables.
            self.px = 20
            self.py = 500
            self.pymin = 100
            self.pymax = 1080 - 256
            self.cx = 1920 + 128
            self.cy = random.randint(128, 1080 - 128)
            self.cymin = 100
            self.cymax = 1080 - 128

            # The time of the past render-frame.
            self.oldst = None

            self.lose = False

            return

        # Draws the screen
        def render(self, width, height, st, at):

            # The Render object we'll be drawing into.
            r = renpy.Render(width, height)

            # Figure out the time elapsed since the previous frame.
            if self.oldst is None:
                self.oldst = st
            if self.key_pressed == "up":
                self.py -= self.PLAYER_VELOCITY
            elif self.key_pressed == "down":
                self.py += self.PLAYER_VELOCITY
            dtime = st - self.oldst
            self.oldst = st

            # This draws the player.
            def player(px, py, pymin, pymax):

                # Render the player image.
                player = renpy.render(self.player, width, height, st, at)

                # renpy.render returns a Render object, which we can
                # blit to the Render we're making.
                r.blit(player, (int(self.px), int(self.py)))
            
            # This draws the food.
            def food(cx, cy, cymin, cymax):

                # Render the food image.
                food = renpy.render(self.food, width, height, st, at)

                # renpy.render returns a Render object, which we can
                # blit to the Render we're making.
                r.blit(food, (int(self.cx), int(self.cy)))

            if self.cx < -128:
                # Player missed the food
                self.player_lives -= 1
                renpy.sound.play("audio/minigames/miss_sound.ogg")
                self.cx = width + 128
                self.cy = random.randint(128, height - 128)
            else:
                # Move the food
                self.cx -= self.food_velocity

            if self.py < self.pymin:
                self.py = self.pymin               
            if self.py > self.pymax:
                self.py = self.pymax

            if self.cy < self.cymin:
                self.cy = self.cymin               
            if self.cy > self.cymax:
                self.cy = self.cymax

            player(self.px, self.py, self.pymin, self.pymax)
            food(self.cx, self.cy, self.cymin, self.cymax)

            # Check for collisions
            def is_colliding(player, food):
                return (
                    self.px <= self.cx + self.COIN_WIDTH and
                    self.px + self.PLAYER_WIDTH >= self.cx and
                    self.py <= self.cy + self.COIN_HEIGHT and
                    self.py + self.PLAYER_HEIGHT >= self.cy
                )
            
            if is_colliding(player, food):
                self.score += 1
                renpy.sound.play("audio/minigames/food_sound.ogg")
                self.food_velocity += self.COIN_ACCELERATION
                self.cx = width + 128
                self.cy = random.randint(128, height - 128)

            # Check for a loss.
            if self.player_lives == 0:
                self.lose = True

                renpy.timeout(0)

            # Ask that we be re-rendered ASAP, so we can show the next
            # frame.
            renpy.redraw(self, 0)

            # Return the Render object.
            return r

        # Handles events.
        def event(self, ev, x, y, st):

            import pygame

            # The following allows to store which key was held down.
            if ev.type == pygame.KEYDOWN and ev.key == pygame.K_UP and self.key_pressed != "up":
                self.key_pressed = "up"
            elif ev.type == pygame.KEYDOWN and ev.key == pygame.K_DOWN and self.key_pressed != "down":
                self.key_pressed = "down"
            elif ev.type == pygame.KEYUP:
                self.key_pressed = None

            # Ensure the screen updates.
            renpy.restart_interaction()

            # If the player loses, return it.
            if self.lose:
                return self.lose
            else:
                raise renpy.IgnoreEvent()

    def display_score(st, at):
        return Text(_("Score: ") + "%d" % feed_the_tiger.score, size=40, color="#00cc00", outlines=[ (4, "#006600", 0, 0) ]), .1

    def display_player_lives(st, at):
        return Text(_("Lives: ") + "%d" % feed_the_tiger.player_lives, size=40, color="#00cc00", outlines=[ (4, "#006600", 0, 0) ]), .1

default feed_the_tiger = TigerGameDisplayable()

screen feed_the_tiger():

    add Solid("#000000")

    add feed_the_tiger

    add DynamicDisplayable(display_score) xpos 240 xanchor 0.5 ypos 25

    add DynamicDisplayable(display_player_lives) xpos (1920 - 240) xanchor 0.5 ypos 25

    text _("Feed the Tiger"):
        xalign 0.5
        ypos 25
        size 40
        color "#00cc00"
        outlines [ (4, "#006600", 0, 0) ]
        #font "gui/font/PressStart2P.ttf"

label play_feed_the_tiger:

    window hide  # Hide the window and quick menu while in Feed the Dragon
    $ quick_menu = False

    play music "audio/minigames/tune.mp3"

    $ feed_the_tiger.lose = False
    $ feed_the_tiger.score = 0
    $ feed_the_tiger.player_lives = 5
    $ feed_the_tiger.food_velocity = feed_the_tiger.COIN_STARTING_VELOCITY
    $ feed_the_tiger.py = 500
    $ feed_the_tiger.cy = random.randint(128, 1080 - 128)

    call screen feed_the_tiger

    play music  "audio/minigames/04.mp3"

    $ quick_menu = True
    window auto

label feed_the_tiger_done:

    if persistent.feed_the_tiger_high_score >= feed_the_tiger.score:
        pass
    else:
        $ persistent.feed_the_tiger_high_score = feed_the_tiger.score

    "Score: [feed_the_tiger.score]\n\nHigh Score: [persistent.feed_the_tiger_high_score]"
label start:
    menu:
        "Would you like to play again?"

        "Yes.":
            jump play_feed_the_tiger

        "No.":
            jump aftergame

Sorry to be a bother and I understand if you can't help

[thexerox123]

Thank you for the reply, I actually looked at this exact code before asking my question but unfortunately, I never managed to make it work. The arrows just won't appear , I managed to do it once but never managed to do it again but even then, it was impossible for me to click on them...
Where in this code would you add this?

Sorry to be a bother and I understand if you can't help

No bother at all! I'm actually at a part in my current minigame endeavour where I've started trying to reverse engineer this bit of _ticlock_'s code to allow for different control schemes, so it's well-timed! (I also haven't gotten it to quite work for myself yet, though, so take anything I say at this point with a grain of salt! Haha.)

The image definitions would be at the start, before the init python block.

The hbox would be within the screen, probably at the end to be the topmost layer. The key action assignments are also in the screen.

I *think* that it would involve passing "key" along to your event and render methods, as that's where the inputs are handled.

In the Christmas Cranes code, I noticed that the imagebuttons were not given an action other than to return the button itself:

Code: Select all

    hbox:
        xalign 0.5 yalign 0.9 spacing 100
        for btn_img in ["a_left", "a_up", "a_right"]:
            imagebutton:
                idle btn_img action Return(btn_img)
                hover Transform(btn_img, matrixcolor=TintMatrix("#10e91a"))
...
    key "input_left" action Return("a_left")
    key "input_right" action Return("a_right")
    key "input_up" action Return("a_up")

The images for a_left, _right, and _up are defined at the beginning, and there are no other references to input_left, _right, _up. Edit: Sussed out that input_left, etc are referencing Renpy's default keymap: https://www.renpy.org/doc/html/keymap.h ... the-keymap So that's how it links the onscreen button to the keyboard button.

But, "key" is referenced in two methods of the code that handle inputs:

In the Crane class:

Code: Select all

        def input_handler(self, key, st, game):
            try:
                if self.arrows[self.progress] == key and self.progress == game.progress:
                    self.progress += 1
                    game.reset_progress = False
                    if self.progress == len(self.arrows):
                        self.progress = "done"
                        self.end_st = st
                        game.reset_progress = True
                        return True
                else:
                    self.progress = 0
            except TypeError:
                return

And in the CraneGame class:

Code: Select all

        def handler(self, key = None):
            if key:
                self.reset_progress = True
                for column in self.columns:
                    for crane in column:
                        if crane.input_handler(key, self.time, self):
                            self.score += 1
                if self.reset_progress:
                    self.progress = 0
                else:
                    self.progress += 1

I think the first one is saying that if the key [a_left, _right, _up] matches the arrow that has been assigned to the crane from the same list, then that crane progresses. And I think the second part runs the first method (crane.input_handler) when the key is pressed, and handles the crane scoring. So they'd be equivalent to your event method and your render method (where it deals with keypresses).

So I think the way it's working is that it changes the keymap functions within the screen, and then the methods handle the logic of what happens when that button is triggered, whether it's by keyboard or onscreen button. So I think you'd need to change how the event methods work, so that it's handling things using "key" rather than "KEYDOWN"/"KEYUP". https://www.renpy.org/doc/html/screens.html#key

Since you just have the two keypresses to consider, I don't know if you can just do a simple "if key == "input_up"" or "if key == "a_"" conditional? I currently only have these two examples which are checking for the arrow == key and just checking for any of the listed keys with "if key".

I don't know if that helps, I'm still trying to figure it out myself! If I do get it working in my new minigame, I'll see if I can clarify or confirm any of this!

[thexerox123]

Another option that I may just give in and do myself:

Allow the player to select their control type at the start, and then it's an either/or thing rather than trying to get the onscreen and keyboard controls to work in conjunction

[_ticlock_]

Thank you for the reply, I actually looked at this exact code before asking my question but unfortunately, I never managed to make it work. The arrows just won't appear , I managed to do it once but never managed to do it again but even then, it was impossible for me to click on them...
Where in this code would you add this?

Your minigame seems to work withing a single call screen statement. You need to process the pressed keys or buttons within the screen interaction. I provided an example in this post viewtopic.php?f=8&t=66003&p=562510#p562510

[Orme_]

Hi,
I have a problem with the dog fishing game. The game is not center and i don't want to mess up the game by meddling with the game (like the sapwn of the fish).
Where can I find the code line in order to center my game?

Thanks a lot!

[Andredron]

Hi,
I have a problem with the dog fishing game. The game is not center and i don't want to mess up the game by meddling with the game (like the sapwn of the fish).
Where can I find the code line in order to center my game?

Thanks a lot!

I ended up changing the position variable for each object. So in each object class (fish & player), there's self.position. It's [x, y], so by default for the fish class, for example, it's [0,0]. Actually I'm not even sure if this one's important -- for the fish, the important one is the createNew(self) one, where position[0] (x position) is random between 0 and 800. Just change that to where you need the fish to spawn. position [1] right below that is for y position, just change 0 to your desired y. Make sure you also change self.maxY in Fish() to where you want the fish to stop falling.

Same thing for class Player (), change position to the new x and y coordinates; that's where it'll spawn. Then change

Code: Select all

if ( self.position[0] < 0 ):
    self.position[0] = 0
elif ( self.position[0] > 800 - self.dimensions[0] ):
    self.position[0] = 800 - self.dimensions[0]

from 0 and 800 to your leftmost and rightmost coordinate, respectively. Basically everything's just fiddling around with the position of each object.

Lastly I noticed there's r = renpy.render( self.image, 800, 600, shownTimebase, animationTimebase ) , which on documentation says this

"class renpy.Render(width, height)"

so I assume you would want to change 800 and 600 to your new dimensions.

[Orme_]

Hi,
I have a problem with the dog fishing game. The game is not center and i don't want to mess up the game by meddling with the game (like the sapwn of the fish).
Where can I find the code line in order to center my game?

Thanks a lot!

I ended up changing the position variable for each object. So in each object class (fish & player), there's self.position. It's [x, y], so by default for the fish class, for example, it's [0,0]. Actually I'm not even sure if this one's important -- for the fish, the important one is the createNew(self) one, where position[0] (x position) is random between 0 and 800. Just change that to where you need the fish to spawn. position [1] right below that is for y position, just change 0 to your desired y. Make sure you also change self.maxY in Fish() to where you want the fish to stop falling.

Same thing for class Player (), change position to the new x and y coordinates; that's where it'll spawn. Then change

Code: Select all

if ( self.position[0] < 0 ):
    self.position[0] = 0
elif ( self.position[0] > 800 - self.dimensions[0] ):
    self.position[0] = 800 - self.dimensions[0]

from 0 and 800 to your leftmost and rightmost coordinate, respectively. Basically everything's just fiddling around with the position of each object.

Lastly I noticed there's r = renpy.render( self.image, 800, 600, shownTimebase, animationTimebase ) , which on documentation says this

"class renpy.Render(width, height)"

so I assume you would want to change 800 and 600 to your new dimensions.

After testing and a lot of head-scratching, I found out that my problem is because, the gui of my game is different of the gui of the source game, and (as it was coded in a prevous version of renpy), I doesn't have a clue on how to solve this problem.

Thanks for your help

[Andredron]

Add 68, GB emulator https://github.com/Pseurae/rengbpy

[Andredron]

https://github.com/BlackRam-oss/Chrome-Dino-Runner

A Replica of the hidden Dinosaur Game from Chrome Browser Offline mode build using Python and PyGame.

[birctreel]

THank you!!
It would be definitely helpful! Each of the mini games looks so interesting ^^

[Andredron]

Code: Select all

#mines
init python:
    
    import random

    class MinesweeperGame:

        def __init__(self, dimx, dimy, bombs):

            if dimx > dimy:

                self.dimx = dimx

                self.dimy = dimy

            else:

                self.dimx = dimy

                self.dimy = dimx

            self.bombs = bombs

            self.table = MinesweeperTileset(self.dimx, self.dimy, bombs)

            self.dim = 1000//self.dimy

            self.colors = [u'#fff',u'#060afe',u'#388e3c',u'#d32f2f',u'#ba2fd3',u'#d38f2f',u'#2fbed3',u'#2fd38f',u'#f5e42b']


    class MinesweeperTileset:

        def __init__(self, dimx, dimy, bombs):

            self.explosion = False

            self.bombs = bombs

            self.opened = 0

            self.marked = 0

            self.tiles = []

            self.dimx = dimx

            self.dimy = dimy

            for i in range(dimy):

                self.tiles.append([])

                for j in range(dimx):

                    self.tiles[i].append(MinesweeperTile(posi = i, posj = j))

            self.pomlist = range(dimx*dimy)

            random.shuffle(self.pomlist)

            for i in range(bombs):

                ii = self.pomlist[i] // dimx
                jj = self.pomlist[i] % dimx

                self.tiles[ii][jj].bomb = True

                pomarr = self.getNeighbours(ii,jj)

                for x in pomarr:

                    x.num += 1

        def getNeighbours(self, posi, posj):

            nbrs = []

            if (posi == 0 and posj == 0):

                nbrs.append(self.tiles[posi+1][posj+1])
                nbrs.append(self.tiles[posi+1][posj])
                nbrs.append(self.tiles[posi][posj+1])

            elif (posi == 0 and posj == self.dimx - 1):

                nbrs.append(self.tiles[posi][posj-1])
                nbrs.append(self.tiles[posi+1][posj])
                nbrs.append(self.tiles[posi+1][posj-1])

            elif (posi == self.dimy - 1 and posj == 0):

                nbrs.append(self.tiles[posi-1][posj+1])
                nbrs.append(self.tiles[posi-1][posj])
                nbrs.append(self.tiles[posi][posj+1])

            elif (posi == self.dimy - 1 and posj == self.dimx - 1):

                nbrs.append(self.tiles[posi-1][posj-1])
                nbrs.append(self.tiles[posi-1][posj])
                nbrs.append(self.tiles[posi][posj-1])

            else:

                if posi == 0:

                    nbrs.append(self.tiles[posi+1][posj-1])
                    nbrs.append(self.tiles[posi+1][posj])
                    nbrs.append(self.tiles[posi+1][posj+1])
                    nbrs.append(self.tiles[posi][posj-1])
                    nbrs.append(self.tiles[posi][posj+1])

                elif posj == 0:

                    nbrs.append(self.tiles[posi-1][posj])
                    nbrs.append(self.tiles[posi+1][posj])
                    nbrs.append(self.tiles[posi-1][posj+1])
                    nbrs.append(self.tiles[posi][posj+1])
                    nbrs.append(self.tiles[posi+1][posj+1])

                elif posi == self.dimy - 1:

                    nbrs.append(self.tiles[posi-1][posj-1])
                    nbrs.append(self.tiles[posi-1][posj])
                    nbrs.append(self.tiles[posi-1][posj+1])
                    nbrs.append(self.tiles[posi][posj-1])
                    nbrs.append(self.tiles[posi][posj+1])

                elif posj == self.dimx - 1:

                    nbrs.append(self.tiles[posi-1][posj-1])
                    nbrs.append(self.tiles[posi][posj-1])
                    nbrs.append(self.tiles[posi+1][posj-1])
                    nbrs.append(self.tiles[posi-1][posj])
                    nbrs.append(self.tiles[posi+1][posj])

                else:

                    nbrs.append(self.tiles[posi-1][posj-1])
                    nbrs.append(self.tiles[posi-1][posj])
                    nbrs.append(self.tiles[posi-1][posj+1])
                    nbrs.append(self.tiles[posi][posj-1])
                    nbrs.append(self.tiles[posi][posj+1])
                    nbrs.append(self.tiles[posi+1][posj-1])
                    nbrs.append(self.tiles[posi+1][posj])
                    nbrs.append(self.tiles[posi+1][posj+1])

            return nbrs


        def open(self, posi, posj):

            self.tiles[posi][posj].opened = True

            self.opened += 1

            if self.tiles[posi][posj].bomb == True:

                self.explosion = True

            else:

                if not self.tiles[posi][posj].num:

                    pomarr = self.getNeighbours(posi,posj)

                    for x in pomarr:

                        if not x.opened:

                            self.open(posi = x.posi, posj = x.posj)


        def toggle(self, posi, posj):

            self.tiles[posi][posj].marked ^= True

            if self.tiles[posi][posj].marked:
                
                self.marked += 1

            else:

                self.marked -= 1 

        def force_open(self, posi, posj):

            nbrs = self.getNeighbours(posi,posj)

            pomnum = 0
            for x in nbrs:

                if x.marked:

                    pomnum+=1

            if pomnum == self.tiles[posi][posj].num:

                for x in nbrs:

                    if not x.opened and not x.marked:

                        self.open(posi = x.posi, posj = x.posj)

            # else:

            #     for x in nbrs:

            #         if not x.opened:

            #             x.hlight = True


            

    class MinesweeperTile:

        def __init__(self, posi, posj):

            self.posi = posi
            self.posj = posj

            self.bomb = False
            self.marked = False
            self.num = 0
            self.opened = False
            self.hlight = False


transform hlighttf():

    easeout 0.3 alpha 0.5
    easein 0.3 alpha 1.0

screen msw_screen(ms):

    modal True
    zorder 1000

    add "background.png"

    frame:

        xalign 0.99
        yalign 0.01
        fixed:

            xsize 200
            ysize 120


            vbox:
                label "Bombs:"
                hbox:
                    text str(ms.table.marked)
                    text "/"
                    text str(ms.table.bombs)
    frame:

        xalign 0.5
        yalign 0.5
    
        fixed:

            xsize ms.dim*ms.dimx
            ysize ms.dim*ms.dimy
    
            for i in range(len(ms.table.tiles)):

                for j in range(len(ms.table.tiles[i])):

                    button:

                        xsize ms.dim
                        ysize ms.dim

                        xpos j * ms.dim
                        ypos i * ms.dim

                        if not ms.table.tiles[i][j].opened:
                            
                            background u'#cc0066'
                            hover_background u'#dd0077'
                            alternate [Function(ms.table.toggle, posi = i, posj = j)]
                            action [Function(ms.table.open, posi = i, posj = j)]
                            if ms.table.tiles[i][j].marked:

                                text ('X') xalign 0.5 yalign 0.5

                            #if ms.table.tiles[i][j].hlight:

                                #at hlighttf

                                #$ ms.table.tiles[i][j].hlight = False

                        else:

                            background u'#191316'
                            alternate [Function(ms.table.force_open, posi = i, posj = j)]
                            action [Function(ms.table.force_open, posi = i, posj = j)]
                            if ms.table.tiles[i][j].bomb:

                                text ('O') xalign 0.5 yalign 0.5

                            elif ms.table.tiles[i][j].num:

                                text (str(ms.table.tiles[i][j].num)) xalign 0.5 yalign 0.5 color ms.colors[ms.table.tiles[i][j].num]


                        
                        #hovered []

    if ms.table.explosion:

        button:

            background u'#191316aa'
            xsize 1920
            ysize 1080

            action [Hide("msw_screen"),Jump("start")]

        vbox:
            xalign 0.5 
            yalign 0.5
            text "The mine exploded :((" size 50 xalign 0.5 yalign 0.5
            text "Press anywhere to play again!" xalign 0.5 yalign 0.5

    if ms.dimx*ms.dimy - ms.table.opened == ms.table.bombs:

        button:

            background u'#191316aa'
            xsize 1920
            ysize 1080

            action [Hide("msw_screen"),Jump("start")]

        vbox:
            xalign 0.5 
            yalign 0.5
            text "You found all the mines!!!" size 50 xalign 0.5 yalign 0.5
            text "Press anywhere to play again!" xalign 0.5 yalign 0.5

label start:

    $ msgame = MinesweeperGame(20,24,99)

    show screen msw_screen(ms = msgame)

    pause

    # This shows a character sprite. A placeholder is used, but you can
    # replace it by adding a file named "eileen happy.png" to the images
    # directory.

    show eileen happy

    # These display lines of dialogue.

    e "You've created a new Ren'Py game."

    e "Once you add a story, pictures, and music, you can release it to the world!"

    # This ends the game.

    return

[thexerox123]

I bring another humble offering for this wonderful thread, made using PyTom's Cardgame Framework:

viewtopic.php?p=565308#p565308