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))
