project1part1.tar

submit/0000755000175000017500000000000011263045734011046 5ustar  phucphucsubmit/aux.h0000644000175000017500000000075511263045612012016 0ustar  phucphucint isVisible(int x1, int y1, int x2, int y2){
  return (abs(x1 - x2)<=5 && abs(y1 - y2)<=5);
}

int readstdin(char * command, char * arg){
  char mystring[300];
  char * pch;

  setvbuf(stdin,NULL,_IONBF,1024 );
  fgets(mystring,300,stdin);
  if(strcmp(mystring,"\n")==0){
    return 0;
  }
  mystring[strlen(mystring)-1] = 0;
  pch = strtok(mystring," ");
  strcpy(command,pch);

  pch += strlen(pch);

  while(*(pch)==' ' || *(pch)=='\0'){
    pch++;
  }

  strcpy(arg, pch);
  return 1;
}
submit/helper.h0000644000175000017500000001002611263045612012470 0ustar  phucphuc#include <stdio.h>
#include <stdlib.h>
#include "constants.h"

void printMessage(char * message, int len){
  int i;
  for(i = 0; i < len; i++){
    printf("%02x ", *(message+i));
  }
  printf("\n");
}

//Helper: handle the various task in clients
// TESTED
int handlelogin(char* name,int sock){
  int i = 0;
  int j;
  // Header
  struct header *hdr = (struct header *) malloc(sizeof(int)); // remember to free this
  struct login_request * payload = (struct login_request *) malloc(sizeof(int)*3); // remember to free this
  hdr->version = 0x04;
  hdr->len = htons(0x0010);
  hdr->msgtype = 0x1;
  strcpy(payload->name,name);
  unsigned char * payload_c = (unsigned char*) payload;
  unsigned char * header_c = (unsigned char *) hdr;
  unsigned char tosent[16];

  for(j = 0; j < 16; j++){
    if(j<4) tosent[j] = header_c[j];
    else tosent[j] = payload_c[j-4];
  }

  // Send a login message to the server
  int bytes_sent = send(sock, tosent,16,0);
  if (bytes_sent < 0) perror("send failed");
  free(hdr);
  free(payload);
  return 0;
}

// TESTED
int handlemove(unsigned char d, int sock){
  struct header *hdr = (struct header *) malloc(sizeof(int)); // Remember to free this
  struct move * payload = (struct move *) malloc(sizeof(int)); // Remember to free this
  int j;

  hdr->version = 0x4;
  hdr->len = htons(0x08);
  hdr->msgtype = MOVE;

  payload->direction = d;

  unsigned char * payload_c = (unsigned char*) payload;
  unsigned char * header_c = (unsigned char *) hdr;
  unsigned char tosent[8];

  for(j = 0; j < 8; j++){
    if(j<4){
      tosent[j] = header_c[j];
    } else {
      tosent[j] = payload_c[j-4];
    }
  }
  
  int bytes_sent = send(sock,tosent,8,0);
  if (bytes_sent < 0){
    perror("send failed.\n");
  }

  // Freeing the pointers;
  free(hdr);
  free(payload);

  return 0;
}


// Helper for attack
// Assuming that the input is valid
// @TODO: Test
int handleattack(char * victim, int sock){
  int j = 0;

  // Sending message
  struct header *hdr = (struct header *) malloc(sizeof(int)); // remember to free this
  struct attack * payload = (struct attack *) malloc(sizeof(int)*3); // remember to free this

  hdr->version = 0x4;
  hdr->len = htons(0x10);
  hdr->msgtype = ATTACK;

  // Copy the name
  strcpy(payload->victimname,victim);

  unsigned char * payload_c = (unsigned char*) payload;
  unsigned char * header_c = (unsigned char *) hdr;

  unsigned char tosent[16];

  for(j = 0; j < 16; j++){
    if(j<4){
      tosent[j] = header_c[j];
    } else {
      tosent[j] = payload_c[j-4];
    }
  }

  // Sending
  int bytes_sent = send(sock,tosent,16,0);
  if (bytes_sent < 0){
    perror("send failed.\n");
    return -1;
  } else {
    //printf("Send: %d bytes\n", bytes_sent);
  }

  free(hdr);
  free(payload);
  return 0;
}

// Speak
int handlespeak(char * m, int sock){
 // Header

  unsigned int payloadLength = strlen(m) + 1 + 4 - ((strlen(m)+1) % 4);
  struct header *hdr = (struct header *) malloc(sizeof(int)); // remember to free this

  //msg = (char *) malloc(sizeof(char)*(strlen(m)+1));

  int j;

  unsigned int totalMessageLength = payloadLength + 4;

  hdr->version = 0x4;
  hdr->len = htons(totalMessageLength);
  hdr->msgtype = SPEAK;

  unsigned char * header_c = (unsigned char *) hdr;

  unsigned char tosent[totalMessageLength];

  for(j = 0; j < totalMessageLength; j++){
    if(j<4){
      tosent[j] = header_c[j];
    } else {
      tosent[j] = *(m+j-4);
    }
  }

  // Send a speak message to the server
  int bytes_sent = send(sock, tosent,totalMessageLength,0);
  if (bytes_sent < 0) {
    perror("send failed");
  } else {
    //printf("Sent: %d bytes\n", bytes_sent);
  }

  free(hdr);
  return 0;
}

int handlelogout(char * name,int sock){
  struct header *hdr = (struct header *) malloc(sizeof(int));
  int j;

  hdr->version = 0x4;
  hdr->len = htons(0x4);
  hdr->msgtype = LOGOUT;

  char * tosent = (char*) hdr;

  // Sending the message;
  int bytes_sent = send(sock,tosent,4,0);
  if (bytes_sent < 0){
    perror("send failed.\n");
    return -1;
  } else {
    //printf("Send: %d bytes\n", bytes_sent);
  }
  free(hdr);
}

submit/constants.h0000644000175000017500000000143311263045612013227 0ustar  phucphuc/**************************************************************************
 * The reference implementation of the EE122 Project #1
 *
 * Author: Junda Liu (liujd@cs)
 * Author: DK Moon (dkmoon@cs)
 * Author: David Zats (dzats@cs)
**************************************************************************/

#ifndef _constants_h_
#define _constants_h_

#define EE122_VALID_VERSION 4
#define EE122_MAX_NAME_LENGTH 9
#define EE122_SIZE_X 100
#define EE122_SIZE_Y 100
#define EE122_VISION_RANGE 10
#define EE122_MAX_MSG_LENGTH 255

enum messages {
  LOGIN_REQUEST = 1,
  LOGIN_REPLY,
  MOVE,
  MOVE_NOTIFY,
  ATTACK,
  ATTACK_NOTIFY,
  SPEAK,
  SPEAK_NOTIFY,
  LOGOUT,
  LOGOUT_NOTIFY,
  INVALID_STATE,

  MAX_MESSAGE,
};

enum direction {NORTH = 0, SOUTH, EAST, WEST};

#endif /* _constants_h_ */
submit/header.h0000644000175000017500000000253211263045612012444 0ustar  phucphucstruct header {
  unsigned char version;
  unsigned short len;
  unsigned char msgtype;
}__attribute__((packed));

// Payload Type
struct login_request {
  unsigned char name[10];
  unsigned char padding[2];
}__attribute__((packed));

struct logout_reply{
  unsigned  char name [10];
  unsigned char padding[2];
}__attribute__((packed));

struct login_reply {
  unsigned char error_code;
  unsigned int hp;
  unsigned int exp;
  unsigned char x;
  unsigned char y;
  unsigned char padding;
}__attribute__((packed));

struct move_notify {
  unsigned char name[10];
  unsigned char x;
  unsigned char y;
  unsigned int hp;
  unsigned int exp;
}__attribute__((packed));


struct move {
  unsigned char direction;
  unsigned char padding[3];
}__attribute__((packed));

struct attack {
  char victimname[10];
  char padding[2];
}__attribute__((packed));

struct attack_notify {
  unsigned char attacker_name[10];
  unsigned char victim_name[10];
  unsigned char damage;
  unsigned int hp; // Specifies the updated HP of the victim in network-byte-order. Cannot be negative
  char padding[3];
}__attribute__((packed));

struct speak {
  char * msg;
  char * padding;
}__attribute__((packed));

struct speak_notify {
  unsigned char broadcaster[10];
  unsigned char * msg;
}__attribute__((packed));

struct invalid_state {
  unsigned char error_code;
}__attribute__((packed));
submit/messages.h0000644000175000017500000001122711263045612013024 0ustar  phucphuc/**************************************************************************
 * The reference server implementation of the EE122 Project #1
 *
 * Author: Junda Liu (liujd@cs)
 * Author: DK Moon (dkmoon@cs)
 * Author: David Zats (dzats@cs)
**************************************************************************/

#ifndef _messages_h_
#define _messages_h_

#include <assert.h>

#include "constants.h"

/**************************************************************************
  * Message functions for the client
  ************************************************************************/
static inline void show_prompt()
{
  fprintf(stdout, "command> ");
  fflush(stdout);
}

/* Error messages for the client. */
static inline void on_client_connect_failure()
{
  fprintf(stdout,
          "The gate to the tiny world of warcraft is not ready.\n");
}

static inline void on_malformed_message_from_server()
{
  fprintf(stdout, "Meteor is striking the world.\n");
  abort();
}

static inline void on_disconnection_from_server()
{
  fprintf(stdout,
          "The gate to the tiny world of warcraft has disappeared.\n");
}

static inline void on_not_visible()
{
  fprintf(stdout, "The target is not visible.\n");
  show_prompt();
}

static inline void on_login_reply(const int error_code)
{
  if (error_code == 0) {
    fprintf(stdout, "Welcome to the tiny world of warcraft.\n");
  } else if (error_code == 1) {
    fprintf(stdout, "A player with the same name is already in the game.\n");
  } else {
    /* This must not happen. The caller of this function must check the
       error code is either 0 or 1 and must perform malformed message
       handling before this function. We simply die here. */
    assert(0);
  }
  show_prompt();
}

static inline void on_move_notify(const char *player_name,
                                  const uint8_t x,
                                  const uint8_t y,
                                  const uint32_t hp,
                                  const uint32_t exp)
{
  fprintf(stdout, "%s: location=(%u,%u), HP=%u, EXP=%u\n",
          player_name, x, y, hp, exp);
  show_prompt();
}

static inline void on_attack_notify(const char *attacker_name,
                                    const char *victim_name,
                                    const int damage,
                                    const int updated_hp)
{
  if (updated_hp <= 0) {
    fprintf(stdout, "%s killed %s\n", attacker_name, victim_name);
  } else {
    fprintf(stdout, "%s damaged %s by %d. %s's HP is now %d\n",
            attacker_name, victim_name, damage, victim_name, updated_hp);
  }
  show_prompt();
}

static inline void on_speak_notify(const char *speaker, const char *message)
{
  fprintf(stdout, "%s: %s\n", speaker, message);
  show_prompt();
}

static inline void on_exit_notify(const char *player_name)
{
  fprintf(stdout, "Player %s has left the tiny world of warcraft.\n",
          player_name);
  show_prompt();
}

static inline void on_invalid_state(const int error_code)
{
  if (error_code == 0) {
    fprintf(stdout, "You must log in first.\n");
  } else if (error_code == 1) {
    fprintf(stdout, "You already logged in.\n");
  } else {
    /* This must not happen. The caller of this function must check the
       error code is either 0 or 1, and must perform malformed message
       handling before this function. We simply die here. */
    assert(0);
  }
  show_prompt();
}


/**************************************************************************
  * Message functions for the server
  ************************************************************************/
/* Error messages for the server. */
static inline const char *message_on_server_port_bind_failure()
{
  return "The gate cannot be opened there.";
}



/**************************************************************************
  * Utility functions
  ************************************************************************/
/* Returns 1 if the name is valid. */
static inline int check_player_name(const char *name)
{
  size_t i;
  /* Must not be null. */
  if (!name[0]) return 0;
  for (i = 0; i <= EE122_MAX_NAME_LENGTH; ++ i) {
    if (!name[i]) return 1;
    /* Must not contain a non-alphanumeric character. */
    if (!isalnum(name[i])) return 0;
  }
  /* Must be null terminated. */
  return 0;
}


/* Returns if 1 if the text message is valid. */
static inline int check_player_message(const char *message)
{
  size_t i;
  /* Must not be null. */
  if (!message[0]) return 0;
  for (i = 0; i <= EE122_MAX_MSG_LENGTH; ++ i) {
    if (!message[i]) return 1;
    /* Must not contain a non-printable character. */
    if (!isprint(message[i])) return 0;
  }
  /* Must be null terminated. */
  return 0;
}


#endif /* _messages_h_ */
submit/README0000644000175000017500000000020311263045734011721 0ustar  phucphucName: Phuc Xuan Nguyen
login: cs122-cn
Name: Kevin Friedheim
login: cs122-cv

How to compile: gcc -o client -lsocket -lnsl client.csubmit/client.c0000644000175000017500000002725411263045612012475 0ustar  phucphuc#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "constants.h"
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <arpa/inet.h>

#include "header.h"
#include "helper.h"
#include "messages.h"
#include "aux.h"

#define STDIN 0
#define HEADER_LENGTH 4

// Debugging variables
int mc; // malloc counter
int fc; // free counter

typedef struct P{
  char name[10];
  int hp;
  int exp;
  int x;
  int y;
} Player;

struct list_el {
  Player * datum;
  struct list_el * next;
};

typedef struct list_el Node;

typedef struct ll{
  Node * head;
  Node * tail;
} LinkedList;

void stats(Player * p){
  fprintf(stdout, "%s: location=(%u,%u), HP=%u, EXP=%u\n",
          p->name, p->x, p->y, p->hp, p->exp);
}

void printPlayers(LinkedList * list){
  Node * n;
  printf("People in the list:\n");
  for(n = list->head; n != NULL; n = n->next){
    stats(n->datum);
  }
  printf("---------------------\n");
}


Node * findPlayer(char * name, LinkedList * list){
  Node * p;
  for(p = list->head; p != NULL; p = p->next){
    if (strcmp(p->datum->name,name)==0){
      return p;
    }
  }
  return NULL;
}

unsigned int removePlayer(char * name, LinkedList * list)
{
  Node * prev = list->head;
  Node * curr = list->head ;
  Node * temp;
	
  /* check for empty list */
  if(!prev){ printf("The list is empty"); return 0; }

  /* check if datum is in head of list */
  if(strcmp(prev->datum->name,name)==0){
    if(strcmp(list->tail->datum->name,name)==0){ // if tail == head, this is the only guy
      free(prev->datum);
      fc++;
      free(prev);
      fc++;

      list->head = NULL;
      list->tail = NULL;
      return 1;
    }
    list->head = list->head->next;

    free(prev->datum);
    free(prev);
    return 1;
  }

  while( curr->next ){
    if(strcmp( curr->next->datum->name,name )==0){
      if(strcmp(list->tail->datum->name
		,name)==0){ // if item is the tail
	list->tail = curr;
      }

      temp = curr->next;
      curr->next = curr->next->next;

      free(temp->datum);
      free(temp);
    }
  }
  return 1;
}

Node * freePlayers(LinkedList * list)
{
  // To free all the players after log out
  Node * curr;
  while(list->head)
    {
      curr = list->head;
      list->head = curr->next;
      free(curr->datum);
      fc++;
      free(curr);
      fc++;
    }

}

void initialize(Player * object,char * name, int hp, int exp, int x, int y){
  strcpy(object->name,name);
  object->hp = hp;
  object->exp = exp;
  object->x = x;
  object->y = y;
}

// Printing out the relevant statistics
void printStat(){
  printf("\n");
  printf("Number of mallocs:%d\n",mc);
  printf("Number of frees:%d\n",fc);
  printf("\n");
}

int main(int argc, char* argv[]){

  // Model Variables
  Player * self = (Player *) malloc(sizeof(Player)); // Remember to free this
  mc++; // Debugging memory leak
  LinkedList * mylist = (LinkedList *) malloc (sizeof(LinkedList));
  mc++;
  mylist->head = NULL;
  mylist->tail = NULL;
  Node * p;
  int isLogin = 0;
  char command[80];
  char arg[4000];
  // Connection variables
  int sock;
  int serverIP;
  int serverPort;
  int done = 0;
  int status;

  // Select
  fd_set readfds;
  fd_set writefds;

  struct sockaddr_in sin;
  memset(&sin, 0, sizeof(sin));


  if(argc < 4){ printf("Usage: ./client -s <server IP address> -p <server port>");}

  // Initilizations
  
  serverIP = argv[2];
  serverPort = atoi(argv[4]);

  sock = socket(AF_INET, SOCK_STREAM, 0);
  if(sock < 0){
    perror("socket() failed\n");
    abort();
  }

  sin.sin_family = AF_INET;
  sin.sin_addr.s_addr = inet_addr(serverIP);
  sin.sin_port = htons(serverPort);

  if(connect(sock,(struct sockaddr *) &sin, sizeof(sin)) < 0){
    perror("client - connect");
    freePlayers(mylist);
    free(self);
    free(mylist);

    close(sock);
    on_client_connect_failure();
    abort();
  }
  show_prompt();

  while(1){
    // Clear the set readfds;
    FD_ZERO(&readfds);
    FD_SET(STDIN, &readfds);
    FD_SET(sock, &readfds);
      
    if (select(sock+1,&readfds,NULL,NULL,NULL) == -1){
      perror("select");
      return 0;
    }

    /*
     * Handling stdin
     *
     */
    
    if(FD_ISSET(STDIN, &readfds)){
      if(!readstdin(command,arg)){
	continue;
      }

      if (strcmp(command,"login") == 0){ // LOGIN
	char* name = arg; // TODO: Sanity check the input.'

	if(!check_player_name(name)){
	  printf("! Invalid syntax.\n");
	  show_prompt();
	  continue;
	}
	
	strcpy(self->name,arg);

	int status = handlelogin(name,sock);


      } else if(strcmp(command,"move") == 0){ // MOVE
	char* direction = arg;
	if (strcmp(arg,"")==0x40){
	  printf("! Invalid syntax\n");
	  show_prompt();
	  continue;
	}
	unsigned char d;

	if(strcmp(direction,"north")==0){       d = NORTH;
	}else if(strcmp(direction,"south")==0){ d = SOUTH;
	}else if(strcmp(direction,"east")==0){  d = EAST;
	}else if(strcmp(direction,"west")==0){  d = WEST;
	} else {
	  printf("! Invalid direction: %s\n", arg);
	  continue;
	}
	int status = handlemove(d,sock);

      } else if(strcmp(command,"attack") == 0){ // ATTACK
	char* victimname = arg;
	if(strcmp(victimname,self->name)== 0){
	  show_prompt();
	  continue;
	}

	if(!check_player_name(victimname)){
	  printf("! Invalid name: %s\n", victimname);
	  continue;
	}

	// Search for the guy in the list
	Node * vic = findPlayer(victimname,mylist);

	if (!vic){ // If it is NULL
	  on_not_visible();
	  continue;
	}

	Player * victim = vic->datum;

	int isvisible = isVisible(self->x,self->y,victim->x,victim->y);

	if(!isvisible){ on_not_visible(); continue;}

	int status = handleattack(victimname,sock);

      } else if(strcmp(command,"speak") == 0){

	char * m = arg;

	// Check the message
	if(!check_player_message(m)){ printf("! Invalid text message.\n"); show_prompt(); continue;}
	if(handlespeak(m,sock)){ perror("handlespeak"); }
	
	
      } else if(strcmp(command,"logout") == 0){
	if(!isLogin){
	  show_prompt();
	  printf("You must login first.\n");
	  show_prompt();
	  continue;
	}
	if (handlelogout(self->name,sock) < 0){ perror("handlelogout");}
	free(self);
	fc++;
	freePlayers(mylist); // Free every player in the list
	free(mylist); // Free the list
	fc++;
	
	if(close(sock) < 0){
	  perror("logout - close");
	  break;
	}
	//printStat();
	break;
      } else if(strcmp(command,"whois") == 0){
	printPlayers(mylist);

      } else if(strcmp(command,"whoami")==0){
	stats(self);
      } else {
	printf("Available command: login, move, attack, speak, logout.\n");
      }

      show_prompt();






      /*
       * Handling data from sock
       *
       */





    } else if (FD_ISSET(sock, &readfds)){ // Receiving from sock
      // Block and wait for response from the server
      unsigned char buffer[4096];
      int expected_data_len = sizeof(buffer);
      unsigned char *p = (char*) buffer; // Introduce a new pointer
      int offset = 0;

      int read_bytes = recv(sock,buffer,expected_data_len,0);
      if (read_bytes == 0){ // Disconnected from the server
	// Free memory
	freePlayers(mylist);
	free(self);
	free(mylist);
	on_disconnection_from_server();
	break;
      }
      
      if(read_bytes % 4 != 0){ // 32-bit aligned\
	// Free memory
	printf("! Message is not 32-bit aligned\n");
	freePlayers(mylist);
	free(self);
	free(mylist);
	on_malformed_message_from_server();
      }

      int j;
      
      unsigned char header_c[HEADER_LENGTH];
      while(offset < read_bytes){
	for(j = 0; j < HEADER_LENGTH; j++){header_c[j] = *(p+offset+j);}
	offset += HEADER_LENGTH;

	// Cast it to struct header
	struct header * hdr = (struct header *) header_c;

	if (hdr->version != 0x4){ // Check for version number
	  // Free memory
	  freePlayers(mylist);
	  free(self);
	  free(mylist);
	  on_malformed_message_from_server();
	}

	int payload_len = ntohs(hdr->len)-HEADER_LENGTH;

	char payload_c[payload_len];

	for(j = 0; j < payload_len; j++){
	  payload_c[j] = *(p+offset+j);
	}

	offset += payload_len; // Increment the offset
      
	// @TODO: Check for the version

	// Check for the msgtype
	if(hdr->msgtype == LOGIN_REPLY){ // LOGIN REPLY

	  struct login_reply * lreply = (struct login_reply *) payload_c;
	  if(isLogin){

	    // Treat it as a malformed package
	    on_malformed_message_from_server();

	  } else {

	    on_login_reply(lreply->error_code);

	    if(lreply->error_code == 0){
	      self->hp = ntohl(lreply->hp);
	      self->exp = ntohl(lreply->exp);
	      self->x = lreply->x;
	      self->y = lreply->y;

	      isLogin = 1;
	    }
	  }
	} else if(hdr->msgtype == MOVE_NOTIFY){
	  struct move_notify * mn = (struct move_notify *) payload_c;
	  Node *p;

	  if (strcmp(mn->name,self->name)==0){ // If the guy is self
	    self->hp = ntohl(mn->hp);
	    self->exp = ntohl(mn->exp);
	    self->x = mn->x;
	    self->y = mn->y;

	    on_move_notify(self->name, self->x, self->y, self->hp,self->exp);

	  } else { // The guy is someone else

	    p = findPlayer(mn->name,mylist);

	    if(p == NULL){ // Not in the list
	      
	      // Adding the player
	      Node * node = (Node*) malloc(sizeof(Node)); // TODO: remember to free this
	      mc++;

	      Player * newplayer = (Player*) malloc(sizeof(Player)); // TODO: remember to free this first
	      mc++;
	      initialize(newplayer,mn->name,ntohl(mn->hp),ntohl(mn->exp),mn->x,mn->y);
	      node->datum = newplayer;
	      node->next = NULL;


	      if(mylist->tail == NULL && mylist->head == NULL){ // First player
		mylist->tail = node;
		mylist->head = node;
	      } else {
		mylist->tail->next = node;
		mylist->tail = node;
	      }

	      // Printing
	      if (isVisible(self->x,self->y,newplayer->x,newplayer->y))
		on_move_notify(newplayer->name, newplayer->x, newplayer->y, newplayer->hp,newplayer->exp);

	    } else { // The guy is in the list
	      int oldv = isVisible(self->x,self->y,p->datum->x,p->datum->y);
	      int newv = isVisible(self->x,self->y,mn->x,mn->y);

	      if(oldv || newv){
		initialize(p->datum,mn->name,ntohl(mn->hp),ntohl(mn->exp),mn->x,mn->y);
		on_move_notify(p->datum->name, p->datum->x, p->datum->y, p->datum->hp,p->datum->exp);
	      }

	    } // End inner if
	  }
	  
	} else if(hdr->msgtype == ATTACK_NOTIFY){
	  struct attack_notify * an = (struct attack_notify *)payload_c;
	  Player * att;
	  Player * vic;

	  if (strcmp(an->attacker_name,self->name)==0){
	    att = self;
	  } else {
	    Node * att_node = findPlayer(an->attacker_name,mylist);
	    att = att_node->datum;
	  }

	  if (strcmp(an->victim_name,self->name)==0){
	    vic = self;
	  } else {
	    Node * vic_node = findPlayer(an->victim_name,mylist);
	    vic = vic_node->datum;
	  }

	  int updated_hp = ntohl(an->hp);
	  char damage = an->damage;

	  // Check the visibility
	  int attVisible = isVisible(self->x,self->y,att->x,att->y);
	  int vicVisible = isVisible(self->x,self->y,vic->x,vic->y);

	  if (attVisible && vicVisible){
	    on_attack_notify(att->name,vic->name,damage,updated_hp);
	  }
	  

	} else if(hdr->msgtype == SPEAK_NOTIFY){ // SPEAK_NOTIFY
	  struct speak_notify* sreply = (struct speak_notify*) payload_c;
	  unsigned char * broadcaster = sreply->broadcaster;

	  char * start = ((char*)payload_c)+10;

	  // null terminated & no longer than 255
	  if(!check_player_message(start)){ printf("! Invalid format\n"); continue;}		
	  printf("%s: %s\n",broadcaster,start);
	  show_prompt();


	} else if(hdr->msgtype == LOGOUT_NOTIFY){
	  // Take the the player out of the database

	  struct logout_reply * loreply = (struct logout_reply *) payload_c;
	  if (!removePlayer(loreply->name, mylist)){
	    perror("LOGOUT_NOTIFY - remove player");
	    exit(-1);
	  }
	  
	  printf("Player %s has left the tiny world of warcraft.\n",loreply->name);
	  show_prompt();


	} else if(hdr->msgtype == INVALID_STATE){

	  struct invalid_state * is = (struct invalid_state *) payload_c;
	  on_invalid_state(is->error_code);

	} // end of else if for hdr->msgtype

      }
    }
  }
}