std/restriction_checker.c

// MorgenGrauen MUDlib
//
// restriction_checker.c -- Beschraenkungen in Gilden, Spells und Skills
//
// $Id: restriction_checker.c 8754 2014-04-26 13:12:58Z Zesstra $
#pragma strong_types
#pragma save_types
#pragma no_clone
#pragma pedantic
//#pragma range_check
#pragma no_shadow

inherit "/std/util/executer";

#define NEED_PROTOTYPES
#include <thing/properties.h>
#include <properties.h>
#include <new_skills.h>
#include <wizlevels.h>
#include <questmaster.h>

#define DEBUG(x) if (find_player("zesstra")) tell_object(find_player("zesstra"),x)

// erweitert um das <pl> argument und die extra-Argument, die bereits in <fun>
// angegeben wurden. (*grummel*)
protected mixed execute_anything(mixed fun, object pl, varargs mixed args)
{
  //DEBUG(sprintf("ex_any(): Fun: %O, Ob: %O, args: %O\n",fun,pl,args));
  // wenn in fun schon extraargumente stehen, dann pl einfuegen und args
  // dranhaengen.
  if (pointerp(fun) && sizeof(fun) > 2)
  {
    // args kann ({}) sein, wenn keine Extraargumente uebergeben wurden, macht
    // aber nix.
    args = ({pl}) + fun[2..] + args;
    fun = fun[0..1];
    return ::execute_anything(fun, args...);
  }
  // s.o.
  return ::execute_anything(fun, pl, args...);
}

mapping race_modifier(object pl, mapping map_ldfied) {
  mapping rmap,help;

  if (mappingp(map_ldfied) && member(map_ldfied,SM_RACE) && objectp(pl) &&
      mappingp(rmap=map_ldfied[SM_RACE]))
//    if (mappingp(help=rmap[pl->_query_real_race()]))
    if (mappingp(help=rmap[pl->QueryProp(P_REAL_RACE)]))
        return map_ldfied+help;
    else if(member(rmap,"*") && mappingp(help=rmap["*"]))
        return map_ldfied+help;
  return map_ldfied;
}

string
check_restrictions(object pl, mapping restr) {
  /* Folgende Einschraenkungen koennen geprueft werden:
   * - Mindestwerte bei allen Attributen und Properties Level, QP, XP
   * - bestimmte Rassen koennen ausgeschlossen werden bzw. erlaubt werden
   *   (SR_EXCLUDE_RACE ist ein Array von ausgeschlossenen Rassen,
   *    SR_INCLUDE_RACE eines mit eingeschlossenen)
   * - SR_RACE kann ein Mapping sein, dass Rassen ein eigenes
   *   Restriction-mapping zuordnet. "*" steht fuer alle anderen Rassen.
   */
  closure cl,cl2;
  string race, guild;

  if (!mappingp(restr) || !sizeof(restr)) return 0; // Keine Einschraenkungen
  if (!objectp(pl)) return "";
  if (pl->QueryDisguise())
    return "Zieh erst mal den Tarnhelm aus.\n";

  restr=race_modifier(&pl,&restr);

  cl=symbol_function("QueryProp",pl);
  cl2=symbol_function("QueryAttribute",pl);

  foreach(string to_check, mixed condition: restr)
  {
    switch(to_check)
    {
      case P_LEVEL:
        if (funcall(cl,P_LEVEL) < condition)
          return "Deine Stufe reicht dafuer nicht aus.\n";
        break;
      case P_GUILD_LEVEL:
        if (funcall(cl,P_GUILD_LEVEL) < condition)
          return "Deine Gildenstufe reicht dafuer nicht aus.\n";
        break;
      case SR_SEER: // das macht nun wahrlich nur bei interactives sinn!!!
        if (condition && query_once_interactive(pl) && !IS_SEER(pl))
          return "Du musst dazu erst Seher werden.\n";
        break;
      case P_XP:
        if (funcall(cl,P_XP) < condition)
          return "Du hast nicht genuegend Erfahrung dafuer.\n";
        break;
      case P_QP:
        if (funcall(cl,P_QP) < condition)
          return "Du hast nicht genuegend Aufgaben geloest.\n";
        break;
      case P_ALCOHOL:
        if (funcall(cl,P_ALCOHOL) >= condition)
          return "Du bist zu besoffen.\n";
        break;
      case P_DRINK:
        if (funcall(cl,P_DRINK) >= condition)
          return "Du hast zuviel getrunken.\n";
        break;
      case P_FOOD:
        if (funcall(cl,P_FOOD) >= condition)
          return "Du hast zuviel gegessen.\n";
        break;
      case P_DEAF:
        if (funcall(cl,P_DEAF))
          return "Du kannst nichts hoeren.\n";
        break;
      case P_BLIND:
        if (funcall(cl,P_BLIND))
          return "Du kannst nichts sehen.\n";
        break;
      case P_FROG:
        if (funcall(cl,P_FROG))
          return "Als Frosch kannst Du das leider nicht.\n";
        break;
      case A_INT:
        if (funcall(cl2,A_INT) < condition)
          return "Deine Intelligenz reicht dafuer nicht aus.\n";
        break;
      case A_DEX:
        if (funcall(cl2,A_DEX) < condition)
          return "Deine Geschicklichkeit reicht dafuer nicht aus.\n";
        break;
      case A_CON:
        if (funcall(cl2,A_CON) < condition)
          return "Deine Ausdauer reicht dafuer nicht aus.\n";
        break;
      case A_STR:
        if (funcall(cl2,A_STR) < condition)
          return "Deine Staerke reicht dafuer nicht aus.\n";
        break;
      case SR_BAD:
        if (funcall(cl,P_ALIGN) < condition)
          return "Du bist zu boese.\n";
        break;
      case SR_GOOD:
        if (funcall(cl,P_ALIGN) > condition)
          return "Du bist nicht boese genug.\n";
        break;
      case SR_MIN_SIZE:
        if (funcall(cl,P_SIZE) < condition)
          return "Du bist dafuer zu klein.\n";
        break;
      case SR_MAX_SIZE:
        if (funcall(cl,P_SIZE) > condition)
          return "Du bist dafuer zu gross.\n";
        break;
      case SR_FREE_HANDS:
        if (condition > (funcall(cl,P_MAX_HANDS)-funcall(cl,P_USED_HANDS)))
          return "Du hast nicht genug freie Haende dafuer.\n";
        break;
      case SR_EXCLUDE_RACE:
        if (IS_LEARNER(pl))
          race=funcall(cl,P_RACE);
        else
          race=funcall(cl,P_REAL_RACE); //race=pl->_query_real_race();
        if ( pointerp(condition) && member(condition,race)>=0 )
          return ("Als "+race+" kannst Du das nicht.\n");
        break;
     case SR_INCLUDE_RACE:
        if (IS_LEARNER(pl))
          race=funcall(cl,P_RACE);
        else
          race=funcall(cl,P_REAL_RACE); //race=pl->_query_real_race();
        if (pointerp(condition) && member(condition,race)<0)
          return ("Als "+race+" kannst Du das nicht.\n");
        break;
     case SR_EXCLUDE_GUILD:
        guild=funcall(cl,P_GUILD);
        if (pointerp(condition) && member(condition,guild)>=0)
          return ("Mit Deiner Gildenzugehoerigkeit kannst Du das nicht.\n");
        break;
      case SR_INCLUDE_GUILD:
        guild=funcall(cl,P_GUILD);
        if (pointerp(condition) && member(condition,guild)<0)
          return ("Mit Deiner Gildenzugehoerigkeit kannst Du das nicht.\n");
        break;
     case SR_FUN:
        // In aller Regel sollte die Funktion dann nicht in diesem Objekt
        // gerufen werden, sondern in dem, was uns ruft.
        if(stringp(condition) && extern_call())
        {
          condition=({previous_object(),condition});
        }
        string res=execute_anything(condition, pl);
        if (stringp(res))
          return res;
        break;
     case SR_PROP:
        foreach ( string propname, mixed value, string msg: condition ) {
          if ( funcall(cl, propname) != value )
            return ( stringp(msg) && sizeof(msg) ? msg :
              "Koennte es sein, dass Du vergessen hast, etwas zu "
              "erledigen?\n");
        }
        break;
     case SR_QUEST:
        if (pointerp(condition))
        {
          // geloeste Quests aus der Liste der Bedingungen entfernen
          condition -= filter(condition, "QueryQuest", pl);
          if ( sizeof(condition) )
            return ("Du musst zuerst das Abenteuer '"+condition[0]+
              "' loesen.\n");
        }
        break;
     case SR_MINIQUEST:
        if (pointerp(condition))
        {
          closure unsolved_MQs = function int (mixed mq_num)
            { return !(QM)->HasMiniQuest(pl, mq_num); };
          if ( sizeof(filter(condition, unsolved_MQs)) )
            return "Du hast eine benoetigte Miniquest noch nicht geloest.\n";
            // Der Name der MQ wird absichtlich nicht explizit ausgegeben.
        }
        break;
    } // switch
  } // foreach
  return 0;
}

varargs mixed
GetData(string dname, mapping map_ldfied, object pl) {
  mixed dat,res;

  if (!dname || !mappingp(map_ldfied)) return 0;
  if (closurep(dat=map_ldfied[dname]) && (res=funcall(dat,pl,map_ldfied)))
        return res;
  return dat;

}

varargs int
GetValue(string vname, mapping map_ldfied, object pl) {
  mixed dat,res;

  // printf("GetValue(%O): %O\n",vname,map_ldfied);
  if (!vname || !map_ldfied) return 0;
  if ((dat=map_ldfied[vname]) && (res=execute_anything(dat,pl,map_ldfied)))
        return res;
  // printf("Value: %O\n",dat);
  return intp(dat) ? dat : 0;
}

varargs int
GetFactor(string fname, mapping map_ldfied, object pl) {
  mixed res;

  // printf("GetFactor(%O):\n",fname);
  if (!fname  || !(res=GetValue(FACTOR(fname),map_ldfied,pl)))
        return 100;
  if (res<10) res=10;
  else if (res>1000) res=1000;
  // printf("Factor: %O\n",res);
  return res;
}

varargs int
GetOffset(string oname, mapping map_ldfied, object pl) {
  mixed res;

  // printf("GetOffset(%O):\n",oname);
  if (!oname  || !(res=GetValue(OFFSET(oname),map_ldfied,pl)))
        return 0;
  if (res<-10000) res=-10000;
  else if (res>10000) res=10000;
  // printf("Offset: %O\n",res);
  return res;
}

varargs int
GetFValue(string vname, mapping map_ldfied, object pl) {
  return (GetValue(vname,map_ldfied,pl)*GetFactor(vname,map_ldfied,pl))/100;
}

varargs int
GetValueO(string vname, mapping map_ldfied, object pl) {
  return GetValue(vname,map_ldfied,pl)+GetOffset(vname,map_ldfied,pl);
}

varargs int
GetFValueO(string vname, mapping map_ldfied, object pl) {
  return ((GetValue(vname,map_ldfied,pl)*GetFactor(vname,map_ldfied,pl))/100
                  + GetOffset(vname,map_ldfied,pl));
}

varargs int
GetRandFValueO(string vname, mapping map_ldfied, object pl) {
  return (random(GetValue(vname,map_ldfied,pl)*GetFactor(vname,map_ldfied,pl))/100
          + GetOffset(vname,map_ldfied,pl));
}

mapping AddSkillMappings(mapping oldmap, mapping newmap) {
  mapping res,t1,t2;
  mixed *inx,ind;
  int i;

  if (!mappingp(oldmap)) return newmap;
  if (!mappingp(newmap)) return oldmap;
  inx=({SI_SKILLRESTR_LEARN,SI_SKILLRESTR_USE,SM_RACE});
  res=oldmap+newmap;
  for (i=sizeof(inx);i--;) {
        ind=inx[i];
        t1=oldmap[ind];
        t2=newmap[ind];
        if (t1) {
          if (t2)
                res[ind]=t1+t2;
          else
                res[ind]=t1;
        } else {
          if (t2)
                res[ind]=t2;
        }
  }
  return res;
}