def __init__(self, width, height, server): """ __init__(self, width, height, server): The instatiation protocol for the snekGUI class. Does all necessary bookkeeping for initial GUI state, and enters a loop to receive and stream data across the system, connecting client and server. Inputs: width: A server passed paramater of board width height: A server passed paramter of board height server: The calling erlang server information Outputs: Upon completion, opens GUI annd enters a receive loop """ global boardWidth global boardHeight self.server = server self.root = Tk() self.root.geometry('751x751') self.root.title("JustSnekThings") self.canvas = Canvas(self.root, width=boardWidth*width, \ height=boardHeight*height) self.root.bind('<Left>', self.left) self.root.bind('<Right>', self.right) self.root.bind('<Up>', self.up) self.root.bind('<Down>', self.down) self.root.bind('q', self.quit) self.canvas.pack() self.root.after(100, self.get_board) cast(self.server, Atom("link")) self.root.mainloop()
def main(): # Global variables global done global clock # Initialize erlport, pygame, and game elements erlport.erlang.set_default_message_handler() pygame.init() pygame.font.init() screen = pygame.display.set_mode((780, 480)) textInput = TextInput(font_size=28) myfont = pygame.font.SysFont("", 28) clock = pygame.time.Clock() click_boxes = make_click_boxes() # The game loop. 1 iteration == 1 frame rendered done = False while not done: # draw background screen.fill(COLOR['game_board']) box_rect = pygame.Rect(0, 0, 300, 480) input_rect = pygame.Rect(0, 440, 300, 50) change_mode = pygame.Rect(750, 0, 30, 30) pygame.draw.rect(screen, COLOR['chat_box'], box_rect) pygame.draw.rect(screen, COLOR['chat_input'], input_rect) pygame.draw.rect(screen, COLOR['change_mode'], change_mode) # draw chat elements blit_chat_log(screen) # draw and check game elements if game_started: if ttt_mode: draw_ttt(screen) else: draw_nim(screen) check_click_boxes(click_boxes) check_click_ttt_mode() # check pygame events events = pygame.event.get() for event in events: if event.type == pygame.QUIT: done = True # draw and check text input events if textInput.update(events): text = textInput.get_text() textInput.clear() if text != "": send_chat(text, myfont) screen.blit(textInput.get_surface(), (10, 450)) # finish handling frame pygame.display.update() clock.tick(30) cast(erlPID, Atom("done")) pygame.display.quit() pygame.quit()
def send_chat(text, font): global my_name global op_name global game_started global done match = re.search(startRE, text) if match and op_name == "": start_game_with(match.group(1)) if text == "!quit": if op_name != "": add_notification("Your game with {0} ended".format(op_name)) send_game_over(op_name) op_name = "" game_started = False return elif text == "!help": add_notification( "@{name} to challenge, !quit to quit game, !exit to exit app") return elif text == "!exit": if (op_name != ""): send_game_over(op_name) done = True return cast(erlPID, (Atom("clientserver"), Atom("send_message"), [unicode("tictactoe"), unicode(text), my_name])) add_to_chat_log(text, True, font)
def main(ServerPID): #kick off the front end process p = multiprocessing.Process(target=run_frontend, args=()) p.start() #wait for the user to press start simulation and get the initial states (Names, Health, Coords, DiseaseParams) = global_q.get() #send data back to erlang backend to start the simulation cast(ServerPID, (Atom("initial_settings"), Names, Health, Coords, DiseaseParams))
def handle_message(message): if MESSAGE_HANDLER_PID is None or DHT11_INSTANCE is None or message != Atom('read'): return try: result = DHT11_INSTANCE.read() if result.is_valid(): cast(MESSAGE_HANDLER_PID, (Atom('python'), (result.temperature, result.humidity))) except Exception, _e: pass
def left(self, _): """ def left(self, _): Tkinter keymapped function to digest left input Inputs: keypress Outputs: erlang message of keypress """ cast(self.server, Atom("left"))
def down(self, _): """ def down(self, _): Tkinter keymapped function to digest down input Inputs: keypress Outputs: erlang message of keypress """ cast(self.server, Atom("down"))
def blurry(path, pid, solution): try: img = cv2.imread(path, 0) laplasjan_variance = cv2.Laplacian(img, cv2.CV_64F).var() if float(laplasjan_variance) < 250.0: cast(pid, Atom('blurry!')) cv2.imwrite(solution, img) return 1 else: return 0 except: return 0
def get_nearest_stops_from_coordinates(lon, lat, distance, pid): longitude = ''.join(chr(i) for i in lon) latitude = ''.join(chr(i) for i in lat) distance = ''.join(chr(i) for i in distance) bus_stop_list = the_map.findBusStopsFromCoordinates( float(longitude), float(latitude), float(distance)) busStop = {} busStop['_id'] = "1234" busStop['bus_stops'] = str(bus_stop_list) response = Atom("ok"), dumps(busStop) cast(pid, response)
def quit(self, _): """ def quit(self, _): Tkinter keymapped function to digest q input as quit Inputs: keypress Outputs: erlang message of keypress, then GUI exit """ cast(self.server, Atom("quit")) time.sleep(1) self.root.destroy() sys.exit(0)
def get_nearest_stops_from_coordinates(lon, lat, distance, pid): longitude = ''.join(chr(i) for i in lon) latitude = ''.join(chr(i) for i in lat) distance = ''.join(chr(i) for i in distance) bus_stop_list = the_map.findBusStopsFromCoordinates(float(longitude), float(latitude), float(distance)) busStop = {} busStop['_id'] = "1234" busStop['bus_stops'] = str(bus_stop_list) response = Atom("ok"), dumps(busStop) cast(pid, response)
def get_route_from_coordinates(coordinates_str_list, pid): coordinate_str = ''.join(chr(i) for i in coordinates_str_list) coordinates_list = ast.literal_eval(coordinate_str) route, cost = the_map.findRouteFromCoordinateList(coordinates_list) if not route: route = [None] path = {} path['_id'] = 1212 path['points'] = coordinate_str path['route'] = str(route) path['start'] = str(route[0]) path['end'] = str(route[-1]) path['cost'] = str(cost) response = Atom("ok"), dumps(path) cast(pid, response)
def sendMoveResult(): print("Sending move result") res = "success" board = [[('a', 1, 1, 1), ('b', 2, 2, 2)], [('c', 3, 3, 3), ('d', 4, 4, 4)]] scores = (10, 15, 20, 30) tile_old_new = ([('e', 5, 5, 5)], [()]) tupac = (res, board, scores, tile_old_new) #res = call(Atom("scrabble"), Atom("sendMoveResult"), [tupac]) print("erlPID is") print(erlPID) cast(erlPID, Atom("madeMove")) #print(res) print("Finished sending thing")
def get_route_from_coordinates(coordinates_str_list, pid): coordinate_str = ''.join(chr(i) for i in coordinates_str_list) coordinates_list = ast.literal_eval(coordinate_str) route, cost = the_map.findRouteFromCoordinateList(coordinates_list) if not route: route = [None] path = {} path['_id'] = 1212 path['points'] = coordinate_str path['route'] = str(route) path['start'] = str(route[0]) path['end'] = str(route[-1]) path['cost'] = str(cost) response = Atom("ok"), dumps(path) cast(pid, response)
def overexposed(path, pid, solution): try: img = cv2.imread(path) hist = cv2.calcHist([img], [0], None, [256], [0, 256]) regions = np.array_split(hist, 10) s = 0 sums = [np.sum(x) for x in regions] for i in range(0, 8): s = s + sums[i] if sums[9] > s: cast(pid, Atom('overexposed!')) cv2.imwrite(solution, img) return 1 else: return 0 except: return 0
def start_game_with(opponent_name): global op_name global whose_turn global game_started global game_board if (opponent_name == my_name or opponent_name == op_name): return op_name = opponent_name game_board = [None] * 9 whose_turn = op_name game_started = True args = [ unicode("tictactoe"), my_name, unicode(opponent_name), get_game_state() ] cast(erlPID, (Atom("tictactoegame"), Atom("request_start"), args))
def get_coordinates_from_address(address, street_no, pid): address_str = ''.join(chr(i) for i in address) num_str = ''.join(chr(i) for i in street_no) if num_str == 'None': num_str = None addressCoordinate = the_map.findCoordinatesFromAdress(address_str, num_str) addr = {} addr['_id'] = "4321" addr['address'] = address addr['street_no'] = num_str if addressCoordinate is not None: lon, lat = addressCoordinate.coordinates addr['longitude'] = lon addr['latitude'] = lat else: addr['longitude'] = None addr['latitude'] = None response = Atom("ok"), dumps(addr) cast(pid, response)
def get_coordinates_from_address(address, street_no, pid): address_str = ''.join(chr(i) for i in address) num_str = ''.join(chr(i) for i in street_no) if num_str == 'None': num_str = None addressCoordinate = the_map.findCoordinatesFromAdress(address_str, num_str) addr = {} addr['_id'] = "4321" addr['address'] = address addr['street_no'] = num_str if addressCoordinate is not None: lon, lat = addressCoordinate.coordinates addr['longitude'] = lon addr['latitude'] = lat else: addr['longitude'] = None addr['latitude'] = None response = Atom("ok"), dumps(addr) cast(pid, response)
def test(pid): network.eval() test_loss = 0 correct = 0 with torch.no_grad(): for data, target in test_loader: output = network(data) test_loss += F.nll_loss(output, target, size_average=False).item() pred = output.data.max(1, keepdim=True)[1] correct += pred.eq(target.data.view_as(pred)).sum() test_loss /= len(test_loader.dataset) test_losses.append(test_loss) msg = 'Test set: Avg. loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format( test_loss, correct, len(test_loader.dataset), 100. * correct / len(test_loader.dataset)) cast(pid, (Atom(b'msg'), msg))
def on_serial(SER): p = re.compile('<.*>') while True: try: packet = str(SER.readline()) except: call(Atom("postman_service"), Atom("stop"), []) result = p.search(packet) if result: #print("\t<--: {}".format(result.group(0))) rf_packet = packet_decode(result.group(0)) print("<-- {} encoded:{}\n".format(rf_packet, result.group(0))) if rf_packet : message = (rf_packet.hop_count, rf_packet.cmd, rf_packet.next_hop, rf_packet.destination, rf_packet.source, rf_packet.data) #call(Atom("mpn_controller_service"), Atom("response_handler"), [message]) for subscriber in SUBSCRIBERS: cast(subscriber, message)
def train(pid, epoch): network.train() for batch_idx, (data, target) in enumerate(train_loader): optimizer.zero_grad() output = network(data) loss = F.nll_loss(output, target) loss.backward() optimizer.step() if batch_idx % log_interval == 0: msg = 'Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format( epoch, batch_idx * len(data), len(train_loader.dataset), 100. * batch_idx / len(train_loader), loss.item()) cast(pid, (Atom(b'msg'), msg)) train_losses.append(loss.item()) train_counter.append((batch_idx * 64) + ((epoch - 1) * len(train_loader.dataset))) torch.save(network.state_dict(), './results/model.pth') torch.save(optimizer.state_dict(), './results/optimizer.pth')
def get_coordinates_from_string(string, pid): string_str = ''.join(chr(i) for i in string) data = {} data['_id'] = 12312 addr = False busStop = False coordinates = None searchObject = re.search('\d+[a-zA-Z]*', string_str) if searchObject is not None: address = re.sub('\d+[a-zA-Z]*', "", string_str).strip() num = searchObject.group() coordinates_obj = the_map.findCoordinatesFromAdress(address, num) if coordinates_obj is not None: addr = True coordinates = coordinates_obj.coordinates if not addr: string_str = re.sub('\d+[a-zA-Z]*', "", string_str).strip() coordinates = the_map.findBusStopPosition(string_str) if coordinates is not None: busStop = True else: coordinates_obj = the_map.findCoordinatesFromAdress(string_str) if coordinates_obj is not None: addr = True coordinates = coordinates_obj.coordinates data['address'] = addr data['bus_stop'] = busStop if coordinates is not None: data['longitude'] = coordinates[0] data['latitude'] = coordinates[1] else: data['longitude'] = None data['latitude'] = None response = Atom("ok"), dumps(data) cast(pid, response)
def get_coordinates_from_string(string, pid): string_str = ''.join(chr(i) for i in string) data = {} data['_id'] = 12312 addr = False busStop = False coordinates = None searchObject = re.search('\d+[a-zA-Z]*', string_str) if searchObject is not None: address = re.sub('\d+[a-zA-Z]*', "", string_str).strip() num = searchObject.group() coordinates_obj = the_map.findCoordinatesFromAdress(address, num) if coordinates_obj is not None: addr = True coordinates = coordinates_obj.coordinates if not addr: string_str = re.sub('\d+[a-zA-Z]*', "", string_str).strip() coordinates = the_map.findBusStopPosition(string_str) if coordinates is not None: busStop = True else: coordinates_obj = the_map.findCoordinatesFromAdress(string_str) if coordinates_obj is not None: addr = True coordinates = coordinates_obj.coordinates data['address'] = addr data['bus_stop'] = busStop if coordinates is not None: data['longitude'] = coordinates[0] data['latitude'] = coordinates[1] else: data['longitude'] = None data['latitude'] = None response = Atom("ok"), dumps(data) cast(pid, response)
def handler(message): ## This makes a handler cast(dest, message) ## Sending a message to an erlang pid (dest).
def perform(fun, *args): try: fun(*args) except Exception as e: response = Atom('error'), e.message cast(args[-1], response)
def perform(fun, *args): try: fun(*args) except Exception as e: response = Atom('error'), e.message cast(args[-1], response)
def finishedCallback(event): erlang.cast(dest, (Atom(b"$gen_cast"), Atom(b"finished"))) # without the prefix '$gen_cast' the message is not recognized as cast by gen_server print("*** Python youtube player finished playing ***")
def handler(message): erlang.cast(dest, message) print(message)
def send_message(dest_pid, message): cast(dest_pid, message)
def people(path, pid): cast(pid, Atom('not implemented')) return 0
def face(path, pid, model): cast(pid, Atom('not implemented')) return 0
def sender(dest, message): if(message == "Hello Human"): cast(dest, Atom("human_msg")) else: cast(dest, Atom("hi_msg"))
def handler(message): cast(dest, message)
def cast_message(pid, message): cast(pid, message)
def cast_message(pid, message): cast(pid, (Atom(b'python'), message))