~flosoft/s25rttr/trunk

« back to all changes in this revision

Viewing changes to src/nofFarmer.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: nofFarmer.cpp 7521 2011-09-08 20:45:55Z FloSoft $
 
1
// $Id: nofFarmer.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
//
37
37
///////////////////////////////////////////////////////////////////////////////
38
38
// Makros / Defines
39
39
#if defined _WIN32 && defined _DEBUG && defined _MSC_VER
40
 
        #define new new(_NORMAL_BLOCK, THIS_FILE, __LINE__)
41
 
        #undef THIS_FILE
42
 
        static char THIS_FILE[] = __FILE__;
 
40
#define new new(_NORMAL_BLOCK, THIS_FILE, __LINE__)
 
41
#undef THIS_FILE
 
42
static char THIS_FILE[] = __FILE__;
43
43
#endif
44
44
 
45
 
nofFarmer::nofFarmer(const unsigned short x, const unsigned short y,const unsigned char player,nobUsual * workplace)
46
 
: nofFarmhand(JOB_FARMER,x,y,player,workplace), harvest(false)
47
 
{
48
 
}
49
 
 
50
 
 
51
 
void nofFarmer::Serialize_nofFarmer(SerializedGameData * sgd) const
52
 
{
53
 
        Serialize_nofFarmhand(sgd);
54
 
 
55
 
        sgd->PushBool(harvest);
56
 
}
57
 
 
58
 
nofFarmer::nofFarmer(SerializedGameData * sgd, const unsigned obj_id) : nofFarmhand(sgd,obj_id),
59
 
harvest(sgd->PopBool())
 
45
nofFarmer::nofFarmer(const unsigned short x, const unsigned short y, const unsigned char player, nobUsual* workplace)
 
46
    : nofFarmhand(JOB_FARMER, x, y, player, workplace), harvest(false)
 
47
{
 
48
}
 
49
 
 
50
 
 
51
void nofFarmer::Serialize_nofFarmer(SerializedGameData* sgd) const
 
52
{
 
53
    Serialize_nofFarmhand(sgd);
 
54
 
 
55
    sgd->PushBool(harvest);
 
56
}
 
57
 
 
58
nofFarmer::nofFarmer(SerializedGameData* sgd, const unsigned obj_id) : nofFarmhand(sgd, obj_id),
 
59
    harvest(sgd->PopBool())
60
60
{
61
61
}
62
62
 
63
63
 
64
64
/// Malt den Arbeiter beim Arbeiten
65
 
void nofFarmer::DrawWorking(int x,int y)
 
65
void nofFarmer::DrawWorking(int x, int y)
66
66
{
67
 
        unsigned now_id;
68
 
 
69
 
 
70
 
    if(harvest){
71
 
        LOADER.GetImageN("rom_bobs", 140+(now_id=GAMECLIENT.Interpolate(88,current_ev))%8)
72
 
            ->Draw(x,y,0,0,0,0,0,0, COLOR_WHITE, COLORS[gwg->GetPlayer(player)->color]);
73
 
 
74
 
                // Evtl Sound abspielen
75
 
                if(now_id%8 == 3)
76
 
                {
77
 
                        SoundManager::inst().PlayNOSound(64,this,now_id/8);
78
 
                        was_sounding = true;
79
 
                }
80
 
 
81
 
    }else{
82
 
        LOADER.GetImageN("rom_bobs", 132+GAMECLIENT.Interpolate(88,current_ev)%8)
83
 
            ->Draw(x,y,0,0,0,0,0,0, COLOR_WHITE, COLORS[gwg->GetPlayer(player)->color]);
 
67
    unsigned now_id;
 
68
 
 
69
 
 
70
    if(harvest)
 
71
    {
 
72
        LOADER.GetImageN("rom_bobs", 140 + (now_id = GAMECLIENT.Interpolate(88, current_ev)) % 8)
 
73
        ->Draw(x, y, 0, 0, 0, 0, 0, 0, COLOR_WHITE, COLORS[gwg->GetPlayer(player)->color]);
 
74
 
 
75
        // Evtl Sound abspielen
 
76
        if(now_id % 8 == 3)
 
77
        {
 
78
            SoundManager::inst().PlayNOSound(64, this, now_id / 8);
 
79
            was_sounding = true;
 
80
        }
 
81
 
 
82
    }
 
83
    else
 
84
    {
 
85
        LOADER.GetImageN("rom_bobs", 132 + GAMECLIENT.Interpolate(88, current_ev) % 8)
 
86
        ->Draw(x, y, 0, 0, 0, 0, 0, 0, COLOR_WHITE, COLORS[gwg->GetPlayer(player)->color]);
84
87
    }
85
88
 
86
89
 
89
92
/// Fragt die abgeleitete Klasse um die ID in JOBS.BOB, wenn der Beruf Waren rausträgt (bzw rein)
90
93
unsigned short nofFarmer::GetCarryID() const
91
94
{
92
 
        return 71;
 
95
    return 71;
93
96
}
94
97
 
95
98
/// Abgeleitete Klasse informieren, wenn sie anfängt zu arbeiten (Vorbereitungen)
96
99
void nofFarmer::WorkStarted()
97
100
{
98
 
        // Wenn ich zu einem Getreidefeld gehe, ernte ich es ab, ansonsten sähe ich
99
 
        harvest = (gwg->GetNO(x,y)->GetType() == NOP_GRAINFIELD);
 
101
    // Wenn ich zu einem Getreidefeld gehe, ernte ich es ab, ansonsten sähe ich
 
102
    harvest = (gwg->GetNO(x, y)->GetType() == NOP_GRAINFIELD);
100
103
 
101
 
        // Getreidefeld Bescheid sagen, damits nicht plötzlich verschwindet, während wir arbeiten
102
 
        if(harvest)
103
 
                gwg->GetSpecObj<noGrainfield>(x,y)->BeginHarvesting();
 
104
    // Getreidefeld Bescheid sagen, damits nicht plötzlich verschwindet, während wir arbeiten
 
105
    if(harvest)
 
106
        gwg->GetSpecObj<noGrainfield>(x, y)->BeginHarvesting();
104
107
}
105
108
 
106
109
/// Abgeleitete Klasse informieren, wenn fertig ist mit Arbeiten
107
110
void nofFarmer::WorkFinished()
108
111
{
109
112
    if(harvest)
110
 
        {
111
 
                // Getreidefeld vernichten und vorher noch die ID von dem abgeernteten Feld holen, was dann als
112
 
                // normales Zierobjekt gesetzt wird
113
 
                noBase * nob = gwg->GetNO(x,y);
114
 
                // Check if there is still a grain field at this position
115
 
                if(nob->GetGOT() != GOT_GRAINFIELD)
116
 
                        return;
117
 
                noGrainfield * gf = static_cast<noGrainfield*>(nob);
 
113
    {
 
114
        // Getreidefeld vernichten und vorher noch die ID von dem abgeernteten Feld holen, was dann als
 
115
        // normales Zierobjekt gesetzt wird
 
116
        noBase* nob = gwg->GetNO(x, y);
 
117
        // Check if there is still a grain field at this position
 
118
        if(nob->GetGOT() != GOT_GRAINFIELD)
 
119
            return;
 
120
        noGrainfield* gf = static_cast<noGrainfield*>(nob);
118
121
        //unsigned env_obj_id = gf->GetHarvestMapLstID();
119
122
        gwg->SetNO(new noEnvObject(x, y, gf->GetHarvestMapLstID()), x, y);
120
 
                gf->Destroy();
121
 
                delete gf;
 
123
        gf->Destroy();
 
124
        delete gf;
122
125
 
123
 
                // Getreide, was wir geerntet haben, in die Hand nehmen
 
126
        // Getreide, was wir geerntet haben, in die Hand nehmen
124
127
        ware = GD_GRAIN;
125
128
    }
126
 
        else
127
 
        {
128
 
                // If there is any road now, don't set the grain field
129
 
                for(unsigned i = 0;i<6;++i)
130
 
                {
131
 
                        if(gwg->GetPointRoad(x,y,i))
132
 
                                return;
133
 
                }
134
 
                
135
 
                // Was stand hier vorher?
136
 
                NodalObjectType nop = gwg->GetNO(x,y)->GetType();
137
 
 
138
 
                // Nur Zierobjekte und Schilder dürfen weggerissen werden
139
 
                if(nop == NOP_ENVIRONMENT || nop == NOP_NOTHING)
140
 
                {
141
 
                        // ggf. vorher wegreißen
142
 
                        noBase * no = gwg->GetSpecObj<noBase>(x,y);
143
 
                        if(no)
144
 
                        {
145
 
                                no->Destroy();
146
 
                                delete no;
147
 
                        }
148
 
                        // neues Getreidefeld setzen
149
 
                        gwg->SetNO(new noGrainfield(x,y),x,y);
150
 
                }
151
 
 
152
 
                // Wir haben nur gesäht (gar nichts in die Hand nehmen)
153
 
                ware = GD_NOTHING;
 
129
    else
 
130
    {
 
131
        // If there is any road now, don't set the grain field
 
132
        for(unsigned i = 0; i < 6; ++i)
 
133
        {
 
134
            if(gwg->GetPointRoad(x, y, i))
 
135
                return;
 
136
        }
 
137
 
 
138
        // Was stand hier vorher?
 
139
        NodalObjectType nop = gwg->GetNO(x, y)->GetType();
 
140
 
 
141
        // Nur Zierobjekte und Schilder dürfen weggerissen werden
 
142
        if(nop == NOP_ENVIRONMENT || nop == NOP_NOTHING)
 
143
        {
 
144
            // ggf. vorher wegreißen
 
145
            noBase* no = gwg->GetSpecObj<noBase>(x, y);
 
146
            if(no)
 
147
            {
 
148
                no->Destroy();
 
149
                delete no;
 
150
            }
 
151
            // neues Getreidefeld setzen
 
152
            gwg->SetNO(new noGrainfield(x, y), x, y);
 
153
        }
 
154
 
 
155
        // Wir haben nur gesäht (gar nichts in die Hand nehmen)
 
156
        ware = GD_NOTHING;
154
157
    }
155
158
 
156
 
        // BQ drumrum neu berechnen
157
 
        gwg->RecalcBQAroundPoint(x,y);
 
159
    // BQ drumrum neu berechnen
 
160
    gwg->RecalcBQAroundPoint(x, y);
158
161
}
159
162
 
160
163
/// Returns the quality of this working point or determines if the worker can work here at all
161
 
nofFarmhand::PointQuality nofFarmer::GetPointQuality(const MapCoord x, const MapCoord y) 
 
164
nofFarmhand::PointQuality nofFarmer::GetPointQuality(const MapCoord x, const MapCoord y)
162
165
{
163
 
        
164
 
        // Entweder gibts ein Getreidefeld, das wir abernten können...
165
 
        if(gwg->GetNO(x,y)->GetType() == NOP_GRAINFIELD)
166
 
        {
167
 
                if(gwg->GetSpecObj<noGrainfield>(x,y)->IsHarvestable())
168
 
                        return PQ_CLASS1;
169
 
                else
170
 
                        return PQ_NOTPOSSIBLE;
171
 
        }
172
 
        // oder einen freien Platz, wo wir ein neues sähen können
173
 
        else
174
 
        {
175
 
                // Nicht auf Straßen bauen!
176
 
                for(unsigned char i = 0;i<6;++i)
177
 
                {
178
 
                        if(gwg->GetPointRoad(x,y,i))
179
 
                                return PQ_NOTPOSSIBLE;
180
 
                }
181
 
 
182
 
                // Terrain untersuchen (nur auf Wiesen und Savanne und Steppe pflanzen
183
 
                unsigned char t,good_terrains = 0;
184
 
                for(unsigned char i = 0;i<6;++i)
185
 
                {
186
 
                        t = gwg->GetTerrainAround(x,y,i);
187
 
                        if(t == 3 || (t>=8 && t<=12))
188
 
                                ++good_terrains;
189
 
                }
190
 
                if (good_terrains != 6) 
191
 
                        return PQ_NOTPOSSIBLE;
192
 
 
193
 
                // Ist Platz frei?
194
 
                NodalObjectType nop = gwg->GetNO(x,y)->GetType();
195
 
                if(nop != NOP_ENVIRONMENT && nop && nop != NOP_NOTHING)
196
 
                        return PQ_NOTPOSSIBLE;
197
 
 
198
 
                for(unsigned char i = 0;i<6;++i)
199
 
                {
200
 
                        // Nicht direkt neben andere Getreidefelder und Gebäude setzen!
201
 
                        nop = gwg->GetNO(gwg->GetXA(x,y,i),gwg->GetYA(x,y,i))->GetType();
202
 
                        if(nop == NOP_GRAINFIELD || nop == NOP_BUILDING || nop == NOP_BUILDINGSITE)
203
 
                                return PQ_NOTPOSSIBLE;
204
 
                }
205
 
 
206
 
                // Nicht direkt neben den Bauernhof pflanzen!
207
 
                if(x == workplace->GetX()+1 && y == workplace->GetY())
208
 
                        return PQ_NOTPOSSIBLE;
209
 
 
210
 
                return PQ_CLASS2;
211
 
        }
 
166
 
 
167
    // Entweder gibts ein Getreidefeld, das wir abernten können...
 
168
    if(gwg->GetNO(x, y)->GetType() == NOP_GRAINFIELD)
 
169
    {
 
170
        if(gwg->GetSpecObj<noGrainfield>(x, y)->IsHarvestable())
 
171
            return PQ_CLASS1;
 
172
        else
 
173
            return PQ_NOTPOSSIBLE;
 
174
    }
 
175
    // oder einen freien Platz, wo wir ein neues sähen können
 
176
    else
 
177
    {
 
178
        // Nicht auf Straßen bauen!
 
179
        for(unsigned char i = 0; i < 6; ++i)
 
180
        {
 
181
            if(gwg->GetPointRoad(x, y, i))
 
182
                return PQ_NOTPOSSIBLE;
 
183
        }
 
184
 
 
185
        // Terrain untersuchen (nur auf Wiesen und Savanne und Steppe pflanzen
 
186
        unsigned char t, good_terrains = 0;
 
187
        for(unsigned char i = 0; i < 6; ++i)
 
188
        {
 
189
            t = gwg->GetTerrainAround(x, y, i);
 
190
            if(t == 3 || (t >= 8 && t <= 12))
 
191
                ++good_terrains;
 
192
        }
 
193
        if (good_terrains != 6)
 
194
            return PQ_NOTPOSSIBLE;
 
195
 
 
196
        // Ist Platz frei?
 
197
        NodalObjectType nop = gwg->GetNO(x, y)->GetType();
 
198
        if(nop != NOP_ENVIRONMENT && nop && nop != NOP_NOTHING)
 
199
            return PQ_NOTPOSSIBLE;
 
200
 
 
201
        for(unsigned char i = 0; i < 6; ++i)
 
202
        {
 
203
            // Nicht direkt neben andere Getreidefelder und Gebäude setzen!
 
204
            nop = gwg->GetNO(gwg->GetXA(x, y, i), gwg->GetYA(x, y, i))->GetType();
 
205
            if(nop == NOP_GRAINFIELD || nop == NOP_BUILDING || nop == NOP_BUILDINGSITE)
 
206
                return PQ_NOTPOSSIBLE;
 
207
        }
 
208
 
 
209
        // Nicht direkt neben den Bauernhof pflanzen!
 
210
        if(x == workplace->GetX() + 1 && y == workplace->GetY())
 
211
            return PQ_NOTPOSSIBLE;
 
212
 
 
213
        return PQ_CLASS2;
 
214
    }
212
215
 
213
216
}
214
217
 
215
218
 
216
219
void nofFarmer::WorkAborted_Farmhand()
217
220
{
218
 
        // dem Getreidefeld Bescheid sagen, damit es wieder verdorren kann, wenn wir abernten
219
 
        if(harvest && state == STATE_WORK)
220
 
                gwg->GetSpecObj<noGrainfield>(x,y)->EndHarvesting();
 
221
    // dem Getreidefeld Bescheid sagen, damit es wieder verdorren kann, wenn wir abernten
 
222
    if(harvest && state == STATE_WORK)
 
223
        gwg->GetSpecObj<noGrainfield>(x, y)->EndHarvesting();
221
224
}
222
225