spielend-programmieren

Mampfi

Horst JENS — Tue, 09 Mar 2010 13:00:39 +0100

Mampfi entstand aus dem Bonusspiel von MonkeyDöner und wird von Teresa programmiert.

Video

Das Adobe Flash Plugin wird benötigt, um diesen Ihnalt anzuzeigen.

Installation

Python2.6 und pygame1.8 (oder besser) müssen richtig installiert sein damit das Spiel funktioniert.

Den Spieler steuert den Zauberer mit den Pfeiltasten ←, →, ↑, ↓ und legt gesunde Nahrung mit den Tasten A, S, D, F. Man muss herausfinden, welches Kind welches Gemüse oder Obst isst. Die 4 coolen Kinder ( Markus, Raphael, Mira, Teresa) bewerfen den Spieler mit Hamburgers und Pommfrits, denen der Spieler ausweichen muss.

Spielziel:

Die 4 Kinder verlieren Hitpoints ¹⁾ wenn sie an der Wand abprallen. Hat ein Kind genug gesunde Nahrung gegessen fährt es von selbst zur Zielposition - wenn alle 4 Kinder dort angelangt sind hat der Spieler gewonnen. Der Spieler verliert wenn er selbst oder ein Kind alle Hitpoints verliert.

Screenshots

¹⁾ Lebenspunkte, symbolisiert durch den grünen Balken. Je grüner, desto gesünder

Spiele

Horst JENS — Tue, 09 Mar 2010 12:58:50 +0100

Python Game Book - Spiele

Einige Spiele sind Teil meines Python Game Book - Projekts und hier zu finden:

Python Game Book Spiele

Bild rechts: Kursteilnehmer beim austesten des pygame-spieles Schiff (4 Spieler-Modus, eine Tastatur)

Spiele von KursteilnehmerInnen

Turtle-Grafik

mit dem Turtle Modul von Python werden grundlegende Programmierkonzepte veranschaulicht und erste Computergrafiken erzeugt. Siehe den Abschnitt Turtle im Bereich code.

Python / Pygame Spiele

Kursteilnehmer speichern ihre mit Python_(Programmiersprache) und pygame programmierten Spiele überlicherweise innerhalb ihrer persönlichen Wikiseiten ab.

mampfi

Mampfi, eine Weiterentwicklung des Bonusspiels aus Monekydoer von Teresa

monkeydöner

Monekydoer (vormals Dönerhaus) von Mira, Teresa, Markus und Raphael, produziert am Austria Game Jam 2010 für den Global Game Jam

Spukhaus

Spukhaus gibt es in deutsch bzw Englisch:

Spukhaus (deutsch) von Teresa
spooky house (englisch) von Mira

Viva la Windows

* Viva la Windows von Aaron

Spiele mit eigener Wiki-Seite

Unterkategorien:

blog

playground

user

wiki

zur_geheimseite

Seiten in dieser Kategorie:

sidebar

externe Spiele

Folgende Spiele stammen nicht von Kursteilnehmern, werden aber als Ausgangsmaterial für eigene Spiele im Kurs verwendet.

Computerspiele

Battle of Wesnoth

Battle of Wesnoth ist ein open-source Rundenstrategiespiel mit sehr schönen handgezeichneten Fantasy-Figuren. Da alle Zeichnungen creative-commons-lizensiert sind können sie in eigenen Spielen verwendet werden.

nicht - Computerspiele

Dungeon Slayers

http://www.dungeonslayers.com

Dungeon Slayers ist ein so gennanntes Pen&Paper Rollenspiel. Da es http://www.creative-commons.org-Lizensiert kann es als Ausgangsmaterial für eigne (Computer)spiele dienen.

Links

https://help.ubuntu.com/community/Games

Raphael

Raphael Röck — Thu, 04 Mar 2010 18:00:12 +0100

Lernen

sprühdosen-Malprogramm

Code

raphael1.py

# -*- coding: utf-8 -*-
import turtle as t
t.speed(0)
t.setpos(-10,0)
t.left(20)
for du in range(75):
   t.fd(10)
   t.rt(45)
   t.fd(du)
t.penup()#nicht mehr zeichnen
t.setpos(-100,-10)
t.seth(270)
t.pendown() #wieder zeichnen
t.speed(3)
t.circle(110)  
t.penup()#nicht mehr zeichnen
t.setpos(0,0)
t.pendown() #wieder zeichnen
for ihm in range(8):
  t.fd(100)
  t.back(100)
  t.rt(45)

raphael2.py

# -*- coding: utf-8 -*-
"""
part2step005_ball_with_fixed_movement
 
bouncing ball. each frame the complete screen is filled with the background,
making this example simple to code but possible slow on larger resolutions.
Each frame, a random-coloured circle is drawn with randomized radius directly on the screen.
Try to manipulate the display.set_mode values to change the resolution."""
import pygame
import random
pygame.init()
screen=pygame.display.set_mode((640,480)) # try out larger values and see what happens !
background = pygame.Surface(screen.get_size())
background.fill((random.randint(0,255)
                ,random.randint(0,255) 
                ,random.randint(0,255)))     # (red,green,blue)
background = background.convert()
ball1 = pygame.Surface((50,50))     #create a new surface (black by default)
ball2 = pygame.Surface((50,50)) 
ball3 = pygame.Surface((50,50)) 
ball1.set_colorkey((0,0,0))         #make black the transparent color (red,green,blue)
ball2.set_colorkey((0,0,0))
ball3.set_colorkey((0,0,0))
#pygame.draw.circle(Surface, color, pos, radius, width=0)
pygame.draw.circle(ball1, (0,0,255), (25,25),25) # paint blue circle
pygame.draw.circle(ball2, (0,0,255), (25,25),25)
pygame.draw.circle(ball3, (0,0,255), (25,25),25)
ball1 = ball1.convert_alpha()       # if you use tranparent colors you need convert_alpha()
ball2 = ball2.convert_alpha()
ball3 = ball3.convert_alpha()
ball1x, ball1y = 0, 750           # start position of the ball (x,y)
ball2x, ball2y = 0, 0
ball3x, ball3y = 750, 350
dx1, dy1 = random.randint(5,10), random.randint(5,10)                 # speed vector of the ball in pixel per frame
dx2, dy2 = random.randint(5,10), random.randint(5,10)
dx3, dy3 = random.randint(5,10), random.randint(5,10)
screen.blit(background, (0,0))     #draw background on screen (overwriting all)
screen.blit(ball1, (ball1x, ball1y))  #draw the topleft corner of ball surface at pos (ballx, bally)
screen.blit(ball2, (ball2x, ball2y))
screen.blit(ball3, (ball3x, ball3y))
clock = pygame.time.Clock()
mainloop = True
zeit=0
FPS = 30 # desired framerate in frames per second. 
while mainloop:
    # do all this each frame
    milliseconds = clock.tick(FPS) # do not go faster than this framerate
    zeit+=milliseconds
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            mainloop = False # pygame window closed by user
        elif event.type == pygame.KEYDOWN:
            if event.key == pygame.K_ESCAPE:
                mainloop = False # user pressed ESC
    pygame.display.set_caption("FPS: %.2f X: %.2f Y: %.2f dx: %.2f dy:"
                               " %.2f" % (clock.get_fps(), ball1x, ball1y, dx1, dy1))
    # if zeit > random.randint(15000,20000): 
        # zeit=0
        # background.fill((random.randint(0,255)
                       # ,random.randint(0,255) 
                       # ,random.randint(0,255)))
        # screen.blit(background, (0,0))     #draw background on screen (overwriting all)
    #inside mainloop, after screen.blit(background,(0,0))
    #colour = (random.randint(0,255),random.randint(0,255),random.randint(0,255))
    #radius = random.randint(50,55)
    #pygame.draw.circle(screen, colour , (100,100), radius, 2) # draw pulsating circle
    #calculate new center of ball 
    ball1x += dx1
    ball2x += dx2
    ball3x += dx3
    ball1y += dy1
    ball2y += dy2
    ball3y += dy3
    if (( abs(ball1x - ball2x) < 25 and abs(ball1y - ball2y) < 25)  or ( abs(ball1x - ball3x) < 25 and abs(ball1y - ball3y) < 25) or ( abs(ball2x - ball3x) < 25 and abs(ball2y - ball3y) < 25)):
		   background.fill((random.randint(0,255) ,random.randint(0,255) ,random.randint(0,255)))
		   screen.blit(background, (0,0))
 
    dx1+= random.randint(-1,1)
    dx2+= random.randint(-1,1)
    dx3+= random.randint(-1,1)
    dy1+= random.randint(-1,1) 
    dy2+= random.randint(-1,1)
    dy3+= random.randint(-1,1)
    # bounce ball if out of screen
    if ball1x < 0:
        ball1x = 0
        #dx *= -1 
        dx1 =random.randint(5,10)
    if ball2x < 0:
        ball2x = 0 
        dx2 =random.randint(5,10)
    if ball3x < 0:
        ball3x = 0 
        dx3 =random.randint(5,10)
    if ball1x + ball1.get_width() > screen.get_width():
        ball1x = screen.get_width() - ball1.get_width()
        #dx *= -1
        dx1= -1*random.randint(5,10)
    if ball2x + ball2.get_width() > screen.get_width():
        ball2x = screen.get_width() - ball2.get_width()
        dx2= -1*random.randint(5,10)
    if ball3x + ball3.get_width() > screen.get_width():
        ball3x = screen.get_width() - ball3.get_width()
        dx3= -1*random.randint(5,10)
    if ball1y < 0:
        ball1y = 0
        #dy *= -1
        dy1 =random.randint(5,10)
    if ball2y < 0:
        ball2y = 0
        dy2 =random.randint(5,10)
    if ball3y < 0:
        ball3y = 0
        dy3 =random.randint(5,10)
    if ball1y + ball1.get_height() > screen.get_height():
        ball1y = screen.get_height() - ball1.get_height()
        #dy *= -1
        dy1= -1*random.randint(5,10)
    if ball2y + ball2.get_height() > screen.get_height():
        ball2y = screen.get_height() - ball2.get_height()
        dy2= -1*random.randint(5,10)
    if ball3y + ball3.get_height() > screen.get_height():
        ball3y = screen.get_height() - ball3.get_height()
        dy3= -1*random.randint(5,10)
 
    # paint the ball    
    pygame.draw.circle(ball1, (random.randint(200,255),random.randint(100,200),random.randint(0,100)), (25,25),25)
    pygame.draw.circle(ball2, (random.randint(0,100),random.randint(100,200),random.randint(200,255)), (25,25),25)
    pygame.draw.circle(ball3, (random.randint(100,200),random.randint(200,255),random.randint(0,100)), (25,25),25)
    screen.blit(ball1, (round(ball1x,0), round(ball1y,0)))    
    screen.blit(ball2, (round(ball2x,0), round(ball2y,0)))
    screen.blit(ball3, (round(ball3x,0), round(ball3y,0)))
    pygame.display.flip()          # flip the screen FPS times a second

SINUS & COSINUS

raphael2.py

# -*- coding: utf-8 -*-
"""
part2step011-rotozoom.py
 
loading the images snake.gif from a subfolder called 'data'
The subfolder must be inside the same folder as the program itself. 
The snake surface can be moved with the cursor keys, 
rotated with a and d key and and zoomed with w and s key.
"""
import pygame
import os
import sys
import math
try:
    # load from subfolder 'data'
    background = pygame.image.load(os.path.join("data","background640x480_a.jpg"))
    snake = pygame.image.load(os.path.join("data","snake.gif"))
except:
    sys.exit("Unable to find the images in the folder 'data' :-( ")  
#finally:
pygame.init()
screen=pygame.display.set_mode((640,480)) # try out larger values and see what happens !
background = background.convert()  # jpg can not have transparency
snake = snake.convert_alpha()      # png image has transparent color 
snake_original = snake.copy()      # store a unmodified copy of the snake surface
snakex, snakey = 250, 240            # start position of snake surface
dx, dy  = 0, 0                   # snake speed in pixel per second !
speed = 0                       # in pixel / second
angle = 0                        # current orientation of snake
zoom = 1.0                       # current zoom factor
zoomspeed = 0.01                   
turnspeed = 30                  # in Grad (360) per second
screen.blit(background, (0,0))     # blit background on screen (overwriting all)
screen.blit(snake, (snakex, snakey))  # blit the snake shape 
clock = pygame.time.Clock()        # create pygame clock object 
mainloop = True
FPS = 60                           # desired max. framerate in frames per second. 
while mainloop:
    milliseconds = clock.tick(FPS)  # milliseconds passed since last frame
    seconds = milliseconds / 1000.0 # seconds passed since last frame
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            mainloop = False # pygame window closed by user
        elif event.type == pygame.KEYDOWN:
            if event.key == pygame.K_ESCAPE:
                mainloop = False # user pressed ESC
    pygame.display.set_caption("press cursor keys and w a s d - fps:"
        "%.2f zoom: %.2f angle %.2f" % (clock.get_fps(), zoom, angle))
    # only blit the part of the background where the snake was (cleanrect)
    try:
        #if the subsurface is outside the screen pygame would raise an error
        #this can happen when using rotozoom, therfore check inside try..except
        dirtyrect = background.subsurface((round(snakex,0), 
                round(snakey,0), snake.get_width(), snake.get_height()))
 
        screen.blit(dirtyrect, (round(snakex,0), round(snakey,0))) 
    except:
        screen.blit(background,(0,0)) # blit the whole background (slow but secure)
    # move snake with cursor keys
    pressedkeys = pygame.key.get_pressed()
    dx, dy  = 0, 0   # no cursor key, no movement
    angleradiant = angle * (math.pi * 2.0) / 180.0
    print angle
    dx += math.cos(angleradiant) * speed
    dy += math.sin(angleradiant) * speed
 
    # if pressedkeys[pygame.K_LEFT]:
        # dx -= speed
    # if pressedkeys[pygame.K_RIGHT]:
        # dx += speed
    if pressedkeys[pygame.K_UP]:
        speed += 2
    if pressedkeys[pygame.K_DOWN]:
        speed -= 2
    if speed < 0:
        speed =0    
 
    #calculate new center of snake 
    snakex += dx * seconds # time based movement
    snakey += dy * seconds
    # rotate snake with a and d key
    turnfactor = 0  # neither a nor d, no turning
    #if pressedkeys[pygame.K_a]:
        #turnfactor += 1 # counter-clockwise
    if pressedkeys[pygame.K_LEFT]:
        turnfactor += 1 
   # if pressedkeys[pygame.K_d]:
       # turnfactor -= 1 #clock-wise
    if pressedkeys[pygame.K_RIGHT]:
        turnfactor -= 1     
    # zoom snake with w and s key
    zoomfactor = 1.0 # neither w nor s, no zooming
    if pressedkeys[pygame.K_w]:
        zoomfactor += zoomspeed
    if pressedkeys[pygame.K_s]:
        zoomfactor -= zoomspeed
    if turnfactor != 0 or zoomfactor !=1.0:
        angle += turnfactor * turnspeed * seconds # time-based turning
        if angle > 360:
			angle -= 360
        if angle < -360:
            angle += 360
        zoom *= zoomfactor 
        # the surface shrinks and zooms and moves by rotating
        oldrect = snake.get_rect() # store current surface rect
        snake = pygame.transform.rotozoom(snake_original, angle, zoom)
        newrect = snake.get_rect() # store new surface rect
        # put new surface rect center on same spot as old surface rect center
        snakex += oldrect.centerx - newrect.width / 2
        snakey += oldrect.centery - newrect.height / 2
    # paint the snake    
    screen.blit(snake, (round(snakex,0), round(snakey,0)))    
    pygame.display.flip()          # flip the screen 30 times a second                # flip the screen 30 (or FPS) times a second

Meine Spiele

Julian Plochberger — Tue, 02 Mar 2010 18:09:34 +0100

selbst programmiert mit freundlicher Hilfe von Horst JENS

Monsterhunterwien

Hier ist der Link zu meinem spielanfang(noch nicht fertig und wenn ihr weiter gemacht habt Kontaktiert mich bitte(das muss nicht heißen das ich es gut finde) )

monsterhunter.zip

Das ist der Code (falls ihr nur den code kopieren soltet bringt das nichts weil der computer einen haufen an fehlermeldungen ausspucken wird das er die dateien nicht findet)

# -*- coding: utf-8 -*-
"""
part2step013-catch-the-thief.py
 
Loading  images and sounds from a subfolder called 'data'
The subfolder must be inside the same folder as the program itself. 
The player(s) can control the Pygame snake (with cursor keys) and the
Tux bird (with the mouse). A blue police icon moves toward the middle
distance between snake and bird (indicated by a cross).
Your task is to catch the thief (red triangle) with the blue police circle.
The thief moves by random. You have only a short period of time. For each 
millisecond where the police circle touches the thief triangle, you get points.
 
cleanrect function seems to be not perfect. 
"""
def play_the_game():
    import pygame
    import os
    import sys
    import random
 
    pygame.mixer.pre_init(44100, -16, 2, 2048) # setup mixer to avoid sound lag
    pygame.init()
    try:
        # load graphic files from subfolder 'data'
        background = pygame.image.load(os.path.join("data","wien.jpg"))
        snake = pygame.image.load(os.path.join("data","Berittener Polizist.png"))
        snakelinks = pygame.image.load(os.path.join("data","Berittener linker Polizist.png"))
        bird = pygame.image.load(os.path.join("data","Polizist.png"))
        birdlinks = pygame.image.load(os.path.join("data","linker Polizist.png"))
        thief = pygame.image.load(os.path.join("data","monster.png"))
        thieflinks = pygame.image.load(os.path.join("data","linkes monster.png"))
        police= pygame.image.load(os.path.join("data","cage.png"))
        # load sound files 
        over = pygame.mixer.Sound(os.path.join('data','time_is_up_game_over.ogg'))
        spring = pygame.mixer.Sound(os.path.join('data', 'spring.wav'))
 
    except:
        sys.exit("Unable to find or play the files in the folder 'data' :-( ")  
    # ------- some functions for later use ----------
    def write(msg="pygame is cool", colour=(0,0,0), fontsize=24):
        """returns a surface with text"""
        myfont = pygame.font.SysFont("None", fontsize)
        mytext = myfont.render(msg, True, colour)
        mytext = mytext.convert_alpha()
        return mytext
    def cleanblit(sprite,x,y):
        """clean a sprite from the screen, restoring the background"""
        dirtyrect = background.subsurface((round(x - sprite.get_width()/2, 0),
                                           round(y - sprite.get_height()/2,0),
                                           sprite.get_width(), sprite.get_height()))
        screen.blit(dirtyrect, ((round(x - sprite.get_width()/2, 0),
                                round(y - sprite.get_height()/2,0)))) 
    def cleanrect(x1,y1,x2,y2):
        """clean a rect from the screen, restoring the background"""
        startx = max(0,min(x1,x2) -5)
        starty = max(0,min(y1,y2) -5)
        width = min(screen.get_width(), 5 +max(x1,x2) - min(x1,x2))
        height =min(screen.get_height(), 5+ max(y1,y2) - min(y1,y2)) 
        dirtyrect = background.subsurface((startx, starty, width, height))
        screen.blit(dirtyrect, (startx, starty))
    def draw(sprite, x, y):
        """blit a sprite"""
        screen.blit(sprite, (round(x,0) - sprite.get_width()/2,
                             round(y,0) - sprite.get_height()/2)) 
    def bounce(sprite, x, y, dx, dy):
        """bounce sprite if it touches the screen borders"""
        if x - sprite.get_width()/2 < 0:
            x =  sprite.get_width()/2
            dx *= -1 
        elif x + sprite.get_width()/2 > screen.get_width():
            x = screen.get_width() - sprite.get_width()/2
            dx *= -1
        if y - sprite.get_height()/2 < 0:
            y = sprite.get_height()/2
            dy *= -1
        elif y + sprite.get_height()/2 > screen.get_height():
            y = screen.get_height() - sprite.get_height()/2
            dy *= -1
        return x,y,dx,dy
    def randomcolour():
        """returns a random colour tuple (red,green,blue)"""
        return (random.randint(0,255), random.randint(0,255), random.randint(0,255))
    # ----------- start ---------
 
    screen=pygame.display.set_mode((1024,600)) # try out larger values and see what happens !
    background = pygame.transform.scale(background, (screen.get_width(), screen.get_height()))
    background = background.convert()  # jpg can not have transparency
    snake = snake.convert_alpha()
    bird = bird.convert_alpha()
    #police = pygame.Surface((50,50)) 
    #pygame.draw.circle(police, (0,0,255), (25,25),25) # blue police
    #police.set_colorkey((0,0,0)) # black transparent colour 
    #police.blit(write("P", (255,255,255), 48), ((12,10))) # white "P"
    police = police.convert_alpha()        # png image has transparent color 
    cross = pygame.Surface((10,10))
    cross.fill((255,255,255)) # fill white
    pygame.draw.line(cross, (0,0,0), (0,0), (10,10)) # black lines
    pygame.draw.line(cross, (0,0,0), (0,10), (10,0))
    cross.set_colorkey((255,255,255))
    cross = cross.convert_alpha()
    #thief = pygame.Surface((26,26))
    #thief.set_colorkey((0,0,0))
    #pygame.draw.polygon(thief, (255,0,0), [(0,0),(25,0),(12,25)])
    #thief.blit(write("T", (0,0,0), 32), ((6,3))) # transparent "T"
    thief = thief.convert_alpha()
    thiefx, thiefy = 50,50
    thiefdx, thiefdy = random.randint(-150,150), random.randint(-150,150)
    thiefmaxspeed = 200
    erratic = 3                            # possible change +/- of thief speed
    policex, policey = 250, 240            # start position of police surface
    policedx, policedy  = 0, 0                   # police speed in pixel per second !
    birdx, birdy = 100,100
    birddx, birddy = 0,0
    snakex, snakey = 200,200
    snakedx, snakedy = 0,0
    crossx, crossy = 150,150
    catch_in_last_frame = False
    catch_in_this_frame = False
    pygame.draw.rect(background, (200,200,200), ((0,0), (470,110)))
    pygame.draw.rect(background, (200,200,200), ((screen.get_width()-360, 
                     screen.get_height()-25), (360,25)))
    background.blit(write("control the rider with the cursor keys (Enter to stop)"),(10,10))
    background.blit(write("control the warrior with the mouse (left button to stop)"), (10,30))
    background.blit(write("the cross is always in the middle between rider and warrior"), (10,50))
    background.blit(write("the cage moves toward the cross"),(10,70))
    background.blit(write("catch the wolfrider with the cage to win points"),(10,90))
    screen.blit(background, (0,0))     # blit background on screen (overwriting all)
    clock = pygame.time.Clock()        # create pygame clock object 
    mainloop = True
    FPS = 60                     # desired max. framerate in frames per second.       
    playtime = 120.0              # seconds of playtime left
    points = 0.0
    gameOver = False
    gameOverSound = True
    while mainloop:
        milliseconds = clock.tick(FPS)  # milliseconds passed since last frame
        seconds = milliseconds / 1000.0 # seconds passed since last frame
        playtime -= seconds
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                mainloop = False # pygame window closed by user
            elif event.type == pygame.KEYDOWN:
                if event.key == pygame.K_ESCAPE:
                    mainloop = False # user pressed ESC
        pygame.display.set_caption("[FPS]: %.2f Snake: dx %i dy %i Bird:"
                                   " dx %i dy %i police: dx %.2f dy %.2f " % 
                                   (clock.get_fps(), snakedx, snakedy,
                                    birddx, birddy, policedx, policedy ))
        if playtime < 0:
            gameOver = True
        if gameOver:
            #background.fill((255,255,255)) # white b
            screen.blit(background,(0,0))
            if gameOverSound:
                over.play()
                gameOverSound = False # play the sound only once
            screen.blit(write("Game Over. %.2f points. Press ESCAPE" % points, (128,0,128), 64), (20,250))
        else:
            screen.blit(background, (0,0))  # not GameOver
            #-------- clean -----------
            #cleanblit(police, policex, policey)
            #cleanblit(bird, birdx, birdy)
            #cleanblit(snake, snakex, snakey)
            #cleanblit(cross, crossx, crossy)
            #cleanblit(thief, thiefx, thiefy)
            pygame.draw.rect(screen, (200,200,200), (screen.get_width()-360, 
                     screen.get_height()-25, 360,25))
            #cleanrect(policex, policey,crossx,crossy)
            #cleanrect(snakex, snakey, birdx, birdy)
            screen.blit(write("points: %.2f time left: %.2f seconds" % (points, playtime)), 
                       (screen.get_width()-350,screen.get_height()-20))
 
            # ----- compute movement ----
            # ---- mouse ---
            #(birdx, birdy) = pygame.mouse.get_pos()
            (mousex, mousey) = pygame.mouse.get_pos()
            if mousex < birdx:
                birddx -= 1
            elif mousex > birdx:
                birddx += 1
            if mousey < birdy:
                birddy -= 1
            elif mousey > birdy:
                birddy += 1
            if pygame.mouse.get_pressed()[0] == True:
                birddx = 0 # stop movement by mouseclick (left button)
                birddy = 0
            # ---- keyboard ------
            pressedkeys = pygame.key.get_pressed() # all keys that are pressed now
            if pressedkeys[pygame.K_a]:
                snakedx -= 2
            if pressedkeys[pygame.K_d]:
                snakedx += 2
            if pressedkeys[pygame.K_w]:
                snakedy -= 2
            if pressedkeys[pygame.K_s]:
                snakedy += 2
            if pressedkeys[pygame.K_RETURN]:
                snakedx = 0 # stop movement by pressing the 's' key
                snakedy = 0
            # ------------ AI ----------------
            crossx = min(birdx,snakex) + ( max(birdx, snakex) -  # cross is in the middle of bird and snake 
                     min(birdx,snakex)) / 2.0 -cross.get_width()/2
            crossy = min(birdy,snakey) + ( max(birdy, snakey) - 
                     min(birdy,snakey)) / 2.0 - cross.get_height()/2
            if crossx < policex:
                policedx -= 1        # police moves toward cross
            elif crossx > policex:
                policedx += 1
            if crossy > policey:
                policedy += 1
            elif crossy < policey:
                policedy -= 1
            thiefdx += random.randint( -erratic,erratic )  # thief is erratic
            thiefdy += random.randint( -erratic,erratic )
            thiefdx = max(thiefdx, -thiefmaxspeed)         # limit speed of thief
            thiefdx = min(thiefdx, thiefmaxspeed)
            thiefdy = max(thiefdy, -thiefmaxspeed)
            thiefdy = min(thiefdy, thiefmaxspeed)
            # ---- friction... sprites get slower ----
            policedx *= 0.995
            policedy *= 0.995
            snakedx *= 0.995
            snakedy *= 0.995
            birddx *= 0.995
            birddy *= 0.995
            # --------- new position -----------
            policex += policedx * seconds 
            policey += policedy * seconds
            birdx += birddx * seconds
            birdy += birddy * seconds
            snakex += snakedx * seconds
            snakey += snakedy * seconds
            thiefx += thiefdx * seconds
            thiefy += thiefdy * seconds
            # ----------- bounce ----------
            policex, policey, policedx, policedy = bounce(police, policex, policey, policedx, policedy)
            birdx, birdy, birddx, birddy = bounce(bird, birdx, birdy, birddx, birddy)
            snakex, snakey, snakedx, snakedy = bounce(snake, snakex, snakey, snakedx, snakedy)
            thiefx, thiefy, thiefdx, thiefdy = bounce(thief, thiefx, thiefy, thiefdx, thiefdy)
            # --- police got thief ? -----
            distx =  max(policex + police.get_width()/2 , thiefx + 
                     thief.get_width()/2) - min(policex + 
                     police.get_width()/2, thiefx + thief.get_width()/2)
            disty =  max(policey + police.get_height()/2 , thiefy + 
                     thief.get_height()/2) - min(policey + police.get_width()/2,
                     thiefy + thief.get_width()/2)
            catch_in_last_frame = catch_in_this_frame # save old catch info
            catch_in_this_frame = False
            if (distx < police.get_width() /2) and (disty < police.get_height()/2):
                catch_in_this_frame = True
                points += seconds
                screen.fill(randomcolour()) 
                if not pygame.mixer.get_busy():
                    spring.play() # only play this sound if mixer is silent at the moment
            else:
                # no catch this time
                if catch_in_last_frame:
                    screen.blit(background, (0,0)) # restore background
            # ---------- blit ----------------
            if birddx > 0:
                # bird (fussoldat) schaut nach rechts
                draw(bird, birdx, birdy)
            else:
                # bird schaut nach links
                draw(birdlinks, birdx, birdy)
            if thiefdx > 0:
                # bird (fussoldat) schaut nach rechts
                draw(thief, thiefx, thiefy)
            else:
                # bird schaut nach links
                draw(thieflinks, thiefx, thiefy)
            if snakedx>0 :  
                draw(snake, snakex, snakey)
            else:
                draw(snakelinks,snakex,snakey)
            pygame.draw.line(screen, randomcolour(), (snakex,snakey), (birdx, birdy), 1)
            pygame.draw.line(screen, randomcolour(), (crossx,crossy), (policex, policey) ,1)
            draw(police, policex, policey)
            draw(cross, crossx, crossy)
        pygame.display.flip()          # flip the screen FPS times a second                
# check if the program is imported. if not, start it directly
if __name__ == "__main__":
    play_the_game()

Marvin

Marvin Tauchner — Tue, 02 Mar 2010 14:58:41 +0100

Internet

Hallo ich bin der Marvin.

Ich bin 14 und gehe in die 5.Klasse

Kampfsimulator:

# -*- coding: utf-8 -*-
"""Das folgende ist ein kleiner Kampfsimulator"""
import random
import easygui
class Monster:
     def __init__(self,name="loretta", attack=50, defense=50, luck=20):
         self.name=name
         self.attack=attack
         self.defense=defense
         self.luck=luck
         self.leben=100
         self.kraft=10
 
zombie=Monster("zombie",50,10,5)
#print zombie.leben
vampir=Monster("vampir",25,25,25)
strelok=Monster("strelok",30,12,10)
armee_soldat=Monster("Armee-soldat",10,15,20)
geist=Monster("geist",5,50,5)
loretta=Monster("loretta",34,14,7)
banker=Monster("banker",30,10,0)
lorenz=Monster("lorenz",45,17,24)
altair=Monster("altair",50,24,38)
wahnsinniger=Monster("wahnsinniger",2,2,12)
 
monsterliste=[zombie,vampir,strelok,armee_soldat,geist,loretta,banker,lorenz,altair,wahnsinniger]
 
def schlag(angreifer, verteidiger):
    wuerfel1=random.randint(1,100)
    wuerfel2=random.randint(1,100)
    wuerfel3=random.randint(1,100)
    wuerfel4=random.randint(1,100)
    #print "wer schlägt zuerst?"
    if (angreifer.attack+wuerfel1)>(verteidiger.defense+wuerfel2):
    	# angreifer trifft
    	verteidiger.leben-=random.randint(1,angreifer.kraft)
    	print "%s greift %s an (%i+%i:%i+%i)" % (angreifer.name, verteidiger.name,
    	  angreifer.attack,wuerfel1, verteidiger.defense, wuerfel2)
    	print "der treffer war genial ! %s hat nur noch %i leben"  % (verteidiger.name,verteidiger.leben)
    else:
    	print "%s greift %s an (%i+%i:%i+%i)" % (angreifer.name, verteidiger.name,
    	  angreifer.attack,wuerfel1, verteidiger.defense, wuerfel2) 
        print " der angriff ging in den abendhimmel"
 
 
#altair vs. loretta
def kampf(angreifer, verteidiger):
 
	runde=0
	while angreifer.leben>0 and verteidiger.leben>0:
		runde+=1
		print "runde %d" % runde
		print "%s %d %s %d" % (angreifer.name, angreifer.leben, verteidiger.name, verteidiger.leben)
		print "angriff"
		schlag(angreifer,verteidiger)
		if angreifer.leben>0 and verteidiger.leben>0:
			print "gegenangriff"
			schlag(verteidiger,angreifer)
	if angreifer.leben > 0:
		sieger = angreifer.name
	else:
		sieger = verteidiger.name
	print " %s hat gesiegt"  % sieger
	return sieger
#print "angreifer %d verteidiger %d" % (angreifer.leben, verteidiger.leben)
 
#testen
ss=0
sb=0
for duell in range(1,101):
	sieger =  kampf(strelok, banker)
	print "-------------------------------------------------------------"
	print sieger
	print "-------------------------------------------------------------"
	strelok.leben=100
	banker.leben=100
	if sieger == "strelok":
		ss+=1
	else:
		sb+=1
print "strelok: banker",ss, sb

Fertiger großer Kampfsimulator

(hat ein paar Grammatik schwächen)

 
# -*- coding: utf-8 -*-
"""Das folgende ist ein kleiner Kampfsimulator
14:Waffen sollen in den Kämpfen eine Rolle spielen"""
 
import random
import easygui
class Waffe:
	def __init__(self, name="stock", attack=1, defense=1, kraft=0, leben=0, trefferdelta=0):
		self.name=name
		self.attack=attack
		self.defense=defense
		self.kraft=kraft
		self.deltaleben=leben
		self.trefferdelta=trefferdelta
 
class Monster:
     def __init__(self,name="loretta", attack=50, defense=50, kraft=50,  waffenliste=[]):
         self.name=name
         self.attack=attack
         self.defense=defense
         self.leben=100
         self.kraft=kraft
         #self.waffenliste=waffenliste
         self.waffe=waffendir[random.choice(waffenliste)]
         self.leben+=self.waffe.deltaleben
 
 
     def vorstellen(self):
         print "------------------------%s---------------------" % self.name
         print "ich bin unbewaffnet. Meine Werte: %i angriff %i defense und %i kraft" %(self.attack, self.defense, self.kraft)
         print "ich bin bewaffnet mit %s,  %i angriff %i defense und %i kraft" %(self.waffe.name, self.attack+self.waffe.attack, self.defense+self.waffe.defense, self.kraft+self.waffe.kraft)
 
 
 
 
waffendir = {}
waffendir["schwert"]=Waffe("einem schwert",-20,4,34,0) # -20, weil es beim angriff behindert
waffendir["schild"]=Waffe("einem schild",-24,50,2)
waffendir["aktenkoffer"]=Waffe("einem aktenkoffer",0,15,17,0)
waffendir["schuhbänder"]=Waffe("zwei schuhbändern",0,0,40,0)
waffendir["schlagring"]=Waffe("einem schlagring",0,1,26,0)
waffendir["englischbuch"]=Waffe("einem englischbuch",0,23,4,0)
waffendir["kainznerbiografie"]=Waffe("einer kainznerbiografie",-2,20,4,0)
waffendir["ast"]=Waffe("einem ast",0,1,2,0)
waffendir["flammenwerfer"]=Waffe("einem flammenwerfer",-34,2,45,0)
waffendir["maschinengewehr"]=Waffe("einem maschinengewehr",-15,1,50,0)
waffendir["bleistift"]=Waffe("einem bleistift",0,1,9,0)
waffendir["alter pc"]=Waffe("einem alten pc",-40,10,14,0)
waffendir["wasserpistole"]=Waffe("einer wasserpistole",-5,1,14,0)
waffendir["grabstein"]=Waffe("einem grabstein",-24,7,17,0)
waffendir["schaufel"]=Waffe("einer schaufel",-5,2,20,0)
waffendir["spitzer holzplock"]=Waffe("einem spitzen holzplock",0,1,23,0)
waffendir["vampirzähne"]=Waffe("vampirzähnen",0,0,29,0,5)
waffendir["titten"]=Waffe("titten",0,50,0,0)
waffendir["schwere handtasche"]=Waffe("einer schweren handtasche",3,11,19,0)
waffendir["lebende ratten"]=Waffe("lebenden ratten",-25,4,13,0) #-25, weil ratten schwer zu fangen sind... 
waffendir["dolch"]=Waffe("einem dolch",0,1,34,0)
waffendir["vergammeltes butterbrot"]=Waffe("einem vergammelten butterbrot",-24,45,3,0)
waffendir["alte spritzen"]=Waffe("alten spritzen",0,0,35,0)
waffendir["hässliche Cousinen"]=Waffe("hässlichen Cousinen",14,24,12,0)
waffendir["eigener fuß"]=Waffe("meinem fuß",-12,5,23,-10)
waffendir["verfluchte vampirzähne"]=Waffe("meinen verluchten vampirzähnen",0,0,30,0,-5)
 
 
 
 
 
zombie=Monster("zombie",5,25,45,["grabstein","schaufel","ast","eigener fuß"])
#print zombie.leben
vampir=Monster("vampir",25,25,25,["spitzer holzplock","vampirzähne","ast","verfluchte vampirzähne"])
#test monster
strelok=Monster("strelok",34,12,23,["maschinengewehr","flammenwerfer","ast"])
armee_soldat=Monster("Armee-soldat",17,15,16,["maschinengewehr","ast","schlagring"])
geist=Monster("geist",50,7,12,["ast","lebende ratten","schwert","schild"])  #schild und schwert ,weil der geist in einem schloss/burg wohnt
loretta=Monster("loretta",45,7,12,["ast","titten","schwere handtasche"])
#test monster
banker=Monster("banker",0,13,34,["ast","bleistift","alter pc","aktenkoffer","englischbuch"])
lorenz=Monster("lorenz",23,19,27,["ast","wasserpistole","kainznerbiografie","schlagring","schuhbänder"])
altair=Monster("altair",45,34,39,["ast","dolch","vergammeltes butterbrot"])
wahnsinniger=Monster("wahnsinniger",34,7,23,["ast","titten","vergammeltes butterbrot","bleistift","alter pc","aktenkoffer","schwert", "schild","wasserpistole","spitzer holzplock","dolch", "lebende ratten","schwere handtasche","schaufel","grabstein","maschinengewehr","flammenwerfer","kainznerbiografie","englischbuch","schuhbänder","schlagring","alte spritzen"])
alte_omi=Monster("alte omi",23,11,21,["ast","hässliche Cousinen"])
 
 
monsterliste=[zombie,vampir,strelok,armee_soldat,geist,loretta,banker,lorenz,altair,wahnsinniger,alte_omi]
 
def schlag(angreifer, verteidiger):
    wuerfel1=random.randint(1,100)
    wuerfel2=random.randint(1,100)
    wuerfel3=random.randint(1,100)
    wuerfel4=random.randint(1,100)
    #print "wer schlägt zuerst?"
    print "%s %d %s %d" % (angreifer.name, angreifer.leben, verteidiger.name, verteidiger.leben)
    print "%s greift %s an %i:%i (%i+%i:%i+%i)" % (angreifer.name, 
                                                  verteidiger.name,
                                                  angreifer.attack+angreifer.waffe.attack+wuerfel1,
                                                  verteidiger.defense+verteidiger.waffe.defense+wuerfel2,
                                                  angreifer.attack+angreifer.waffe.attack,wuerfel1,
                                                  verteidiger.defense+verteidiger.waffe.defense, wuerfel2)
    if (angreifer.attack+angreifer.waffe.attack+wuerfel1)>(verteidiger.defense+verteidiger.waffe.defense+wuerfel2):
     # angreifer trifft
     #verteidiger.leben-=random.randint(angreifer.kraft/4,angreifer.kraft)
     schaden=random.randint(1,angreifer.kraft)
     verteidiger.leben-=schaden
     if angreifer.waffe.trefferdelta >0:
         print "%s trinkt das Blut des Gengners und gewinnt %i Leben" % (angreifer.name,angreifer.waffe.trefferdelta)
         angreifer.leben+=angreifer.waffe.trefferdelta
     elif angreifer.waffe.trefferdelta<0:
        print "%s verletzt sich selber durch %s und verliert %i Leben" % (angreifer.name, angreifer.waffe.name, angreifer.waffe.trefferdelta)
        angreifer.leben+=angreifer.waffe.trefferdelta
     if schaden>angreifer.kraft * 0.75:
         wow="der treffer war genial!"
     elif schaden>angreifer.kraft * 0.50:
         wow="der war ordenlich, aber nicht herausragend"
     elif schaden>angreifer.kraft * 0.25:
         wow="der treffer war unter dem durchschnitt, vielleicht beim nächsten mal"
     elif schaden>angreifer.kraft * 0.10:
         wow="gerade noch getroffen"
     else:
         wow="schäm dich"
     print "%s %s verursacht %i schaden bei %s "  % (wow, angreifer.name, schaden,verteidiger.name)
    else:
     print "der angriff ging in den abendhimmel"
 
 
#altair vs. loretta
def kampf(angreifer, verteidiger):
     angreifer.vorstellen()
     verteidiger.vorstellen()
     print "---------------------------------------------------"
     runde=0
     while angreifer.leben>0 and verteidiger.leben>0 and runde<100:
          runde+=1
          print"==============---- Runde %i ----================" % runde
          print "angriff"
          schlag(angreifer,verteidiger)
          if angreifer.leben>0 and verteidiger.leben>0:
               print "gegenangriff"
               schlag(verteidiger,angreifer)
     if verteidiger.leben > 0:
          sieger = verteidiger.name
     else:
          sieger = angreifer.name
     print " %s hat gesiegt"  % sieger
     return sieger
#print "angreifer %d verteidiger %d" % (angreifer.leben, verteidiger.leben)
 
#testen
ss=0
sb=0
for duell in range(1,2):
     sieger =  kampf(zombie, vampir)
     print "-------------------------------------------------------------"
     print sieger
     print "-------------------------------------------------------------"
     zombie.leben=100
     vampir.leben=100
     if sieger == "zombie":
          ss+=1
     else:
          sb+=1
print "zombie: vampir",ss, sb
 
#jedes monster hat eine kleine gruppe,l aus möglichen waffen...zb banker mit kugelschreiber,lebender sekritärin aktenkoffer,...
#zombie wirft grabsteine oder seinen fuß...dass kostet aber leben,...

xturtle

 
import xturtle as xt
xt.bgcolor("black")
for marvin in range(101):
    xt.fd(12)
    xt.color("red")
    xt.fd(7)
    xt.color("blue")
    xt.left(87)
    xt.fd(marvin)
    xt.color("yellow")
xt.penup()
xt.home()
xt.fd(-151)
xt.pendown()
 
for marvin in range(201):
    xt.fd(8)
    xt.color("red")
    xt.fd(7)
    xt.penup()
    xt.right(100)
    xt.left(marvin)
    xt.pendown()
    xt.color("blue")

 
# -*- coding: utf-8 -*-
"""Das folgende ist ein kleiner Kampfsimulator
14:Waffen sollen in den Kämpfen eine Rolle spielen"""
 
import random
import easygui
class Waffe(object):
    def __init__(self, name="stock", speed=1, zielgenauigkeit=1 , kraft=1 , failrisk=0.9, feuerrate=10, munition=30 , defense=0, gruppe="primär"):
        self.name=name
        self.speed=speed
        self.zielgenauigkeit=zielgenauigkeit
        self.kraft=kraft
        self.failrisk=failrisk
        self.feuerrate=feuerrate
        self.munition=munition
        self.defense=defense
        self.gruppe=gruppe
 
 
 
class Monster(object):
     def __init__(self,name="loretta", speed=1, zielgenauigkeit=1, defense=1, ruestung=1, leben=100, waffe=""):
         self.name=name
         self.speed=speed
         self.zielgenauigkeit=zielgenauigkeit #fähigkeit des schützen
         self.defense=defense
         self.ruestung=ruestung
         self.leben=leben
         self.waffe=waffe
 
 
waffendir = {}
waffendir["P90"]=Waffe("p90",20, 15, 100, 0.5, 20, 30, 0, "primär")
waffendir["MP5"]=Waffe("mp5",20, 18, 100, 0.4,  15, 30, 0, "primär")
 
monolithsoldat=Monster("monolithsoldat",20, 20, 20, 5, 100,waffendir["P90"])
zombie=Monster("zombie",10, 10, 10, 5, 100,waffendir["MP5"])
 
def schusswechsel(x, y):
    wspeedx=random.randint(1,20)
    wspeedy=random.randint(1,20)
 
 
    runde=1
    print "%s greift %s an %i:%i (%i+%i+%i:%i+%i+%i)" % (x.name, y.name,
                                            x.speed+x.waffe.speed+wspeedx, y.speed+y.waffe.speed+wspeedy, x.speed, x.waffe.speed,wspeedx, 
                                       y.speed, y.waffe.speed, wspeedy)
    print "schlag"
    if x.speed+x.waffe.speed+wspeedx > y.speed+y.waffe.speed+wspeedy:
        kampfrunde (x,y) 
        if y.leben>0:
           print "gegenschlag"
           kampfrunde(y,x) 
    else:
        kampfrunde(y,x)
        if x.leben>0:
            print "gegenschlag"
            kampfrunde(x,y)
def kampfrunde(a,v):
    wzielgenauigkeita=random.randint(-10,10)
    wdefensev=random.randint(-10,10)
    #treffer?
    print "%s trifft %s %i:%i (%i+%i+%i:%i+%i+%i)" % (a.name, v.name, a.zielgenauigkeit+a.waffe.zielgenauigkeit+wzielgenauigkeita, v.defense+v.waffe.defense+wdefensev, 
                                                      a.zielgenauigkeit,a.waffe.zielgenauigkeit,wzielgenauigkeita, v.defense,v.waffe.defense,wdefensev)
 
    if a.zielgenauigkeit+a.waffe.zielgenauigkeit+wzielgenauigkeita >  v.defense+v.waffe.defense+wdefensev:
        print "treffer!"
    else:
        print "der schlag geht in den abendhimmel"
#los
schusswechsel(monolithsoldat,zombie)

 
# -*- coding: utf-8 -*-
 
"""Das folgende ist ein kleiner Kampfsimulator
14:Waffen sollen in den Kämpfen eine Rolle spielen"""
import Tkinter as t
import random
class Waffe(object):
    def __init__(self, name="stock", speed=1, zielgenauigkeit=1 , kraft=1 , failrisk=0.9, feuerrate=10, munition=30 , defense=0, gruppe="primär"):
        self.name=name
        self.speed=speed
        self.zielgenauigkeit=zielgenauigkeit
        self.kraft=kraft
        self.failrisk=failrisk
        self.feuerrate=feuerrate
        self.munition=munition
        self.defense=defense
        self.gruppe=gruppe
 
 
 
class Monster(object):
     def __init__(self,name="loretta", speed=1, zielgenauigkeit=1, defense=1, ruestung=1, leben=100, waffe=""):
         self.name=name
         self.speed=speed
         self.zielgenauigkeit=zielgenauigkeit #fähigkeit des schützen
         self.defense=defense
         self.ruestung=ruestung
         self.leben=leben
         self.waffe=waffe
 
 
waffendir = {}
waffendir["P90"]=Waffe("p90",20, 15, 100, 0.5, 20, 30, 0, "primär")
waffendir["MP5"]=Waffe("mp5",20, 18, 100, 0.4,  15, 30, 0, "primär")
 
monolithsoldat=Monster("monolithsoldat",20, 20, 20, 5, 100,waffendir["P90"])
zombie=Monster("zombie",10, 10, 10, 5, 100,waffendir["MP5"])
 
def schusswechsel(x, y):
    output=""
    wspeedx=random.randint(1,20)
    wspeedy=random.randint(1,20)
 
 
    zeile= "%s greift %s an %i:%i (%i+%i+%i:%i+%i+%i) \n" % (x.name, y.name,
                                            x.speed+x.waffe.speed+wspeedx, y.speed+y.waffe.speed+wspeedy, x.speed, x.waffe.speed,wspeedx, 
                                       y.speed, y.waffe.speed, wspeedy)
    #print zeile                                
    output += zeile                            
    output+= "angriff \n"
    if x.speed+x.waffe.speed+wspeedx > y.speed+y.waffe.speed+wspeedy:
        output+= kampfrunde (x,y) 
        if y.leben>0:
           output+= "gegenangriff"
           output+=kampfrunde(y,x) 
    else:
        output+=kampfrunde(y,x)
        if x.leben>0:
            output+= "gegenangriff"
    print output
    return output       
def kampfrunde(a,v):
    output=""
    wzielgenauigkeita=random.randint(-10,10)
    wdefensev=random.randint(-10,10)
    wvolltreffer=random.random()
    #treffer?
 
    zeile = "%s trifft %s %i:%i (%i+%i+%i:%i+%i+%i) \n" % (a.name, v.name, a.zielgenauigkeit+a.waffe.zielgenauigkeit+wzielgenauigkeita, v.defense+v.waffe.defense+wdefensev, 
                                                      a.zielgenauigkeit,a.waffe.zielgenauigkeit,wzielgenauigkeita, v.defense,v.waffe.defense,wdefensev)
 
    output += zeile
    if a.zielgenauigkeit+a.waffe.zielgenauigkeit+wzielgenauigkeita >  v.defense+v.waffe.defense+wdefensev:
        output+= "treffer! \n"
        impact=random.random()#*a.waffe.kraft)
        zeile= "impact: %f x kraft: %i = %i \n" % (impact, a.waffe.kraft, impact * a.waffe.kraft)
        output+=zeile
        impact =int(impact* a.waffe.kraft )
        schaden=impact- v.ruestung
        if schaden>0:
            zeile= "%s verursacht %i schaden \n" % (a.name, schaden)
            output+=zeile
            v.leben-=schaden
            output+= "so viel leben ist noch übrig: %i \n" % v.leben
        else:
            output+= " dein gegener war zu stark, haha...."
 
    else:
        output+= "der schlag geht in den abendhimmel"
    return output
 
 
# jetz gehts wirklich los
 
#gefecht(monolithsoldat, zombie)
 
spieler=monolithsoldat
 
 
def einerunde(angreifer, verteidiger):
    angreifer.leben, verteidiger.leben=kampf(angreifer, verteidiger)
 
 
def lol():
    #print"karte, etc."
    text1.set("karte")
    text2.set("medkit")
    text3.set("stein")
    text4.set("ast")
    text5.set("p90")
 
def hallo():
    #print "P90"
    #meldung.set("leben")
    pass
 
def hey():
    kampfbericht=schusswechsel(zombie, spieler)
 
def ad():
    #print"medkit"
    #meldung.set("arsch")
    pass
 
def flucht():
    pass
 
def tolles_inventar():
    inventar=["tux","fenster","appfel","fux","cod","portal"] 
 
def mies_inventar():
    inventar1=["lalala","asdasdad","st.lorenz_strom","chicago"]
 
root=t.Tk()
#meldung=t.StringVar()
#meldung.set("hallo")
gegner=zombie
statuslinks=t.StringVar()
statusrechts=t.StringVar()
kampfbericht=t.StringVar()
statuslinks.set("Status: SPD: %i DEF: %i KRT: %i HP: %i\n Waffe: %s" %(spieler.speed, spieler.defense, spieler.waffe.kraft, spieler.leben, spieler.waffe.name))
statusrechts.set("Status: SPD: %i DEF: %i KRT: %i HP: %i\n Waffe: %s" %(gegner.speed, gegner.defense, gegner.waffe.kraft, gegner.leben, gegner.waffe.name))
 
 
kampfbericht.set("")
t.Label(root, text="Ich vs. Zombie", borderwidth=1).grid(row=0,column=0, columnspan=5)
t.Label(root, textvariable=statuslinks, borderwidth=1).grid(row=1,column=0, columnspan=2)
t.Label(root, textvariable=statusrechts, borderwidth=1).grid(row=1, column=3, columnspan=2)
marvin= t.PhotoImage(file="marvin1.gif")
t.Label(root, image=marvin).grid(row=2, column=0, rowspan=5 ,columnspan=2)
marvin1= t.PhotoImage(file="marvin2.gif")
t.Label(root, image=marvin1).grid(row=2, column=3, rowspan=5, columnspan=2)
t.Button(root, text="Inventar", command=lol).grid(row=2, column=2)
t.Button(root, text="Waffe wechseln", command=hallo).grid(row=3, column=2)
t.Button(root, text="Angreiffen", command=hey).grid(row=4, column=2)
t.Button(root, text="Flüchten", command=flucht).grid(row=5, column=2)
t.Button(root, text="Medkit", command=ad).grid(row=6, column=2)
text1=t.StringVar()
text2=t.StringVar()
text3=t.StringVar()
text4=t.StringVar()
text5=t.StringVar()
t.Button(root, textvariable=text1).grid(row=7, column=0)
t.Button(root, textvariable=text2).grid(row=7, column=1)
t.Button(root, textvariable=text3).grid(row=7, column=2)
t.Button(root, textvariable=text4).grid(row=7, column=3)
t.Button(root, textvariable=text5).grid(row=7, column=4)
t.Label(root, textvariable=kampfbericht).grid(row=8, column=0, columnspan=5)
root.mainloop()

marvin200909.zip

marvin_blut_und_morde.zip

Markus Hauser

Horst JENS — Fri, 26 Feb 2010 20:12:23 +0100

Byte of Python lesen: http://www.swaroopch.com/notes/Python

Pygame gibt's hier: http://pygame.org/

schweifdemo

schweifdemo.py

# -*- coding: utf-8 -*-
"""wizard duell
by markus, mira, raphael and theresa.
 
"""
import pygame
import random
import os
print pygame.ver 
 
def megaultrasuperfatdef(humanplayers=1,datadir="data"):
 
    HITPOINTS = 100.0
    FORCE_OF_GRAVITY = 10 # in pixel per second² .See http://en.wikipedia.org/wiki/Gravitational_acceleration
 
 
    def write(msg="pygame is cool"):
        """write text into pygame surfaces"""
        myfont = pygame.font.SysFont("None", 100)
        mytext = myfont.render(msg, True, (0,0,0))
        mytext = mytext.convert_alpha()
        return mytext
 
    def neudelta():
        return random.randint(1, 20)
 
    def farbcheck(farbe, delta):
        if farbe > 255:
            farbe=255
            delta*=-1
        if farbe < 0:
            farbe=0
            delta = neudelta()
        return farbe,delta
    class dummysound:
        def play(self): pass
 
    def load_sound(file):
        if not pygame.mixer: 
            return dummysound()
        file = os.path.join(datadir, file)
        try:
            sound = pygame.mixer.Sound(file)
            return sound
        except pygame.error:
            print ("Warning, unable to load,", file)
 
        return dummysound()
    pygame.mixer.pre_init(44100,-16,2,2048)
    pygame.init()
    PEACEZEIT = .5
    if pygame.mixer and not pygame.mixer.get_init():
            print ('Warning, no sound')
            pygame.mixer = None
    #load the sound effects
    bump = load_sound('bump.ogg')
    tock = load_sound('tock.ogg')
    winna = load_sound('winner.ogg')
    if pygame.mixer:
            music = os.path.join(datadir,'an-turr.ogg')
            pygame.mixer.music.load(music)
            pygame.mixer.music.play(-1)
 
 
 
    class Hirni(pygame.sprite.Sprite):
        hirnis = {}
        number = 0
        def __init__(self,spieler,pos,links=pygame.K_LEFT,rechts=pygame.K_RIGHT,
                     unten=pygame.K_DOWN,oben=pygame.K_UP):
            pygame.sprite.Sprite.__init__(self, self.groups)
            #print "Hirni  startet"
            self.pos=pos
            self.links=links
            self.rechts=rechts
            self.unten=unten
            self.oben=oben
            self.spieler=spieler
            self.rot = random.randint(10,200)
            self.gruen = random.randint(10,200)
            self.blau = random.randint(10,200)
            self.peacezeit = 0
            self.deltarot = random.randint(1,20)
            self.deltagruen = random.randint(1,20)
            self.deltablau = random.randint(1,20)
 
            self.image=pygame.Surface((50,50))
            self.farbwechsel()
 
            self.hitpointsfull = HITPOINTS # maximal hitpoints
            self.hitpoints = HITPOINTS # actual hitpoints
            self.image.set_colorkey((0,0,0))
            self.image=self.image.convert_alpha()
            self.rect=self.image.get_rect()
            self.rect.center=pos
            self.dx = 0.0
            self.dy = 0.0
            self.x = self.pos[0] + 0.0
            self.y = self.pos[1] + 0.0
 
            self.number = Hirni.number # get my personal Birdnumber
            Hirni.number+= 1           # increase the number for next Bird
            Hirni.hirnis[self.number] = self
            #Livebar(self) #create a Livebar for him.
            self.catched = False
            self.crashing = False
 
 
        def kill(self):
            """because i want to do some special effects (sound, directory etc.)
            before killing the Bird sprite i have to write my own kill(self)
            function and finally call pygame.sprite.Sprite.kill(self) 
            to do the 'real' killing"""
            tock.play()
            winna.play()
            #print Bird.birds, "..."
            for _ in range(random.randint(100,200)):
                Fragment((self.x,self.y),2)
            Hirni.hirnis[self.number] = None # kill Bird in sprite Directory
            pygame.sprite.Sprite.kill(self)
 
        def farbwechsel(self):
            self.rot += self.deltarot
            self.gruen += self.deltagruen
            self.blau += self.deltablau
 
            self.rot, self.deltarot = farbcheck(self.rot, self.deltarot)
            self.gruen, self.deltagruen = farbcheck(self.gruen, self.deltagruen)
            self.blau, self.deltablau = farbcheck(self.blau, self.deltablau)
 
            #pygame.draw.circle(self.image,(self.rot,self.gruen,self.blau),
            #                   (25,25),25)
            pygame.draw.circle(self.image,
                               (self.rot,self.gruen,self.blau),
                               (25,25),10)
            self.image=self.image.convert_alpha()
 
        def cleanstatus(self):
            self.catched = False
            self.crashing = False
 
        def update(self,seconds):
 
            #print "hirni updated sich und startet einen schweif"
            Schweif(self.pos,(self.rot,self.gruen,self.blau), self.deltarot, self.deltagruen, self.deltablau)
 
            self.farbwechsel()
            tasten  = pygame.key.get_pressed()
            if self.peacezeit > 0:
                self.peacezeit-=seconds
            else:
                self.peacezeit=0
            if self.spieler == "human":
                #sorry for bad code
                if tasten[self.links]:
                    self.dx -= 1
                if tasten[self.rechts]:
                    self.dx += 1
                if tasten[self.oben]:
                    self.dy -= 1
                if tasten[self.unten]:
                    self.dy += 1
 
            self.dx *= 0.995 # bremsen
            self.dy *= 0.995
 
            if self.dx > 500:
                self.dx = 500
            elif self.dx < -500:
                self.dx = -500
 
            if self.dy > 500:
                self.dy = 500
            elif self.dy < -500:
                self.dy = -500
 
 
 
            self.x += self.dx * seconds
            self.y += self.dy * seconds
 
            if self.x - self.rect.width/2 < 0:
                self.x = 0 + self.rect.width/2
                self.dx *= -1
                tock.play()
            elif self.x + self.rect.width/2 > screen.get_width():
                self.x = screen.get_width() - self.rect.width/2
                self.dx *= -1
                tock.play()
            if self.y - self.rect.height/2 < 0:
                self.y = 0 + self.rect.height/2
                self.dy *= -1
                tock.play()
            elif self.y + self.rect.height/2 > screen.get_height():
                self.y = screen.get_height() - self.rect.height/2
                self.dy *= -1
                tock.play()
 
            self.pos = (self.x, self.y)
            self.rect.centerx = round(self.x, 0)
            self.rect.centery = round(self.y, 0)
 
            #--- loose hitpoins
            if self.crashing:
                self.hitpoints -=1
            #--- check if still alive
            if self.hitpoints <= 0:
                if self.number==0:
                    # findet raus ob der zauberer oder der player gestorben ist.
                    screen.blit(write("WTF!"),(150,10))
                    background.blit(write("wtf!"),(150,10))
                    screen.blit(write("You lose!"),(300,60))
                    background.blit(write("You lose!"),(300,60))
                    self.kill()
                else:
                    # findet raus ob der zauberer oder der player gestorben ist.
                    screen.blit(write("WTF!"),(150,10))
                    background.blit(write("wtf!"),(150,10))
                    screen.blit(write("You win!"),(350,60))
                    background.blit(write("You win!"),(350,60))
                    self.kill()
 
    class Schweif(pygame.sprite.Sprite):
        """ist völlig unnötig"""
        def __init__(self,pos,farbe, deltarot, deltagruen, deltablau):
            pygame.sprite.Sprite.__init__(self,self.groups)
            self.image = pygame.Surface((25,25))
            self.image.set_colorkey((0,0,0))
            pygame.draw.circle(self.image,farbe,(12,12),10)
            self.rect = self.image.get_rect()
            self.time=0
            self.pos=pos
            self.farbe = farbe
            self.rot = self.farbe[0]
            self.gruen = self.farbe[1]
            self.blau = self.farbe[2]
            self.deltarot = deltarot
            self.deltagruen = deltagruen
            self.deltablau = deltablau
            self.rect.centerx = round(self.pos[0],0)
            self.rect.centery = round(self.pos[1],0) 
            self.schweiftime = 3# länge vom Schweif in sekunden
 
 
        def update(self, time):
            self.time+=time
            if self.time >= self.schweiftime:
                self.kill()
 
 
    class Mine(pygame.sprite.Sprite):
        """liegt rum und macht bumm"""
        images = []
        images.append(pygame.image.load(os.path.join(datadir,"mine1.png")))
        images.append(pygame.image.load(os.path.join(datadir,"mine2.png")))
 
        def __init__(self,pos,bombenleger):
            pygame.sprite.Sprite.__init__(self,self.groups)
            self.image = Mine.images[0]
            self.rect = self.image.get_rect()
            self.bombenleger = bombenleger
            self.pos = pos
            self.rect.center = self.pos
            self.time = 0
            #self.lebendig = True
        def update(self, time):
            self.time += time
            self.image = Mine.images[int(self.time % 2)]
            #if self.time > 5:
            #    self.kill()
        def kill(self):
            """because i want to do some special effects (sound, directory etc.)
            before killing the mine sprite i have to write my own kill(self)
            function and finally call pygame.sprite.Sprite.kill(self) 
            to do the 'real' killing"""
            bump.play()
            #print Bird.birds, "..."
            for _ in range(random.randint(3,100)):
                Fragment(self.pos)
            #Bird.birds[self.number] = None # kill mine in sprite Directory
            pygame.sprite.Sprite.kill(self) # kill the actual mine
 
    class Fragment(pygame.sprite.Sprite):
        """a fragment of an exploding Bird"""
        gravity = True # fragments fall down ?
        def __init__(self, pos, style=1):
            pygame.sprite.Sprite.__init__(self, self.groups)
            self.pos = [0.0,0.0]
            self.pos[0] = pos[0]
            self.pos[1] = pos[1]
            self.style=style
            self.image = pygame.Surface((50,50))
            self.image.set_colorkey((0,0,0)) # black transparent
            if style == 2:
                pygame.draw.circle(self.image, (random.randint(0,255),random.randint(0,255),random.randint(0,255)),
                                                (25,25), 
                                                random.randint(0,45))
            else:
                pygame.draw.circle(self.image, (random.randint(100,150),122,255),
                                                (25,25), 
                                                random.randint(0,15))
            self.image = self.image.convert_alpha()
            self.rect = self.image.get_rect()
            self.lifetime = 1 + random.random()*5 # max 6 seconds
            self.time = 0.0
            self.fragmentmaxspeed = 523 # try out other factors !
            self.dx = random.randint(-self.fragmentmaxspeed,self.fragmentmaxspeed)
            self.dy = random.randint(-self.fragmentmaxspeed,self.fragmentmaxspeed)
 
        def update(self, seconds):
            self.time += seconds
            if self.time > self.lifetime:
                self.kill() 
            self.pos[0] += self.dx * seconds
            self.pos[1] += self.dy * seconds
            if Fragment.gravity:
                self.dy += FORCE_OF_GRAVITY # gravity suck fragments down
            self.rect.centerx = round(self.pos[0],0)
            self.rect.centery = round(self.pos[1],0)
 
    class Livebar(pygame.sprite.Sprite):
        """shows a bar with the hitpoints of a ball sprite"""
        def __init__(self, boss):
            pygame.sprite.Sprite.__init__(self,self.groups)
            self.boss = boss
            self.image = pygame.Surface((self.boss.rect.width,7))
            self.image.set_colorkey((0,0,0)) # black transparent
            pygame.draw.rect(self.image, (0,255,0), (0,0,self.boss.rect.width,7),1)
            self.rect = self.image.get_rect()
            self.oldpercent = 0
            self.bossnumber = self.boss.number
 
        def update(self, time):
            self.percent = self.boss.hitpoints / self.boss.hitpointsfull * 1.0
            if self.percent != self.oldpercent:
                pygame.draw.rect(self.image, (0,0,0), (1,1,self.boss.rect.width-2,5)) # fill black
                pygame.draw.rect(self.image, (0,255,0), (1,1,
                    int(self.boss.rect.width * self.percent),5),0) # fill green
            self.oldpercent = self.percent
            self.rect.centerx = self.boss.rect.centerx
            self.rect.centery = self.boss.rect.centery - self.boss.rect.height /2 - 10
            #check if boss is still alive
            if not Hirni.hirnis[self.bossnumber]:
                self.kill() # kill the hitbar
 
 
    #breite=640
    #hoehe=480
    screen=pygame.display.set_mode((0,0)) # try out larger values and see what happens !
    background = pygame.Surface(screen.get_size())
    rot=random.randint(0,255)
    gruen=random.randint(0,255)
    blau=random.randint(0,255)
    background.fill((rot,gruen,blau))     #fill the background white (red,green,blue)
    #pygame.draw.circle(background, (50,50,0), (300,250), 200) # draw a circle on the background
    #pygame.draw.circle(background, (255,255,255), (300,250), 150)
    background = background.convert()
    screen.blit(background,(0,0))
    deltarot = neudelta()
    deltagruen = neudelta()
    deltablau = neudelta()
    clock = pygame.time.Clock()
    mainloop = True
    FPS = 60 # desired framerate in frames per second.
 
    hirnigruppe=pygame.sprite.Group()
    minengruppe = pygame.sprite.Group()
    fragmentgruppe = pygame.sprite.Group()
    livebargruppe = pygame.sprite.Group()
    schweifgroup = pygame.sprite.Group()
    allgroup = pygame.sprite.LayeredUpdates()
    #hirn1=Hirni((random.randint(0,640),random.randint(0,480)))
    Hirni.groups = allgroup, hirnigruppe
    Schweif.groups = allgroup, schweifgroup
    Mine.groups = minengruppe, allgroup
    Fragment.groups = fragmentgruppe, allgroup
    Livebar.groups = livebargruppe, allgroup
 
    Hirni._layer = 2
    print "start hirn1"
    hirn1 = Hirni("human",(50,55))
    if humanplayers ==2:
        hirn2 = Hirni("human",(590,430), pygame.K_a,pygame.K_d,pygame.K_s,pygame.K_w)
    else:
        hirn2 = Hirni("AI",(590,430))
    hirn3 = Hirni("AI",(200,430))
    hirn4 = Hirni("AI",(200,430))
    gameover = False
    overtime = 9.3
    #hirnigruppe.add(hirn1,hirn2,hirn3,hirn4)
 
    while mainloop:
        # do all this each frame
        milliseconds = clock.tick(FPS)  # milliseconds passed since last frame
        seconds = milliseconds / 1000.0 # seconds passed since last frame
        if gameover:
            overtime -= seconds
            if overtime < 0:
                mainloop = False
 
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                mainloop = False # pygame window closed by user
            elif event.type == pygame.KEYDOWN:
                if event.key == pygame.K_ESCAPE:
                    mainloop = False # user pressed ESC
                #if event.key == pygame.K_SPACE:
                    #loesch()
                    #background.fill((rot,gruen,blau))     #fill the background white (red,green,blue)
                    #screen.blit(background,(0,0))
                #if event.key == pygame.K_LCTRL:
                    #if hirn2.peacezeit==0:
                        #Mine(hirn2.rect.center,2)
                        #hirn2.peacezeit=PEACEZEIT
                #if event.key == pygame.K_RCTRL:
                    #if hirn1.peacezeit==0:
                        #Mine(hirn1.rect.center,1)
                        #hirn1.peacezeit=PEACEZEIT
 
                        #print("Habe Mine gelegt, und bin ein cooles Kind!")
 
        tasten  = pygame.key.get_pressed()
        if hirn2.peacezeit==0:
            if hirn2.spieler == "human":
                if tasten[pygame.K_LCTRL]:
                    Mine(hirn2.rect.center, 2)
            else:
                #Mine(hirn2.rect.center,2)
                pass
            hirn2.peacezeit=PEACEZEIT
        if tasten[pygame.K_RCTRL]:
            if hirn1.peacezeit==0:
                Mine(hirn1.rect.center,1)
                hirn1.peacezeit=PEACEZEIT
        rot+=deltarot
        gruen+=deltagruen
        blau+=deltablau
        if len(hirnigruppe) < 2:
            gameover = True
        if hirn2.spieler == "AI":
            if hirn2.x < hirn1.x:
                hirn2.dx += 10
            if hirn2.x > hirn1.x:
                hirn2.dx -= 10
            if hirn2.y < hirn1.y:
                hirn2.dy += 10
            if hirn2.y > hirn1.y:
                hirn2.dy -= 10
 
        if hirn3.spieler == "AI":
            if hirn3.x < hirn2.x:
                hirn3.dx += 5
            if hirn3.x > hirn2.x:
                hirn3.dx -= 5
            if hirn3.y < hirn2.y:
                hirn3.dy += 5
            if hirn3.y > hirn2.y:
                hirn3.dy -= 5
 
        if hirn4.spieler == "AI":
            if hirn4.x < hirn3.x:
                hirn4.dx += 5
            if hirn4.x > hirn3.x:
                hirn4.dx -= 5
            if hirn4.y < hirn3.y:
                hirn4.dy += 5
            if hirn4.y > hirn3.y:
                hirn4.dy -= 5
 
        rot,deltarot=farbcheck(rot,deltarot)
        gruen,deltagruen=farbcheck(gruen,deltagruen)
        blau,deltablau=farbcheck(blau,deltablau)
        #background.fill((rot,gruen,blau))     #fill the background white (red,green,blue)
        #screen.blit(background,(0,0))
 
        pygame.display.set_caption("fps %.2f dx %.2f" % (clock.get_fps(), hirn1.dx))
        # only blit the part of the background where the ball was (cleanrect)
        #cleanrect = background.subsurface((ballx, bally, ball.get_width(), ball.get_height()))
        #screen.blit(cleanrect, (ballx, bally)) # comment out this line for a funny effect !
        #calculate new center of ball
        # time based movement. No matter how busy the cpu and how low the framerate,
        # movement speed will always be constant.
 
        #hirnigruppe.clear(screen,background)
        crashgroup = pygame.sprite.spritecollide(hirn1, minengruppe, False)
        for crash in crashgroup:
            if crash.bombenleger == 1:
                print("Ich bin auf eigene Mine gestiegen, und bin ein cooles Kind!")
            else:
                print("Ich bin auf fremde Mine getreten, und bin ein cooles Kind!")
                hirn1.hitpoints -= 10
                crash.kill()
 
        megacrashgroup = pygame.sprite.spritecollide(hirn1, hirnigruppe, False)
        for megacrash in megacrashgroup:
            if megacrash.number == 0:
                pass
            else:
                megacrash.dx *= -1
                megacrash.dy *= -1
 
        crashgroup2 = pygame.sprite.spritecollide(hirn2, minengruppe, False)
        for crash in crashgroup2:
            if crash.bombenleger == 2:
                print("Ich bin auf eigene Mine gestiegen, und bin ein cooles Kind!")
            else:
                print("Ich bin auf fremde Mine getreten, und bin ein cooles Kind!")
                hirn2.hitpoints -= 10
                crash.kill()
 
        #pygame.sprite.groupcollide(group1, group2, dokill1, dokill2): return Sprite_dict
        #crashgroup = pygame.sprite.groupcollide(hirnigruppe, minengruppe, False, True)
        #minengruppe.clear(screen, background)
        #fragmentgruppe.clear(screen, background)
        #fragmentgruppe.update(seconds)
        #livebargruppe.clear(screen,background)
        #minengruppe.update(seconds)
        #hirnigruppe.update(seconds)
        #livebargruppe.update(seconds)
        #minengruppe.draw(screen)
        #hirnigruppe.draw(background)
        #hirnigruppe.draw(screen)    
        #fragmentgruppe.draw(screen)
        #livebargruppe.draw(screen)
         # ----------- clear, draw , update, flip -----------------  
        allgroup.clear(screen, background)
        #print seconds
        allgroup.update(seconds)
        allgroup.draw(screen)           
        #pygame.display.flip() 
        pygame.display.flip()          # flip the screen 30 times a second
 
if __name__ == "__main__":
    megaultrasuperfatdef()
    pygame.quit()

DER HIRNSCHONER

Download:hirnschoner.zip

Hirnschoner 2:hirni.zip Musik von: http://modarchive.org/index.php?request=view_by_moduleid&query=33502

Nie wieder Aspirin kaufen! Der Hirnschoner hilft bei akuten Kopfschmerzen oder Stress viel besser. Gebrauchsanleitung: Bei plötzlichem Stress, oder Kopfschmerzen alle Arbeit liegen lassen, und Hirnschoner starten! Einfach zugucken und entspannen. Und für alle die mitmachen wollen, kann man den Ball mit W,A,S und D, das Quadrat mit den Pfeiltasten steuern. Selbstverständluch kann man auch alles mit der Maus steuern.

Achtung! Der Hirnschoner enthält viele Farbeffekte, die unter Dauereinwirkung den Nutzer hypnotisieren können. Setzen sie den Hirnschoner deshalb nicht länger als 25 Stunden am Tag ein.

Code

# -*- coding: utf-8 -*-
"""bouncing ball
markus hauser 2009
 
"""
import pygame
import random
import os
 
def neudelta():
    return random.randint(1, 20)
def loesch():
    screen.blit(background, (0, 0))
def farbcheck(farbe, delta):
    if farbe > 255:
        farbe=255
        delta*=-1
    if farbe < 0:
        farbe=0
        delta = neudelta()
    return farbe,delta
class dummysound:
    def play(self): pass
 
def load_sound(file):
    if not pygame.mixer: 
        return dummysound()
    file = os.path.join('data', file)
    try:
        sound = pygame.mixer.Sound(file)
        return sound
    except pygame.error:
        print ("Warning, unable to load,", file)
    return dummysound()
pygame.init()
if pygame.mixer and not pygame.mixer.get_init():
        print ('Warning, no sound')
        pygame.mixer = None
#load the sound effects
bump = load_sound('bump.ogg')
tock = load_sound('tock.ogg')
#if pygame.mixer:
        #music = os.path.join('data', 'house_lo.wav')
        #pygame.mixer.music.load(music)
        #pygame.mixer.music.play(-1)
 
breite=640
hoehe=480
screen=pygame.display.set_mode((breite,hoehe)) # try out larger values and see what happens !
background = pygame.Surface(screen.get_size())
background.fill((255,255,255))     #fill the background white (red,green,blue)
#pygame.draw.circle(background, (50,50,0), (300,250), 200) # draw a circle on the background
#pygame.draw.circle(background, (255,255,255), (300,250), 150)
background = background.convert()
ball = pygame.Surface((50,50))     #create a new surface
ball.set_colorkey((0,0,0))         #make black the transparent color (red,green,blue)
quadrat = pygame.Surface((50,50))
quadratx=100
quadraty=100
#pygame.draw.circle(Surface, color, pos, radius, width=0): return Rect
breite = 1 #linienbreite
ballrot=55
ballgruen=200
ballblau=0
quadratrot=0
quadratgruen=30
quadratblau=200
deltarot = neudelta()
deltagruen = neudelta()
deltablau = neudelta()
quadratdeltarot = neudelta()
quadratdeltagruen = neudelta()
quadratdeltablau = neudelta()
pygame.draw.circle(ball, (ballrot,ballgruen,ballblau), (25,25),25) # paint blue circle
ball = ball.convert()
ballx = 550
bally = 240
dx = 60 # pixel per second ! ball
dy = 60 # pixel per second ! ball
qx = 0 # quadrat
qy = 0 #quadrat
screen.blit(background, (0,0))     #draw background on screen (overwriting all)
screen.blit(ball, (ballx, bally))  #draw the ball shape
clock = pygame.time.Clock()
mainloop = True
FPS = 60 # desired framerate in frames per second.
dist=0
distx=0
disty=0
while mainloop:
    # do all this each frame
    milliseconds = clock.tick(FPS)  # milliseconds passed since last frame
    seconds = milliseconds / 1000.0 # seconds passed since last frame
    clock.tick(FPS) # do not go faster than this framerate
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            mainloop = False # pygame window closed by user
        elif event.type == pygame.KEYDOWN:
            if event.key == pygame.K_ESCAPE:
                mainloop = False # user pressed ESC
            if event.key == pygame.K_SPACE:
                loesch()
    # mausbewegung
    if pygame.mouse.get_pressed()[0] == 1:
        if pygame.mouse.get_pos()[0] < ballx:
            dx-=30
        elif pygame.mouse.get_pos()[0] > ballx:
            dx+=30
        if pygame.mouse.get_pos()[1] < bally:
            dy-=30
        elif pygame.mouse.get_pos()[1] > bally:
            dy+=30
    if pygame.mouse.get_pressed()[2] == 1:
        if pygame.mouse.get_pos()[0] < quadratx:
            qx-=30
        elif pygame.mouse.get_pos()[0] > quadratx:
            qx+=30
        if pygame.mouse.get_pos()[1] < quadraty:
            qy-=30
        elif pygame.mouse.get_pos()[1] > quadraty:
            qy+=30
 
    if quadratx < ballx:
        dx-=40
    elif quadratx > ballx:
        dx+=40
    if quadraty < bally:
        dy-=40
    elif quadraty > bally:
        dy+=40
 
    if ballx < quadratx:
        qx-=40
    elif ballx > quadratx:
        qx+=40
    if bally < quadraty:
        qy-=40
    elif bally > quadraty:
        qy+=40
 
    pygame.display.set_caption("Press Space to clean. %.2f frames per second" % clock.get_fps())
    # only blit the part of the background where the ball was (cleanrect)
    #cleanrect = background.subsurface((ballx, bally, ball.get_width(), ball.get_height()))
    #screen.blit(cleanrect, (ballx, bally)) # comment out this line for a funny effect !
    #calculate new center of ball
    # time based movement. No matter how busy the cpu and how low the framerate,
    # movement speed will always be constant.
    ballx += dx * seconds
    ballx = round(ballx,0)
    bally += dy * seconds
    bally = round(bally,0)
 
    quadratx += qx * seconds
    quadratx = round(quadratx,0)
    quadraty += qy * seconds
    quadraty = round(quadraty,0)
    # bounce ball if out of screen
    if ballx < 0:
        ballx = 0
        dx *= -1
        #tock.play()
    elif ballx + ball.get_width() > screen.get_width():
        ballx = screen.get_width() - ball.get_width()
        dx *= -1
        #tock.play()
    if bally < 0:
        bally = 0
        dy *= -1
        #tock.play()
    elif bally + ball.get_height() > screen.get_height():
        bally = screen.get_height() - ball.get_height()
        dy *= -1
        #tock.play()
 
    if quadratx < 0:
        quadratx = 0
        qx *= -1
        #tock.play()
    elif quadratx + quadrat.get_width() > screen.get_width():
        quadratx = screen.get_width() - quadrat.get_width()
        qx *= -1
        #tock.play()
    if quadraty < 0:
        quadraty = 0
        qy *= -1
        #tock.play()
    elif quadraty + quadrat.get_height() > screen.get_height():
        quadraty = screen.get_height() - quadrat.get_height()
        qy *= -1
        #tock.play()
    # speed limit    
    if qy > 200:
        qy=200
    if qy < -200:
        qy=-200
    if qx < -200:
        qx=-200
    if qx > 200:
        qx=200
 
    if dy > 1000:
        dy=1000
    if dy < -1000:
        dy=-1000
    if dx < -1000:
        dx=-1000
    if dx > 1000:
        dx=1000
 
    if dist < 100:
        dx=1000
        qx=-1000
        dy=1000
        qy=-1000
        #bump.play()
 
 
    # paint the ball
    ballrot+=deltarot
    ballgruen+=deltagruen
    ballblau+=deltablau
 
    quadratrot+=quadratdeltarot
    quadratgruen+=quadratdeltagruen
    quadratblau+=quadratdeltablau
 
    ballrot,deltarot=farbcheck(ballrot,deltarot)
    #if ballrot > 255:
     #   ballrot=255
      #  deltarot*=-1
    ballgruen,deltagruen=farbcheck(ballgruen,deltagruen)
    #if ballgruen > 255:
     #   ballgruen=255
      #  deltagruen*=-1
    ballblau,deltablau=farbcheck(ballblau,deltablau)
    #if ballblau > 255:
     #   ballblau=255
      #  deltablau*=-1
    if ballrot < 0:
        ballrot=0
        deltarot=neudelta()
    if ballgruen < 0:
        ballgruen=0
        deltagruen=neudelta()
    if ballblau < 0:
        ballblau=0
        deltablau=neudelta()
 
    quadratrot,quadratdeltarot=farbcheck(quadratrot,quadratdeltarot)
    #if quadratrot > 255:
     #   quadratrot=255
        #deltarot*=-1
    quadratgruen,quadratdeltagruen=farbcheck(quadratgruen,quadratdeltagruen)
    #if quadratgruen > 255:
     #   quadratgruen=255
        #deltagruen*=-1
    quadratblau,quadratdeltablau=farbcheck(quadratblau,quadratdeltablau)
    #if quadratblau > 255:
     #   quadratblau=255
        #deltablau*=-1
    if quadratrot < 0:
        quadratrot=0
        deltarot=neudelta()
    if quadratgruen < 0:
        quadratgruen=0
        deltagruen=neudelta()
    if quadratblau < 0:
        quadratblau=0
        deltablau=neudelta()
 
    # more precise keyboard event handler
    pressed_keys = pygame.key.get_pressed()
    if pressed_keys[pygame.K_UP]:
        qy-=100
    if pressed_keys[pygame.K_DOWN]:
        qy+=100
    if pressed_keys[pygame.K_LEFT]:
        qx-=100
    if pressed_keys[pygame.K_RIGHT]:
        qx+=100
 
    pressed_keys = pygame.key.get_pressed()
    if pressed_keys[pygame.K_w]:
        dy-=100
    if pressed_keys[pygame.K_s]:
        dy+=100
    if pressed_keys[pygame.K_a]:
        dx-=100
    if pressed_keys[pygame.K_d]:
        dx+=100
 
    #if pygame.mouse.get_pressed()[0] == 1: # linke maustaste wurde gedrückt
        #breite +=0.2
    #elif pygame.mouse.get_pressed()[2] == 1: #rechte maustaste
        #breite -=0.2
    #breite = min(10,breite)
    #breite = max(1,breite)
    #print "quadratrot %i quadratdgruen %i quadreatblau %i " % (quadratrot,quadratgruen,quadratblau)
    pygame.draw.circle(ball, (ballrot,ballgruen,ballblau), (25,25),25)
    pygame.draw.rect(quadrat, (quadratrot,quadratgruen,quadratblau), (0,0,50,50))
    screen.blit(quadrat, (quadratx, quadraty))
    screen.blit(ball, (ballx, bally))
    #print "quadratrot %i quadratdgruen %i quadreatblau %i   ballrot %i ballgruen %i ballblau %i mixrot %i mixgruen %i mixblau %i " % (quadratrot,quadratgruen,quadratblau, ballrot, ballgruen, ballblau, (ballrot+quadratrot)/2, (ballgruen+quadratgruen)/2, (ballblau+quadratblau)/2)
    linienfarbe=(ballgruen,quadratgruen)
    pygame.draw.line(screen, (ballrot,quadratgruen,linienfarbe[random.randint(0,1)]), (ballx+25,bally+25), (quadratx+25,quadraty+25), breite)
 
    distx=max(ballx,quadratx)-min(ballx,quadratx)
    disty=max(bally,quadraty)-min(bally,quadraty)
    dist = (distx*distx + disty*disty)**0.5
    #print"distx %i disty %i dist %i" % (distx,disty,dist)
    pygame.display.flip()          # flip the screen 30 times a second

Ein Ball der rumspringt

ist eigentlich nur eine frühere Version des Hirnschoners

# -*- coding: utf-8 -*-
"""bouncing ball
markus hauser 2009
"""
import pygame
import random
def neudelta():
    return random.randint(1, 15)
 
pygame.init()
screen=pygame.display.set_mode((640,480)) # try out larger values and see what happens !
background = pygame.Surface(screen.get_size())
background.fill((255,255,255))     #fill the background white (red,green,blue)
pygame.draw.circle(background, (50,50,0), (300,250), 200) # draw a circle on the background
background = background.convert()
ball = pygame.Surface((50,50))     #create a new surface
ball.set_colorkey((0,0,0))         #make black the transparent color (red,green,blue)
#pygame.draw.circle(Surface, color, pos, radius, width=0): return Rect
def loesch():
    screen.blit(background, (0, 0))
ballrot=55
ballgruen=200
ballblau=0
deltarot = neudelta()
deltagruen = neudelta()
deltablau = neudelta()
pygame.draw.circle(ball, (ballrot,ballgruen,ballblau), (25,25),25) # paint blue circle
ball = ball.convert()
ballx = 550
bally = 240
dx = 60 # pixel per second !
dy = 60 # pixel per second !
screen.blit(background, (0,0))     #draw background on screen (overwriting all)
screen.blit(ball, (ballx, bally))  #draw the ball shape
clock = pygame.time.Clock()
mainloop = True
FPS = 60 # desired framerate in frames per second.
while mainloop:
    # do all this each frame
    milliseconds = clock.tick(FPS)  # milliseconds passed since last frame
    seconds = milliseconds / 1000.0 # seconds passed since last frame
    clock.tick(FPS) # do not go faster than this framerate
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            mainloop = False # pygame window closed by user
        elif event.type == pygame.KEYDOWN:
            if event.key == pygame.K_ESCAPE:
                mainloop = False # user pressed ESC
    if pygame.mouse.get_pos()[0] < ballx:
        dx-=50
    elif pygame.mouse.get_pos()[0] > ballx:
        dx+=50
    if pygame.mouse.get_pos()[1] < bally:
        dy-=50
    elif pygame.mouse.get_pos()[1] > bally:
        dy+=50    
    pygame.display.set_caption("pygame is running with %.2f frames per second" % clock.get_fps())
    # only blit the part of the background where the ball was (cleanrect)
    cleanrect = background.subsurface((ballx, bally, ball.get_width(), ball.get_height()))
    #screen.blit(cleanrect, (ballx, bally)) # comment out this line for a funny effect !
    #calculate new center of ball
    # time based movement. No matter how busy the cpu and how low the framerate,
    # movement speed will always be constant.
    ballx += dx * seconds
    ballx = round(ballx,0)
    bally += dy * seconds
    bally = round(bally,0)
    # bounce ball if out of screen
    if ballx < 0:
        ballx = 0
        dx *= -1
        loesch()
    elif ballx + ball.get_width() > screen.get_width():
        ballx = screen.get_width() - ball.get_width()
        dx *= -1
        loesch()
    if bally < 0:
        bally = 0
        dy *= -1
        loesch()
    elif bally + ball.get_height() > screen.get_height():
        bally = screen.get_height() - ball.get_height()
        dy *= -1
        loesch()
    # paint the ball
    ballrot+=deltarot
    ballgruen+=deltagruen
    ballblau+=deltablau
 
    if ballrot > 255:
        ballrot=255
        deltarot*=-1
    if ballgruen > 255:
        ballgruen=255
        deltagruen*=-1
    if ballblau > 255:
        ballblau=255
        deltablau*=-1
    if ballrot < 0:
        ballrot=0
        deltarot=neudelta()
    if ballgruen < 0:
        ballgruen=0
        deltagruen=neudelta()
    if ballblau < 0:
        ballblau=0
        deltablau=neudelta()
 
    pygame.draw.circle(ball, (ballrot,ballgruen,ballblau), (25,25),25)
    screen.blit(ball, (ballx, bally))
    pygame.display.flip()          # flip the screen 30 times a second

Kurszeiten & Preise

Horst JENS — Mon, 22 Feb 2010 07:44:32 +0100

Prinzipiell gilt:

Der laufende Programmier-Unterricht findet während der Schulzeit nachmittags statt,
Intensiv-Kurse während der Schulferien finden immer vormittags statt. Sofern nicht anders vereinbart finden alle Kurse im Büro JENS statt.

Schnuppertermine

Alle Schnuppertermine sind kostenlos und unverbindlich. Einen kostenlosen, unverbindlichen Schnuppertertermin (eine Stunde) gibt es für jede(n) Interessierte(n):

Termin: nach Vereinbarung.
Kosten: kostenlos & unverbindlich
Anmeldung: telefonische Anmeldung ist erforderlich.

Laufender Unterricht

Während der Schulzeit (Wien), mind. 2 Stunden pro Woche

Termine: Montag bis Freitag, Nachmittags, 16:00 bis 18:00 oder 18:00 bis 20:00
Während der Wiener Schulferien kein laufender Unterricht. Siehe auch Intensivkurs.
Kosten: 12,-€ pro Stunde. Monatliche Vorauszahlung erforderlich.
Anmeldung: Einstieg jederzeit möglich, Anmeldung (Email oder telefonisch) erforderlich
Kursdauer: siehe f.a.q.

Stundenplan

an folgenden Wochentagen finden während der Schulzeit Programmierkurse statt:

Zeit \ Wochentag	Mo	Di	Mi	Do	Fr
09:00 - 12:00	F	F	F	F	F
13:00 - 15:00	-	k	-	-	-
16:00 - 18:00	-	k	-	k	-
18:00 - 20:00	-	-	-	k	-

Legende:

F: Nur während der Ferien möglich, siehe Intensiv-Kurs
-: Dieser Termin (während der Schulzeit) ist noch frei. Einstieg möglich, allerdings zur Zeit Einzelunterricht.
k: Kurs (während der Schulzeit) läuft, Einstieg möglich da noch Plätze frei sind.
X: Kurs (während der Schulzeit) ist ausgebucht, Einstieg zur Zeit nicht möglich.

Intensiv-Kurs

Nur an schulfreien Tagen möglich,

Zeiten: 3 Stunden pro Tag, jeweils vormittags, 9:00 bis 12:00
Kosten: € 12,- pro Stunde (x 3 Stunden pro Tag = € 36,- pro Tag). Vorauszahlung für den ganzen Kurs erforderlich,
Anmeldung: Einstieg zu Kursbeginn möglich, Anmeldung (Email oder telefonisch) erforderlich

Für Fragen betreffend Fernunterricht, Schulungen vor Ort oder Terminwünsche kontaktieren Sie bitte Horst JENS

Kurs buchen

Einfach eine Email an horst.jens@spielend-programmieren.at schreiben oder anrufen. Sie bekommen einen Erlagschein per Post geschickt.

Veranstaltungen

Unabhängig von den Programmierkursen empfehle ich Ihnen eine dieser zahlreichen meist kostenlosen Veranstaltungen (Messen, Vorträge, Workshops) zu besuchen: Werfen Sie einen Blick auf die Seite Veranstaltungskalender.