~flosoft/s25rttr/trunk

« back to all changes in this revision

Viewing changes to src/nobBaseWarehouse.cpp

  • 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.cpp 9123 2014-01-30 11:36:17Z marcus $
 
1
// $Id: nobBaseWarehouse.cpp 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
//
48
48
///////////////////////////////////////////////////////////////////////////////
49
49
// Makros / Defines
50
50
#if defined _WIN32 && defined _DEBUG && defined _MSC_VER
51
 
        #define new new(_NORMAL_BLOCK, THIS_FILE, __LINE__)
52
 
        #undef THIS_FILE
53
 
        static char THIS_FILE[] = __FILE__;
 
51
#define new new(_NORMAL_BLOCK, THIS_FILE, __LINE__)
 
52
#undef THIS_FILE
 
53
static char THIS_FILE[] = __FILE__;
54
54
#endif
55
55
 
56
56
/// Intervall für Ausleerung (in gf)
64
64
const unsigned short RECRUITE_GF = 200;
65
65
const unsigned short RECRUITE_RANDOM_GF = 200;
66
66
 
67
 
nobBaseWarehouse::nobBaseWarehouse(const BuildingType type,const unsigned short x, const unsigned short y,const unsigned char player,const Nation nation)
68
 
: nobBaseMilitary(type,x,y,player,nation), fetch_double_protection(false), producinghelpers_event(em->AddEvent(this,PRODUCE_HELPERS_GF+RANDOM.Rand(__FILE__,__LINE__,obj_id,PRODUCE_HELPERS_RANDOM_GF),1)), recruiting_event(0),
69
 
empty_event(0), store_event(0)
 
67
nobBaseWarehouse::nobBaseWarehouse(const BuildingType type, const unsigned short x, const unsigned short y, const unsigned char player, const Nation nation)
 
68
    : nobBaseMilitary(type, x, y, player, nation), fetch_double_protection(false), producinghelpers_event(em->AddEvent(this, PRODUCE_HELPERS_GF + RANDOM.Rand(__FILE__, __LINE__, obj_id, PRODUCE_HELPERS_RANDOM_GF), 1)), recruiting_event(0),
 
69
      empty_event(0), store_event(0)
70
70
{
71
 
        // Reserve nullen
72
 
        for(unsigned i = 0;i<5;++i)
73
 
                reserve_soldiers_available[i] = 
74
 
                reserve_soldiers_claimed_visual[i] = 
75
 
                reserve_soldiers_claimed_real[i] = 0;
 
71
    // Reserve nullen
 
72
    for(unsigned i = 0; i < 5; ++i)
 
73
        reserve_soldiers_available[i] =
 
74
            reserve_soldiers_claimed_visual[i] =
 
75
                reserve_soldiers_claimed_real[i] = 0;
76
76
}
77
77
 
78
78
nobBaseWarehouse::~nobBaseWarehouse()
79
79
{
80
 
        // Waiting Wares löschen
81
 
        for(list<Ware*>::iterator it = waiting_wares.begin();it.valid();++it)
82
 
                delete (*it);
 
80
    // Waiting Wares löschen
 
81
    for(list<Ware*>::iterator it = waiting_wares.begin(); it.valid(); ++it)
 
82
        delete (*it);
83
83
}
84
84
 
85
85
void nobBaseWarehouse::Destroy_nobBaseWarehouse()
86
86
{
87
 
        // Aus der Warenhausliste entfernen
88
 
        gwg->GetPlayer(player)->RemoveWarehouse(this);
89
 
        // Den Waren und Figuren Bescheid sagen, die zu uns auf den Weg sind, dass wir nun nicht mehr existieren
90
 
        for(std::list<noFigure*>::iterator it = dependent_figures.begin();it != dependent_figures.end();++it)
91
 
                (*it)->GoHome();
92
 
        for(list<Ware*>::iterator it = dependent_wares.begin();it.valid();++it)
93
 
                (*it)->GoalDestroyed();
94
 
 
95
 
        // ggf. Events abmelden
96
 
        em->RemoveEvent(recruiting_event);
97
 
        em->RemoveEvent(producinghelpers_event);
98
 
        em->RemoveEvent(empty_event);
99
 
        em->RemoveEvent(store_event);
100
 
 
101
 
        // Waiting Wares löschen
102
 
        for(list<Ware*>::iterator it = waiting_wares.begin();it.valid();++it)
103
 
        {
104
 
                (*it)->WareLost(player);
105
 
                delete (*it);
106
 
        }
107
 
 
108
 
        waiting_wares.clear();
109
 
 
110
 
        // restliche Warenbestände von der Inventur wieder abziehen
111
 
        for(unsigned int i = 0; i < WARE_TYPES_COUNT; ++i)
112
 
                gwg->GetPlayer(player)->DecreaseInventoryWare(GoodType(i),real_goods.goods[i]);
113
 
 
114
 
        //for(unsigned int i = 0; i < 30; ++i)
115
 
        //      gwg->GetPlayer(player)->DecreaseInventoryJob(Job(i),real_goods.people[i]);
116
 
 
117
 
        // Objekt, das die flüchtenden Leute nach und nach ausspuckt, erzeugen
118
 
        new BurnedWarehouse(x,y,player,real_goods.people);
119
 
 
120
 
        Destroy_nobBaseMilitary();
121
 
}
122
 
 
123
 
 
124
 
void nobBaseWarehouse::Serialize_nobBaseWarehouse(SerializedGameData * sgd) const
125
 
{
126
 
        Serialize_nobBaseMilitary(sgd);
127
 
 
128
 
        sgd->PushObjectList(waiting_wares,true);
129
 
        sgd->PushBool(fetch_double_protection);
130
 
        sgd->PushObjectList(dependent_figures,false);
131
 
        sgd->PushObjectList(dependent_wares,true);
132
 
        sgd->PushObject(producinghelpers_event,true);
133
 
        sgd->PushObject(recruiting_event,true);
134
 
        sgd->PushObject(empty_event,true);
135
 
        sgd->PushObject(store_event,true);
136
 
 
137
 
        for(unsigned i = 0;i<5;++i)
138
 
        {
139
 
                // Nur das Reale, nicht das visuelle speichern, das wäre sinnlos!, beim Laden ist das visuelle = realem
140
 
                sgd->PushUnsignedInt(reserve_soldiers_available[i]);
141
 
                sgd->PushUnsignedInt(reserve_soldiers_claimed_real[i]);
142
 
        }
143
 
 
144
 
        for(unsigned i = 0;i<WARE_TYPES_COUNT;++i)
145
 
        {
146
 
                sgd->PushUnsignedInt(goods.goods[i]);
147
 
                sgd->PushUnsignedInt(real_goods.goods[i]);
148
 
                sgd->PushUnsignedChar(inventory_settings_real.wares[i]);
149
 
        }
150
 
        for(unsigned i = 0;i<JOB_TYPES_COUNT;++i)
151
 
        {
152
 
                sgd->PushUnsignedInt(goods.people[i]);
153
 
                sgd->PushUnsignedInt(real_goods.people[i]);
154
 
                sgd->PushUnsignedChar(inventory_settings_real.figures[i]);
155
 
        }
156
 
}
157
 
 
158
 
nobBaseWarehouse::nobBaseWarehouse(SerializedGameData * sgd, const unsigned obj_id) : nobBaseMilitary(sgd,obj_id)
159
 
{
160
 
        sgd->PopObjectList(waiting_wares,GOT_WARE);
161
 
        fetch_double_protection = sgd->PopBool();
162
 
        sgd->PopObjectList(dependent_figures,GOT_UNKNOWN);
163
 
        sgd->PopObjectList(dependent_wares,GOT_WARE);
164
 
        
165
 
        producinghelpers_event = sgd->PopObject<EventManager::Event>(GOT_EVENT);
166
 
        recruiting_event = sgd->PopObject<EventManager::Event>(GOT_EVENT);
167
 
        empty_event = sgd->PopObject<EventManager::Event>(GOT_EVENT);
168
 
        store_event = sgd->PopObject<EventManager::Event>(GOT_EVENT);
169
 
 
170
 
        for(unsigned i = 0;i<5;++i)
171
 
        {
172
 
                reserve_soldiers_available[i] = sgd->PopUnsignedInt();
173
 
                reserve_soldiers_claimed_visual[i] = reserve_soldiers_claimed_real[i] = sgd->PopUnsignedInt();
174
 
        }
175
 
 
176
 
        for(unsigned i = 0;i<WARE_TYPES_COUNT;++i)
177
 
        {
178
 
                goods.goods[i] = sgd->PopUnsignedInt();
179
 
                real_goods.goods[i] = sgd->PopUnsignedInt();
180
 
                inventory_settings_real.wares[i] = inventory_settings_visual.wares[i] = sgd->PopUnsignedChar();
181
 
        }
182
 
        for(unsigned i = 0;i<JOB_TYPES_COUNT;++i)
183
 
        {
184
 
                goods.people[i] = sgd->PopUnsignedInt();
185
 
                real_goods.people[i] = sgd->PopUnsignedInt();
186
 
                inventory_settings_real.figures[i] = inventory_settings_visual.figures[i] = sgd->PopUnsignedChar();
187
 
        }
188
 
}
189
 
 
190
 
 
191
 
void nobBaseWarehouse::OrderCarrier(noRoadNode* const goal, RoadSegment * workplace)
192
 
{
193
 
        workplace->setCarrier(0, new nofCarrier((workplace->GetRoadType() == RoadSegment::RT_BOAT) ? nofCarrier::CT_BOAT : nofCarrier::CT_NORMAL, x, y, player, workplace, goal));
194
 
 
195
 
        if(!UseFigureAtOnce(workplace->getCarrier(0), goal))
196
 
                AddLeavingFigure(workplace->getCarrier(0));
197
 
 
198
 
        --real_goods.people[JOB_HELPER];
199
 
        if((workplace->GetRoadType() == RoadSegment::RT_BOAT))
200
 
                --real_goods.goods[GD_BOAT];
201
 
 
202
 
        // Evtl. kein Gehilfe mehr, sodass das Rekrutieren gestoppt werden muss
203
 
        TryStopRecruiting();
 
87
    // Aus der Warenhausliste entfernen
 
88
    gwg->GetPlayer(player)->RemoveWarehouse(this);
 
89
    // Den Waren und Figuren Bescheid sagen, die zu uns auf den Weg sind, dass wir nun nicht mehr existieren
 
90
    for(std::list<noFigure*>::iterator it = dependent_figures.begin(); it != dependent_figures.end(); ++it)
 
91
        (*it)->GoHome();
 
92
    for(list<Ware*>::iterator it = dependent_wares.begin(); it.valid(); ++it)
 
93
        (*it)->GoalDestroyed();
 
94
 
 
95
    // ggf. Events abmelden
 
96
    em->RemoveEvent(recruiting_event);
 
97
    em->RemoveEvent(producinghelpers_event);
 
98
    em->RemoveEvent(empty_event);
 
99
    em->RemoveEvent(store_event);
 
100
 
 
101
    // Waiting Wares löschen
 
102
    for(list<Ware*>::iterator it = waiting_wares.begin(); it.valid(); ++it)
 
103
    {
 
104
        (*it)->WareLost(player);
 
105
        delete (*it);
 
106
    }
 
107
 
 
108
    waiting_wares.clear();
 
109
 
 
110
    // restliche Warenbestände von der Inventur wieder abziehen
 
111
    for(unsigned int i = 0; i < WARE_TYPES_COUNT; ++i)
 
112
        gwg->GetPlayer(player)->DecreaseInventoryWare(GoodType(i), real_goods.goods[i]);
 
113
 
 
114
    //for(unsigned int i = 0; i < 30; ++i)
 
115
    //  gwg->GetPlayer(player)->DecreaseInventoryJob(Job(i),real_goods.people[i]);
 
116
 
 
117
    // Objekt, das die flüchtenden Leute nach und nach ausspuckt, erzeugen
 
118
    new BurnedWarehouse(x, y, player, real_goods.people);
 
119
 
 
120
    Destroy_nobBaseMilitary();
 
121
}
 
122
 
 
123
 
 
124
void nobBaseWarehouse::Serialize_nobBaseWarehouse(SerializedGameData* sgd) const
 
125
{
 
126
    Serialize_nobBaseMilitary(sgd);
 
127
 
 
128
    sgd->PushObjectList(waiting_wares, true);
 
129
    sgd->PushBool(fetch_double_protection);
 
130
    sgd->PushObjectList(dependent_figures, false);
 
131
    sgd->PushObjectList(dependent_wares, true);
 
132
    sgd->PushObject(producinghelpers_event, true);
 
133
    sgd->PushObject(recruiting_event, true);
 
134
    sgd->PushObject(empty_event, true);
 
135
    sgd->PushObject(store_event, true);
 
136
 
 
137
    for(unsigned i = 0; i < 5; ++i)
 
138
    {
 
139
        // Nur das Reale, nicht das visuelle speichern, das wäre sinnlos!, beim Laden ist das visuelle = realem
 
140
        sgd->PushUnsignedInt(reserve_soldiers_available[i]);
 
141
        sgd->PushUnsignedInt(reserve_soldiers_claimed_real[i]);
 
142
    }
 
143
 
 
144
    for(unsigned i = 0; i < WARE_TYPES_COUNT; ++i)
 
145
    {
 
146
        sgd->PushUnsignedInt(goods.goods[i]);
 
147
        sgd->PushUnsignedInt(real_goods.goods[i]);
 
148
        sgd->PushUnsignedChar(inventory_settings_real.wares[i]);
 
149
    }
 
150
    for(unsigned i = 0; i < JOB_TYPES_COUNT; ++i)
 
151
    {
 
152
        sgd->PushUnsignedInt(goods.people[i]);
 
153
        sgd->PushUnsignedInt(real_goods.people[i]);
 
154
        sgd->PushUnsignedChar(inventory_settings_real.figures[i]);
 
155
    }
 
156
}
 
157
 
 
158
nobBaseWarehouse::nobBaseWarehouse(SerializedGameData* sgd, const unsigned obj_id) : nobBaseMilitary(sgd, obj_id)
 
159
{
 
160
    sgd->PopObjectList(waiting_wares, GOT_WARE);
 
161
    fetch_double_protection = sgd->PopBool();
 
162
    sgd->PopObjectList(dependent_figures, GOT_UNKNOWN);
 
163
    sgd->PopObjectList(dependent_wares, GOT_WARE);
 
164
 
 
165
    producinghelpers_event = sgd->PopObject<EventManager::Event>(GOT_EVENT);
 
166
    recruiting_event = sgd->PopObject<EventManager::Event>(GOT_EVENT);
 
167
    empty_event = sgd->PopObject<EventManager::Event>(GOT_EVENT);
 
168
    store_event = sgd->PopObject<EventManager::Event>(GOT_EVENT);
 
169
 
 
170
    for(unsigned i = 0; i < 5; ++i)
 
171
    {
 
172
        reserve_soldiers_available[i] = sgd->PopUnsignedInt();
 
173
        reserve_soldiers_claimed_visual[i] = reserve_soldiers_claimed_real[i] = sgd->PopUnsignedInt();
 
174
    }
 
175
 
 
176
    for(unsigned i = 0; i < WARE_TYPES_COUNT; ++i)
 
177
    {
 
178
        goods.goods[i] = sgd->PopUnsignedInt();
 
179
        real_goods.goods[i] = sgd->PopUnsignedInt();
 
180
        inventory_settings_real.wares[i] = inventory_settings_visual.wares[i] = sgd->PopUnsignedChar();
 
181
    }
 
182
    for(unsigned i = 0; i < JOB_TYPES_COUNT; ++i)
 
183
    {
 
184
        goods.people[i] = sgd->PopUnsignedInt();
 
185
        real_goods.people[i] = sgd->PopUnsignedInt();
 
186
        inventory_settings_real.figures[i] = inventory_settings_visual.figures[i] = sgd->PopUnsignedChar();
 
187
    }
 
188
}
 
189
 
 
190
 
 
191
void nobBaseWarehouse::OrderCarrier(noRoadNode* const goal, RoadSegment* workplace)
 
192
{
 
193
    workplace->setCarrier(0, new nofCarrier((workplace->GetRoadType() == RoadSegment::RT_BOAT) ? nofCarrier::CT_BOAT : nofCarrier::CT_NORMAL, x, y, player, workplace, goal));
 
194
 
 
195
    if(!UseFigureAtOnce(workplace->getCarrier(0), goal))
 
196
        AddLeavingFigure(workplace->getCarrier(0));
 
197
 
 
198
    --real_goods.people[JOB_HELPER];
 
199
    if((workplace->GetRoadType() == RoadSegment::RT_BOAT))
 
200
        --real_goods.goods[GD_BOAT];
 
201
 
 
202
    // Evtl. kein Gehilfe mehr, sodass das Rekrutieren gestoppt werden muss
 
203
    TryStopRecruiting();
204
204
}
205
205
 
206
206
bool nobBaseWarehouse::OrderJob(const Job job, noRoadNode* const goal, const bool allow_recruiting)
207
207
{
208
 
        // Job überhaupt hier vorhanden
209
 
        if(!real_goods.people[job])
210
 
        {
211
 
                // Evtl das Werkzeug der Person vorhanden sowie ein Träger?
212
 
                bool tool_available = (JOB_CONSTS[job].tool == GD_NOTHING) ? true : (real_goods.goods[JOB_CONSTS[job].tool]!=0);
213
 
                if(!(real_goods.people[JOB_HELPER] && tool_available) || !allow_recruiting)
214
 
                {
215
 
                        // nein --> dann tschüss
216
 
                        return false;
217
 
                }
218
 
        }
219
 
 
220
 
        noFigure * fig = CreateJob(job,x,y,player,goal);
221
 
        // Wenn Figur nicht sofort von abgeleiteter Klasse verwenet wird, fügen wir die zur Leave-Liste hinzu
222
 
        if(!UseFigureAtOnce(fig,goal))
223
 
                AddLeavingFigure(fig);
224
 
 
225
 
                
226
 
        // Ziel Bescheid sagen, dass dortin ein neuer Arbeiter kommt (bei Flaggen als das anders machen)
227
 
        if(goal->GetType() == NOP_FLAG)
228
 
        {
229
 
        }
230
 
        else
231
 
        {
232
 
                static_cast<noBaseBuilding*>(goal)->GotWorker(job,fig);
233
 
        }
234
 
 
235
 
        if(real_goods.people[job])
236
 
                --real_goods.people[job];
237
 
        else
238
 
        {
239
 
                // ansonsten muss er erst noch "rekrutiert" werden
240
 
                if(JOB_CONSTS[job].tool != GD_NOTHING)
241
 
                {
242
 
                        --real_goods.goods[JOB_CONSTS[job].tool];
243
 
                        --goods.goods[JOB_CONSTS[job].tool];
244
 
                        gwg->GetPlayer(player)->DecreaseInventoryWare(JOB_CONSTS[job].tool,1);
245
 
                }
246
 
 
247
 
                --real_goods.people[JOB_HELPER];
248
 
                --goods.people[JOB_HELPER];
249
 
                gwg->GetPlayer(player)->DecreaseInventoryJob(JOB_HELPER,1);
250
 
 
251
 
                // erhöhen, da er ja dann rauskommt und es bei den visuellen wieder abgezogen wird!
252
 
                ++goods.people[job];
253
 
                gwg->GetPlayer(player)->IncreaseInventoryJob(job,1);
254
 
        }
255
 
 
256
 
 
257
 
        // Evtl. kein Gehilfe mehr da, sodass das Rekrutieren gestoppt werden muss
258
 
        TryStopRecruiting();
259
 
        
260
 
        return true;
 
208
    // Job überhaupt hier vorhanden
 
209
    if(!real_goods.people[job])
 
210
    {
 
211
        // Evtl das Werkzeug der Person vorhanden sowie ein Träger?
 
212
        bool tool_available = (JOB_CONSTS[job].tool == GD_NOTHING) ? true : (real_goods.goods[JOB_CONSTS[job].tool] != 0);
 
213
        if(!(real_goods.people[JOB_HELPER] && tool_available) || !allow_recruiting)
 
214
        {
 
215
            // nein --> dann tschüss
 
216
            return false;
 
217
        }
 
218
    }
 
219
 
 
220
    noFigure* fig = CreateJob(job, x, y, player, goal);
 
221
    // Wenn Figur nicht sofort von abgeleiteter Klasse verwenet wird, fügen wir die zur Leave-Liste hinzu
 
222
    if(!UseFigureAtOnce(fig, goal))
 
223
        AddLeavingFigure(fig);
 
224
 
 
225
 
 
226
    // Ziel Bescheid sagen, dass dortin ein neuer Arbeiter kommt (bei Flaggen als das anders machen)
 
227
    if(goal->GetType() == NOP_FLAG)
 
228
    {
 
229
    }
 
230
    else
 
231
    {
 
232
        static_cast<noBaseBuilding*>(goal)->GotWorker(job, fig);
 
233
    }
 
234
 
 
235
    if(real_goods.people[job])
 
236
        --real_goods.people[job];
 
237
    else
 
238
    {
 
239
        // ansonsten muss er erst noch "rekrutiert" werden
 
240
        if(JOB_CONSTS[job].tool != GD_NOTHING)
 
241
        {
 
242
            --real_goods.goods[JOB_CONSTS[job].tool];
 
243
            --goods.goods[JOB_CONSTS[job].tool];
 
244
            gwg->GetPlayer(player)->DecreaseInventoryWare(JOB_CONSTS[job].tool, 1);
 
245
        }
 
246
 
 
247
        --real_goods.people[JOB_HELPER];
 
248
        --goods.people[JOB_HELPER];
 
249
        gwg->GetPlayer(player)->DecreaseInventoryJob(JOB_HELPER, 1);
 
250
 
 
251
        // erhöhen, da er ja dann rauskommt und es bei den visuellen wieder abgezogen wird!
 
252
        ++goods.people[job];
 
253
        gwg->GetPlayer(player)->IncreaseInventoryJob(job, 1);
 
254
    }
 
255
 
 
256
 
 
257
    // Evtl. kein Gehilfe mehr da, sodass das Rekrutieren gestoppt werden muss
 
258
    TryStopRecruiting();
 
259
 
 
260
    return true;
261
261
}
262
262
 
263
 
nofCarrier * nobBaseWarehouse::OrderDonkey(RoadSegment * road,noRoadNode * const goal_flag)
 
263
nofCarrier* nobBaseWarehouse::OrderDonkey(RoadSegment* road, noRoadNode* const goal_flag)
264
264
{
265
 
        // Ãœberhaupt ein Esel vorhanden?
266
 
        if(!real_goods.people[JOB_PACKDONKEY])
267
 
                return 0;
268
 
 
269
 
        nofCarrier * donkey;
270
 
        AddLeavingFigure(donkey = new nofCarrier(nofCarrier::CT_DONKEY,x,y,player,road,goal_flag));
271
 
        --real_goods.people[JOB_PACKDONKEY];
272
 
 
273
 
        return donkey;
 
265
    // Ãœberhaupt ein Esel vorhanden?
 
266
    if(!real_goods.people[JOB_PACKDONKEY])
 
267
        return 0;
 
268
 
 
269
    nofCarrier* donkey;
 
270
    AddLeavingFigure(donkey = new nofCarrier(nofCarrier::CT_DONKEY, x, y, player, road, goal_flag));
 
271
    --real_goods.people[JOB_PACKDONKEY];
 
272
 
 
273
    return donkey;
274
274
}
275
275
 
276
276
 
277
277
void nobBaseWarehouse::HandleBaseEvent(const unsigned int id)
278
278
{
279
 
        switch(id)
280
 
        {
281
 
        // Rausgeh-Event
282
 
        case 0:
283
 
                {
284
 
                        leaving_event = 0;
285
 
 
286
 
                        // Falls eine Bestellung storniert wurde
287
 
                        if(!leave_house.size() && !waiting_wares.size())
288
 
                        {
289
 
                                go_out = false;
290
 
                                return;
291
 
                        }
292
 
 
293
 
                        // Fight or something in front of the house and we are not defending?
294
 
                        if (!gwg->IsRoadNodeForFigures(gwg->GetXA(x,y,4), gwg->GetYA(x,y,4), 4))
295
 
                        {
296
 
                                // there's a fight
297
 
                                bool found = false;
298
 
 
299
 
                                // try to find a defender and make him leave the house first
300
 
                                for(std::list<noFigure*>::iterator it = leave_house.begin();it!=leave_house.end();++it)
301
 
                                {
302
 
                                        if (((*it)->GetGOT() == GOT_NOF_AGGRESSIVEDEFENDER) ||
303
 
                                                ((*it)->GetGOT() == GOT_NOF_DEFENDER))
304
 
                                        {
305
 
                                                // remove defender from list, insert him again in front of all others
306
 
                                                leave_house.push_front(*it);
307
 
                                                leave_house.erase(it);
308
 
 
309
 
                                                found = true;
310
 
 
311
 
                                                break;
312
 
                                        }
313
 
                                }
314
 
 
315
 
                                // no defender found? trigger next leaving event :)
316
 
                                if (!found)
317
 
                                {
318
 
                                        go_out = false;
319
 
                                        AddLeavingEvent();
320
 
                                        return;
321
 
                                }
322
 
                        }
323
 
 
324
 
                        // Figuren kommen zuerst raus
325
 
                        if(leave_house.size())
326
 
                        {
327
 
                                noFigure * fig = *leave_house.begin();
328
 
 
329
 
                                gwg->AddFigure(fig,x,y);
330
 
 
331
 
                                /// Aktive Soldaten laufen nicht im Wegenetz, die das Haus verteidigen!
332
 
                                if(fig->GetGOT() != GOT_NOF_AGGRESSIVEDEFENDER && 
333
 
                                        fig->GetGOT() != GOT_NOF_DEFENDER)
334
 
                                        // ansonsten alle anderen müssen aber wissen, auf welcher Straße sie zu Beginn laufen
335
 
                                        fig->InitializeRoadWalking(routes[4],0,true);
336
 
 
337
 
                                fig->ActAtFirst();
338
 
                                // Bei Lagerhausarbeitern das nicht abziehen!
339
 
                                if(!fig->MemberOfWarehouse())
340
 
                                {
341
 
                                        // War das ein Boot-Träger?
342
 
                                        if(fig->GetJobType() == JOB_BOATCARRIER)
343
 
                                        {
344
 
                                                // Träger abziehen einzeln
345
 
                                                --goods.people[JOB_HELPER];
346
 
                                                // Boot abziehen einzeln
347
 
                                                --goods.goods[GD_BOAT];
348
 
                                        }
349
 
                                        else
350
 
                                                --goods.people[(*leave_house.begin())->GetJobType()];
351
 
 
352
 
                                        if(fig->GetGOT() == GOT_NOF_TRADEDONKEY)
353
 
                                        {
354
 
                                                // Trade donkey carrying wares?
355
 
                                                --goods.goods[static_cast<nofTradeDonkey*>(fig)->GetCarriedWare()];
356
 
                                        }
357
 
                                }
358
 
 
359
 
                                leave_house.pop_front();
360
 
                        }
361
 
                        else
362
 
                        {
363
 
                                // Ist noch Platz an der Flagge?
364
 
                                if(GetFlag()->GetWareCount() < 8)
365
 
                                {
366
 
                                        // Dann Ware raustragen lassen
367
 
                                        Ware * ware = *waiting_wares.begin();
368
 
                                        nofWarehouseWorker * worker = new nofWarehouseWorker(x,y,player,ware,0);
369
 
                                        gwg->AddFigure(worker,x,y);
370
 
                                        assert(goods.goods[ConvertShields(ware->type)]>0);
371
 
                                        --goods.goods[ConvertShields(ware->type)];
372
 
                                        worker->WalkToGoal();
373
 
                                        ware->Carry(GetFlag());
374
 
                                        waiting_wares.pop_front();
375
 
                                }
376
 
                                else
377
 
                                {
378
 
                                        // Kein Platz mehr für Waren --> keiner brauch mehr rauszukommen, und Figuren gibts ja auch keine mehr
379
 
                                        go_out = false;
380
 
                                }
381
 
                        }
382
 
 
383
 
                        // Wenn keine Figuren und Waren mehr da sind (bzw die Flagge vorm Haus voll ist), brauch auch keiner mehr rauszukommen
384
 
                        if(!leave_house.size() && !waiting_wares.size())
385
 
                                go_out = false;
386
 
 
387
 
 
388
 
                        if(go_out)
389
 
                                leaving_event = em->AddEvent(this,20+RANDOM.Rand(__FILE__,__LINE__,obj_id,10));
390
 
                } break;
391
 
        // Träger-Produzier-Event
392
 
        case 1:
393
 
                {
394
 
                        // Nur bei unter 100 Träcern, weitere "produzieren"
395
 
                        if(real_goods.people[JOB_HELPER] < 100)
396
 
                        {
397
 
                                ++real_goods.people[JOB_HELPER];
398
 
                                ++goods.people[JOB_HELPER];
399
 
 
400
 
                                gwg->GetPlayer(player)->IncreaseInventoryJob(JOB_HELPER,1);
401
 
 
402
 
                                if(real_goods.people[JOB_HELPER] == 1)
403
 
                                {
404
 
                                        
405
 
                                        // Wenn vorher keine Träger da waren, müssen alle unbesetzen Wege gucken, ob sie nen Weg hierher finden, könnte ja sein, dass vorher nich genug Träger da waren
406
 
                                        gwg->GetPlayer(player)->FindWarehouseForAllRoads();
407
 
                                        // evtl Träger mit Werkzeug kombiniert -> neuer Beruf
408
 
                                        gwg->GetPlayer(player)->FindWarehouseForAllJobs(JOB_NOTHING);
409
 
                                }
410
 
                        }
411
 
                        else if(real_goods.people[JOB_HELPER] > 100)
412
 
                        {
413
 
                                // Bei Ãœberbevölkerung Träger vernichten
414
 
                                --real_goods.people[JOB_HELPER];
415
 
                                --goods.people[JOB_HELPER];
416
 
 
417
 
                                gwg->GetPlayer(player)->DecreaseInventoryJob(JOB_HELPER,1);
418
 
                        }
419
 
 
420
 
                        producinghelpers_event = em->AddEvent(this,PRODUCE_HELPERS_GF+RANDOM.Rand(__FILE__,__LINE__,obj_id,PRODUCE_HELPERS_RANDOM_GF),1);
421
 
 
422
 
 
423
 
                        // Evtl. genau der Gehilfe, der zum Rekrutieren notwendig ist
424
 
                        TryRecruiting();
425
 
 
426
 
                        // Evtl die Typen gleich wieder auslagern, falls erforderlich
427
 
                        CheckOuthousing(1,JOB_HELPER);
428
 
                } break;
429
 
        // Soldaten-Rekrutierungsevent
430
 
        case 2:
431
 
                {
432
 
                        recruiting_event = 0;
433
 
                        // Wir wollen so viele der Soldaten rekrutieren,
434
 
                        // wie in den military_settings angegeben.
435
 
                        // Wird evtl gerundet, dann fair nach Zufall ;) ).
436
 
 
437
 
                        unsigned max_recruits;
438
 
                        max_recruits = std::min(
439
 
                                real_goods.goods[GD_SWORD],
440
 
                                real_goods.goods[GD_SHIELDROMANS]);
441
 
                        max_recruits = std::min(
442
 
                                real_goods.goods[GD_BEER],
443
 
                                max_recruits);
444
 
                        max_recruits = std::min(
445
 
                                real_goods.people[JOB_HELPER],
446
 
                                max_recruits);
447
 
 
448
 
                        const unsigned recruiting_ratio 
449
 
                                = gwg->GetPlayer(player)->military_settings[0];
450
 
                        unsigned real_recruits = 
451
 
                                max_recruits 
452
 
                                * recruiting_ratio
453
 
                                / MILITARY_SETTINGS_SCALE[0];
454
 
                        // Wurde abgerundet?
455
 
                        if (real_recruits * recruiting_ratio % MILITARY_SETTINGS_SCALE[0] != 0)
456
 
                        if (unsigned(RANDOM.Rand(__FILE__,__LINE__,obj_id,MILITARY_SETTINGS_SCALE[0]-1)) 
457
 
                            < real_recruits * recruiting_ratio % MILITARY_SETTINGS_SCALE[0])
458
 
                        { 
459
 
                                ++real_recruits;
460
 
                        }
461
 
 
462
 
                        real_goods.people[JOB_PRIVATE] += real_recruits;
463
 
                        goods.people[JOB_PRIVATE] += real_recruits;
464
 
                        gwg->GetPlayer(player)->IncreaseInventoryJob(JOB_PRIVATE, real_recruits);
465
 
 
466
 
                        real_goods.people[JOB_HELPER] -= real_recruits;
467
 
                        goods.people[JOB_HELPER] -= real_recruits;
468
 
                        gwg->GetPlayer(player)->DecreaseInventoryJob(JOB_HELPER, real_recruits);
469
 
                        
470
 
                        real_goods.goods[GD_SWORD] -= real_recruits;
471
 
                        goods.goods[GD_SWORD] -= real_recruits;
472
 
                        gwg->GetPlayer(player)->DecreaseInventoryWare(GD_SWORD,real_recruits);
473
 
 
474
 
                        real_goods.goods[GD_SHIELDROMANS] -= real_recruits;
475
 
                        goods.goods[GD_SHIELDROMANS] -= real_recruits;
476
 
                        gwg->GetPlayer(player)->DecreaseInventoryWare(GD_SHIELDROMANS, real_recruits);
477
 
 
478
 
                        real_goods.goods[GD_BEER] -= real_recruits;
479
 
                        goods.goods[GD_BEER] -= real_recruits;
480
 
                        gwg->GetPlayer(player)->DecreaseInventoryWare(GD_BEER, real_recruits);
481
 
 
482
 
 
483
 
                        // Evtl. versuchen nächsten zu rekrutieren
484
 
                        TryRecruiting();
485
 
 
486
 
                        // Wenn vorher keine Soldaten hier waren, Reserve prüfen
487
 
                        if(real_goods.people[JOB_PRIVATE] == real_recruits)
488
 
                                this->RefreshReserve(0);
489
 
 
490
 
                        // Wenn vorher keine Soldaten hier waren, Militärgebäude prüfen (evtl kann der Soldat ja wieder in eins gehen)
491
 
                        if(real_goods.people[JOB_PRIVATE] == real_recruits)
492
 
                                for (unsigned short i = 0; i < real_recruits; ++i)
493
 
                                        gwg->GetPlayer(player)->NewSoldierAvailable(real_goods.people[JOB_PRIVATE]);
494
 
 
495
 
 
496
 
                } break;
497
 
        // Auslagerevent
498
 
        case 3:
499
 
                {
500
 
                        // Fight or something in front of the house? Try again later!
501
 
                        if (!gwg->IsRoadNodeForFigures(gwg->GetXA(x,y,4), gwg->GetYA(x,y,4), 4))
502
 
                        {
503
 
                                empty_event = em->AddEvent(this,EMPTY_INTERVAL,3);
504
 
                                return;
505
 
                        }
506
 
 
507
 
                        empty_event = 0;
508
 
 
509
 
                        list<unsigned> type_list;
510
 
                        // Waren und Figuren zum Auslagern zusammensuchen (id >= 34 --> Figur!)
511
 
                        // Wenn keine Platz an Flagge, dann keine Waren raus
512
 
                        if(GetFlag()->IsSpaceForWare())
513
 
                        {
514
 
                                for(unsigned i = 0;i<WARE_TYPES_COUNT;++i)
515
 
                                {
516
 
                                        if(CheckRealInventorySettings(0,4,i) && real_goods.goods[i])
517
 
                                                type_list.push_back(i);
518
 
                                }
519
 
                        }
520
 
 
521
 
                        for(unsigned i = 0;i<JOB_TYPES_COUNT;++i)
522
 
                        {
523
 
                                // Figuren, die noch nicht implementiert sind, nicht nehmen!
524
 
                                if(CheckRealInventorySettings(1,4,i) && real_goods.people[i])
525
 
                                        type_list.push_back(WARE_TYPES_COUNT+i);
526
 
                        }
527
 
 
528
 
                        // Gibts überhaupt welche?
529
 
                        if(!type_list.size())
530
 
                                // ansonsten gleich tschüss
531
 
                                return;
532
 
 
533
 
                        // Eine ID zufällig auswählen
534
 
                        unsigned type = *type_list[RANDOM.Rand(__FILE__,__LINE__,obj_id,type_list.size())];
535
 
 
536
 
                        if(type < WARE_TYPES_COUNT)
537
 
                        {
538
 
                                // Ware
539
 
 
540
 
                                Ware * ware = new Ware(GoodType(type),0,this);
541
 
                                ware->goal = gwg->GetPlayer(player)->FindClientForWare(ware);
542
 
 
543
 
                                // Ware zur Liste hinzufügen, damit sie dann rausgetragen wird
544
 
                                waiting_wares.push_back(ware);
545
 
 
546
 
                                AddLeavingEvent();
547
 
 
548
 
                                // Ware aus Inventar entfernen
549
 
                                --(real_goods.goods[type]);
550
 
 
551
 
                                // Evtl. kein Schwert/Schild/Bier mehr da, sodass das Rekrutieren gestoppt werden muss
552
 
                                TryStopRecruiting();
553
 
                        }
554
 
                        else
555
 
                        {
556
 
                                // Figur
557
 
                                type-=WARE_TYPES_COUNT;
558
 
 
559
 
                                nobBaseWarehouse * wh = gwg->GetPlayer(player)->FindWarehouse(this,FW::Condition_StoreFigure,0,true,&type,false);
560
 
                                nofPassiveWorker * fig = new nofPassiveWorker(Job(type),x,y,player,NULL);
561
 
                                
562
 
                                if(wh)
563
 
                                        fig->GoHome(wh);
564
 
                                else
565
 
                                        fig->StartWandering();
566
 
 
567
 
                                // Kein Ziel gefunden, dann später gleich rumirren!
568
 
                                /*if(!wh)
569
 
                                        fig->StartWandering();*/
570
 
 
571
 
                                AddLeavingFigure(fig);
572
 
 
573
 
                                // Person aus Inventar entfernen
574
 
                                --(real_goods.people[type]);
575
 
 
576
 
                                // Evtl. kein Gehilfe mehr da, sodass das Rekrutieren gestoppt werden muss
577
 
                                TryStopRecruiting();
578
 
                        }
579
 
 
580
 
                        // Weitere Waren/Figuren zum Auslagern? 
581
 
                        if(AreWaresToEmpty())
582
 
                                // --> Nächstes Event
583
 
                                empty_event = em->AddEvent(this,EMPTY_INTERVAL,3);
584
 
 
585
 
                } break;
586
 
        // Einlagerevent
587
 
        case 4:
588
 
                {
589
 
                        store_event = NULL;
590
 
                        
591
 
                        // Storing wares done?
592
 
                        bool storing_done = false;
593
 
                        // Is storing still wanted?
594
 
                        bool storing_wanted = false;
595
 
 
596
 
                        // Untersuchen, welche Waren und Figuren eingelagert werden sollen
597
 
                        for(unsigned i = 0;i<WARE_TYPES_COUNT;++i)
598
 
                        {
599
 
                                // Soll Ware eingeliefert werden?
600
 
                                if(inventory_settings_real.wares[i] & 8)
601
 
                                {
602
 
                                        storing_wanted = true;
603
 
 
604
 
                                        // Lagerhaus suchen, das diese Ware enthält
605
 
                                        nobBaseWarehouse * wh = players->getElement(player)
606
 
                                                ->FindWarehouse(this,FW::Condition_StoreAndDontWantWare,NULL,false,(void*)&i,false);
607
 
                                        // Gefunden?
608
 
                                        if(wh)
609
 
                                        {
610
 
                                                // Dann bestellen
611
 
                                                Ware * ware = wh->OrderWare(GoodType(i),this);
612
 
                                                if(ware)
613
 
                                                {
614
 
                                                        dependent_wares.push_back(ware);
615
 
                                                        storing_done = true;
616
 
                                                        break;
617
 
                                                }
618
 
                                        }
619
 
                                }
620
 
                        }
621
 
 
622
 
                        // Menschen "bestellen" wenn noch keine Ware bestellt wurde
623
 
                        if(!storing_done)
624
 
                        {
625
 
                                for(unsigned i = 0;i<JOB_TYPES_COUNT;++i)
626
 
                                {
627
 
                                        // Soll dieser Typ von Mensch bestellt werden?
628
 
                                        if(inventory_settings_real.figures[i] & 8)
629
 
                                        {
630
 
                                                storing_wanted = true;
631
 
 
632
 
                                                // Lagerhaus suchen, das diesen Job enthält
633
 
                                                nobBaseWarehouse * wh = players->getElement(player)
634
 
                                                        ->FindWarehouse(this,FW::Condition_StoreAndDontWantFigure,NULL,false,(void*)&i,false);
635
 
                                                // Gefunden?
636
 
                                                if(wh)
637
 
                                                {
638
 
                                                        // Dann bestellen
639
 
                                                        if(wh->OrderJob(Job(i),this,false))
640
 
                                                                break;
641
 
                                                }
642
 
                                        }
643
 
                                }
644
 
                        }
645
 
 
646
 
                        // Storing still wanted?
647
 
                        // Then continue ordering new stuff
648
 
                        if(storing_wanted)
649
 
                                store_event = em->AddEvent(this,STORE_INTERVAL,4);
650
 
 
651
 
 
652
 
                } break;
653
 
        }
 
279
    switch(id)
 
280
    {
 
281
            // Rausgeh-Event
 
282
        case 0:
 
283
        {
 
284
            leaving_event = 0;
 
285
 
 
286
            // Falls eine Bestellung storniert wurde
 
287
            if(!leave_house.size() && !waiting_wares.size())
 
288
            {
 
289
                go_out = false;
 
290
                return;
 
291
            }
 
292
 
 
293
            // Fight or something in front of the house and we are not defending?
 
294
            if (!gwg->IsRoadNodeForFigures(gwg->GetXA(x, y, 4), gwg->GetYA(x, y, 4), 4))
 
295
            {
 
296
                // there's a fight
 
297
                bool found = false;
 
298
 
 
299
                // try to find a defender and make him leave the house first
 
300
                for(std::list<noFigure*>::iterator it = leave_house.begin(); it != leave_house.end(); ++it)
 
301
                {
 
302
                    if (((*it)->GetGOT() == GOT_NOF_AGGRESSIVEDEFENDER) ||
 
303
                            ((*it)->GetGOT() == GOT_NOF_DEFENDER))
 
304
                    {
 
305
                        // remove defender from list, insert him again in front of all others
 
306
                        leave_house.push_front(*it);
 
307
                        leave_house.erase(it);
 
308
 
 
309
                        found = true;
 
310
 
 
311
                        break;
 
312
                    }
 
313
                }
 
314
 
 
315
                // no defender found? trigger next leaving event :)
 
316
                if (!found)
 
317
                {
 
318
                    go_out = false;
 
319
                    AddLeavingEvent();
 
320
                    return;
 
321
                }
 
322
            }
 
323
 
 
324
            // Figuren kommen zuerst raus
 
325
            if(leave_house.size())
 
326
            {
 
327
                noFigure* fig = *leave_house.begin();
 
328
 
 
329
                gwg->AddFigure(fig, x, y);
 
330
 
 
331
                /// Aktive Soldaten laufen nicht im Wegenetz, die das Haus verteidigen!
 
332
                if(fig->GetGOT() != GOT_NOF_AGGRESSIVEDEFENDER &&
 
333
                        fig->GetGOT() != GOT_NOF_DEFENDER)
 
334
                    // ansonsten alle anderen müssen aber wissen, auf welcher Straße sie zu Beginn laufen
 
335
                    fig->InitializeRoadWalking(routes[4], 0, true);
 
336
 
 
337
                fig->ActAtFirst();
 
338
                // Bei Lagerhausarbeitern das nicht abziehen!
 
339
                if(!fig->MemberOfWarehouse())
 
340
                {
 
341
                    // War das ein Boot-Träger?
 
342
                    if(fig->GetJobType() == JOB_BOATCARRIER)
 
343
                    {
 
344
                        // Träger abziehen einzeln
 
345
                        --goods.people[JOB_HELPER];
 
346
                        // Boot abziehen einzeln
 
347
                        --goods.goods[GD_BOAT];
 
348
                    }
 
349
                    else
 
350
                        --goods.people[(*leave_house.begin())->GetJobType()];
 
351
 
 
352
                    if(fig->GetGOT() == GOT_NOF_TRADEDONKEY)
 
353
                    {
 
354
                        // Trade donkey carrying wares?
 
355
                        --goods.goods[static_cast<nofTradeDonkey*>(fig)->GetCarriedWare()];
 
356
                    }
 
357
                }
 
358
 
 
359
                leave_house.pop_front();
 
360
            }
 
361
            else
 
362
            {
 
363
                // Ist noch Platz an der Flagge?
 
364
                if(GetFlag()->GetWareCount() < 8)
 
365
                {
 
366
                    // Dann Ware raustragen lassen
 
367
                    Ware* ware = *waiting_wares.begin();
 
368
                    nofWarehouseWorker* worker = new nofWarehouseWorker(x, y, player, ware, 0);
 
369
                    gwg->AddFigure(worker, x, y);
 
370
                    assert(goods.goods[ConvertShields(ware->type)] > 0);
 
371
                    --goods.goods[ConvertShields(ware->type)];
 
372
                    worker->WalkToGoal();
 
373
                    ware->Carry(GetFlag());
 
374
                    waiting_wares.pop_front();
 
375
                }
 
376
                else
 
377
                {
 
378
                    // Kein Platz mehr für Waren --> keiner brauch mehr rauszukommen, und Figuren gibts ja auch keine mehr
 
379
                    go_out = false;
 
380
                }
 
381
            }
 
382
 
 
383
            // Wenn keine Figuren und Waren mehr da sind (bzw die Flagge vorm Haus voll ist), brauch auch keiner mehr rauszukommen
 
384
            if(!leave_house.size() && !waiting_wares.size())
 
385
                go_out = false;
 
386
 
 
387
 
 
388
            if(go_out)
 
389
                leaving_event = em->AddEvent(this, 20 + RANDOM.Rand(__FILE__, __LINE__, obj_id, 10));
 
390
        } break;
 
391
        // Träger-Produzier-Event
 
392
        case 1:
 
393
        {
 
394
            // Nur bei unter 100 Träcern, weitere "produzieren"
 
395
            if(real_goods.people[JOB_HELPER] < 100)
 
396
            {
 
397
                ++real_goods.people[JOB_HELPER];
 
398
                ++goods.people[JOB_HELPER];
 
399
 
 
400
                gwg->GetPlayer(player)->IncreaseInventoryJob(JOB_HELPER, 1);
 
401
 
 
402
                if(real_goods.people[JOB_HELPER] == 1)
 
403
                {
 
404
 
 
405
                    // Wenn vorher keine Träger da waren, müssen alle unbesetzen Wege gucken, ob sie nen Weg hierher finden, könnte ja sein, dass vorher nich genug Träger da waren
 
406
                    gwg->GetPlayer(player)->FindWarehouseForAllRoads();
 
407
                    // evtl Träger mit Werkzeug kombiniert -> neuer Beruf
 
408
                    gwg->GetPlayer(player)->FindWarehouseForAllJobs(JOB_NOTHING);
 
409
                }
 
410
            }
 
411
            else if(real_goods.people[JOB_HELPER] > 100)
 
412
            {
 
413
                // Bei Ãœberbevölkerung Träger vernichten
 
414
                --real_goods.people[JOB_HELPER];
 
415
                --goods.people[JOB_HELPER];
 
416
 
 
417
                gwg->GetPlayer(player)->DecreaseInventoryJob(JOB_HELPER, 1);
 
418
            }
 
419
 
 
420
            producinghelpers_event = em->AddEvent(this, PRODUCE_HELPERS_GF + RANDOM.Rand(__FILE__, __LINE__, obj_id, PRODUCE_HELPERS_RANDOM_GF), 1);
 
421
 
 
422
 
 
423
            // Evtl. genau der Gehilfe, der zum Rekrutieren notwendig ist
 
424
            TryRecruiting();
 
425
 
 
426
            // Evtl die Typen gleich wieder auslagern, falls erforderlich
 
427
            CheckOuthousing(1, JOB_HELPER);
 
428
        } break;
 
429
        // Soldaten-Rekrutierungsevent
 
430
        case 2:
 
431
        {
 
432
            recruiting_event = 0;
 
433
            // Wir wollen so viele der Soldaten rekrutieren,
 
434
            // wie in den military_settings angegeben.
 
435
            // Wird evtl gerundet, dann fair nach Zufall ;) ).
 
436
 
 
437
            unsigned max_recruits;
 
438
            max_recruits = std::min(
 
439
                               real_goods.goods[GD_SWORD],
 
440
                               real_goods.goods[GD_SHIELDROMANS]);
 
441
            max_recruits = std::min(
 
442
                               real_goods.goods[GD_BEER],
 
443
                               max_recruits);
 
444
            max_recruits = std::min(
 
445
                               real_goods.people[JOB_HELPER],
 
446
                               max_recruits);
 
447
 
 
448
            const unsigned recruiting_ratio
 
449
            = gwg->GetPlayer(player)->military_settings[0];
 
450
            unsigned real_recruits =
 
451
                max_recruits
 
452
                * recruiting_ratio
 
453
                / MILITARY_SETTINGS_SCALE[0];
 
454
            // Wurde abgerundet?
 
455
            if (real_recruits * recruiting_ratio % MILITARY_SETTINGS_SCALE[0] != 0)
 
456
                if (unsigned(RANDOM.Rand(__FILE__, __LINE__, obj_id, MILITARY_SETTINGS_SCALE[0] - 1))
 
457
                        < real_recruits * recruiting_ratio % MILITARY_SETTINGS_SCALE[0])
 
458
                {
 
459
                    ++real_recruits;
 
460
                }
 
461
 
 
462
            real_goods.people[JOB_PRIVATE] += real_recruits;
 
463
            goods.people[JOB_PRIVATE] += real_recruits;
 
464
            gwg->GetPlayer(player)->IncreaseInventoryJob(JOB_PRIVATE, real_recruits);
 
465
 
 
466
            real_goods.people[JOB_HELPER] -= real_recruits;
 
467
            goods.people[JOB_HELPER] -= real_recruits;
 
468
            gwg->GetPlayer(player)->DecreaseInventoryJob(JOB_HELPER, real_recruits);
 
469
 
 
470
            real_goods.goods[GD_SWORD] -= real_recruits;
 
471
            goods.goods[GD_SWORD] -= real_recruits;
 
472
            gwg->GetPlayer(player)->DecreaseInventoryWare(GD_SWORD, real_recruits);
 
473
 
 
474
            real_goods.goods[GD_SHIELDROMANS] -= real_recruits;
 
475
            goods.goods[GD_SHIELDROMANS] -= real_recruits;
 
476
            gwg->GetPlayer(player)->DecreaseInventoryWare(GD_SHIELDROMANS, real_recruits);
 
477
 
 
478
            real_goods.goods[GD_BEER] -= real_recruits;
 
479
            goods.goods[GD_BEER] -= real_recruits;
 
480
            gwg->GetPlayer(player)->DecreaseInventoryWare(GD_BEER, real_recruits);
 
481
 
 
482
 
 
483
            // Evtl. versuchen nächsten zu rekrutieren
 
484
            TryRecruiting();
 
485
 
 
486
            // Wenn vorher keine Soldaten hier waren, Reserve prüfen
 
487
            if(real_goods.people[JOB_PRIVATE] == real_recruits)
 
488
                this->RefreshReserve(0);
 
489
 
 
490
            // Wenn vorher keine Soldaten hier waren, Militärgebäude prüfen (evtl kann der Soldat ja wieder in eins gehen)
 
491
            if(real_goods.people[JOB_PRIVATE] == real_recruits)
 
492
                for (unsigned short i = 0; i < real_recruits; ++i)
 
493
                    gwg->GetPlayer(player)->NewSoldierAvailable(real_goods.people[JOB_PRIVATE]);
 
494
 
 
495
 
 
496
        } break;
 
497
        // Auslagerevent
 
498
        case 3:
 
499
        {
 
500
            // Fight or something in front of the house? Try again later!
 
501
            if (!gwg->IsRoadNodeForFigures(gwg->GetXA(x, y, 4), gwg->GetYA(x, y, 4), 4))
 
502
            {
 
503
                empty_event = em->AddEvent(this, EMPTY_INTERVAL, 3);
 
504
                return;
 
505
            }
 
506
 
 
507
            empty_event = 0;
 
508
 
 
509
            list<unsigned> type_list;
 
510
            // Waren und Figuren zum Auslagern zusammensuchen (id >= 34 --> Figur!)
 
511
            // Wenn keine Platz an Flagge, dann keine Waren raus
 
512
            if(GetFlag()->IsSpaceForWare())
 
513
            {
 
514
                for(unsigned i = 0; i < WARE_TYPES_COUNT; ++i)
 
515
                {
 
516
                    if(CheckRealInventorySettings(0, 4, i) && real_goods.goods[i])
 
517
                        type_list.push_back(i);
 
518
                }
 
519
            }
 
520
 
 
521
            for(unsigned i = 0; i < JOB_TYPES_COUNT; ++i)
 
522
            {
 
523
                // Figuren, die noch nicht implementiert sind, nicht nehmen!
 
524
                if(CheckRealInventorySettings(1, 4, i) && real_goods.people[i])
 
525
                    type_list.push_back(WARE_TYPES_COUNT + i);
 
526
            }
 
527
 
 
528
            // Gibts überhaupt welche?
 
529
            if(!type_list.size())
 
530
                // ansonsten gleich tschüss
 
531
                return;
 
532
 
 
533
            // Eine ID zufällig auswählen
 
534
            unsigned type = *type_list[RANDOM.Rand(__FILE__, __LINE__, obj_id, type_list.size())];
 
535
 
 
536
            if(type < WARE_TYPES_COUNT)
 
537
            {
 
538
                // Ware
 
539
 
 
540
                Ware* ware = new Ware(GoodType(type), 0, this);
 
541
                ware->goal = gwg->GetPlayer(player)->FindClientForWare(ware);
 
542
 
 
543
                // Ware zur Liste hinzufügen, damit sie dann rausgetragen wird
 
544
                waiting_wares.push_back(ware);
 
545
 
 
546
                AddLeavingEvent();
 
547
 
 
548
                // Ware aus Inventar entfernen
 
549
                --(real_goods.goods[type]);
 
550
 
 
551
                // Evtl. kein Schwert/Schild/Bier mehr da, sodass das Rekrutieren gestoppt werden muss
 
552
                TryStopRecruiting();
 
553
            }
 
554
            else
 
555
            {
 
556
                // Figur
 
557
                type -= WARE_TYPES_COUNT;
 
558
 
 
559
                nobBaseWarehouse* wh = gwg->GetPlayer(player)->FindWarehouse(this, FW::Condition_StoreFigure, 0, true, &type, false);
 
560
                nofPassiveWorker* fig = new nofPassiveWorker(Job(type), x, y, player, NULL);
 
561
 
 
562
                if(wh)
 
563
                    fig->GoHome(wh);
 
564
                else
 
565
                    fig->StartWandering();
 
566
 
 
567
                // Kein Ziel gefunden, dann später gleich rumirren!
 
568
                /*if(!wh)
 
569
                    fig->StartWandering();*/
 
570
 
 
571
                AddLeavingFigure(fig);
 
572
 
 
573
                // Person aus Inventar entfernen
 
574
                --(real_goods.people[type]);
 
575
 
 
576
                // Evtl. kein Gehilfe mehr da, sodass das Rekrutieren gestoppt werden muss
 
577
                TryStopRecruiting();
 
578
            }
 
579
 
 
580
            // Weitere Waren/Figuren zum Auslagern?
 
581
            if(AreWaresToEmpty())
 
582
                // --> Nächstes Event
 
583
                empty_event = em->AddEvent(this, EMPTY_INTERVAL, 3);
 
584
 
 
585
        } break;
 
586
        // Einlagerevent
 
587
        case 4:
 
588
        {
 
589
            store_event = NULL;
 
590
 
 
591
            // Storing wares done?
 
592
            bool storing_done = false;
 
593
            // Is storing still wanted?
 
594
            bool storing_wanted = false;
 
595
 
 
596
            // Untersuchen, welche Waren und Figuren eingelagert werden sollen
 
597
            for(unsigned i = 0; i < WARE_TYPES_COUNT; ++i)
 
598
            {
 
599
                // Soll Ware eingeliefert werden?
 
600
                if(inventory_settings_real.wares[i] & 8)
 
601
                {
 
602
                    storing_wanted = true;
 
603
 
 
604
                    // Lagerhaus suchen, das diese Ware enthält
 
605
                    nobBaseWarehouse* wh = players->getElement(player)
 
606
                                           ->FindWarehouse(this, FW::Condition_StoreAndDontWantWare, NULL, false, (void*)&i, false);
 
607
                    // Gefunden?
 
608
                    if(wh)
 
609
                    {
 
610
                        // Dann bestellen
 
611
                        Ware* ware = wh->OrderWare(GoodType(i), this);
 
612
                        if(ware)
 
613
                        {
 
614
                            dependent_wares.push_back(ware);
 
615
                            storing_done = true;
 
616
                            break;
 
617
                        }
 
618
                    }
 
619
                }
 
620
            }
 
621
 
 
622
            // Menschen "bestellen" wenn noch keine Ware bestellt wurde
 
623
            if(!storing_done)
 
624
            {
 
625
                for(unsigned i = 0; i < JOB_TYPES_COUNT; ++i)
 
626
                {
 
627
                    // Soll dieser Typ von Mensch bestellt werden?
 
628
                    if(inventory_settings_real.figures[i] & 8)
 
629
                    {
 
630
                        storing_wanted = true;
 
631
 
 
632
                        // Lagerhaus suchen, das diesen Job enthält
 
633
                        nobBaseWarehouse* wh = players->getElement(player)
 
634
                                               ->FindWarehouse(this, FW::Condition_StoreAndDontWantFigure, NULL, false, (void*)&i, false);
 
635
                        // Gefunden?
 
636
                        if(wh)
 
637
                        {
 
638
                            // Dann bestellen
 
639
                            if(wh->OrderJob(Job(i), this, false))
 
640
                                break;
 
641
                        }
 
642
                    }
 
643
                }
 
644
            }
 
645
 
 
646
            // Storing still wanted?
 
647
            // Then continue ordering new stuff
 
648
            if(storing_wanted)
 
649
                store_event = em->AddEvent(this, STORE_INTERVAL, 4);
 
650
 
 
651
 
 
652
        } break;
 
653
    }
654
654
}
655
655
 
656
 
/// Abgeleitete kann eine gerade erzeugte Ware ggf. sofort verwenden 
 
656
/// Abgeleitete kann eine gerade erzeugte Ware ggf. sofort verwenden
657
657
/// (muss in dem Fall true zurückgeben)
658
 
bool nobBaseWarehouse::UseWareAtOnce(Ware * ware, noBaseBuilding* const goal)
 
658
bool nobBaseWarehouse::UseWareAtOnce(Ware* ware, noBaseBuilding* const goal)
659
659
{
660
 
        return false;
 
660
    return false;
661
661
}
662
662
 
663
663
/// Dasselbe für Menschen
664
 
bool nobBaseWarehouse::UseFigureAtOnce(noFigure * fig, noRoadNode* const goal)
665
 
{
666
 
        return false;
667
 
}
668
 
 
669
 
Ware * nobBaseWarehouse::OrderWare(const GoodType good, noBaseBuilding* const goal)
670
 
{
671
 
        // Ware überhaupt hier vorhanden (Abfrage eigentlich nicht nötig, aber erstmal zur Sicherheit)
672
 
        if(!real_goods.goods[good])
673
 
        {
674
 
                LOG.lprintf("nobBaseWarehouse::OrderWare: WARNING: No ware type %u in warehouse!\n",static_cast<unsigned>(good));
675
 
                return 0;
676
 
        }
677
 
 
678
 
        Ware * ware = new Ware(good,goal,this);
679
 
 
680
 
        // Abgeleitete Klasse fragen, ob die irgnend etwas besonderes mit dieser Ware anfangen will
681
 
        if(!UseWareAtOnce(ware,goal))
682
 
                // Ware zur Liste hinzufügen, damit sie dann rausgetragen wird
683
 
                waiting_wares.push_back(ware);
684
 
 
685
 
        --real_goods.goods[good];
686
 
 
687
 
        // Wenn gerade keiner rausgeht, muss neues Event angemeldet werden
688
 
        AddLeavingEvent();
689
 
 
690
 
        // Evtl. keine Waffen/Bier mehr da, sodass das Rekrutieren gestoppt werden muss
691
 
        TryStopRecruiting();
692
 
 
693
 
        return ware;
694
 
}
695
 
 
696
 
void nobBaseWarehouse::AddWaitingWare(Ware * ware)
697
 
{
698
 
        waiting_wares.push_back(ware);
699
 
        // Wenn gerade keiner rausgeht, muss neues Event angemeldet werden
700
 
        AddLeavingEvent();
701
 
        // Die visuelle Warenanzahl wieder erhöhen
702
 
        ++goods.goods[ConvertShields(ware->type)];
 
664
bool nobBaseWarehouse::UseFigureAtOnce(noFigure* fig, noRoadNode* const goal)
 
665
{
 
666
    return false;
 
667
}
 
668
 
 
669
Ware* nobBaseWarehouse::OrderWare(const GoodType good, noBaseBuilding* const goal)
 
670
{
 
671
    // Ware überhaupt hier vorhanden (Abfrage eigentlich nicht nötig, aber erstmal zur Sicherheit)
 
672
    if(!real_goods.goods[good])
 
673
    {
 
674
        LOG.lprintf("nobBaseWarehouse::OrderWare: WARNING: No ware type %u in warehouse!\n", static_cast<unsigned>(good));
 
675
        return 0;
 
676
    }
 
677
 
 
678
    Ware* ware = new Ware(good, goal, this);
 
679
 
 
680
    // Abgeleitete Klasse fragen, ob die irgnend etwas besonderes mit dieser Ware anfangen will
 
681
    if(!UseWareAtOnce(ware, goal))
 
682
        // Ware zur Liste hinzufügen, damit sie dann rausgetragen wird
 
683
        waiting_wares.push_back(ware);
 
684
 
 
685
    --real_goods.goods[good];
 
686
 
 
687
    // Wenn gerade keiner rausgeht, muss neues Event angemeldet werden
 
688
    AddLeavingEvent();
 
689
 
 
690
    // Evtl. keine Waffen/Bier mehr da, sodass das Rekrutieren gestoppt werden muss
 
691
    TryStopRecruiting();
 
692
 
 
693
    return ware;
 
694
}
 
695
 
 
696
void nobBaseWarehouse::AddWaitingWare(Ware* ware)
 
697
{
 
698
    waiting_wares.push_back(ware);
 
699
    // Wenn gerade keiner rausgeht, muss neues Event angemeldet werden
 
700
    AddLeavingEvent();
 
701
    // Die visuelle Warenanzahl wieder erhöhen
 
702
    ++goods.goods[ConvertShields(ware->type)];
703
703
}
704
704
 
705
705
bool nobBaseWarehouse::FreePlaceAtFlag()
706
706
{
707
 
        if(waiting_wares.size())
708
 
        {
709
 
                AddLeavingEvent();
710
 
                return true;
711
 
        }
712
 
        else
713
 
        {
714
 
                // Evtl. war die Flagge voll und das Auslagern musste gestoppt werden
715
 
                // Weitere Waren/Figuren zum Auslagern und kein Event angemeldet?
716
 
                if(AreWaresToEmpty() && !empty_event)
717
 
                        // --> Nächstes Event
718
 
                        empty_event = em->AddEvent(this,EMPTY_INTERVAL,3);
 
707
    if(waiting_wares.size())
 
708
    {
 
709
        AddLeavingEvent();
 
710
        return true;
 
711
    }
 
712
    else
 
713
    {
 
714
        // Evtl. war die Flagge voll und das Auslagern musste gestoppt werden
 
715
        // Weitere Waren/Figuren zum Auslagern und kein Event angemeldet?
 
716
        if(AreWaresToEmpty() && !empty_event)
 
717
            // --> Nächstes Event
 
718
            empty_event = em->AddEvent(this, EMPTY_INTERVAL, 3);
719
719
 
720
 
                return false;
721
 
        }
 
720
        return false;
 
721
    }
722
722
}
723
723
 
724
 
void nobBaseWarehouse::AddWare(Ware * ware)
 
724
void nobBaseWarehouse::AddWare(Ware* ware)
725
725
{
726
 
        // Ware nicht mehr abhängig
727
 
        RemoveDependentWare(ware);
728
 
 
729
 
        // Die Schilde der verschiedenen Nation in eine "Schild-Sorte" (den der Römer) umwandeln!
730
 
        GoodType type;
731
 
        if(ware->type == GD_SHIELDAFRICANS || ware->type == GD_SHIELDJAPANESE || ware->type == GD_SHIELDVIKINGS)
732
 
                type = GD_SHIELDROMANS;
733
 
        else
734
 
                type = ware->type;
735
 
 
736
 
        gwg->GetPlayer(player)->RemoveWare(ware);
737
 
        delete ware;
738
 
 
739
 
        ++real_goods.goods[type];
740
 
        ++goods.goods[type];
741
 
 
742
 
        CheckUsesForNewWare(type);
 
726
    // Ware nicht mehr abhängig
 
727
    RemoveDependentWare(ware);
 
728
 
 
729
    // Die Schilde der verschiedenen Nation in eine "Schild-Sorte" (den der Römer) umwandeln!
 
730
    GoodType type;
 
731
    if(ware->type == GD_SHIELDAFRICANS || ware->type == GD_SHIELDJAPANESE || ware->type == GD_SHIELDVIKINGS)
 
732
        type = GD_SHIELDROMANS;
 
733
    else
 
734
        type = ware->type;
 
735
 
 
736
    gwg->GetPlayer(player)->RemoveWare(ware);
 
737
    delete ware;
 
738
 
 
739
    ++real_goods.goods[type];
 
740
    ++goods.goods[type];
 
741
 
 
742
    CheckUsesForNewWare(type);
743
743
}
744
744
 
745
745
/// Prüft verschiedene Verwendungszwecke für eine neuangekommende Ware
746
746
void nobBaseWarehouse::CheckUsesForNewWare(const GoodType gt)
747
747
{
748
 
        // Wenn es ein Werkzeug war, evtl neuen Job suchen, der jetzt erzeugt werden könnte..
749
 
        if(gt >= GD_TONGS && gt <= GD_BOAT)
750
 
        {
751
 
                for(unsigned i = 0;i<30;++i)
752
 
                {
753
 
                        if(JOB_CONSTS[i].tool == gt)
754
 
                                gwg->GetPlayer(player)->FindWarehouseForAllJobs(Job(i));
755
 
                }
756
 
        }
757
 
 
758
 
        
759
 
 
760
 
        // Wars Baumaterial? Dann den Baustellen Bescheid sagen
761
 
        if(gt == GD_BOARDS || gt == GD_STONES)
762
 
                gwg->GetPlayer(player)->FindMaterialForBuildingSites();
763
 
 
764
 
        // Evtl wurden Bier oder Waffen reingetragen --> versuchen zu rekrutieren
765
 
        TryRecruiting();
766
 
 
767
 
        // Evtl die Ware gleich wieder auslagern, falls erforderlich
768
 
        CheckOuthousing(0,type);
 
748
    // Wenn es ein Werkzeug war, evtl neuen Job suchen, der jetzt erzeugt werden könnte..
 
749
    if(gt >= GD_TONGS && gt <= GD_BOAT)
 
750
    {
 
751
        for(unsigned i = 0; i < 30; ++i)
 
752
        {
 
753
            if(JOB_CONSTS[i].tool == gt)
 
754
                gwg->GetPlayer(player)->FindWarehouseForAllJobs(Job(i));
 
755
        }
 
756
    }
 
757
 
 
758
 
 
759
 
 
760
    // Wars Baumaterial? Dann den Baustellen Bescheid sagen
 
761
    if(gt == GD_BOARDS || gt == GD_STONES)
 
762
        gwg->GetPlayer(player)->FindMaterialForBuildingSites();
 
763
 
 
764
    // Evtl wurden Bier oder Waffen reingetragen --> versuchen zu rekrutieren
 
765
    TryRecruiting();
 
766
 
 
767
    // Evtl die Ware gleich wieder auslagern, falls erforderlich
 
768
    CheckOuthousing(0, type);
769
769
}
770
770
 
771
771
/// Prüft verschiedene Sachen, falls ein neuer Mensch das Haus betreten hat
772
772
void nobBaseWarehouse::CheckJobsForNewFigure(const Job job)
773
773
{
774
 
        // Evtl ging ein Gehilfe rein --> versuchen zu rekrutieren
775
 
        if(job == JOB_HELPER)
776
 
                TryRecruiting();
777
 
 
778
 
        if(job >= JOB_PRIVATE && job <= JOB_GENERAL)
779
 
        {
780
 
                // Reserve prüfen
781
 
                RefreshReserve(job-JOB_PRIVATE);
782
 
                // Truppen prüfen in allen Häusern
783
 
                gwg->GetPlayer(player)->NewSoldierAvailable(real_goods.people[job]);
784
 
        }
785
 
        else
786
 
        {
787
 
                if(job == JOB_PACKDONKEY)
788
 
                {
789
 
                        // Straße für Esel suchen
790
 
                        noRoadNode * goal;
791
 
                        if(RoadSegment * road = gwg->GetPlayer(player)->FindRoadForDonkey(this,&goal))
792
 
                        {
793
 
                                // gefunden --> Esel an die Straße bestellen
794
 
                                road->GotDonkey(OrderDonkey(road,goal));
795
 
                        }
796
 
 
797
 
                }
798
 
                else
799
 
                {
800
 
                        // Evtl. Abnehmer für die Figur wieder finden
801
 
                        gwg->GetPlayer(player)->FindWarehouseForAllJobs(job);
802
 
                        // Wenns ein Träger war, auch Wege prüfen
803
 
                        if(job == JOB_HELPER && real_goods.people[JOB_HELPER]==1)
804
 
                        {
805
 
                                // evtl als Träger auf Straßen schicken
806
 
                                gwg->GetPlayer(player)->FindWarehouseForAllRoads();
807
 
                                // evtl Träger mit Werkzeug kombiniert -> neuer Beruf
808
 
                                gwg->GetPlayer(player)->FindWarehouseForAllJobs(JOB_NOTHING);
809
 
                        }
810
 
                                
811
 
                }
812
 
        }
813
 
 
814
 
        // Evtl den Typen gleich wieder auslagern, falls erforderlich
815
 
        CheckOuthousing(1,job);
 
774
    // Evtl ging ein Gehilfe rein --> versuchen zu rekrutieren
 
775
    if(job == JOB_HELPER)
 
776
        TryRecruiting();
 
777
 
 
778
    if(job >= JOB_PRIVATE && job <= JOB_GENERAL)
 
779
    {
 
780
        // Reserve prüfen
 
781
        RefreshReserve(job - JOB_PRIVATE);
 
782
        // Truppen prüfen in allen Häusern
 
783
        gwg->GetPlayer(player)->NewSoldierAvailable(real_goods.people[job]);
 
784
    }
 
785
    else
 
786
    {
 
787
        if(job == JOB_PACKDONKEY)
 
788
        {
 
789
            // Straße für Esel suchen
 
790
            noRoadNode* goal;
 
791
            if(RoadSegment* road = gwg->GetPlayer(player)->FindRoadForDonkey(this, &goal))
 
792
            {
 
793
                // gefunden --> Esel an die Straße bestellen
 
794
                road->GotDonkey(OrderDonkey(road, goal));
 
795
            }
 
796
 
 
797
        }
 
798
        else
 
799
        {
 
800
            // Evtl. Abnehmer für die Figur wieder finden
 
801
            gwg->GetPlayer(player)->FindWarehouseForAllJobs(job);
 
802
            // Wenns ein Träger war, auch Wege prüfen
 
803
            if(job == JOB_HELPER && real_goods.people[JOB_HELPER] == 1)
 
804
            {
 
805
                // evtl als Träger auf Straßen schicken
 
806
                gwg->GetPlayer(player)->FindWarehouseForAllRoads();
 
807
                // evtl Träger mit Werkzeug kombiniert -> neuer Beruf
 
808
                gwg->GetPlayer(player)->FindWarehouseForAllJobs(JOB_NOTHING);
 
809
            }
 
810
 
 
811
        }
 
812
    }
 
813
 
 
814
    // Evtl den Typen gleich wieder auslagern, falls erforderlich
 
815
    CheckOuthousing(1, job);
816
816
}
817
817
 
818
 
void nobBaseWarehouse::AddFigure(noFigure * figure, const bool increase_visual_counts)
 
818
void nobBaseWarehouse::AddFigure(noFigure* figure, const bool increase_visual_counts)
819
819
{
820
 
        // Warenhausarbeiter werden nicht gezählt!
821
 
        if(!figure->MemberOfWarehouse())
822
 
        {
823
 
                // War das ein Boot-Träger?
824
 
                if(figure->GetJobType() == JOB_BOATCARRIER)
825
 
                {
826
 
                        // Träger hinzufügen einzeln
827
 
                        if(increase_visual_counts) ++goods.people[JOB_HELPER];
828
 
                        ++real_goods.people[JOB_HELPER];
829
 
                        // Boot hinzufügen einzeln
830
 
                        if(increase_visual_counts) ++goods.goods[GD_BOAT];
831
 
                        ++real_goods.goods[GD_BOAT];
832
 
                }
833
 
                else
834
 
                {
835
 
                        if(increase_visual_counts) ++goods.people[figure->GetJobType()];
836
 
                        ++real_goods.people[figure->GetJobType()];
837
 
                }
838
 
        }
839
 
        
840
 
        RemoveDependentFigure(figure);
841
 
        em->AddToKillList(figure);
842
 
 
843
 
        CheckJobsForNewFigure(figure->GetJobType());
 
820
    // Warenhausarbeiter werden nicht gezählt!
 
821
    if(!figure->MemberOfWarehouse())
 
822
    {
 
823
        // War das ein Boot-Träger?
 
824
        if(figure->GetJobType() == JOB_BOATCARRIER)
 
825
        {
 
826
            // Träger hinzufügen einzeln
 
827
            if(increase_visual_counts) ++goods.people[JOB_HELPER];
 
828
            ++real_goods.people[JOB_HELPER];
 
829
            // Boot hinzufügen einzeln
 
830
            if(increase_visual_counts) ++goods.goods[GD_BOAT];
 
831
            ++real_goods.goods[GD_BOAT];
 
832
        }
 
833
        else
 
834
        {
 
835
            if(increase_visual_counts) ++goods.people[figure->GetJobType()];
 
836
            ++real_goods.people[figure->GetJobType()];
 
837
        }
 
838
    }
 
839
 
 
840
    RemoveDependentFigure(figure);
 
841
    em->AddToKillList(figure);
 
842
 
 
843
    CheckJobsForNewFigure(figure->GetJobType());
844
844
}
845
845
 
846
846
void nobBaseWarehouse::FetchWare()
847
847
{
848
 
        if(!fetch_double_protection)
849
 
        {
850
 
                AddLeavingFigure(new nofWarehouseWorker(x,y,player,0,1));
851
 
                /*gwg->AddFigure(worker,x,y);
852
 
                worker->ActAtFirst();*/
853
 
        }
854
 
 
855
 
        fetch_double_protection = false;
856
 
}
857
 
 
858
 
void nobBaseWarehouse::WareLost(Ware * ware)
859
 
{
860
 
        RemoveDependentWare(ware);
861
 
}
862
 
 
863
 
void nobBaseWarehouse::CancelWare(Ware * ware)
864
 
{
865
 
        // Ware aus den Waiting-Wares entfernen
866
 
        waiting_wares.erase(ware);
867
 
        // Anzahl davon wieder hochsetzen
868
 
        ++real_goods.goods[ConvertShields(ware->type)];
 
848
    if(!fetch_double_protection)
 
849
    {
 
850
        AddLeavingFigure(new nofWarehouseWorker(x, y, player, 0, 1));
 
851
        /*gwg->AddFigure(worker,x,y);
 
852
        worker->ActAtFirst();*/
 
853
    }
 
854
 
 
855
    fetch_double_protection = false;
 
856
}
 
857
 
 
858
void nobBaseWarehouse::WareLost(Ware* ware)
 
859
{
 
860
    RemoveDependentWare(ware);
 
861
}
 
862
 
 
863
void nobBaseWarehouse::CancelWare(Ware* ware)
 
864
{
 
865
    // Ware aus den Waiting-Wares entfernen
 
866
    waiting_wares.erase(ware);
 
867
    // Anzahl davon wieder hochsetzen
 
868
    ++real_goods.goods[ConvertShields(ware->type)];
869
869
}
870
870
 
871
871
/// Bestellte Figur, die sich noch inder Warteschlange befindet, kommt nicht mehr und will rausgehauen werden
872
 
void nobBaseWarehouse::CancelFigure(noFigure * figure)
873
 
{
874
 
        // Figure aus den Waiting-Wares entfernen
875
 
        leave_house.erase(std::find(leave_house.begin(),leave_house.end(),figure));
876
 
        //leave_house.erase(figure);
877
 
        AddFigure(figure,false);
878
 
}
879
 
 
880
 
void nobBaseWarehouse::TakeWare(Ware * ware)
881
 
{
882
 
        // Ware zur Abhängigkeitsliste hinzufügen, damit sie benachrichtigt wird, wenn dieses Lagerhaus zerstört wird
883
 
        dependent_wares.push_back(ware);
884
 
}
885
 
 
886
 
void nobBaseWarehouse::OrderTroops(nobMilitary * goal, unsigned count)
887
 
{
888
 
        // Soldaten durchgehen und count rausschicken
889
 
 
890
 
        // Ränge durchgehen, absteigend, starke zuerst
891
 
        if (gwg->GetPlayer(player)->military_settings[1] >= MILITARY_SETTINGS_SCALE[1]/2)
892
 
        {
893
 
                for(unsigned i = 5;i && count;--i)
894
 
                {
895
 
                        // Vertreter der Ränge ggf rausschicken
896
 
                        while(real_goods.people[JOB_PRIVATE-1+i] && count)
897
 
                        {
898
 
                                nofSoldier * soldier = new nofPassiveSoldier(x,y,player,goal,goal,i-1);
899
 
                                AddLeavingFigure(soldier);
900
 
                                goal->GotWorker(JOB_NOTHING,soldier);
901
 
 
902
 
                                --real_goods.people[JOB_PRIVATE-1+i];
903
 
 
904
 
                                --count;
905
 
                        }
906
 
                }
907
 
        }
908
 
        // Ränge durchgehen, aufsteigend, schwache zuerst
909
 
        else
910
 
        {
911
 
                for(unsigned i = 1;i<=5 && count;++i)
912
 
                {
913
 
                        // Vertreter der Ränge ggf rausschicken
914
 
                        while(real_goods.people[JOB_PRIVATE-1+i] && count)
915
 
                        {
916
 
                                nofSoldier * soldier = new nofPassiveSoldier(x,y,player,goal,goal,i-1);
917
 
                                AddLeavingFigure(soldier);
918
 
                                goal->GotWorker(JOB_NOTHING,soldier);
919
 
 
920
 
                                --real_goods.people[JOB_PRIVATE-1+i];
921
 
 
922
 
                                --count;
923
 
                        }
924
 
                }
925
 
        }
926
 
        
927
 
}
928
 
 
929
 
nofAggressiveDefender * nobBaseWarehouse::SendDefender(nofAttacker * attacker)
930
 
{
931
 
        // Sind noch Soldaten da?
932
 
        unsigned char rank;
933
 
        for(rank = 5;rank;--rank)
934
 
        {
935
 
                if(real_goods.people[JOB_PRIVATE+rank-1])
936
 
                        break;
937
 
        }
938
 
 
939
 
        // Wenn kein Soldat mehr da ist --> 0 zurückgeben
940
 
        if(!rank)
941
 
                return 0;
942
 
 
943
 
        // Dann den Stärksten rausschicken
944
 
        nofAggressiveDefender * soldier = new nofAggressiveDefender(x,y,player,this,rank-1,attacker);
945
 
        --real_goods.people[JOB_PRIVATE+rank-1];
946
 
        AddLeavingFigure(soldier);
947
 
 
948
 
        troops_on_mission.push_back(soldier);
949
 
 
950
 
        return soldier;
951
 
}
952
 
 
953
 
void nobBaseWarehouse::SoldierLost(nofSoldier * soldier)
954
 
{
955
 
        // Soldat konnte nicht (mehr) kommen --> rauswerfen
956
 
        troops_on_mission.erase(static_cast<nofActiveSoldier*>(soldier));
957
 
}
958
 
 
959
 
void nobBaseWarehouse::AddActiveSoldier(nofActiveSoldier * soldier)
960
 
{
961
 
        // Soldat hinzufügen
962
 
        ++real_goods.people[JOB_PRIVATE+soldier->GetRank()];
963
 
        ++goods.people[JOB_PRIVATE+soldier->GetRank()];
964
 
        
965
 
        // Evtl. geht der Soldat wieder in die Reserve
966
 
        RefreshReserve(soldier->GetRank());
967
 
 
968
 
        // Truppen prüfen in allen Häusern
969
 
        gwg->GetPlayer(player)->RegulateAllTroops();
970
 
 
971
 
        // und Soldat vernichten
972
 
        em->AddToKillList(soldier);
973
 
        
974
 
        // Ggf. war er auf Mission
975
 
        troops_on_mission.erase(soldier);
976
 
}
977
 
 
978
 
nofDefender * nobBaseWarehouse::ProvideDefender(nofAttacker * const attacker)
979
 
{
980
 
        // Ränge zählen
981
 
        unsigned rank_count = 0;
982
 
 
983
 
        for(unsigned i = 0;i<5;++i)
984
 
        {
985
 
                if(real_goods.people[JOB_PRIVATE+i] || reserve_soldiers_available[i])
986
 
                        ++rank_count;
987
 
        }
988
 
 
989
 
 
990
 
        if(rank_count)
991
 
        {
992
 
                // Gewünschten Rang an Hand der Militäreinstellungen ausrechnen, je nachdem wie stark verteidigt werden soll
993
 
                unsigned rank = (rank_count-1)*gwg->GetPlayer(player)->military_settings[1]/MILITARY_SETTINGS_SCALE[1];
994
 
 
995
 
                // Gewünschten Rang suchen
996
 
                unsigned r = 0;
997
 
                for(unsigned i = 0;i<5;++i)
998
 
                {
999
 
                        
1000
 
                        // anderere Soldaten bevorzugen
1001
 
                        if(real_goods.people[JOB_PRIVATE+i])
1002
 
                        {
1003
 
                                if(r == rank)
1004
 
                                {
1005
 
                                        // diesen Soldaten wollen wir
1006
 
                                        --real_goods.people[JOB_PRIVATE+i];
1007
 
                                        nofDefender * soldier = new nofDefender(x,y,player,this,i,attacker);
1008
 
                                        return soldier;
1009
 
                                }
1010
 
 
1011
 
                                ++r;
1012
 
                        }
1013
 
                        // Reserve
1014
 
                        else if(reserve_soldiers_available[i])
1015
 
                        {
1016
 
                                if(r == rank)
1017
 
                                {
1018
 
                                        // diesen Soldaten wollen wir
1019
 
                                        --reserve_soldiers_available[i];
1020
 
                                        // bei der visuellen Warenanzahl wieder hinzufügen, da er dann wiederrum von der abgezogen wird, wenn
1021
 
                                        // er rausgeht und es so ins minus rutschen würde
1022
 
                                        ++goods.people[JOB_PRIVATE+i];
1023
 
                                        nofDefender * soldier = new nofDefender(x,y,player,this,i,attacker);
1024
 
                                        return soldier;
1025
 
 
1026
 
                                }
1027
 
 
1028
 
                                ++r;
1029
 
                        }
1030
 
                        
1031
 
                }
1032
 
        }
1033
 
 
1034
 
        // Kein Soldat gefunden, als letzten Hoffnung die Soldaten nehmen, die ggf in der Warteschlange noch hängen
1035
 
        for(std::list<noFigure*>::iterator it = leave_house.begin();it!=leave_house.end();++it)
1036
 
        {
1037
 
                // Soldat?
1038
 
                if((*it)->GetGOT() == GOT_NOF_AGGRESSIVEDEFENDER)
1039
 
                {
1040
 
                        static_cast<nofAggressiveDefender*>(*it)->NeedForHomeDefence();
1041
 
                        // Aus Missionsliste raushauen
1042
 
                        troops_on_mission.erase(static_cast<nofAggressiveDefender*>(*it));
1043
 
 
1044
 
                        nofDefender * soldier = new nofDefender(x,y,player,this,static_cast<nofAggressiveDefender*>(*it)->GetRank(),attacker);
1045
 
                        (*it)->Destroy();
1046
 
                        delete *it;
1047
 
                        leave_house.erase(it);
1048
 
                        //leave_house.erase(&it);
1049
 
                        return soldier;
1050
 
                }
1051
 
                else if((*it)->GetGOT() == GOT_NOF_PASSIVESOLDIER)
1052
 
                {
1053
 
                        (*it)->Abrogate();
1054
 
                        nofDefender * soldier = new nofDefender(x,y,player,this,static_cast<nofPassiveSoldier*>(*it)->GetRank(),attacker);
1055
 
                        (*it)->Destroy();
1056
 
                        delete *it;
1057
 
                        leave_house.erase(it);
1058
 
                        //leave_house.erase(&it);
1059
 
                        return soldier;
1060
 
                }
1061
 
        }
1062
 
 
1063
 
        return 0;
 
872
void nobBaseWarehouse::CancelFigure(noFigure* figure)
 
873
{
 
874
    // Figure aus den Waiting-Wares entfernen
 
875
    leave_house.erase(std::find(leave_house.begin(), leave_house.end(), figure));
 
876
    //leave_house.erase(figure);
 
877
    AddFigure(figure, false);
 
878
}
 
879
 
 
880
void nobBaseWarehouse::TakeWare(Ware* ware)
 
881
{
 
882
    // Ware zur Abhängigkeitsliste hinzufügen, damit sie benachrichtigt wird, wenn dieses Lagerhaus zerstört wird
 
883
    dependent_wares.push_back(ware);
 
884
}
 
885
 
 
886
void nobBaseWarehouse::OrderTroops(nobMilitary* goal, unsigned count)
 
887
{
 
888
    // Soldaten durchgehen und count rausschicken
 
889
 
 
890
    // Ränge durchgehen, absteigend, starke zuerst
 
891
    if (gwg->GetPlayer(player)->military_settings[1] >= MILITARY_SETTINGS_SCALE[1] / 2)
 
892
    {
 
893
        for(unsigned i = 5; i && count; --i)
 
894
        {
 
895
            // Vertreter der Ränge ggf rausschicken
 
896
            while(real_goods.people[JOB_PRIVATE - 1 + i] && count)
 
897
            {
 
898
                nofSoldier* soldier = new nofPassiveSoldier(x, y, player, goal, goal, i - 1);
 
899
                AddLeavingFigure(soldier);
 
900
                goal->GotWorker(JOB_NOTHING, soldier);
 
901
 
 
902
                --real_goods.people[JOB_PRIVATE - 1 + i];
 
903
 
 
904
                --count;
 
905
            }
 
906
        }
 
907
    }
 
908
    // Ränge durchgehen, aufsteigend, schwache zuerst
 
909
    else
 
910
    {
 
911
        for(unsigned i = 1; i <= 5 && count; ++i)
 
912
        {
 
913
            // Vertreter der Ränge ggf rausschicken
 
914
            while(real_goods.people[JOB_PRIVATE - 1 + i] && count)
 
915
            {
 
916
                nofSoldier* soldier = new nofPassiveSoldier(x, y, player, goal, goal, i - 1);
 
917
                AddLeavingFigure(soldier);
 
918
                goal->GotWorker(JOB_NOTHING, soldier);
 
919
 
 
920
                --real_goods.people[JOB_PRIVATE - 1 + i];
 
921
 
 
922
                --count;
 
923
            }
 
924
        }
 
925
    }
 
926
 
 
927
}
 
928
 
 
929
nofAggressiveDefender* nobBaseWarehouse::SendDefender(nofAttacker* attacker)
 
930
{
 
931
    // Sind noch Soldaten da?
 
932
    unsigned char rank;
 
933
    for(rank = 5; rank; --rank)
 
934
    {
 
935
        if(real_goods.people[JOB_PRIVATE + rank - 1])
 
936
            break;
 
937
    }
 
938
 
 
939
    // Wenn kein Soldat mehr da ist --> 0 zurückgeben
 
940
    if(!rank)
 
941
        return 0;
 
942
 
 
943
    // Dann den Stärksten rausschicken
 
944
    nofAggressiveDefender* soldier = new nofAggressiveDefender(x, y, player, this, rank - 1, attacker);
 
945
    --real_goods.people[JOB_PRIVATE + rank - 1];
 
946
    AddLeavingFigure(soldier);
 
947
 
 
948
    troops_on_mission.push_back(soldier);
 
949
 
 
950
    return soldier;
 
951
}
 
952
 
 
953
void nobBaseWarehouse::SoldierLost(nofSoldier* soldier)
 
954
{
 
955
    // Soldat konnte nicht (mehr) kommen --> rauswerfen
 
956
    troops_on_mission.erase(static_cast<nofActiveSoldier*>(soldier));
 
957
}
 
958
 
 
959
void nobBaseWarehouse::AddActiveSoldier(nofActiveSoldier* soldier)
 
960
{
 
961
    // Soldat hinzufügen
 
962
    ++real_goods.people[JOB_PRIVATE + soldier->GetRank()];
 
963
    ++goods.people[JOB_PRIVATE + soldier->GetRank()];
 
964
 
 
965
    // Evtl. geht der Soldat wieder in die Reserve
 
966
    RefreshReserve(soldier->GetRank());
 
967
 
 
968
    // Truppen prüfen in allen Häusern
 
969
    gwg->GetPlayer(player)->RegulateAllTroops();
 
970
 
 
971
    // und Soldat vernichten
 
972
    em->AddToKillList(soldier);
 
973
 
 
974
    // Ggf. war er auf Mission
 
975
    troops_on_mission.erase(soldier);
 
976
}
 
977
 
 
978
nofDefender* nobBaseWarehouse::ProvideDefender(nofAttacker* const attacker)
 
979
{
 
980
    // Ränge zählen
 
981
    unsigned rank_count = 0;
 
982
 
 
983
    for(unsigned i = 0; i < 5; ++i)
 
984
    {
 
985
        if(real_goods.people[JOB_PRIVATE + i] || reserve_soldiers_available[i])
 
986
            ++rank_count;
 
987
    }
 
988
 
 
989
 
 
990
    if(rank_count)
 
991
    {
 
992
        // Gewünschten Rang an Hand der Militäreinstellungen ausrechnen, je nachdem wie stark verteidigt werden soll
 
993
        unsigned rank = (rank_count - 1) * gwg->GetPlayer(player)->military_settings[1] / MILITARY_SETTINGS_SCALE[1];
 
994
 
 
995
        // Gewünschten Rang suchen
 
996
        unsigned r = 0;
 
997
        for(unsigned i = 0; i < 5; ++i)
 
998
        {
 
999
 
 
1000
            // anderere Soldaten bevorzugen
 
1001
            if(real_goods.people[JOB_PRIVATE + i])
 
1002
            {
 
1003
                if(r == rank)
 
1004
                {
 
1005
                    // diesen Soldaten wollen wir
 
1006
                    --real_goods.people[JOB_PRIVATE + i];
 
1007
                    nofDefender* soldier = new nofDefender(x, y, player, this, i, attacker);
 
1008
                    return soldier;
 
1009
                }
 
1010
 
 
1011
                ++r;
 
1012
            }
 
1013
            // Reserve
 
1014
            else if(reserve_soldiers_available[i])
 
1015
            {
 
1016
                if(r == rank)
 
1017
                {
 
1018
                    // diesen Soldaten wollen wir
 
1019
                    --reserve_soldiers_available[i];
 
1020
                    // bei der visuellen Warenanzahl wieder hinzufügen, da er dann wiederrum von der abgezogen wird, wenn
 
1021
                    // er rausgeht und es so ins minus rutschen würde
 
1022
                    ++goods.people[JOB_PRIVATE + i];
 
1023
                    nofDefender* soldier = new nofDefender(x, y, player, this, i, attacker);
 
1024
                    return soldier;
 
1025
 
 
1026
                }
 
1027
 
 
1028
                ++r;
 
1029
            }
 
1030
 
 
1031
        }
 
1032
    }
 
1033
 
 
1034
    // Kein Soldat gefunden, als letzten Hoffnung die Soldaten nehmen, die ggf in der Warteschlange noch hängen
 
1035
    for(std::list<noFigure*>::iterator it = leave_house.begin(); it != leave_house.end(); ++it)
 
1036
    {
 
1037
        // Soldat?
 
1038
        if((*it)->GetGOT() == GOT_NOF_AGGRESSIVEDEFENDER)
 
1039
        {
 
1040
            static_cast<nofAggressiveDefender*>(*it)->NeedForHomeDefence();
 
1041
            // Aus Missionsliste raushauen
 
1042
            troops_on_mission.erase(static_cast<nofAggressiveDefender*>(*it));
 
1043
 
 
1044
            nofDefender* soldier = new nofDefender(x, y, player, this, static_cast<nofAggressiveDefender*>(*it)->GetRank(), attacker);
 
1045
            (*it)->Destroy();
 
1046
            delete *it;
 
1047
            leave_house.erase(it);
 
1048
            //leave_house.erase(&it);
 
1049
            return soldier;
 
1050
        }
 
1051
        else if((*it)->GetGOT() == GOT_NOF_PASSIVESOLDIER)
 
1052
        {
 
1053
            (*it)->Abrogate();
 
1054
            nofDefender* soldier = new nofDefender(x, y, player, this, static_cast<nofPassiveSoldier*>(*it)->GetRank(), attacker);
 
1055
            (*it)->Destroy();
 
1056
            delete *it;
 
1057
            leave_house.erase(it);
 
1058
            //leave_house.erase(&it);
 
1059
            return soldier;
 
1060
        }
 
1061
    }
 
1062
 
 
1063
    return 0;
1064
1064
 
1065
1065
}
1066
1066
 
1067
1067
 
1068
1068
bool nobBaseWarehouse::AreRecruitingConditionsComply()
1069
1069
{
1070
 
        // Mindestanzahl der Gehilfen die vorhanden sein müssen anhand der 1. Militäreinstellung ausrechnen
1071
 
        unsigned needed_helpers = 100-10*gwg->GetPlayer(player)->military_settings[0];
1072
 
 
1073
 
        // einer muss natürlich mindestens vorhanden sein!
1074
 
        if(!needed_helpers) needed_helpers = 1;
1075
 
 
1076
 
        // Wenn alle Bedingungen erfüllt sind, Event anmelden
1077
 
        return (real_goods.people[JOB_HELPER] >= needed_helpers && real_goods.goods[GD_SWORD]
1078
 
        && real_goods.goods[GD_SHIELDROMANS] && real_goods.goods[GD_BEER]);
 
1070
    // Mindestanzahl der Gehilfen die vorhanden sein müssen anhand der 1. Militäreinstellung ausrechnen
 
1071
    unsigned needed_helpers = 100 - 10 * gwg->GetPlayer(player)->military_settings[0];
 
1072
 
 
1073
    // einer muss natürlich mindestens vorhanden sein!
 
1074
    if(!needed_helpers) needed_helpers = 1;
 
1075
 
 
1076
    // Wenn alle Bedingungen erfüllt sind, Event anmelden
 
1077
    return (real_goods.people[JOB_HELPER] >= needed_helpers && real_goods.goods[GD_SWORD]
 
1078
            && real_goods.goods[GD_SHIELDROMANS] && real_goods.goods[GD_BEER]);
1079
1079
}
1080
1080
 
1081
1081
 
1082
1082
void nobBaseWarehouse::TryRecruiting()
1083
1083
{
1084
 
        // Wenn noch kein Event angemeldet wurde und alle Bedingungen erfüllt sind, kann ein neues angemeldet werden
1085
 
        if(!recruiting_event)
1086
 
        {
1087
 
                if(AreRecruitingConditionsComply())
1088
 
                        recruiting_event = em->AddEvent(this,RECRUITE_GF+RANDOM.Rand(__FILE__,__LINE__,obj_id,RECRUITE_RANDOM_GF),2);
1089
 
        }
 
1084
    // Wenn noch kein Event angemeldet wurde und alle Bedingungen erfüllt sind, kann ein neues angemeldet werden
 
1085
    if(!recruiting_event)
 
1086
    {
 
1087
        if(AreRecruitingConditionsComply())
 
1088
            recruiting_event = em->AddEvent(this, RECRUITE_GF + RANDOM.Rand(__FILE__, __LINE__, obj_id, RECRUITE_RANDOM_GF), 2);
 
1089
    }
1090
1090
}
1091
1091
 
1092
1092
void nobBaseWarehouse::TryStopRecruiting()
1093
1093
{
1094
 
        // Wenn ein Event angemeldet wurde und die Bedingungen nicht mehr erfüllt sind, muss es wieder vernichtet werden
1095
 
        if(recruiting_event)
1096
 
        {
1097
 
                if(!AreRecruitingConditionsComply())
1098
 
                {
1099
 
                        em->RemoveEvent(recruiting_event);
1100
 
                        recruiting_event = 0;
1101
 
                }
1102
 
        }
1103
 
}
1104
 
 
1105
 
 
1106
 
bool FW::Condition_Ware(nobBaseWarehouse * wh, const void * param)
1107
 
{
1108
 
        return (wh->GetRealWaresCount(static_cast<const Param_Ware*>(param)->type) >= static_cast<const Param_Ware*>(param)->count);
1109
 
}
1110
 
 
1111
 
bool FW::Condition_Job(nobBaseWarehouse * wh, const void * param)
1112
 
{
1113
 
        if(wh->GetRealFiguresCount(static_cast<const Param_Job*>(param)->type) >= static_cast<const Param_Job*>(param)->count)
1114
 
                return true;
1115
 
        else
1116
 
        {
1117
 
                // die entsprechende Figur ist nicht vorhanden, wenn das Werkzeug der Figur und ein Mann (Träger) zum Rekrutieren
1118
 
                // da ist, geht das auch, nur bei Eseln nicht !!
1119
 
                bool tool_available = (JOB_CONSTS[static_cast<const Param_Job*>(param)->type].tool != GD_NOTHING) ? 
1120
 
                        (wh->GetRealWaresCount(JOB_CONSTS[static_cast<const Param_Job*>(param)->type].tool)>0) : true;
1121
 
 
1122
 
                if(static_cast<const Param_Job*>(param)->type == JOB_PACKDONKEY)
1123
 
                        tool_available = false;
1124
 
 
1125
 
                if( wh->GetRealFiguresCount(JOB_HELPER) && tool_available)
1126
 
                        return true;
1127
 
 
1128
 
                return false;
1129
 
        }
1130
 
}
1131
 
 
1132
 
 
1133
 
 
1134
 
bool FW::Condition_WareAndJob(nobBaseWarehouse * wh, const void * param)
1135
 
{
1136
 
        return (Condition_Ware(wh,&static_cast<const Param_WareAndJob*>(param)->ware) &&
1137
 
                Condition_Job(wh,&static_cast<const Param_WareAndJob*>(param)->job));
1138
 
}
1139
 
 
1140
 
bool FW::Condition_Troops(nobBaseWarehouse * wh, const void * param)
1141
 
{
1142
 
        return (wh->GetSoldiersCount() >= *static_cast<const unsigned*>(param));
1143
 
}
1144
 
 
1145
 
bool FW::NoCondition(nobBaseWarehouse * wh, const void * param)
1146
 
{
1147
 
        return true;
1148
 
}
1149
 
 
1150
 
bool FW::Condition_StoreWare(nobBaseWarehouse * wh, const void * param)
1151
 
{
1152
 
        // Einlagern darf nicht verboten sein
1153
 
        // Schilder beachten!
1154
 
        if(*static_cast<const GoodType*>(param) == GD_SHIELDVIKINGS || *static_cast<const GoodType*>(param) == GD_SHIELDAFRICANS || 
1155
 
                *static_cast<const GoodType*>(param) == GD_SHIELDJAPANESE)
1156
 
                return (!wh->CheckRealInventorySettings(0,2,GD_SHIELDROMANS));
1157
 
        else
1158
 
                return (!wh->CheckRealInventorySettings(0,2,*static_cast<const GoodType*>(param)));
1159
 
}
1160
 
 
1161
 
 
1162
 
bool FW::Condition_StoreFigure(nobBaseWarehouse * wh, const void * param)
1163
 
{
1164
 
        // Einlagern darf nicht verboten sein, Bootstypen zu normalen Trägern machen
1165
 
        if(*static_cast<const Job*>(param) == JOB_BOATCARRIER)
1166
 
                return (!wh->CheckRealInventorySettings(1,2,JOB_HELPER));
1167
 
        else
1168
 
                return (!wh->CheckRealInventorySettings(1,2,*static_cast<const Job*>(param)));
1169
 
}
1170
 
 
1171
 
bool FW::Condition_WantStoreFigure(nobBaseWarehouse * wh, const void * param)
1172
 
{
1173
 
        // Einlagern muss gewollt sein
1174
 
        Job job = (*static_cast<const Job*>(param) == JOB_BOATCARRIER) ? JOB_HELPER : *static_cast<const Job*>(param);
1175
 
        return (wh->CheckRealInventorySettings(1,8,job));
1176
 
}
1177
 
 
1178
 
bool FW::Condition_WantStoreWare(nobBaseWarehouse * wh, const void * param)
1179
 
{
1180
 
        // Einlagern muss gewollt sein
1181
 
        // Schilder beachten!
1182
 
        GoodType gt = ConvertShields(*static_cast<const GoodType*>(param));
1183
 
        return (wh->CheckRealInventorySettings(0,8,gt));
 
1094
    // Wenn ein Event angemeldet wurde und die Bedingungen nicht mehr erfüllt sind, muss es wieder vernichtet werden
 
1095
    if(recruiting_event)
 
1096
    {
 
1097
        if(!AreRecruitingConditionsComply())
 
1098
        {
 
1099
            em->RemoveEvent(recruiting_event);
 
1100
            recruiting_event = 0;
 
1101
        }
 
1102
    }
 
1103
}
 
1104
 
 
1105
 
 
1106
bool FW::Condition_Ware(nobBaseWarehouse* wh, const void* param)
 
1107
{
 
1108
    return (wh->GetRealWaresCount(static_cast<const Param_Ware*>(param)->type) >= static_cast<const Param_Ware*>(param)->count);
 
1109
}
 
1110
 
 
1111
bool FW::Condition_Job(nobBaseWarehouse* wh, const void* param)
 
1112
{
 
1113
    if(wh->GetRealFiguresCount(static_cast<const Param_Job*>(param)->type) >= static_cast<const Param_Job*>(param)->count)
 
1114
        return true;
 
1115
    else
 
1116
    {
 
1117
        // die entsprechende Figur ist nicht vorhanden, wenn das Werkzeug der Figur und ein Mann (Träger) zum Rekrutieren
 
1118
        // da ist, geht das auch, nur bei Eseln nicht !!
 
1119
        bool tool_available = (JOB_CONSTS[static_cast<const Param_Job*>(param)->type].tool != GD_NOTHING) ?
 
1120
                              (wh->GetRealWaresCount(JOB_CONSTS[static_cast<const Param_Job*>(param)->type].tool) > 0) : true;
 
1121
 
 
1122
        if(static_cast<const Param_Job*>(param)->type == JOB_PACKDONKEY)
 
1123
            tool_available = false;
 
1124
 
 
1125
        if( wh->GetRealFiguresCount(JOB_HELPER) && tool_available)
 
1126
            return true;
 
1127
 
 
1128
        return false;
 
1129
    }
 
1130
}
 
1131
 
 
1132
 
 
1133
 
 
1134
bool FW::Condition_WareAndJob(nobBaseWarehouse* wh, const void* param)
 
1135
{
 
1136
    return (Condition_Ware(wh, &static_cast<const Param_WareAndJob*>(param)->ware) &&
 
1137
            Condition_Job(wh, &static_cast<const Param_WareAndJob*>(param)->job));
 
1138
}
 
1139
 
 
1140
bool FW::Condition_Troops(nobBaseWarehouse* wh, const void* param)
 
1141
{
 
1142
    return (wh->GetSoldiersCount() >= *static_cast<const unsigned*>(param));
 
1143
}
 
1144
 
 
1145
bool FW::NoCondition(nobBaseWarehouse* wh, const void* param)
 
1146
{
 
1147
    return true;
 
1148
}
 
1149
 
 
1150
bool FW::Condition_StoreWare(nobBaseWarehouse* wh, const void* param)
 
1151
{
 
1152
    // Einlagern darf nicht verboten sein
 
1153
    // Schilder beachten!
 
1154
    if(*static_cast<const GoodType*>(param) == GD_SHIELDVIKINGS || *static_cast<const GoodType*>(param) == GD_SHIELDAFRICANS ||
 
1155
            *static_cast<const GoodType*>(param) == GD_SHIELDJAPANESE)
 
1156
        return (!wh->CheckRealInventorySettings(0, 2, GD_SHIELDROMANS));
 
1157
    else
 
1158
        return (!wh->CheckRealInventorySettings(0, 2, *static_cast<const GoodType*>(param)));
 
1159
}
 
1160
 
 
1161
 
 
1162
bool FW::Condition_StoreFigure(nobBaseWarehouse* wh, const void* param)
 
1163
{
 
1164
    // Einlagern darf nicht verboten sein, Bootstypen zu normalen Trägern machen
 
1165
    if(*static_cast<const Job*>(param) == JOB_BOATCARRIER)
 
1166
        return (!wh->CheckRealInventorySettings(1, 2, JOB_HELPER));
 
1167
    else
 
1168
        return (!wh->CheckRealInventorySettings(1, 2, *static_cast<const Job*>(param)));
 
1169
}
 
1170
 
 
1171
bool FW::Condition_WantStoreFigure(nobBaseWarehouse* wh, const void* param)
 
1172
{
 
1173
    // Einlagern muss gewollt sein
 
1174
    Job job = (*static_cast<const Job*>(param) == JOB_BOATCARRIER) ? JOB_HELPER : *static_cast<const Job*>(param);
 
1175
    return (wh->CheckRealInventorySettings(1, 8, job));
 
1176
}
 
1177
 
 
1178
bool FW::Condition_WantStoreWare(nobBaseWarehouse* wh, const void* param)
 
1179
{
 
1180
    // Einlagern muss gewollt sein
 
1181
    // Schilder beachten!
 
1182
    GoodType gt = ConvertShields(*static_cast<const GoodType*>(param));
 
1183
    return (wh->CheckRealInventorySettings(0, 8, gt));
1184
1184
}
1185
1185
 
1186
1186
// Lagerhäuser enthalten die jeweilien Waren, liefern sie aber NICHT gleichzeitig ein
1187
 
bool FW::Condition_StoreAndDontWantWare(nobBaseWarehouse * wh, const void * param)
 
1187
bool FW::Condition_StoreAndDontWantWare(nobBaseWarehouse* wh, const void* param)
1188
1188
{
1189
 
        Param_Ware pw = { *static_cast<const GoodType*>(param), 1 };
1190
 
        return (Condition_Ware(wh,&pw) && !Condition_WantStoreWare(wh,param));
 
1189
    Param_Ware pw = { *static_cast<const GoodType*>(param), 1 };
 
1190
    return (Condition_Ware(wh, &pw) && !Condition_WantStoreWare(wh, param));
1191
1191
}// param = &GoodType -> Warentyp
1192
1192
 
1193
1193
// Warehouse does not collect the job and has job in store
1194
 
bool FW::Condition_StoreAndDontWantFigure(nobBaseWarehouse * wh, const void * param)
 
1194
bool FW::Condition_StoreAndDontWantFigure(nobBaseWarehouse* wh, const void* param)
1195
1195
{
1196
 
        Job job = *static_cast<const Job*>(param);
1197
 
        return ((wh->GetRealFiguresCount(job) >= 1) && !Condition_WantStoreFigure(wh,param));
 
1196
    Job job = *static_cast<const Job*>(param);
 
1197
    return ((wh->GetRealFiguresCount(job) >= 1) && !Condition_WantStoreFigure(wh, param));
1198
1198
}
1199
1199
// param = &Job -> Jobtyp
1200
1200
 
1201
1201
 
1202
1202
 
1203
 
const Goods *nobBaseWarehouse::GetInventory() const
 
1203
const Goods* nobBaseWarehouse::GetInventory() const
1204
1204
{
1205
 
        return &goods;
 
1205
    return &goods;
1206
1206
}
1207
1207
 
1208
1208
/// Fügt einige Güter hinzu
1209
1209
void nobBaseWarehouse::AddGoods(const Goods goods)
1210
1210
{
1211
 
        for(unsigned int i = 0; i < WARE_TYPES_COUNT; ++i)
1212
 
        {
1213
 
                this->goods.goods[i] += goods.goods[i];
1214
 
                this->real_goods.goods[i] += goods.goods[i];
1215
 
 
1216
 
                if(goods.goods[i])
1217
 
                        CheckUsesForNewWare(GoodType(i));
1218
 
        }
1219
 
 
1220
 
        for(unsigned int i = 0; i < JOB_TYPES_COUNT; ++i)
1221
 
        {
1222
 
                this->goods.people[i] += goods.people[i];
1223
 
                this->real_goods.people[i] += goods.people[i];
1224
 
 
1225
 
                if(goods.people[i])
1226
 
                        CheckJobsForNewFigure(Job(i));
1227
 
        }
 
1211
    for(unsigned int i = 0; i < WARE_TYPES_COUNT; ++i)
 
1212
    {
 
1213
        this->goods.goods[i] += goods.goods[i];
 
1214
        this->real_goods.goods[i] += goods.goods[i];
 
1215
 
 
1216
        if(goods.goods[i])
 
1217
            CheckUsesForNewWare(GoodType(i));
 
1218
    }
 
1219
 
 
1220
    for(unsigned int i = 0; i < JOB_TYPES_COUNT; ++i)
 
1221
    {
 
1222
        this->goods.people[i] += goods.people[i];
 
1223
        this->real_goods.people[i] += goods.people[i];
 
1224
 
 
1225
        if(goods.people[i])
 
1226
            CheckJobsForNewFigure(Job(i));
 
1227
    }
1228
1228
}
1229
1229
 
1230
1230
void nobBaseWarehouse::AddToInventory()
1231
1231
{
1232
 
        for(unsigned int i = 0; i < WARE_TYPES_COUNT; ++i)
1233
 
                gwg->GetPlayer(player)->IncreaseInventoryWare(GoodType(i),real_goods.goods[i]);
 
1232
    for(unsigned int i = 0; i < WARE_TYPES_COUNT; ++i)
 
1233
        gwg->GetPlayer(player)->IncreaseInventoryWare(GoodType(i), real_goods.goods[i]);
1234
1234
 
1235
 
        for(unsigned int i = 0; i < JOB_TYPES_COUNT; ++i)
1236
 
                gwg->GetPlayer(player)->IncreaseInventoryJob(Job(i),real_goods.people[i]);
 
1235
    for(unsigned int i = 0; i < JOB_TYPES_COUNT; ++i)
 
1236
        gwg->GetPlayer(player)->IncreaseInventoryJob(Job(i), real_goods.people[i]);
1237
1237
 
1238
1238
}
1239
1239
 
1240
1240
/// Verändert Ein/Auslagerungseinstellungen (visuell)
1241
 
void nobBaseWarehouse::ChangeVisualInventorySettings(unsigned char category,unsigned char state,unsigned char type)
 
1241
void nobBaseWarehouse::ChangeVisualInventorySettings(unsigned char category, unsigned char state, unsigned char type)
1242
1242
{
1243
 
        ((category == 0)?inventory_settings_visual.wares[type]:inventory_settings_visual.figures[type]) ^= state;
 
1243
    ((category == 0) ? inventory_settings_visual.wares[type] : inventory_settings_visual.figures[type]) ^= state;
1244
1244
 
1245
 
        // Einlagern -> Einlagern verbieten / Auslagern auf false setzen, weil es keinen Sinn macht
1246
 
        if(state == 8)
1247
 
                ((category == 0)?inventory_settings_visual.wares[type]:inventory_settings_visual.figures[type]) &= 8;
1248
 
        else
1249
 
                // Und jeweils umgekehrt
1250
 
                ((category == 0)?inventory_settings_visual.wares[type]:inventory_settings_visual.figures[type]) &= ( 2 | 4 );
 
1245
    // Einlagern -> Einlagern verbieten / Auslagern auf false setzen, weil es keinen Sinn macht
 
1246
    if(state == 8)
 
1247
        ((category == 0) ? inventory_settings_visual.wares[type] : inventory_settings_visual.figures[type]) &= 8;
 
1248
    else
 
1249
        // Und jeweils umgekehrt
 
1250
        ((category == 0) ? inventory_settings_visual.wares[type] : inventory_settings_visual.figures[type]) &= ( 2 | 4 );
1251
1251
 
1252
1252
}
1253
 
        
 
1253
 
1254
1254
/// Gibt Ein/Auslagerungseinstellungen zurück (visuell)
1255
 
bool nobBaseWarehouse::CheckVisualInventorySettings(unsigned char category,unsigned char state,unsigned char type) const
1256
 
1257
 
        return ((((category == 0)?inventory_settings_visual.wares[type]:inventory_settings_visual.figures[type]) & state) == state); 
 
1255
bool nobBaseWarehouse::CheckVisualInventorySettings(unsigned char category, unsigned char state, unsigned char type) const
 
1256
{
 
1257
    return ((((category == 0) ? inventory_settings_visual.wares[type] : inventory_settings_visual.figures[type]) & state) == state);
1258
1258
}
1259
1259
 
1260
1260
 
1261
1261
//void nobBaseWarehouse::ChangeRealInventorySetting(const unsigned char * const wares,const unsigned char * const figures)
1262
1262
//{
1263
 
//      memcpy(inventory_settings_real.wares,wares,36);
1264
 
//      memcpy(inventory_settings_real.figures,figures,31);
1265
 
//
1266
 
//      // Evtl gabs verlorene Waren, die jetzt in das HQ wieder reinkönnen
1267
 
//      gwg->GetPlayer(player)->FindClientForLostWares();
1268
 
//
1269
 
//      // Sind Waren vorhanden, die ausgelagert werden müssen und ist noch kein Auslagerungsevent vorhanden --> neues anmelden
1270
 
//      if(AreWaresToEmpty() && !empty_event.valid())
1271
 
//              empty_event = em->AddEvent(this,EMPTY_INTERVAL,3);
 
1263
//  memcpy(inventory_settings_real.wares,wares,36);
 
1264
//  memcpy(inventory_settings_real.figures,figures,31);
 
1265
//
 
1266
//  // Evtl gabs verlorene Waren, die jetzt in das HQ wieder reinkönnen
 
1267
//  gwg->GetPlayer(player)->FindClientForLostWares();
 
1268
//
 
1269
//  // Sind Waren vorhanden, die ausgelagert werden müssen und ist noch kein Auslagerungsevent vorhanden --> neues anmelden
 
1270
//  if(AreWaresToEmpty() && !empty_event.valid())
 
1271
//      empty_event = em->AddEvent(this,EMPTY_INTERVAL,3);
1272
1272
//
1273
1273
//}
1274
1274
 
1275
1275
/// Verändert Ein/Auslagerungseinstellungen (real)
1276
 
void nobBaseWarehouse::ChangeRealInventorySetting(unsigned char category,unsigned char state,unsigned char type)
 
1276
void nobBaseWarehouse::ChangeRealInventorySetting(unsigned char category, unsigned char state, unsigned char type)
1277
1277
{
1278
 
        /// Einstellung ändern
1279
 
        ((category == 0)?inventory_settings_real.wares[type]:inventory_settings_real.figures[type]) ^= state; 
1280
 
 
1281
 
        // Einlagern -> Einlagern verbieten / Auslagern auf false setzen, weil es keinen Sinn macht
1282
 
        if(state == 8)
1283
 
                ((category == 0)?inventory_settings_real.wares[type]:inventory_settings_real.figures[type]) &= 8;
1284
 
        else
1285
 
                // Und jeweils umgekehrt
1286
 
                ((category == 0)?inventory_settings_real.wares[type]:inventory_settings_real.figures[type]) &= ( 2 | 4 );
1287
 
 
1288
 
 
1289
 
        /// Bei anderen Spielern als dem lokalen, der das in Auftrag gegeben hat, müssen die visuellen ebenfalls
1290
 
        /// geändert werden oder auch bei Replays
1291
 
        if(GameClient::inst().IsReplayModeOn() || GameClient::inst().GetPlayerID() != player)
1292
 
                ChangeVisualInventorySettings(category,state,type);
1293
 
 
1294
 
        // Evtl gabs verlorene Waren, die jetzt in das HQ wieder reinkönnen
1295
 
        if(state == 2)
1296
 
                gwg->GetPlayer(player)->FindClientForLostWares();
1297
 
 
1298
 
        // Sind Waren vorhanden, die ausgelagert werden müssen und ist noch kein Auslagerungsevent vorhanden --> neues anmelden
1299
 
        if(state == 4 && ((category == 0)?real_goods.goods[type]:real_goods.people[type]) && !empty_event)
1300
 
                empty_event = em->AddEvent(this,EMPTY_INTERVAL,3);
1301
 
 
1302
 
        // Sollen Waren eingelagert werden? Dann müssen wir neue bestellen
1303
 
        if(state == 8 && !store_event && ((category == 0)?inventory_settings_real.wares[type]:inventory_settings_real.figures[type]) & 8)
1304
 
                store_event = em->AddEvent(this,STORE_INTERVAL,4);
 
1278
    /// Einstellung ändern
 
1279
    ((category == 0) ? inventory_settings_real.wares[type] : inventory_settings_real.figures[type]) ^= state;
 
1280
 
 
1281
    // Einlagern -> Einlagern verbieten / Auslagern auf false setzen, weil es keinen Sinn macht
 
1282
    if(state == 8)
 
1283
        ((category == 0) ? inventory_settings_real.wares[type] : inventory_settings_real.figures[type]) &= 8;
 
1284
    else
 
1285
        // Und jeweils umgekehrt
 
1286
        ((category == 0) ? inventory_settings_real.wares[type] : inventory_settings_real.figures[type]) &= ( 2 | 4 );
 
1287
 
 
1288
 
 
1289
    /// Bei anderen Spielern als dem lokalen, der das in Auftrag gegeben hat, müssen die visuellen ebenfalls
 
1290
    /// geändert werden oder auch bei Replays
 
1291
    if(GameClient::inst().IsReplayModeOn() || GameClient::inst().GetPlayerID() != player)
 
1292
        ChangeVisualInventorySettings(category, state, type);
 
1293
 
 
1294
    // Evtl gabs verlorene Waren, die jetzt in das HQ wieder reinkönnen
 
1295
    if(state == 2)
 
1296
        gwg->GetPlayer(player)->FindClientForLostWares();
 
1297
 
 
1298
    // Sind Waren vorhanden, die ausgelagert werden müssen und ist noch kein Auslagerungsevent vorhanden --> neues anmelden
 
1299
    if(state == 4 && ((category == 0) ? real_goods.goods[type] : real_goods.people[type]) && !empty_event)
 
1300
        empty_event = em->AddEvent(this, EMPTY_INTERVAL, 3);
 
1301
 
 
1302
    // Sollen Waren eingelagert werden? Dann müssen wir neue bestellen
 
1303
    if(state == 8 && !store_event && ((category == 0) ? inventory_settings_real.wares[type] : inventory_settings_real.figures[type]) & 8)
 
1304
        store_event = em->AddEvent(this, STORE_INTERVAL, 4);
1305
1305
}
1306
1306
 
1307
1307
/// Verändert alle Ein/Auslagerungseinstellungen einer Kategorie (also Waren oder Figuren)(real)
1308
 
void nobBaseWarehouse::ChangeAllRealInventorySettings(unsigned char category,unsigned char state)
 
1308
void nobBaseWarehouse::ChangeAllRealInventorySettings(unsigned char category, unsigned char state)
1309
1309
{
1310
 
        // Merken, ob Waren/Figuren eingelagert werden sollen
1311
 
        bool store = false;
1312
 
 
1313
 
        if(category == 0)
1314
 
        {
1315
 
                // Waren ändern
1316
 
                for(unsigned i = 0;i<WARE_TYPES_COUNT;++i)
1317
 
                {
1318
 
                        inventory_settings_real.wares[i] ^= state;
1319
 
                        if(state == 8 && inventory_settings_real.wares[i] & state)
1320
 
                                store = true;
1321
 
                }
1322
 
        }
1323
 
        else
1324
 
        {
1325
 
                // Figuren ändern
1326
 
                for(unsigned i = 0;i<JOB_TYPES_COUNT;++i)
1327
 
                {
1328
 
                        inventory_settings_real.figures[i] ^= state;
1329
 
                        if(state == 8 && inventory_settings_real.figures[i] & state)
1330
 
                                store = true;
1331
 
                }
1332
 
        }
1333
 
 
1334
 
        // Evtl gabs verlorene Waren, die jetzt in das HQ wieder reinkönnen
1335
 
        if(state == 2)
1336
 
                gwg->GetPlayer(player)->FindClientForLostWares();
1337
 
 
1338
 
        // Sind Waren vorhanden, die ausgelagert werden müssen und ist noch kein Auslagerungsevent vorhanden --> neues anmelden
1339
 
        if(state == 4 && AreWaresToEmpty() && !empty_event)
1340
 
                empty_event = em->AddEvent(this,EMPTY_INTERVAL,3);
1341
 
 
1342
 
        // Sollen Waren eingelagert werden? Dann müssen wir neue bestellen
1343
 
        if(store && !store_event)
1344
 
                store_event = em->AddEvent(this,STORE_INTERVAL,4);
 
1310
    // Merken, ob Waren/Figuren eingelagert werden sollen
 
1311
    bool store = false;
 
1312
 
 
1313
    if(category == 0)
 
1314
    {
 
1315
        // Waren ändern
 
1316
        for(unsigned i = 0; i < WARE_TYPES_COUNT; ++i)
 
1317
        {
 
1318
            inventory_settings_real.wares[i] ^= state;
 
1319
            if(state == 8 && inventory_settings_real.wares[i] & state)
 
1320
                store = true;
 
1321
        }
 
1322
    }
 
1323
    else
 
1324
    {
 
1325
        // Figuren ändern
 
1326
        for(unsigned i = 0; i < JOB_TYPES_COUNT; ++i)
 
1327
        {
 
1328
            inventory_settings_real.figures[i] ^= state;
 
1329
            if(state == 8 && inventory_settings_real.figures[i] & state)
 
1330
                store = true;
 
1331
        }
 
1332
    }
 
1333
 
 
1334
    // Evtl gabs verlorene Waren, die jetzt in das HQ wieder reinkönnen
 
1335
    if(state == 2)
 
1336
        gwg->GetPlayer(player)->FindClientForLostWares();
 
1337
 
 
1338
    // Sind Waren vorhanden, die ausgelagert werden müssen und ist noch kein Auslagerungsevent vorhanden --> neues anmelden
 
1339
    if(state == 4 && AreWaresToEmpty() && !empty_event)
 
1340
        empty_event = em->AddEvent(this, EMPTY_INTERVAL, 3);
 
1341
 
 
1342
    // Sollen Waren eingelagert werden? Dann müssen wir neue bestellen
 
1343
    if(store && !store_event)
 
1344
        store_event = em->AddEvent(this, STORE_INTERVAL, 4);
1345
1345
 
1346
1346
}
1347
1347
 
1348
1348
 
1349
1349
bool nobBaseWarehouse::AreWaresToEmpty() const
1350
1350
{
1351
 
        // Prüfen, ob Warentyp ausgelagert werden soll und ob noch Waren davon vorhanden sind
1352
 
        // Waren überprüfen
1353
 
        for(unsigned i = 0;i<WARE_TYPES_COUNT;++i)
1354
 
        {
1355
 
                if(CheckRealInventorySettings(0,4,i) && real_goods.goods[i])
1356
 
                        return true;
1357
 
        }
1358
 
 
1359
 
        // Figuren überprüfen
1360
 
        for(unsigned i = 0;i<JOB_TYPES_COUNT;++i)
1361
 
        {
1362
 
                if(CheckRealInventorySettings(1,4,i) && real_goods.people[i])
1363
 
                        return true;
1364
 
        }
1365
 
 
1366
 
        return false;
 
1351
    // Prüfen, ob Warentyp ausgelagert werden soll und ob noch Waren davon vorhanden sind
 
1352
    // Waren überprüfen
 
1353
    for(unsigned i = 0; i < WARE_TYPES_COUNT; ++i)
 
1354
    {
 
1355
        if(CheckRealInventorySettings(0, 4, i) && real_goods.goods[i])
 
1356
            return true;
 
1357
    }
 
1358
 
 
1359
    // Figuren überprüfen
 
1360
    for(unsigned i = 0; i < JOB_TYPES_COUNT; ++i)
 
1361
    {
 
1362
        if(CheckRealInventorySettings(1, 4, i) && real_goods.people[i])
 
1363
            return true;
 
1364
    }
 
1365
 
 
1366
    return false;
1367
1367
}
1368
1368
 
1369
1369
bool nobBaseWarehouse::DefendersAvailable() const
1370
1370
{
1371
 
        // Warenbestand und Reserve prüfen
1372
 
        for(unsigned i = 0;i<5;++i)
1373
 
        {
1374
 
                // Reserve
1375
 
                if(reserve_soldiers_available[i])
1376
 
                        return true;
1377
 
                // Warenbestand
1378
 
                if(real_goods.people[JOB_PRIVATE+i])
1379
 
                        return true;
1380
 
        }
 
1371
    // Warenbestand und Reserve prüfen
 
1372
    for(unsigned i = 0; i < 5; ++i)
 
1373
    {
 
1374
        // Reserve
 
1375
        if(reserve_soldiers_available[i])
 
1376
            return true;
 
1377
        // Warenbestand
 
1378
        if(real_goods.people[JOB_PRIVATE + i])
 
1379
            return true;
 
1380
    }
1381
1381
 
1382
 
        return false;
 
1382
    return false;
1383
1383
}
1384
1384
 
1385
1385
unsigned nobBaseWarehouse::IncreaseReserveVisual(unsigned rank)
1386
1386
{
1387
 
        return ++reserve_soldiers_claimed_visual[rank];
 
1387
    return ++reserve_soldiers_claimed_visual[rank];
1388
1388
}
1389
1389
 
1390
1390
unsigned nobBaseWarehouse::DecreaseReserveVisual(unsigned rank)
1391
1391
{
1392
 
        if(reserve_soldiers_claimed_visual[rank])
1393
 
                --reserve_soldiers_claimed_visual[rank];
 
1392
    if(reserve_soldiers_claimed_visual[rank])
 
1393
        --reserve_soldiers_claimed_visual[rank];
1394
1394
 
1395
 
        return reserve_soldiers_claimed_visual[rank];
 
1395
    return reserve_soldiers_claimed_visual[rank];
1396
1396
}
1397
1397
 
1398
1398
void nobBaseWarehouse::SetRealReserve(const unsigned rank, const unsigned count)
1399
1399
{
1400
 
        reserve_soldiers_claimed_real[rank] = count;
1401
 
 
1402
 
        // Replay oder anderer Spieler? Dann die visuellen auch erhöhen
1403
 
        if(GameClient::inst().IsReplayModeOn() || GameClient::inst().GetPlayerID() != player)
1404
 
                reserve_soldiers_claimed_visual[rank] = count;
1405
 
 
1406
 
        // Geforderte Soldaten ggf. einbeziehen
1407
 
        RefreshReserve(rank);
 
1400
    reserve_soldiers_claimed_real[rank] = count;
 
1401
 
 
1402
    // Replay oder anderer Spieler? Dann die visuellen auch erhöhen
 
1403
    if(GameClient::inst().IsReplayModeOn() || GameClient::inst().GetPlayerID() != player)
 
1404
        reserve_soldiers_claimed_visual[rank] = count;
 
1405
 
 
1406
    // Geforderte Soldaten ggf. einbeziehen
 
1407
    RefreshReserve(rank);
1408
1408
}
1409
1409
 
1410
1410
void nobBaseWarehouse::RefreshReserve(unsigned rank)
1411
1411
{
1412
 
        // Zuviele oder zuwenig Soldaten einkassiert?
1413
 
        if(reserve_soldiers_available[rank] < reserve_soldiers_claimed_real[rank])
1414
 
        {
1415
 
                // Zuwenig --> gucken,ob wir noch mehr einkassieren können
1416
 
                if(real_goods.people[JOB_PRIVATE+rank])
1417
 
                {
1418
 
                        // ja, dann nehmen wir mal noch soviele wie nötig und möglich
1419
 
                        unsigned add = min(real_goods.people[JOB_PRIVATE+rank], // möglich
1420
 
                                reserve_soldiers_claimed_real[rank]-reserve_soldiers_available[rank]); // nötig
1421
 
 
1422
 
                        // Bei der Reserve hinzufügen
1423
 
                        reserve_soldiers_available[rank] += add;
1424
 
                        // vom Warenbestand abziehen
1425
 
                        goods.people[JOB_PRIVATE+rank] -= add;
1426
 
                        real_goods.people[JOB_PRIVATE+rank] -= add;
1427
 
                }
1428
 
        }
1429
 
        else if(reserve_soldiers_available[rank] > reserve_soldiers_claimed_real[rank])
1430
 
        {
1431
 
                // Zuviele, dann wieder welche freigeben
1432
 
                unsigned subtract = reserve_soldiers_available[rank] - reserve_soldiers_claimed_real[rank];
1433
 
 
1434
 
                // Bei der Reserve abziehen
1435
 
                reserve_soldiers_available[rank] -= subtract;
1436
 
                // beim Warenbestand hinzufügen
1437
 
                goods.people[JOB_PRIVATE+rank] += subtract;
1438
 
                real_goods.people[JOB_PRIVATE+rank] += subtract;
1439
 
 
1440
 
                // Ggf. Truppen in die Militärgebäude schicken
1441
 
                gwg->GetPlayer(player)->RegulateAllTroops();
1442
 
        }
1443
 
        // ansonsten ists gleich und alles ist in Ordnung!
 
1412
    // Zuviele oder zuwenig Soldaten einkassiert?
 
1413
    if(reserve_soldiers_available[rank] < reserve_soldiers_claimed_real[rank])
 
1414
    {
 
1415
        // Zuwenig --> gucken,ob wir noch mehr einkassieren können
 
1416
        if(real_goods.people[JOB_PRIVATE + rank])
 
1417
        {
 
1418
            // ja, dann nehmen wir mal noch soviele wie nötig und möglich
 
1419
            unsigned add = min(real_goods.people[JOB_PRIVATE + rank], // möglich
 
1420
                               reserve_soldiers_claimed_real[rank] - reserve_soldiers_available[rank]); // nötig
 
1421
 
 
1422
            // Bei der Reserve hinzufügen
 
1423
            reserve_soldiers_available[rank] += add;
 
1424
            // vom Warenbestand abziehen
 
1425
            goods.people[JOB_PRIVATE + rank] -= add;
 
1426
            real_goods.people[JOB_PRIVATE + rank] -= add;
 
1427
        }
 
1428
    }
 
1429
    else if(reserve_soldiers_available[rank] > reserve_soldiers_claimed_real[rank])
 
1430
    {
 
1431
        // Zuviele, dann wieder welche freigeben
 
1432
        unsigned subtract = reserve_soldiers_available[rank] - reserve_soldiers_claimed_real[rank];
 
1433
 
 
1434
        // Bei der Reserve abziehen
 
1435
        reserve_soldiers_available[rank] -= subtract;
 
1436
        // beim Warenbestand hinzufügen
 
1437
        goods.people[JOB_PRIVATE + rank] += subtract;
 
1438
        real_goods.people[JOB_PRIVATE + rank] += subtract;
 
1439
 
 
1440
        // Ggf. Truppen in die Militärgebäude schicken
 
1441
        gwg->GetPlayer(player)->RegulateAllTroops();
 
1442
    }
 
1443
    // ansonsten ists gleich und alles ist in Ordnung!
1444
1444
}
1445
1445
 
1446
1446
void nobBaseWarehouse::CheckOuthousing(unsigned char category, unsigned job_ware_id)
1447
1447
{
1448
 
        // Bootsträger in Träger umwandeln, der evtl dann raus soll
1449
 
        if(category == 1 && job_ware_id == JOB_BOATCARRIER)
1450
 
                job_ware_id = JOB_HELPER;
 
1448
    // Bootsträger in Träger umwandeln, der evtl dann raus soll
 
1449
    if(category == 1 && job_ware_id == JOB_BOATCARRIER)
 
1450
        job_ware_id = JOB_HELPER;
1451
1451
 
1452
 
        if(CheckRealInventorySettings(category,4,job_ware_id) && !empty_event)
1453
 
                empty_event = em->AddEvent(this,EMPTY_INTERVAL,3);
 
1452
    if(CheckRealInventorySettings(category, 4, job_ware_id) && !empty_event)
 
1453
        empty_event = em->AddEvent(this, EMPTY_INTERVAL, 3);
1454
1454
}
1455
1455
 
1456
1456
/// For debug only
1457
 
bool nobBaseWarehouse::CheckDependentFigure(noFigure * fig)
 
1457
bool nobBaseWarehouse::CheckDependentFigure(noFigure* fig)
1458
1458
{
1459
 
        for(std::list<noFigure*>::iterator it = dependent_figures.begin();it != dependent_figures.end();++it)
1460
 
        {
1461
 
                if(*it == fig)
1462
 
                        return true;
1463
 
        }
1464
 
        
1465
 
        return false;
 
1459
    for(std::list<noFigure*>::iterator it = dependent_figures.begin(); it != dependent_figures.end(); ++it)
 
1460
    {
 
1461
        if(*it == fig)
 
1462
            return true;
 
1463
    }
 
1464
 
 
1465
    return false;
1466
1466
}
1467
1467
 
1468
1468
/// Available goods of a speciefic type that can be used for trading
1469
1469
unsigned nobBaseWarehouse::GetAvailableWaresForTrading(const GoodType gt) const
1470
 
1471
 
        // We need a helper as leader
1472
 
        if(!real_goods.people[JOB_HELPER]) return 0;
 
1470
{
 
1471
    // We need a helper as leader
 
1472
    if(!real_goods.people[JOB_HELPER]) return 0;
1473
1473
 
1474
 
        return min(real_goods.goods[gt],real_goods.people[JOB_PACKDONKEY]); 
 
1474
    return min(real_goods.goods[gt], real_goods.people[JOB_PACKDONKEY]);
1475
1475
}
1476
1476
 
1477
 
/// Available figures of a speciefic type that can be used for trading 
 
1477
/// Available figures of a speciefic type that can be used for trading
1478
1478
unsigned nobBaseWarehouse::GetAvailableFiguresForTrading(const Job job) const
1479
1479
{
1480
 
        // We need a helper as leader
1481
 
        if(!real_goods.people[JOB_HELPER]) return 0;
 
1480
    // We need a helper as leader
 
1481
    if(!real_goods.people[JOB_HELPER]) return 0;
1482
1482
 
1483
 
        if(job == JOB_HELPER)
1484
 
                return (real_goods.people[JOB_HELPER]-1)/2; // need one as leader
1485
 
        else
1486
 
                return min(real_goods.people[job],real_goods.people[JOB_HELPER]-1); 
 
1483
    if(job == JOB_HELPER)
 
1484
        return (real_goods.people[JOB_HELPER] - 1) / 2; // need one as leader
 
1485
    else
 
1486
        return min(real_goods.people[job], real_goods.people[JOB_HELPER] - 1);
1487
1487
}
1488
1488
 
1489
1489
/// Starts a trade caravane from this warehouse
1490
 
void nobBaseWarehouse::StartTradeCaravane(const GoodType gt,  Job job, const unsigned count,const TradeRoute& tr,nobBaseWarehouse * goal)
 
1490
void nobBaseWarehouse::StartTradeCaravane(const GoodType gt,  Job job, const unsigned count, const TradeRoute& tr, nobBaseWarehouse* goal)
1491
1491
{
1492
 
        nofTradeLeader * tl = new nofTradeLeader(x,y,player,tr,this->GetPos(),goal->GetPos());
1493
 
        AddLeavingFigure(tl);
1494
 
 
1495
 
        // Create the donkeys or other people
1496
 
        nofTradeDonkey * last = NULL;
1497
 
        for(unsigned i = 0;i<count;++i)
1498
 
        {
1499
 
                nofTradeDonkey * next = new nofTradeDonkey(x,y,player,tl,gt,job);
1500
 
 
1501
 
                if(last == NULL) tl->SetSuccessor(next);
1502
 
                else last->SetSuccessor(next);
1503
 
 
1504
 
                last = next;
1505
 
 
1506
 
                AddLeavingFigure(next);
1507
 
        }
1508
 
 
1509
 
        // Also diminish the count of donkeys
1510
 
        if(job == JOB_NOTHING)
1511
 
        {
1512
 
                job = JOB_PACKDONKEY;
1513
 
                // Diminish the goods in the warehouse
1514
 
                --real_goods.people[JOB_HELPER];
1515
 
                this->players->getElement(player)->DecreaseInventoryJob(JOB_HELPER,1);
1516
 
                if(gt != GD_NOTHING) 
1517
 
                { 
1518
 
                        real_goods.goods[gt] -= count;
1519
 
                        this->players->getElement(player)->DecreaseInventoryWare(gt,count);
1520
 
                }
1521
 
                if(job != JOB_NOTHING) //now that we have removed the goods lets remove the donkeys
1522
 
                { 
1523
 
                        real_goods.people[job] -= count;
1524
 
                        this->players->getElement(player)->DecreaseInventoryJob(job,count);
1525
 
                }
1526
 
        }
1527
 
        else
1528
 
        {
1529
 
                --real_goods.people[JOB_HELPER];
1530
 
                this->players->getElement(player)->DecreaseInventoryJob(JOB_HELPER,1);
1531
 
                if(gt != GD_NOTHING) 
1532
 
                { 
1533
 
                        real_goods.goods[gt] -= count;
1534
 
                        this->players->getElement(player)->DecreaseInventoryWare(gt,count);
1535
 
                }
1536
 
                if(job != JOB_NOTHING) //we shouldnt have had goods so lets remove the jobs & the helpers
1537
 
                { 
1538
 
                        real_goods.people[job] -= count;
1539
 
                        this->players->getElement(player)->DecreaseInventoryJob(job,count);
1540
 
                        real_goods.people[JOB_HELPER] -= count;
1541
 
                        this->players->getElement(player)->DecreaseInventoryJob(JOB_HELPER,count);
1542
 
                }
1543
 
        }
1544
 
        
 
1492
    nofTradeLeader* tl = new nofTradeLeader(x, y, player, tr, this->GetPos(), goal->GetPos());
 
1493
    AddLeavingFigure(tl);
 
1494
 
 
1495
    // Create the donkeys or other people
 
1496
    nofTradeDonkey* last = NULL;
 
1497
    for(unsigned i = 0; i < count; ++i)
 
1498
    {
 
1499
        nofTradeDonkey* next = new nofTradeDonkey(x, y, player, tl, gt, job);
 
1500
 
 
1501
        if(last == NULL) tl->SetSuccessor(next);
 
1502
        else last->SetSuccessor(next);
 
1503
 
 
1504
        last = next;
 
1505
 
 
1506
        AddLeavingFigure(next);
 
1507
    }
 
1508
 
 
1509
    // Also diminish the count of donkeys
 
1510
    if(job == JOB_NOTHING)
 
1511
    {
 
1512
        job = JOB_PACKDONKEY;
 
1513
        // Diminish the goods in the warehouse
 
1514
        --real_goods.people[JOB_HELPER];
 
1515
        this->players->getElement(player)->DecreaseInventoryJob(JOB_HELPER, 1);
 
1516
        if(gt != GD_NOTHING)
 
1517
        {
 
1518
            real_goods.goods[gt] -= count;
 
1519
            this->players->getElement(player)->DecreaseInventoryWare(gt, count);
 
1520
        }
 
1521
        if(job != JOB_NOTHING) //now that we have removed the goods lets remove the donkeys
 
1522
        {
 
1523
            real_goods.people[job] -= count;
 
1524
            this->players->getElement(player)->DecreaseInventoryJob(job, count);
 
1525
        }
 
1526
    }
 
1527
    else
 
1528
    {
 
1529
        --real_goods.people[JOB_HELPER];
 
1530
        this->players->getElement(player)->DecreaseInventoryJob(JOB_HELPER, 1);
 
1531
        if(gt != GD_NOTHING)
 
1532
        {
 
1533
            real_goods.goods[gt] -= count;
 
1534
            this->players->getElement(player)->DecreaseInventoryWare(gt, count);
 
1535
        }
 
1536
        if(job != JOB_NOTHING) //we shouldnt have had goods so lets remove the jobs & the helpers
 
1537
        {
 
1538
            real_goods.people[job] -= count;
 
1539
            this->players->getElement(player)->DecreaseInventoryJob(job, count);
 
1540
            real_goods.people[JOB_HELPER] -= count;
 
1541
            this->players->getElement(player)->DecreaseInventoryJob(JOB_HELPER, count);
 
1542
        }
 
1543
    }
 
1544
 
1545
1545
}
1546
1546