~flosoft/s25rttr/trunk

« back to all changes in this revision

Viewing changes to src/nobBaseWarehouse.h

  • Committer: FloSoft
  • Date: 2014-04-25 15:35:50 UTC
  • Revision ID: flosoft@siedler25.org-20140425153550-9muu4vodhlqu58m0
committing subversion revision 9357 by FloSoft
astyle

modified:
s25client/trunk/
s25client/trunk/contrib/lua/lin32/include/
s25client/trunk/contrib/lua/lin64/include/
s25client/trunk/contrib/lua/mac/include/
s25client/trunk/contrib/lua/win32/include/
s25client/trunk/contrib/lua/win64/include/
s25client/trunk/driver/audio/SDL/src/
s25client/trunk/driver/src/
s25client/trunk/driver/video/GLFW/src/
s25client/trunk/driver/video/SDL/src/
s25client/trunk/driver/video/WinAPI/src/
s25client/trunk/src/
s25client/trunk/win32/
s25client/trunk/win32/prebuild-mutex/src/

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
// $Id: nobBaseWarehouse.h 9094 2014-01-25 10:37:37Z marcus $
 
1
// $Id: nobBaseWarehouse.h 9357 2014-04-25 15:35:25Z FloSoft $
2
2
//
3
3
// Copyright (c) 2005 - 2011 Settlers Freaks (sf-team at siedler25.org)
4
4
//
37
37
/// Ein/Auslagereinstellungsstruktur
38
38
struct InventorySettings
39
39
{
40
 
        unsigned char wares[WARE_TYPES_COUNT];
41
 
        unsigned char figures[JOB_TYPES_COUNT];
 
40
    unsigned char wares[WARE_TYPES_COUNT];
 
41
    unsigned char figures[JOB_TYPES_COUNT];
42
42
 
43
 
        InventorySettings() 
44
 
        { memset(wares,0,sizeof(wares)); memset(figures,0,sizeof(figures)); }
 
43
    InventorySettings()
 
44
    { memset(wares, 0, sizeof(wares)); memset(figures, 0, sizeof(figures)); }
45
45
};
46
46
 
47
47
/// Grundlegende Warenhausklasse, die alle Funktionen vereint, die für Warenhäuser (HQ, Lagerhaus, Häfen)
48
 
/// wichtig sind. 
 
48
/// wichtig sind.
49
49
class nobBaseWarehouse : public nobBaseMilitary
50
50
{
51
 
protected:
52
 
        // Liste von Waren, die noch rausgebracht werden müssen, was im Moment aber nicht möglich ist,
53
 
        // weil die Flagge voll ist vor dem Lagerhaus
54
 
        list<Ware*> waiting_wares;
55
 
        // verhindert doppeltes Holen von Waren
56
 
        bool fetch_double_protection;
57
 
        /// Liste von Figuren, die auf dem Weg zu dem Lagerhaus sind bzw. Soldaten die von ihm kommen
58
 
        std::list<noFigure*> dependent_figures;
59
 
        /// Liste von Waren, die auf dem Weg zum Lagerhaus sind
60
 
        list<Ware*> dependent_wares;
61
 
        /// Produzier-Träger-Event
62
 
        EventManager::EventPointer producinghelpers_event;
63
 
        /// Rekrutierungsevent für Soldaten
64
 
        EventManager::EventPointer recruiting_event;
65
 
        /// Auslagerevent für Waren und Figuren
66
 
        EventManager::EventPointer empty_event;
67
 
        /// Einlagerevent für Waren und Figuren
68
 
        EventManager::EventPointer store_event;
69
 
 
70
 
 
71
 
protected:
72
 
 
73
 
        /// Soldaten-Reserve-Einstellung
74
 
        unsigned reserve_soldiers_available[5]; /// einkassierte Soldaten zur Reserve
75
 
        unsigned reserve_soldiers_claimed_visual[5]; /// geforderte Soldaten zur Reserve - visuell
76
 
        unsigned reserve_soldiers_claimed_real[5]; /// geforderte Soldaten zur Reserve - real
77
 
 
78
 
        /// Waren bzw. Menschenanzahl im Gebäude, real_goods ist die tatsächliche Anzahl und wird zum berechnen verwendet, goods ist nur die, die auch angezeigt wird
79
 
        Goods goods,real_goods;
80
 
        InventorySettings inventory_settings_visual; ///< die Inventar-Einstellungen, visuell
81
 
        InventorySettings inventory_settings_real; ///< die Inventar-Einstellungen, real
82
 
 
83
 
private:
84
 
 
85
 
        /// Prüft, ob alle Bedingungen zum Rekrutieren erfüllt sind
86
 
        bool AreRecruitingConditionsComply();
87
 
        /// Abgeleitete kann eine gerade erzeugte Ware ggf. sofort verwenden 
88
 
        /// (muss in dem Fall true zurückgeben)
89
 
        virtual bool UseWareAtOnce(Ware * ware, noBaseBuilding* const goal);
90
 
        /// Dasselbe für Menschen
91
 
        virtual bool UseFigureAtOnce(noFigure * fig, noRoadNode* const goal); 
92
 
        /// Prüft verschiedene Verwendungszwecke für eine neuangekommende Ware
93
 
        void CheckUsesForNewWare(const GoodType gt);
94
 
        /// Prüft verschiedene Sachen, falls ein neuer Mensch das Haus betreten hat
95
 
        void CheckJobsForNewFigure(const Job job);
96
 
        
97
 
 
98
 
protected:
99
 
 
100
 
        /// Stellt Verteidiger zur Verfügung
101
 
        virtual nofDefender * ProvideDefender(nofAttacker * const attacker);
102
 
 
103
 
        void HandleBaseEvent(const unsigned int id);
104
 
        /// Versucht ein Rekrutierungsevent anzumelden, falls ausreichend Waffen und Bier sowie genügend Gehilfen
105
 
        /// vorhanden sind (je nach Militäreinstellungen)
106
 
        void TryRecruiting();
107
 
        /// Versucht Rekrutierungsevent abzumeldne, falls die Bedingungen nicht mehr erfüllt sind (z.B. wenn Ware
108
 
        /// rausgetragen wurde o.Ä.)
109
 
        void TryStopRecruiting();
110
 
        /// Aktuellen Warenbestand zur aktuellen Inventur dazu addieren
111
 
        void AddToInventory();
112
 
 
113
 
public:
114
 
 
115
 
 
116
 
        nobBaseWarehouse(const BuildingType type,const unsigned short x, const unsigned short y,const unsigned char player,const Nation nation);
117
 
        nobBaseWarehouse(SerializedGameData * sgd, const unsigned obj_id);
118
 
 
119
 
        virtual ~nobBaseWarehouse();
120
 
 
121
 
        /// Aufräummethoden
122
 
protected:      
123
 
        void Destroy_nobBaseWarehouse();
124
 
public:         
125
 
        void Destroy() { Destroy_nobBaseWarehouse(); }
126
 
 
127
 
                /// Serialisierungsfunktionen
128
 
protected: void Serialize_nobBaseWarehouse(SerializedGameData * sgd) const;
129
 
public: void Serialize(SerializedGameData *sgd) const { Serialize_nobBaseWarehouse(sgd); }
130
 
 
131
 
        const Goods *GetInventory() const;
132
 
 
133
 
        /// Fügt einige Güter hinzu
134
 
        void AddGoods(const Goods goods);
135
 
 
136
 
 
137
 
        /// Gibt Anzahl der Waren bzw. Figuren zurück
138
 
        unsigned GetRealWaresCount(GoodType type) const { return real_goods.goods[type]; }
139
 
        unsigned GetRealFiguresCount(Job type) const { return real_goods.people[type]; }
140
 
        unsigned GetVisualWaresCount(GoodType type) const { return goods.goods[type]; }
141
 
        unsigned GetVisualFiguresCount(Job type) const { return goods.people[type]; }
142
 
 
143
 
        /// Verändert Ein/Auslagerungseinstellungen (visuell)
144
 
        void ChangeVisualInventorySettings(unsigned char category,unsigned char state,unsigned char type);
145
 
        /// Gibt Ein/Auslagerungseinstellungen zurück (visuell)
146
 
        bool CheckVisualInventorySettings(unsigned char category,unsigned char state,unsigned char type) const;
147
 
        ///// Generiert einen NC-Befehl für eine Inventory Settings Änderung und führt noch entsprechend eigene Änderungen aus
148
 
        //void SubmitInventorySettings();
149
 
 
150
 
        /// Verändert Ein/Auslagerungseinstellungen (real)
151
 
        void ChangeRealInventorySetting(unsigned char category,unsigned char state,unsigned char type);
152
 
        /// Verändert alle Ein/Auslagerungseinstellungen einer Kategorie (also Waren oder Figuren)(real)
153
 
        void ChangeAllRealInventorySettings(unsigned char category,unsigned char state);
154
 
        /// Gibt Ein/Auslagerungseinstellungen zurück (real), cannot check for state 0
155
 
        bool CheckRealInventorySettings(unsigned char category,unsigned char state,unsigned char type) const 
156
 
        { return ((((category == 0)?inventory_settings_real.wares[type]:inventory_settings_real.figures[type]) & state) == state); }
157
 
 
158
 
        /// Lässt einen bestimmten Waren/Job-Typ ggf auslagern
159
 
        void CheckOuthousing(unsigned char category, unsigned job_ware_id);
160
 
 
161
 
 
162
 
        /// Bestellt einen Träger
163
 
        void OrderCarrier(noRoadNode* const goal, RoadSegment * workplace);
164
 
        /// Bestellt irgendeinen Beruf (ggf. stellt er ihn noch mit einem Werkzeug her)
165
 
        bool OrderJob(const Job job, noRoadNode* const goal, const bool allow_recruiting);
166
 
        /// Bestellt einen Esel
167
 
        nofCarrier * OrderDonkey(RoadSegment * road,noRoadNode * const goal_flag);
168
 
        
169
 
        /// Reiht einen Beruf sofort in die Warteschlange zum Rausgehen rein, wenn er da ist und gibt den Pointer auf
170
 
        /// ihn zurück, wenn keiner da ist, wird 0 zurückgegeben
171
 
        noFigure * OrderDefender();
172
 
        /// "Bestellt" eine Ware --> gibt den Pointer auf die Ware zurück
173
 
        Ware * OrderWare(const GoodType good, noBaseBuilding * const goal);
174
 
        /// Wird von den Lagerhaus-Arbeitern aufgerufen, wenn sie ein Ware wieder zurückbringen, die sie vorne nicht ablegen konnten
175
 
        void AddWaitingWare(Ware * ware);
176
 
        /// Wird aufgerufen, wenn von der Fahne vor dem Gebäude ein Rohstoff aufgenommen wurde
177
 
        bool FreePlaceAtFlag();
178
 
        // Eine Ware liegt vor der Flagge des Warenhauses und will rein --> ein Warenhausmitarbeiter muss kommen und sie holen
179
 
        void FetchWare();
180
 
        // Soll die nächste Ware nicht holen
181
 
        void DontFetchNextWare() {fetch_double_protection = true;}
182
 
 
183
 
        /// Legt eine Ware im Lagerhaus ab
184
 
        virtual void AddWare(Ware * ware);
185
 
        /// Eine Figur geht ins Lagerhaus
186
 
        virtual void AddFigure(noFigure * figure, const bool increase_visual_counts = true);
187
 
 
188
 
        void CarryOutWare();
189
 
        /// Eine bestellte Ware konnte doch nicht kommen
190
 
        virtual void WareLost(Ware * ware);
191
 
        /// Bestellte Ware, die sich noch hier drin befindet, storniert ihre Auslieferung
192
 
        void CancelWare(Ware * ware);
193
 
        /// Bestellte Figur, die sich noch inder Warteschlange befindet, kommt nicht mehr und will rausgehauen werden
194
 
        virtual void CancelFigure(noFigure * figure);
195
 
 
196
 
        /// Sowas ist bei Warenhäusern nicht nötig
197
 
        unsigned CalcDistributionPoints(noRoadNode * start,const GoodType type) { return 0; }
198
 
        /// Wird aufgerufen, wenn eine neue Ware zum dem Gebäude geliefert wird (nicht wenn sie bestellt wurde vom Gebäude!)
199
 
        void TakeWare(Ware * ware);
200
 
 
201
 
        /// Fügt eine Figur hinzu, die auf dem Weg zum Lagerhaus ist
202
 
        void AddDependentFigure(noFigure * figure) { assert(CheckDependentFigure(figure) == false); dependent_figures.push_back(figure); }
203
 
        //// Entfernt eine abhängige Figur wieder aus der Liste
204
 
        virtual void RemoveDependentFigure(noFigure * figure) { dependent_figures.remove(figure); }
205
 
        /// Wird aufgerufen, wenn ein Arbeiter hierher kommt
206
 
        void GotWorker(Job job, noFigure * worker)
207
 
        { assert(CheckDependentFigure(worker) == false); dependent_figures.push_back(worker); }
208
 
 
209
 
        //// Entfernt eine abhängige Ware wieder aus der Liste (wird mit TakeWare hinzugefügt)
210
 
        void RemoveDependentWare(Ware * ware) { dependent_wares.erase(ware); }
211
 
        /// Überprüft, ob Ware abhängig ist
212
 
        bool IsWareDependent(Ware * ware) { return dependent_wares.search(ware).valid(); }
213
 
 
214
 
        /// Prüft, ob es Waren zum Auslagern gibt
215
 
        bool AreWaresToEmpty() const;
216
 
 
217
 
        /// Fügt aktiven Soldaten (der aus von einer Mission) zum Militärgebäude hinzu
218
 
        void AddActiveSoldier(nofActiveSoldier * soldier);
219
 
        /// Gibt Gesamtanzahl aller im Lager befindlichen Soldaten zurück
220
 
        unsigned GetSoldiersCount() const { return real_goods.people[JOB_PRIVATE]+real_goods.people[JOB_PRIVATEFIRSTCLASS]+
221
 
                real_goods.people[JOB_SERGEANT]+real_goods.people[JOB_OFFICER]+real_goods.people[JOB_GENERAL]; }
222
 
        /// Bestellt Soldaten
223
 
        void OrderTroops(nobMilitary * goal, unsigned count);
224
 
 
225
 
        /// Schickt einen Verteidiger raus, der einem Angreifer in den Weg rennt
226
 
        nofAggressiveDefender * SendDefender(nofAttacker * attacker);
227
 
        /// Wird aufgerufen, wenn ein Soldat nicht mehr kommen kann
228
 
        void SoldierLost(nofSoldier * soldier);
229
 
 
230
 
        /// Sind noch Truppen drinne, die dieses Gebäude verteidigen könnten?
231
 
        bool DefendersAvailable() const;
232
 
 
233
 
        /// Verändert Reserveeinstellung - visuell (nur das geforderte natürlich) und gibt neue Anzahl zurück
234
 
        unsigned IncreaseReserveVisual(unsigned rank);
235
 
        unsigned DecreaseReserveVisual(unsigned rank);
236
 
        void SetRealReserve(const unsigned rank, const unsigned count);
237
 
 
238
 
        /// Versucht, die geforderten Reserve-Soldaten bereitzustellen
239
 
        void RefreshReserve(unsigned rank);
240
 
 
241
 
        /// Gibt Zeiger auf dir Reserve zurück für das GUI
242
 
        const unsigned * GetReservePointerAvailable(unsigned rank) const { return &reserve_soldiers_available[rank]; }
243
 
        const unsigned * GetReservePointerClaimed(unsigned rank) const { return &reserve_soldiers_claimed_visual[rank]; }
244
 
 
245
 
        /// Available goods of a speciefic type that can be used for trading
246
 
        unsigned GetAvailableWaresForTrading(const GoodType gt) const;
247
 
        /// Available figures of a speciefic type that can be used for trading 
248
 
        unsigned GetAvailableFiguresForTrading(const Job job) const;
249
 
        /// Starts a trade caravane from this warehouse
250
 
        void StartTradeCaravane(const GoodType gt,  Job job, const unsigned count,const TradeRoute& tr,nobBaseWarehouse * goal);
251
 
        
252
 
        /// For debug only
253
 
        bool CheckDependentFigure(noFigure * fig);
254
 
};      
 
51
    protected:
 
52
        // Liste von Waren, die noch rausgebracht werden müssen, was im Moment aber nicht möglich ist,
 
53
        // weil die Flagge voll ist vor dem Lagerhaus
 
54
        list<Ware*> waiting_wares;
 
55
        // verhindert doppeltes Holen von Waren
 
56
        bool fetch_double_protection;
 
57
        /// Liste von Figuren, die auf dem Weg zu dem Lagerhaus sind bzw. Soldaten die von ihm kommen
 
58
        std::list<noFigure*> dependent_figures;
 
59
        /// Liste von Waren, die auf dem Weg zum Lagerhaus sind
 
60
        list<Ware*> dependent_wares;
 
61
        /// Produzier-Träger-Event
 
62
        EventManager::EventPointer producinghelpers_event;
 
63
        /// Rekrutierungsevent für Soldaten
 
64
        EventManager::EventPointer recruiting_event;
 
65
        /// Auslagerevent für Waren und Figuren
 
66
        EventManager::EventPointer empty_event;
 
67
        /// Einlagerevent für Waren und Figuren
 
68
        EventManager::EventPointer store_event;
 
69
 
 
70
 
 
71
    protected:
 
72
 
 
73
        /// Soldaten-Reserve-Einstellung
 
74
        unsigned reserve_soldiers_available[5]; /// einkassierte Soldaten zur Reserve
 
75
        unsigned reserve_soldiers_claimed_visual[5]; /// geforderte Soldaten zur Reserve - visuell
 
76
        unsigned reserve_soldiers_claimed_real[5]; /// geforderte Soldaten zur Reserve - real
 
77
 
 
78
        /// Waren bzw. Menschenanzahl im Gebäude, real_goods ist die tatsächliche Anzahl und wird zum berechnen verwendet, goods ist nur die, die auch angezeigt wird
 
79
        Goods goods, real_goods;
 
80
        InventorySettings inventory_settings_visual; ///< die Inventar-Einstellungen, visuell
 
81
        InventorySettings inventory_settings_real; ///< die Inventar-Einstellungen, real
 
82
 
 
83
    private:
 
84
 
 
85
        /// Prüft, ob alle Bedingungen zum Rekrutieren erfüllt sind
 
86
        bool AreRecruitingConditionsComply();
 
87
        /// Abgeleitete kann eine gerade erzeugte Ware ggf. sofort verwenden
 
88
        /// (muss in dem Fall true zurückgeben)
 
89
        virtual bool UseWareAtOnce(Ware* ware, noBaseBuilding* const goal);
 
90
        /// Dasselbe für Menschen
 
91
        virtual bool UseFigureAtOnce(noFigure* fig, noRoadNode* const goal);
 
92
        /// Prüft verschiedene Verwendungszwecke für eine neuangekommende Ware
 
93
        void CheckUsesForNewWare(const GoodType gt);
 
94
        /// Prüft verschiedene Sachen, falls ein neuer Mensch das Haus betreten hat
 
95
        void CheckJobsForNewFigure(const Job job);
 
96
 
 
97
 
 
98
    protected:
 
99
 
 
100
        /// Stellt Verteidiger zur Verfügung
 
101
        virtual nofDefender* ProvideDefender(nofAttacker* const attacker);
 
102
 
 
103
        void HandleBaseEvent(const unsigned int id);
 
104
        /// Versucht ein Rekrutierungsevent anzumelden, falls ausreichend Waffen und Bier sowie genügend Gehilfen
 
105
        /// vorhanden sind (je nach Militäreinstellungen)
 
106
        void TryRecruiting();
 
107
        /// Versucht Rekrutierungsevent abzumeldne, falls die Bedingungen nicht mehr erfüllt sind (z.B. wenn Ware
 
108
        /// rausgetragen wurde o.Ä.)
 
109
        void TryStopRecruiting();
 
110
        /// Aktuellen Warenbestand zur aktuellen Inventur dazu addieren
 
111
        void AddToInventory();
 
112
 
 
113
    public:
 
114
 
 
115
 
 
116
        nobBaseWarehouse(const BuildingType type, const unsigned short x, const unsigned short y, const unsigned char player, const Nation nation);
 
117
        nobBaseWarehouse(SerializedGameData* sgd, const unsigned obj_id);
 
118
 
 
119
        virtual ~nobBaseWarehouse();
 
120
 
 
121
        /// Aufräummethoden
 
122
    protected:
 
123
        void Destroy_nobBaseWarehouse();
 
124
    public:
 
125
        void Destroy() { Destroy_nobBaseWarehouse(); }
 
126
 
 
127
        /// Serialisierungsfunktionen
 
128
    protected: void Serialize_nobBaseWarehouse(SerializedGameData* sgd) const;
 
129
    public: void Serialize(SerializedGameData* sgd) const { Serialize_nobBaseWarehouse(sgd); }
 
130
 
 
131
        const Goods* GetInventory() const;
 
132
 
 
133
        /// Fügt einige Güter hinzu
 
134
        void AddGoods(const Goods goods);
 
135
 
 
136
 
 
137
        /// Gibt Anzahl der Waren bzw. Figuren zurück
 
138
        unsigned GetRealWaresCount(GoodType type) const { return real_goods.goods[type]; }
 
139
        unsigned GetRealFiguresCount(Job type) const { return real_goods.people[type]; }
 
140
        unsigned GetVisualWaresCount(GoodType type) const { return goods.goods[type]; }
 
141
        unsigned GetVisualFiguresCount(Job type) const { return goods.people[type]; }
 
142
 
 
143
        /// Verändert Ein/Auslagerungseinstellungen (visuell)
 
144
        void ChangeVisualInventorySettings(unsigned char category, unsigned char state, unsigned char type);
 
145
        /// Gibt Ein/Auslagerungseinstellungen zurück (visuell)
 
146
        bool CheckVisualInventorySettings(unsigned char category, unsigned char state, unsigned char type) const;
 
147
        ///// Generiert einen NC-Befehl für eine Inventory Settings Änderung und führt noch entsprechend eigene Änderungen aus
 
148
        //void SubmitInventorySettings();
 
149
 
 
150
        /// Verändert Ein/Auslagerungseinstellungen (real)
 
151
        void ChangeRealInventorySetting(unsigned char category, unsigned char state, unsigned char type);
 
152
        /// Verändert alle Ein/Auslagerungseinstellungen einer Kategorie (also Waren oder Figuren)(real)
 
153
        void ChangeAllRealInventorySettings(unsigned char category, unsigned char state);
 
154
        /// Gibt Ein/Auslagerungseinstellungen zurück (real), cannot check for state 0
 
155
        bool CheckRealInventorySettings(unsigned char category, unsigned char state, unsigned char type) const
 
156
        { return ((((category == 0) ? inventory_settings_real.wares[type] : inventory_settings_real.figures[type]) & state) == state); }
 
157
 
 
158
        /// Lässt einen bestimmten Waren/Job-Typ ggf auslagern
 
159
        void CheckOuthousing(unsigned char category, unsigned job_ware_id);
 
160
 
 
161
 
 
162
        /// Bestellt einen Träger
 
163
        void OrderCarrier(noRoadNode* const goal, RoadSegment* workplace);
 
164
        /// Bestellt irgendeinen Beruf (ggf. stellt er ihn noch mit einem Werkzeug her)
 
165
        bool OrderJob(const Job job, noRoadNode* const goal, const bool allow_recruiting);
 
166
        /// Bestellt einen Esel
 
167
        nofCarrier* OrderDonkey(RoadSegment* road, noRoadNode* const goal_flag);
 
168
 
 
169
        /// Reiht einen Beruf sofort in die Warteschlange zum Rausgehen rein, wenn er da ist und gibt den Pointer auf
 
170
        /// ihn zurück, wenn keiner da ist, wird 0 zurückgegeben
 
171
        noFigure* OrderDefender();
 
172
        /// "Bestellt" eine Ware --> gibt den Pointer auf die Ware zurück
 
173
        Ware* OrderWare(const GoodType good, noBaseBuilding* const goal);
 
174
        /// Wird von den Lagerhaus-Arbeitern aufgerufen, wenn sie ein Ware wieder zurückbringen, die sie vorne nicht ablegen konnten
 
175
        void AddWaitingWare(Ware* ware);
 
176
        /// Wird aufgerufen, wenn von der Fahne vor dem Gebäude ein Rohstoff aufgenommen wurde
 
177
        bool FreePlaceAtFlag();
 
178
        // Eine Ware liegt vor der Flagge des Warenhauses und will rein --> ein Warenhausmitarbeiter muss kommen und sie holen
 
179
        void FetchWare();
 
180
        // Soll die nächste Ware nicht holen
 
181
        void DontFetchNextWare() {fetch_double_protection = true;}
 
182
 
 
183
        /// Legt eine Ware im Lagerhaus ab
 
184
        virtual void AddWare(Ware* ware);
 
185
        /// Eine Figur geht ins Lagerhaus
 
186
        virtual void AddFigure(noFigure* figure, const bool increase_visual_counts = true);
 
187
 
 
188
        void CarryOutWare();
 
189
        /// Eine bestellte Ware konnte doch nicht kommen
 
190
        virtual void WareLost(Ware* ware);
 
191
        /// Bestellte Ware, die sich noch hier drin befindet, storniert ihre Auslieferung
 
192
        void CancelWare(Ware* ware);
 
193
        /// Bestellte Figur, die sich noch inder Warteschlange befindet, kommt nicht mehr und will rausgehauen werden
 
194
        virtual void CancelFigure(noFigure* figure);
 
195
 
 
196
        /// Sowas ist bei Warenhäusern nicht nötig
 
197
        unsigned CalcDistributionPoints(noRoadNode* start, const GoodType type) { return 0; }
 
198
        /// Wird aufgerufen, wenn eine neue Ware zum dem Gebäude geliefert wird (nicht wenn sie bestellt wurde vom Gebäude!)
 
199
        void TakeWare(Ware* ware);
 
200
 
 
201
        /// Fügt eine Figur hinzu, die auf dem Weg zum Lagerhaus ist
 
202
        void AddDependentFigure(noFigure* figure) { assert(CheckDependentFigure(figure) == false); dependent_figures.push_back(figure); }
 
203
        //// Entfernt eine abhängige Figur wieder aus der Liste
 
204
        virtual void RemoveDependentFigure(noFigure* figure) { dependent_figures.remove(figure); }
 
205
        /// Wird aufgerufen, wenn ein Arbeiter hierher kommt
 
206
        void GotWorker(Job job, noFigure* worker)
 
207
        { assert(CheckDependentFigure(worker) == false); dependent_figures.push_back(worker); }
 
208
 
 
209
        //// Entfernt eine abhängige Ware wieder aus der Liste (wird mit TakeWare hinzugefügt)
 
210
        void RemoveDependentWare(Ware* ware) { dependent_wares.erase(ware); }
 
211
        /// Überprüft, ob Ware abhängig ist
 
212
        bool IsWareDependent(Ware* ware) { return dependent_wares.search(ware).valid(); }
 
213
 
 
214
        /// Prüft, ob es Waren zum Auslagern gibt
 
215
        bool AreWaresToEmpty() const;
 
216
 
 
217
        /// Fügt aktiven Soldaten (der aus von einer Mission) zum Militärgebäude hinzu
 
218
        void AddActiveSoldier(nofActiveSoldier* soldier);
 
219
        /// Gibt Gesamtanzahl aller im Lager befindlichen Soldaten zurück
 
220
        unsigned GetSoldiersCount() const
 
221
        {
 
222
            return real_goods.people[JOB_PRIVATE] + real_goods.people[JOB_PRIVATEFIRSTCLASS] +
 
223
                   real_goods.people[JOB_SERGEANT] + real_goods.people[JOB_OFFICER] + real_goods.people[JOB_GENERAL];
 
224
        }
 
225
        /// Bestellt Soldaten
 
226
        void OrderTroops(nobMilitary* goal, unsigned count);
 
227
 
 
228
        /// Schickt einen Verteidiger raus, der einem Angreifer in den Weg rennt
 
229
        nofAggressiveDefender* SendDefender(nofAttacker* attacker);
 
230
        /// Wird aufgerufen, wenn ein Soldat nicht mehr kommen kann
 
231
        void SoldierLost(nofSoldier* soldier);
 
232
 
 
233
        /// Sind noch Truppen drinne, die dieses Gebäude verteidigen könnten?
 
234
        bool DefendersAvailable() const;
 
235
 
 
236
        /// Verändert Reserveeinstellung - visuell (nur das geforderte natürlich) und gibt neue Anzahl zurück
 
237
        unsigned IncreaseReserveVisual(unsigned rank);
 
238
        unsigned DecreaseReserveVisual(unsigned rank);
 
239
        void SetRealReserve(const unsigned rank, const unsigned count);
 
240
 
 
241
        /// Versucht, die geforderten Reserve-Soldaten bereitzustellen
 
242
        void RefreshReserve(unsigned rank);
 
243
 
 
244
        /// Gibt Zeiger auf dir Reserve zurück für das GUI
 
245
        const unsigned* GetReservePointerAvailable(unsigned rank) const { return &reserve_soldiers_available[rank]; }
 
246
        const unsigned* GetReservePointerClaimed(unsigned rank) const { return &reserve_soldiers_claimed_visual[rank]; }
 
247
 
 
248
        /// Available goods of a speciefic type that can be used for trading
 
249
        unsigned GetAvailableWaresForTrading(const GoodType gt) const;
 
250
        /// Available figures of a speciefic type that can be used for trading
 
251
        unsigned GetAvailableFiguresForTrading(const Job job) const;
 
252
        /// Starts a trade caravane from this warehouse
 
253
        void StartTradeCaravane(const GoodType gt,  Job job, const unsigned count, const TradeRoute& tr, nobBaseWarehouse* goal);
 
254
 
 
255
        /// For debug only
 
256
        bool CheckDependentFigure(noFigure* fig);
 
257
};
255
258
 
256
259
 
257
260
 
258
261
/// Vorgefertigte Bedingungsfunktionen für FindWarehouse, param jeweils Pointer auf die einzelnen Strukturen
259
262
namespace FW
260
263
{
261
 
        struct Param_Ware { GoodType type; unsigned count; };
262
 
        bool Condition_Ware(nobBaseWarehouse * wh, const void * param);
263
 
        struct Param_Job { Job type; unsigned count; };
264
 
        bool Condition_Job(nobBaseWarehouse * wh, const void * param);
265
 
        struct Param_WareAndJob { Param_Ware ware; Param_Job job; };
266
 
        bool Condition_WareAndJob(nobBaseWarehouse * wh, const void * param);
267
 
 
268
 
        bool Condition_Troops(nobBaseWarehouse * wh, const void * param); // param = &unsigned --> count
269
 
        bool Condition_StoreWare(nobBaseWarehouse * wh, const void * param); // param = &GoodType -> Warentyp
270
 
        bool Condition_StoreFigure(nobBaseWarehouse * wh, const void * param); // param = &Job -> Jobtyp
271
 
 
272
 
        // Die Lagerhäuser lagern die jeweiligen Waren ein
273
 
        bool Condition_WantStoreWare(nobBaseWarehouse * wh, const void * param); // param = &GoodType -> Warentyp
274
 
        bool Condition_WantStoreFigure(nobBaseWarehouse * wh, const void * param); // param = &Job -> Jobtyp
275
 
 
276
 
        // Lagerhäuser enthalten die jeweilien Waren, liefern sie aber NICHT gleichzeitig ein
277
 
        bool Condition_StoreAndDontWantWare(nobBaseWarehouse * wh, const void * param); // param = &GoodType -> Warentyp
278
 
        bool Condition_StoreAndDontWantFigure(nobBaseWarehouse * wh, const void * param); // param = &Job -> Jobtyp
279
 
 
280
 
 
281
 
        bool NoCondition(nobBaseWarehouse * wh, const void * param);
 
264
    struct Param_Ware { GoodType type; unsigned count; };
 
265
    bool Condition_Ware(nobBaseWarehouse* wh, const void* param);
 
266
    struct Param_Job { Job type; unsigned count; };
 
267
    bool Condition_Job(nobBaseWarehouse* wh, const void* param);
 
268
    struct Param_WareAndJob { Param_Ware ware; Param_Job job; };
 
269
    bool Condition_WareAndJob(nobBaseWarehouse* wh, const void* param);
 
270
 
 
271
    bool Condition_Troops(nobBaseWarehouse* wh, const void* param);   // param = &unsigned --> count
 
272
    bool Condition_StoreWare(nobBaseWarehouse* wh, const void* param);   // param = &GoodType -> Warentyp
 
273
    bool Condition_StoreFigure(nobBaseWarehouse* wh, const void* param);   // param = &Job -> Jobtyp
 
274
 
 
275
    // Die Lagerhäuser lagern die jeweiligen Waren ein
 
276
    bool Condition_WantStoreWare(nobBaseWarehouse* wh, const void* param);   // param = &GoodType -> Warentyp
 
277
    bool Condition_WantStoreFigure(nobBaseWarehouse* wh, const void* param);   // param = &Job -> Jobtyp
 
278
 
 
279
    // Lagerhäuser enthalten die jeweilien Waren, liefern sie aber NICHT gleichzeitig ein
 
280
    bool Condition_StoreAndDontWantWare(nobBaseWarehouse* wh, const void* param);   // param = &GoodType -> Warentyp
 
281
    bool Condition_StoreAndDontWantFigure(nobBaseWarehouse* wh, const void* param);   // param = &Job -> Jobtyp
 
282
 
 
283
 
 
284
    bool NoCondition(nobBaseWarehouse* wh, const void* param);
282
285
}
283
286
 
284
287
#endif