update to nebual code

Author: ronmurphy

client.py

@@ -3,39 +3,43 @@
 import socket
 from threading import Thread, Event, Lock
 import struct
+from warnings import warn
 # Third-party packages
 
 # Modules from this project
-from warnings import warn
 import blocks
 from globals import BLOCKS_DIR, SECTOR_SIZE
 from savingsystem import null2, structuchar2, sector_to_blockpos
-from get_ip import get_lan_ip
-HOST = "0.0.0.0" #""127.0.0.1"
 
 class PacketReceiver(Thread):
-    HOST = get_lan_ip()
-    print HOST
-    def __init__ (self, world, controller, ipport=(HOST, 1486)): # was "neb.nebtown.info" , nebual's server
+    def __init__ (self, world, controller, sock):
         Thread.__init__(self)
         self.world = world
         self.controller = controller
         self._stop = Event()
         self.lock = Lock()
+        self.sock = sock
+
+    def run(self):
         try:
-            self.sock = socket.socket()
-            self.sock.connect(ipport)
+            self.loop()
         except socket.error as e:
-            print "Socket Error:", e
+            if e[0] in (10053, 10054):
+                #TODO: GUI tell the client they were disconnected
+                print "Disconnected from server."
+                self.controller.back_to_main_menu.set()
+            else:
+                raise e
 
-    def run(self):
+    def loop(self):
         packetcache, packetsize = "", 0
 
         main_thread = self.world.sector_packets.append
         while 1:
             resp = self.sock.recv(16384)
             if self._stop.isSet() or not resp:
                 print "Client PacketReceiver:",self._stop.isSet() and "Shutting down" or "We've been disconnected by the server"
+                self.sock.shutdown(SHUT_RDWR)
                 return
 
             packetcache += resp
@@ -65,6 +69,9 @@ def run(self):
                 elif packetid == 5:  # Print Chat
                     with self.lock:
                         main_thread((packetid, (packet[:-4], struct.unpack("BBBB", packet[-4:]))))
+                elif packetid == 255:  # Spawn Position
+                    with self.lock:
+                        main_thread((packetid, struct.unpack("iii", packet)))
                 else:
                     warn("Received unknown packetid %s" % packetid)
                 packetcache = packetcache[packetsize:]
@@ -104,15 +111,21 @@ def dequeue_packet(self):
             self.world._remove_block(packet)
         elif packetid == 5:  # Chat Print
             self.controller.write_line(packet[0], color=packet[1])
+        elif packetid == 255:  # Spawn Position
+            self.controller.player.position = packet
+            #Now that we know where the player should be, we can enable .update again
+            self.controller.update = self.controller.update_disabled
 
     def request_sector(self, sector):
-        self.sock.send("\1"+struct.pack("iii", *sector))
+        self.sock.sendall("\1"+struct.pack("iii", *sector))
     def add_block(self, position, block):
-        self.sock.send("\3"+struct.pack("iiibb", *(position+(block.id.main, block.id.sub))))
+        self.sock.sendall("\3"+struct.pack("iiiBB", *(position+(block.id.main, block.id.sub))))
     def remove_block(self, position):
-        self.sock.send("\4"+struct.pack("iii", *position))
+        self.sock.sendall("\4"+struct.pack("iii", *position))
     def send_chat(self, msg):
-        self.sock.send("\5"+struct.pack("i", len(msg))+msg)
+        self.sock.sendall("\5"+struct.pack("i", len(msg))+msg)
+    def request_spawnpos(self):
+        self.sock.sendall(struct.pack("B", 255))
 
     def stop(self):
         self._stop.set()

controllers.py

@@ -2,6 +2,8 @@
 
 # Python packages
 from binascii import hexlify
+import socket
+import time
 import datetime
 from functools import partial
 from itertools import imap
@@ -11,6 +13,7 @@
 import random
 
 # Third-party packages
+import threading
 from pyglet.gl import *
 
 # Modules from this project
@@ -117,7 +120,12 @@ def __init__(self, window):
         self.hour_deg = 15.0
         self.clock = 6
 
+        self.back_to_main_menu = threading.Event()
+
     def update(self, dt):
+        if self.back_to_main_menu.isSet():
+            self.switch_controller_class(MainMenuController)
+            return
         self.update_sector(dt)
         self.update_player(dt)
         self.update_mouse(dt)
@@ -199,8 +207,19 @@ def init_gl(self):
         glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
 
     def setup(self):
+        try:
+            #Make sure the address they want to connect to works
+            ipport = G.IP_ADDRESS.split(":")
+            if len(ipport) == 1: ipport.append(1486)
+            sock = socket.socket()
+            sock.connect(tuple(ipport))
+        except socket.error as e:
+            print "Socket Error:", e
+            #Otherwise back to the main menu we go
+            return False
+
         self.init_gl()
-        
+
         sky_rotation = -20.0  # -20.0
         print 'loading sky'
         self.skydome = Skydome(
@@ -223,12 +242,18 @@ def setup(self):
         #    open_world(self, G.game_dir, G.SAVE_FILENAME)
 
         self.world = World()
-        self.packetreceiver = PacketReceiver(self.world, self)
+        self.packetreceiver = PacketReceiver(self.world, self, sock)
         self.world.packetreceiver = self.packetreceiver
         self.packetreceiver.start()
-        #TODO: Get our position from the server
-        #self.player = Player((0,self.world.terraingen.get_height(0,0)+2,0), (-20, 0),
-        self.player = Player((0,50,0), (-20, 0),
+
+        #Get our position from the server
+        self.packetreceiver.request_spawnpos()
+        #Since we don't know it yet, lets disable self.update, or we'll load the wrong chunks and fall
+        self.update_disabled = self.update
+        self.update = lambda dt: None
+        #We'll re-enable it when the server tells us where we should be
+
+        self.player = Player((0,0,0), (-20, 0),
                                 game_mode=G.GAME_MODE)
         print('Game mode: ' + self.player.game_mode)
         self.item_list = ItemSelector(self, self.player, self.world)
@@ -256,6 +281,7 @@ def setup(self):
         pyglet.clock.schedule_interval_soft(self.world.process_queue,
                                             1.0 / G.MAX_FPS)
         pyglet.clock.schedule_interval_soft(self.world.hide_sectors, 1.0, self.player)
+        return True
 
     def update_time(self):
         """
@@ -525,7 +551,8 @@ def text_input_callback(self, symbol, modifier):
         if symbol == G.VALIDATE_KEY:
             txt = self.text_input.text.replace('\n', '')
             self.text_input.clear()
-            self.world.packetreceiver.send_chat(txt)
+            if txt:
+                self.world.packetreceiver.send_chat(txt)
             return pyglet.event.EVENT_HANDLED
 
     def on_text_input_toggled(self):
@@ -548,19 +575,18 @@ def toggle_text_input(self):
             self.window.remove_handlers(self.text_input)
 
     def push_handlers(self):
-        self.setup()
-        self.window.push_handlers(self.camera)
-        self.window.push_handlers(self.player)
-        self.window.push_handlers(self)
-        self.window.push_handlers(self.item_list)
-        self.window.push_handlers(self.inventory_list)
+        if self.setup():
+            self.window.push_handlers(self.camera)
+            self.window.push_handlers(self.player)
+            self.window.push_handlers(self)
+            self.window.push_handlers(self.item_list)
+            self.window.push_handlers(self.inventory_list)
+        else:
+            self.switch_controller_class(MainMenuController)
 
     def pop_handlers(self):
-        self.window.pop_handlers()
-        self.window.pop_handlers()
-        self.window.pop_handlers()
-        self.window.pop_handlers()
-        self.window.pop_handlers()
+        while self.window._event_stack:
+            self.window.pop_handlers()
 
     def on_close(self):
         self.world.packetreceiver.stop()  # Disconnect from the server so the process can close

entity.py

@@ -34,6 +34,44 @@ def __init__(self, position, rotation, velocity=0, health=0, max_health=0,
         # it to check if monsters can see player
         self.sight_range = sight_range
         self.attack_range = attack_range
+        self.entity_id = None
+
+    def can_handle(self, msg_type):
+        return False
+
+    def handle_message(self, msg_type, *args, **kwargs):
+        pass
+
+#
+# Message type
+#
+MSG_PICKUP, \
+MSG_REDSTONE_ACTIVATE, MSG_REDSTONE_DEACTIVATE, \
+    = range(3)
+
+class EntityManager(object):
+    def __init__(self):
+        self.last_id = 0
+        self.entities = {}
+
+    def add_entity(self, entity):
+        self.last_id = self.last_id + 1
+        self.entities[self.last_id] = entity
+        self.entities[self.last_id].entity_id = self.last_id
+
+    def remove_entity(self, entity_id):
+        del self.entities[entity_id]
+
+    def broadcast(self, msg_type, *args, **kwargs):
+        for entity in self.entities:
+            if entity.can_handle(msg_type):
+                entity.handle_message(msg_type, *args, **kwargs)
+
+    def send_message(self, receiver, msg_type, *args, **kwargs):
+        if self.entities[receiver].can_handle(msg_type):
+                self.entities[receiver].handle_message(msg_type, *args, **kwargs)
+
+entity_manager = EntityManager()
 
 class TileEntity(Entity):
     """
@@ -163,3 +201,32 @@ def smelt(self):
         self.fuel_task = G.main_timer.add_task(burning_time, self.remove_fuel)
         # smelting task
         self.smelt_task = G.main_timer.add_task(smelting_time, self.smelt_done)
+
+class RedstoneTorchEntity(TileEntity):
+    def __init__(self, world, position):
+        super(RedstoneTorchEntity, self).__init__(world, position)
+        self.activated = True
+
+        entity_manager.broadcast(MSG_REDSTONE_ACTIVATE, position=self.position)
+
+    def can_handle(self, msg_type):
+        return msg_type == MSG_REDSTONE_ACTIVATE or msg_type == MSG_REDSTONE_DEACTIVATE
+
+    def handle_message(self, msg_type, *args, **kwargs):
+        pass
+
+class DroppedBlockEntity(Entity):
+    def __init__(self, world, position, item):
+        super(TileEntity, self).__init__(position, rotation=(0,0))
+        self.world = world
+        self.item_stack = item
+
+    def can_handle(self, msg_type):
+        return msg_type == MSG_PICKUP
+
+    # argument: player
+    def handle_message(self, msg_type, *args, **kwargs):
+        if msg_type == MSG_PICKUP:
+            pass
+            # entity_manager.remove_entity(self.entity_id)
+

globals.py

@@ -26,6 +26,7 @@
 
 DEBUG = False
 
+IP_ADDRESS = "neb.nebtown.info"  # The IP Address to connect to
 
 #
 # Game modes