def resetGame(self):
print("Game reset. Waiting for new players")
if self.p1 != None:
if self.isConnected(self.p1.ip):
self.p1.status = status.logged_in
self.safeSend(self.p1.connexion, message.set_player(self.p1.status.value))
else:
self.p1.status = status.identified
if self.p2 != None and self.p2 != self.name:
if self.isConnected(self.p2.ip):
self.p2.status = status.logged_in
self.safeSend(self.p2.connexion, message.set_player(self.p2.status.value))
else:
self.p2.status = status.identified
self.p1 = None
self.p2 = None
for spect in self.spectators:
spect.status = status.logged_in
self.safeSend(spect.connexion, message.msg("Game reset"))
self.safeSend(spect.connexion, message.set_player(spect.status.value))
self.spectators = []
self.grids = [grid(), grid(), grid()]
self.current_player = None
self.timerResetGameP1 = None
self.timerResetGameP2 = None
def main():
grids = [grid(), grid(), grid()]
current_player = J1
grids[J1].display()
while grids[0].gameOver() == -1:
if current_player == J1:
shot = -1
while shot < 0 or shot >= NB_CELLS:
shot = int(input("quel case allez-vous jouer ?"))
else:
shot = random.randint(0, 8)
while grids[current_player].cells[shot] != EMPTY:
shot = random.randint(0, 8)
if (grids[0].cells[shot] != EMPTY):
grids[current_player].cells[shot] = grids[0].cells[shot]
else:
grids[current_player].cells[shot] = current_player
grids[0].play(current_player, shot)
current_player = current_player % 2 + 1
if current_player == J1:
grids[J1].display()
print("game over")
grids[0].display()
if grids[0].gameOver() == J1:
print("You win !")
else:
print("you loose !")
def vs_ia():
grids = [grid(), grid(), grid()]
current_player = J1
grids[J1].display()
while grids[0].gameOver() == -1:
if current_player == J1:
shot = -1
while shot < 0 or shot >= NB_CELLS:
try:
shot = int(
input(
"Quelle case allez-vous jouer ? (entrez un chiffre entre 0 et 8)\n>"
))
except (EOFError, ValueError):
print("Veuillez entrer un entier de 0 à 8.")
else:
shot = randint(0, 8)
while grids[current_player].cells[shot] != EMPTY:
shot = randint(0, 8)
if (grids[0].cells[shot] != EMPTY):
grids[current_player].cells[shot] = grids[0].cells[shot]
else:
grids[current_player].cells[shot] = current_player
grids[0].play(current_player, shot)
current_player = current_player % 2 + 1
if current_player == J1:
grids[J1].display()
grids[0].display()
if grids[0].gameOver() == J1:
print("You win !")
elif grids[0].gameOver() == J2:
print("Loser.")
else:
print("Match nul !")
def main():
grids = [grid(), grid(), grid()]
current_player = J1
os.system('clear')
grids[J1].display()
while grids[0].gameOver() == -1:
if current_player == J1:
shot = -1
while shot < 0 or shot >= NB_CELLS:
shot = int(input("Quelle case allez-vous jouer ?"))
else:
shot = random.randint(0, 8)
while grids[current_player].cells[shot] != EMPTY:
shot = random.randint(0, 8)
if (grids[0].cells[shot] != EMPTY):
grids[current_player].cells[shot] = grids[0].cells[shot]
else:
grids[current_player].cells[shot] = current_player
grids[0].play(current_player, shot)
current_player = current_player % 2 + 1
if current_player == J1:
os.system('clear')
grids[J1].display()
os.system('clear')
print("Partie finie")
grids[0].display()
if grids[0].gameOver() == J1:
print("Vous avez gagné !")
else:
print("Vous avez perdu !")
def BuildRandomHouses(amount):
build_single = int(amount * 0.6)
build_bungalow = int(amount * 0.25)
build_maison = int(amount * 0.15)
cordinatelist = grid().makecordinatelist()
coordinate_list = []
housecount = 0
total_value = 0
while housecount < build_single:
cord = Randomizer(1)
build = single
if SetHouseInList(build, cord, coordinate_list, cordinatelist) == True:
housecount += 1
total_value += single(cord).giveworth()
while housecount < (build_single + build_bungalow):
cord = Randomizer(1)
build = bungalow
if SetHouseInList(build, cord, coordinate_list, cordinatelist) == True:
housecount += 1
total_value += bungalow(cord).giveworth()
while housecount < amount:
cord = Randomizer(1)
build = maison
if SetHouseInList(build, cord, coordinate_list, cordinatelist) == True:
housecount += 1
total_value += maison(cord).giveworth()
# print(cordinatelist)
grid().makegrid(coordinate_list, total_value)
def test_bandnumber(self):
self.grid = grid().createGrid(4, 4)
self.grid = grid().detEdgecode(self.grid)
self.grid = grid().setBandNumber(self.grid)
bandnumbers = []
for i in self.grid:
for j in i:
bandnumbers.append(j["bandnumber"])
self.assertEqual(max(bandnumbers), 3)
def addBreaklinePressed2(instance):
'''End the add breaklines interface'''
self.addBreakline.unbind(on_press=addBreaklinePressed2)
self.addBreakline.text="(A)dd Breaklines"
##reset grid properties
self.grid = grid().detEdgecode(self.grid)
self.grid = grid().setBandNumber(self.grid)
printKnot()
self.app.setOnBreaklines(False)
self.addBreakline.bind(on_press=addBreaklinePressed)
def build(self):
app = MyKnotworkWidget()
self.grid = grid().createGrid(4,3)
self.grid = grid().detEdgecode(self.grid)
self.grid = grid().setBandNumber(self.grid)
app.printGrid(self.grid, 50)
app.printPoints(self.grid, 50)
app.printBreaklines(self.grid, 50)
app.printKnot(self.grid, 50, 10)
return app
def main():
grids = [grid(), grid(), grid()] # Un tableau de trois grilles
if (len(sys.argv) == 1):
serveur()
elif (len(sys.argv) == 2):
client(sys.argv[1])
else:
print("Usage: " + argv[0] + " [hote]")
sys.exit()
def test_edgecode(self):
self.grid = grid().createGrid(4, 4)
self.grid = grid().detEdgecode(self.grid)
##just check edgecodes on corners
self.assertEqual(self.grid[0][0]["edgecode"]["to"], 2)
self.assertEqual(self.grid[0][0]["edgecode"]["from"], 4)
self.assertEqual(self.grid[7][7]["edgecode"]["to"], 8)
self.assertEqual(self.grid[7][7]["edgecode"]["from"], 6)
self.assertEqual(self.grid[0][7]["edgecode"]["to"], 4)
self.assertEqual(self.grid[0][7]["edgecode"]["from"], 6)
self.assertEqual(self.grid[7][0]["edgecode"]["to"], 2)
self.assertEqual(self.grid[7][0]["edgecode"]["from"], 8)
def test_get_breaklines(self):
self.grid = grid().createGrid(4, 4)
self.grid = grid().detEdgecode(self.grid)
self.grid = grid().setBandNumber(self.grid)
self.grid = grid().addBreakline([2, 0],[2, 4], self.grid)
bls = grid().getblPoints(self.grid)
for i in range(8):
self.assertEqual([[i, 0], [i+1, 0]] in bls, True)
self.assertEqual([[0, i], [0, i+1]] in bls, True)
self.assertEqual([[i, 8], [i+1, 8]] in bls, True)
self.assertEqual([[8, i], [8, i+1]] in bls, True)
for i in range(4):
self.assertEqual([[2, i], [2, i+1]] in bls, True)
def test_getKnotPointsByBand(self):
self.grid = grid().createGrid(4, 4)
self.grid = grid().detEdgecode(self.grid)
self.grid = grid().setBandNumber(self.grid)
##Initialise the app
app = MyKnotworkWidget()
points = app.getKnotPointsbyBand(self.grid,10, 50, 10, 100, 0, 11)
##Test number of bands
self.assertEqual(len(points), 4)
##check types
for i in points:
self.assertEqual(type(i), list)
for j in i:
self.assertEqual(type(j), list)
self.assertEqual(len(j), 8)
def SetHouseInList(build, cord, coordinate_list, cordinatelist):
housecords = build(cord).coordinates_house()
if housecords != None:
if len(coordinate_list) == 0:
coordinate_list.append(housecords)
cordinatelist = grid().updatecordinatelist(cordinatelist,
housecords, "house")
return True
elif grid().overlapping(cordinatelist, housecords) == True:
coordinate_list.append(housecords)
cordinatelist = grid().updatecordinatelist(cordinatelist,
housecords, "house")
return True
elif grid().overlapping(cordinatelist, housecords) != True:
return False
def percolation_wave(input_grid, short=False):
"""
Percolation algorithm by wave. Uses input_grid to determine where flow is
allowed, trace to determine whether or not to visualize it graphically,
and short to determine whether or not to exit early. Essentially, if your
algorithm exits early, the code inside the 'if short' condition is what
your code might look like.
"""
flow_grid = grid(len(input_grid), -1)
next_wave = []
# Populate the inital wave from the top row
for k in range(len(input_grid[0])):
if input_grid[0][k] == 0:
flow_grid[0][k] = 1
next_wave.append((0, k))
while next_wave:
if short:
row = len(flow_grid) - 1
for k in range(len(flow_grid[0])):
if flow_grid[row][k] != -1:
return flow_grid, True
next_wave = gen_next_wave(input_grid, flow_grid, next_wave)
# Check if we made it to the bottom
row = len(flow_grid) - 1
percolates = False
for k in range(len(flow_grid[0])):
if flow_grid[row][k] != -1:
percolates = True
return flow_grid, percolates
def __init__(self):
self.options = {}
self.options["focused"] = {}
self.focus_grid = grid()
self.focus_grid.set(0,0, self)
self.eventmgr = event_manager()
self.image_surfaces = {}
def __init__(self, grid ):
# Проверка что массивы RPM и TURBO не убывающие, если ла то выходим из функции
if Func.checkTable(ED.Turbo_table, 'Turbo') == False and Func.checkTable(ED.RPM_table, 'RPM') == False:
title_str = u"Дизельная калибровка - " + ED.name_cal + u" Горизонталь RPM, вертикаль TURBO. "
dialog = wx.Dialog(ED.main_parent, -1, title_str, pos=(0, 0), size=ED.CalWindowSize)
self.grid = grid(dialog)
dialog.SetBackgroundColour("WHITE")
self.grid.popupItemRead(1)
main_sz = wx.BoxSizer(wx.VERTICAL)
sz1 = wx.BoxSizer(wx.HORIZONTAL)
self.cbPaint = wx.CheckBox( dialog, -1, u"Не раскрашивать" )
self.cbShow = wx.CheckBox( dialog, -1, u"Подача" )
ED.calWinSetupCheckBox[0] = False
self.cbPaint.SetValue( ED.calWinSetupCheckBox[0])
self.cbShow.SetValue( ED.calWinSetupCheckBox[1])
dialog.Bind(wx.EVT_CHECKBOX, self.optionEvtCheckBox, self.cbPaint )
dialog.Bind(wx.EVT_CHECKBOX, self.optionEvtCheckBox, self.cbShow )
sz1.Add( self.cbPaint , 0, wx.ALIGN_BOTTOM|wx.LEFT,20 )
sz1.Add( self.cbShow , 0, wx.ALIGN_BOTTOM|wx.LEFT, 20 )
buttons = wx.StdDialogButtonSizer()
OK_button = wx.Button(dialog, wx.ID_OK, u"ДА")
OK_button.SetDefault()
buttons.AddButton(OK_button)
NO_button = wx.Button(dialog, wx.ID_CANCEL, u"НЕТ")
buttons.AddButton(NO_button)
sz1.Add( (ED.calWinButtonOffset,0), 0 ) # Пустое пространство
sz1.Add( buttons , 0, wx.TOP|wx.RIGHT, 10 )
main_sz.Add( self.grid , 0, wx.ALIGN_TOP )
main_sz.Add( sz1 , 0, wx.TOP|wx.LEFT|wx.ALIGN_TOP,0 )
buttons.Realize()
dialog.SetSizer(main_sz)
result = dialog.ShowModal()
if result == wx.ID_OK:
self.grid.popupItemWrite(1)
def test_grid_types_all(self):
self.grid = grid().createGrid(4, 4)
self.assertEqual(type(self.grid), list)
for i in self.grid:
self.assertEqual(type(i), list)
for j in i:
self.assertEqual(type(j), dict)
def percolation_wave(input_grid, short=False):
"""
Percolation algorithm by wave. Uses input_grid to determine where flow is
allowed, trace to determine whether or not to visualize it graphically,
and short to determine whether or not to exit early. Essentially, if your
algorithm exits early, the code inside the 'if short' condition is what
your code might look like.
"""
flow_grid = grid(len(input_grid), -1)
next_wave = []
# Populate the inital wave from the top row
for k in range(len(input_grid[0])):
if input_grid[0][k] == 0:
flow_grid[0][k] = 1
next_wave.append((0,k))
while next_wave:
if short:
row = len(flow_grid) - 1
for k in range(len(flow_grid[0])):
if flow_grid[row][k] != -1:
return flow_grid, True
next_wave = gen_next_wave(input_grid, flow_grid, next_wave)
# Check if we made it to the bottom
row = len(flow_grid) - 1
percolates = False
for k in range(len(flow_grid[0])):
if flow_grid[row][k] != -1:
percolates = True
return flow_grid, percolates
def __init__(self):
self.options = {}
self.options["focused"] = {}
self.focus_grid = grid()
self.focus_grid.set(0, 0, self)
self.eventmgr = event_manager()
self.image_surfaces = {}
def __init__(self):
self.grid = grid()
self.players = dict()
self.scores = dict()
self.currentPlayer = J1
for i in [J1, J2]:
self.players[i] = None
self.scores[i] = 0
def main():
grid_ = generateGrid(128, 128)
start = (0, 0)
goal = (100, 100)
(path, visited) = search(grid_, start, goal)
if (path != False):
print("True")
display = grid(grid_, path, visited)
def forwardFunction(self):
'''Redo function'''
if (len(self.breaklinesf) != 0):
points = self.breaklinesf.pop()
self.breaklines.append(points)
self.grid = grid().addBreakline(points[0], points[1], self.grid) ##rewrites the breakline
##recalculate the grid
self.grid = grid().setProps(self.grid)
self.grid = grid().detEdgecode(self.grid)
self.grid = grid().setBandNumber(self.grid)
##Redraw the knot
self.clearCanvas()
self.printFinalKnot(self.grid, self.gridUnits,self.width2, self.spacing,self.curve, self.offsetX, self.offsetY, self.cornerType)
##Redo is also available outside of the breaklines interface
if (self.onBreaklines):
self.drawAddBreakline(self.grid, self.gridUnits, self.offsetX, self.offsetY, self.width2, self.spacing, self.curve, self.cornerType)
self.printBreaklines(self.grid, self.gridUnits, self.offsetX, self.offsetY)
def backFuntion(self):
'''Undoes the previously added breakline'''
if (len(self.breaklines) != 0):
points = self.breaklines.pop()
self.breaklinesf.append(points)
self.grid = grid().addBreakline(points[0], points[1], self.grid) ##Writes over breakline
#recalculate the grid
self.grid = grid().setProps(self.grid)
self.grid = grid().detEdgecode(self.grid)
self.grid = grid().setBandNumber(self.grid)
#reprint Knot
self.clearCanvas()
self.printFinalKnot(self.grid, self.gridUnits,self.width2, self.spacing,self.curve, self.offsetX, self.offsetY, self.cornerType)
#undo is also possible outside of the breaklines interface
if (self.onBreaklines):
self.drawAddBreakline(self.grid, self.gridUnits, self.offsetX, self.offsetY, self.width2, self.spacing, self.curve, self.cornerType)
self.printBreaklines(self.grid, self.gridUnits, self.offsetX, self.offsetY)
def endGame(self):
print("---- GAME ENDING ----")
winner = self.grids[0].gameOver()
if winner > 0:
self.gameReady = False
self.grids = [grid(), grid(), grid()]
# Incrementing score and sending them with end token
self.scores[winner] += 1
self.sendAll("END " + str(winner) + "\n")
self.sendAll(self.getScore())
self.playerToSpectator(J1)
self.playerToSpectator(J2)
self.sendAll("---------------------\n"
"TYPE \"JOIN\" TO PLAY\n"
"---------------------\n")
return True
else:
return False
def cmd_convert_data_to_grid(data):
data = formalizedata(data, "STATE ")
tmp = data.split(" ")
cells = []
for elem in tmp:
cells.append(int(elem))
grid_instance = grid()
grid_instance.cells = cells
return grid_instance
def __init__(self, host = '', port=50500):
self.main_connexion = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.main_connexion.bind((host, port))
self.main_connexion.listen(5)
self.connexions = []
self.spectators = []
self.clients = {}
self.timeOut = 60.0
self.timerResetGameP1 = None
self.timerResetGameP2 = None
self.p1 = None
self.p2 = None
self.current_player = None
self.grids = [grid(), grid(), grid()]
self.name = "SERVINATORR"
print("New server created {}:{}".format(socket.gethostbyname(socket.gethostname()), port))
def startGame(self): ####################
print("Game start")
self.hGrid.append(grid())
game = len(self.hGrid) - 1
for p in self.players: #The game starts, we can display players' grids
if p.pGame == -1:
p.pGame = game
if p.pClient.socket != None:
p.sendMessage("$gamestart")
p.displayGrid()
self.currentPlayer.append(-1)
self.switchPlayer(game)
def plotKnotAcc():
'''Replots the knot and validate any input'''
try:
dismiss_popup() #there may or may not be a popup
except:
pass
self.app.clearCanvas()
##Validate datat
self.gridUnits = checkValue(self.gridUnitsI.text, 50, False, False)
self.gridUnitsI.text = str(self.gridUnits)
self.X.text = str(checkValue(self.X.text, 4, False, False))
self.Y.text = str(checkValue(self.Y.text, 4, False, False))
self.WidthI.text = str(checkValue(self.WidthI.text, 8.0, True, False))
#Create a new grid
self.grid = grid().createGrid(int(self.X.text),int(self.Y.text))
self.grid = grid().detEdgecode(self.grid)
self.grid = grid().setBandNumber(self.grid)
#set sizing so the knot doesnt cover interface elements
self.knotX = int(self.X.text)*2
self.knotY = int(self.Y.text)*2
viewWidth = Window.width*0.52
viewHeight = Window.height-110
if ((viewWidth)/self.knotX < (viewHeight)/self.knotY):
self.gridUnitsView = (viewWidth)/self.knotX
else:
self.gridUnitsView = (viewHeight)/self.knotY
self.knotWidthView = (float(self.WidthI.text)/self.gridUnits)*self.gridUnitsView
self.spacing = self.knotWidthView
if self.knotWidthView < 1:
self.knotWidthView = 1
self.offsetX = Window.width*0.25 - self.gridUnitsView
self.offsetY = Window.height*0.05 - self.gridUnitsView
##Print the new knot
printKnot()
def test_grid_breaklines(self):
self.grid = grid().createGrid(4, 4)
for i in range(len(self.grid)):
for j in range(len(self.grid[i])):
if (i == 0 and j == 0):
self.assertEqual(self.grid[i][j]["breakline"]["1"], True)
self.assertEqual(self.grid[i][j]["breakline"]["2"], False)
self.assertEqual(self.grid[i][j]["breakline"]["3"], False)
self.assertEqual(self.grid[i][j]["breakline"]["4"], True)
elif (i == 0 and j == len(self.grid[i]) - 1):
self.assertEqual(self.grid[i][j]["breakline"]["1"], True)
self.assertEqual(self.grid[i][j]["breakline"]["2"], True)
self.assertEqual(self.grid[i][j]["breakline"]["3"], False)
self.assertEqual(self.grid[i][j]["breakline"]["4"], False)
elif (i == len(self.grid)-1 and j == 0):
self.assertEqual(self.grid[i][j]["breakline"]["1"], False)
self.assertEqual(self.grid[i][j]["breakline"]["2"], False)
self.assertEqual(self.grid[i][j]["breakline"]["3"], True)
self.assertEqual(self.grid[i][j]["breakline"]["4"], True)
elif (i == len(self.grid)-1 and j == len(self.grid[i]) - 1):
self.assertEqual(self.grid[i][j]["breakline"]["1"], False)
self.assertEqual(self.grid[i][j]["breakline"]["2"], True)
self.assertEqual(self.grid[i][j]["breakline"]["3"], True)
self.assertEqual(self.grid[i][j]["breakline"]["4"], False)
elif (i == 0):
self.assertEqual(self.grid[i][j]["breakline"]["1"], True)
self.assertEqual(self.grid[i][j]["breakline"]["2"], False)
self.assertEqual(self.grid[i][j]["breakline"]["3"], False)
self.assertEqual(self.grid[i][j]["breakline"]["4"], False)
elif (i == len(self.grid)-1):
self.assertEqual(self.grid[i][j]["breakline"]["1"], False)
self.assertEqual(self.grid[i][j]["breakline"]["2"], False)
self.assertEqual(self.grid[i][j]["breakline"]["3"], True)
self.assertEqual(self.grid[i][j]["breakline"]["4"], False)
elif (j == 0):
self.assertEqual(self.grid[i][j]["breakline"]["1"], False)
self.assertEqual(self.grid[i][j]["breakline"]["2"], False)
self.assertEqual(self.grid[i][j]["breakline"]["3"], False)
self.assertEqual(self.grid[i][j]["breakline"]["4"], True)
elif (j == len(self.grid[i]) - 1):
self.assertEqual(self.grid[i][j]["breakline"]["1"], False)
self.assertEqual(self.grid[i][j]["breakline"]["2"], True)
self.assertEqual(self.grid[i][j]["breakline"]["3"], False)
self.assertEqual(self.grid[i][j]["breakline"]["4"], False)
else:
self.assertEqual(self.grid[i][j]["breakline"]["1"], False)
self.assertEqual(self.grid[i][j]["breakline"]["2"], False)
self.assertEqual(self.grid[i][j]["breakline"]["3"], False)
self.assertEqual(self.grid[i][j]["breakline"]["4"], False)
def on_touch_down(self, touch):
'''Called on mouse click, recieves touch object which contains the coordinates of the click'''
if (self.bp): #if add breaklines interface is on
if (self.num<2): ##if there are less than 2 points
point = self.checkPoint(touch.x, touch.y, self.grid)
if (point):
self.num += 1
self.points.append(point)
if self.num == 2: ##When you have two points
pointTest = self.checkPoints(self.points[0], self.points[1], self.grid)
if (not pointTest): ##if the lines are on the border brekline (we dont want to remove this)
self.points = []
self.num = 0
else:
self.num = 0
##Check that these breklines dont conflict with any current ones
blPoints = grid().getblPoints(self.grid)
for i in range(len(blPoints)):
if self.checkCross(blPoints[i][0], blPoints[i][1], self.points[0], self.points[1]):
self.points=[]
break
#add breaklines to list for undo
if self.points != []:
self.breaklines.append(self.points)
# add breaklines to grid
for j in range (len(self.points)//2):
self.grid = grid().addBreakline(self.points[j*2], self.points[j*2+1], self.grid)
#recalculate grid and redraw breakline interface
self.grid = grid().setProps(self.grid)
self.grid = grid().detEdgecode(self.grid)
self.grid = grid().setBandNumber(self.grid)
self.clearCanvas()
self.printFinalKnot(self.grid, self.gridUnits,self.width2, self.spacing,self.curve, self.offsetX, self.offsetY, self.cornerType)
self.drawAddBreakline(self.grid, self.gridUnits, self.offsetX, self.offsetY, self.width2, self.spacing, self.curve, self.cornerType)
self.printBreaklines(self.grid, self.gridUnits, self.offsetX, self.offsetY)
def read_from_micaps4(filename,grid = None):
try:
if not os.path.exists(filename):
print(filename + " is not exist")
return None
try:
file = open(filename,'r')
str1 = file.read()
file.close()
except:
file = open(filename,'r',encoding='utf-8')
str1 = file.read()
file.close()
strs = str1.split()
if int(strs[0])>19:
year = str(19) + str(strs[0])
else:
year = str(20) + str(strs[0])
month = str(strs[1])
day = str(strs[2])
times = year + month + day
dlon = float(strs[9])
dlat = float(strs[10])
slon = float(strs[11])
elon = float(strs[12])
slat = float(strs[13])
elat = float(strs[14])
nlon = int(strs[15])
nlat = int(strs[16])
elon = slon + dlon * (nlon -1)
elat = slat + dlat * (nlat -1)
grid1 = grid([slon,dlon,elon],[slat,dlat,elat])
grd = grid_data(grid1)
if len(strs) - 22 >= grd.nlon * grd.nlat :
k=22
grd.dat = (np.array(strs[k:])).astype(float).reshape((grd.nlat,grd.nlon))
grd.reset()
if (grid is None):
return grd
else:
return bt.ggf.linearInterpolation(grd, grid)
else:
return None
except:
print(filename + "'s format is wrong")
return None
def main():
gdicts = json.load(open("grilles.json"))
num = input("rentrez le numéro de la grille sur laquelle vous souhaitez jouer (de 1 à 41)")
gdict = gdicts[num]
gameGrid = Grid(gdict)
trials = 0 # trials iterator
while True:
print(grid(gameGrid.toArray(), size=3))
if parser(gameGrid): # parser renvoie faux tant que la voiture Z n'es pas sortie
break # du coup si il renvoie vrai, c'est qu'on a gagné, donc on sort de la boucle
trials += 1 # à chaque tour de boucle, un essai supplémentaire
print("WINNER !! \nNombre de coups :", trials)
def endGame(self, game):
p1 = None
p2 = None
for p in self.players:
if p.pGame == game:
if p.pClient != None:
p.pClient.cType = 0
if p1 == None:
p1 = p
else:
p2 = p
if p1 != None:
p1.pClient = None
if p2 != None:
p2.pClient = None
self.hGrid[game] = grid()
def main():
gdicts = json.load(open('grilles.json'))
num = input("rentrez le numéro de la grille sur laquelle vous souhaitez jouer (de 1 à 41)")
gdict = gdicts[num]
gameGrid = Grid(gdict)
trials = 0 #trials iterator
while(True):
print(grid(gameGrid.toArray(), size=3))
if parser(gameGrid): #parser renvoie faux tant que la voiture Z n'es pas sortie
break #du coup si il renvoie vrai, c'est qu'on a gagné, donc on sort de la boucle
trials +=1 #à chaque tour de boucle, un essai supplémentaire
print("WINNER !! \nNombre de coups :", trials)
def get_focus_grid(self):
new_grid = grid()
for x in range(self.focus_grid.w):
new_col = []
old_col = self.focus_grid.get_col(x)
for item in old_col:
if item != None:
new_col.append(item)
if len(new_col) < self.focus_grid.h:
repeat = self.focus_grid.h / len(new_col)
tmp = []
for i in new_col:
for r in range(repeat):
tmp.append(i)
for i in range(self.focus_grid.h % len(new_col)):
tmp.append(new_col[-1])
new_col = tmp
for i in range(len(new_col)):
new_grid.set(x, i, new_col[i])
return new_grid
def get_focus_grid(self): new_grid = grid() for x in range(self.focus_grid.w): new_col = [] old_col = self.focus_grid.get_col(x) for item in old_col: if item != None: new_col.append(item) if len(new_col) < self.focus_grid.h: repeat = self.focus_grid.h / len(new_col) tmp = [] for i in new_col: for r in range(repeat): tmp.append(i) for i in range(self.focus_grid.h%len(new_col)): tmp.append(new_col[-1]) new_col = tmp for i in range(len(new_col)): new_grid.set(x, i, new_col[i]) return new_grid
def percolation_recursive(input_grid, short=False):
"""
Determine whether or not a grid percolates, and which cells are filled.
Like before, short is True if you want the algorithm to stop immediately
when it percolates, rather than exploring the entire grid.
"""
size = len(input_grid)
flow_grid = grid(size, -1)
#start exploration from each space in top (zeroth) row
for col in range(size):
if explore(input_grid, flow_grid, 0, col, short):
return flow_grid, True
#check last (size-1'th) row for full spaces
for col in range(size):
if flow_grid[size-1][col] == '*':
return flow_grid, True
#no full spaces in bottom row; doesn't percolate
return flow_grid, False
def main():
pygame.init()
screen = pygame.display
DISPLAY = screen.set_mode((1310, 929), 0, 32)
screen.set_caption('Goblin Dwarf Star')
WHITE = (255, 255, 255)
DISPLAY.fill(WHITE)
fond = pygame.image.load("carte.jpg")
DISPLAY.blit(fond, (0, 0))
g = grid(DISPLAY)
while True:
for event in pygame.event.get():
if event.type == QUIT:
pygame.quit()
sys.exit()
if event.type == pygame.MOUSEBUTTONUP:
pos = pygame.mouse.get_pos()
g.onClick(pos[0], pos[1], DISPLAY, fond)
screen.update()
def __init__(self, host="192.168.1.15", port=50500):
Thread.__init__(self)
self.main_connexion = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
print("Connecting...")
self.main_connexion.connect((host, port))
except ConnectionRefusedError:
print("Error: Connection refused.")
except TimeoutError:
print("Error: Timout.\n")
except:
print("Error: Connexion impossible.\n")
else:
print("Connexion set with {}:{}.".format(host, port))
self.main_connexion.settimeout(0.1)
self.grid = grid()
self.login = []
self.cell = []
self.otherGame = []
self.chooseRole = []
def run(self):
while (self.nbClient < 2):
time.sleep(1)
gameOver = 0
num = 1
msg = str(num)
J1.send(msg.encode())
num = 2
msg = str(num)
J2.send(msg.encode())
grids = grid()
currentPlayer = 1
grids.display()
while grids.gameOver() == -1:
msg = str(gameOver)
J1.send(msg.encode())
J2.send(msg.encode())
time.sleep(0.2)
msg = str(currentPlayer)
J1.send(msg.encode())
J2.send(msg.encode())
if (currentPlayer == 1):
case = J1.recv(8192)
case = int(case)
if (grids.cells[case] == EMPTY):
grids.play(currentPlayer, case)
grids.display()
msg = str(OK)
J1.send(msg.encode())
time.sleep(0.2)
currentPlayer = currentPlayer % 2 + 1
elif (grids.cells[case] == currentPlayer):
msg = str(-1)
J1.send(msg.encode())
time.sleep(0.2)
def play():
screen_rows = 30
screen_columns = 141
grid_columns = 1000
obj_grid = grid(screen_rows, grid_columns)
obj_grid.create_roof()
obj_grid.create_floor()
obj_mandalorian = mandalorian(screen_rows - 6, 0)
obj_mandalorian.initial_placement(obj_grid)
obj_boss_enemy = boss_enemy(screen_rows - 6, grid_columns - 6)
obj_boss_enemy.initial_placement(obj_grid)
create_coinshelves(obj_grid)
create_firebeam(obj_grid, screen_columns)
create_powerup(obj_grid, screen_columns, 8)
magnet_arr = create_magnet(obj_grid, screen_columns, 3)
start = 0
vir_time = 600
def move_mandalorian(last_up):
if screen_rows - 6 == obj_mandalorian.get_row():
last_up = screen_rows - 6
ch = user_input()
if ch == 'w' or ch == 'W':
if obj_mandalorian.get_row() - 1 > 1:
if obj_mandalorian.get_shield() == 0:
if obj_grid.get_grid(
obj_mandalorian.get_row() - 1,
obj_mandalorian.get_column()
) != Fore.MAGENTA + Style.BRIGHT + "%" + Style.RESET_ALL and obj_grid.get_grid(
obj_mandalorian.get_row() - 1,
obj_mandalorian.get_column() + 1
) != Fore.MAGENTA + Style.BRIGHT + "%" + Style.RESET_ALL and obj_grid.get_grid(
obj_mandalorian.get_row() - 1,
obj_mandalorian.get_column() + 2
) != Fore.MAGENTA + Style.BRIGHT + "%" + Style.RESET_ALL:
obj_mandalorian.disappear_mandalorian(obj_grid)
last_up -= 1
obj_mandalorian.change_row(-1)
obj_mandalorian.check_coin_collision(obj_grid)
obj_mandalorian.check_powerup_collision(
obj_grid, vir_time // 1)
obj_mandalorian.check_obstacle_collision(
obj_grid, start, vir_time // 1)
obj_mandalorian.reappear_mandalorian(obj_grid, 1)
elif obj_mandalorian.get_shield() == 1:
if obj_grid.get_grid(
obj_mandalorian.get_row() - 1,
obj_mandalorian.get_column()
) != Fore.MAGENTA + Style.BRIGHT + "%" + Style.RESET_ALL and obj_grid.get_grid(
obj_mandalorian.get_row() - 1,
obj_mandalorian.get_column() + 1
) != Fore.MAGENTA + Style.BRIGHT + "%" + Style.RESET_ALL and obj_grid.get_grid(
obj_mandalorian.get_row() - 1,
obj_mandalorian.get_column() + 2
) != Fore.MAGENTA + Style.BRIGHT + "%" + Style.RESET_ALL and obj_grid.get_grid(
obj_mandalorian.get_row() - 1,
obj_mandalorian.get_column() + 3
) != Fore.MAGENTA + Style.BRIGHT + "%" + Style.RESET_ALL:
obj_mandalorian.disappear_mandalorian(obj_grid)
last_up -= 1
obj_mandalorian.change_row(-1)
obj_mandalorian.check_coin_collision(obj_grid)
obj_mandalorian.check_powerup_collision(
obj_grid, vir_time // 1)
obj_mandalorian.check_obstacle_collision(
obj_grid, start, vir_time // 1)
obj_mandalorian.reappear_mandalorian(obj_grid, 1)
elif ch == 'd' or ch == 'D':
if obj_mandalorian.get_shield() == 0:
if obj_mandalorian.get_column() + 3 < screen_columns + start:
obj_mandalorian.disappear_mandalorian(obj_grid)
if obj_grid.get_grid(
obj_mandalorian.get_row(),
obj_mandalorian.get_column() + 3
) != Fore.MAGENTA + Style.BRIGHT + "%" + Style.RESET_ALL and obj_grid.get_grid(
obj_mandalorian.get_row() + 1,
obj_mandalorian.get_column() + 3
) != Fore.MAGENTA + Style.BRIGHT + "%" + Style.RESET_ALL and obj_grid.get_grid(
obj_mandalorian.get_row() + 2,
obj_mandalorian.get_column() + 3
) != Fore.MAGENTA + Style.BRIGHT + "%" + Style.RESET_ALL:
obj_mandalorian.change_column(+1)
obj_mandalorian.check_coin_collision(obj_grid)
obj_mandalorian.check_powerup_collision(
obj_grid, vir_time // 1)
obj_mandalorian.check_obstacle_collision(
obj_grid, start, vir_time // 1)
change = 0
if obj_mandalorian.get_row() + (obj_mandalorian.get_row(
) - last_up) // 10 + 1 < screen_rows - 5:
change = (obj_mandalorian.get_row() -
last_up) // 10 + 1
elif screen_rows - 6 - obj_mandalorian.get_row() > 0:
change = screen_rows - 6 - obj_mandalorian.get_row()
last_up = screen_rows - 6
for j in range(change):
if obj_grid.get_grid(
obj_mandalorian.get_row() + 3,
obj_mandalorian.get_column()
) != Fore.MAGENTA + Style.BRIGHT + "%" + Style.RESET_ALL and obj_grid.get_grid(
obj_mandalorian.get_row() + 3,
obj_mandalorian.get_column() + 1
) != Fore.MAGENTA + Style.BRIGHT + "%" + Style.RESET_ALL and obj_grid.get_grid(
obj_mandalorian.get_row() + 3,
obj_mandalorian.get_column() + 2
) != Fore.MAGENTA + Style.BRIGHT + "%" + Style.RESET_ALL:
obj_mandalorian.change_row(+1)
obj_mandalorian.check_coin_collision(obj_grid)
obj_mandalorian.check_powerup_collision(
obj_grid, vir_time // 1)
obj_mandalorian.check_obstacle_collision(
obj_grid, start, vir_time // 1)
else:
break
obj_mandalorian.reappear_mandalorian(obj_grid, 0)
elif obj_mandalorian.get_shield() == 1:
if obj_mandalorian.get_column() + 4 < screen_columns + start:
obj_mandalorian.disappear_mandalorian(obj_grid)
if obj_grid.get_grid(
obj_mandalorian.get_row(),
obj_mandalorian.get_column() + 4
) != Fore.MAGENTA + Style.BRIGHT + "%" + Style.RESET_ALL and obj_grid.get_grid(
obj_mandalorian.get_row() + 1,
obj_mandalorian.get_column() + 4
) != Fore.MAGENTA + Style.BRIGHT + "%" + Style.RESET_ALL and obj_grid.get_grid(
obj_mandalorian.get_row() + 2,
obj_mandalorian.get_column() + 4
) != Fore.MAGENTA + Style.BRIGHT + "%" + Style.RESET_ALL:
obj_mandalorian.change_column(+1)
obj_mandalorian.check_coin_collision(obj_grid)
obj_mandalorian.check_powerup_collision(
obj_grid, vir_time // 1)
obj_mandalorian.check_obstacle_collision(
obj_grid, start, vir_time // 1)
change = 0
if obj_mandalorian.get_row() + (obj_mandalorian.get_row(
) - last_up) // 10 + 1 < screen_rows - 5:
change = (obj_mandalorian.get_row() -
last_up) // 10 + 1
elif screen_rows - 6 - obj_mandalorian.get_row() > 0:
change = screen_rows - 6 - obj_mandalorian.get_row()
last_up = screen_rows - 6
for j in range(change):
if obj_grid.get_grid(
obj_mandalorian.get_row() + 3,
obj_mandalorian.get_column()
) != Fore.MAGENTA + Style.BRIGHT + "%" + Style.RESET_ALL and obj_grid.get_grid(
obj_mandalorian.get_row() + 3,
obj_mandalorian.get_column() + 1
) != Fore.MAGENTA + Style.BRIGHT + "%" + Style.RESET_ALL and obj_grid.get_grid(
obj_mandalorian.get_row() + 3,
obj_mandalorian.get_column() + 2
) != Fore.MAGENTA + Style.BRIGHT + "%" + Style.RESET_ALL and obj_grid.get_grid(
obj_mandalorian.get_row() + 3,
obj_mandalorian.get_column() + 3
) != Fore.MAGENTA + Style.BRIGHT + "%" + Style.RESET_ALL:
obj_mandalorian.change_row(+1)
obj_mandalorian.check_coin_collision(obj_grid)
obj_mandalorian.check_powerup_collision(
obj_grid, vir_time // 1)
obj_mandalorian.check_obstacle_collision(
obj_grid, start, vir_time // 1)
else:
break
obj_mandalorian.reappear_mandalorian(obj_grid, 0)
elif ch == 'a' or ch == 'S':
obj_mandalorian.disappear_mandalorian(obj_grid)
if obj_mandalorian.get_column() - 2 >= start:
if obj_grid.get_grid(
obj_mandalorian.get_row(),
obj_mandalorian.get_column() - 2
) != Fore.MAGENTA + Style.BRIGHT + "%" + Style.RESET_ALL and obj_grid.get_grid(
obj_mandalorian.get_row() + 1,
obj_mandalorian.get_column() - 2
) != Fore.MAGENTA + Style.BRIGHT + "%" + Style.RESET_ALL and obj_grid.get_grid(
obj_mandalorian.get_row() + 2,
obj_mandalorian.get_column() - 2
) != Fore.MAGENTA + Style.BRIGHT + "%" + Style.RESET_ALL:
obj_mandalorian.change_column(-2)
obj_mandalorian.check_coin_collision(obj_grid)
obj_mandalorian.check_powerup_collision(
obj_grid, vir_time // 1)
obj_mandalorian.check_obstacle_collision(
obj_grid, start, vir_time // 1)
change = 0
if obj_mandalorian.get_row() + (obj_mandalorian.get_row() - last_up
) // 10 + 1 < screen_rows - 5:
change = (obj_mandalorian.get_row() - last_up) // 10 + 1
elif screen_rows - 6 - obj_mandalorian.get_row() > 0:
change = screen_rows - 6 - obj_mandalorian.get_row()
last_up = screen_rows - 6
if obj_mandalorian.get_shield() == 1:
x = 3
else:
x = 0
for j in range(change):
if obj_grid.get_grid(
obj_mandalorian.get_row() + 3,
obj_mandalorian.get_column()
) != Fore.MAGENTA + Style.BRIGHT + "%" + Style.RESET_ALL and obj_grid.get_grid(
obj_mandalorian.get_row() + 3,
obj_mandalorian.get_column() + 1
) != Fore.MAGENTA + Style.BRIGHT + "%" + Style.RESET_ALL and obj_grid.get_grid(
obj_mandalorian.get_row() + 3,
obj_mandalorian.get_column() + 2
) != Fore.MAGENTA + Style.BRIGHT + "%" + Style.RESET_ALL and obj_grid.get_grid(
obj_mandalorian.get_row() + 3,
obj_mandalorian.get_column() + x
) != Fore.MAGENTA + Style.BRIGHT + "%" + Style.RESET_ALL:
obj_mandalorian.change_row(+1)
obj_mandalorian.check_coin_collision(obj_grid)
obj_mandalorian.check_powerup_collision(
obj_grid, vir_time // 1)
obj_mandalorian.check_obstacle_collision(
obj_grid, start, vir_time // 1)
else:
break
obj_mandalorian.reappear_mandalorian(obj_grid, 0)
elif ch == ' ':
if obj_mandalorian.get_column() + 3 < screen_columns + start:
if obj_grid.get_grid(
obj_mandalorian.get_row(),
obj_mandalorian.get_column() + 3
) != Fore.MAGENTA + Style.BRIGHT + "%" + Style.RESET_ALL and obj_grid.get_grid(
obj_mandalorian.get_row() + 1,
obj_mandalorian.get_column() + 3
) != Fore.MAGENTA + Style.BRIGHT + "%" + Style.RESET_ALL and obj_grid.get_grid(
obj_mandalorian.get_row() + 2,
obj_mandalorian.get_column() + 3
) != Fore.MAGENTA + Style.BRIGHT + "%" + Style.RESET_ALL:
obj_mandalorian.disappear_mandalorian(obj_grid)
obj_mandalorian.activate_shield(vir_time // 1)
obj_mandalorian.check_coin_collision(obj_grid)
obj_mandalorian.check_powerup_collision(
obj_grid, vir_time // 1)
obj_mandalorian.check_obstacle_collision(
obj_grid, start, vir_time // 1)
obj_mandalorian.reappear_mandalorian(obj_grid, 0)
else:
obj_mandalorian.disappear_mandalorian(obj_grid)
obj_mandalorian.change_column(-1)
obj_mandalorian.activate_shield(vir_time // 1)
obj_mandalorian.check_coin_collision(obj_grid)
obj_mandalorian.check_powerup_collision(
obj_grid, vir_time // 1)
obj_mandalorian.check_obstacle_collision(
obj_grid, start, vir_time // 1)
obj_mandalorian.reappear_mandalorian(obj_grid, 0)
elif ch == 'q' or ch == 'Q':
os.system('clear')
print(Style.BRIGHT + Fore.RED + 'Terminating Game ...' +
Style.RESET_ALL)
for i in range(30):
print()
time.sleep(1.5)
sys.exit(0)
elif ch == 's' or ch == 'S':
obj_mandalorian.shoot(obj_grid)
obj_mandalorian.disappear_mandalorian(obj_grid)
change = 0
if obj_mandalorian.get_row() + (obj_mandalorian.get_row() - last_up
) // 4 + 1 < screen_rows - 5:
change = (obj_mandalorian.get_row() - last_up) // 4 + 1
elif screen_rows - 6 - obj_mandalorian.get_row() > 0:
change = screen_rows - 6 - obj_mandalorian.get_row()
last_up = screen_rows - 6
if obj_mandalorian.get_shield() == 1:
x = 3
else:
x = 0
for j in range(change):
if obj_grid.get_grid(
obj_mandalorian.get_row() + 3,
obj_mandalorian.get_column()
) != Fore.MAGENTA + Style.BRIGHT + "%" + Style.RESET_ALL and obj_grid.get_grid(
obj_mandalorian.get_row() + 3,
obj_mandalorian.get_column() + 1
) != Fore.MAGENTA + Style.BRIGHT + "%" + Style.RESET_ALL and obj_grid.get_grid(
obj_mandalorian.get_row() + 3,
obj_mandalorian.get_column() + 2
) != Fore.MAGENTA + Style.BRIGHT + "%" + Style.RESET_ALL and obj_grid.get_grid(
obj_mandalorian.get_row() + 3,
obj_mandalorian.get_column() + x
) != Fore.MAGENTA + Style.BRIGHT + "%" + Style.RESET_ALL:
obj_mandalorian.change_row(+1)
obj_mandalorian.check_coin_collision(obj_grid)
obj_mandalorian.check_powerup_collision(
obj_grid, vir_time // 1)
obj_mandalorian.check_obstacle_collision(
obj_grid, start, vir_time // 1)
else:
break
obj_mandalorian.reappear_mandalorian(obj_grid, 0)
else:
obj_mandalorian.disappear_mandalorian(obj_grid)
change = 0
if obj_mandalorian.get_row() + (obj_mandalorian.get_row() - last_up
) // 10 + 1 < screen_rows - 5:
change = (obj_mandalorian.get_row() - last_up) // 10 + 1
elif screen_rows - 6 - obj_mandalorian.get_row() > 0:
change = screen_rows - 6 - obj_mandalorian.get_row()
last_up = screen_rows - 6
if obj_mandalorian.get_shield() == 1:
x = 3
else:
x = 0
for j in range(change):
if obj_grid.get_grid(
obj_mandalorian.get_row() + 3,
obj_mandalorian.get_column()
) != Fore.MAGENTA + Style.BRIGHT + "%" + Style.RESET_ALL and obj_grid.get_grid(
obj_mandalorian.get_row() + 3,
obj_mandalorian.get_column() + 1
) != Fore.MAGENTA + Style.BRIGHT + "%" + Style.RESET_ALL and obj_grid.get_grid(
obj_mandalorian.get_row() + 3,
obj_mandalorian.get_column() + 2
) != Fore.MAGENTA + Style.BRIGHT + "%" + Style.RESET_ALL and obj_grid.get_grid(
obj_mandalorian.get_row() + 3,
obj_mandalorian.get_column() + x
) != Fore.MAGENTA + Style.BRIGHT + "%" + Style.RESET_ALL:
obj_mandalorian.change_row(+1)
obj_mandalorian.check_coin_collision(obj_grid)
obj_mandalorian.check_powerup_collision(
obj_grid, vir_time // 1)
obj_mandalorian.check_obstacle_collision(
obj_grid, start, vir_time // 1)
else:
break
obj_mandalorian.reappear_mandalorian(obj_grid, 0)
return last_up
prev_time = cur_time()
prev_time1 = cur_time()
prev_time3 = cur_time()
flag = 0
last_up = 0
os.system('clear')
while obj_mandalorian.get_lives() > 0 and (
vir_time // 1 > 0) and obj_boss_enemy.get_lives() > 0:
if cur_time() - prev_time1 > 90:
vir_time -= 0.5
prev_time1 = cur_time()
obj_mandalorian.check_shield(vir_time, obj_grid)
obj_mandalorian.check_powerup(vir_time)
if cur_time() - prev_time3 > 100:
obj_mandalorian.disappear_mandalorian(obj_grid)
last_up = check_magnet_range(screen_columns, start,
obj_mandalorian, last_up, obj_grid,
vir_time // 1, magnet_arr)
obj_mandalorian.reappear_mandalorian(obj_grid, 0)
prev_time3 = cur_time()
if start == obj_grid.get_grid_columns() - screen_columns and flag == 0:
prev_time2 = vir_time // 1
flag = 1
if start != obj_grid.get_grid_columns() - screen_columns:
tt = cur_time()
if tt - prev_time > 60:
prev_time = tt
change = 0
if obj_mandalorian.get_powerup_status(vir_time // 1):
if start + 3 < obj_grid.get_grid_columns(
) - screen_columns + 1:
change = 3
elif start + 2 < obj_grid.get_grid_columns(
) - screen_columns + 1:
change = 2
elif start + 1 < obj_grid.get_grid_columns(
) - screen_columns + 1:
change = 1
else:
change = 1
obj_mandalorian.disappear_mandalorian(obj_grid)
for k in range(change):
if obj_mandalorian.get_shield == 0:
x = 0
else:
x = 1
if obj_grid.get_grid(
obj_mandalorian.get_row(),
obj_mandalorian.get_column() + 3 + x
) != Fore.MAGENTA + Style.BRIGHT + "%" + Style.RESET_ALL and obj_grid.get_grid(
obj_mandalorian.get_row() + 1,
obj_mandalorian.get_column() + 3 + x
) != Fore.MAGENTA + Style.BRIGHT + "%" + Style.RESET_ALL and obj_grid.get_grid(
obj_mandalorian.get_row() + 2,
obj_mandalorian.get_column() + 3 + x
) != Fore.MAGENTA + Style.BRIGHT + "%" + Style.RESET_ALL:
start = start + 1
obj_mandalorian.change_column(+1)
obj_mandalorian.check_coin_collision(obj_grid)
obj_mandalorian.check_powerup_collision(
obj_grid, vir_time // 1)
obj_mandalorian.check_obstacle_collision(
obj_grid, start, vir_time // 1)
obj_mandalorian.move_bullets(obj_grid, start, screen_columns,
obj_boss_enemy, vir_time // 1)
obj_mandalorian.reappear_mandalorian(obj_grid, 0)
else:
tt = cur_time()
if tt - prev_time > 60:
prev_time = tt
obj_mandalorian.move_bullets(obj_grid, start, screen_columns,
obj_boss_enemy, vir_time // 1)
obj_boss_enemy.move_bullets(obj_grid, start, screen_columns,
obj_mandalorian, vir_time // 1)
if prev_time2 - vir_time // 1 > 3:
prev_time2 = vir_time // 1
obj_boss_enemy.shoot(obj_grid)
print("\033[0;0H", end="")
st = ""
for i in range(obj_grid.get_grid_rows()):
for j in range(start, screen_columns + start):
st += obj_grid.get_grid(i, j)
st += "\n"
print(st)
print("\033[0K", end="")
st1 = ""
st1 = st1 + "ЁЯТ╡ :" + str(
obj_mandalorian.get_coins()) + " " + "lives = "
for i in range(obj_mandalorian.get_lives()):
st1 = st1 + 'тЭдя╕П '
for i in range(obj_mandalorian.get_max_lives() -
obj_mandalorian.get_lives()):
st1 = st1 + ' '
st1 = st1 + " " + "enemy_lives = "
for i in range(obj_boss_enemy.get_lives()):
st1 = st1 + 'тЭдя╕П '
for i in range(obj_boss_enemy.get_max_lives() -
obj_boss_enemy.get_lives()):
st1 = st1 + ' '
st1 = st1 + " " + "time remaining = " + str(
vir_time // 1) + " " + "shield = " + str(
obj_mandalorian.get_shield_availability()) + "\n"
print(st1, end="\r")
last_up = move_mandalorian(last_up)
obj_boss_enemy.move_boss_enemy(obj_grid, obj_mandalorian)
os.system('clear')
if obj_mandalorian.get_lives() <= 0:
with open('resources/youlose_ascii.txt') as f:
while True:
c = f.read(1)
if not c:
break
else:
print(Fore.RED + Style.BRIGHT + c + Style.RESET_ALL,
end="")
for i in range(25):
print()
elif obj_boss_enemy.get_lives() <= 0:
while (obj_mandalorian.get_column() !=
obj_grid.get_grid_columns() - 4):
obj_boss_enemy.disappear_boss_enemy(obj_grid)
if cur_time() - prev_time1 > 20:
prev_time1 = cur_time()
obj_mandalorian.disappear_mandalorian(obj_grid)
obj_mandalorian.change_column(+1)
obj_mandalorian.reappear_mandalorian(obj_grid, 0)
print("\033[0;0H", end="")
st = ""
for i in range(obj_grid.get_grid_rows()):
for j in range(start, screen_columns + start):
st += obj_grid.get_grid(i, j)
st += "\n"
print(st)
print("\033[0K", end="")
st1 = ""
st1 = st1 + "ЁЯТ╡ :" + str(
obj_mandalorian.get_coins()) + " " + "lives = "
for i in range(obj_mandalorian.get_lives()):
st1 = st1 + 'тЭдя╕П '
for i in range(obj_mandalorian.get_max_lives() -
obj_mandalorian.get_lives()):
st1 = st1 + ' '
st1 = st1 + " " + "enemy_lives = "
for i in range(obj_boss_enemy.get_lives()):
st1 = st1 + 'тЭдя╕П '
for i in range(obj_boss_enemy.get_max_lives() -
obj_boss_enemy.get_lives()):
st1 = st1 + ' '
st1 = st1 + " " + "time remaining = " + str(
vir_time // 1) + " " + "shield = " + str(
obj_mandalorian.get_shield_availability()) + "\n"
print(st1, end="\r")
with open('resources/youwin_ascii.txt') as f:
while True:
c = f.read(1)
if not c:
break
else:
print(Fore.RED + Style.BRIGHT + c + Style.RESET_ALL,
end="")
for i in range(25):
print()
else:
with open('resources/youlose_ascii.txt') as f:
while True:
c = f.read(1)
if not c:
break
else:
print(Fore.RED + Style.BRIGHT + c + Style.RESET_ALL,
end="")
for i in range(25):
print()
thread[nbPlayer - 1].start()
nbPlayer = 0
scoreJ1 = 0
scoreJ2 = 0
winTest1 = False
winTest2 = False
winDraw = False
inGame = False
s = socket.socket(socket.AF_INET6, socket.SOCK_STREAM, 0)
l = []
shotPlayed = []
whoPayed = []
gridLogic = grid() # Une seule grille logique
#MAIN
i = 0
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
s.bind(('localhost', 7777))
s.listen(1)
l.append(s)
os.system('clear')
print("En attente de joueurs...")
threading.Thread(None, connect, None).start()
while True:
if nbPlayer >= 2 and inGame == False:
os.system('clear')
print("Début d'une partie")
inGame = True
def test_grid_size(self):
self.assertEqual(len(grid().createGrid(4, 4)), 8)
self.assertEqual(len(grid().createGrid(4, 4)[0]), 8)
def main():
score = 0
if len(sys.argv) == 1:
s = socket.socket(socket.AF_INET6, socket.SOCK_STREAM, 0)
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
s.bind((HOST, PORT))
s.listen(1)
liste = [] #liste contient tous les clients
while True:
socketList, _, _ = select.select(
liste + [s], [], []) #contient la liste des sockets en lecture
for n in socketList: #on parcourt la liste des sockets
if (
n == s
): #si n est la socket d'écoute (çàd un client vient de se connecter)
connex, _ = s.accept(
) #on créé une nouvelle connexion entre le client et le serveur
liste.append(
connex) #que l'on ajoute à la liste des clients
if len(liste) == 1:
connex.send("1".encode())
if len(liste) == 2:
connex.send("2".encode())
if len(liste) > 2:
connex.send("Spectator".encode())
else:
data = n.recv(1500)
if (data == 0):
n.close()
liste.remove(n)
break #siginifie arrête toi là et passe à l'itération suivante
for i in liste:
if (
i != n
): #si la socket est différente de celle qui nous a envoyé un message
i.send(
data
) #on envoie à toutes les autres socket le message envoyé par s
#End of server
elif len(sys.argv) == 2:
s = socket.socket(family=socket.AF_INET6,
type=socket.SOCK_STREAM,
proto=0,
fileno=None)
s.connect((HOST, 7777))
string_player = s.recv(1500).decode()
if string_player == "1":
current_player = J1
elif string_player == "2":
current_player = J2
elif string_player == "Spectator":
current_player = 0
if current_player == 1 or current_player == 2:
print("You are the player " + str(current_player))
else:
print("You are a spectator")
while True:
grids = [grid(), grid(), grid()]
grids[J1].display()
while grids[0].gameOver() == -1:
shot = -1
if current_player == J1:
while True:
tmp = input("In which position do you want to play? ")
if ord(tmp) >= 48 and ord(
tmp) <= 56: #conversion en ascii
shot = ord(tmp) - 48
if shot >= 0 and shot < NB_CELLS:
break
else:
print("You should choose between 0 and 8.")
if (grids[0].cells[shot] != EMPTY):
grids[J1].cells[shot] = grids[0].cells[shot]
grids[J1].display()
else:
grids[J1].cells[shot] = current_player
grids[0].play(J1, shot)
grids[J1].display()
shot_to_send = bytes(str(shot), "ascii")
s.send(shot_to_send)
current_player = current_player % 2 + 1
else:
shot = int(s.recv(1500))
grids[0].play(current_player, shot)
if current_player == 0: #pour le mode spectateur
grids[0].display()
else:
current_player = current_player % 2 + 1
print("Game over")
grids[0].display()
if grids[0].gameOver() == J1:
print("You win !")
score += 1
else:
print("You lose !")
print("Score : " + str(score))
"""-------Allows the player to play again-------"""
answer = ''
while answer != 'y' or answer != 'n':
answer = input("Do you want to continue? y/n ")
print(answer)
if answer == 'y' or answer == 'n':
break
if answer == 'n':
break
"""---------------------------------------------"""
def test_grid_0(self):
self.assertEqual(len(grid().createGrid(0, 0)), 0)
elif arg == '--spacing':
try:
spacing = int(args.pop())
except ValueError:
print '--spacing requires an integer'
elif arg == '--img':
try:
backgroundimg = arg
except IndexError:
print '--img requires a string'
# Startup!
pygame.init()
pygame.display.set_caption('SimpleMap')
grid = grid(spacing, gridsize)
size = width, height = grid.size
#size = width, height + 20 + grid.s
screen = pygame.display.set_mode(size)
print 'Size: ' + str(size)
background = pygame.Surface(screen.get_size())
background = background.convert()
background = pygame.image.load(backgroundimg)
#pygame.transform.crop(background,grid.size)
#background.fill(white)
# grid( spacing, width/hieght in tiles, origin point )
grid.draw(screen)
grid.draw_darkness(screen)
grid.draw_tokens(screen)
m_store = 0 # initial storage, in kg capex_kw = 1400 # capital cost per kW cap_op_ratio = 0.02 # capital cost operational cost ratio pem_lifetime = 20 # lifetime of pem fuel cell # yearly electricity price for PEM (for hybrid system it equals to 0) price_ePEM = [0.0] * pem_lifetime ############################################### ############################################### # generate grid demand ############################################### uk_grid = grid(dataMode, inFile, multiplier) uk_grid.gen() uk_grid.demand_plot() time = uk_grid.aquire_time() P_demand = uk_grid.aquire_demand() time = time[0:10] P_demand = P_demand[0:10] #time = time[0:48] #P_demand = P_demand[0:48] uk_grid.user_demand_plot(time, P_demand) ############################################### # economic data of the hybrid system
step = 1
best_loss = 0.6
for epoch in range(args.epochs):
running_loss = 0.0
total_bz = 0
net.zero_grad()
net.train()
grid.set_prob(epoch, args.epochs)
for itr, (data, label) in enumerate(dataloader_train):
bz = data.shape[0]
total_bz += bz
optimizer.zero_grad()
data = data.cuda()
# use gridmask
data = grid(data)
output = net(data).squeeze()
label = label.cuda()
loss = criterion(output, label)
loss.backward()
optimizer.step()
running_loss += loss.item() * bz
# get acc
train_acc = ((output > 0) == label).sum().float().item() / bz
writer.add_scalar("Loss/train", loss.item(), step)
writer.add_scalar("Acc/train", train_acc, step)
step += 1
if not itr % 50:
logger.info(
'[EPOCH %d ITER %3d/%d] train acc: %.8f, train loss: %.8f (%.4f)'
break
elif CharacterIndex == 4:
print "Now go get a soul"
characterselected = "true"
break
elif CharacterIndex == 5:
print "Mayeth your adventure be exquisite"
characterselected = "true"
break
elif CharacterIndex == 6:
print "You may even find Luna"
characterselected = "true"
break
elif CharacterIndex == 7:
print "Don't tap out!"
characterselected = "true"
break
else:
print "sigh, try again"
print "\n \n It was a plain and simple Saturday night in the man cave with a few good gamer mates, when Anton found a small free multiplayer indie cross platform action rpg puzzel fps with an live rts element to assist other players against a perfectly weighted dynamic 1st/3rd person adventure game."
grid = grid((0, 0, 20, 20), default="F")
print "MINECRAFT!"
print "Later..."
print "Entering nether portal..."
print "Error: Unknown Error, Auto debug?"
print "Teleporting...\n *In minecraft*"
print "Fixing..."
print "Backup loaded."
print "*now in HNRPG*"
def test_grid_types_quick(self):
self.assertEqual(type(grid().createGrid(4, 4)), list)
self.assertEqual(type(grid().createGrid(4, 4)[0]), list)
self.assertEqual(type(grid().createGrid(4, 4)[0][0]), dict)
def __init__(self):
self.child_elements = []
self.child_ids = {}
self.focus_grid = []
element.__init__(self)
self.focus_grid = grid()
def __init__(self):
self.child_elements = []
self.child_ids = {}
self.focus_grid = []
element.__init__(self)
self.focus_grid = grid()
print("Usage:", sys.argv[0] , "<output grid> <#cols> <#rows> <#iterations> <minimal radius> <maximal radius> <distance> [include_boundary=0]", file=sys.stderr)
sys.exit(0)
outfile_path = sys.argv[1]
num_cols = int(sys.argv[2])
num_rows = int(sys.argv[3])
max_iter = int(sys.argv[4])
min_radius = int(sys.argv[5])
max_radius = int(sys.argv[6])
distance = int(sys.argv[7])
include_boundary = False
if len(sys.argv) >= 9:
include_boundary = (int(sys.argv[8]) == 1)
g = grid(num_cols, num_rows)
x_range = range(1, num_cols - 2) if include_boundary else range(0, num_cols)
y_range = range(1, num_rows - 2) if include_boundary else range(0, num_rows)
indices = itertools.product(x_range, y_range)
iters = 0
while iters < max_iter:
for x, y in indices:
radius = random.randint(min_radius, max_radius)
if g.add_shape(circle([x, y], radius), distance, include_boundary):
iters += 1
print(iters)
from grid import *
SQUARESIZE = 100
NUM_ROWS =3
NUM_COLS = 3
WIDTH = (NUM_COLS+1) * SQUARESIZE
HEIGHT = NUM_ROWS * SQUARESIZE
pygame.init()
screen = pygame.display.set_mode([WIDTH, HEIGHT])
pygame.display.set_caption("Tic-Tac-Toe")
font = pygame.font.SysFont("comicsans" , 20 ,True)
board = grid()
run = True
player = "X"
while run :
for event in pygame.event.get():
if event.type == pygame.QUIT:
run = False
if event.type == pygame.MOUSEBUTTONDOWN and not board.get_game_over():
if pygame.mouse.get_pressed()[0]:
pos = pygame.mouse.get_pos()
board.get_mouse(pos[0] // 100 , pos[1] // 100 , player)
if board.get_switch_player() == True:
if player == 'X' :
player = 'O'
else:
player = 'X'
max_n = int(sys.argv[10])
def make_branch(grid, pos, width, distance, n):
if n <= max_n and not (pos[0] > num_cols - 2 or pos[1] > num_rows - 2 or pos[0] < 1 or pos[1] < 1):
lengthrand = random.randint(lengthlow, lengthhigh)
distrand = random.randint(distancelow, distancehigh)
grid.add_shape(rectangle(pos, [pos[0] + lengthrand, pos[1] + width - 1]))
if random.randint(0, 100) >= dead_perc:
if grid.add_shape(zigzag([pos[0] + 1 + lengthrand - width, pos[1] + width], width, distrand), 1):
make_branch(
grid, [pos[0] + 1 + lengthrand + distrand, pos[1] + distrand + width], width, distrand, n + 1
)
if random.randint(0, 100) >= dead_perc:
if grid.add_shape(zigzag([pos[0] + 1 + lengthrand - width, pos[1] - 1], width, -distrand), 1):
make_branch(
grid, [pos[0] + 1 + lengthrand + distrand, pos[1] - 1 - distrand - width], width, distrand, n + 1
)
g = grid(num_cols, num_rows, inverted=True)
start_y = 1 + (num_rows - 2) / 2 - width / 2
make_branch(g, [1, start_y], width, random.randint(distancelow, distancehigh), 1)
g.apply_shapes()
g.write_to(outfile_path)
# for split in range(num_splits + 1):
import datetime
import time
from grid import *
from UI import *
from printSTL import *
##Instatiate the objects used to create the grid and generate the 3d points
gridFun = grid()
app = MyKnotworkWidget()
##run a test by generating a rxc grid
##r = number of rows
##c = number of columns
def testGrid(r, c):
grid=[]
time1 = time.clock()
grid = gridFun.createGrid(r,c)
grid = gridFun.detEdgecode(grid)
grid = gridFun.setBandNumber(grid)
time2 = time.clock()
return time2-time1
##run n tests generating a rxc grid
##n = number of tests
##r = number of rows
##c = number of columns
def testGridMult(n, r, c):
print("starting test Grid "+str(r)+"x"+str(c))
time = []
def test_grid_neg(self):
self.assertEqual(len(grid().createGrid(-10, -10)), 0)
###Objective function
def g(x,w1,w2):
val=(w2)/(w1)
return -(val)*(x**2)-w1
n1=1
n2=1
varianceW2givenW1=1.0
dimensionKernel=2
trainingPoints=int(sys.argv[2])
numberSamplesForF=int(sys.argv[3])
lowerX=[-3.0]
UpperX=[3.0]
nGrid=50
pointsVOI=grid(lowerX,UpperX,nGrid)
###parameters of w1
varianceW1=np.array(1.0).reshape(1)
muW1=np.array(0.0).reshape(1)
def noisyF(XW,n):
X=XW[0,0:n1]
W=XW[0,n1:n1+n2]
t=np.array(np.random.normal(W,varianceW2givenW1,n))
t=g(X,W,t)
return np.mean(t),float(np.var(t))/n
def simulatorW(n):
def build(self):
def checkValue(val, default, flt, allowz):
'''Check that val is a positive number, else set it to the absolute value or default. If flt then the number returned a a float (else trailing decimal places are removed). if allowz then val can be zero'''
if len(val) == 0:
if flt:
return default
else:
return default
if (not allowz and val == "0"):
return default
if val.isdigit():
if flt:
return float(val)
else:
return int(val)
try:
return int(math.sqrt(int(float(val))**2))
except:
pass
return default
def plotButtonPressed(instance):
'''Called on_text_validate when new text is entered in x, y, gridUnits, width. Redraws the knot'''
plotKnotCheck()
def plotKnotCheck():
'''Check that no new breaklines have been addded (a warning is shown when you have breaklines that will be erased)'''
if self.app.getAddedBLS():
content = PlotDialog(cancel=dismiss_popup, plot=plotKnotAcc)#show warning
self._popup = Popup(title="Plot new Knot", content=content, size_hint=(0.3, 0.3))
self._popup.open()
else:
plotKnotAcc() #replot knot
def plotKnotAcc():
'''Replots the knot and validate any input'''
try:
dismiss_popup() #there may or may not be a popup
except:
pass
self.app.clearCanvas()
##Validate datat
self.gridUnits = checkValue(self.gridUnitsI.text, 50, False, False)
self.gridUnitsI.text = str(self.gridUnits)
self.X.text = str(checkValue(self.X.text, 4, False, False))
self.Y.text = str(checkValue(self.Y.text, 4, False, False))
self.WidthI.text = str(checkValue(self.WidthI.text, 8.0, True, False))
#Create a new grid
self.grid = grid().createGrid(int(self.X.text),int(self.Y.text))
self.grid = grid().detEdgecode(self.grid)
self.grid = grid().setBandNumber(self.grid)
#set sizing so the knot doesnt cover interface elements
self.knotX = int(self.X.text)*2
self.knotY = int(self.Y.text)*2
viewWidth = Window.width*0.52
viewHeight = Window.height-110
if ((viewWidth)/self.knotX < (viewHeight)/self.knotY):
self.gridUnitsView = (viewWidth)/self.knotX
else:
self.gridUnitsView = (viewHeight)/self.knotY
self.knotWidthView = (float(self.WidthI.text)/self.gridUnits)*self.gridUnitsView
self.spacing = self.knotWidthView
if self.knotWidthView < 1:
self.knotWidthView = 1
self.offsetX = Window.width*0.25 - self.gridUnitsView
self.offsetY = Window.height*0.05 - self.gridUnitsView
##Print the new knot
printKnot()
def printKnot():
'''Print knot (and additional elements such as the grid) based on various parameters'''
self.app.clearCanvas()
if (self.showDots):
self.app.printPoints(self.grid, self.gridUnitsView, self.offsetX, self.offsetY)
if (self.showGrid):
self.app.printGrid(self.grid, self.gridUnitsView, self.offsetX, self.offsetY)
if (self.showBreaklines):
self.app.printBreaklines(self.grid, self.gridUnitsView, self.offsetX, self.offsetY)
if (self.showSkeleton):
self.app.printKnot(self.grid, self.gridUnitsView,2, self.spacing,self.offsetX, self.offsetY)
if (self.showKnot):
time1 = datetime.datetime.now()
self.app.printFinalKnot(self.grid, self.gridUnitsView,self.knotWidthView, self.spacing,self.curve.value,self.offsetX, self.offsetY, self.cornerType)
time2 = datetime.datetime.now()
print("Time taken to draw knot: "+str(time2-time1)) #shows time taken to print the knot
def toggleDotsPressed(instance, value):
'''Toggles Dot display'''
if (self.showDots):
self.toggleDotsL.text = "Show (D)ots" #change label
self.toggleDots.active = False #change value of checkbox (for keyboard input)
self.showDots = False
else:
self.toggleDotsL.text = "Hide (D)ots"
self.toggleDots.active = True
self.showDots = True
printKnot() #printKnot()
def toggleGridPressed(instance, value):
'''toggle grid display'''
if (self.showGrid):
self.toggleGridL.text = "Show (G)rid" #change label
self.toggleGrid.active = False #change value of textbox (for keyboard input)
self.showGrid = False
else:
self.toggleGridL.text = "Hide (G)rid"
self.toggleGrid.active = True
self.showGrid = True
printKnot()
def toggleBreaklinesPressed(instance, value):
'''Toggle breaklines display'''
if (self.showBreaklines):
self.toggleBreaklinesL.text = "Show (B)reaklines" #change label
self.toggleBreaklines.active = False #change value of textbox (for keyboard input)
self.showBreaklines = False
else:
self.toggleBreaklinesL.text = "Hide (B)reaklines"
self.toggleBreaklines.active = True
self.showBreaklines = True
printKnot()
def toggleSkeletonPressed(instance, value):
'''Toggle skeleton display'''
if (self.showSkeleton):
self.toggleSkeletonL.text = "Show (S)keleton" #change label
self.toggleSkeleton.active = False #change value of textbox (for keyboard input)
self.showSkeleton = False
else:
self.toggleSkeletonL.text = "Hide (S)keleton"
self.toggleSkeleton.active = True
self.showSkeleton = True
printKnot()
def toggleKnotPressed(instance, value):
'''Toggle final knot display'''
if (self.showKnot):
self.toggleKnotL.text = "Show (K)not" #change label
self.toggleKnot.active = False #change value of textbox (for keyboard input)
self.showKnot = False
else:
self.toggleKnotL.text = "Hide (K)not"
self.toggleKnot.active = True
self.showKnot = True
printKnot()
def addBreaklinePressed(instance):
'''Start the add breaklines interface'''
self.addBreakline.unbind(on_press=addBreaklinePressed)
self.addBreakline.bind(on_press=addBreaklinePressed2)
self.addBreakline.text="(A) Done"#Change text label
self.app.setOnBreaklines(True)
##Check values
if (self.WidthI.text[0] == "-"):
self.WidthI.text = self.WidthI.text[1:]
if re.search('[a-zA-Z]+',self.WidthI.text):
self.WidthI.text = "8"
##start draw breaklines interface
self.app.drawAddBreakline(self.grid, self.gridUnitsView, self.offsetX, self.offsetY, self.knotWidthView, self.spacing,self.curve.value, self.cornerType)
def addBreaklinePressed2(instance):
'''End the add breaklines interface'''
self.addBreakline.unbind(on_press=addBreaklinePressed2)
self.addBreakline.text="(A)dd Breaklines"
##reset grid properties
self.grid = grid().detEdgecode(self.grid)
self.grid = grid().setBandNumber(self.grid)
printKnot()
self.app.setOnBreaklines(False)
self.addBreakline.bind(on_press=addBreaklinePressed)
def output3DPressed(instance):
'''Output 3D button pressed'''
#unbind keyboard shortcuts
try:
self._keyboard.unbind(on_key_down=_on_keyboard_down)
self._keyboard = None
except:
pass
#display config popup
content = output3DPopup(cancel=dismiss_popup, save=savePressed3D)
content.plot2(10, 20, 3, 10, 11, 10)
self._popup = Popup(title="Output 3D", content=content, size_hint=(0.9, 0.9))
self._popup.open()
def cornerButton1Pressed():
'''Set corner type to 0 (right angle)'''
self.cornerType = 0
printKnot()
def cornerButton2Pressed():
'''Set corner type to 1 (curve)'''
self.cornerType = 1
printKnot()
def on_resize(window, height, somethingesle):
'''Called on window resize - sets size of knot to fit within screen'''
self.knotX = int(self.X.text)*2
self.knotY = int(self.Y.text)*2
viewWidth = window.width*0.52
viewHeight = window.height-110
if ((viewWidth)/self.knotX < (viewHeight)/self.knotY):
self.gridUnitsView = (viewWidth)/self.knotX
else:
self.gridUnitsView = (viewHeight)/self.knotY
self.knotWidthView = (float(self.WidthI.text)/self.gridUnits)*self.gridUnitsView
self.spacing = self.knotWidthView
if self.knotWidthView < 1:
self.knotWidthView = 1
self.offsetX = window.width*0.25 - self.gridUnitsView
self.offsetY = window.height*0.05 - self.gridUnitsView
printKnot()
def savePressed3D(width, height, radius, tri, overlap, cyl):
'''Opens save 3D dialogue, and stores settings for the 3D model to be used on save'''
dismiss_popup()
##Store variables to be used later
self.tdwidth = checkValue(width, 10.0, True, False)
self.tdheight = checkValue(height, 20.0, True, False)
self.tdradius = checkValue(radius, 3.0, True, True)
self.tdtri = checkValue(tri, 10, False, False)
self.tdoverlap = checkValue(overlap, 11.0, True, False)
self.tdcyl = checkValue(cyl, 10, False, False)
##open the save dialogue
content = SaveDialog(save=save3D, cancel=dismiss_popup)
self._popup = Popup(title="Save file", content=content,
size_hint=(0.9, 0.9))
self._popup.open()
def save3D(path, filename):
'''Saves the 3D output to path/filename'''
##Generate the points
points = self.app.getKnotPointsbyBand(self.grid,self.tdcyl, self.gridUnits, self.offsetX, self.offsetY, self.cornerType, self.tdoverlap)
##Generate the 3D model
genCyl3(points, self.tdwidth, self.tdheight, self.tdradius, self.tdcyl, path+"/"+filename)
dismiss_popup()
def savePressed():
'''Opens the save dialogue'''
##Unbind keyboard, so shortcuts no longer running
self._keyboard.unbind(on_key_down=_on_keyboard_down)
self._keyboard = None
content = SaveDialog(save=save, cancel=dismiss_popup)
self._popup = Popup(title="Save file", content=content,
size_hint=(0.9, 0.9))
self._popup.open()
def show_load():
'''OPens the load dialogue'''
##Unbind keyboard, so shortcuts no longer running
self._keyboard.unbind(on_key_down=_on_keyboard_down)
self._keyboard = None
content = LoadDialog(load=load, cancel=dismiss_popup)
self._popup = Popup(title="Load file", content=content,
size_hint=(0.9, 0.9))
self._popup.open()
def dismiss_popup():
'''Close popups'''
##initiate the keyboard fo rshortcuts
self._keyboard = Window.request_keyboard(_keyboard_closed, self, 'text')
if self._keyboard.widget:
# If it exists, this widget is a VKeyboard object which you can use
# to change the keyboard layout.
pass
self._keyboard.bind(on_key_down=_on_keyboard_down)
self._popup.dismiss()
def save(path, filename):
'''Save the knot to path/filename'''
f = open(path+"/"+filename, 'w')
simplejson.dump(self.grid, f)
f.close()
dismiss_popup()
def load(path, filename):
'''load the knot from path/filename'''
f = open(filename[0].replace("u", ""), 'r')
self.grid = simplejson.load(f)
f.close()
##Set sizing of knot
self.knotX = len(self.grid[0])
self.X.text = str(len(self.grid[0])//2)
self.knotY = len(self.grid)
self.Y.text = str(len(self.grid)//2)
viewWidth = Window.width*0.52
viewHeight = Window.height-110
if ((viewWidth)/self.knotX < (viewHeight)/self.knotY):
self.gridUnitsView = (viewWidth)/self.knotX
else:
self.gridUnitsView = (viewHeight)/self.knotY
self.knotWidthView = (float(self.WidthI.text)/self.gridUnits)*self.gridUnitsView
self.spacing = self.knotWidthView
if self.knotWidthView < 1:
self.knotWidthView = 1
self.offsetX = Window.width*0.25 - self.gridUnitsView
self.offsetY = Window.height*0.05 - self.gridUnitsView
printKnot()
dismiss_popup()
def _keyboard_closed():
'''Close the keyboard'''
print('My keyboard have been closed!')
try:
self._keyboard.unbind(on_key_down=_on_keyboard_down)
self._keyboard = None
except:
pass
def _on_keyboard_down(keyboard, keycode, text, modifiers):
'''Handles keyboard shortcuts'''
print('The key', keycode, 'have been pressed')
print(' - text is %r' % text)
print(' - modifiers are %r' % modifiers)
if keycode[1] == "d":
toggleDotsPressed(self.toggleDots, 0)
elif keycode[1] == "g":
toggleGridPressed(self.toggleGrid, 0)
elif keycode[1] == "b":
toggleBreaklinesPressed(self.toggleBreaklines, 0)
elif keycode[1] == "s" and len(modifiers) == 0:
toggleSkeletonPressed(self.toggleSkeleton, 0)
elif keycode[1] == "k":
toggleKnotPressed(self.toggleKnot, 0)
elif keycode[1] == "a":
if self.addBreakline.text == "(A) Done":
addBreaklinePressed2(self.addBreakline)
else:
addBreaklinePressed(self.addBreakline)
elif keycode[1] == "o" and len(modifiers) == 0:
output3DPressed(self.output3D)
elif len(modifiers) == 1 and (keycode[1] == "z" and (modifiers[0]=="ctrl" or modifiers[0]=="meta")):
self.app.backFuntion()
if self.app.getOnBreaklines() == False:
printKnot()
elif len(modifiers)==2 and (keycode[1] == "z" and modifiers[0]=="shift" and (modifiers[1]=="ctrl" or modifiers[1]=="meta")):
self.app.forwardFunction()
if self.app.getOnBreaklines() == False:
printKnot()
elif len(modifiers) == 1 and (keycode[1] == "s" and (modifiers[0]=="ctrl" or modifiers[0]=="meta")):
savePressed()
elif len(modifiers) == 1 and (keycode[1] == "o" and (modifiers[0]=="ctrl" or modifiers[0]=="meta")):
show_load()
# Return True to accept the key. Otherwise, it will be used by
# the system.
return True
##Open the keyboard
self._keyboard = Window.request_keyboard(_keyboard_closed, self, 'text')
if self._keyboard.widget:
# If it exists, this widget is a VKeyboard object which you can use
# to change the keyboard layout.
pass
self._keyboard.bind(on_key_down=_on_keyboard_down)
##Instance Variables
self.showDots = True
self.showGrid = True
self.showBreaklines = True
self.showSkeleton = True
self.showKnot = True
self.knotX = 4
self.knotY = 4
self.knotWidth = 8
self.knotWidthView = 8
self.gridUnits = 50
self.gridUnitsView = 50
self.spacing = 10
self.offsetX = 150
self.offsetY = 50
self.totTabs = 1
self.tabNo = 1
self.cornerType = 0
Window.bind(on_resize=on_resize)
##Main Layout
layout_main = AnchorLayout(anchor_x = "left", anchor_y="top")
##Left hand bar - show/hide buttons and tools
layout_left = AnchorLayout(anchor_x='left', anchor_y="top")
layout_left_inner = BoxLayout(orientation= "vertical", size_hint=(0.2,1), padding =[0,0,0,0])
##Buttons on left layout
#Save Load
loadSaveButs = LoadSaveButtons(save = savePressed, load = show_load)
layout_left_inner.add_widget(loadSaveButs)
#Add Breakline
self.addBreakline = Button(text='(A)dd Breaklines')
self.addBreakline.bind(on_press=addBreaklinePressed)
layout_left_inner.add_widget(self.addBreakline)
#Show/Hide Dots
layouttd = BoxLayout(orientation= "horizontal", size_hint=(1, 1), padding =[0,0,0,0])
self.toggleDots = CheckBox(active = True)
self.toggleDotsL = Label(text='Hide (D)ots')
self.toggleDots.bind(active=toggleDotsPressed)
layouttd.add_widget(self.toggleDots)
layouttd.add_widget(self.toggleDotsL)
layout_left_inner.add_widget(layouttd)
#Show/Hide Grid
layouttg = BoxLayout(orientation= "horizontal", size_hint=(1, 1), padding =[0,0,0,0])
self.toggleGrid = CheckBox(active = True)
self.toggleGridL = Label(text='Hide (G)rid')
self.toggleGrid.bind(active=toggleGridPressed)
layouttg.add_widget(self.toggleGrid)
layouttg.add_widget(self.toggleGridL)
layout_left_inner.add_widget(layouttg)
#Show/Hide Breaklines
layouttb = BoxLayout(orientation= "horizontal", size_hint=(1, 1), padding =[0,0,0,0])
self.toggleBreaklines = CheckBox(active = True)
self.toggleBreaklinesL = Label(text='Hide (B)reaklines')
self.toggleBreaklines.bind(active=toggleBreaklinesPressed)
layouttb.add_widget(self.toggleBreaklines)
layouttb.add_widget(self.toggleBreaklinesL)
layout_left_inner.add_widget(layouttb)
#Show/Hide Skeleton
layoutts = BoxLayout(orientation= "horizontal", size_hint=(1, 1), padding =[0,0,0,0])
self.toggleSkeleton = CheckBox(active = True)
self.toggleSkeletonL = Label(text='Hide (S)keleton')
self.toggleSkeleton.bind(active=toggleSkeletonPressed)
layoutts.add_widget(self.toggleSkeleton)
layoutts.add_widget(self.toggleSkeletonL)
layout_left_inner.add_widget(layoutts)
#Show/Hide Final Knot
layouttk = BoxLayout(orientation= "horizontal", size_hint=(1, 1), padding =[0,0,0,0])
self.toggleKnot = CheckBox(active = True)
self.toggleKnotL = Label(text='Hide (K)not')
self.toggleKnot.bind(active=toggleKnotPressed)
layouttk.add_widget(self.toggleKnot)
layouttk.add_widget(self.toggleKnotL)
layout_left_inner.add_widget(layouttk)
##Add Left Layout to scene
layout_left.add_widget(layout_left_inner)
layout_main.add_widget(layout_left)
##Right hand bar - knot settings
layout_right = AnchorLayout(anchor_x='right', anchor_y="top")
layout_right_inner = BoxLayout(orientation= "vertical", size_hint=(0.2,1), padding =[0,0,0,0])
##buttons for right layout
#Grid Size
#X
self.labelX = Label(text='X =')
self.X = TextInput(text = "4",multiline=False)
self.X.bind(on_text_validate=plotButtonPressed)
layout_x = BoxLayout(orientation= "horizontal", size_hint=(1, 1), padding =[0,0,0,0])
layout_x.add_widget(self.labelX)
layout_x.add_widget(self.X)
layout_right_inner.add_widget(layout_x)
#Y
self.labelY = Label(text='Y =')
self.Y = TextInput(text = "4", multiline=False)
self.Y.bind(on_text_validate=plotButtonPressed)
layout_y = BoxLayout(orientation= "horizontal", size_hint=(1, 1), padding =[0,0,0,0])
layout_y.add_widget(self.labelY)
layout_y.add_widget(self.Y)
layout_right_inner.add_widget(layout_y)
#Grid Units
self.labelGU = Label(text='GridUnits =')
self.gridUnitsI = TextInput(text = "50", multiline=False)
self.gridUnitsI.bind(on_text_validate=plotButtonPressed)
layout_gu = BoxLayout(orientation= "horizontal", size_hint=(1, 1), padding =[0,0,0,0])
layout_gu.add_widget(self.labelGU)
layout_gu.add_widget(self.gridUnitsI)
layout_right_inner.add_widget(layout_gu)
#Width
self.labelWidth = Label(text='Width =')
self.WidthI = TextInput(text = "8", multiline=False)
self.WidthI.bind(on_text_validate=plotButtonPressed)
layout_w = BoxLayout(orientation= "horizontal", size_hint=(1, 1), padding =[0,0,0,0])
layout_w.add_widget(self.labelWidth)
layout_w.add_widget(self.WidthI)
layout_right_inner.add_widget(layout_w)
#corner Option
self.cornerLabel = Label(text="Corner")
layout_c = BoxLayout(orientation= "horizontal", size_hint=(1, 1), padding =[0,0,0,0])
cornerbuts = CornerButtons(b1 = cornerButton1Pressed, b2 = cornerButton2Pressed)
layout_right_inner.add_widget(self.cornerLabel)
layout_right_inner.add_widget(cornerbuts)
#Curve Slider
self.curveLabel = Label(text="Curvature")
self.curve = Slider(min=-1, max=1, value=0)
#Output 3D
self.output3D = Button(text='(O)utput 3D')
self.output3D.bind(on_press=output3DPressed)
layout_right_inner.add_widget(self.output3D)
##Add right layout to scene
layout_right.add_widget(layout_right_inner)
layout_main.add_widget(layout_right)
##Print Initial knot
self.app = MyKnotworkWidget()
self.grid = grid().createGrid(4,4)
self.grid = grid().detEdgecode(self.grid)
self.grid = grid().setBandNumber(self.grid)
self.gridUnits = checkValue(self.gridUnitsI.text, 50, False, False)
self.gridUnitsI.text = str(self.gridUnits)
self.X.text = str(checkValue(self.X.text, 4, False, False))
self.Y.text = str(checkValue(self.Y.text, 4, False, False))
self.WidthI.text = str(checkValue(self.WidthI.text, 8.0, True, False))
self.grid = grid().createGrid(int(self.X.text),int(self.Y.text))
self.grid = grid().detEdgecode(self.grid)
self.grid = grid().setBandNumber(self.grid)
self.knotX = int(self.X.text)*2
self.knotY = int(self.Y.text)*2
viewWidth = Window.width*0.52
viewHeight = Window.height-110
if ((viewWidth)/self.knotX < (viewHeight)/self.knotY):
self.gridUnitsView = (viewWidth)/self.knotX
else:
self.gridUnitsView = (viewHeight)/self.knotY
self.knotWidthView = (float(self.WidthI.text)/self.gridUnits)*self.gridUnitsView
self.spacing = self.knotWidthView
if self.knotWidthView < 1:
self.knotWidthView = 1
self.offsetX = Window.width*0.25 - self.gridUnitsView
self.offsetY = Window.height*0.05 - self.gridUnitsView
printKnot()
layout_main.add_widget(self.app)
return layout_main
