Mike's Junk

EXTRAS

All of the things that don't fit anywhere else.

Code snippets and work-in-progress,

also my discontinued projects and old ressources.

Resources:

PYnoid source
3D-RPG-Game (2013)
2D-RPG-Game (2006)
Pictures
Old Levels (1997/98)

PYnoid (Python source code)

This is the source file of my very simple example of the popular game "Arcanoid". To make the file easier to find and read, I decided to keep the whole code in just one single file.
It still needs some optimizations!

Screenshots and more informations also available HERE.

##########################################################################################
###  PYnoid by Michael Jaskula. June 2022.
##########################################################################################
###  This is a very simple example of the popular "Arcanoid" game.
###  To make the file easier to find and read on my website ( www.mikej.de )
###  I decided to keep the whole code in just one single file.
###  It still needs some optimizations!
##########################################################################################

import tkinter as tk
import time
from random import randint
from tkinter import messagebox  
from tkinter import Menu

##########################################################################################
SCREENX=1024
SCREENY=800

########################################################################################
def rgb(r, g, b):
    return "#%s%s%s" % tuple([hex(c)[2:].rjust(2, "0") for c in (r, g, b)])

########################################################################################
def mouse_event(win):
    def catch_event_cursor(event,state):
        win.config(cursor=state)  
        
    def catch_event(event):
        xx=event.x
        if scene.paused==False:
            if xx<1:
                xx=1
            if xx>SCREENX-player.SIZEX:
                xx=SCREENX-player.SIZEX

player.update(xx)
            player.draw()
        
    win.bind("<Motion>", catch_event)   # motion 
    win.bind("<Button-1>", lambda eff: catch_event_cursor(eff,"arrow"))    # LMB pressed
    win.bind("<ButtonRelease-1>", lambda eff: catch_event_cursor(eff,"none"))  # LMB released

########################################################################################
class Timer:
    def __init__(self,win):
        self.win=win
        self.win.after(16, self.__clock)

def __clock(self):
        if scene.paused==False:

for bb in ball:
                    bb.update(ball)    
                    bb.check_collision(player)
            
                    for i in range(len(scene.allblocks)):
                        if scene.allblocks[i]:
                            bb.check_collision(scene.allblocks[i]) 
                            scene.allblocks[i].update()

bb.draw()

self.win.after(16, self.__clock)

########################################################################################
class Player:
    SIZEX=220  
    SIZEY=20

def __init__(self, canvas, x, y):
        self.x=x
        self.y=y
        self.status=0
        self.canvas=canvas
        self.widg=self.__create()
        self.active=True

def __create(self):
        self.widg=self.canvas.create_rectangle(self.x, self.y, self.x+self.SIZEX, self.y+self.SIZEY, fill="#55ddaa", outline="") 
        self.widg2=self.canvas.create_rectangle(self.x, self.y, self.x, self.y, fill='#ffddcc', outline="")  
        return self.widg

def draw(self):
        self.canvas.coords(self.widg,  self.x, self.y, self.x+self.SIZEX, self.y+self.SIZEY)
        self.canvas.coords(self.widg2, self.x+0, self.y+3, self.x+self.SIZEX-0, self.y+7)

def update(self,xx):
        self.x=xx

def reset(self):
        self.update((SCREENX//2)-(self.SIZEX//2))
        self.draw()
        self.canvas.tag_raise(self.widg)
        self.canvas.tag_raise(self.widg2)

########################################################################################
class Block:
    SIZEX=112
    SIZEY=32

def __init__(self,canvas, x,y):
        self.x=x
        self.y=y
        self.color=0
        self.active=True
        self.type=0
        self.canvas=canvas
        
    
    def update(self):
        if self.color>0:
            self.color -=1
            self.refresh()

if self.color==1:
            if self.type==1:  ## normal block
                self.remove()

elif self.type==2: ## reinforced block
                self.type=1
                self.color=0
                col=scene.getcolor(self.type-1)
                self.canvas.itemconfig(self.widg, fill=col)
            
            elif self.type==3:  ## create new balls here
                ball.append(Ball(self.canvas, self.x,  self.y))
                self.remove()

def refresh(self):
        rr=255-(self.color*1)
        gg=255-(self.color*14)
        bb=255-(self.color*20)
        self.canvas.itemconfig(self.widg, fill=rgb(rr,gg,bb))

def create(self):
        col=scene.getcolor(self.type-1)
        self.widg=self.canvas.create_rectangle(self.x, self.y, self.x+self.SIZEX, self.y+self.SIZEY, fill=col, outline=col, width=0)
        self.canvas.tag_raise(self.widg)
        return self.widg

def remove(self):
        self.active=False
        self.color=0
        self.canvas.delete(self.widg)
        scene.total -=1
        ###print("total blocks to remove:",scene.total)
        if scene.total<1:
            scene.reset()

########################################################################################
class Ball:
    BALLSIZEX=48 
    BALLSIZEY=48

def __init__(self,canvas,x,y):
        self.x=x
        self.y=y
        self.time=1
        self.vecx=-9+(randint(1,16))
        self.vecy=-6+(randint(1,4))
        self.canvas=canvas
        self.widg=self.create()

def update(self, what):
        if self.time>1:
            self.time -=0.033
        else: 
            self.time=1.0

if (self.x+self.vecx<20) or (self.x+self.vecx>(SCREENX-20)): 
            self.vecx= -self.vecx
        if (self.y+self.vecy<20) or (self.y+self.vecy>(SCREENY-20)):
            self.vecy= -self.vecy

self.x=self.x+(self.vecx*self.time)
        self.y=self.y+(self.vecy*self.time)

if self.vecx>11:
            self.vecx=11
        if self.vecy>11:
            self.vecy=11
        if self.vecx<11 and self.vecx>=0:
            self.vecx=11
        if self.vecx>-11 and self.vecx<0:
            self.vecx=-11
        if self.vecy<8 and self.vecy>=0:
            self.vecy=11
        if self.vecy>-11 and self.vecy<0:
            self.vecy=-11
    
        if self.y>(SCREENY-40):
            self.removeball(True)

def removeball(self, rrr):
            self.canvas.delete(self.widg)
            self.canvas.delete(self.widg2)
            if rrr==True:
                ball.remove(self)  ## remove from list
            if len(ball)<1:
                scene.level-=1
                scene.reset()

def create(self):
        sizx=self.BALLSIZEX//2
        sizy=self.BALLSIZEY//2
        self.widg=self.canvas.create_oval(self.x-sizx, self.y-sizy,210,210, fill="#8890dd", outline="#666677", width=2)
        self.widg2=self.canvas.create_oval(self.x-sizx, self.y-sizy,210,210, fill="#ffffff", outline="#ccccff", width=3)
        self.canvas.tag_raise(self.widg)
        self.canvas.tag_raise(self.widg2)
        self.draw()
        return self.widg

def draw(self):
        sizx=self.BALLSIZEX//2.8
        sizy=self.BALLSIZEY//2.8
        self.canvas.coords(self.widg, self.x-sizx, self.y-sizy, self.x+sizx, self.y+sizy)
        self.canvas.coords(self.widg2, self.x-sizx+5, self.y-sizy+5, self.x+sizx//7, self.y+sizy//7)

def check_collision(self, other):
        sizx=self.BALLSIZEX//2
        sizy=self.BALLSIZEY//2

if other and other.active:
            if ( (self.x+sizx > other.x) and (self.x-sizx < other.x+other.SIZEX) ) and  (   (self.y+sizy > other.y) and (self.y-sizy < other.y+other.SIZEY) ):

self.time=1.66
                gotit=False

if (self.x>other.x+other.SIZEX) and (self.vecx<0):
                    self.vecx=-self.vecx
                    if type(other).__name__=="Block":
                            other.color=9
                            gotit=True
                    
                if (gotit==False) and (self.y>other.y+other.SIZEY) and (self.vecy<0):
                    self.vecy=-self.vecy
                    if type(other).__name__=="Block":
                            other.color=9
                            gotit=True
                    
                if (gotit==False) and (self.x<other.x) and (self.vecx>0):
                    self.vecx=-self.vecx
                    if type(other).__name__=="Block":
                            other.color=9
                            gotit=True

if (gotit==False) and (self.y<other.y) and (self.vecy>0):
                    self.vecy=-self.vecy
                    if type(other).__name__=="Block":
                            other.color=9
                            gotit=True

if randint(1,10)<3:
                    self.vecx=self.vecx+randint(-6,6)
                    self.vecy=self.vecy+randint(-6,6)

########################################################################################
class Scene:

## 1 =normal
    ## 2 =reinforced
    ## 3 =extra ball

allblocks=[]
    layout=[[1,1,3,1,1,3,1,1,   0,1,1,2,1,1,1,0,   0,0,1,1,1,1,0,0,   0,1,1,1,2,1,1,0,   1,1,3,1,1,3,1,1],
            [0,0,0,2,2,0,0,0,   0,0,2,1,1,2,0,0,   0,0,2,1,1,2,0,0,   0,0,2,1,1,2,0,0,   0,0,0,2,2,0,0,0],
            [1,2,0,0,0,0,2,1,   1,2,0,1,1,0,2,1,   1,2,0,1,1,0,2,1,   1,2,0,1,1,0,2,1,   1,3,0,0,0,0,3,1],
            [1,0,1,0,1,0,1,0,   0,1,0,1,0,1,0,1,   1,0,1,0,1,0,1,0,   0,1,0,1,0,1,0,1,   1,0,1,0,1,0,1,0],
            [1,1,1,3,1,1,1,1,   2,2,2,2,2,2,3,2,   3,1,1,1,1,1,1,1,   2,2,2,2,3,2,2,2,   1,1,3,1,1,1,1,1],
            ]
    ##                       normal blocks                                                  reinforced-blocks 
    blockcolor=[["#66ccff", "#bbff88",  "#bb4466", "#66aaff", "#aa33aa"], ["#bbffff", "#88cc55",  "#882233", "#3377dd", "#ee7799"] ]
   
    def __init__(self, canvas):
        self.level=-1  
        self.total=0
        self.paused=False
        self.canvas=canvas
        
    def __remove_background(self):
            self.canvas.delete("stars") 
            self.canvas.delete("gradient")

def __draw_background(self):
        dd=(scene.level % 3)
        if dd==1:  
            for i in range(SCREENY):
                rr=(1+(i//5))
                gg=(10+i//8)
                bb=(255-(i//6))
                rr=rr//2
                gg=gg//5
                bb=bb//2
                gradient=self.canvas.create_line(0,i,SCREENX,i, tags="gradient", fill=rgb(rr, gg, bb))
                self.canvas.tag_lower(gradient)

if dd==0:
            for i in range(SCREENY):
                rr=(130+(i//10))
                gg=(100+i//20)
                bb=(185-(i//7))
                gradient=self.canvas.create_line(0,i,SCREENX,i, tags="gradient", fill=rgb(rr, gg, bb))
                self.canvas.tag_lower(gradient)

if dd==2:
            for i in range(SCREENY):
                rr=(220-(i//16))
                gg=(220-(i//6))
                bb=(190-(i//10))
                gradient=self.canvas.create_line(0,i,SCREENX,i, tags="gradient", fill=rgb(rr, gg, bb))
                self.canvas.tag_lower(gradient)

## put some stars
        for i in range(20):  
            x=randint(0,SCREENX-4)
            y=i*25
            stars=self.canvas.create_oval(x, y, x, y, width = 3, tags="stars", outline=rgb(240-(i*4),220-(i*5), 255-(i*2)))
        self.canvas.tag_lower(stars)

def __create_new(self):
        for bb in ball:
            bb.removeball(False)

ball.clear()
        ball.append(Ball(self.canvas, SCREENX//2,  SCREENY//2))
        
        ## print("creating scene for level:", self.level)
        yy=0
        xx=0
        self.total=0
        for i in range(len(self.layout[self.level])):
            if self.layout[self.level][i]>0:
                xx=32+(i%8)*120
                yy=100+(i//8)*40
                bb=Block(self.canvas, xx,yy)
                bb.active=True
                bb.type=self.layout[self.level][i]
                bb.create()
                self.allblocks.append(bb)
                self.total +=1

def getcolor(self, type):
        if type==2:
            return "#ffffff"
        return self.blockcolor[type][self.level]

def __removeallblocks(self):
        for i in range(len(self.allblocks)):
            if self.allblocks[i]:
                self.canvas.delete(self.allblocks[i].widg)
                self.allblocks[i].active=False

def reset(self):
        self.__removeallblocks()
        self.level +=1
        if self.level>4: 
            self.level=0

self.__remove_background()
        self.__draw_background()
        self.__create_new()
        player.reset()
        menubar.update_menu()

########################################################################################
class Application:
    def __init__(self, win=None):
        self.win = win 
        txt=f"{SCREENX}x{SCREENY}"
        self.win.geometry(txt)
        self.win.resizable(False, False)
        self.win.title('PYnoid by Michael Jaskula // June.2022 // www.mikej.de ')
        self.win.config(cursor="none")
        self.win.config(background="#666666")

def createcanvas(self):
        canvas=tk.Canvas(self.win, width=SCREENX, height=SCREENY, highlightthickness=0, relief='ridge')
        canvas.place(x=0,y=0)
        return canvas

########################################################################################
class MenuBar:
    def __init__(self, win):
        self.menubar=Menu(win)
        self.win=win
        self.__create()

def __create(self):
        win.config(menu = self.menubar)

self.help_menu = Menu(
            self.menubar,
            tearoff=0
        )
        self.menubar.add_cascade(
            label="Menu",
            menu=self.help_menu
        )
        self.menubar.add_cascade(
            label="Level:",
        )

self.help_menu.add_command(label='About...', 
            command =lambda: messagebox.showinfo(title="ABOUT", message="PYnoid \nby\nMichael Jaskula\n\nA simpe Arcanoid-based game in Python.\nJune,2022\n\nContact:\nmikej@mikej.de\nwww.mikej.de\n") 
        )
        self.help_menu.add_separator()
        self.help_menu.add_command(label='Restart game', 
            command =self.__restart_all
        )
        self.help_menu.add_separator()
        self.help_menu.add_command(label='Pause', 
            command =self.__pause_game
        )
        self.help_menu.add_separator()
        self.help_menu.add_command(label='Skip Level',
            command=self.__skip

)

self.help_menu.add_separator()
        self.help_menu.add_command(label='Exit',
            command=self.win.destroy
        )

def __skip(self):
            scene.reset()

def __pause_game(self):
        if scene.paused:
            self.help_menu.entryconfig(4, label="Pause")
            scene.paused=False
            self.win.config(cursor="none")  ## change cursor on LMB
        else:
            self.help_menu.entryconfig(4, label="Pause  \u221a")
            scene.paused=True
            self.win.config(cursor="arrow")  ## change cursor on LMB

def __restart_all(self):
            scene.level=-1
            scene.reset()

def update_menu(self):
        self.menubar.entryconfig(2, label=f"Level : {scene.level+1}")

########################################################################################
########################################################################################
########################################################################################

win = tk.Tk()
app=Application(win)
canvas=app.createcanvas()

menubar = MenuBar(win)

ball=[]

player=Player(canvas, (SCREENX//2),  SCREENY-64)

scene=Scene(canvas)

scene.reset()
    
win.bind("<Escape>",lambda qq: win.quit())

mouse_event(win)

timer = Timer(win)

win.mainloop()

3D-RPG-Game (Last ver. 2013) (abandoned)

This "RPG-Project" was my unfinished game that provided a fully graphical role-playing feeling.
Graphics Engine: Irrlicht (DirectX / OpenGL).
Music and SFX: FMOD

It is coded in C++ and features:

Full 3D-Graphics (FPP style)
Post-Processing HLSL/GLSL Shaders (e.g.Bloom) and Surface-Shaders (e.g.Water,Lava)
Dynamic Lights
Normal mapping (PerPixel)
Huge seamless world(s) with optimized single locations and indoors,
Dynamic day/night cycles and weather system (snow, fog, rain...)
2D & 3D Sound effects (thanks to FMOD),
Quest-, Dialogue-, Skills- System
WYSIWYG Editor,
and many more...

Below you will find some screenshots of this game.

Click picture to view full size in a new window:

2013

2011 & older

2D-iso-rpg-game" (abandoned in 2006)

This 2d-isometric game was intended to be played as a single player game for Windows 32-bit.
It featured my own pathfinding system, dungeons, weather-system, spells (4 magic-classes), a simpe AI, in-game-music and more..
The player could buy and sell items in shops and enchant items...
Used library: SDL.

Click picture to view full size in a new window: