| #define NEED_PROTOTYPES |
| #include <thing/properties.h> |
| #include <thing/language.h> |
| #include <thing/description.h> |
| #include <thing/commands.h> |
| #undef NEED_PROTOTYPES |
| #include <moving.h> |
| #include <items/kraeuter/kraeuter.h> |
| #include <defines.h> |
| #include <living/combat.h> // Fuer P_FREE_HANDS |
| |
| // Standardwert von 2 h fuer vollstaendige Regeneration des Krautes. |
| // Einfaches Nachwachsen ist typischerweise die Haelfte davon. |
| #define STD_WACHSTUM 7200 |
| #define BS(x) break_string(x, 78) |
| |
| // Struktur (6 Eintraege pro Kraut): |
| // ([ filename : ({ Zeit_bis_nachgewachsen, Zeit_bis_komplett_regeneriert, |
| // Kraut-IDs, Kraut-Adjektive, Kraut->Name(WER,1), |
| // ID_des_Bewacher-NPCs }) ]) |
| mapping plantMap = ([]); |
| |
| // kann benutzt werden um schnell und einfach eine Pflanze in einem Raum |
| // hinzuzufuegen. Beispiel: AddPlant(BAERENKLAU); |
| // Diese Funktion erzeugt automatisch ein AddCmd() fuer das Pfluecken und |
| // (falls noch nicht vorhanden) Details fuer die Pflanze. |
| // Rueckgabewerte: |
| // 1 -> Erfolg; -1 -> filename ungueltig |
| varargs int AddPlant(string filename, string|string* npcId) |
| { |
| mixed arr; |
| |
| // Dateiname nicht uebergeben? Dann tun wir erstmal gar nix. |
| if (!stringp(filename)) |
| return -1; |
| object ob=load_object(filename); |
| |
| // Wenn wir zu dem Kraut schon Daten haben (erkennbar an >2 Eintraegen), |
| // werfen wir einen Fehler, damit das beim Laden des Raumes schon |
| // erkannt wird. |
| if (pointerp(arr=plantMap[filename]) && sizeof(arr)>2) |
| raise_error("AddPlant(): "+filename+" already exists.\n"); |
| |
| // IDs und Adjektive parsen und den Datensatz zusammenstellen |
| string *ids = ob->Query(P_IDS, F_VALUE)-({ "Ding" }); |
| string *adj = ob->Query(P_ADJECTIVES, F_VALUE); |
| |
| if (!pointerp(arr) || sizeof(arr)<2) |
| arr = ({0,0}); |
| if ( !npcId ) |
| npcId = ({}); |
| else if (stringp(npcId)) |
| npcId = ({npcId}); |
| plantMap[filename]=({arr[0], arr[1], ids, adj, ob->Name(WER, 1), npcId }); |
| |
| // Details erzeugen aus Adjektiven und IDs |
| adj = ob->QueryProp(P_NAME_ADJ); |
| |
| // aktuelles Geschlecht zwischenspeichern, wird spaeter wiederhergestellt |
| int gender = Query(P_GENDER, F_VALUE); |
| Set(P_GENDER, ob->Query(P_GENDER, F_VALUE), F_VALUE); |
| |
| // erzeugt fuer jede moegliche Kombination aus Adjektiv im Akkusativ |
| // und ID des Krautes ein Detail. |
| adj = map(adj, #'DeclAdj, WEN, 0); |
| |
| string *det=({}); |
| foreach(string _id : ids) { |
| foreach(string _adj : adj) { |
| det += ({ _adj + _id }); |
| } |
| } |
| |
| det += ids; |
| // keine existierenden Details ueberschreiben |
| det -= m_indices(Query(P_DETAILS, F_VALUE) || ([])); |
| if (sizeof(det)) |
| AddDetail(det, ob->Query(PLANT_ROOMDETAIL, F_VALUE)); |
| |
| // Eine Befehlsfunktion brauchen wir natuerlich auch. |
| AddCmd(({"pflueck", "pfluecke", "ernte"}), "_pfluecken"); |
| |
| return 1; |
| } |
| |
| // Wenn jemand per Hand das Plantdetail hinzufuegen moechte... |
| // z.B. bei Verwendung von GetPlant() anstelle von AddPlant() |
| void AddPlantDetail(string filename) |
| { |
| // Pfad in Objektpointer wandeln |
| object ob=load_object(filename); |
| |
| // Details erzeugen |
| string *det = ({}); |
| string *ids = ob->Query(P_IDS, F_VALUE)-({ "Ding" }); |
| string *adj = ob->QueryProp(P_NAME_ADJ); |
| // aktuelles Geschlecht zwischenspeichern, wird spaeter wiederhergestellt |
| int gender=Query(P_GENDER, F_VALUE); |
| Set(P_GENDER, ob->Query(P_GENDER, F_VALUE)); |
| // erzeugt fuer jede moegliche Kombination aus Adjektiv im Akkusativ |
| // und ID des Krautes ein Detail. |
| adj = map(adj, #'DeclAdj, WEN, 0); |
| foreach(string _id : ids) { |
| foreach(string _adj : adj) { |
| det += ({ _adj + _id }); |
| } |
| } |
| AddDetail(det+ids, ob->Query(PLANT_ROOMDETAIL, F_VALUE)); |
| // Geschlecht zuruecksetzen |
| Set(P_GENDER, gender, F_VALUE); |
| } |
| |
| // Prueft, ob die Pflanze zu "filename" in diesem Raum schon nachgewachsen |
| // ist. |
| protected int CheckPlant(string filename) |
| { |
| mixed arr=plantMap[filename]; |
| if (!pointerp(arr) || sizeof(arr)<2) { |
| arr=plantMap[filename]=({ 0, 0 }); |
| } |
| // Solange die Zeit arr[0] noch nicht erreicht ist, ist das Kraut nicht |
| // nachgewachsen, dann gibt es gar nix. |
| return (time()>arr[0]); |
| } |
| |
| // Moechte man AddPlant() nicht benutzen, weil man die Pflanze nicht einfach |
| // pfluecken, sondern vielleicht abschneiden, oder ausgraben soll, so kann |
| // man sich mittels GetPlant(filename) das Objekt erzeugen lassen. Gibt |
| // GetPlant() 0 zurueck, ist die Pflanze noch nicht wieder weit genug |
| // nachgewachsen. |
| object GetPlant(string filename) |
| { |
| int *arr=plantMap[filename]; |
| if (!pointerp(arr) || sizeof(arr)<2) |
| { |
| arr=plantMap[filename]=({ 0, 0 }); |
| } |
| // arr[0] enthaelt den Zeitpunkt, wann das Kraut nachgewachsen ist, |
| int nachgewachsen = arr[0]; |
| // arr[1] denjenigen, wann es vollstaendig regeneriert ist. |
| int regeneriert = arr[1]; |
| |
| // Vor dem Nachgewachsen-Zeitpunkt kann man gar nix ernten. |
| if (time()<nachgewachsen) return 0; // noch nicht nachgewachsen |
| |
| // Restzeit bis zur vollstaendigen Regeneration. |
| regeneriert-=time(); |
| |
| // Wenn vollstaendig regeneriert, ist STD_WACHSTUM die neue Zeit bis zur |
| // Regeneration. Wenn noch nicht vollstaendig regenriert, Restzeit |
| // verdoppeln und STD_WACHSTUM nochmal drauf addieren. |
| regeneriert = (regeneriert<=0 ? STD_WACHSTUM |
| : (regeneriert*2)+STD_WACHSTUM); |
| // nachgewachsen ist die halbe Regenerationszeit |
| arr[0]=nachgewachsen=time()+(regeneriert/2); |
| // Zeit voelliger Regeneration |
| arr[1]=regeneriert+=time(); |
| |
| return clone_object(filename); |
| } |
| |
| static int _pfluecken(string str) |
| { |
| int res; |
| |
| if (!mappingp(plantMap)) return 0; |
| _notify_fail("WAS moechtest Du pfluecken?\n"); |
| |
| // IDs und Adjektive zwischenspeichern |
| mixed ids = Query(P_IDS, F_VALUE); |
| mixed adj = Query(P_ADJECTIVES, F_VALUE); |
| |
| foreach(string key, mixed krautinfo : plantMap) |
| { |
| if ( sizeof(krautinfo) != 6 ) |
| continue; |
| |
| // IDs und Adjektive des Krautes kopieren |
| Set(P_IDS, krautinfo[2], F_VALUE); |
| Set(P_ADJECTIVES, krautinfo[3], F_VALUE); |
| |
| // Syntaxpruefung wird dann mit id() gemacht. |
| if (id(str)) |
| { |
| object ob; |
| object bewacher; |
| res=1; |
| |
| // Liste der eingetragenen Bewacher-IDs durchlaufen und pruefen, ob |
| // mindestens einer davon anwesend ist. |
| foreach( string npcId : krautinfo[5] ) |
| { |
| bewacher = present(npcId, ME); |
| if (objectp(bewacher)) |
| break; |
| } |
| |
| if ( !PL->QueryProp(P_FREE_HANDS) ) |
| { |
| tell_object(PL, BS("Du hast keine Hand frei, um etwas pfluecken " |
| "zu koennen.")); |
| } |
| // Ist der Bewacher anwesend? Dann kann man das Kraut nicht pfluecken. |
| else if ( objectp(bewacher) ) |
| { |
| tell_object(PL, BS(bewacher->Name(WER, 2)+" laesst Dich " |
| "leider nicht nah genug heran. Irgendwie musst Du Dich wohl " |
| "zunaechst um "+bewacher->QueryPronoun(WEN)+" kuemmern.")); |
| } |
| // Wenn GetPlant() ein Objekt liefert, kann was gepflueckt werden. |
| else if ( objectp(ob=GetPlant(key)) ) |
| { |
| if ( ob->move(PL, M_GET) == MOVE_OK ) |
| { |
| write(BS("Vorsichtig pflueckst Du "+ob->name(WEN, 1)+ |
| " und nimmst "+ob->QueryPronoun(WEN)+" an Dich.")); |
| } |
| else |
| { |
| write(BS("Vorsichtig pflueckst Du "+ob->name(WEN, 1)+", kannst "+ |
| ob->QueryPronoun(WEN)+" aber nicht nehmen.")); |
| ob->move(environment(PL), M_GET); |
| } |
| } |
| // Wenn alles nicht, dann ist das Kraut noch nicht wieder da. |
| else |
| { |
| write(BS(krautinfo[4]+" ist noch nicht reif genug " |
| +"und muss erst noch etwas wachsen.")); |
| break; |
| } |
| } |
| } |
| // IDs und Adjektive zuruecksetzen. |
| Set(P_IDS, ids, F_VALUE); |
| Set(P_ADJECTIVES, adj, F_VALUE); |
| |
| return res; |
| } |
| |