def subscribe(subscriber): if not subscriber in SUBSCRIBERS: SUBSCRIBERS.append(subscriber) return (Atom(b'ok'), Atom(b'subscribed'))
def send_message(player_number, message): global PID_my, PID_players dest = PID_players[player_number] # Erlport call function to send message because it spawns a new process call(Atom("scrabble"), Atom("send_to_pyclient"), [dest, message])
def global_message(self, status, message, pid): '''Sends a message to the server and local_broadcast it ''' erlport.erlang.cast(pid, (Atom('guess'), Atom('garbage'), Atom(str(message))))
def test_encode_opaque_object(self): self.assertEqual( b"\x83h\3d\0\x0f$erlport.opaqued\0\10language" b"m\0\0\0\4data", encode(OpaqueObject(b"data", Atom(b"language")))) self.assertEqual(b"\x83data", encode(OpaqueObject(b"data", Atom(b"erlang"))))
def stop(): player.stop() return Atom(b"ok")
def test_decode_python(self): data = OpaqueObject.decode(dumps(b"test"), Atom(b"python")) self.assertEqual(b"test", data)
def test_encode_erlang(self): obj = OpaqueObject(b"data", Atom(b"erlang")) self.assertEqual(b"data", obj.encode())
def test_default_port_read(self): client = TestPortClient() self.assertEqual(12, client.write("\0\0\0\10\x83d\0\4test")) atom = client.port.read() self.assert_(isinstance(atom, Atom)) self.assertEqual(Atom("test"), atom)
def test_default_port_write(self): client = TestPortClient() self.assertEqual(12, client.port.write(Atom("test"))) self.assertEqual("\0\0\0\10\x83d\0\4test", client.read())
def test_packet1_port_read(self): client = TestPortClient(packet=1) self.assertEqual(9, client.write("\10\x83d\0\4test")) atom = client.port.read() self.assert_(isinstance(atom, Atom)) self.assertEqual(Atom("test"), atom)
def test_packet1_port_write(self): client = TestPortClient(packet=1) self.assertEqual(9, client.port.write(Atom("test"))) self.assertEqual("\10\x83d\0\4test", client.read())
def test_small_buffer_read(self): client = TestPortClient(buffer_size=1) self.assertEqual(12, client.write("\0\0\0\10\x83d\0\4test")) atom = client.port.read() self.assert_(isinstance(atom, Atom)) self.assertEqual(Atom("test"), atom)
def _handle_error(self, exception): t, val, tb = exception exc = Atom("%s.%s" % (t.__module__, t.__name__)) exc_tb = traceback.extract_tb(tb) exc_tb.reverse() return Atom("error"), (Atom("exception"), (exc, unicode(val), exc_tb))
def unsubscribe(subscriber): if subscriber in SUBSCRIBERS: SUBSCRIBERS.remove(subscriber) return (Atom(b'ok'), Atom(b'unsubscribed'))
def test_comparison(self): obj = OpaqueObject(b"data", Atom(b"language")) self.assertEqual(obj, obj) self.assertEqual(obj, OpaqueObject(b"data", Atom(b"language"))) self.assertNotEqual(obj, OpaqueObject(b"data", Atom(b"language2"))) self.assertNotEqual(obj, OpaqueObject(b"data2", Atom(b"language")))
def setup_dtype(): set_encoder(dtype_encoder) set_decoder(dtype_decoder) return Atom(b'ok')
def test_decode(self): obj = OpaqueObject.decode(b"data", Atom(b"language")) self.assertEqual(b"data", obj.data) self.assertEqual(b"language", obj.language)
def message_init(dest): def handler(message): sender(dest, message) set_message_handler(handler) return Atom("ok")
def test_encode(self): obj = OpaqueObject(b"data", Atom(b"language")) term = Atom(b"$erlport.opaque"), Atom(b"language"), b"data" self.assertEqual(erlterms.encode_term(term), obj.encode())
def sender(dest, message): if(message == "Hello Human"): cast(dest, Atom("human_msg")) else: cast(dest, Atom("hi_msg"))
def test_encode_atom(self): self.assertEqual(b"\x83d\0\0", encode(Atom(b""))) self.assertEqual(b"\x83d\0\4test", encode(Atom(b"test")))
def cast_message(pid, message): cast(pid, (Atom(b'python'), message))
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 _move_check(UserName, UserNode, newP, oldP): """ _move_check( UserName, UserNode, newP, oldP ): An internal function to check whether a move from input oldP location to input newP location is valid for the given player. Inputs: UserName: The name of the moving user UserNode: The node of the moving user newP: The calculated move destination oldP: The calculated previous move location Outputs: On success, an erlang callback indicating that the player moved. On failure, an internal call to the remove_player function, which then handles bookkeeping cleanup. """ global board global players global snakes global server pTup = (UserName, UserNode) temparray = None for i in players: if i[0] == pTup: temparray = i # Do nothing if trying to backtrack if newP[0] == temparray[4][0] and newP[1] == temparray[4][1]: return (Atom('moved'), pTup) collis = board[newP[0]][newP[1]] # collision with powerup if collis == '*': collis = ' ' temparray[5] += 25 seed = find_empty_spot() board[seed[0]][seed[1]] = '*' # collision with powerup elif collis == '@': collis = ' ' temparray[5] += 20 seed = find_empty_spot() board[seed[0]][seed[1]] = '*' # collision with other filled space if collis != ' ': # crash - this kills the snek board[oldP[0]][oldP[1]] = ' ' return remove_player(UserName, UserNode) else: # make old head space lowercase board[oldP[0]][oldP[1]] = temparray[2].lower() # make new head space non-space board[newP[0]][newP[1]] = temparray[2] # remember last space temparray[4] = oldP #remember new space temparray[1] = newP # every move costs a point temparray[5] -= 1 if temparray[5] == 0: return remove_player(UserName, UserNode) # track the snake tail temparray[6].append(oldP) if len(temparray[6]) > 20: tail_rem = temparray[6].pop(0) board[tail_rem[0]][tail_rem[1]] = ' ' # replace the players element with the updated values for i in players: if i[0] == (UserName, UserNode): x = players.index(i) players[x] = temparray return (Atom('moved'),\ (Atom(UserName), Atom(UserNode)))
def register(pid, _address): global MESSAGE_HANDLER_PID global CCS811_INSTANCE MESSAGE_HANDLER_PID = pid CCS811_INSTANCE = Adafruit_CCS811() return (Atom('ok'), pid)
def people(path, pid): cast(pid, Atom('not implemented')) return 0
def register_handler(dest): set_message_handler(handler) return Atom("ok")
def face(path, pid, model): cast(pid, Atom('not implemented')) return 0
def pids(): Pid1 = call(Atom("erlang"), Atom("self"), []) Pid2 = call(Atom("erlang"), Atom("self"), []) return [Pid1, Pid2]
def subscribe(subscriber): if not subscriber in self.subscribers: self.subscribers.append(subscriber) return (Atom(b'ok'), Atom(b'subscribed'))