1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
|
// Copyright Hugh Perkins 2006, 2009
// hughperkins@gmail.com http://manageddreams.com
//
// This program is free software; you can redistribute it and/or modify it
// under the terms of the GNU General Public License as published by the
// Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
// or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
// more details.
//
// You should have received a copy of the GNU General Public License along
// with this program in the file licence.txt; if not, write to the
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-
// 1307 USA
// You can find the licence also on the web at:
// http://www.opensource.org/licenses/gpl-license.php
//
// ======================================================================================
//
package hughai.controllers.level1;
import java.util.*;
import java.util.Map;
import com.springrts.ai.*;
import com.springrts.ai.oo.clb.*;
import hughai.*;
import hughai.basictypes.*;
import hughai.*;
import hughai.mapping.*;
import hughai.packcoordinators.*;
import hughai.unitdata.*;
import hughai.unitdata.UnitController.UnitAdapter;
import hughai.utils.*;
import hughai.controllers.level2.*;
// verbal contract with higher level:
// This class, by being instantiated, is essentially being told
// "You, go and handle reconnaissance. Do as you like.
// You can use any scout units you need, as I build them
// Note: for now, central workflow class is responsible for deciding
// what to build and when
//
// implementation notes:
// we need a list of scout types, eg jeffy, and those tiny surveillance planes
// maybe those tiny boats if it's water
// our job is to maximize loscoverage at all time, using some heuristic to
// judge this
// maybe we can also be told "over here is a good place to check"
// anywhere with a high threat level / lots of enemy, maybe we just scout
// around the edge, rather than going in
// though perhaps we can use those little bird planes if we have enough of them
// for example if the amount of metal we are producing is really high compared
// to the cost of the small bird planes
public class Reconnaissance {
final float agingfactor = 1f / 600f; // 1f/ 600f means ages over 10 minutes, ish
PlayerObjects playerObjects;
LogFile logfile;
Config config;
BuildTable buildTable;
UnitController unitController;
ScoutControllerRaider scoutcontrollerraider;
Collection<UnitDef> managedUnitTypes = new HashSet<UnitDef>();
Collection<Unit> managedunits = new HashSet<Unit>();
public Reconnaissance( PlayerObjects playerObjects ) {
this.playerObjects = playerObjects;
this.logfile = playerObjects.getLogFile();
this.config = playerObjects.getConfig();
this.buildTable = playerObjects.getBuildTable();
this.unitController = playerObjects.getUnitController();
}
public void Activate(){
playerObjects.getCSAI().registerGameListener( new GameListener() );
unitController.registerListener( new UnitListener() );
List<String> unittypenames = config.getReconnaissanceunitnames();
managedUnitTypes.clear();
for( String unittypename : unittypenames ) {
UnitDef unitdef = buildTable.getUnitDefByName( unittypename );
managedUnitTypes.add( unitdef );
logfile.WriteLine( "Allowed unit type for " + this.getClass().getSimpleName()
+ " " + unitdef.getHumanName() );
}
scoutcontrollerraider = new ScoutControllerRaider( playerObjects );
scoutcontrollerraider.Activate();
//scoutcontroller.AssignUnits( units )
}
void Reappraise( int frame ) {
if( frame % 150 == 0) {
getLosCoverageStatistic( frame );
}
}
// how should this statistic behave?
// should prioritize, and reward, searching areas that haven't been checked
// for ages, or ever, over areas that were searched more recently
// we could simply make this linear, or we could make it more polynomial
// or exponential
// let's make it linear for now perhaps
// probably good if the number is positive rather than negative,
// but not essential
// we could have zero as total loscoverage, up to date
// or 100 for that
// we could always normalize later somehow, unless the measure goes
// down to infinity, where we cannot.
float getLosCoverageStatistic( int frame ) {
logfile.WriteLine( "getLosCoverageStatistic running" );
LosMap losMap = playerObjects.getMaps().getLosMap();
// int[][]lastseenframecountmap = losMap.LastSeenFrameCount;
// how about we give 1 point for each point fully up to date
// and then reduce that as the point gets older?
//
int numpoints = 0;
float nonnormalizedscore = 0;
for( int z = 0; z < losMap.getLosMapHeight(); z++ ) {
for( int x = 0; x < losMap.getLosMapWidth(); x++ ) {
LosMap.LosMapPos losMapPos = new LosMap.LosMapPos( x, z );
// int lastseen = lastseenframecountmap[x][z];
int lastseen = losMap.getLastSeenFrameCount( losMapPos );
float thisvalue = 0;
if( lastseen != 0 ) {
int age = frame - lastseen;
thisvalue = Math.max( 0, 1 - age * agingfactor ); // clamp so can't go below zero
}
nonnormalizedscore += thisvalue;
numpoints++;
}
}
float loscoveragestatistic = nonnormalizedscore * 100 / numpoints;
playerObjects.getLogFile().WriteLine( "getLosCoverageStatistic:" + loscoveragestatistic );
//logfile.WriteLine( "getLosCoverageStatistic running" );
return loscoveragestatistic;
}
class GameListener extends GameAdapter {
@Override
public void Tick( int frame ) {
// if( frame % 30 == 0 ) {
Reappraise( frame );
// }
}
}
class UnitListener extends UnitAdapter {
@Override
public void UnitAdded(Unit unit ) {
UnitDef unitdef = unit.getDef();
if( managedUnitTypes.contains( unitdef ) ) {
logfile.WriteLine( "New reconnaissance unit: " +
unit.getUnitId() + " " + unit.getDef().getHumanName() );
managedunits.add( unit );
scoutcontrollerraider.AssignUnits(
Arrays.asList( new Unit[]{ unit } ) );
}
}
@Override
public void UnitRemoved( Unit unit ) {
UnitDef unitdef = unit.getDef();
if( managedUnitTypes.contains( unitdef ) ) {
managedunits.remove( unit );
scoutcontrollerraider.RevokeUnits(
Arrays.asList( new Unit[]{ unit } ) );
}
}
}
}
|
