GrMemoryPool::~GrMemoryPool() {
VALIDATE;
GrAssert(0 == fAllocationCnt);
GrAssert(fHead == fTail);
GrAssert(0 == fHead->fLiveCount);
DeleteBlock(fHead);
};
void GrMemoryPool::release(void* p) {
VALIDATE;
intptr_t ptr = reinterpret_cast<intptr_t>(p) - kPerAllocPad;
BlockHeader* block = *reinterpret_cast<BlockHeader**>(ptr);
if (1 == block->fLiveCount) {
// the head block is special, it is reset rather than deleted
if (fHead == block) {
fHead->fCurrPtr = reinterpret_cast<intptr_t>(fHead) +
kHeaderSize;
fHead->fLiveCount = 0;
fHead->fFreeSize = fPreallocSize;
} else {
BlockHeader* prev = block->fPrev;
BlockHeader* next = block->fNext;
GrAssert(prev);
prev->fNext = next;
if (next) {
next->fPrev = prev;
} else {
GrAssert(fTail == block);
fTail = prev;
}
DeleteBlock(block);
}
} else {
--block->fLiveCount;
}
GR_DEBUGCODE(--fAllocationCnt);
VALIDATE;
}
GrMemoryPool::~GrMemoryPool() {
VALIDATE;
SkASSERT(0 == fAllocationCnt);
SkASSERT(fHead == fTail);
SkASSERT(0 == fHead->fLiveCount);
DeleteBlock(fHead);
};
bool World::Build(Block * block,
const ushort x, const ushort y, const ushort z,
const quint8 dir, Block * const who, const bool anyway)
{
Block * const target_block = GetBlock(x, y, z);
if ( ENVIRONMENT!=target_block->Movable() && !anyway ) {
if ( who ) {
who->ReceiveSignal(tr("Cannot build here."));
}
return false;
} // else:
const int old_transparency = target_block->Transparent();
DeleteBlock(target_block);
block->Restore();
block->SetDir(dir);
block = ReplaceWithNormal(block);
SetBlock(block, x, y, z);
if ( old_transparency != block->Transparent() ) {
ReEnlightenBlockAdd(x, y, z);
}
const uchar block_light = block->LightRadius();
if ( block_light ) {
AddFireLight(x, y, z, block_light);
}
return true;
}
void DeleteBlock_CurrPos(
struct Tracker_Windows *window
){
struct WBlocks *wblock=window->wblock;
NInt blockpos;
PlayStop();
if(wblock->l.next==NULL && wblock==window->wblocks) return;
blockpos=window->wblock->l.num;
Undo_Block_Delete(blockpos);
DeleteBlock(blockpos);
wblock=ListFindElement1_r0(&window->wblocks->l,blockpos);
if(wblock==NULL){
wblock=ListLast1(&window->wblocks->l);
}
SelectWBlock(window,wblock);
BS_UpdateBlockList();
BS_UpdatePlayList();
}
Block * World::ReplaceWithNormal(Block * const block) const {
if ( block!=Normal(block->Sub()) && *block==*Normal(block->Sub()) ) {
const int sub=block->Sub();
DeleteBlock(block);
return Normal(sub);
} else {
return block;
}
}
void World::DestroyAndReplace(const ushort x, const ushort y, const ushort z) {
Block * const temp = GetBlock(x, y, z);
if ( temp->Durability() > 0 ) {
return;
}
Block * const dropped = temp->DropAfterDamage();
Shred * const shred = GetShred(x, y);
const ushort x_in_shred = Shred::CoordInShred(x);
const ushort y_in_shred = Shred::CoordInShred(y);
if ( PILE!=temp->Kind() && (temp->HasInventory() || dropped) ) {
Block * const new_pile=( ( dropped && PILE==dropped->Kind() ) ?
dropped : NewBlock(PILE, DIFFERENT) );
shred->SetBlock(new_pile, x_in_shred, y_in_shred, z);
Inventory * const inv = temp->HasInventory();
Inventory * const new_pile_inv = new_pile->HasInventory();
if ( inv ) {
new_pile_inv->GetAll(inv);
}
if ( dropped && PILE!=dropped->Kind() &&
!new_pile_inv->Get(dropped) )
{
DeleteBlock(dropped);
}
shred->AddFalling(x_in_shred, y_in_shred, z);
} else {
PutBlock(Normal(AIR), x, y, z);
}
const int old_transparency = temp->Transparent();
const uchar old_light = temp->LightRadius();
DeleteBlock(temp);
shred->AddFalling(x_in_shred, y_in_shred, z+1);
if ( old_transparency != INVISIBLE ) {
ReEnlightenBlockRemove(x, y, z);
}
if ( old_light ) {
RemoveFireLight(x, y, z);
}
} // void World::DestroyAndReplace(ushort x, y, z)
bool World::CanMove(const ushort x, const ushort y, const ushort z,
const ushort newx, const ushort newy, const ushort newz,
const quint8 dir)
{
if ( !InBounds(x, y, z) ) {
return false;
}
Block * const block = GetBlock(x, y, z);
if ( NOT_MOVABLE == block->Movable() ) {
return false;
}
Block * block_to = GetBlock(newx, newy, newz);
if ( ENVIRONMENT == block->Movable() ) {
if ( *block == *block_to ) {
return false;
} else if ( MOVABLE == block_to->Movable() ) {
NoCheckMove(x, y, z, newx, newy, newz, dir);
return true;
}
}
switch ( block_to->BeforePush(dir, block) ) {
case MOVE_SELF: block_to = GetBlock(newx, newy, newz); break;
case DESTROY:
DeleteBlock(block_to);
PutBlock(Normal(AIR), newx, newy, newz);
return true;
break;
case JUMP:
if ( DOWN!=dir && UP!=dir ) {
Jump(x, y, z, dir);
return false;
}
break;
case MOVE_UP:
if ( DOWN!=dir && UP!=dir ) {
Move(x, y, z, UP);
return false;
}
break;
case DAMAGE:
Damage(x, y, z,
block_to->DamageLevel(),
block_to->DamageKind());
return false;
break;
}
return ( ENVIRONMENT==block_to->Movable() );/* ||
( (block->Weight() > block_to->Weight()) &&
Move(newx, newy, newz, dir) ) );*/
} // bool World::CanMove(ushort x, y, z, newx, newy, newz, quint8 dir)
void World::Damage(const ushort x, const ushort y, const ushort z,
const ushort dmg, const int dmg_kind)
{
Block * temp = GetBlock(x, y, z);
if ( temp==Normal(temp->Sub()) && AIR!=temp->Sub() ) {
SetBlock((temp=NewBlock(temp->Kind(), temp->Sub())), x, y, z);
}
if ( temp->Damage(dmg, dmg_kind) > 0 ) {
temp->ReceiveSignal(SOUND_STRINGS[1]); // "Ouch!"
if ( block_manager.MakeId(BLOCK, STONE)==temp->GetId() &&
temp->Durability()!=MAX_DURABILITY )
{ // convert stone into ladder
DeleteBlock(temp);
SetBlock(NewBlock(LADDER, STONE), x, y, z);
emit ReEnlighten(x, y, z);
} else {
SetBlock(ReplaceWithNormal(temp), x, y, z);
}
}
}
bool CheckBlockList(struct in_addr* piaPeer)
{
block_node* pBlock = FindBlock(piaPeer);
// true means not blocked and can connect
// false means block still in effect
if (!pBlock)
return true;
if (pBlock->iExpires < 0)
return false;
if (pBlock->iExpires <= GetTime())
{
DeleteBlock(piaPeer);
return true;
}
return false;
}
void GrMemoryPool::release(void* p) {
VALIDATE;
intptr_t ptr = reinterpret_cast<intptr_t>(p) - kPerAllocPad;
AllocHeader* allocData = reinterpret_cast<AllocHeader*>(ptr);
SkASSERT(kAssignedMarker == allocData->fSentinal);
SkDEBUGCODE(allocData->fSentinal = kFreedMarker);
BlockHeader* block = allocData->fHeader;
SkASSERT(kAssignedMarker == block->fBlockSentinal);
if (1 == block->fLiveCount) {
// the head block is special, it is reset rather than deleted
if (fHead == block) {
fHead->fCurrPtr = reinterpret_cast<intptr_t>(fHead) + kHeaderSize;
fHead->fLiveCount = 0;
fHead->fFreeSize = fPreallocSize;
} else {
BlockHeader* prev = block->fPrev;
BlockHeader* next = block->fNext;
SkASSERT(prev);
prev->fNext = next;
if (next) {
next->fPrev = prev;
} else {
SkASSERT(fTail == block);
fTail = prev;
}
fSize -= block->fSize;
DeleteBlock(block);
SkDEBUGCODE(fAllocBlockCnt--);
}
} else {
--block->fLiveCount;
// Trivial reclaim: if we're releasing the most recent allocation, reuse it
if (block->fPrevPtr == ptr) {
block->fFreeSize += (block->fCurrPtr - block->fPrevPtr);
block->fCurrPtr = block->fPrevPtr;
}
}
SkDEBUGCODE(--fAllocationCnt);
VALIDATE;
}
void *Undo_Do_Block_Split(
struct Tracker_Windows *window,
struct WBlocks *wblock,
struct WTracks *wtrack,
int realline,
void *pointer
){
struct Undo_Block_MergeSplit *ubm=(struct Undo_Block_MergeSplit *)pointer;
struct WBlocks *wblocktemp=NULL;
if(ubm->nwblock==NULL){
//Undo
ubm->nwblock=CB_CopyBlock(wblock);
// wblocktemp=CB_CopyBlock((struct WBlocks*)ListPrevElement1(&window->wblocks->l,&wblock->l));
wblocktemp=CB_CopyBlock(NextWBlock(wblock));
CB_PasteBlock(window,ubm->wblock,wblock);
DeleteBlock(ubm->blockpos+1);
ubm->wblock=wblocktemp;
}else{
//Redo
InsertBlock(ubm->blockpos,20,20,"n");
wblocktemp=CB_CopyBlock(wblock);
CB_PasteBlock(window,ubm->wblock,wblock);
CB_PasteBlock(window,ubm->nwblock,(struct WBlocks*)ListPrevElement1(&window->wblocks->l,&wblock->l));
ubm->wblock=wblocktemp;
ubm->nwblock=NULL;
}
BS_UpdateBlockList();
BS_UpdatePlayList();
return ubm;
}
void *Undo_Do_Block_Insert(
struct Tracker_Windows *window,
struct WBlocks *wblock,
struct WTracks *wtrack,
int realline,
void *pointer
){
struct Undo_Block_InsertDelete *ubi=(struct Undo_Block_InsertDelete *)pointer;
if(ubi->wblock!=NULL){
return Undo_Do_Block_Delete(window,wblock,wtrack,realline,pointer);
}
ubi->wblock=(struct WBlocks *)ListFindElement1(&window->wblocks->l,ubi->blockpos);
DeleteBlock(ubi->blockpos);
SEQUENCER_create_from_state(ubi->sequencer_state);
BS_UpdateBlockList();
BS_UpdatePlayList();
return ubi;
}
