team.c-Dateireferenz

#include <properties.h>
#include <living/combat.h>
#include <combat.h>
#include <living/team.h>
#include <wizlevels.h>
Include-Abhängigkeitsdiagramm für team.c:

gehe zum Quellcode dieser Datei

Makrodefinitionen

#define NEED_PROTOTYPES
#define ME   this_object()
#define TP   this_player()
#define PO   previous_object()
#define ENV   environment()
#define FILLSTRING   " "

Funktionen

void create ()
void add_team_commands ()
string _query_team_attack_cmd ()
int _query_team_autofollow ()
static private int team_help ()
object IsTeamLeader ()
object * TeamMembers ()
string TeamPrefix ()
static private int team_aufnahmewunsch (string arg)
static private int team_aufnahme (string arg)
object IsTeamMove ()
static void DoTeamAttack (object env, object callbackto)
int CallTeamAttack (object env)
static int DoTeamFollow ()
int CallTeamFollow (object env, string cmd)
int ClearTeamFollow ()
mixed * PresentTeamRows ()
varargs mixed * PresentEnemyRows (object *here)
varargs object SelectNearEnemy (object *here, int forcefrom)
varargs object SelectFarEnemy (object *here, int min, int max, int forcefrom)
mixed _query_friend ()
int DeAssocMember (object npc)
int AssocMember (object npc)
varargs void InsertEnemyTeam (mixed ens, int rek)
int TeamFlee ()
varargs mapping PresentTeamPositions (mixed pres_rows)
varargs int PresentPosition (mixed pmap)
varargs static private string center_string (string str, int w)
static private int ShowTeamRows ()
varargs int team_list (string arg)
varargs int teamcmd (string arg)
varargs void InformRowChange (int from, int to, object caster)

Variablen

private nosave string team_attack_cmd
private nosave mapping team_follow_todo
private nosave int team_autofollow
private nosave object teammove

Makro-Dokumentation

#define ENV   environment()

Definiert in Zeile 24 der Datei team.c.

#define FILLSTRING   " "

Definiert in Zeile 492 der Datei team.c.

Wird benutzt von center_string().

#define ME   this_object()

Definiert in Zeile 21 der Datei team.c.

#define NEED_PROTOTYPES

Definiert in Zeile 12 der Datei team.c.

#define PO   previous_object()

Definiert in Zeile 23 der Datei team.c.

#define TP   this_player()

Definiert in Zeile 22 der Datei team.c.

Dokumentation der Funktionen

mixed _query_friend (  ) 

Definiert in Zeile 346 der Datei team.c.

Benutzt P_FRIEND, P_TEAM_ASSOC_MEMBERS und Query().

00346                       {
00347   mixed res;
00348 
00349   if (res=Query(P_FRIEND))
00350     return res;
00351   if (objectp(res=Query(P_TEAM_ASSOC_MEMBERS))
00352       && query_once_interactive(res))
00353     return res;
00354   return 0;
00355 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

string _query_team_attack_cmd (  ) 

Definiert in Zeile 45 der Datei team.c.

Benutzt P_TEAM_ATTACK_CMD, Set() und team_attack_cmd.

00045                                 {
00046   return Set(P_TEAM_ATTACK_CMD,team_attack_cmd);
00047 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

int _query_team_autofollow (  ) 

Definiert in Zeile 49 der Datei team.c.

Benutzt P_TEAM_AUTOFOLLOW, Set() und team_autofollow.

00049                              {
00050   return Set(P_TEAM_AUTOFOLLOW,team_autofollow);
00051 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

void add_team_commands (  ) 

Definiert in Zeile 39 der Datei team.c.

Wird benutzt von create().

00039                          {
00040   add_action("teamcmd","gruppe");
00041   add_action("teamcmd","g");
00042   add_action("teamcmd","team");
00043 }

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

int AssocMember ( object  npc  ) 

Definiert in Zeile 375 der Datei team.c.

Benutzt IsEnemy(), ME, obs, P_TEAM, P_TEAM_ASSOC_MEMBERS, PO, QueryProp(), SetProp() und team.

00375                             {
00376   mixed obs;
00377   object team;
00378 
00379   if (extern_call() && PO!=npc &&
00380       member(({"gilden","spellbooks"}),
00381              explode(object_name(PO),"/")[1])<0)
00382     return 0;
00383   if (!objectp(npc)
00384       || npc->QueryProp(P_TEAM_ASSOC_MEMBERS)
00385       || IsEnemy(npc)
00386       || npc==ME
00387       || query_once_interactive(npc))
00388     return 0;
00389   obs=QueryProp(P_TEAM_ASSOC_MEMBERS);
00390   if (objectp(obs))
00391     return 0;
00392   if (!pointerp(obs))
00393     obs=({});
00394   obs=(obs-({npc,0}))+({npc});
00395   SetProp(P_TEAM_ASSOC_MEMBERS,obs);
00396   npc->SetProp(P_TEAM_ASSOC_MEMBERS,ME);
00397   if (objectp(team=QueryProp(P_TEAM)))
00398     team->AddAssocMember(ME,npc);
00399   return 1;
00400 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

int CallTeamAttack ( object  env  ) 

Definiert in Zeile 167 der Datei team.c.

Benutzt call_out(), P_TEAM, PO, Query() und team_attack_cmd.

00167                                {
00168   if (stringp(team_attack_cmd)
00169       && find_call_out("DoTeamAttack")<0
00170       && PO
00171       && PO==Query(P_TEAM))
00172     return call_out("DoTeamAttack",0,env,PO),1;
00173   return 0;
00174 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

int CallTeamFollow ( object  env,
string  cmd 
)

Definiert in Zeile 203 der Datei team.c.

Benutzt call_out(), ENV, P_TEAM, PO, Query(), team_autofollow und team_follow_todo.

00203                                            {
00204   if (!team_autofollow
00205       || PO!=Query(P_TEAM)
00206       || !PO
00207       || !objectp(env)
00208       || !stringp(cmd))
00209     return 0;
00210   if (!mappingp(team_follow_todo))
00211     team_follow_todo=([]);
00212   if (ENV!=env && !team_follow_todo[ENV])
00213     return 0;
00214   team_follow_todo[env]=cmd;
00215   if (find_call_out("DoTeamFollow")<0)
00216     call_out("DoTeamFollow",0);
00217   return 1;
00218 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

varargs static private string center_string ( string  str,
int  w 
) [static]

Definiert in Zeile 493 der Datei team.c.

Benutzt FILLSTRING.

Wird benutzt von ShowTeamRows().

00493                                                                {
00494   return (FILLSTRING[0..((w-strlen(str))/2-1)]+str+FILLSTRING)[0..(w-1)];
00495 }

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

int ClearTeamFollow (  ) 

Definiert in Zeile 220 der Datei team.c.

Benutzt P_TEAM, PO, Query() und team_follow_todo.

00220                       {
00221   if (PO!=Query(P_TEAM) || !PO)
00222     return 0;
00223   team_follow_todo=([]);
00224   return 1;
00225 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

void create (  ) 

Definiert in Zeile 31 der Datei team.c.

Benutzt F_MODE_AS, F_SET_METHOD, P_TEAM_ATTACK_CMD, P_TEAM_AUTOFOLLOW, PROTECTED, Set() und teammove.

00031               {
00032   Set(P_TEAM_ATTACK_CMD,-1,F_SET_METHOD);
00033   Set(P_TEAM_ATTACK_CMD,PROTECTED,F_MODE_AS);
00034   Set(P_TEAM_AUTOFOLLOW,-1,F_SET_METHOD);
00035   Set(P_TEAM_AUTOFOLLOW,PROTECTED,F_MODE_AS);
00036   teammove=0;
00037 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

int DeAssocMember ( object  npc  ) 

Definiert in Zeile 357 der Datei team.c.

Benutzt ME, obs, P_TEAM, P_TEAM_ASSOC_MEMBERS, PO, QueryProp(), SetProp() und team.

00357                               {
00358   mixed obs;
00359   object team;
00360 
00361   if (extern_call() && PO!=npc &&
00362       member(({"gilden","spellbooks"}),
00363              explode(object_name(PO),"/")[1])<0)
00364     return 0;
00365   obs=QueryProp(P_TEAM_ASSOC_MEMBERS);
00366   if (!pointerp(obs))
00367     return 0;
00368   obs-=({npc,0});
00369   SetProp(P_TEAM_ASSOC_MEMBERS,obs);
00370   if (objectp(team=QueryProp(P_TEAM)))
00371     team->RemoveAssocMember(ME,npc);
00372   return 1;
00373 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

static void DoTeamAttack ( object  env,
object  callbackto 
) [static]

Definiert in Zeile 155 der Datei team.c.

Benutzt command, ENV, IS_LEARNER, ME, P_TEAM, Query(), team_attack_cmd und teammove.

00155                                                         {
00156   if (env==ENV && stringp(team_attack_cmd) && !IS_LEARNER(ME)
00157       && (interactive(ME) || !query_once_interactive(ME))
00158       && objectp(callbackto) && callbackto==Query(P_TEAM)) {
00159     teammove=callbackto;
00160     command(team_attack_cmd);
00161   }
00162   if (objectp(callbackto))
00163     callbackto->TeamAttackExecuted_Callback(teammove?1:0);
00164   teammove=0;
00165 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

static int DoTeamFollow (  )  [static]

Definiert in Zeile 176 der Datei team.c.

Benutzt call_out(), command, ENV, IS_LEARNER, m_delete(), ME, team_autofollow und team_follow_todo.

00176                           {
00177   string cmd;
00178 
00179   if (!team_autofollow
00180       || (!interactive(ME) && query_once_interactive(ME))
00181       || IS_LEARNER(ME)
00182       || !mappingp(team_follow_todo))
00183     return 0;
00184   if (!stringp(cmd=team_follow_todo[ENV]))
00185     return team_follow_todo=0;
00186 
00187   do {
00188     efun::m_delete(team_follow_todo,ENV);
00189     tell_object(ME,sprintf("Du folgst Deinem Team mit \"%s\".\n",cmd));
00190     command(cmd);
00191   } while (get_eval_cost()>900000 && random(1000)>20 && objectp(ME)
00192            && stringp(cmd=team_follow_todo[ENV]));
00193 
00194   // Ist Spieler in Umgebung gelandet, fuer die noch ein
00195   // Befehl auszufuehren ist?
00196   if (!objectp(ME) || !stringp(team_follow_todo[ENV]))
00197     return team_follow_todo=0;
00198   while  (remove_call_out("DoTeamFollow")!=-1) ;
00199   call_out("DoTeamFollow",0);
00200   return 0;
00201 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

varargs void InformRowChange ( int  from,
int  to,
object  caster 
)

Definiert in Zeile 637 der Datei team.c.

Benutzt gilde, ME, P_GUILD, P_TEAM, PO, Query() und QueryProp().

00637                                                               {
00638   mixed gilde;
00639 
00640   if (caster) return; // Fuer den Fall, dass Gildenobjekt==ME ist
00641   if (PO!=Query(P_TEAM)) return;
00642   if (!stringp(gilde=QueryProp(P_GUILD))) return;
00643   if (!objectp(gilde=find_object("/gilden/"+gilde))) return;
00644   gilde->InformRowChange(from,to,ME);
00645 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

varargs void InsertEnemyTeam ( mixed  ens,
int  rek 
)

Definiert in Zeile 402 der Datei team.c.

Benutzt i, InsertSingleEnemy(), ME, ob(), obs, P_TEAM, Query() und team.

Wird benutzt von InsertEnemy().

00402                                                  {
00403   object *obs,ob,eteam,team;
00404   int i;
00405 
00406   team=Query(P_TEAM);
00407   // Alle Teammitglieder des Gegners sind Feind:
00408   if (objectp(ens)) {
00409     if (objectp(eteam=ens->QueryProp(P_TEAM))) {
00410       if (eteam==team) // feindliches Team = eigenes Team?
00411         return;        // also nicht alle Teammitglieder gegeneinander hetzen
00412       ens=eteam->Members();
00413     } else {
00414       ens=({ens});
00415     }
00416   }
00417   if (!pointerp(ens))
00418     return;
00419   ens-=({ME});
00420 
00421   // Interactives sollen keine Interactives durch Team angreifen:
00422   if (query_once_interactive(ME)) {
00423     for (i=sizeof(ens)-1;i>=0;i--)
00424       if (objectp(ob=ens[i]) && environment(ob)==environment()
00425           && !query_once_interactive(ob))
00426         InsertSingleEnemy(ob);
00427   } else {
00428     for (i=sizeof(ens)-1;i>=0;i--)
00429       if (objectp(ob=ens[i]) && environment(ob)==environment())
00430         InsertSingleEnemy(ob);
00431   }
00432 
00433   // Alle anderen Teammitglieder Informieren:
00434   if (rek || !objectp(team) || !pointerp(obs=team->Members()))
00435     return;
00436   obs-=({ME});
00437   obs-=ens;
00438   for (i=sizeof(obs)-1;i>=0;i--)
00439     if (objectp(ob=obs[i]))
00440       ob->InsertEnemyTeam(ens,1);
00441 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

object IsTeamLeader (  ) 

Definiert in Zeile 81 der Datei team.c.

Benutzt ME, P_TEAM, P_TEAM_LEADER, Query() und team.

Wird benutzt von NotifyMove() und teamcmd().

00081                       {
00082   object team;
00083 
00084   if (!objectp(team=Query(P_TEAM))
00085       || team!=Query(P_TEAM_LEADER)
00086       || team->Leader()!=ME)
00087     return 0;
00088   return team;
00089 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

object IsTeamMove (  ) 

Definiert in Zeile 149 der Datei team.c.

Benutzt P_TEAM, Query() und teammove.

Wird benutzt von InitAttack().

00149                     {
00150   if (!objectp(teammove) || (teammove!=Query(P_TEAM)))
00151     teammove=0;
00152   return teammove;
00153 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

varargs mixed* PresentEnemyRows ( object *  here  ) 

Definiert in Zeile 245 der Datei team.c.

Benutzt EMPTY_TEAMARRAY, ENV, i, MAX_TEAMROWS, ob(), P_TEAM, PresentEnemies(), Query(), rows und team.

Wird benutzt von SelectFarEnemy() und ShowTeamRows().

00245                                               {
00246   mixed *res,*rows;
00247   mapping added_teams;
00248   int i,j;
00249   object ob,team;
00250 
00251   added_teams=([Query(P_TEAM):1]); // Nicht auf eigenes Team hauen
00252   res=EMPTY_TEAMARRAY;
00253   if (!pointerp(here))
00254     here=PresentEnemies();
00255   for (i=sizeof(here)-1;i>=0;i--) {
00256     if (!objectp(ob=here[i]))
00257       continue;
00258     if (!objectp(team=ob->QueryProp(P_TEAM))) {
00259       res[0]+=({ob});
00260       continue;
00261     }
00262     if (added_teams[team])
00263       continue;
00264     added_teams[team]=1;
00265     rows=team->PresentRows(ENV);
00266     for (j=0;j<MAX_TEAMROWS;j++)
00267       res[j]+=rows[j];
00268   }
00269   return res;
00270 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

varargs int PresentPosition ( mixed  pmap  ) 

Definiert in Zeile 476 der Datei team.c.

Benutzt ENV, i, MAX_TEAMROWS, ME, P_TEAM, Query() und team.

00476                                         {
00477   object team;
00478   int i;
00479 
00480   if (!objectp(team=Query(P_TEAM)))
00481     return 1;
00482   if (mappingp(pmap))
00483     return pmap[ME];
00484   if (!pointerp(pmap))
00485     pmap=team->PresentRows(ENV);
00486   for (i=1;i<MAX_TEAMROWS;i++)
00487     if (member(pmap[i],ME)>=0)
00488       return i+1;
00489   return 1;
00490 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

varargs mapping PresentTeamPositions ( mixed  pres_rows  ) 

Definiert in Zeile 459 der Datei team.c.

Benutzt i, MAX_TEAMROWS, ob(), obs und PresentTeamRows().

00459                                                       {
00460   mapping res;
00461   int i,j;
00462   object *obs,ob;
00463 
00464   res=([]);
00465   if (!pointerp(pres_rows))
00466     pres_rows=PresentTeamRows();
00467   for (i=0;i<MAX_TEAMROWS;i++) {
00468     obs=pres_rows[i];
00469     for (j=sizeof(obs)-1;j>=0;j--)
00470       if (objectp(ob=obs[j]) && !res[ob])
00471         res[ob]=i+1;
00472   }
00473   return res;
00474 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

mixed* PresentTeamRows (  ) 

Definiert in Zeile 227 der Datei team.c.

Benutzt EMPTY_TEAMARRAY, ENV, i, MAX_TEAMROWS, ME, P_TEAM, Query() und team.

Wird benutzt von PresentTeamPositions() und ShowTeamRows().

00227                          {
00228   object team;
00229   mixed *res;
00230   int i;
00231 
00232   if (!objectp(team=Query(P_TEAM))) {
00233     res=EMPTY_TEAMARRAY;
00234     res[0]=({ME});
00235     return res;
00236   }
00237   res=team->PresentRows(ENV);
00238   for (i=0;i<MAX_TEAMROWS;i++)
00239     if (member(res[i],ME)>=0)
00240       return res;
00241   res[0]+=({ME});
00242   return res;
00243 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

varargs object SelectFarEnemy ( object *  here,
int  min,
int  max,
int  forcefrom 
)

Definiert in Zeile 315 der Datei team.c.

Benutzt i, MAX_TEAMROWS, PresentEnemies(), PresentEnemyRows(), rows, SelectEnemy() und sum.

00315                                                                              {
00316   mixed *rows;
00317   int *prob,i,r,sum;
00318   object en;
00319 
00320   if (max<0 || min>=MAX_TEAMROWS || max<min)
00321     return 0;
00322   if (min<0) min=0;
00323   if (max>=MAX_TEAMROWS) max=MAX_TEAMROWS-1;
00324   if (!pointerp(here))
00325     here=PresentEnemies();
00326   rows=PresentEnemyRows(here);
00327   prob=({0,0,0,0,0});
00328   sum=0;
00329   for (i=min;i<=max;i++)
00330     sum=prob[i]=sum+sizeof(rows[i])+max-i;
00331 
00332   r=random(sum);
00333   for (i=min;i<=max;i++)
00334     if (r<prob[i])
00335       break;
00336   if (i>max)
00337     i=min;
00338   if (objectp(en=SelectEnemy(forcefrom?(here&rows[i]):rows[i])))
00339     return en;
00340   for (i=min;i<=max;i++)
00341     if (objectp(en=SelectEnemy(forcefrom?(here&rows[i]):rows[i])))
00342       return en;
00343   return 0;
00344 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

varargs object SelectNearEnemy ( object *  here,
int  forcefrom 
)

Definiert in Zeile 272 der Datei team.c.

Benutzt ENV, i, MAX_TEAMROWS, ME, ob(), P_TEAM, PresentEnemies(), Query(), rows, SelectEnemy(), sum und team.

Wird benutzt von heart_beat().

00272                                                             {
00273   object ob,en,team;
00274   mixed *rows;
00275   int *prob,prot,i,r,sz,upsz,sum;
00276 
00277   if (!pointerp(here))
00278     here=PresentEnemies();
00279   if (!objectp(ob=SelectEnemy(here)))
00280     return 0;
00281   en=ob->QueryProp(P_TEAM);          // Feindliches Team
00282   if (objectp(team=Query(P_TEAM))) { // Eigenes Team
00283     if (en==team) // Feind im eigenen Team, kein ANDERES Mitglied waehlen.
00284       return ob;  // Aber auch ausserhalb Reihe 1 draufhauen
00285     rows=team->PresentRows(ENV);
00286     if (member(rows[0],ME)<0) // Stehe ich in der ersten Reihe?
00287       return 0; // Falls nein ist auch kein Gegner nahe.
00288   }
00289   if (!objectp(en))
00290     return ob; // Ist nicht in einem Team, also drauf.
00291   rows=en->PresentRows(environment(ob));
00292   prob=({1,0,0,0,0});
00293   prot=sum=0;
00294   for (i=0;i<MAX_TEAMROWS;i++) {
00295     if (prot>0) prot--;                // Schutzkegel nimmt ab.
00296     if (!sz=sizeof(rows[i])) continue; // Gegner in dieser Reihe
00297     upsz=sz-prot;if (upsz<0) continue; // Anzahl ungeschuetzter Gegner
00298     prob[i]+=(upsz+sum);               // Wahrscheinlichkeit += ungeschuetzt
00299     sum=prob[i];                       // Summe bisheriger Wahrscheinlichkeiten
00300     if (sz>prot) prot=sz;              // Neuer Schutzkegel
00301   }
00302   r=random(sum);
00303   for (i=0;i<MAX_TEAMROWS;i++)
00304     if (r<prob[i])
00305       break;
00306   if (i>=MAX_TEAMROWS)
00307     i=0;
00308   if (objectp(en=SelectEnemy(forcefrom?(here&rows[i]):rows[i])))
00309     return en;
00310   if (i && objectp(en=SelectEnemy(forcefrom?(here&rows[0]):rows[0])))
00311     return en;
00312   return ob;
00313 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

static private int ShowTeamRows (  )  [static]

Definiert in Zeile 497 der Datei team.c.

Benutzt center_string(), i, MAX_TEAMROWS, ob(), obs, PresentEnemyRows(), PresentTeamRows() und RAW.

Wird benutzt von teamcmd().

00497                                   {
00498   int i,j,sz;
00499   mixed *pres_rows;
00500   object *obs,ob;
00501   string str;
00502 
00503   pres_rows=PresentEnemyRows();
00504   for (sz=MAX_TEAMROWS-1;sz>=0;sz--)
00505     if (sizeof(pres_rows[sz]))
00506       break;
00507   for (i=sz;i>=0;i--) {
00508     obs=pres_rows[i];str="";
00509     for (j=sizeof(obs)-1;j>=0;j--)
00510       if (objectp(ob=obs[j])) {
00511         if (str!="") str+=" / ";
00512         str+=ob->Name(RAW);
00513       }
00514     printf("%d. %s\n",i+1,center_string(str,75));
00515   }
00516   if (sz>=0)
00517     write("   ---------------------------------------------------------------------------\n");
00518   pres_rows=PresentTeamRows();
00519   for (sz=MAX_TEAMROWS-1;sz>0;sz--)
00520     if (sizeof(pres_rows[sz]))
00521       break;
00522   for (i=0;i<=sz;i++) {
00523     obs=pres_rows[i];str="";
00524     for (j=sizeof(obs)-1;j>=0;j--)
00525       if (objectp(ob=obs[j])) {
00526         if (str!="") str+=" / ";
00527         str+=ob->Name(RAW);
00528       }
00529     printf("%d. %s\n",i+1,center_string(str,75));
00530   }
00531   return 1;
00532 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

static private int team_aufnahme ( string  arg  )  [static]

Definiert in Zeile 129 der Datei team.c.

Benutzt ENV, find_player(), ME, notify_fail(), P_TEAM, P_TEAM_NEWMEMBER, pl, QueryProp(), team, TEAM_OBJECT und WER.

Wird benutzt von teamcmd().

00129                                              {
00130   object pl,team;
00131   int res;
00132 
00133   if ((!objectp(pl=find_player(arg)) && !objectp(pl=present(arg,ENV)))
00134       || pl->QueryProp(P_INVIS) || environment(pl)!=ENV)
00135     return notify_fail(capitalize(arg)+" nicht gefunden.\n"),0;
00136   if (pl->QueryProp(P_TEAM_NEWMEMBER)!=ME)
00137     return notify_fail(pl->Name(WER)+" hat Dich nicht um Aufnahme gebeten.\n"),
00138       0;
00139   if (pl==ME)
00140     return notify_fail("Du bist eine Person zu wenig fuer ein Team.\n"),0;
00141   if (!objectp(team=QueryProp(P_TEAM)))
00142     team=clone_object(TEAM_OBJECT);
00143   res=team->AddMember(pl);
00144   if (!sizeof(team->Members()))
00145     team->remove();
00146   return res;
00147 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

static private int team_aufnahmewunsch ( string  arg  )  [static]

Definiert in Zeile 108 der Datei team.c.

Benutzt ENV, find_player(), ME, notify_fail(), P_TEAM_NEWMEMBER, pl, SetProp(), TP, WEN und WER.

Wird benutzt von teamcmd().

00108                                                    {
00109   object pl;
00110 
00111   if ((!objectp(pl=find_player(arg)) && !objectp(pl=present(arg,ENV)))
00112       || pl->QueryProp(P_INVIS) || environment(pl)!=ENV)
00113     return notify_fail(capitalize(arg)+" nicht gefunden.\n"),0;
00114   if (!living(pl))
00115     return notify_fail(pl->Name(WER)+" ist etwas zu inaktiv.\n"),0;
00116   if (pl==ME)
00117     return notify_fail("Du bist eine Person zu wenig fuer ein Team.\n"),0;
00118   SetProp(P_TEAM_NEWMEMBER,pl);
00119   if (pl->IsTeamLeader()) {
00120     write("Du bittest "+pl->name(WEN)+" um Aufnahme ins Team.\n");
00121     tell_object(pl,TP->Name(WER)+" bittet Dich um Aufnahme ins Team.\n");
00122   } else {
00123     write("Du bittest "+pl->name(WEN)+" um Gruendung eines Teams.\n");
00124     tell_object(pl,TP->Name(WER)+" bittet Dich um Gruendung eines Teams.\n");
00125   }
00126   return 1;
00127 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

static private int team_help (  )  [static]

Definiert in Zeile 53 der Datei team.c.

Wird benutzt von teamcmd().

00053                                {
00054   // Syntax-Kompatiblitaet (Avalon) ist ganz nett :-)
00055   write("\
00056 (Befehle des Teamleiters sind mit * gekennzeichnet\n\
00057 \n\
00058 * team angriff\n\
00059   team angriffsbefehl <befehl>\n\
00060 * team aufnahme <name>\n\
00061   team autof[olge] <ein/aus>\n\
00062 * team autoi[nfo] <ein/aus> [+[lp]] [+[kp]] [sofort]\n\
00063 * team entlasse <name>\n\
00064   team farben lp_rot lp_gelb kp_rot kp_gelb\n\
00065   team flucht[reihe] <reihe>\n\
00066   team folge <name>\n\
00067 * team formation <min[-max]> [<min[-max]> ...]\n\
00068   team hilfe|?\n\
00069   team [info] [sortiert|alphabetisch]\n\
00070   team [kampf]reihe <reihe>\n\
00071 * team leiter[in] <name>\n\
00072   team liste\n\
00073 * team name <gruppenname>\n\
00074   team orte [alle]\n\
00075   team ruf[e]\n\
00076   team uebersicht\n\
00077   team verlasse\n");
00078   return 1;
00079 }

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

varargs int team_list ( string  arg  ) 

Definiert in Zeile 534 der Datei team.c.

Benutzt i, ME, ob(), obs, TEAM_MASTER und WER.

Wird benutzt von teamcmd().

00534                                   {
00535   object *tobs,*obs,tob,ob,ld;
00536   string *nms,*tnms,str;
00537   int i,j;
00538 
00539   if (!pointerp(tobs=TEAM_MASTER->ListTeamObjects())) return 0;
00540   if (arg!="alle") arg=0;
00541   tnms=({});
00542   for (i=sizeof(tobs)-1;i>=0;i--) {
00543     if (!objectp(tob=tobs[i])
00544         || !objectp(ld=tob->Leader())
00545         || (!query_once_interactive(ld) && !arg)
00546         || !pointerp(obs=tob->Members()))
00547       continue;
00548     nms=({});
00549     for (j=sizeof(obs)-1;j>=0;j--) {
00550       if (!objectp(ob=obs[j])
00551           || (!query_once_interactive(ob) &&!arg))
00552         continue;
00553       if (!stringp(str=ob->Name(WER))) str="?";
00554       if (ob==ld) str+="(*)";
00555       nms+=({str});
00556       nms=sort_array(nms,#'>);
00557     }
00558     if (!stringp(str=tob->Name())) str="Team ?";
00559     str+=": ";
00560     tnms+=({break_string(implode(nms,", "),78,str)});
00561     tnms=sort_array(tnms,#'<);
00562   }
00563   if (sizeof(tnms))
00564     tell_object(ME, sprintf("%@s\n", tnms));
00565   else
00566     tell_object(ME, "Keine Teams gefunden.\n"); 
00567   
00568   return 1;
00569 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

varargs int teamcmd ( string  arg  ) 

Definiert in Zeile 571 der Datei team.c.

Benutzt IsTeamLeader(), notify_fail(), P_TEAM, QueryProp(), ShowTeamRows(), team, team_attack_cmd, team_aufnahme(), team_aufnahmewunsch(), team_autofollow, team_help(), team_list() und TP.

00571                                 {
00572   string *words,narg;
00573   object team;
00574 
00575   if (!arg)
00576     arg="";
00577   if (!stringp(narg=TP->_unparsed_args()))
00578     narg = arg;
00579   if (!sizeof(words=explode(arg," ")))
00580     return 0;
00581  
00582   if (sizeof(words) > 1) {
00583       arg=implode(words[1..]," ");
00584       narg = implode(explode(narg, " ")[1..], " ");
00585   }
00586   else
00587       arg = narg = "";
00588 
00589   switch(words[0]) { // Befehle die keine Mitgliedschaft erfordern:
00590   case "aufnahme":
00591     return team_aufnahme(arg);
00592   case "folge":
00593     return team_aufnahmewunsch(arg);
00594   case "?":
00595   case "hilfe":
00596     return team_help();
00597   case "liste":
00598     return team_list(arg);  
00599   case "uebersicht":
00600     return ShowTeamRows();
00601   default:;
00602   }
00603 
00604   if (!objectp(team=QueryProp(P_TEAM)))
00605     return notify_fail("Du bist in keinem Team.\n"),0;
00606 
00607   switch(words[0]) {
00608   case "angriffsbefehl":
00609     if (narg=="") narg=0;
00610     team_attack_cmd=narg;
00611     if (stringp(narg))
00612       write("Du beginnst den Kampf mit \""+narg+"\"\n");
00613     else
00614       write("Du hast den Teamangriffsbefehl deaktiviert.\n");
00615     break; // NICHT return!
00616   case "autofolge":
00617   case "autof":
00618     if (arg=="ein" || arg=="an") {
00619       team_autofollow=1;
00620       if (IsTeamLeader())
00621         write("Dein Team folgt Dir.\n");
00622       else
00623         write("Du folgst jetzt dem Teamleiter.\n");
00624     } else {
00625       team_autofollow=0;
00626       if (IsTeamLeader())
00627         write("Dein Team folgt Dir nicht mehr.\n");
00628       else
00629         write("Du folgst jetzt nicht mehr dem Teamleiter.\n");
00630     }
00631     break; // NICHT return!
00632   default: ;
00633   }
00634   return team->TeamCmd(words[0],narg); // Befehle die Mitgliedschaft erfordern:
00635 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

int TeamFlee (  ) 

Definiert in Zeile 443 der Datei team.c.

Benutzt ME, P_TEAM, P_TEAM_LEADER, P_TEAM_WIMPY_ROW, Query(), team und team_autofollow.

Wird benutzt von CheckWimpyAndFlee() und Flee().

00443                {
00444   object team;
00445 
00446   if (Query(P_TEAM_WIMPY_ROW)<2 || !objectp(team=Query(P_TEAM)))
00447     return 0;
00448   if (!team->FleeToRow(ME))
00449      return 0;
00450   if (Query(P_TEAM_LEADER)==team) {
00451     if (team_autofollow)
00452       tell_object(ME,"Du versuchst zu fliehen, "+
00453                   "Dein Team folgt Dir nicht mehr.\n");
00454     team_autofollow=0;
00455   }
00456   return 1;
00457 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

object* TeamMembers (  ) 

Definiert in Zeile 91 der Datei team.c.

Benutzt ME, P_TEAM, Query() und team.

Wird benutzt von Pacify().

00091                       {
00092   object team;
00093 
00094   if (!objectp(team=Query(P_TEAM)))
00095     return ({ME});
00096   return team->Members();
00097 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

string TeamPrefix (  ) 

Definiert in Zeile 99 der Datei team.c.

Benutzt P_TEAM, Query() und team.

Wird benutzt von score().

00099                     {
00100   object team;
00101 
00102   if (!objectp(team=Query(P_TEAM)))
00103     return "";
00104   return "["+team->Name()+"] ";
00105 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

Variablen-Dokumentation

private nosave string team_attack_cmd

Definiert in Zeile 26 der Datei team.c.

Wird benutzt von _query_team_attack_cmd(), CallTeamAttack(), DoTeamAttack() und teamcmd().

private nosave int team_autofollow

Definiert in Zeile 28 der Datei team.c.

Wird benutzt von _query_team_autofollow(), CallTeamFollow(), DoTeamFollow(), teamcmd() und TeamFlee().

private nosave mapping team_follow_todo

Definiert in Zeile 27 der Datei team.c.

Wird benutzt von CallTeamFollow(), ClearTeamFollow() und DoTeamFollow().

private nosave object teammove

Definiert in Zeile 29 der Datei team.c.

Wird benutzt von create(), DoTeamAttack() und IsTeamMove().

Erzeugt am Thu Jun 3 14:40:47 2010 für MorgenGrauen Mudlib von  doxygen 1.6.3