Added public files
Roughly added all public files. Probably missed some, though.
diff --git a/secure/lepmaster.c b/secure/lepmaster.c
new file mode 100644
index 0000000..3d7cb79
--- /dev/null
+++ b/secure/lepmaster.c
@@ -0,0 +1,408 @@
+// MorgenGrauen MUDlib
+//
+// lepmaster.c -- Master, welcher aus scoremaster, explorationmaster,
+// questmaster und dem Spielerobjekt Informationen
+// ausliest und aus diesen die Levelpunkte des Spieler
+// berechnet
+// Weiters derjenige, der die Seheranforderungen
+// prueft.
+//
+// $Id: lepmaster.c 9168 2015-03-05 00:04:22Z Zesstra $
+
+// Hier kommen Funktionen fuer die Levelpunkte
+#pragma strict_types
+#pragma no_clone
+#pragma no_shadow
+#pragma no_inherit
+#pragma verbose_errors
+#pragma combine_strings
+//#pragma pedantic
+//#pragma range_check
+#pragma warn_deprecated
+
+#include <config.h>
+#include <properties.h>
+#include <new_skills.h>
+#include <exploration.h>
+#include <questmaster.h>
+#include <scoremaster.h>
+#include <wizlevels.h>
+
+#include "lepmaster.h"
+
+// Das Programm zur Foerderung der kleinen Level aktivieren. ;-)
+#define __PFOERKL__ 1
+
+// die ersten 8 Level, d.h. Level 1 bis 8 entsprechen diesen LEPs.
+int *LOW_LEVEL_LEP_LIST = ({100,120,140,180,220,300,360,420}); // 9. Level: 500 LEP
+
+#define REQ_TEXT1 ([0:"unglaublich viel", \
+ 1:"unglaublich viel", \
+ 2:"enorm viel", \
+ 3:"sehr viel", \
+ 4:"viel", \
+ 5:"einiges", \
+ 6:"etwas", \
+ 7:"wenig", \
+ 8:"sehr wenig", \
+ 9:"kaum etwas" ])
+
+#define REQ_TEXT2 ([0:"unglaublich viele", \
+ 1:"unglaublich viele", \
+ 2:"enorm viele", \
+ 3:"sehr viele", \
+ 4:"viele", \
+ 5:"einige", \
+ 6:"ein paar", \
+ 7:"wenige", \
+ 8:"sehr wenige", \
+ 9:"kaum" ])
+
+#define DEBUG(x,y)
+//#define DEBUG(x,y) if (find_player("zook")) tell_object(find_player("zook"),sprintf(x,y))
+
+
+void create()
+{
+ seteuid(getuid());
+}
+
+int QueryLEPForPlayer(object pl)
+{
+ int ret, val, i, l;
+
+ if (extern_call() && !IS_ARCH(geteuid(previous_object())))
+ return -1;
+ if (!pl || !query_once_interactive(pl))
+ return -2;
+
+ // Grundoffset 100, da man mit Level 1 statt 0 startet
+ ret = 100;
+
+ // Beitrag A: Stupse von NPC-Erstkills
+ ret += (int)SCOREMASTER->QueryKillPoints(pl);
+
+ DEBUG("Nach KP: ret = %d\n", ret);
+
+ // Beitrag B: Stupse von geloesten Miniquests
+ ret += (int)QM->QueryMiniQuestPoints(pl);
+
+ DEBUG("Nach MQP: ret = %d\n", ret);
+
+ // Beitrag C: Questpunkte
+ // werden 1:1 uebernommen;
+ ret += (int)pl->QueryProp(P_QP);
+
+ DEBUG("Nach QP: ret = %d\n", ret);
+
+ // Beitrag D: Erfahrungspunkte
+ // Stupse = XPs ^ 0.32
+ val = (int)pl->QueryProp(P_XP);
+
+ if (val<1) l=0;
+ else l=to_int(exp(log(to_float(val))*0.32));
+
+ ret += l;
+
+ DEBUG("Nach XP: ret = %d\n", ret);
+
+ // Beitrag E: Zaubertraenke
+ // Gefundene Traenke geben 5 LEP
+ // Die Heiltraenke geben zusaetzlich 10+20+30+40 LEP
+ i = 80 - (val = sizeof((int *)pl->QueryProp(P_POTIONROOMS)));
+
+ ret += 5*i + ([ 0: 100, 1: 60, 2: 30, 3: 10])[val];
+
+ // Beitrag F: Forscherpunkte
+ // Pro FP gibt es 6 Stufenpunkte
+ ret += 6 * (int)EPMASTER->QueryExplorationPoints(pl);
+
+ DEBUG("Nach FP: ret = %d\n", ret);
+
+ // Beitrag G: Gildeneinstufung
+ // Maximale Gildeneinstufung (10000) entspricht vier Leveln
+ ret += ((int)pl->QueryProp(P_GUILD_RATING))/25;
+
+ DEBUG("Nach GR: ret = %d\n", ret);
+
+ // Ausgabe gibt es nur in 20er-Schritten
+ ret -= ret%20;
+
+ return (ret > 100) ? ret : 100;
+
+}
+
+nomask int QueryLEP()
+{
+ if (!previous_object())
+ return 0;
+ return QueryLEPForPlayer(previous_object());
+}
+
+nomask int QueryLevel(int lep) {
+ if (lep<=0)
+ lep=QueryLEP();
+
+ if (lep<=0)
+ return 0;
+
+#ifdef __PFOERKL__
+ // normale Level alle 100 LEP
+ if (lep >= 500)
+ return lep/100 + 4;
+ else {
+ // level mit weniger LEP am Anfang (1-8)
+ // Level aus der LOW_LEVEL_LEP_LIST raussuchen.
+ int lev = sizeof(LOW_LEVEL_LEP_LIST) - 1;
+ for ( ; lev >= 0; --lev) {
+ if (LOW_LEVEL_LEP_LIST[lev] <= lep)
+ break; // gefunden
+ }
+ return lev+1;
+ }
+#else
+ return lep/100;
+#endif // __PFOERKL__
+ return 0;
+}
+
+// Wieviele LEP fehlen zum naechsten Level?
+nomask int QueryNextLevelLEP(int lvl, int lep) {
+ int needed;
+
+ if (QueryLevel(lep) > lvl)
+ return 0;
+
+#ifdef __PFOERKL__
+ if (lvl < sizeof(LOW_LEVEL_LEP_LIST))
+ needed = LOW_LEVEL_LEP_LIST[lvl];
+ else
+ needed = (lvl-3) * 100; // (lvl + 1 - 4) * 100
+#else
+ needed = (lvl+1) * 100;
+#endif // __PFOERKL__
+
+ // needed sind jetzt die insgesamt benoetigten LEP. Vorhandene abziehen.
+ needed -= lep;
+ // nix < 0 zurueckliefern
+ return max(needed,0);
+}
+
+string QueryForschung()
+{
+ int max, my, avg;
+ string ret;
+
+ if ((my=(int)EPMASTER->QueryExplorationPoints(getuid(previous_object()))) < MIN_EP)
+ return "Du kennst Dich im "MUDNAME" so gut wie gar nicht aus.\n";
+
+ my *= 100;
+ max = my/(int)EPMASTER->QueryMaxEP();
+ avg = my/(int)EPMASTER->QueryAverage();
+
+ ret = "Verglichen mit Deinen Mitspielern, kennst Du Dich im "MUDNAME" ";
+ switch(avg) {
+ case 0..10:
+ ret += "kaum";
+ break;
+ case 11..40:
+ ret += "aeusserst schlecht";
+ break;
+ case 41..56:
+ ret += "sehr schlecht";
+ break;
+ case 57..72:
+ ret += "schlecht";
+ break;
+ case 73..93:
+ ret += "unterdurchschnittlich";
+ break;
+ case 94..109:
+ ret += "durchschnittlich gut";
+ break;
+ case 110..125:
+ ret += "besser als der Durchschnitt";
+ break;
+ case 126..145:
+ ret += "recht gut";
+ break;
+ case 146..170:
+ ret += "ziemlich gut";
+ break;
+ case 171..210:
+ ret += "gut";
+ break;
+ case 211..300:
+ ret += "sehr gut";
+ break;
+ case 301..400:
+ ret += "ausserordentlich gut";
+ break;
+ case 401..500:
+ ret += "unheimlich gut";
+ break;
+ default:
+ ret += "einfach hervorragend";
+ break;
+ }
+ ret += " aus.\nAbsolut gesehen ";
+
+ switch(max) {
+ case 0..5:
+ ret += "kennst Du nur wenig vom "MUDNAME".";
+ break;
+ case 6..10:
+ ret += "solltest Du Dich vielleicht noch genauer umsehen.";
+ break;
+ case 11..17:
+ ret += "bist Du durchaus schon herumgekommen.";
+ break;
+ case 18..25:
+ ret += "hast Du schon einiges gesehen.";
+ break;
+ case 26..35:
+ ret += "bist Du schon weit herumgekommen.";
+ break;
+ case 36..50:
+ ret += "koenntest Du eigentlich einen Reisefuehrer herausbringen.";
+ break;
+ case 51..75:
+ ret += "hast Du schon sehr viel gesehen.";
+ break;
+ default:
+ ret += "besitzt Du eine hervorragende Ortskenntnis.";
+ }
+ return break_string(ret, 78, 0, 1);
+}
+
+
+nomask mixed QueryWizardRequirements(object player)
+{
+ // Diese Funktion gibt ein 2-elementiges Array zurueck, in dem im ersten
+ // Element steht, ob der Spieler Seher werden kann (1) oder
+ // nicht (0) und im zweiten Element steht, was genau ihm noch
+ // fehlt.
+ // Fehlercode ist ({-1, ""})
+
+ // Die Umrechnungsfaktoren wurden einfach aus QueryLEP uebernommen; ggf.
+ // kann man das einmal in Unterfunktionen auslagern.
+
+ mixed ret;
+ string s;
+ int i,z,val;
+
+ ret = ({-1, "Hier ist etwas schief gelaufen. Bitte einen Erzmagier\n"
+ +"benachrichtigen.\n"});
+ s = "";
+ i = 0;
+
+ if(!player || !objectp(player))
+ player=(this_player()?this_player():this_interactive());
+
+ if(!player)
+ return ({-1,""});
+
+ DEBUG("Es geht um: %O\n", player);
+
+ // Abenteuerpunkte
+ DEBUG("Abenteuerpunkte: %d ("+REQ_QP+")\n", player->QueryProp(P_QP));
+ if (player->QueryProp(P_QP) < REQ_QP) {
+ s += sprintf(" * Dir fehlen noch mindestens %d Abenteuerpunkte.\n",
+ REQ_QP - (int)player->QueryProp(P_QP));
+ i--;
+ }
+
+ // Forscherpunkte
+ z = 6 * (int)EPMASTER->QueryExplorationPoints(player);
+ DEBUG("Forscherpunkte: %d ("+REQ_EP+")\n", z);
+ if (z < REQ_EP) {
+ s += sprintf(" * Du kennst Dich im "MUDNAME" noch nicht genug aus, "
+ +"genau genommen\n musst Du Dir noch %s ansehen.\n",
+ REQ_TEXT1[(z*10/REQ_EP)] );
+ i--;
+ }
+
+ // Zaubertraenke
+ z = 80 - (val = sizeof((int*)player->QueryProp(P_POTIONROOMS)));
+ z = z*5 + ([0:100, 1:60, 2:30, 3:10])[val];
+ DEBUG("Zaubertraenke: %d ("+REQ_P+")\n", z);
+ if (z < REQ_P) {
+ s += sprintf(" * Du musst noch einige Zaubertraenke (ca. %d) suchen.\n",
+ (REQ_P - z)/5 );
+ i--;
+ }
+
+ // Erstkills
+ z = (int)SCOREMASTER->QueryKillPoints(player);
+ DEBUG("Erstkills: %d ("+REQ_K+")\n", z);
+ if (z < REQ_K) {
+ s += sprintf(" * Du hast noch nicht genuegend wuerdige Gegner erlegt, genau "
+ +"genommen\n musst Du noch %s wuerdige Monster toeten.\n",
+ REQ_TEXT2[(z*10/REQ_K)] );;
+ i--;
+ }
+
+ int minlevel = QueryLevel(REQ_LEP);
+
+ // Restliche Stufenpunkte
+ DEBUG("Stufenpunkte: %d ("+REQ_LEP+")\n", player->QueryProp(P_LEP));
+ if ((int)(player->QueryProp(P_LEP)) < REQ_LEP) {
+ s += sprintf(" * Du musst mindestens %d Stufenpunkte, entspricht Stufe %d, "
+ "erreichen.\n", REQ_LEP, minlevel);
+ i--;
+ }
+
+ // Demnach mindestens REQ/100-Level
+ DEBUG("Level: %d ("+REQ_LEP/100+")\n", player->QueryProp(P_LEVEL));
+ if ((int)player->QueryProp(P_LEVEL) < minlevel) {
+ s += sprintf(" * Du musst mindestens Stufe %d erreichen.\n", minlevel);
+ i--;
+ }
+
+ if(i<0) {
+ ret = ({-1,
+ sprintf("Du hast noch nicht alle Seher-Anforderungen erfuellt.\n"
+ +"Im einzelnen fehlt Dir folgendes:\n\n%s\n"
+ +break_string("Falls Du Dir nun dennoch unsicher bist, "
+ +"welche Anforderungen Du erfuellen musst, dann "
+ +"schaue bei 'hilfe seher' und 'hilfe stufenpunkte' doch einfach noch "
+ +"einmal nach. Sind dann "
+ +"immer noch Dinge offen oder unklar, so sprich einfach einen "
+ +"der Erzmagier an.", 78,0,1),s) });
+ }
+
+ if (i==0) {
+ ret = ({1, break_string(
+ "Du hast alle Seher-Anforderungen erfuellt. Wende Dich doch "
+ +"einmal an Merlin und frage ihn, ob er Dich befoerdert.",
+ 78,0,1) });
+ }
+
+ return ret;
+}
+
+nomask int QueryReadyForWiz(object player)
+{
+ mixed r;
+
+ r = QueryWizardRequirements(player);
+
+ if (!pointerp(r) && sizeof(r)!=2 && !intp(r[0]))
+ return -1;
+
+ return r[0];
+}
+
+nomask string QueryReadyForWizText(object player)
+{
+ mixed r;
+
+ r = QueryWizardRequirements(player);
+
+ if (!pointerp(r) && sizeof(r)!=2 && !stringp(r[1]))
+ return "Hier ist etwas schief gegangen, bitte verstaendige einen "
+ +"Erzmagier.";
+
+ return r[1];
+}
+