/[fgs]/fgs/src/roomproc.cc
ViewVC logotype

Diff of /fgs/src/roomproc.cc

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.8 by dougm, Sat Sep 6 22:47:31 2003 UTC revision 1.9 by drysdam, Wed Sep 10 02:51:07 2003 UTC
# Line 42  enum GameType Line 42  enum GameType
42    Free = 1    Free = 1
43  };  };
44    
45    enum GovtType
46    {
47      FASCISM,
48      ANARCHY,
49      KILLARCHY
50    };
51    
52  struct open_challenge  struct open_challenge
53  {  {
54    int challenger;    int challenger;
# Line 113  enum RoomCode Line 120  enum RoomCode
120    ListMembers = 16,    ListMembers = 16,
121    ListAdmins = 17,    ListAdmins = 17,
122    ListSilenced = 18,    ListSilenced = 18,
123    ListBanned = 19    ListBanned = 19,
124      Ban = 20,
125      UnBan = 21
126  };  };
127    
128  struct room  struct room
129  {  {
130    std::string name;    std::string name;
131      GovtType govt;
132    std::vector<int> members;    std::vector<int> members;
133    std::vector<int> admins;    std::vector<int> admins;
134    std::vector<int> silenced;    std::vector<int> silenced;
# Line 159  int rooms_init() Line 169  int rooms_init()
169    DIR *dp;    DIR *dp;
170    struct dirent *d;    struct dirent *d;
171    struct stat buf;    struct stat buf;
   std::string roomname;  
172    int r, member, admin, silenced, banned;    int r, member, admin, silenced, banned;
173    char comma;    char comma;
174    
# Line 181  int rooms_init() Line 190  int rooms_init()
190    
191        room rm;        room rm;
192    
193        in >> roomname;        in >> rm.name;
194          in >> (int)rm.govt;
       rm.name = roomname;  
195    
196        in >> std::skipws >> member >> comma;        in >> member;
197        while(in.good()) {        while(in.good()) {
198          rm.members.push_back(member);          rm.members.push_back(member);
199          /*          in >> member;
         std::cout << member;  
         std::cout << "\n";  
         std::cout.flush();  
         */  
         if(comma == ';') break;  
         in >> std::skipws >> member >> comma;  
200        }        }
201          in.clear();
202          in >> comma;
203    
204        in >> std::skipws >> admin >> comma;        in >> admin;
205        while(in.good()) {        while(in.good()) {
206          rm.admins.push_back(admin);          rm.admins.push_back(admin);
207          if(comma == ';') break;          in >> admin;
         in >> std::skipws >> admin >> comma;  
208        }        }
209          in.clear();
210          in >> comma;
211    
212        in >> std::skipws >> silenced >> comma;        in >> silenced;
213        while(in.good()) {        while(in.good()) {
214          rm.silenced.push_back(silenced);          rm.silenced.push_back(silenced);
215          if(comma == ';') break;          in >> silenced;
         in >> std::skipws >> silenced >> comma;  
216        }        }
217          in.clear();
218          in >> comma;
219    
220        in >> std::skipws >> banned >> comma;        in >> banned;
221        while(in.good()) {        while(in.good()) {
222          rm.banned.push_back(banned);          rm.banned.push_back(banned);
223          if(comma == ';') break;          in >> banned;
         in >> std::skipws >> banned >> comma;  
224        }        }
225          in.clear();
226          in >> comma;
227    
228    
229        rarray.insert(std::pair<int, room>(r, rm));        rarray.insert(std::pair<int, room>(r, rm));
230    
# Line 243  int SaveRoom(int r) Line 251  int SaveRoom(int r)
251      return COM_NOTIFYADMIN;      return COM_NOTIFYADMIN;
252    
253    out << rm.name;    out << rm.name;
254    //  out << "\nMembers\n";    out << "\n";
255      out << (int)rm.govt;
256    out << "\n";    out << "\n";
257    
258    for(std::vector<int>::iterator i = rm.members.begin();    for(std::vector<int>::iterator i = rm.members.begin();
259        i != rm.members.end(); ++i) {        i != rm.members.end(); ++i) {
260      out << *i;      out << *i;
261      std::vector<int>::iterator j = i;      std::vector<int>::iterator j = i;
262      if(++j != rm.members.end()) out << ", ";      if(++j != rm.members.end()) out << " ";
263    }    }
264    
265    //  out << "\nAdmins\n";    out << ";\n";
   out << "\n";  
266    
267    for(std::vector<int>::iterator i = rm.admins.begin();    for(std::vector<int>::iterator i = rm.admins.begin();
268        i != rm.admins.end(); ++i) {        i != rm.admins.end(); ++i) {
269      out << *i;      out << *i;
270      std::vector<int>::iterator j = i;      std::vector<int>::iterator j = i;
271      if(++j != rm.admins.end()) out << ", ";      if(++j != rm.admins.end()) out << " ";
272    }    }
273    
274    //  out << "\nSilenced\n";    out << ";\n";
   out << "\n";  
275    
276    for(std::vector<int>::iterator i = rm.silenced.begin();    for(std::vector<int>::iterator i = rm.silenced.begin();
277        i != rm.silenced.end(); ++i) {        i != rm.silenced.end(); ++i) {
278      out << *i;      out << *i;
279      std::vector<int>::iterator j = i;      std::vector<int>::iterator j = i;
280      if(++j != rm.silenced.end()) out << ", ";      if(++j != rm.silenced.end()) out << " ";
281    }    }
282    
283    //  out << "\nBanned\n";    out << ";\n";
   out << "\n";  
284    
285    for(std::vector<int>::iterator i = rm.banned.begin();    for(std::vector<int>::iterator i = rm.banned.begin();
286        i != rm.banned.end(); ++i) {        i != rm.banned.end(); ++i) {
287      out << *i;      out << *i;
288      std::vector<int>::iterator j = i;      std::vector<int>::iterator j = i;
289      if(++j != rm.banned.end()) out << ", ";      if(++j != rm.banned.end()) out << " ";
290    }    }
291    
292      out << ";";
293    
294    out.close();    out.close();
295    
296    return COM_OK;    return COM_OK;
# Line 307  int clear_player_from_rooms(int p) Line 315  int clear_player_from_rooms(int p)
315    }    }
316  }  }
317    
318    //should some govt types be by invite only?
319  int com_roomjoin(int p, param_list param)  int com_roomjoin(int p, param_list param)
320  {  {
321    int r = param[0].val.integer;    int r = param[0].val.integer;
# Line 327  int com_roomjoin(int p, param_list param Line 336  int com_roomjoin(int p, param_list param
336    return SaveRoom(r);    return SaveRoom(r);
337  }  }
338    
339    //I guess it would be going to far to not let
340    //people emigrate...?
341  int com_roomunjoin(int p, param_list param)  int com_roomunjoin(int p, param_list param)
342  {  {
343    int r = param[0].val.integer;    int r = param[0].val.integer;
# Line 339  int com_roomunjoin(int p, param_list par Line 350  int com_roomunjoin(int p, param_list par
350    if(res == rm.occupants.end() || !res->second.member)    if(res == rm.occupants.end() || !res->second.member)
351      return COM_NOTMEMBER;      return COM_NOTMEMBER;
352    res->second.member = false;    res->second.member = false;
353      std::vector<int>::iterator memi = std::find(rm.members.begin(), rm.members.end(), parray[p].uid);
354      if(memi != rm.members.end())
355        rm.members.erase(memi);
356    ReplyOccupant(r, p, ROOM + Unjoin, parray[p].name);    ReplyOccupant(r, p, ROOM + Unjoin, parray[p].name);
357    NotifyOccupants(r, ROOM + Unjoin, parray[p].name, p);    NotifyOccupants(r, ROOM + Unjoin, parray[p].name, p);
358    return COM_OK;    return COM_OK;
359  }  }
360    
361    //I guess admins should be able to close rooms
362    //to visitors
363  int com_roomvisit(int p, param_list param)  int com_roomvisit(int p, param_list param)
364  {  {
365    int r = param[0].val.integer;    int r = param[0].val.integer;
# Line 374  int com_roomvisit(int p, param_list para Line 390  int com_roomvisit(int p, param_list para
390    return COM_OK;    return COM_OK;
391  }  }
392    
393    //...but if they can visit, I think we have to allow
394    //them to leave
395  int com_roomleave(int p, param_list param)  int com_roomleave(int p, param_list param)
396  {  {
397    int r = param[0].val.integer;    int r = param[0].val.integer;
# Line 392  int com_roomleave(int p, param_list para Line 410  int com_roomleave(int p, param_list para
410    return COM_OK;    return COM_OK;
411  }  }
412    
413    //admins can already silence people
414    //so that's all the rights needed here
415  int com_roomtell(int p, param_list param)  int com_roomtell(int p, param_list param)
416  {  {
417    int r = param[0].val.integer;    int r = param[0].val.integer;
# Line 412  int com_roomtell(int p, param_list param Line 432  int com_roomtell(int p, param_list param
432    return COM_OK;    return COM_OK;
433  }  }
434    
435    //heh, should the secret police be vigilant or not?
436    //if so, maybe Fascists should be able to disallow
437    //whispers
438  int com_roomwhisper(int p1, param_list param)  int com_roomwhisper(int p1, param_list param)
439  {  {
440    int r = param[0].val.integer;    int r = param[0].val.integer;
# Line 429  int com_roomwhisper(int p1, param_list p Line 452  int com_roomwhisper(int p1, param_list p
452    return COM_OK;    return COM_OK;
453  }  }
454    
455    //The creating player should be automatically
456    //made an admin.  Except in the case of Anarchy
457    //types, which have no admin.
458  //TODO: Don't allow creation of rooms with same name?  //TODO: Don't allow creation of rooms with same name?
459  int com_roomcreate(int p, param_list param)  int com_roomcreate(int p, param_list param)
460  {  {
461    std::string s = param[0].val.string;    int g = param[0].val.integer;
462      std::string s = param[1].val.string;
463    
464    // find empty slot    // find empty slot
465    int r;    int r;
466    for(r = 0; rarray.find(r) != rarray.end(); r++)    for(r = 0; rarray.find(r) != rarray.end(); r++)
467      ;      ;
468    rarray[r].name = s;    rarray[r].name = s;
469      rarray[r].govt = (GovtType)g;
470    
471      switch(g)
472        {
473        case FASCISM:
474          if(!parray[p].registered) return COM_NOTREGISTERED;
475          rarray[r].admins.push_back(parray[p].uid);
476          break;
477        case ANARCHY:
478        case KILLARCHY:
479        default:
480          break;
481        }      
482    
483    ReplyOccupant(r, p, ROOM + Create, s);    ReplyOccupant(r, p, ROOM + Create, s);
484    
485    return SaveRoom(r);    return SaveRoom(r);
486  }  }
487    
488    //It might be fun to mess with people's heads,
489    //but let's just leave this on for now
490  int com_roomlistoccupants(int p, param_list param)  int com_roomlistoccupants(int p, param_list param)
491  {  {
492    int r = param[0].val.integer;    int r = param[0].val.integer;
# Line 456  int com_roomlistoccupants(int p, param_l Line 500  int com_roomlistoccupants(int p, param_l
500    for(std::map<int, occupant>::iterator i = rm.occupants.begin();    for(std::map<int, occupant>::iterator i = rm.occupants.begin();
501        i != rm.occupants.end(); ++i) {        i != rm.occupants.end(); ++i) {
502      std::string s = parray[i->first].login;      std::string s = parray[i->first].login;
503      s += "\n";      std::map<int, occupant>::iterator j = i;
504        if(++j != rm.occupants.end()) s += "\n";
505      ReplyOccupant(r, p, ROOM + ListOcc, s);      ReplyOccupant(r, p, ROOM + ListOcc, s);
506    }    }
507    
# Line 467  int com_roomlistoccupants(int p, param_l Line 512  int com_roomlistoccupants(int p, param_l
512     and banned lists, should probably fall under     and banned lists, should probably fall under
513     gov't policy rules.  Imagine the fun of a     gov't policy rules.  Imagine the fun of a
514     police stateroom where you don't even know who     police stateroom where you don't even know who
515     has been...eliminated.  (Gosh, what does that     has been....ELIMINATED (w/ extreme etc).  
516     remind me of?)     (Gosh, what does that remind me of?)
517  */  */
518  int com_roomlistmembers(int p, param_list param)  int com_roomlistmembers(int p, param_list param)
519  {  {
# Line 486  int com_roomlistmembers(int p, param_lis Line 531  int com_roomlistmembers(int p, param_lis
531        i != rm.members.end(); ++i) {        i != rm.members.end(); ++i) {
532      if(find_name(*i, login) != 0) return COM_NOTIFYADMIN;      if(find_name(*i, login) != 0) return COM_NOTIFYADMIN;
533      std::string s = login;      std::string s = login;
534      s += "\n";      std::vector<int>::iterator j = i;
535        if(++j != rm.members.end()) s += "\n";
536      ReplyOccupant(r, p, ROOM + ListMembers, s);      ReplyOccupant(r, p, ROOM + ListMembers, s);
537    }    }
538    
# Line 509  int com_roomlistadmins(int p, param_list Line 555  int com_roomlistadmins(int p, param_list
555        i != rm.admins.end(); ++i) {        i != rm.admins.end(); ++i) {
556      if(find_name(*i, login) != 0) return COM_NOTIFYADMIN;      if(find_name(*i, login) != 0) return COM_NOTIFYADMIN;
557      std::string s = login;      std::string s = login;
558      s += "\n";      std::vector<int>::iterator j = i;
559        if(++j != rm.admins.end()) s += "\n";
560      ReplyOccupant(r, p, ROOM + ListAdmins, s);      ReplyOccupant(r, p, ROOM + ListAdmins, s);
561    }    }
562    
# Line 532  int com_roomlistsilenced(int p, param_li Line 579  int com_roomlistsilenced(int p, param_li
579        i != rm.silenced.end(); ++i) {        i != rm.silenced.end(); ++i) {
580      if(find_name(*i, login) != 0) return COM_NOTIFYADMIN;      if(find_name(*i, login) != 0) return COM_NOTIFYADMIN;
581      std::string s = login;      std::string s = login;
582      s += "\n";      std::vector<int>::iterator j = i;
583        if(++j != rm.silenced.end()) s += "\n";
584      ReplyOccupant(r, p, ROOM + ListSilenced, s);      ReplyOccupant(r, p, ROOM + ListSilenced, s);
585    }    }
586    
# Line 555  int com_roomlistbanned(int p, param_list Line 603  int com_roomlistbanned(int p, param_list
603        i != rm.banned.end(); ++i) {        i != rm.banned.end(); ++i) {
604      if(find_name(*i, login) != 0) return COM_NOTIFYADMIN;      if(find_name(*i, login) != 0) return COM_NOTIFYADMIN;
605      std::string s = login;      std::string s = login;
606      s += "\n";      std::vector<int>::iterator j = i;
607        if(++j != rm.banned.end()) s += "\n";
608      ReplyOccupant(r, p, ROOM + ListBanned, s);      ReplyOccupant(r, p, ROOM + ListBanned, s);
609    }    }
610    
611    return COM_OK;    return COM_OK;
612  }  }
613    
614    int com_roomban(int p, param_list param)
615    {
616      int r = param[0].val.integer;
617      std::string login_to_ban = param[1].val.string;
618      bool do_ban;
619      int uid;
620    
621      // lookup room
622      std::map<int, room>::iterator rmi = rarray.find(r);
623      if(rmi == rarray.end()) return COM_NOSUCHROOM;
624      room& rm = rmi->second;
625    
626      switch(rm.govt)
627        {
628        case FASCISM:
629          //only admins can ban
630          do_ban = std::find(rm.admins.begin(), rm.admins.end(), parray[p].uid)
631            != rm.admins.end();
632          break;
633    
634        case KILLARCHY:
635          //no admins, everyone can ban
636          do_ban = true;
637        case ANARCHY:
638          //no admins, nobody can ban
639        default:
640          do_ban = false;
641        }
642          
643      if(!do_ban) return COM_NOBANPERMS;
644    
645      if((uid = find_uid(login_to_ban.c_str())) >= 0)
646        rm.banned.push_back(uid);
647      else
648        return COM_NOTIFYADMIN;
649    
650      ReplyOccupant(r, p, ROOM + Ban, login_to_ban.c_str());
651    
652      return SaveRoom(r);
653    }
654    
655    int com_roomunban(int p, param_list param)
656    {
657      int r = param[0].val.integer;
658      std::string login_to_unban = param[1].val.string;
659      bool do_unban;
660      int uid;
661    
662      // lookup room
663      std::map<int, room>::iterator rmi = rarray.find(r);
664      if(rmi == rarray.end()) return COM_NOSUCHROOM;
665      room& rm = rmi->second;
666    
667      switch(rm.govt)
668        {
669        case FASCISM:
670          //only admins can ban
671          do_unban = std::find(rm.admins.begin(), rm.admins.end(), parray[p].uid)
672            != rm.admins.end();
673          break;
674    
675        case KILLARCHY:
676          //no admins, everyone can ban
677          do_unban = true;
678        case ANARCHY:
679          //no admins, nobody can ban
680        default:
681          do_unban = false;
682        }
683          
684      if(!do_unban) return COM_NOBANPERMS;
685    
686      if((uid = find_uid(login_to_unban.c_str())) >= 0) {
687        std::vector<int>::iterator bani = std::find(rm.banned.begin(), rm.banned.end(), uid);
688        if(bani != rm.banned.end())
689          rm.banned.erase(bani);
690      }
691      else
692        return COM_NOTIFYADMIN;
693      
694      ReplyOccupant(r, p, ROOM + UnBan, login_to_unban.c_str());
695      
696      return SaveRoom(r);
697    }
698    
699    //not a room-level command, so gov't doesn't apply
700  int com_roomlistrooms(int p, param_list param){  int com_roomlistrooms(int p, param_list param){
701    
702    //reply with list of rooms    //reply with list of rooms
# Line 570  int com_roomlistrooms(int p, param_list Line 705  int com_roomlistrooms(int p, param_list
705      std::string s = rarray[i->first].name;      std::string s = rarray[i->first].name;
706      std::map<int, room>::iterator j = i;      std::map<int, room>::iterator j = i;
707      if(++j != rarray.end()) s += "\n";      if(++j != rarray.end()) s += "\n";
708      pprintf(p, "%d %d %s", ROOM + ListRoom, i->first, s.c_str());      pprintf(p, "%d %d %d %s", ROOM + ListRoom, i->first, i->second.govt, s.c_str());
709    }    }
710    
711    return COM_OK;    return COM_OK;
712  }  }
713    
714    //For all the game related commands:
715    //Fun to mess with, but let's leave them on
716  int com_roomlistgames(int p, param_list param)  int com_roomlistgames(int p, param_list param)
717  {  {
718    int r = param[0].val.integer;    int r = param[0].val.integer;

Legend:
Removed from v.1.8  
changed lines
  Added in v.1.9

savannah-hackers-public@gnu.org
ViewVC Help
Powered by ViewVC 1.1.26