ALMaSS Hare ODDox  1.1
The hare model description following ODdox protocol
WinterRyeStrigling.cpp
Go to the documentation of this file.
1 //
2 // WinterRyeStrigling.cpp
3 //
4 /*
5 *******************************************************************************************************
6 Copyright (c) 2011, Christopher John Topping, Aarhus University
7 All rights reserved.
8 
9 Redistribution and use in source and binary forms, with or without modification, are permitted provided
10 that the following conditions are met:
11 
12 Redistributions of source code must retain the above copyright notice, this list of conditions and the
13 following disclaimer.
14 Redistributions in binary form must reproduce the above copyright notice, this list of conditions and
15 the following disclaimer in the documentation and/or other materials provided with the distribution.
16 
17 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
18 IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
19 FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
20 BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
21 BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
22 BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23 LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
24 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25 ********************************************************************************************************
26 */
27 
28 #include "../../Landscape/ls.h"
29 #include "../../Landscape/cropprogs/WinterRyeStrigling.h"
30 
31 
32 extern CfgFloat cfg_ins_app_prop1;
33 extern CfgFloat cfg_herbi_app_prop;
34 extern CfgFloat cfg_fungi_app_prop1;
35 extern CfgFloat cfg_greg_app_prop;
36 extern CfgFloat cfg_strigling_prop;
37 
38 bool WinterRyeStrigling::Do( Farm *a_farm, LE *a_field, FarmEvent *a_ev )
39 {
40  int d1=0;
41  m_farm = a_farm;
42  m_field = a_field;
43  m_ev = a_ev;
44  bool done = false;
45 
46  switch ( m_ev->m_todo )
47  {
48  case wrys_start:
49  {
50  // Set up the date management stuff
51  m_last_date=g_date->DayInYear(1,9);
52  // Start and stop dates for all events after harvest
53  int noDates=4;
54  m_field->SetMDates(0,0,g_date->DayInYear(15,8));
55  // Determined by harvest date - used to see if at all possible
56  m_field->SetMDates(1,0,g_date->DayInYear(15,8));
57  m_field->SetMDates(0,1,g_date->DayInYear(10,8)); // Subbleharrow start
58  m_field->SetMDates(1,1,g_date->DayInYear(1,9)); // Stubbleharrow end
59  m_field->SetMDates(0,2,g_date->DayInYear(3,8)); // alternative to 1st
60  m_field->SetMDates(1,2,g_date->DayInYear(25,8));
61  m_field->SetMDates(0,3,g_date->DayInYear(3,8)); // follows last one
62  m_field->SetMDates(1,3,g_date->DayInYear(25,8));
63  // Check the next crop for early start, unless it is a spring crop
64  // in which case we ASSUME that no checking is necessary!!!!
65  // So DO NOT implement a crop that runs over the year boundary
66  if (m_ev->m_startday>g_date->DayInYear(1,7))
67  {
68  if (m_field->GetMDates(0,0) >=m_ev->m_startday)
69  {
70  g_msg->Warn( WARN_BUG, "WinterRye::Do(): "
71  "Harvest too late for the next crop to start!!!", "" );
72  exit( 1 );
73  }
74  // Now fix any late finishing problems
75  bool toggle=false;
76  for (int i=0; i<noDates; i++) {
77  if (m_field->GetMDates(0,i)>=m_ev->m_startday) {
78  toggle=true;
79  m_field->SetMDates(0,i,m_ev->m_startday-1);
80  }
81  if (m_field->GetMDates(1,i)>=m_ev->m_startday){
82  toggle=true;
83  m_field->SetMDates(1,i,m_ev->m_startday-1);
84  }
85  }
86  if (toggle) for (int i=0; i<10; i++) m_field->SetMConstants(i,0);
87  }
88  // Now no operations can be timed after the start of the next crop.
89 
90  // CJT note:
91  // Start single block date checking code to be cut-'n-pasted...
92  d1;
93  if ( ! m_ev->m_first_year )
94  {
95  // Are we before July 1st?
96  d1 = g_date->OldDays() + g_date->DayInYear( 1,7 );
97  if (g_date->Date() < d1)
98  {
99  // Yes, too early. We assumme this is because the last crop was late
100  g_msg->Warn( WARN_BUG, "WinterRyeStrigling::Do(): "
101  "Crop start attempt between 1st Jan & 1st July", "" );
102  exit( 1 );
103  }
104  else
105  {
106  d1 = g_date->OldDays() + m_first_date; // Add 365 for spring crop
107  if (g_date->Date() > d1)
108  {
109  // Yes too late - should not happen - raise an error
110  g_msg->Warn( WARN_BUG, "WinterRyeStrigling::Do(): "
111  "Crop start attempt after last possible start date", "" );
112  exit( 1 );
113  }
114  }
115  }
116  else
117  {
118  // Is the first year
119  SimpleEvent( g_date->OldDays() + g_date->DayInYear( 1,8 ),
120  wrys_harvest, false );
121  break;
122  }
123  // End single block date checking code. Please see next line
124  // comment as well.
125  // Reinit d1 to first possible starting date.
126  // OK, let's go.
127 
128  if ( m_farm->IsStockFarmer())
129  {
130  d1 = g_date->OldDays() + g_date->DayInYear( 10,9 );
131  }
132  else
133  {
134  d1 = g_date->OldDays() + g_date->DayInYear( 15,9 );
135  }
136  if ( g_date->Date() > d1 )
137  {
138  d1 = g_date->Date();
139  }
140 
141  if ( m_farm->IsStockFarmer()) {
142  WRYS_DID_MANURE = false;
143  WRYS_DID_SLUDGE = false;
144  SimpleEvent( d1, wrys_fertmanure_stock, false );
145  SimpleEvent( d1, wrys_fertsludge_stock, false );
146  } else {
147  SimpleEvent( d1, wrys_autumn_plough, false );
148  }
149  }
150  break;
151 
152  case wrys_fertmanure_stock:
153  if ( m_ev->m_lock || m_farm->DoIt( 15 )) {
154  if (!m_farm->FA_Manure( m_field, 0.0,
155  g_date->DayInYear( 10, 10 ) -
156  g_date->DayInYear())) {
157  SimpleEvent( g_date->Date() + 1, wrys_fertmanure_stock, true );
158  break;
159  }
160  }
161  WRYS_DID_MANURE = true;
162  if ( WRYS_DID_SLUDGE ) {
163  // We are the last thread.
164  SimpleEvent( g_date->OldDays() + g_date->DayInYear( 15,9 ),
165  wrys_autumn_plough, false );
166  }
167  break;
168 
169  case wrys_fertsludge_stock:
170  if ( m_ev->m_lock || m_farm->DoIt( 5 )) {
171  if (!m_farm->FA_Sludge( m_field, 0.0,
172  g_date->DayInYear( 10, 10 ) -
173  g_date->DayInYear())) {
174  SimpleEvent( g_date->Date() + 1, wrys_fertsludge_stock, true );
175  break;
176  }
177  }
178  WRYS_DID_SLUDGE = true;
179  if ( WRYS_DID_MANURE ) {
180  // No, *we* are the last thread!
181  SimpleEvent( g_date->OldDays() + g_date->DayInYear( 15,9 ),
182  wrys_autumn_plough, false );
183  }
184  break;
185 
186  case wrys_autumn_plough:
187  if (!m_farm->AutumnPlough( m_field, 0.0,
188  g_date->DayInYear( 15, 10 ) -
189  g_date->DayInYear())) {
190  SimpleEvent( g_date->Date() + 1, wrys_autumn_plough, true );
191  break;
192  }
193  SimpleEvent( g_date->Date(), wrys_autumn_harrow, false );
194  break;
195 
196  case wrys_autumn_harrow:
197  if (!m_farm->AutumnHarrow( m_field, 0.0,
198  g_date->DayInYear( 15, 10 ) -
199  g_date->DayInYear())) {
200  SimpleEvent( g_date->Date() + 1, wrys_autumn_harrow, true );
201  break;
202  }
203  SimpleEvent( g_date->OldDays() + g_date->DayInYear( 1,10 ),
204  wrys_autumn_sow, false );
205  break;
206 
207  case wrys_autumn_sow:
208  if (!m_farm->AutumnSow( m_field, 0.0,
209  g_date->DayInYear( 1, 11 ) -
210  g_date->DayInYear())) {
211  SimpleEvent( g_date->Date() + 1, wrys_autumn_sow, true );
212  break;
213  }
214  SimpleEvent( g_date->Date(), wrys_autumn_roll, false );
215  break;
216 
217  case wrys_autumn_roll:
218  if ( m_ev->m_lock || m_farm->DoIt( 20 )) {
219  if (!m_farm->AutumnRoll( m_field, 0.0,
220  g_date->DayInYear( 1, 11 ) -
221  g_date->DayInYear())) {
222  SimpleEvent( g_date->Date() + 1, wrys_autumn_roll, true );
223  break;
224  }
225  }
226 
227  if ( m_farm->IsStockFarmer()) {
228  SimpleEvent( g_date->OldDays() + g_date->DayInYear( 1,4 ) + 365,
229  wrys_fertslurry_stock, false );
230  } else {
231  SimpleEvent( g_date->OldDays() + g_date->DayInYear( 2,10 ),
232  wrys_fertmanganese_plant_one, false );
233  }
234  SimpleEvent( d1, wrys_strigling_one, false );
235  break;
236 
237  case wrys_strigling_one:
238  if ( m_ev->m_lock || (cfg_strigling_prop.value() * m_farm->DoIt( 70 ))) {
239  if (!m_farm->Strigling( m_field, 0.0,
240  g_date->DayInYear( 25, 10 ) -
241  g_date->DayInYear())) {
242  SimpleEvent( g_date->Date() + 1, wrys_strigling_one, true );
243  break;
244  }
245  }
246  {
247  d1 = g_date->Date() + 7;
248  if ( d1 < g_date->OldDays() + g_date->DayInYear( 5,10 )) {
249  d1 = g_date->OldDays() + g_date->DayInYear( 5,10 );
250  }
251  SimpleEvent( d1, wrys_strigling_two, false );
252  }
253  break;
254 
255  case wrys_strigling_two:
256  if ( m_ev->m_lock || (cfg_strigling_prop.value() * m_farm->DoIt( 15 ))) {
257  if (!m_farm->Strigling( m_field, 0.0,
258  g_date->DayInYear( 2, 11 ) -
259  g_date->DayInYear())) {
260  SimpleEvent( g_date->Date() + 1, wrys_strigling_two, true );
261  break;
262  }
263  }
264  // End of this strigling thread
265  break;
266 
267  case wrys_fertmanganese_plant_one:
268  if ( m_ev->m_lock || m_farm->DoIt( 20 )) {
269  if (!m_farm->FP_ManganeseSulphate( m_field, 0.0,
270  g_date->DayInYear( 30, 10 ) -
271  g_date->DayInYear())) {
272  SimpleEvent( g_date->Date() + 1, wrys_fertmanganese_plant_one, true );
273  break;
274  }
275  // Did first application, then queue up second for next year.
276  SimpleEvent( g_date->OldDays() + g_date->DayInYear( 1,4 ) + 365,
277  wrys_fertmanganese_plant_two, false );
278  }
279  SimpleEvent( g_date->OldDays() + g_date->DayInYear( 5,3 ) + 365,
280  wrys_fertnpk_plant, false );
281  break;
282 
283  case wrys_fertmanganese_plant_two:
284  if (!m_farm->FP_ManganeseSulphate( m_field, 0.0,
285  g_date->DayInYear( 5, 5 ) -
286  g_date->DayInYear())) {
287  SimpleEvent( g_date->Date() + 1, wrys_fertmanganese_plant_two, true );
288  break;
289  }
290  // End of thread.
291  break;
292 
293  case wrys_fertnpk_plant:
294  if (!m_farm->FP_NPK( m_field, 0.0,
295  g_date->DayInYear( 30, 4 ) -
296  g_date->DayInYear())) {
297  SimpleEvent( g_date->Date() + 1, wrys_fertnpk_plant, true );
298  break;
299  }
300  SimpleEvent( g_date->OldDays() + g_date->DayInYear( 1,4 ),
301  wrys_spring_roll, false );
302  SimpleEvent( g_date->OldDays() + g_date->DayInYear( 1,4 ),
303  wrys_strigling_three, false );
304  break;
305 
306  case wrys_fertslurry_stock:
307  if ( m_ev->m_lock || m_farm->DoIt( 65 )) {
308  if (!m_farm->FA_Slurry( m_field, 0.0,
309  g_date->DayInYear( 30, 4 ) -
310  g_date->DayInYear())) {
311  SimpleEvent( g_date->Date() + 1, wrys_fertslurry_stock, true );
312  break;
313  }
314  }
315  SimpleEvent( g_date->Date(), wrys_fert_ammonium_stock, false );
316  break;
317 
318  case wrys_fert_ammonium_stock:
319  if ( m_ev->m_lock || m_farm->DoIt( 25 )) {
320  if (!m_farm->FA_AmmoniumSulphate( m_field, 0.0,
321  g_date->DayInYear( 30, 4 ) -
322  g_date->DayInYear())) {
323  SimpleEvent( g_date->Date() + 1, wrys_fert_ammonium_stock, true );
324  break;
325  }
326  }
327  SimpleEvent( g_date->Date(), wrys_spring_roll, false );
328  SimpleEvent( g_date->OldDays() + g_date->DayInYear( 1,4 ),
329  wrys_strigling_three, false );
330  break;
331 
332  case wrys_strigling_three:
333  if ( m_ev->m_lock || (cfg_strigling_prop.value() * m_farm->DoIt( 60 ))) {
334  if (!m_farm->Strigling( m_field, 0.0,
335  g_date->DayInYear( 15, 4 ) -
336  g_date->DayInYear())) {
337  SimpleEvent( g_date->Date() + 1, wrys_strigling_three, true );
338  break;
339  }
340  }
341  // End of the last strigling thread
342  break;
343 
344  case wrys_spring_roll:
345  if ( m_ev->m_lock || m_farm->DoIt( 10 )) {
346  if (!m_farm->SpringRoll( m_field, 0.0,
347  g_date->DayInYear( 25,4 ) -
348  g_date->DayInYear())) {
349  SimpleEvent( g_date->Date() + 1, wrys_spring_roll, true );
350  break;
351  }
352  }
353  SimpleEvent( g_date->OldDays() + g_date->DayInYear( 20,4 ),
354  wrys_growth_reg_one, false );
355  break;
356 
357  case wrys_growth_reg_one:
358  if ( m_ev->m_lock || m_farm->DoIt( (int) (60*cfg_greg_app_prop.value() ))) {
359  if (!m_farm->GrowthRegulator( m_field, 0.0,
360  g_date->DayInYear( 2,5 ) -
361  g_date->DayInYear())) {
362  SimpleEvent( g_date->Date() + 1, wrys_growth_reg_one, true );
363  break;
364  }
365  // Did first application of growth regulator, so
366  // queue up the second one too.
367  SimpleEvent( g_date->OldDays() + g_date->DayInYear( 11,5 ),
368  wrys_growth_reg_two, false );
369  }
370  {
371  d1 = g_date->OldDays() + g_date->DayInYear( 25,4 );
372  if ( d1 <= g_date->Date()) {
373  d1 = g_date->Date() + 1;
374  }
375  SimpleEvent( g_date->OldDays() + g_date->DayInYear( 15,5 ),
376  wrys_fungicide, false );
377  }
378  break;
379 
380  case wrys_growth_reg_two:
381  if (!m_farm->GrowthRegulator( m_field, 0.0,
382  g_date->DayInYear( 25,5 ) -
383  g_date->DayInYear())) {
384  SimpleEvent( g_date->Date() + 1, wrys_growth_reg_two, true );
385  break;
386  }
387  // End of thread.
388  break;
389 
390  case wrys_fungicide:
391  if ( m_ev->m_lock || m_farm->DoIt( (int) (50*cfg_fungi_app_prop1.value() ))) {
392  if (!m_farm->FungicideTreat( m_field, 0.0,
393  g_date->DayInYear( 30,5 ) -
394  g_date->DayInYear())) {
395  SimpleEvent( g_date->Date() + 1, wrys_fungicide, true );
396  break;
397  }
398  }
399  SimpleEvent( g_date->OldDays() + g_date->DayInYear( 25,5 ),
400  wrys_insecticide, false );
401  break;
402 
403  case wrys_insecticide:
404  if ( m_ev->m_lock || m_farm->DoIt( (int) (10*cfg_ins_app_prop1.value() ))) {
405  if (!m_farm->InsecticideTreat( m_field, 0.0,
406  g_date->DayInYear( 10,6 ) -
407  g_date->DayInYear())) {
408  SimpleEvent( g_date->Date() + 1, wrys_insecticide, true );
409  break;
410  }
411  }
412  {
413  d1 = g_date->OldDays() + g_date->DayInYear( 1,6 );
414  if ( d1 <= g_date->Date()) {
415  d1 = g_date->Date() + 1;
416  }
417  SimpleEvent( d1, wrys_water, false );
418  }
419  break;
420 
421  case wrys_water:
422  if ( m_ev->m_lock || m_farm->DoIt( 5 ))
423  {
424  if (!m_farm->Water( m_field, 0.0,
425  g_date->DayInYear( 15,6 ) -
426  g_date->DayInYear())) {
427  SimpleEvent( g_date->Date() + 1, wrys_water, true );
428  break;
429  }
430  }
431  SimpleEvent( g_date->OldDays() + g_date->DayInYear( 1,8 ),
432  wrys_harvest, false );
433  break;
434 
435  case wrys_harvest:
436  if (!m_farm->Harvest( m_field, 0.0,
437  g_date->DayInYear( 15,8 ) -
438  g_date->DayInYear())) {
439  SimpleEvent( g_date->Date() + 1, wrys_harvest, true );
440  break;
441  }
442  SimpleEvent( g_date->Date(), wrys_straw_chopping, false );
443  break;
444 
445  case wrys_straw_chopping:
446  if ( m_ev->m_lock || m_farm->DoIt( 60 )) {
447  if (!m_farm->StrawChopping( m_field, 0.0,
448  m_field->GetMDates(1,0) -
449  g_date->DayInYear())) {
450  SimpleEvent( g_date->Date()+1, wrys_straw_chopping, true );
451  break;
452  }
453  // OK, did chop, so go directly to stubbles.
454  SimpleEvent( g_date->OldDays() + m_field->GetMDates(0,1),
455  wrys_stubble_harrowing, false );
456  break;
457  }
458  // No chopping, so do hay turning and bailing before stubbles.
459  SimpleEvent( g_date->OldDays() + m_field->GetMDates(0,2),
460  wrys_hay_turning, false );
461  break;
462 
463  case wrys_hay_turning:
464  if ( m_ev->m_lock || m_farm->DoIt( 40 ))
465  {
466  if (!m_farm->HayTurning( m_field, 0.0,
467  m_field->GetMDates(1,2) -
468  g_date->DayInYear())) {
469  SimpleEvent( g_date->Date() + 1, wrys_hay_turning, true );
470  break;
471  }
472  }
473  SimpleEvent( g_date->OldDays() + m_field->GetMDates(0,3),
474  wrys_hay_bailing, false );
475  break;
476 
477  case wrys_hay_bailing:
478  if (!m_farm->HayBailing( m_field, 0.0,
479  m_field->GetMDates(1,3) -
480  g_date->DayInYear())) {
481  SimpleEvent( g_date->Date() + 1, wrys_hay_bailing, true );
482  break;
483  }
484  SimpleEvent( g_date->OldDays() + m_field->GetMDates(0,1),
485  wrys_stubble_harrowing, false );
486  break;
487 
488  case wrys_stubble_harrowing:
489  if ( m_ev->m_lock || m_farm->DoIt( 30 ))
490  {
491  if (!m_farm->StubbleHarrowing( m_field, 0.0,
492  m_field->GetMDates(1,1) -
493  g_date->DayInYear())) {
494  SimpleEvent( g_date->Date() + 1, wrys_stubble_harrowing, true );
495  break;
496  }
497  }
498  // End of main thread.
499  done = true;
500  break;
501 
502  default:
503  g_msg->Warn( WARN_BUG, "WinterRye::Do(): "
504  "Unknown event type! ", "" );
505  exit( 1 );
506  }
507 
508  return done;
509 }
510 
511 
wrys_growth_reg_one
Definition: WinterRyeStrigling.h:58
Farm::SpringRoll
virtual bool SpringRoll(LE *a_field, double a_user, int a_days)
Carry out a roll event in the spring on a_field.
Definition: farmfuncs.cpp:525
Farm::FA_Slurry
virtual bool FA_Slurry(LE *a_field, double a_user, int a_days)
Spready slurry on a_field owned by an stock farmer.
Definition: farmfuncs.cpp:965
cfg_herbi_app_prop
CfgFloat cfg_herbi_app_prop
wrys_stubble_harrowing
Definition: WinterRyeStrigling.h:70
Farm::IsStockFarmer
bool IsStockFarmer(void)
Definition: farm.h:905
wrys_autumn_sow
Definition: WinterRyeStrigling.h:50
Farm::Strigling
virtual bool Strigling(LE *a_field, double a_user, int a_days)
Carry out a mechanical weeding on a_field.
Definition: farmfuncs.cpp:1545
Farm::Harvest
virtual bool Harvest(LE *a_field, double a_user, int a_days)
Carry out a harvest on a_field.
Definition: farmfuncs.cpp:1769
FarmEvent::m_lock
bool m_lock
Definition: farm.h:465
Farm::FP_ManganeseSulphate
virtual bool FP_ManganeseSulphate(LE *a_field, double a_user, int a_days)
Apply Manganse Sulphate to a_field owned by an arable farmer.
Definition: farmfuncs.cpp:727
FarmEvent
A struct to hold the information required to trigger a farm event.
Definition: farm.h:463
Farm::FP_NPK
virtual bool FP_NPK(LE *a_field, double a_user, int a_days)
Apply NPK fertilizer, on a_field owned by an arable farmer.
Definition: farmfuncs.cpp:629
Farm::DoIt
bool DoIt(double a_probability)
Return chance out of 0 to 100.
Definition: farm.cpp:800
wrys_fertsludge_stock
Definition: WinterRyeStrigling.h:47
wrys_fertnpk_plant
Definition: WinterRyeStrigling.h:53
FarmEvent::m_first_year
bool m_first_year
Definition: farm.h:467
Farm::FA_Manure
virtual bool FA_Manure(LE *a_field, double a_user, int a_days)
Spread manure on a_field owned by an stock farmer.
Definition: farmfuncs.cpp:1036
Farm::FA_Sludge
virtual bool FA_Sludge(LE *a_field, double a_user, int a_days)
Spread sewege sludge on a_field owned by an stock farmer.
Definition: farmfuncs.cpp:1086
wrys_fertmanganese_plant_one
Definition: WinterRyeStrigling.h:52
cfg_strigling_prop
CfgFloat cfg_strigling_prop
Crop::m_first_date
int m_first_date
Definition: farm.h:540
FarmEvent::m_startday
int m_startday
Definition: farm.h:466
Farm::FungicideTreat
virtual bool FungicideTreat(LE *a_field, double a_user, int a_days)
Apply fungicide to a_field.
Definition: farmfuncs.cpp:1279
wrys_strigling_two
Definition: WinterRyeStrigling.h:60
WinterRyeStrigling::Do
bool Do(Farm *a_farm, LE *a_field, FarmEvent *a_ev)
Definition: WinterRyeStrigling.cpp:38
wrys_harvest
Definition: WinterRyeStrigling.h:66
wrys_fertslurry_stock
Definition: WinterRyeStrigling.h:55
Crop::SimpleEvent
void SimpleEvent(long a_date, int a_todo, bool a_lock)
Adds an event to this crop management.
Definition: farm.cpp:307
wrys_autumn_roll
Definition: WinterRyeStrigling.h:51
wrys_autumn_plough
Definition: WinterRyeStrigling.h:48
Farm::AutumnSow
virtual bool AutumnSow(LE *a_field, double a_user, int a_days)
Carry out a sowing event in the autumn on a_field.
Definition: farmfuncs.cpp:364
wrys_water
Definition: WinterRyeStrigling.h:65
wrys_hay_bailing
Definition: WinterRyeStrigling.h:69
Farm::HayBailing
virtual bool HayBailing(LE *a_field, double a_user, int a_days)
Carry out hay bailing on a_field.
Definition: farmfuncs.cpp:2184
WRYS_DID_MANURE
#define WRYS_DID_MANURE
Definition: WinterRyeStrigling.h:41
Farm::StrawChopping
virtual bool StrawChopping(LE *a_field, double a_user, int a_days)
Carry out straw chopping on a_field.
Definition: farmfuncs.cpp:2132
wrys_insecticide
Definition: WinterRyeStrigling.h:64
wrys_fertmanure_stock
Definition: WinterRyeStrigling.h:46
wrys_autumn_harrow
Definition: WinterRyeStrigling.h:49
Crop::m_farm
Farm * m_farm
Definition: farm.h:537
Crop::m_field
LE * m_field
Definition: farm.h:538
cfg_fungi_app_prop1
CfgFloat cfg_fungi_app_prop1
wrys_hay_turning
Definition: WinterRyeStrigling.h:68
FarmEvent::m_todo
int m_todo
Definition: farm.h:469
Farm::InsecticideTreat
virtual bool InsecticideTreat(LE *a_field, double a_user, int a_days)
Apply insecticide to a_field.
Definition: farmfuncs.cpp:1348
wrys_fungicide
Definition: WinterRyeStrigling.h:63
Farm::AutumnRoll
virtual bool AutumnRoll(LE *a_field, double a_user, int a_days)
Carry out a roll event in the autumn on a_field.
Definition: farmfuncs.cpp:288
Farm::Water
virtual bool Water(LE *a_field, double a_user, int a_days)
Carry out a watering on a_field.
Definition: farmfuncs.cpp:1717
Crop::m_last_date
int m_last_date
Definition: farm.h:542
Farm::AutumnPlough
virtual bool AutumnPlough(LE *a_field, double a_user, int a_days)
Carry out a ploughing event in the autumn on a_field.
Definition: farmfuncs.cpp:132
Farm::AutumnHarrow
virtual bool AutumnHarrow(LE *a_field, double a_user, int a_days)
Carry out a harrow event in the autumn on a_field.
Definition: farmfuncs.cpp:261
Farm::FA_AmmoniumSulphate
virtual bool FA_AmmoniumSulphate(LE *a_field, double a_user, int a_days)
Apply ammonium sulphate to a_field owned by an stock farmer.
Definition: farmfuncs.cpp:990
Farm
The base class for all farm types.
Definition: farm.h:767
wrys_strigling_one
Definition: WinterRyeStrigling.h:59
wrys_strigling_three
Definition: WinterRyeStrigling.h:61
cfg_ins_app_prop1
CfgFloat cfg_ins_app_prop1
wrys_growth_reg_two
Definition: WinterRyeStrigling.h:62
Farm::GrowthRegulator
virtual bool GrowthRegulator(LE *a_field, double a_user, int a_days)
Apply growth regulator to a_field.
Definition: farmfuncs.cpp:1250
wrys_fertmanganese_plant_two
Definition: WinterRyeStrigling.h:54
wrys_spring_roll
Definition: WinterRyeStrigling.h:57
cfg_greg_app_prop
CfgFloat cfg_greg_app_prop
Farm::HayTurning
virtual bool HayTurning(LE *a_field, double a_user, int a_days)
Carry out hay turning on a_field.
Definition: farmfuncs.cpp:2159
wrys_straw_chopping
Definition: WinterRyeStrigling.h:67
Crop::m_ev
FarmEvent * m_ev
Definition: farm.h:539
WRYS_DID_SLUDGE
#define WRYS_DID_SLUDGE
Definition: WinterRyeStrigling.h:42
wrys_start
Definition: WinterRyeStrigling.h:45
Farm::StubbleHarrowing
virtual bool StubbleHarrowing(LE *a_field, double a_user, int a_days)
Carry out stubble harrowing on a_field.
Definition: farmfuncs.cpp:2209
wrys_fert_ammonium_stock
Definition: WinterRyeStrigling.h:56