Dans un cas simple voici ce que ca pourrait donner :

struct modele {
  int largeur, hauteur;
  bool[][] tirs;
  /* etc */
};

void tirer(modele* data, int x, int y) {
   if (x>=0 && y>=0 && x<largeur && y<hauteur)
     data->tirs[x][y] = true;
   else
     std::cerr << "tir incorrect !" << std::endl;
}

pour le réseau, tu auras un message : un tir
ceci va être traité par une méthode "tir" qui appellera tirer() sur le modèle qui va bien (celui de l'adversaire) avec les paramètres reçus depuis le réseau.

modele* adversaire;
void tir(int x, int y) {
   tirer(adversaire, x, y);
}

// Drapeau de contrôle de la boucle d'écoute :
bool conditionArret;
// A exécuter dans un thread :
void ecoute() {
  while(!conditionArret) {
    // 1) Récupération du message :
    std::string message;
    /* "lire un message" avec read(); */

    // 2) Traitement du message :
    switch((char) message[0]) {
      case 'T':
         {
            int x, y;
            sscanf(message, "T %f %f", &x, &y);
            tir(x, y);
         }
         break;
      default:
         std::cout << "Message inconnu : '" << message << "'" << std::endl;
    }
  }
}

pour l'interface homme-machine, en supposant que tu sois en mesure de réagir à la position sur une grille où l'humain cliquera cela reviendra à déclencher la méthode tirer sur le modèle local avec les positions récupérées du click.

En C++ tu auras tout intérêt à créer une classe Modele reprenant la structure de données et intégrant les fonctions comme tirer sous forme de méthode. Tu auras ainsi une meilleure lisibilité de ton code ainsi qu'une meilleur fiabilité (il vaut mieux invoquer une méthode sur un objet qu'appeler une fonction avec pour paramètre un pointeur sur une structure, le compilateur faisant un certain boulot de vérification).

Les sémaphores sont une technique de communication inter-processus, utilisés sous unix. Je t'en ai parlé plus pour ta culture générale, ils n'ont pas d'utilité dans un programme multithreadé. Le principe est d'utiliser des compteurs, que l'on incrémente quand on en a besoin et que l'on décrémente. Ceci permet notamment de synchroniser des processus (compteurs partagés sur la taille des données en commun par exemple, verrous binaires en limitant le compteur à 1).