//加入人走过的路径
struct sokomap * addPersonWalkPath(struct sokomap *map)
{
struct sokomap *current_map = map;
struct sokomap *nxt_map = NULL;
struct sokomap *tmp_map1 = NULL,*tmp_map2 = NULL;
while(current_map)
{
nxt_map = current_map -> next;
if(nxt_map != NULL)
{
struct mappos * pos = personWalkPath(current_map,nxt_map);
pos = pos -> next;
while(pos)
{
//复制一个地图
tmp_map1 = copyMap(current_map);
tmp_map2 = current_map -> next;
current_map -> next = tmp_map1;
tmp_map1 -> parent = current_map;
tmp_map1 -> next = tmp_map2;
tmp_map2 -> parent = tmp_map1;
setPerson_xy(tmp_map1,pos->x,pos->y);
current_map = tmp_map1;
pos = pos -> next;
}
freeMappos(pos);
}
current_map = nxt_map;
}
}
GLColorMap& GLColorMap::setColors(GLsizei newNumEntries,const GLColorMap::Color* newEntries)
{
/* Copy entry array: */
copyMap(newNumEntries,newEntries,min,max);
return *this;
}
//计算地图的列表
struct sokomap * caculatePath(struct sokomap *map)
{
struct sokomap *current,*currentHeader;//当前各个地图列表,failHeader失败的列表
struct sokomap *retSokomap = NULL;//要返回的列表
struct sokomap *currentTail;
int box_count,wall_count,person_count,dest_count;
mapProperyCount(map,&wall_count,&box_count,&person_count,&dest_count);//计算箱子的个数
struct mappos * boxPos = (struct mappos*) malloc(sizeof(struct mappos)*box_count);
//生成头节点
currentHeader = copyMap(map);
//进行循环的操作
current = currentHeader;
currentTail = current;
//循环的操作
int flag = 0;
while(current)
{
if(isMapSuccess(current))
{
flag = 1;
break;
}
addNxtStep(currentHeader,¤tTail,current,boxPos,box_count);
current = current -> next;
}
if(flag)
{
//成功的地图，进行一些必要的保存步骤的操作
struct sokomap * tmpSokoPtr = NULL;
while(current)
{
retSokomap = copyMap(current);
retSokomap -> parent = NULL;
retSokomap->next = tmpSokoPtr;
//设置父亲节点
if(tmpSokoPtr)
{
tmpSokoPtr -> parent = retSokomap;
}
tmpSokoPtr = retSokomap;
current = current -> parent;
}
}
//清除内存的操作
freeMap(currentHeader);
return retSokomap;
}
GLColorMap& GLColorMap::operator=(const GLColorMap& source)
{
if(this!=&source)
{
/* Copy entry array: */
copyMap(source.numEntries,source.entries,source.min,source.max);
}
return *this;
}
// copies the data from the given bitvector to this bitvector.
// returns true if this results in a change in this bitvector or false otherwise
// (change = among the variables mapped by bitvector src)
// if there's a variable in srcMap that is not in this, this variable's mapping is copied to this
// if there's a variable in this that is not in srcMap, it is unchanged
bool VarBitVector::copy(VarBitVector& src)
{
// cout <<"copy() src="<<src<<"\n";
bool modified = !this->initialized ||
(this->initialized != src.initialized);
this->initialized = src.initialized;
bool modifiedCopy = copyMap(src.varMap);
return modified || modifiedCopy;
}
// computes the union of this bitvector and the given bitvector, updating this bitvector to be that union
bool VarBitVector::unionUpdate(VarBitVector &other)
{
VarBitVector *vecUnion = unionVec(other);
// if the union is different from this bitvector's initial value
if ((*this) != (*vecUnion))
{
// copy the new union into the current bitvector
copyMap(vecUnion->varMap);
delete vecUnion;
return true; // inform the caller that this bitvector has changed
}
else
return false; // inform the caller that this bitvector has not changed
}
// computes the intersection of this bitvector and the given bitvector, updating this bitvector to be that intersection
bool VarBitVector::intersectUpdate(VarBitVector &other)
{
VarBitVector *inter = intersectVec(other);
// if the intersection is different from this bitvector's initial value
if ((*this) != (*inter))
{
// copy the new intersection into the current bitvector
copyMap(inter->varMap);
delete inter;
return true; // inform the caller that this bitvector has changed
}
else
return false; // inform the caller that this bitvector has not changed
}
int gameoflife()
{
int row, col;
char ans;
init();
while(1)
{
outputMap();
for(row = 0; row < MAXROW; row++)
{
for(col = 0; col < MAXCOL; col++)
{
switch (neighbors(row, col))
{
case 0:
case 1:
case 4:
case 5:
case 6:
case 7:
case 8:
newmap[row][col] = DEAD;
break;
case 2:
newmap[row][col] = map[row][col];
break;
case 3:
newmap[row][col] = ALIVE;
break;
}
}
}
copyMap();
printf("\nContinue next Generation ? ");
getchar();
ans = toupper(getchar());
if(ans != 'Y') break;
}
return 0;
}
void mirrorMap()
{
//--------------------------------------------------------------
// mirror map
//--------------------------------------------------------------
// normalMirroring()
int swapXa = pickFrom2(-1,1, 1,advancedMirrorOK_G);
int swapYa = pickFrom2(-1,advancedMirrorOK_G, 1,1);
int swapXb = pickFrom2(-1,advancedMirrorOK_G, 1,1);
int swapYb = pickFrom2(-1,1, 1,advancedMirrorOK_G);
switch (mirrorTypeG)
{
case NORMALMIRROR: //four quadrants
//ABCBA
//DEFED
//GHIHG
//DEFED
//ABCBA
copyMap(mapCornerMaxG, 0, swapXa, swapYa);
copyMap(0, mapCornerMaxG, swapXb, swapYb);
copyMap(mapCornerMaxG, mapCornerMaxG, swapXa*swapXb, swapYa*swapYb);
break;
case XOFFSETMIRROR: //Like normal, but one half is moved horizontally by 1/4 totalmapsize
//ABABABABA
//DEFGHGFED
//CDCDCDCDC
//FGHGFEDEF
//ABABABABA
if (swapYa == -1) //ensures fairness
swapXb = -1;
copyMap(mapCornerMaxG, 0, 1, swapYa);
copyMap(mapCornerMaxG/2, mapCornerMaxG, swapXb, swapYb);
copyMap(mapCornerMaxG*3/2, mapCornerMaxG, swapXb, swapYa*swapYb);
break;
case YOFFSETMIRROR: //Like normal, but one half is moved vertically by 1/4 totalmapsize
if (swapXb == -1) //ensures fairness
swapYa = -1;
copyMap(mapCornerMaxG, mapCornerMaxG/2, swapXa, swapYa);
copyMap(0, mapCornerMaxG, swapXb, 1);
copyMap(mapCornerMaxG, mapCornerMaxG*3/2, swapXa*swapXb, swapYa);
break;
case MAXDISTMIRROR: //Allows maximum distance between starting points
default:
//ABCDCBA
//E*GHIJE
//HIJE*GH
//DCBABCD
//HG*EJIH
//EJIHG*E
//ABCDCBA
copyMap(mapCornerMaxG, 0, 1, -1);
copyMap(0, mapCornerMaxG, -1, 1);
copyMap(mapCornerMaxG, mapCornerMaxG, -1, -1);
}
}
//增加下一个地图的步骤
void addNxtStep(struct sokomap *header,struct sokomap **currentTail,struct sokomap *current,struct mappos * boxPos,int boxCount)
{
//计算人所在的列表
if(current->pos==NULL)
{
current->pos = personCanWalkPoint(current);
}
getBoxList(current,boxPos);
//进行循环判断箱子可以移动的方向
for(int i=0;i < boxCount;i++)
{
int x = boxPos[i].x;
int y = boxPos[i].y;
//向上推的操作
if(isCanPushUp(current,x,y))
{
if(isInMappos(current->pos,boxPos[i].x,boxPos[i].y+1))
{
struct sokomap * tmpMap = copyMap(current);
tmpMap ->parent = current;
pushUp(tmpMap,x,y);
//判断地图是否已经棍了,没棍的话就加入到尾步
if(isMapDead(tmpMap,x,y+1,UP))
{
freeMap(tmpMap);
}else if(isInSokoMap(header,tmpMap))//已经在列表中，就把这个新地图删除
{
freeMap(tmpMap);
}else
{
(*currentTail)->next = tmpMap;
*currentTail = tmpMap;
}
}
}
//向下推的操作
if(isCanPushDown(current,boxPos[i].x,boxPos[i].y))
{
if(isInMappos(current->pos,boxPos[i].x,boxPos[i].y - 1))
{
struct sokomap * tmpMap = copyMap(current);
tmpMap ->parent = current;
pushDown(tmpMap,x,y);
//判断地图是否已经棍了,没棍的话加入到尾部
if(isMapDead(tmpMap,x,y-1,DOWN))
{
freeMap(tmpMap);
}else if(isInSokoMap(header,tmpMap))//已经在列表中，就把这个新地图删除
{
freeMap(tmpMap);
}else
{
(*currentTail)->next = tmpMap;
*currentTail = tmpMap;
}
}
}
//向左推的操作
if(isCanPushLeft(current,boxPos[i].x,boxPos[i].y))
{
if(isInMappos(current->pos,boxPos[i].x + 1,boxPos[i].y))
{
struct sokomap * tmpMap = copyMap(current);
tmpMap ->parent = current;
pushLeft(tmpMap,x,y);
//判断地图是否已经棍了,没棍的话加入到尾部
if(isMapDead(tmpMap,x - 1,y,LEFT))
{
freeMap(tmpMap);
}else if(isInSokoMap(header,tmpMap))//已经在列表中，就把这个新地图删除
{
freeMap(tmpMap);
}else
{
(*currentTail)->next = tmpMap;
*currentTail = tmpMap;
}
}
}
//向右推的操作
if(isCanPushRight(current,boxPos[i].x,boxPos[i].y))
{
if(isInMappos(current->pos,boxPos[i].x - 1,boxPos[i].y))
{
struct sokomap * tmpMap = copyMap(current);
tmpMap ->parent = current;
pushRight(tmpMap,x,y);
//判断地图是否已经棍了,没棍的话加入到尾部
if(isMapDead(tmpMap,x + 1,y,RIGHT))
{
freeMap(tmpMap);
}else if(isInSokoMap(header,tmpMap))//已经在列表中，就把这个新地图删除
{
freeMap(tmpMap);
}else
{
(*currentTail)->next = tmpMap;
*currentTail = tmpMap;
}
}
}
}
}
GLColorMap::GLColorMap(const GLColorMap& source)
:numEntries(0),entries(0)
{
/* Copy entry array: */
copyMap(source.numEntries,source.entries,source.min,source.max);
}
GLColorMap::GLColorMap(GLsizei sNumEntries,const GLColorMap::Color* sEntries,GLdouble sMin,GLdouble sMax)
:numEntries(0),entries(0),min(sMin),max(sMax)
{
/* Copy entry array: */
copyMap(sNumEntries,sEntries,sMin,sMax);
}
void vblank(void) {
#ifdef WIN
drawFramebuffer();
#endif
#ifdef PS4
void readController(void);
readController();
extern unsigned int buttons;
keys.c = (unsigned char)buttons;
sceKernelUsleep(1000000 / 60);
#endif
#ifdef DS
// The Game Boy and DS use the same key layout, how convenient :)
keys.c = (unsigned char)REG_KEYINPUT;
// Support scrolling
copyMap();
#endif
#ifdef GC
VIDEO_WaitVSync();
#endif
#ifdef DS3
hidScanInput();
u32 kHeld = hidKeysHeld();
keys.keys1 = 0x0f;
keys.keys2 = 0x0f;
if(kHeld & KEY_B) keys.b = 0;
if(kHeld & KEY_A) keys.a = 0;
if(kHeld & KEY_START) keys.start = 0;
if(kHeld & KEY_SELECT) keys.select = 0;
if(kHeld & KEY_UP) keys.up = 0;
if(kHeld & KEY_DOWN) keys.down = 0;
if(kHeld & KEY_LEFT) keys.left = 0;
if(kHeld & KEY_RIGHT) keys.right = 0;
//gfxFlushBuffers();
gspWaitForVBlank();
gfxSwapBuffers();
if(!aptMainLoop() || ((kHeld & KEY_START) && (kHeld & KEY_SELECT) && (kHeld & KEY_L) && (kHeld & KEY_R))) quit();
#endif
#ifdef LIN
drawFramebuffer();
#endif
#ifdef PSP
SceCtrlData pad;
sceCtrlReadBufferPositive(&pad, 1);
keys.keys1 = 0x0f;
keys.keys2 = 0x0f;
if(pad.Buttons & PSP_CTRL_SQUARE) keys.b = 0;
if(pad.Buttons & PSP_CTRL_CROSS) keys.a = 0;
if(pad.Buttons & PSP_CTRL_START) keys.start = 0;
if(pad.Buttons & PSP_CTRL_SELECT) keys.select = 0;
if(pad.Buttons & PSP_CTRL_UP) keys.up = 0;
if(pad.Buttons & PSP_CTRL_DOWN) keys.down = 0;
if(pad.Buttons & PSP_CTRL_LEFT) keys.left = 0;
if(pad.Buttons & PSP_CTRL_RIGHT) keys.right = 0;
sceDisplayWaitVblankStart();
#endif
interrupt.master = 0;
writeShortToStack(registers.pc);
registers.pc = 0x40;
ticks += 12;
}
