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