Colony

                 new = [newx, newy] + [items[i] for i in range(6,12)]
                 self.draw.bot = new
     #         info = self.draw.bot
     #         dx = random() * 2 - 1
     #         dy = random() * 2 - 1
     #         self.draw.bot = [info[0] + dx, info[1] + dx, info[2]]
             return True
-...
         sock = socket()
         sock.connect((hostname, int(sys.argv[1])))
     #    mywidg = Screen(sock)
         mywidg = Screen(sock)
-...
         window.show()
         gobject.idle_add(mywidg.receive_info)
      #   gobject.timeout_add(250, mywidg.receive_info)
         gtk.main()
     if __name__=='__main__':

     #include "robots.h"
     #include "wireless.h"
     void donothin()
+    {
          return;
+    }
     int main(int argc, char *argv[])
+    {
          char buffer[256];
          int n, newsockfd;
          short int x,y,ir1,ir2,ir3,ir4,ir5;
          float theta;
          Packet *received;
          if (argc < 2) {
     	  fprintf(stderr,"usage: %s <port number>\n", argv[0]);
     	  exit(1);
+         }
     /*      newsockfd = make_sock(atoi(argv[1])); */
          newsockfd = make_sock(atoi(argv[1]));
          printf("Made socket\n");
          make_listener();
          printf("Robot listener created.\n");
          bzero(buffer,256);
          while (1)
+         {
     	  bzero(buffer, 256);
     	  wl_do();
     	  received = dequeue();
     	  if (received)
+    	  {
     	       buffer[0] = (char) received->source;
     	       buffer[1] = (char) received->length;
     	       buffer[2] = (char) received->type;
     	       buffer[3] = 0;
     	       memcpy(buffer+4, received->packet, received->length);
     	       memcpy(&x, buffer+4, 2);
     	       memcpy(&y, buffer+6, 2);
     	       memcpy(&theta, buffer+8, 4);
     	       memcpy(&ir1, buffer+12, 2);
     	       memcpy(&ir2, buffer+14, 2);
     	       memcpy(&ir3, buffer+16, 2);
     	       memcpy(&ir4, buffer+18, 2);
     	       memcpy(&ir5, buffer+20, 2);
     	       printf("(%d, %d, %f, %d, %d, %d, %d, %d)\n",
     		      x, y, theta, ir1, ir2, ir3, ir4, ir5);
     /* 	       n = write(newsockfd, buffer, 22); */
     	       free(received);
     	       bzero(buffer, 256);
+    	  }
+         }
          return 0;
+    }
-...
          printf(msg);
          exit(1);
+    }

     #include <wl_token_ring.h>
     #include <string.h>
     #include <stdio.h>
     #include <unistd.h>
     #include "robots.h"
     #define CHANNEL 0xE
     #define GROUP 1
     typedef struct Node {
          Packet *info;
          struct Node *next;
          struct Node *prev;
     } Node;
     Node *thead = NULL;
     void enqueue(char typ, int src, unsigned char *wrds,int len);
     void do_nothing(void);
     void packet_receive(char type, int source, unsigned char* packet, int length);
     void make_listener()
+    {
-...
          receiver->groupCode = GROUP;
          receiver->handle_response = do_nothing;
          receiver->timeout_handler = do_nothing;
          receiver->handle_receive = enqueue;
          receiver->handle_receive = packet_receive;
          wl_register_packet_group(receiver);
+    }
     //if we ever get more than one packet, before reading any
     void enqueue(char typ, int src, unsigned char *wrds,int len)
     void packet_receive(char type, int source, unsigned char* packet, int length)
+    {
          printf("queued one\n");
          Node *new = malloc(sizeof(Node));
          new->info = malloc(sizeof(Packet));
          new->info->source = src;
          new->info->length = len;
          new->info->type = typ;
          new->info->packet = malloc((strlen(wrds)+1)*sizeof(char));
          strcpy(new->info->packet, wrds);
          /* stolen from cmar */
          char buffer[22];
          short x,y,ir1,ir2,ir3,ir4,ir5, n;
          x = ((short)packet[1] << 8) | (short)packet[0];
          y = ((short)packet[3] << 8) | (short)packet[2];
          ir1 = ((short)packet[9] << 8) | (short)packet[8];
          ir2 = ((short)packet[11] << 8) | (short)packet[10];
          ir3 = ((short)packet[13] << 8) | (short)packet[12];
          ir4 = ((short)packet[15] << 8) | (short)packet[14];
          ir5 = ((short)packet[17] << 8) | (short)packet[16];
          if (!thead)
     	  thead = new;
          else
+         {
     	  new->next = thead;
     	  thead->prev = new;
     	  thead = new;
+         }
          char tarr[] = {packet[4],packet[5],packet[6],packet[7]};
          float *theta_ptr = (float *)tarr;
          float theta = *theta_ptr;
          printf( "%d %d %f %d %d %d %d %d\n", x, y, theta,
     	    ir1, ir2, ir3, ir4, ir5);
          buffer[0] = (char) source;
          buffer[1] = (char) length;
          buffer[2] = type;
          buffer[3] = 0;
          memcpy ( buffer+4, packet, length);
          n = write(newsockfd, buffer, 22);
          bzero(buffer, 22);
+    }
     Packet * dequeue()
     void do_nothing()
+    {
          Node *iter;
          Packet *ret;
          if (!thead)
     	  return NULL;
          for (iter = thead; iter->next != NULL; iter = iter->next)
+    	  ;
          ret = iter->info;
          if (iter->prev)
     	  (iter->prev)->next = NULL;
          else
     	  thead = NULL;
          free (iter);
          return ret;
+    }
     void do_nothing(void)
+    {
          return;
+    }

     #ifndef ROBOTS
     #define ROBOTS
     typedef struct Packet
+    {
       int source;
       int length;
       char type;
       char *packet;
     } Packet;
     void make_listener();
     Packet *dequeue();
     int newsockfd;
     #endif

Revision 934