← Back to branch summary

~ubuntu-branches/ubuntu/saucy/kblocks/saucy-proposed

« back to all changes in this revision

Viewing changes to AI/KBlocksAIFeature.h

  • Committer: Package Import Robot
  • Author(s): Jonathan Riddell
  • Date: 2012-12-07 17:39:13 UTC
  • Revision ID: package-import@ubuntu.com-20121207173913-5wqlq9suj93x4ap2
Tags: upstream-4.9.90
Import upstream version 4.9.90

Show diffs side-by-side

added added

removed removed

Lines of Context:
AI/KBlocksAIFeature.h
 
1
/***************************************************************************
 
2
*   KBlocks, a falling blocks game for KDE                                *
 
3
*   Copyright (C) 2010 University Freiburg                                *
 
4
*                                                                         *
 
5
*   This program is free software; you can redistribute it and/or modify  *
 
6
*   it under the terms of the GNU General Public License as published by  *
 
7
*   the Free Software Foundation; either version 2 of the License, or     *
 
8
*   (at your option) any later version.                                   *
 
9
***************************************************************************/
 
10
#ifndef KBLOCKSAIFEATURE_H
 
11
#define KBLOCKSAIFEATURE_H
 
12
 
 
13
#include "KBlocksAITypeDefine.h"
 
14
#include "EvaluationInterface.h"
 
15
 
 
16
#include "../KBlocksField.h"
 
17
#include "../KBlocksPiece.h"
 
18
 
 
19
/*******************************************************
 
20
****   Feature  List   ********************************
 
21
*******************************************************/
 
22
 
 
23
enum FeatureEnumeration
 
24
{
 
25
    FEATURE_MAX_HEIGHT,
 
26
    FEATURE_HOLES_COUNT,
 
27
    FEATURE_CLOSED_HOLES_COUNT,
 
28
    FEATURE_WELLS_COUNT,
 
29
    FEATURE_AVERAGE_HEIGHT,
 
30
    FEATURE_AVERAGE_HEIGHT_DIFFERENT,            
 
31
    FEATURE_MAX_HEIGHT_DIFFERENT,            
 
32
    FEATURE_KONTUR_COUNT,
 
33
    FEATURE_MAX_KONTUR_LENGTH,    
 
34
    FEATURE_BLOCKS_COUNT,
 
35
    FEATURE_BLOCKS_OVER_HOLES_COUNT,
 
36
    FEATURE_WEIGHTED_BLOCKS_COUNT,
 
37
    FEATURE_ROW_TRANSITION_COUNT,
 
38
    FEATURE_COLUMN_TRANSITION_COUNT,  
 
39
    FEATURE_MAX_WELL_DEPTH,
 
40
    FEATURE_NARROW_COUNT,
 
41
    FEATURE_PREDICTION_COUNT,
 
42
    FEATURE_COUNT
 
43
};
 
44
 
 
45
enum SpecialFeatureEnumeration
 
46
{
 
47
    FEATURE_REMOVE_LINES,
 
48
    FEATURE_LANDING_HEIGHT
 
49
};
 
50
 
 
51
double getFeature(const FeatureEnumeration, KBlocksField*);
 
52
const char * getFeatureName(const FeatureEnumeration);
 
53
double getSpecialFeature(const SpecialFeatureEnumeration, KBlocksField*, KBlocksField*, KBlocksPiece*);
 
54
void update_board_signature(KBlocksField * field);
 
55
void set_ground_line(int);
 
56
 
 
57
/*******************************************************
 
58
****   Feature     ************************************
 
59
*******************************************************/
 
60
class Evaluation_Max_Height: public EvaluationInterface
 
61
{
 
62
public:
 
63
    double evaluate(KBlocksField*);
 
64
    static Evaluation_Max_Height* instance()
 
65
    {
 
66
        if(_instance == 0)
 
67
        {
 
68
            _instance = new Evaluation_Max_Height();
 
69
        }
 
70
        return _instance;
 
71
    }
 
72
    CLASSNAME(Evaluation_Max_Height)
 
73
private:
 
74
    Evaluation_Max_Height(){}
 
75
    ~Evaluation_Max_Height(){}
 
76
    static Evaluation_Max_Height* _instance;
 
77
};
 
78
//------------------------------------------------------
 
79
class  Evaluation_Holes_Count: public EvaluationInterface
 
80
{
 
81
public:
 
82
    double evaluate(KBlocksField*);
 
83
    static Evaluation_Holes_Count* instance()
 
84
    {
 
85
        if(_instance == 0)
 
86
        {
 
87
            _instance = new Evaluation_Holes_Count();
 
88
        }
 
89
        return _instance;
 
90
    }
 
91
    CLASSNAME(Evaluation_Holes_Count)
 
92
private:
 
93
    Evaluation_Holes_Count(){}
 
94
    ~Evaluation_Holes_Count(){}
 
95
    static Evaluation_Holes_Count* _instance;
 
96
};
 
97
//------------------------------------------------------
 
98
class  Evaluation_Average_Height: public EvaluationInterface
 
99
{
 
100
public:
 
101
    double evaluate(KBlocksField*);
 
102
    static Evaluation_Average_Height* instance()
 
103
    {
 
104
        if(_instance == 0)
 
105
        {
 
106
            _instance = new Evaluation_Average_Height();
 
107
        }
 
108
        return _instance;
 
109
    }
 
110
    CLASSNAME(Evaluation_Average_Height)
 
111
private:
 
112
    Evaluation_Average_Height(){}
 
113
    ~Evaluation_Average_Height(){}
 
114
    static Evaluation_Average_Height* _instance;
 
115
};
 
116
//------------------------------------------------------
 
117
class  Evaluation_Max_Height_Difference: public EvaluationInterface
 
118
{
 
119
public:
 
120
    double evaluate(KBlocksField*);
 
121
    static Evaluation_Max_Height_Difference* instance()
 
122
    {
 
123
        if(_instance == 0)
 
124
        {
 
125
            _instance = new Evaluation_Max_Height_Difference();
 
126
        }
 
127
        return _instance;
 
128
    }
 
129
    CLASSNAME(Evaluation_Max_Height_Difference)
 
130
private:
 
131
    Evaluation_Max_Height_Difference(){}
 
132
    ~Evaluation_Max_Height_Difference(){}
 
133
    static Evaluation_Max_Height_Difference* _instance;
 
134
};  
 
135
//------------------------------------------------------
 
136
class  Evaluation_Average_Height_Difference: public EvaluationInterface
 
137
{
 
138
public:
 
139
    double evaluate(KBlocksField*);
 
140
    static Evaluation_Average_Height_Difference* instance()
 
141
    {
 
142
        if(_instance == 0)
 
143
        {
 
144
            _instance = new Evaluation_Average_Height_Difference();
 
145
        }
 
146
        return _instance;
 
147
    }
 
148
    CLASSNAME(Evaluation_Average_Height_Difference)
 
149
private:
 
150
    Evaluation_Average_Height_Difference(){}
 
151
    ~Evaluation_Average_Height_Difference(){}
 
152
    static Evaluation_Average_Height_Difference* _instance;
 
153
};  
 
154
//------------------------------------------------------
 
155
class  Evaluation_Kontur_Count: public EvaluationInterface
 
156
{
 
157
public:
 
158
    double evaluate(KBlocksField*);
 
159
    static Evaluation_Kontur_Count* instance()
 
160
    {
 
161
        if(_instance == 0)
 
162
        {
 
163
            _instance = new Evaluation_Kontur_Count();
 
164
        }
 
165
        return _instance;
 
166
    }
 
167
    CLASSNAME(Evaluation_Kontur_Count)
 
168
private:
 
169
    Evaluation_Kontur_Count(){}
 
170
    ~Evaluation_Kontur_Count(){}
 
171
    static Evaluation_Kontur_Count* _instance;
 
172
};
 
173
//------------------------------------------------------
 
174
class  Evaluation_Max_Kontur_Length: public EvaluationInterface
 
175
{
 
176
public:
 
177
    double evaluate(KBlocksField*);
 
178
    static Evaluation_Max_Kontur_Length* instance()
 
179
    {
 
180
        if(_instance == 0)
 
181
        {
 
182
            _instance = new Evaluation_Max_Kontur_Length();
 
183
        }
 
184
        return _instance;
 
185
    }
 
186
    CLASSNAME(Evaluation_Max_Kontur_Length)
 
187
private:
 
188
    Evaluation_Max_Kontur_Length(){}
 
189
    ~Evaluation_Max_Kontur_Length(){}
 
190
    static Evaluation_Max_Kontur_Length* _instance;
 
191
};
 
192
//------------------------------------------------------
 
193
class  Evaluation_Closed_Holes_Count: public EvaluationInterface
 
194
{
 
195
public:
 
196
    double evaluate(KBlocksField*);
 
197
    static Evaluation_Closed_Holes_Count* instance()
 
198
    {
 
199
        if(_instance == 0)
 
200
        {
 
201
            _instance = new Evaluation_Closed_Holes_Count();
 
202
        }
 
203
        return _instance;
 
204
    }
 
205
    CLASSNAME(Evaluation_Closed_Holes_Count)
 
206
private:
 
207
    Evaluation_Closed_Holes_Count(){}
 
208
    ~Evaluation_Closed_Holes_Count(){}
 
209
    static Evaluation_Closed_Holes_Count* _instance;
 
210
};
 
211
//------------------------------------------------------
 
212
class  Evaluation_Wells_Count: public EvaluationInterface
 
213
{
 
214
public:
 
215
    double evaluate(KBlocksField*);
 
216
    static Evaluation_Wells_Count* instance()
 
217
    {
 
218
        if(_instance == 0)
 
219
        {
 
220
            _instance = new Evaluation_Wells_Count();
 
221
        }
 
222
        return _instance;
 
223
    }
 
224
    CLASSNAME(Evaluation_Wells_Count)
 
225
private:
 
226
    Evaluation_Wells_Count(){}
 
227
    ~Evaluation_Wells_Count(){}
 
228
    static Evaluation_Wells_Count* _instance;
 
229
};
 
230
//------------------------------------------------------
 
231
class  Evaluation_Blocks_Count: public EvaluationInterface
 
232
{
 
233
public:
 
234
    double evaluate(KBlocksField*);
 
235
    static Evaluation_Blocks_Count* instance()
 
236
    {
 
237
        if(_instance == 0)
 
238
        {
 
239
            _instance = new Evaluation_Blocks_Count();
 
240
        }
 
241
        return _instance;
 
242
    }
 
243
    CLASSNAME(Evaluation_Blocks_Count)
 
244
private:
 
245
    Evaluation_Blocks_Count(){}
 
246
    ~Evaluation_Blocks_Count(){}
 
247
    static Evaluation_Blocks_Count* _instance;
 
248
};
 
249
//------------------------------------------------------
 
250
class  Evaluation_Blocks_Over_Holes_Count: public EvaluationInterface
 
251
{
 
252
public:
 
253
    double evaluate(KBlocksField*);
 
254
    static Evaluation_Blocks_Over_Holes_Count* instance()
 
255
    {
 
256
        if(_instance == 0)
 
257
        {
 
258
            _instance = new Evaluation_Blocks_Over_Holes_Count();
 
259
        }
 
260
        return _instance;
 
261
    }
 
262
    CLASSNAME(Evaluation_Blocks_Over_Holes_Count)
 
263
private:
 
264
    Evaluation_Blocks_Over_Holes_Count(){}
 
265
    ~Evaluation_Blocks_Over_Holes_Count(){}
 
266
    static Evaluation_Blocks_Over_Holes_Count* _instance;
 
267
};
 
268
//------------------------------------------------------
 
269
class Evaluation_Weighted_Blocks_Count:public EvaluationInterface
 
270
{
 
271
public:
 
272
    double evaluate(KBlocksField*);
 
273
    static Evaluation_Weighted_Blocks_Count* instance()
 
274
    {
 
275
        if(_instance == 0)
 
276
        {
 
277
            _instance = new Evaluation_Weighted_Blocks_Count();
 
278
        }
 
279
        return _instance;
 
280
    }
 
281
    CLASSNAME(Evaluation_Weighted_Blocks_Count)
 
282
private:
 
283
    Evaluation_Weighted_Blocks_Count(){}
 
284
    ~Evaluation_Weighted_Blocks_Count(){}
 
285
    static Evaluation_Weighted_Blocks_Count* _instance;
 
286
};
 
287
//------------------------------------------------------
 
288
class Evaluation_Row_Transition_Count:public EvaluationInterface
 
289
{
 
290
public:
 
291
    double evaluate(KBlocksField*);
 
292
    static Evaluation_Row_Transition_Count* instance()
 
293
    {
 
294
        if(_instance == 0)
 
295
        {
 
296
            _instance = new Evaluation_Row_Transition_Count();
 
297
        }
 
298
        return _instance;
 
299
    }
 
300
    CLASSNAME(Evaluation_Row_Transition_Count)
 
301
private:
 
302
    Evaluation_Row_Transition_Count(){}
 
303
    ~Evaluation_Row_Transition_Count(){}
 
304
    static Evaluation_Row_Transition_Count* _instance;
 
305
};
 
306
//------------------------------------------------------
 
307
class Evaluation_Column_Transition_Count:public EvaluationInterface
 
308
{
 
309
public:
 
310
    double evaluate(KBlocksField*);
 
311
    static Evaluation_Column_Transition_Count* instance()
 
312
    {
 
313
        if(_instance == 0)
 
314
        {
 
315
            _instance = new Evaluation_Column_Transition_Count();
 
316
        }
 
317
        return _instance;
 
318
    }
 
319
    CLASSNAME(Evaluation_Column_Transition_Count)
 
320
private:
 
321
    Evaluation_Column_Transition_Count(){}
 
322
    ~Evaluation_Column_Transition_Count(){}
 
323
    static Evaluation_Column_Transition_Count* _instance;
 
324
};
 
325
//------------------------------------------------------
 
326
class Evaluation_Narrow_Count:public EvaluationInterface
 
327
{
 
328
public:
 
329
    double evaluate(KBlocksField*);
 
330
    static Evaluation_Narrow_Count* instance()
 
331
    {
 
332
        if(_instance == 0)
 
333
        {
 
334
            _instance = new Evaluation_Narrow_Count();
 
335
        }
 
336
        return _instance;
 
337
    }
 
338
    CLASSNAME(Evaluation_Narrow_Count)
 
339
private:
 
340
    Evaluation_Narrow_Count(){}
 
341
    ~Evaluation_Narrow_Count(){}
 
342
    static Evaluation_Narrow_Count* _instance;
 
343
};
 
344
//------------------------------------------------------
 
345
class Evaluation_Prediction_Count:public EvaluationInterface
 
346
{
 
347
public:
 
348
    double evaluate(KBlocksField*);
 
349
    static Evaluation_Prediction_Count* instance()
 
350
    {
 
351
        if(_instance == 0)
 
352
        {
 
353
            _instance = new Evaluation_Prediction_Count();
 
354
        }
 
355
        return _instance;
 
356
    }
 
357
    CLASSNAME(Evaluation_Prediction_Count)
 
358
private:
 
359
    Evaluation_Prediction_Count(){}
 
360
    ~Evaluation_Prediction_Count(){}
 
361
    static Evaluation_Prediction_Count* _instance;
 
362
};
 
363
//------------------------------------------------------
 
364
class Evaluation_Max_Well_Depth:public EvaluationInterface
 
365
{
 
366
public:
 
367
    double evaluate(KBlocksField*);
 
368
    static Evaluation_Max_Well_Depth* instance()
 
369
    {
 
370
        if(_instance == 0)
 
371
        {
 
372
            _instance = new Evaluation_Max_Well_Depth();
 
373
        }
 
374
        return _instance;
 
375
    }
 
376
    CLASSNAME(Evaluation_Max_Well_Depth)
 
377
private:
 
378
    Evaluation_Max_Well_Depth(){}
 
379
    ~Evaluation_Max_Well_Depth(){}
 
380
    static Evaluation_Max_Well_Depth* _instance;
 
381
};
 
382
 
 
383
//# SPECIAL FEATURE #######################################
 
384
class Evaluation_Remove_Lines:public SpecialEvaluationInterface
 
385
{
 
386
public:
 
387
    double evaluate(KBlocksField*);
 
388
    static Evaluation_Remove_Lines* instance()
 
389
    {
 
390
        if(_instance == 0)
 
391
        {
 
392
            _instance = new Evaluation_Remove_Lines();
 
393
        }
 
394
        return _instance;
 
395
    }
 
396
    CLASSNAME(Evaluation_Remove_Lines)
 
397
private:
 
398
    Evaluation_Remove_Lines(){}
 
399
    ~Evaluation_Remove_Lines(){}
 
400
    static Evaluation_Remove_Lines* _instance;
 
401
};
 
402
//------------------------------------------------------
 
403
class Evaluation_Landing_Height:public SpecialEvaluationInterface
 
404
{
 
405
public:
 
406
    double evaluate(KBlocksField*);
 
407
    static Evaluation_Landing_Height* instance()
 
408
    {
 
409
        if(_instance == 0)
 
410
        {
 
411
            _instance = new Evaluation_Landing_Height();
 
412
        }
 
413
        return _instance;
 
414
    }
 
415
    CLASSNAME(Evaluation_Landing_Height)
 
416
private:
 
417
    Evaluation_Landing_Height(){}
 
418
    ~Evaluation_Landing_Height(){}
 
419
    static Evaluation_Landing_Height* _instance;
 
420
};
 
421
 
 
422
#endif //KBLOCKSAIFEATURE_H