struct list *createList(int s) {
struct list *p;
p = malloc(sizeof(struct list));
p -> head = p -> tail = NULL;
SETSIZE(p, s);
return p;
};
void BackgroundLayer::createBackground(std::string filename)
{
bg = Sprite::create(filename);
bg->setAnchorPoint(Point::ZERO);
SETSIZE(bg, 1);
bg->setPosition(Point::ZERO);
this->addChild(bg);
tempBg = Sprite::create(filename);
tempBg->setAnchorPoint(Point(1, 0));
SETSIZE(tempBg, 1);
tempBg->setPosition(Point(visibleSize.width, 0));
tempBg->setVisible(false);
this->addChild(tempBg, 0);
bgWidth = bg->getContentSize().width * bg->getScaleY();
}
struct object * staticAllocate(int sz) {
staticPointer = WORDSDOWN(staticPointer, sz + 2);
if (staticPointer < staticBase) {
budd_panic_pointer("insufficient static memory", staticPointer);
}
SETSIZE(staticPointer, sz);
return(staticPointer);
}
struct object * staticIAllocate(int sz) {
int trueSize;
struct object *result;
trueSize = (sz + BytesPerWord - 1) / BytesPerWord;
result = staticAllocate(trueSize);
SETSIZE(result, sz);
result->size |= FLAG_BIN;
return result;
}
void GameScene::createQuitButton()
{
auto closeItem = MenuItemImage::create("CloseNormal.png", "CloseSelected.png", CC_CALLBACK_1(GameScene::quitGame, this));
closeItem->setPosition(Point(visibleSize.width / 2, 0));
closeItem->setAnchorPoint(Point(0.5f, 0));
SETSIZE(closeItem, 0.1);
auto menu = Menu::create(closeItem, NULL);
menu->setPosition(Point::ZERO);
this->addChild(menu, 1);
}
struct object * gcialloc(int sz) {
int trueSize;
struct object *result;
trueSize = (sz + BytesPerWord - 1) / BytesPerWord;
result = gcalloc(trueSize);
SETSIZE(result, sz);
result->size |= FLAG_BIN;
return result;
}
void GameScene::lose()
{
setBulletSpeed(0);
setTrashSpeed(0);
this->removeChild(player);
Sprite* s = Sprite::create("sprites/lose.png");
s->setPosition(Point(visibleSize.width / 2, visibleSize.height / 2));
SETSIZE(s, 0.3);
this->addChild(s);
}
struct object * gcalloc(int sz) {
struct object *result;
memoryPointer = WORDSDOWN(memoryPointer, sz + 2);
if (memoryPointer < memoryBase) {
return gcollect(sz);
}
SETSIZE(memoryPointer, sz);
return(memoryPointer);
}
void ButtonLayer::RGBRGBMode()
{
setUpRightButton(right, GREEN);
setDownRightButton(right, BLUE);
setUpLeftButton(left, GREEN);
setDownLeftButton(left, BLUE);
rS = Sprite::create();
changeSprite(rS, RED);
SETSIZE(rS, 0.1);
rS->setPosition(Point(right, (up+down)/2));
this->addChild(rS);
lS = Sprite::create();
changeSprite(lS, RED);
SETSIZE(lS, 0.1);
lS->setPosition(Point(left, (up+down)/2));
this->addChild(lS);
rightButtonFlag = true;
leftButtonFlag = true;
}
Obstacle* ColorWallLayer::createWall(std::string filename)
{
Sprite* wall;
wall = Sprite::createWithSpriteFrameName(filename);
SETSIZE(wall, 1);
wall->setAnchorPoint(Point(0, 0));
wall->setPosition(Point(origin.x + visibleSize.width, origin.y));
addChild(wall);
Obstacle* cw = Obstacle::create();
cw->wall = wall;
blockArray->pushBack(cw);
return cw;
}
void XMX_Button::XMX_Button_addButton(int id, Sprite* button, float size, int x, int y, Method press/* =NULL */, Method release/* =NULL */)
{
XMX_Button_Node* adding = XMX_Button_Node::create();
SETSIZE(button, size);
button->setPosition(Point(x,y));
adding->button = button;
addChild(adding->button);
adding->rect = button->getBoundingBox();
adding->onPress = press;
adding->onRelease = release;
adding->buttonFlag = true;
adding->allowFlag = true;
XMX_Button_addButton(id, adding);
}
void XMX_Button::XMX_Button_changeButton(int id, Sprite* button, float size, int x, int y)
{
XMX_Button_Node* p = XMX_Button_searchButton(id);
if (!p)
{
XMX_Button_addButton(id, button, size, x, y);
}
else
{
removeChild(p->button);
SETSIZE(button, size);
button->setPosition(Point(x,y));
p->button = button;
addChild(p->button);
p->rect = button->getBoundingBox();
}
}
void GameScene::setLead(Warrior* le)
{
moveableGroup->setLead(le);
informationGroup->addAllAttributes(le->getAllAttributes());
informationGroup->addNickNameAttributes(le->getNickName());
le->setAttributesChanged(false);
lead = le;
moveableGroup->removeChild(leadRound);
leadRound = Sprite::create("players/lead.png");
SETSIZE(leadRound, 0.11);
leadRound->setPosition(node[le->getPositionIndex()]);
moveableGroup->addChild(leadRound);
focusPoint(true, lead->getPositionIndex());
}
bool Trash::init()
{
#define TrashSize 0.12
bool bRet = false;
do
{
CC_BREAK_IF(!Node::init());
trash = Sprite::create("sprites/trash.png");
trash->setAnchorPoint(Point(0, 0.5));
SETSIZE(trash, TrashSize);
this->addChild(trash);
bRet = true;
} while (0);
return bRet;
}
void GameScene::win()
{
setBulletSpeed(0);
setTrashSpeed(0);
this->removeChild(enemy);
for (int i = danmakus.size() - 1; i >= 0; --i)
{
Danmaku* danmaku = danmakus.at(i);
danmakus.eraseObject(danmaku);
this->removeChild(danmaku);
}
Sprite* s = Sprite::create("sprites/win.png");
s->setPosition(Point(visibleSize.width / 2, visibleSize.height / 2));
SETSIZE(s, 0.3);
this->addChild(s);
}
struct object * gcollect(int sz) {
int i;
gccount++;
/* first change spaces */
if (globalBudd.inSpaceOne) {
memoryBase = globalBudd.spaceTwo;
globalBudd.inSpaceOne = 0;
oldBase = globalBudd.spaceOne;
} else {
memoryBase = globalBudd.spaceOne;
globalBudd.inSpaceOne = 1;
oldBase = globalBudd.spaceTwo;
}
memoryPointer = memoryTop = memoryBase + globalBudd.spaceSize;
oldTop = oldBase + globalBudd.spaceSize;
/* then do the collection */
for (i = 0; i < rootTop; i++) {
rootStack[i] = gc_move((struct mobject *)rootStack[i]);
}
for (i = 0; i < staticRootTop; i++) {
(*staticRoots[i]) = gc_move((struct mobject *)
*staticRoots[i]);
}
flushCache();
/* then see if there is room for allocation */
memoryPointer = WORDSDOWN(memoryPointer, sz + 2);
if (memoryPointer < memoryBase) {
budd_panic_int("insufficient memory after garbage collection", sz);
}
SETSIZE(memoryPointer, sz);
return(memoryPointer);
}
void Warrior::setWarriorSprite(Sprite* s, float size)
{
warrior = s;
SETSIZE(warrior, size);
addChild(warrior);
}
static struct object * gc_move(struct mobject *ptr) {
struct mobject *old_address = ptr, *previous_object = 0,
*new_address = 0, *replacement = 0;
int sz;
while (1) {
/*
* part 1. Walking down the tree
* keep stacking objects to be moved until we find
* one that we can handle
*/
for (;; ) {
/*
* SmallInt's are not proper memory pointers,
* so catch them first. Their "object pointer"
* value can be used as-is in the new space.
*/
if (IS_SMALLINT(old_address)) {
replacement = old_address;
old_address = previous_object;
break;
/*
* If we find a pointer in the current space
* to the new space (other than indirections) then
* something is very wrong
*/
} else if ((old_address >=
(struct mobject *)memoryBase)
&& (old_address <= (struct mobject *)memoryTop)) {
budd_panic_pointer(
"GC invariant failure -- address in new space",
old_address);
/* else see if not in old space */
} else if ((old_address < (struct mobject *)oldBase) ||
(old_address > (struct mobject *)oldTop)) {
replacement = old_address;
old_address = previous_object;
break;
/* else see if already forwarded */
} else if (old_address->size & FLAG_GCDONE) {
if (old_address->size & FLAG_BIN) {
replacement = old_address->data[0];
} else {
sz = SIZE(old_address);
replacement = old_address->data[sz];
}
old_address = previous_object;
break;
/* else see if binary object */
} else if (old_address->size & FLAG_BIN) {
int isz;
isz = SIZE(old_address);
sz = (isz + BytesPerWord - 1) / BytesPerWord;
memoryPointer = WORDSDOWN(memoryPointer,
sz + 2);
new_address = (struct mobject *)memoryPointer;
SETSIZE(new_address, isz);
new_address->size |= FLAG_BIN;
while (sz) {
new_address->data[sz] =
old_address->data[sz];
sz--;
}
old_address->size |= FLAG_GCDONE;
new_address->data[0] = previous_object;
previous_object = old_address;
old_address = old_address->data[0];
previous_object->data[0] = new_address;
/* now go chase down class pointer */
/* must be non-binary object */
} else {
sz = SIZE(old_address);
memoryPointer = WORDSDOWN(memoryPointer,
sz + 2);
new_address = (struct mobject *)memoryPointer;
SETSIZE(new_address, sz);
old_address->size |= FLAG_GCDONE;
new_address->data[sz] = previous_object;
previous_object = old_address;
old_address = old_address->data[sz];
previous_object->data[sz] = new_address;
}
}
/*
* part 2. Fix up pointers,
* move back up tree as long as possible
* old_address points to an object in the old space,
* which in turns points to an object in the new space,
* which holds a pointer that is now to be replaced.
* the value in replacement is the new value
*/
for (;; ) {
/* backed out entirely */
if (old_address == 0) {
return (struct object *)replacement;
}
/* case 1, binary or last value */
if ((old_address->size & FLAG_BIN) ||
(SIZE(old_address) == 0)) {
/* fix up class pointer */
new_address = old_address->data[0];
previous_object = new_address->data[0];
new_address->data[0] = replacement;
old_address->data[0] = new_address;
replacement = new_address;
old_address = previous_object;
} else {
sz = SIZE(old_address);
new_address = old_address->data[sz];
previous_object = new_address->data[sz];
new_address->data[sz] = replacement;
sz--;
/*
* quick cheat for recovering zero fields
*/
while (sz && (old_address->data[sz] == 0)) {
new_address->data[sz--] = 0;
}
SETSIZE(old_address, sz);
old_address->size |= FLAG_GCDONE;
new_address->data[sz] = previous_object;
previous_object = old_address;
old_address = old_address->data[sz];
previous_object->data[sz] = new_address;
break; /* go track down this value */
}
}
}
}
