class Game: def __init__(self): self.name = "Test" self.map_size = [100, 20] self.map = Map(self.map_size) self.window_size = [700, 600] self.fullscreen = False self.window = Window(self.name, self.window_size, self.fullscreen) self.player = Player() def __call__(self): self.show() while self.window.open: self.window.check() self.getInput() self.update() self.show() def getInput(self): self.input = self.window.press() def update(self): self.map.update() self.player.update(self.map, self.input) def show(self): vision = self.player.position + self.player.view self.map.show(vision, self.window)
def __init__(self): self.name = "Rpg" self.map = Map("Rpg") self.players = [Player("Marc")] self.window = Window(self.name) self.scenes = [] self.map.generate()
def __init__(self): self.name = "Test" self.map_size = [100, 20] self.map = Map(self.map_size) self.window_size = [700, 600] self.fullscreen = False self.window = Window(self.name, self.window_size, self.fullscreen) self.player = Player()
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)
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
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()
def __init__(self, plane=Plane(), window=None, **kwargs): if window: self.window = window else: window = Window(**kwargs) self.plane = plane self.window = window self.window.text_size = 30
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()
def __init__(self, window=None, plane=None): """Create a draw object using the window and optional plane.""" if window: self.window = window else: self.window = Window() if plane: self.plane = plane else: self.plane = Plane(offset=[window.w / 2, window.h / 2], zoom=min(window.size) / 10)
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()
class Rpg: def __init__(self): self.name = "Rpg" self.map = Map("Rpg") self.players = [Player("Marc")] self.window = Window(self.name) self.scenes = [] self.map.generate() def __call__(self): self.show() while self.window.open: self.window.check() self.getInput() self.update() self.show() self.end() def end(self): self.window.kill() def show(self): self.window.screen.fill(WHITE) self.player.see(self.map, self.window) self.window.flip() def update(self): for player in self.players: player.update()
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()
def __init__(self, tictactoe, players, window=Window(name="TicTacToe", size=(500, 500)), restart_at_end=False, telling=True): """Create a game of TicTacToe using the TicTacToe object.""" self.tictactoe = tictactoe self.players = players self.window = window self.default_size = window.size self.restart_at_end = restart_at_end # =>Easier to manipulate than having nasty infinities to deal with self.choice = None self.on = False self.telling = telling self.start_duration = 1 self.end_duration = 1 self.start_time = None self.end_time = None self.game_number = 0
def __call__(self): """Return all coordonnates of the circle.""" return [self.x,self.y,self.radius] def crossCircle(self,other): """Determine if two circles are crossing.""" vector=Vector.createFromTwoPoints(self.center,other.center) return vector.norm<self.radius+other.radius if __name__=="__main__": from mysurface import Surface from myzone import Zone from mywindow import Window surface=Surface(plane=Zone(),window=Window()) c1=Circle(4,2,2,color=mycolors.BLUE) c2=Circle(1,2,1,color=mycolors.BLUE) corners=[-1,-1,1,1] cs=[Circle.random(corners,color=mycolors.random()) for i in range(10)] fill=False c1_border_color=mycolors.random() c2_border_color=mycolors.random() c1_area_color=mycolors.random() c2_area_color=mycolors.random() while surface.open: surface.check() surface.control()
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() if __name__ == "__main__": window = Window(build=False) game = Game(window=window) game()
for entity in self.entities: entity.update(self.cursor, self.click, self.keys) def input(self): """Wait for user to insert input.""" change = False while not change: cursor = self.window.point() if cursor is not self.cursor: self.cursor = cursor change = True click = self.window.click() if click is not self.click: self.click = click change = True keys = self.window.press() if keys is not self.keys: self.keys = keys change = True def log(self, message): """Print message with game mention.""" output = str(type(self)) print(output) if __name__ == "__main__": game = Game("test", Window()) game() game.log("salut")
from mywindow import Window from mycolors import WHITE, BLACK from Othello import Othello window = Window(size=[800, 800], set=False) window.open = True window.text_color = BLACK window.background_color = BLACK window.text_size = 30 #window.size=[900,20] results = [] i = 0 number = 10000 display = False while i < number and window.open: i += 1 game = Othello(window, display) game() winner_side = (game.state + 1) % 2 results.append(winner_side) message = "Results for " + str( i) + " tests:\n" + "White victories: " + str( results.count(0)) + "\n" + "Black victories: " + str( results.count(1)) + "\n" window.print(str(message), size=[50, 20]) window.flip() print(message)
x, y, sx, sy = self.center(window, self.default_size) self.position = (x, y) self.size = (sx, sy) def center(self, window): """Center object by default.""" wsx, wsy = window.size wcx, wcy, wcsx, wcsy = window.coordonnates hx, hy = (wcsx - wcx, wcsy - wcy) return (hx, hy, wsx, wsy) def createButtons(self, names): """Create button entities for pannel.""" for i in range(len(names)): self.buttons.append(Button(names[i])) def checkButtons(self): """Return buttons states.""" states = [] for button in self.buttons: states.append(button()) return states if __name__ == "__main__": w = Window("Testing pannel") p = Panel(w) p.show(w, [100, 100, 400, 400], BLUE, GREEN) w.flip() w.pause()
def __init__(self,plane=Plane(),window=Window()): self.plane=plane self.window=window
from marclib.polynomial import Polynomial from mygrapher import Grapher from mywindow import Window import functools import math prod = lambda l: functools.reduce(lambda a, b: a * b, l) #p=Polynomial([2,1]) sample = lambda f, xmin, xmax, n: [ f(xmin + (xmax - xmin) * i / n) for i in range(n) ] interpolator = lambda x, s: sum([ s[j] * prod([(len(s) * x - i) / (j - i) for i in range(len(s)) if i != j]) for j in range(len(s)) ]) s = sample(math.cos, -10, 10, 100) print(s) cosinus_interpolation = lambda x: interpolator(x, s) print(cosinus_interpolation(0)) #print(sample(math.cos,-10,10,100)) window = Window(size=[1000, 800], fullscreen=False) fs = [math.cos, cosinus_interpolation] grapher = Grapher(fs) grapher(window)
def __init__(self, name="Lab", entities=[]): """Creates lab using name.""" self.name = name self.entities = entities self.loop = [] self.window = Window(self.name)
class Triangle(Polygone): def __init__(self, points): Polygone.__init__(points) class Square(Polygone): def __init__(self, points): Polygone.__init__(points) """ Syntax: segment1*segment2=>bool polygone1*polygone2=>bool x:p.position[0] x:p.x x:p[0] """ if __name__ == "__main__": window = Window() p1 = Point(15, 200) p2 = Point(540, 54) #s=Segment(p1,p2) print(p1.x) s.show(window) window()
from mypoint import Point from myform import Form from myvector import Vector from mywindow import Window from random import randint window=Window() wsx,wsy=window.size X=wsx//4 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)
button_key=self.checkButtons() if button_key is not None: self.tree[self.key] def checkButtons(self): """Check if the buttons are being clicked.""" for i in range(len(self.page.buttons)): if self.page.buttons[i].clicked: return i key_action=self.tree[self.key] action=self.actions[key_action] action() def getPage(self): """Return the current page.""" return self.pages[self.key] page=property(getPage) if __name__=="__main__": from mywindow import Window window=Window("Page") buttons=[Button(t) for t in ["oui","non","peut etre","pourquoi pas"]] page=Page(window.size,buttons) page(window)
"""Create a new form according screen coordonnates using a form and the window.""" points = [ Point(self.getToScreen(point, window)) for point in plane_form ] screen_form = deepcopy(plane_form) screen_form.points = points return screen_form def event(self, window): """Handle window events specifics to the maker.""" keys = window.press() click = window.click() cursor = window.point() if click: if not self.selection: self.startForm(cursor, window) else: self.changeForm(cursor, window) if keys[K_SPACE]: self.endForm() def select(self, window): """Still not clear what it does. (it means its useless)""" pass if __name__ == "__main__": window = Window(fullscreen=True) maker = Maker() maker(window)
def jouer(self, plateau, fenetre, tour): input = np.array(plateau.grille) predictions = self.model.predict([input]) #print(predictions) raw_choice = predictions.argmax() choice = [ raw_choice // plateau.taille[0], raw_choice % plateau.taille[0] ] #print("Network choice:",choice) if choice in plateau.mouvements: pass #print("Valid") else: #print("Random") choice = random.choice(plateau.mouvements) #print("Final choice: ",choice) #print("") return choice if __name__ == "__main__": window = Window(taille=[800, 800], set=False) players = [Beast(2), NeuralNetwork()] training = Trainer(window, players, affichage=True) training(5) window.set() print(training.players[1].training_data) game = Othello(window, [NeuralNetwork(), Robot(1)]) #game=Othello(window,[Humain(),training.players[1]],affichage=True) game()
def lines(self,color,positions,connected=True,width=1): new_positions=self.plane.getAllToScreen(positions,self.window) self.window.draw.lines(screen,color,connected,positions,width) def show(self): self.plane.showGrid(self.window) self.window.flip() def clear(self): self.plane.clear(self.window) def check(self): self.window.check() def control(self): self.plane.control(self.window) if __name__=="__main__": window=Window("mydraw") plane=Plane() draw=Draw(plane,window) while draw.window.open: draw.check() draw.control() draw.clear() draw.line(WHITE,(3,-5),(-2,6)) draw.show()
return rect def getRectFromCorners(corners): """Return the rect (top_left_corner,size) using the corners (top_left_corner,bottom_right_corner).""" """[mx,my,Mx,My] -> [mx,my,sx,sy]""" mx, my, Mx, My = corners sx, sy = Mx - mx, My - my rect = [mx, my, sx, sy] return rect def getCornersFromRect(rect): """Return the (top_left_corner,bottom_right_corner) using the corners rect (top_left_corner,size).""" """[mx,my,Mx,My] -> [mx,my,sx,sy]""" mx, my, sx, sy = rect Mx, My = mx + sx, my + sy corners = [mx, my, Mx, My] return corners if __name__ == "__main__": window = Window(fullscreen=False) theme = { "background": (0, 0, 0), "show scale": True, "show origin": True, "grid color": (200, 200, 200) } plane = Plane(theme) #plane.units=[1/10**300,1/10**300] plane(window)
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()
from mywindow import Window from mysurface import Surface from mydraw import Draw from math import sqrt, atan, pi, cos, sin, pi from cmath import polar from mycolors import * from myabstract import Point, Form, Vector import random import time if __name__ == "__main__": real_window = Window(size=[1440, 900], fullscreen=True) draw = Draw(window=real_window) window = Surface( draw) #Create not a real window but a surface to display on screen. #window=Window(fullscreen=True) p1 = Point(1, -6) p2 = Point(-2, 4) p3 = Point(8, 5) p4 = Point(4, 4, color=(0, 255, 0)) points = [p1, p3, p2, p4] f = Form([ Point(random.randint(-10, 10), random.randint(-10, 10)) for i in range(10) ]) #f.show(window) f2 = f.getSparse() p1.show(window)