double CFeatureRewardFunction::getReward(CState *oldState, CAction *action, CState *newState)
{
double reward = 0;
int type = oldState->getStateProperties()->getType() & (FEATURESTATE | DISCRETESTATE);
switch (type)
{
case FEATURESTATE:
{
for (unsigned int oldS = 0; oldS < oldState->getNumDiscreteStates(); oldS++)
{
for (unsigned int newS = 0; newS < newState->getNumDiscreteStates(); newS++)
{
reward += getReward(oldState->getDiscreteState(oldS), action, newState->getDiscreteState(newS)) * oldState->getContinuousState(oldS) * newState->getContinuousState(newS);
}
}
break;
}
case DISCRETESTATE:
{
reward = getReward(oldState->getDiscreteState(0), action, newState->getDiscreteState(0));
break;
}
default:
{
reward = getReward(oldState->getDiscreteStateNumber(), action, newState->getDiscreteStateNumber());
}
}
return reward;
}
// -----------------------------------------------------------------------
void BanditLearner::save(ofstream& outputStream, int numTabs)
{
BaseLearner::save(outputStream, numTabs);
outputStream << Serialization::standardTag("reward", getReward(), numTabs) << endl;
outputStream << Serialization::standardTag("K", getK(), numTabs) << endl;
outputStream << Serialization::standardTag("arm", getKeyToString(), numTabs) << endl;
}
void Task::passOneDay()
{
expiresIn--;
reward = (int) (getReward() * 0.9); // Todo: degradation and minreward constants
if (reward < 33)
{
reward = 33;
}
}
void CRewardEpisode::saveBIN(FILE *stream)
{
int buf = getNumRewards();
fwrite(&buf, sizeof(int), 1, stream);
for (int i = 0; i < buf; i ++)
{
double dBuf = getReward(i);
fwrite(&dBuf, sizeof(double), 1, stream);
}
}
double CRewardEpisode::getLastStepsMeanReward(int Steps)
{
assert(getNumRewards() > 0);
double mean = 0;
for (int i = getNumRewards() - Steps; i < getNumRewards(); i ++)
{
mean += getReward(i);
}
return mean / (getNumRewards() - Steps);
}
double CRewardEpisode::getMeanReward()
{
assert(getNumRewards() > 0);
double mean = 0;
for (int i = 0; i < getNumRewards(); i ++)
{
mean += getReward(i);
}
return mean / getNumRewards();
}
double CRewardEpisode::getSummedReward(double gamma)
{
double sum = 0;
double l_gamma = 1.0;
for (int i = 0; i < getNumRewards(); i ++)
{
sum += l_gamma * getReward(i);
l_gamma = gamma * l_gamma;
}
return sum;
}
void TurntableSystem::changeBox(int boxid,bool change)
{
CCPoint thisboxpiont = this->getChildByTag(TAG_ZP_BD)->getChildByTag(boxid)->getPosition();
this->getChildByTag(TAG_ZP_BD)->removeChildByTag(boxid);
Zp_BoxData* thisbox = new Zp_BoxData();
thisbox->set_boxid(boxid);
thisbox->set_xuanzhong(change);
thisbox->set_boxReward(getReward(boxid%6));
thisbox->set_point(thisboxpiont);
Gzi* gz = new Gzi((CCSprite*)this->getChildByTag(TAG_ZP_BD),thisbox);
}
double CFeatureStateRewardModel::getReward(CState *, CAction *, CState *newState)
{
double reward = 0.0;
if (newState->getStateProperties()->isType(FEATURESTATE))
{
for (unsigned int i = 0; i < newState->getNumContinuousStates(); i++)
{
reward += newState->getContinuousState(i) * getReward(newState->getDiscreteState(i));
}
}
else
{
if (newState->getStateProperties()->isType(DISCRETESTATE))
{
reward = getReward(newState->getDiscreteState(0));
}
}
return reward;
}
void Enemy::setHealth(float hp)
{
m_health = hp;
if (m_health < 0.f)
{
getObject()->getScene().findChild("GC")->getComponent<GameController>()->addMoney(getReward());
getObject()->getScene().findChild("GC")->getComponent<GameController>()->addScore(getReward());
getObject()->removeSelf();
}
getObject()->setScale((m_health * 2.f / 100.f) + 0.25f);
}
/**
* Performs the iteration of BRUE
*/
void performIteration(treeNode* root, int switchingPoint, heuristics_t heuristic, int budget){
int level = 0;
treeNode* n = root, *leaf = NULL;
while (n != NULL && n->n>0){
leaf = n;
POLICY p = level < switchingPoint ? EXPLORATION : EXPLOITATION;
n = nextNode(n,p);
level++;
}
double reward = getReward(leaf, heuristic, budget);
backpropagate(leaf, reward);
}
void CRewardEpisode::saveData(FILE *stream)
{
fprintf(stream, "NumRewards: %d\n", getNumRewards());
for (int i = 0; i < getNumRewards(); i ++)
{
double dBuf = getReward(i);
fprintf(stream, "%lf ", dBuf);
}
fprintf(stream, "\n");
}
double CFeatureRewardFunction::getReward(CFeatureList *oldState, CAction *action, CFeatureList *newState)
{
double reward = 0;
CFeatureList::iterator oldIt;
CFeatureList::iterator newIt;
for (oldIt = oldState->begin(); oldIt != oldState->end(); oldIt++)
{
for (newIt = newState->begin(); newIt != newState->end(); newIt++)
{
reward += getReward((*oldIt)->featureIndex, action, (*newIt)->featureIndex) * (*oldIt)->factor * (*newIt)->factor;
}
}
return reward;
}
static void usage(char *command)
{
fprintf(stderr,
"\nPixel-to-pixel stereo algorithm.\n\n"
"usage: %s [options] file1 file2 maxdisparity [file_dm]\n\n"
"Files 'file1' and 'file2' are read, the stereo algorithm (including\n"
"postprocessing) is run, and the resulting disparity map and depth\n"
"discontinuities are saved in files '%s' and '%s'. Note that maxdisp\n"
"must lie between 14 and 50. The original images must be in PGM file\n"
"format. If the -b option is selected, then the results after processing\n"
"the scanlines independently are also saved, in '%s' and '%s'. All results\n"
"are written to the current directory. Options:\n\n"
" [-h] displays this help message\n"
" [-o n] sets the occlusion penalty to 'n' (default: %d)\n"
" [-r n] sets the reward to 'n' (default: %d)\n"
" [-d dir] looks for input files in directory 'dir'\n"
" (default: current directory)\n"
" [-b] also writes out the results after independent matching\n"
" [-rel n] sets the reliable threshold to n (default: %d)\n"
" [-alpha f] sets alpha (for reliability) to f (default: %f)\n"
" [-ma n] sets the max-attraction threshold to n (default: %d)\n\n"
" [-wpi] writes the intermediate results during postprocessing\n"
" (default: off)\n"
" [-np] do not postprocess disparity map\n"
" [-jp] just postprocess disparity map\n"
" (i.e., 'file_dm' is taken to be a disparity map to\n"
" postprocess. 'file2' is ignored).\n"
" [-ig f] for matching, uses intensity gradients specified\n"
" in 'f' (E.g., f='ig%%c.pgm'). x & y go into '%%c'\n"
"Example: %s -o 15 -hr 30 -d ~/images img1.pgm img2.pgm 20\n\n",
command, fname_dm, fname_dd, fname_dm_intermediate, fname_dd_intermediate,
getOcclusionPenalty(), getReward(),
getReliableThreshold(), getAlpha(),
getMaxAttractionThreshold(),
command);
exit(1);
}
void matchScanlines(uchar *imgL,
uchar *imgR,
uchar *disparity_map,
uchar *depth_discontinuities,
char *ptr_ig)
{
int *phi; /* cost of a match sequence */
int *pie_y; /* points to the immediately */
int *pie_d; /* preceding match */
int *dis; /* dissimilarity b/w two pixels */
int *no_igL; /* indicates no intensity gradient */
int *no_igR;
int scanline; /* the current scanline */
int y, deltaa; /* the match following (y_p, delta_p) */
int y_p, delta_p; /* the current match */
int ymin, *xmin; /* used to prune bad nodes */
int phi_new;
int phi_best, pie_y_best, pie_d_best;
int *q_no_igL; /* indicates no intensity gradient */
int *q_no_igR;
phi = malloc((g_cols+g_slop)*(g_maxdisp + 1)*sizeof(int));
if (phi == NULL)
error("(matchScanlines) Memory not allocated");
pie_y = malloc((g_cols+g_slop)*(g_maxdisp + 1)*sizeof(int));
if (pie_y == NULL)
error("(matchScanlines) Memory not allocated");
pie_d = malloc((g_cols+g_slop)*(g_maxdisp + 1)*sizeof(int));
if (pie_d == NULL)
error("(matchScanlines) Memory not allocated");
dis = malloc((g_cols+g_slop)*(g_maxdisp + 1)*sizeof(int));
if (dis == NULL)
error("(matchScanlines) Memory not allocated");
no_igL = malloc((g_cols+g_slop)*sizeof(int));
if (no_igL == NULL)
error("(matchScanlines) Memory not allocated");
no_igR = malloc((g_cols+g_slop)*sizeof(int));
if (no_igR == NULL)
error("(matchScanlines) Memory not allocated");
xmin = malloc((g_cols+g_slop)*sizeof(int));
if (xmin == NULL)
error("(matchScanlines) Memory not allocated");
q_no_igL = malloc((g_rows)*(g_cols+g_slop)*sizeof(int));
if (q_no_igL == NULL)
error("(matchScanlines) Memory not allocated");
q_no_igR = malloc((g_rows)*(g_cols+g_slop)*sizeof(int));
if (q_no_igR == NULL)
error("(matchScanlines) Memory not allocated");
printf("Parameters: occ=%d, rew=%d, ptr_ig='%s'\n",
getOcclusionPenalty(), getReward(), ptr_ig ? ptr_ig : "NULL");
if (ptr_ig != NULL) {
readIGXFiles(ptr_ig, q_no_igL, q_no_igR);
}
for (scanline = 0 ; scanline < g_rows ; scanline++) {
if (scanline % 50 == 0 && g_rows > 200) printf(" scanline %d\n", scanline);
/* Fill tables */
fillDissimilarityTable(imgL, imgR, dis, scanline);
if (ptr_ig == NULL)
computeIntensityGradientsX(imgL, imgR, scanline, no_igL, no_igR);
else {
memcpy(no_igL, (void *)q_no_igL[scanline], (g_cols+g_slop)*sizeof(int));
memcpy(no_igR, (void *)q_no_igR[scanline], (g_cols+g_slop)*sizeof(int));
}
#ifdef BACKWARD_LOOKING
for (delta_p = 0 ; delta_p <= g_maxdisp ; delta_p++) {
phi[(g_maxdisp + 1)*0+delta_p] = DEFAULT_COST + dis[(g_maxdisp + 1)*0+delta_p];
pie_y[(g_maxdisp + 1)*0+delta_p] = FIRST_MATCH;
pie_d[(g_maxdisp + 1)*0+delta_p] = FIRST_MATCH;
}
for (y = 1 ; y < g_cols ; y++) {
/* printf("y=%d\n", y); fflush(stdout); */
for (deltaa = 0 ; deltaa <= g_maxdisp ; deltaa++) {
phi_best = INF;
for (delta_p = 0 ; delta_p <= g_maxdisp ; delta_p++) {
y_p = y - max(1, delta_p - deltaa + 1);
if (y_p>=0) {
if (deltaa==delta_p ||
(deltaa>delta_p && !no_igL[y+deltaa-1]) ||
(deltaa<delta_p && !no_igR[y_p+1])) {
phi_new = phi[(g_maxdisp + 1)*y_p+delta_p] + occ_pen * (deltaa != delta_p);
if (phi_new < phi_best) {
phi_best = phi_new;
pie_y_best = y_p;
pie_d_best = delta_p;
}
}
}
}
phi[(g_maxdisp + 1)*y+deltaa] = phi_best + dis[(g_maxdisp + 1)*y+deltaa]-reward;
pie_y[(g_maxdisp + 1)*y+deltaa] = pie_y_best;
pie_d[(g_maxdisp + 1)*y+deltaa] = pie_d_best;
}
}
#else
/* Initialize arrays */
for (y_p = 1 ; y_p < g_cols ; y_p++) {
xmin[y_p] = INF;
for (delta_p = 0 ; delta_p <= g_maxdisp ; delta_p++)
phi[(g_maxdisp + 1)*y_p+delta_p] = INF;
}
for (delta_p = 0 ; delta_p <= g_maxdisp ; delta_p++) {
phi[(g_maxdisp + 1)*0+delta_p] = DEFAULT_COST + dis[(g_maxdisp + 1)*0+delta_p];
pie_y[(g_maxdisp + 1)*0+delta_p] = FIRST_MATCH;
pie_d[(g_maxdisp + 1)*0+delta_p] = FIRST_MATCH;
xmin[0] = phi[(g_maxdisp + 1)*0+delta_p];
}
for (y_p = 0 ; y_p < g_cols ; y_p++) {
/* Determine ymin */
ymin = INF;
for (delta_p = 0 ; delta_p <= g_maxdisp ; delta_p++) {
ymin = min(ymin, phi[(g_maxdisp + 1)*y_p+delta_p]);
}
for (delta_p = 0 ; delta_p <= g_maxdisp ; delta_p++) {
/* Expand good y nodes */
if ( phi[(g_maxdisp + 1)*y_p+delta_p] <= ymin ) {
y = y_p + 1;
for (deltaa = delta_p + 1 ; deltaa <= g_maxdisp ; deltaa++) {
phi_new = phi[(g_maxdisp + 1)*y_p+delta_p] + dis[(g_maxdisp + 1)*y+deltaa] - reward + occ_pen
+ no_igL[y + deltaa];
if (phi_new < phi[(g_maxdisp + 1)*y+deltaa]) {
phi[(g_maxdisp + 1)*y+deltaa] = phi_new;
pie_y[(g_maxdisp + 1)*y+deltaa] = y_p;
pie_d[(g_maxdisp + 1)*y+deltaa] = delta_p;
xmin[y+deltaa] = min(xmin[y+deltaa], phi_new);
} /* end if(phi_new) */
} /* end for(deltaa) */
} /* end if(phi[][] <= ymin) */
/* Expand good x nodes */
if ( phi[(g_maxdisp + 1)*y_p+delta_p] <= xmin[y_p+delta_p] ) {
for (deltaa = 0 ; deltaa < delta_p ; deltaa++) {
y = y_p + delta_p - deltaa + 1;
phi_new = phi[(g_maxdisp + 1)*y_p+delta_p] + dis[(g_maxdisp + 1)*y+deltaa] - reward + occ_pen
+ no_igR[y_p];
if (phi_new < phi[(g_maxdisp + 1)*y+deltaa]) {
phi[(g_maxdisp + 1)*y+deltaa] = phi_new;
pie_y[(g_maxdisp + 1)*y+deltaa] = y_p;
pie_d[(g_maxdisp + 1)*y+deltaa] = delta_p;
xmin[y+deltaa] = min(xmin[y+deltaa], phi_new);
} /* end if(phi_new) */
} /* end for(deltaa) */
} /* end if(phi[][] <= xmin[]) */
/* Expand all nodes */
phi_new = phi[(g_maxdisp + 1)*y_p+delta_p] + dis[(g_maxdisp + 1)*(y_p+1)+delta_p] - reward;
if ( phi_new < phi[(g_maxdisp + 1)*(y_p+1)+delta_p] ) {
phi[(g_maxdisp + 1)*(y_p+1)+delta_p] = phi_new;
pie_y[(g_maxdisp + 1)*(y_p+1)+delta_p] = y_p;
pie_d[(g_maxdisp + 1)*(y_p+1)+delta_p] = delta_p;
xmin[y_p+1+delta_p] = min(xmin[y_p+1+delta_p], phi_new);
} /* end(if) */
} /* end for(delta_p) */
} /* end for(y_p) */
#endif /* BACKWARD_LOOKING */
/* find ending match $m_k$ */
phi_best = INF;
for (deltaa = 0 ; deltaa <= g_maxdisp ; deltaa++) {
y = g_cols - 1 - deltaa;
if (phi[(g_maxdisp + 1)*y+deltaa] <= phi_best) {
phi_best = phi[(g_maxdisp + 1)*y+deltaa];
pie_y_best = y;
pie_d_best = deltaa;
}
}
/******** */
#if 0
/* This code extracts matches from phi and pie tables. */
/* It is only included for debugging purposes, and its */
/* results are used by no one. */
{
int *matches;
int num_matches;
int tmp_y, tmp_d;
int zz = 0;
matches = malloc(2*g_cols*sizeof(int)];
if (matches == NULL)
error("(matchScanlines) Memory not allocated");
y_p = pie_y_best;
delta_p = pie_d_best;
while (y_p != FIRST_MATCH && delta_p != FIRST_MATCH) {
matches[(g_cols)*0+zz] = y_p + delta_p;
matches[(g_cols)1+zz] = y_p;
tmp_y = pie_y[(g_maxdisp + 1)*y_p+delta_p];
tmp_d = pie_d[(g_maxdisp + 1)*y_p+delta_p];
y_p = tmp_y;
delta_p = tmp_d;
zz++;
}
num_matches = y;
free(matches);
}
#endif
/******** */
/* Compute disparity map and depth discontinuities */
{
int x, x1, x2, y1, y2, deltaa1, deltaa2;
y1 = pie_y_best; deltaa1 = pie_d_best; x1 = y1 + deltaa1;
y2 = pie_y[(g_maxdisp + 1)*y1+deltaa1]; deltaa2 = pie_d[(g_maxdisp + 1)*y1+deltaa1]; x2 = y2 + deltaa2;
for (x = g_cols - 1 ; x >= x1 ; x--) {
disparity_map[(g_cols)*scanline+x] = deltaa1;
depth_discontinuities[(g_cols)*scanline+x] = NO_DISCONTINUITY;
}
while (y2 != FIRST_MATCH) {
if (deltaa1 == deltaa2) {
disparity_map[(g_cols)*scanline+x2] = deltaa2;
depth_discontinuities[(g_cols)*scanline+x2] = NO_DISCONTINUITY;
}
else if (deltaa2 > deltaa1) {
disparity_map[(g_cols)*scanline+x2] = deltaa2;
depth_discontinuities[(g_cols)*scanline+x2] = DISCONTINUITY;
}
else {
disparity_map[(g_cols)*scanline+x1 - 1] = deltaa2;
depth_discontinuities[(g_cols)*scanline+x1 - 1] = DISCONTINUITY;
for (x = x1 - 2 ; x >= x2 ; x--) {
disparity_map[(g_cols)*scanline+x] = deltaa2;
depth_discontinuities[(g_cols)*scanline+x] = NO_DISCONTINUITY;
}
}
y1 = y2; deltaa1 = deltaa2; x1 = y1 + deltaa1;
y2 = pie_y[(g_maxdisp + 1)*y1+deltaa1]; deltaa2 = pie_d[(g_maxdisp + 1)*y1+deltaa1]; x2 = y2 + deltaa2;
}
for (x = y1 + deltaa1 - 1 ; x >= 0 ; x--) {
disparity_map[(g_cols)*scanline+x] = deltaa1;
depth_discontinuities[(g_cols)*scanline+x] = NO_DISCONTINUITY;
}
}
} /* endfor -- scanline */
free(phi);
free(pie_y);
free(pie_d);
free(dis);
free(no_igL);
free(no_igR);
free(xmin);
free(q_no_igL);
free(q_no_igR);
}
void offenseAgent(int port, int numTMates, int numEpi, double learnR,
int suffix, bool oppPres, double eps) {
// Number of features
int numF = oppPres ? (4 + 4 * numTMates) : (3 + 3 * numTMates);
// Number of actions
int numA = 2 + numTMates;
double discFac = 1;
// Tile coding parameter
double resolution = 0.1;
double range[numF];
double min[numF];
double res[numF];
for(int i = 0; i < numF; i++) {
min[i] = -1;
range[i] = 2;
res[i] = resolution;
}
// Weights file
char *wtFile;
std::string s = "weights_" + std::to_string(port) +
"_" + std::to_string(numTMates + 1) +
"_" + std::to_string(suffix);
wtFile = &s[0u];
double lambda = 0;
CMAC *fa = new CMAC(numF, numA, range, min, res);
SarsaAgent *sa = new SarsaAgent(numF, numA, learnR, eps, lambda, fa, wtFile, wtFile);
hfo::HFOEnvironment hfo;
hfo::status_t status;
hfo::action_t a;
double state[numF];
int action = -1;
double reward;
hfo.connectToServer(hfo::HIGH_LEVEL_FEATURE_SET,"../../bin/teams/base/config/formations-dt",6000,"localhost","base_left",false,"");
for (int episode=0; episode < numEpi; episode++) {
int count = 0;
status = hfo::IN_GAME;
action = -1;
while (status == hfo::IN_GAME) {
const std::vector<float>& state_vec = hfo.getState();
// If has ball
if(state_vec[5] == 1) {
if(action != -1) {
reward = getReward(status);
sa->update(state, action, reward, discFac);
}
// Fill up state array
purgeFeatures(state, state_vec, numTMates, oppPres);
// Get raw action
action = sa->selectAction(state);
// Get hfo::Action
a = toAction(action, state_vec);
} else {
a = hfo::MOVE;
}
if (a== hfo::PASS) {
hfo.act(a,state_vec[(9+6*numTMates) - (action-2)*3]);
//std::cout<<(9+6*numTMates) - (action-2)*3;
} else {
hfo.act(a);
}
status = hfo.step();
}
// End of episode
if(action != -1) {
reward = getReward(status);
sa->update(state, action, reward, discFac);
sa->endEpisode();
}
}
delete sa;
delete fa;
}
void doGridLearning() {
int i, j, k, moves, oldx, oldy, reward, ret;
int count = 0;
int up, down, left, right;
for( count; count < EPISODES; count++ ) {
episodeNumber++;
//randomly choose features phi0 to phi2
/* for( i = 0; i < 3; i++ ) {
if( ( (float)random() / (float)RAND_MAX ) < 0.5 ) {
phi[i] = 1;
} else {
phi[i] = 0;
}
}
*/ if( ((float)random() / (float)RAND_MAX) < 0.7 ) {
phi[0] = 1;
} else {
phi[0] = 0;
}
if( ((float)random() / (float)RAND_MAX) < 0.3 ) {
phi[1] = 1;
} else {
phi[1] = 0;
}
if( ((float)random() / (float)RAND_MAX) < 0.5 ) {
phi[2] = 1;
} else {
phi[2] = 0;
}
if( ( phi[0] == 1 && phi[1] == 0 ) || ( phi[0] == 0 && phi[1] == 1 )) {
rewardx = rewardAx;
rewardy = rewardAy;
} else {
rewardx = rewardBx;
rewardy = rewardBy;
}
for( k = 0; k < 3; k++ ) {
phiVal[rewardAx][rewardAy][k] = 0;
phiVal[rewardBx][rewardBy][k] = 0;
phiVal[rewardx][rewardy][k] = REWARD;
}
val[rewardAx][rewardAy] = 0;
val[rewardBx][rewardBy] = 0;
grid[rewardAx][rewardAy] = FLOOR;
grid[rewardBx][rewardBy] = FLOOR;
grid[rewardx][rewardy] = REWARD;
val[rewardx][rewardy] = REWARD;
//randomly chose starting position
do{
i = random() % MAXX;
j = random() % MAXY;
}while( grid[i][j] == WALL || (i == rewardx && j == rewardy) );
xloc = i;
yloc = j;
step = 0;
do{
step++;
//reset freedom of movement
for( moves = 0; moves < 4; moves++ ) {
canmove[moves] = 0;
}
//determine freedom of movement
if( xloc > 0 ) {
if( grid[xloc-1][yloc] != WALL ) {
canmove[LEFT] = 1;
}
}
if( xloc < (MAXX-1) ) {
if( grid[xloc+1][yloc] != WALL ) {
canmove[RIGHT] = 1;
}
}
if( yloc > 0 ) {
if( grid[xloc][yloc-1] != WALL ) {
canmove[UP] = 1;
}
}
if( yloc < (MAXY-1) ) {
if( grid[xloc][yloc+1] != WALL ) {
canmove[DOWN] = 1;
}
}
oldx = xloc;
oldy = yloc;
do{
ret = doMove(choseMove());
}while( ret == -1 );
reward = getReward();
val[oldx][oldy] += ALPHA*(reward+(GAMMA*val[xloc][yloc])-val[oldx][oldy]);
for( k = 0; k < 3; k ++ ) {
if( phi[k] == 1 ) {
phiVal[oldx][oldy][k] += ALPHA*(reward+(GAMMA*phiVal[xloc][yloc][k])-phiVal[oldx][oldy][k]);
}
}
if( episodeNumber % 1000 == 0 && step == 1 ) {
showMap();
usleep((useconds_t)SLEEPTIME);
}
}while( step < MAXSTEPS && ( xloc != rewardx || yloc != rewardy ));
}
return;
}
double CFeatureRewardFunction::getReward(CStateCollection *oldState, CAction *action, CStateCollection *newState)
{
return getReward(oldState->getState(properties), action, newState->getState(properties));
}
double CFeatureStateRewardFunction::getReward(int , CAction *, int newState)
{
return getReward(newState);
}
TurntableSystem::TurntableSystem(CCLayer* layer)
{
CCSprite* allbd = CCSprite::create(IMG_ZP_BD.c_str());
allbd->setPosition(VisibleRect::center());
int allbd_w = allbd->getContentSize().width;
int allbd_h = allbd->getContentSize().height;
CCSprite* cbd = CCSprite::create(IMG_ZP_CENTERBD.c_str());
cbd->setPosition(ccp(allbd_w/2,allbd_h/2));
//格子s
CCSprite* gezi_bd = CCSprite::create(IMG_ZP_KUANGBD.c_str());
int gezi_w = gezi_bd->getContentSize().width;
int gezi_h = gezi_bd->getContentSize().height;
//创建一个矩阵格子阵
boxgezi = CCArray::create();
int bid = 0;
for (int i = 0; i < 4; i++)
{
for (int j = 0; j <=5; j++)
{
Zp_BoxData* thisbox = new Zp_BoxData();
thisbox->set_boxid(bid);
thisbox->set_boxReward(getReward(bid%6));
if(bid==4)
{
thisbox->set_xuanzhong(true);
}
else
{
thisbox->set_xuanzhong(false);
}
thisbox->set_tag(bid);
switch (i)
{
case 0:
thisbox->set_point(ccp(55+gezi_w*j,allbd_h-30));
boxgezi->addObject(thisbox);
break;
case 1:
if(j<=2)
{
thisbox->set_point(ccp(55+gezi_w*5,allbd_h-30-gezi_h-gezi_h*j));
boxgezi->addObject(thisbox);
}
break;
case 2:
thisbox->set_point(ccp(55+gezi_w*5-gezi_w*j,30));
boxgezi->addObject(thisbox);
break;
case 3:
if(j<=2)
{
thisbox->set_point(ccp(55,30+gezi_h+gezi_h*j));
boxgezi->addObject(thisbox);
}
break;
default:
break;
}
bid++;
}
}
vector<int> maua ;
for (int i = 0; i < boxgezi->count(); i++)
{
Zp_BoxData* bdata = (Zp_BoxData*)boxgezi->objectAtIndex(i);
Gzi* gz = new Gzi(allbd,bdata);
maua.push_back(bdata->get_boxid());
}
GlobalInfo::getInstance()->set_gizilist(maua);
CCMenuItemImage *item1 = CCMenuItemImage::create(IMG_ZP_START.c_str(), IMG_ZP_START0.c_str(), layer, menu_selector(TurntableSystem::runPlay));
item1->setPosition(ccp(cbd->getContentSize().width/2, cbd->getContentSize().height/2+10));
CCMenu *menu = CCMenu::create(item1, NULL);
menu->setPosition(CCPointZero);
cbd->addChild(menu, 0,TAG_ZP_PLAY);
allbd->addChild(cbd,2,TAG_ZP_ZHONGJIAN);
layer->addChild(allbd,3,TAG_ZP_BD);
}