MG Mud User | 88f1247 | 2016-06-24 23:31:02 +0200 | [diff] [blame^] | 1 | /** Doku: |
| 2 | public int AddRoute(string transporter, string* l_stops) |
| 3 | Beschreibung: |
| 4 | Setzt die aktuelle Route eines Transporters. |
| 5 | Die Route hier ist allerdings nur die Liste von Haltepunkten - nicht der |
| 6 | Rest, der in den Routen in den Transporter abgelegt ist. |
| 7 | Eine neue Route ersetzt immer die bisherige Route |
| 8 | Wird von /std/transport gerufen, wenn P_NO_TRAVELING nicht gesetzt ist. |
| 9 | Rueckgabewerte: |
| 10 | - 1: Transporter und Haltepunkt Eingetragen. |
| 11 | - 0: Transporter oder Haltepunkt kein string|string*. |
| 12 | - -1: Es wurde versucht einen Transporter in /p/ oder /players/ |
| 13 | einzutragen |
| 14 | und der Eintragende ist kein EM. |
| 15 | |
| 16 | public int RemoveTransporter(string|object transporter) |
| 17 | public int RemoveStop(string|object stop) |
| 18 | Beschreibung: |
| 19 | Entfernt einen kompletten Transporter oder einen Haltepunkt aus dem |
| 20 | Daemon. |
| 21 | Rueckgabewerte: |
| 22 | - 1: Erfolg. |
| 23 | - 0: Transporter|Haltepunkt existiert nicht. |
| 24 | - -1: Keine Berechtigung. |
| 25 | |
| 26 | public varargs int|object* HasTransporter(object stop, string transporter_id) |
| 27 | Beschreibung: |
| 28 | Gibt eine Liste der Transporter aus, den den Haltepunkt anlaufen, oder |
| 29 | prueft auf einen bestimmten Transporter. |
| 30 | Rueckgabewerte: |
| 31 | - 0: Haltepunkt ist kein Objekt, dem Haltepunkt sind keine Transporter |
| 32 | zugeordnet, |
| 33 | die Transporter sind nicht geladen |
| 34 | oder, bei angabe von <transporter>: <transporter> faehrt den Hafen |
| 35 | nicht an. |
| 36 | - object*: Liste mit einem oder mehreren Transportern. |
| 37 | Bemerkung: |
| 38 | Auch bei der Angabe von <transporter_id> koennen mehrere Objekte |
| 39 | zurueckgegeben werden, es wird mittels id() gefiltert. |
| 40 | |
| 41 | public mixed RouteExists(object transporter, string dest) |
| 42 | Beschreibung: |
| 43 | Prueft auf korrekte Parameter und leitet die Anfrage an |
| 44 | /std/transport weiter. |
| 45 | Rueckgabewerte: |
| 46 | - 0: <transporter> ist kein Objekt oder <dest> ist kein String. |
| 47 | - Das Ergebnis von transporter->HasRoute(dest); |
| 48 | |
| 49 | public mapping QueryTransporters() |
| 50 | public mapping QueryAllStops() |
| 51 | public mapping QueryTransporterByStop(string stop) |
| 52 | public mapping QueryStopsByTransporter(string transporter) |
| 53 | Beschreibung: |
| 54 | Gibt das jewilige gefilterte oder ungefilterte Mapping aus. |
| 55 | Rueckgabewerte: |
| 56 | Mapping mit dem Ergebnis. |
| 57 | */ |
| 58 | |
| 59 | #pragma strong_types,save_types,rtt_checks |
| 60 | #pragma pedantic,range_check,warn_deprecated |
| 61 | #pragma warn_empty_casts,warn_missing_return,warn_function_inconsistent |
| 62 | #pragma no_clone,no_shadow |
| 63 | |
| 64 | #include <transport.h> |
| 65 | #include <wizlevels.h> |
| 66 | #include <daemon.h> |
| 67 | |
| 68 | #define TRANSPORTER 0 |
| 69 | #define STOP 1 |
| 70 | |
| 71 | #define MEMORY "/secure/memory" |
| 72 | |
| 73 | // Key: string Schiff. |
| 74 | // Value0: string* Haefen, die von <Schiff> angefahren werden. |
| 75 | mapping transporters = ([]); |
| 76 | // Key: string Hafen |
| 77 | // Value0: string* Schiffe, die <Hafen> anfahren. |
| 78 | mapping stops = ([]); |
| 79 | |
| 80 | protected void create() |
| 81 | { |
| 82 | // Vom MEMORY die Daten abholen. |
| 83 | // Wenn keine da, war vermutlich Reboot, dann muessen wir warten, bis die |
| 84 | // Transporter sich wieder melden. Aber die Mappings muessen ins Memory |
| 85 | // geschrieben werden. |
| 86 | mapping tmp = MEMORY->Load("stops"); |
| 87 | if (mappingp(tmp)) |
| 88 | { |
| 89 | stops = tmp; |
| 90 | } |
| 91 | else |
| 92 | { |
| 93 | if (MEMORY->Save("stops",stops) != 1) |
| 94 | raise_error("Could not save memory to /secure/memory."); |
| 95 | } |
| 96 | tmp = MEMORY->Load("transporters"); |
| 97 | if (mappingp(tmp)) |
| 98 | { |
| 99 | transporters = tmp; |
| 100 | } |
| 101 | else |
| 102 | { |
| 103 | if (MEMORY->Save("transporters",transporters) != 1) |
| 104 | raise_error("Could not save memory to /secure/memory."); |
| 105 | } |
| 106 | } |
| 107 | |
| 108 | varargs int remove(int s) |
| 109 | { |
| 110 | destruct(this_object()); |
| 111 | return 1; |
| 112 | } |
| 113 | |
| 114 | // Loeschfunktion |
| 115 | private int _remove_data(string|object key, int what) |
| 116 | { |
| 117 | mapping first,second; |
| 118 | // Erstmal die Arbeitsmappings befuellen. |
| 119 | if(what==TRANSPORTER) |
| 120 | { |
| 121 | first=transporters; |
| 122 | second=stops; |
| 123 | } |
| 124 | else |
| 125 | { |
| 126 | first=stops; |
| 127 | second=transporters; |
| 128 | } |
| 129 | |
| 130 | // Key auf einen String normalisieren. |
| 131 | if(objectp(key)) |
| 132 | { |
| 133 | key=object_name(key); |
| 134 | } |
| 135 | |
| 136 | if(!member(first,key)) |
| 137 | { |
| 138 | return 0; |
| 139 | } |
| 140 | |
| 141 | // Erstmal aus dem jeweils anderen Mapping austragen. |
| 142 | foreach(string s : first[key]) |
| 143 | { |
| 144 | // Nicht existent oder nicht zugeordnet -> weiter. |
| 145 | if(!member(second,s) || member(second[s],key)==-1) |
| 146 | { |
| 147 | continue; |
| 148 | } |
| 149 | second[s]-=({key}); |
| 150 | if (!sizeof(second[s])) |
| 151 | m_delete(second,s); |
| 152 | } |
| 153 | // Jetzt noch aus dem eigenen Mapping austragen. |
| 154 | m_delete(first,key); |
| 155 | return 1; |
| 156 | } |
| 157 | |
| 158 | // Ein komplettes Schiff entfernen. |
| 159 | public int RemoveTransporter(object|string transporter) |
| 160 | { |
| 161 | if (extern_call() && !IS_ARCH(getuid(previous_object()))) return -1; |
| 162 | return _remove_data(transporter,TRANSPORTER); |
| 163 | } |
| 164 | |
| 165 | // Entfernt einen kompletten Hafen aus dem Daemon |
| 166 | public int RemoveStop(object|string stop) |
| 167 | { |
| 168 | if (extern_call() && !IS_ARCH(getuid(previous_object()))) return -1; |
| 169 | return _remove_data(stop,STOP); |
| 170 | } |
| 171 | |
| 172 | // Setzt die aktuelle Route eines Transporters. |
| 173 | // Die Route hier ist allerdings nur die Liste von Haltepunkten - nicht der |
| 174 | // Rest, der in den Routen in den Transporter abgelegt ist. |
| 175 | // Wird von /std/transport gerufen, wenn P_NO_TRAVELING nicht gesetzt ist. |
| 176 | public int AddRoute(string transporter, string* l_stops) |
| 177 | { |
| 178 | if (!stringp(transporter) || !pointerp(l_stops) || !sizeof(l_stops)) |
| 179 | return 0; |
| 180 | |
| 181 | if ((transporter[0..2] == "/p/" || transporter[0..8] == "/players/") |
| 182 | && !IS_ARCH(getuid(previous_object()))) |
| 183 | { |
| 184 | return -1; |
| 185 | } |
| 186 | |
| 187 | // Damit sind alle Abfragen auf find_object(transporter|stop) ueberfluessig, |
| 188 | // im Zweifelsfall knallt es naemlich hier. ;-) |
| 189 | transporter = object_name(load_object(transporter)); |
| 190 | |
| 191 | // Wenn die route bereits existiert, austragen. Dies ist noetig, weil die |
| 192 | // Haltepunkte ja auch bereinigt werden muessen. |
| 193 | if (member(transporters, transporter)) |
| 194 | RemoveTransporter(transporter); |
| 195 | |
| 196 | // Transporter eintragen, die Route wird dabei immer ueberschrieben, wenn |
| 197 | // der Transporter schon bekannt ist. Ziel: hier ist immer die aktuell |
| 198 | // konfigurierte Route drin. |
| 199 | m_add(transporters, transporter, l_stops); |
| 200 | |
| 201 | // Nach obigen Schema, nur diesmal Haltepunkte und zugehoerige Schiffe |
| 202 | // eintragen. |
| 203 | foreach(string stop : l_stops) |
| 204 | { |
| 205 | if (!member(stops,stop)) |
| 206 | { |
| 207 | m_add(stops, stop, ({transporter})); |
| 208 | } |
| 209 | else if (member(stops[stop],transporter) == -1) |
| 210 | { |
| 211 | stops[stop] += ({ transporter }); |
| 212 | } |
| 213 | } |
| 214 | return 1; |
| 215 | |
| 216 | } |
| 217 | |
| 218 | // Abfrage ob ein Schiff einen Hafen anfaehrt. |
| 219 | public varargs int|object* HasTransporter(object stop, |
| 220 | string transporter_id) |
| 221 | { |
| 222 | if (!objectp(stop)) return 0; |
| 223 | |
| 224 | <string|object>* trans=stops[object_name(stop)]; |
| 225 | if (!pointerp(trans)) return 0; |
| 226 | |
| 227 | // Eigentlich sollten sich Transporter ordentlich abmelden... Aber zur |
| 228 | // Sicherheit die nicht gefundenen Objekte ausfiltern. |
| 229 | trans = map(trans, #'find_object) - ({0}); |
| 230 | |
| 231 | // Wenn ne bestimmte ID gesucht wird, nur diese Transporter liefern. |
| 232 | if (stringp(transporter_id)) |
| 233 | trans = filter_objects(trans, "id", transporter_id); |
| 234 | |
| 235 | return sizeof(trans) ? trans : 0; |
| 236 | } |
| 237 | |
| 238 | public mixed RouteExists(object transporter, string dest) |
| 239 | { |
| 240 | if (!objectp(transporter) || !stringp(dest)) |
| 241 | { |
| 242 | return 0; |
| 243 | } |
| 244 | return transporter->HasRoute(dest); |
| 245 | } |
| 246 | |
| 247 | public mapping QueryTransporters() |
| 248 | { |
| 249 | return deep_copy(transporters); |
| 250 | } |
| 251 | |
| 252 | public mapping QueryAllStops() |
| 253 | { |
| 254 | return deep_copy(stops); |
| 255 | } |
| 256 | |
| 257 | // Liefert alle Transporter mit ihren Haltepunkten zurueck, die diesen Halt ansteuern. |
| 258 | public mapping QueryTransportByStop(string stop) |
| 259 | { |
| 260 | mapping res=m_allocate(4); |
| 261 | foreach(string s, string* arr : transporters) |
| 262 | { |
| 263 | if(member(arr,stop)!=-1) |
| 264 | { |
| 265 | m_add(res,s,arr); |
| 266 | } |
| 267 | } |
| 268 | return res; |
| 269 | } |
| 270 | |
| 271 | // Liefert alle Haltepunkte mit ihren Transportern zurueck, die dieser |
| 272 | // transporter ansteuert. |
| 273 | public mapping QueryStopsByTransporter(string transporter) |
| 274 | { |
| 275 | mapping res=m_allocate(4); |
| 276 | foreach(string s, string* arr : stops) |
| 277 | { |
| 278 | if(member(arr,transporter)!=-1) |
| 279 | { |
| 280 | m_add(res,s,arr); |
| 281 | } |
| 282 | } |
| 283 | return res; |
| 284 | } |
| 285 | |