Esempio n. 1
0
class Lab:
    def __init__(self, name="Lab", entities=[]):
        """Creates lab using name."""
        self.name = name
        self.entities = entities
        self.loop = []
        self.window = Window(self.name)

    def __call__(self):
        """Main loop."""
        #self.spawn()
        while self.window.open:
            self.window.check()
            self.window.clear()
            for function in self.loop:
                function()
            self.update()
            self.show()

    def update(self):
        """Updating all entities."""
        for entity in self.entities:
            entity.update(self.window.input)

    def show(self):
        """Update screen."""

        for entity in self.entities:
            entity.show(self.window)
        self.window.flip()

    def spawn(self):
        """Spawn all entites."""
        for entity in self.entities:
            entity.spawn()
Esempio n. 2
0
class Game:
    def __init__(self, name="Asteroid", window=None):
        self.name = name
        self.window = window
        if self.window == None: self.window = Window(self.name, build=False)
        self.window.build()
        self.plan = Plan(lines=False)
        self.levels = [Level("First level")]
        self.round = 0
        self.over = False

    def __call__(self):
        while self.window.open and not self.over:
            self.window.check()
            self.update()
            self.show()

    def update(self):
        level = self.levels[self.round]
        if level.over:
            self.round += 1
        else:
            level()
            entities = self.levels[self.level].entities
            player = level.control()
            for entity in entities:
                entity.update(entities)

    def show(self):
        self.window.clear()
        for entity in self.levels[self.round].entities:
            entity.show(self.window, self.plan)
        self.window.flip()
Esempio n. 3
0
class Lab:
    def __init__(self, name="Lab"):
        """Creates lab using name."""
        self.name = name
        self.entities = []
        self.window = Window(self.name)

    def __call__(self):
        """Main loop."""
        while self.window.open:
            self.window.check()
            #self.input()
            self.update()
            self.show()

    def input(self):
        """Updates game inputs."""
        self.inputs = self.window.getInput()

    def update(self):
        """Updating all entities."""
        for entity in self.entities:
            entity.update(self.window)

    def show(self):
        """Update screen."""
        self.window.clear()
        for entity in self.entities:
            entity.show(self.window)
        self.window.flip()
Esempio n. 4
0
class Game:
    def __init__(self):
        self.name="Test"
        self.map_size=[60,40]
        self.map=Map(self.map_size)
        self.window_size=[1400,800]
        self.fullscreen=False
        self.window=Window(self.name,self.window_size,self.fullscreen,text_color=RED)
        self.player=Player(borders=[0,0]+self.map.size)
        #print(self.map.grid)

    def __call__(self):
        self.show()
        while self.window.open:
            self.window.check()
            #self.getInput()
            self.update()
            self.show()

    def update(self):
        self.map.update()
        self.player.update(self.map,self.window)
        keys=self.window.press()
        if keys[K_RSHIFT]:
            self.map.camera.size[0]+=1
            self.map.camera.size[1]+=1
        if keys[K_LSHIFT]:
            self.map.camera.size[0]-=1
            self.map.camera.size[1]-=1

    def show(self):
        self.window.clear()
        #print("self.player.position:",self.player.position)
        self.map.show(self.player.position,self.player.size,self.window)
        self.window.print(text="Player's position: "+str(self.player.position),position=[10,10])
        self.window.flip()
Esempio n. 5
0
class Segment:
    def __init__(self, p1, p2, thickness=1, color=mycolors.RED):
        """Create a Segment using its arguments:
        - tuples p1, p2 : points of the segment extremities
        - int    thickness : thickness of the segment (1px by default)
        - bool   show : display the segment"""
        self.p1 = list(p1)
        self.p2 = list(p2)
        self.thickness = thickness
        self.color = color

    def show(self, window):
        """Show the segment on the window."""
        window.draw.line(window.screen, self.color, self.p1, self.p2,
                         self.thickness)


if __name__ == "__main__":
    from mywindow import Window
    w = Window(size=[600, 400], call=True)
    w.clear()
    c = Circle(center=[300, 200], radius=50)
    s = Segment(p1=[100, 100], p2=[500, 300], color=mycolors.RED)
    w.clear(color=mycolors.WHITE)

    while w.open:
        w.check()
        c.show(w)
        s.show(w)
        w.flip()
Esempio n. 6
0
Y=wsy//4

posAlea=lambda :[randint(X,3*X),randint(Y,3*Y)]


f1=Form([Point(*posAlea()) for i in range(5)])
f1=f1.getSparse()
f2=Form([Point(*posAlea()) for i in range(5)])
f2=f2.getSparse()

#f1.points[0].color=(255,0,0)
#f1.points[1].color=(255,0,0)

while window.open:
    window.check()
    window.clear()
    f1.rotate(0.01,f1[0])
    #f1.rotate(-0.01)
    f2.rotate(0.02,f1[1])
    f2.rotate(-0.03)
    f1.show(window)
    f2.show(window)
    f1.center(color=(0,255,0)).show(window)
    f2.center(color=(0,255,0)).show(window)
    if f1*f2:
        f1.color(RED)
        f2.color(RED)
    else:
        f1.color(WHITE)
        f2.color(WHITE)
    f1[0].show(window,color=(255,0,0))
Esempio n. 7
0
import mycolors
import math


SAND_NUMBER = 10

sand = [Sand.random(9e-1, 11e-1) for i in range(SAND_NUMBER)]


window = Window()
plane = Plane(offset=[window.w/2, window.h/2], zoom=min(window.size)/10)
angle = 0

while window.open:
    window.check()
    window.clear(mycolors.WHITE)

    angle += 0.01
    angle %= 2*math.pi

    xoffset = math.cos(angle)
    yoffset = math.sin(angle)

    for grain in sand:
        x, y = plane.getToScreen(grain.center)

        x += xoffset*plane.zoom
        y -= yoffset*plane.zoom

        grain_pixel = Sand([int(x), int(y)], radius=grain.radius*plane.zoom)
        grain_pixel.show(window)