void OctreeNode::subdivide(){ VoxelSize halfSize = getHalfSize(); if (halfSize > 1) { for (VoxelSize i = 0; i < 8; i++) { VoxelSize quarterSize = halfSize / 2; cout << "SIZE:" << +m_size << endl; Vector<3, VoxelSize> newOrigin({ VoxelSize(m_origin[Dimensions::X] + ((i & 4) ? quarterSize : -quarterSize)), VoxelSize(m_origin[Dimensions::Y] + ((i & 2) ? quarterSize : -quarterSize)), VoxelSize(m_origin[Dimensions::Z] + ((i & 1) ? quarterSize : -quarterSize)) }); m_children[i] = std::move(make_unique<OctreeNode>(m_block, getHalfSize(), newOrigin)); } } else { for (VoxelSize i = 0; i < 8; i++) { Vector<3, VoxelSize> newBottomLeft({ VoxelSize((i & 4) ? m_origin[Dimensions::X] : m_origin[Dimensions::X] - 1), VoxelSize((i & 2) ? m_origin[Dimensions::Y] : m_origin[Dimensions::Y] - 1), VoxelSize((i & 1) ? m_origin[Dimensions::Z] : m_origin[Dimensions::Z] - 1) }); m_children[i] = std::move(make_unique<OctreeNode>(m_block, getHalfSize(), newBottomLeft)); } } }
Entity::CollisionRect Boss::getCollisionRect() { CollisionRect rect; rect.myTopLeft = getPosition()-getHalfSize()-float2(2,2); rect.myBottomRight = getPosition()+getHalfSize()+float2(2,2); return rect; }
void BossSaw::draw( BITMAP *buffer, int offsetX, int offsetY, int layer ) { int x = getDrawPositionX() + offsetX - getHalfSize().x; int y = getDrawPositionY() + offsetY - getHalfSize().y; mySaw->drawFrame(buffer, myFrameCounter / 10, x, y); //Entity::draw(buffer, offsetX, offsetY, layer); }
Entity::CollisionRect Entity::getCollisionRect() { CollisionRect collisionRect; collisionRect.myTopLeft = getPosition()-getHalfSize(); collisionRect.myBottomRight = getPosition()+getHalfSize(); return collisionRect; }
void Boss::setTilesCollidable( bool aCollidable ) { int sx = (getPosition().x-getHalfSize().x)/10; int sy = (getPosition().y-getHalfSize().y)/10; for (int x = sx; x < sx + 3; x++) for (int y = sy; y < sy + 4; y++) mRoom->setCollidable(x, y, aCollidable); }
void Entity::draw(BITMAP *buffer, int offsetX, int offsetY, int layer) { int x = getDrawPositionX() + offsetX; int y = getDrawPositionY() + offsetY; int x1 = (int)(x - getHalfSize().x); int y1 = (int)(y - getHalfSize().y); int x2 = (int)(x + getHalfSize().x); int y2 = (int)(y + getHalfSize().y); rect(buffer, x1, y1, x2, y2, makecol(255, 255, 0)); line(buffer, x - 3, y, x + 3, y, makecol(255, 255, 0)); line(buffer, x, y - 3, x, y + 3, makecol(255, 255, 0)); //textout_centre_ex(buffer, font, typeid(this).name(), x, y - 9, makecol(200, 200, 200), 0); }
HRESULT cameraManager::init(float minX, float minY, float maxX, float maxY) { // 기본설정 setPivot(0.5f, 0.5f); RECT rt = RectMake(0, 0, WINSIZEX, WINSIZEY); setSize(static_cast<float>(rt.right), static_cast<float>(rt.bottom)); setPos(getHalfSize().width, getHalfSize().height); _minX = minX; _minY = minY; _maxX = maxX; _maxY = maxY; return S_OK; }
void Boss::draw( BITMAP *buffer, int offsetX, int offsetY, int layer ) { int x = getDrawPositionX() + offsetX - getHalfSize().x; int y = getDrawPositionY() + offsetY - getHalfSize().y; if (myState == State_Sleeping) myReactor->drawFrame(buffer, DAMAGE_MAX / FRAME_PER_DAMAGE - (myInitalHealth + 3) / FRAME_PER_DAMAGE, x , y ); else if (myState == State_InitialBlow) myReactor->drawFrame(buffer, 3, x , y ); else if (myState == State_Vulnerable) myBoss->drawFrame(buffer, 0, x, y); else myBoss->drawFrame(buffer, myAnimFrameCounter / 5, x, y); // Entity::draw(buffer, offsetX, offsetY, layer); }
void Shot::draw(BITMAP *buffer, int offsetX, int offsetY, int layer){ int x = getDrawPositionX(); int y = getDrawPositionY(); int frame; if(! hasCollided()){ frame = mFrame/10; mShotAnimation[mShotType]->drawFrame(buffer, frame, offsetX + x - mShotAnimation[mShotType]->getFrameWidth()/2, offsetY + y+getHalfSize().y-mShotAnimation[mShotType]->getFrameHeight()); } else { cFrame++; frame = cFrame/10; mCollisionAnimation[mShotType]->drawFrame(buffer, frame, offsetX + x - mCollisionAnimation[mShotType]->getFrameWidth()/2, offsetY + y+getHalfSize().y-mCollisionAnimation[mShotType]->getFrameHeight()); } }
void BoundingBox::transform(const Matrix4x4& transform) { Vector3 newCenter = (transform * Vector4(getCenter(), 1.0)).xyz(); Vector3 halfSize = getHalfSize(); Vector3 newHalfSize = Vector3( transform[0].xyz().absolute() * halfSize.x + transform[1].xyz().absolute() * halfSize.y + transform[2].xyz().absolute() * halfSize.z); set(newCenter - newHalfSize, newCenter + newHalfSize); }
void Savepoint::draw(BITMAP *buffer, int offsetX, int offsetY, int layer) { if (mTextCounter > 0) { mFont->drawCenter(buffer, "GAME SAVED", 0, 0, 320, 100); } mAnimation.drawFrame( buffer, mFrame / 4, offsetX + getDrawPositionX() - mAnimation.getFrameWidth() / 2, offsetY + getDrawPositionY() + getHalfSize().y - mAnimation.getFrameHeight() + 10); }
void MovableBox::draw(BITMAP *buffer, int offsetX, int offsetY, int layer) { int x = getDrawPositionX(); int y = getDrawPositionY(); int frame = 1; //frame = mFrame/4; bool gravityFlip = (getGravityDirection()>0)?false:true; mBoxAnimation.drawFrame(buffer, frame, offsetX + x - mBoxAnimation.getFrameWidth()/2, offsetY + y+getHalfSize().y-mBoxAnimation.getFrameHeight(), true,gravityFlip); }
void Powerup::draw(BITMAP *buffer, int offsetX, int offsetY, int layer) { if (GameState::getInt(mKind) != 0) { return; } int f = (mFrame / 4) % 4; if (mKind == GameState::POWERUP_HIJUMP) { f += 4; } else if (mKind == GameState::POWERUP_GUN) { f += 8; } mAnimation.drawFrame(buffer, f, offsetX + getDrawPositionX() - getHalfSize().x, offsetY + getDrawPositionY() - getHalfSize().y); }
void AxisAlignedBox::transformAffine(const Matrix4& m) { PE_ASSERT(m.isAffine()); // Do nothing if current null or infinite if (mExtent != EXTENT_FINITE) return; Vector3 centre = getCenter(); Vector3 halfSize = getHalfSize(); Vector3 newCentre = m.transformAffine(centre); Vector3 newHalfSize( Math::Abs(m[0][0]) * halfSize.x + Math::Abs(m[0][1]) * halfSize.y + Math::Abs(m[0][2]) * halfSize.z, Math::Abs(m[1][0]) * halfSize.x + Math::Abs(m[1][1]) * halfSize.y + Math::Abs(m[1][2]) * halfSize.z, Math::Abs(m[2][0]) * halfSize.x + Math::Abs(m[2][1]) * halfSize.y + Math::Abs(m[2][2]) * halfSize.z); setExtents(newCentre - newHalfSize, newCentre + newHalfSize); }
// Checks that set volume is contained in given child node. bool OctreeNode::fitsInChildOctant(VoxelSize childOctant, Vector<3, VoxelSize> insertionBottomLeft, VoxelSize size){ // m_hsize is the total size of any child node. VoxelSize hsize = getHalfSize(); if (hsize > size){ Vector<3, VoxelSize> childBottomLeft({ VoxelSize(m_origin[Dimensions::X] + ((childOctant & 4) ? 0 : -hsize)), // Calculate the bottom left front of the VoxelSize(m_origin[Dimensions::Y] + ((childOctant & 2) ? 0 : -hsize)), // child into which the volume may fit. VoxelSize(m_origin[Dimensions::Z] + ((childOctant & 1) ? 0 : -hsize)) }); Vector<3, VoxelSize> childTopRight({ VoxelSize(childBottomLeft[Dimensions::X] + hsize), // Using the above cordinate calculate VoxelSize(childBottomLeft[Dimensions::Y] + hsize), // the upper right back of the child node. VoxelSize(childBottomLeft[Dimensions::Z] + hsize) }); Vector<3, VoxelSize> insertionTopRight({ // Calculate the upper right back of the affected area. VoxelSize(insertionBottomLeft[Dimensions::X] + size), VoxelSize(insertionBottomLeft[Dimensions::Y] + size), VoxelSize(insertionBottomLeft[Dimensions::Z] + size) }); if (rangeInRange(childBottomLeft[Dimensions::X], childTopRight[Dimensions::X], insertionBottomLeft[Dimensions::X], insertionTopRight[Dimensions::X]) && rangeInRange(childBottomLeft[Dimensions::Y], childTopRight[Dimensions::Y], insertionBottomLeft[Dimensions::Y], insertionTopRight[Dimensions::Y]) && rangeInRange(childBottomLeft[Dimensions::Z], childTopRight[Dimensions::Z], insertionBottomLeft[Dimensions::Z], insertionTopRight[Dimensions::Z])){ return true; // Check for containment returning true if the range fits inside the child. } else{ return false; } } else{ return false; } }
void Hero::draw(BITMAP *buffer, int offsetX, int offsetY, int layer) { int x = getDrawPositionX(); int y = getDrawPositionY(); if (myIsDead) { mAnimationHurt.drawFrame(buffer, 0, offsetX + x - mAnimationHurt.getFrameWidth()/2, offsetY + y+getHalfSize().y-mAnimationHurt.getFrameHeight(), mFacingDirection == Direction_Left); return; } Animation* animation = 0; int frame = 1; // mMovementState = MovementState_Jump; switch(mMovementState) { case MovementState_Run: animation = &mAnimationRun; frame = mFrame/10; break; case MovementState_AirRun: animation = &mAnimationRun; frame = mFrame/3; break; case MovementState_Still: animation = &mAnimationRun; frame = 1; break; case MovementState_Jump: animation = &mAnimationJump; frame = 1; break; case MovementState_Fall: animation = &mAnimationFall; frame = 1; break; default: Entity::draw(buffer, offsetX, offsetY, layer); } if (mRopeState != RopeState_Retracted && (mRopeState != RopeState_Dissapearing || (mRopeDissapearCounter & 1) != 0)) { int x2 = getDrawPositionX() + offsetX; int y2 = getDrawPositionY() + offsetY; int x1 = (int)(mRopePosition.x + 0.5f) + offsetX; int y1 = (int)(mRopePosition.y + 0.5f) + offsetY; float2 line(x2-x1, y2-y1); int rlength = length(line); line /= length(line); line *= 3; float x = x1; float y = y1; int segments = (int)ceil(rlength/length(line)); for (int i = 0; i < segments; i++) { float2 wave; if ((mRopeState == RopeState_Moving || mRopeState == RopeState_Dissapearing) && segments > 1) { float t = i / (float)(segments - 1); float value = sin(t * 3.141592) * sin(i * 0.3f); wave = float2(line.y, -line.x) * value; } mAnimationRope.drawFrame(buffer, frame, x + wave.x - mAnimationRope.getFrameWidth()/2, y + wave.y - mAnimationRope.getFrameHeight()/2); x += line.x; y += line.y; } mAnimationHook.drawFrame(buffer, frame, x1 - mAnimationHook.getFrameWidth()/2, y1 - mAnimationHook.getFrameHeight()/2); } if (mBlinkingTicksLeft > 0 && !mOnGround) { animation = &mAnimationHurt; } if ((mBlinkingTicksLeft/6)%2 == 0) { animation->drawFrame(buffer, frame, offsetX + x - animation->getFrameWidth()/2, offsetY + y+getHalfSize().y-animation->getFrameHeight(), mFacingDirection == Direction_Left); } }
void Hero::draw(BITMAP *buffer, int offsetX, int offsetY, int layer) { if (mySpawnPortal) { return; } int x = getDrawPositionX(); int y = getDrawPositionY(); if (myIsDead) { bool gravityFlip = (getGravityDirection()>0)?false:true; mAnimationHurt.drawFrame(buffer, 0, offsetX + x - mAnimationHurt.getFrameWidth()/2, offsetY + y+getHalfSize().y-mAnimationHurt.getFrameHeight(), mFacingDirection == Direction_Left, gravityFlip); return; } Animation* animation = 0; int frame = 1; // mMovementState = MovementState_Jump; switch(mMovementState) { case MovementState_Run: animation = &mAnimationRun; frame = mFrame/5; break; case MovementState_Still: animation = &mAnimationRun; frame = 1; break; case MovementState_Jump: animation = &mAnimationJump; frame = 1; break; case MovementState_Fall: animation = &mAnimationFall; frame = 1; break; default: Entity::draw(buffer, offsetX, offsetY, layer); } if (mBlinkingTicksLeft > 0 && !mOnGround) { animation = &mAnimationHurt; } if ((mBlinkingTicksLeft/6)%2 == 0) { bool gravityFlip = (getGravityDirection()>0)?false:true; animation->drawFrame(buffer, frame, offsetX + x - animation->getFrameWidth()/2, offsetY + y + (gravityFlip ? -getHalfSize().y : getHalfSize().y - animation->getFrameHeight()), mFacingDirection == Direction_Left, gravityFlip); } }
unsigned int Entity::moveWithCollision(float2 delta) { int substeps = (int)ceil((abs(delta.x) + abs(delta.y)) * 0.2); delta /= substeps; unsigned int result = Direction_None; float2 halfSize = getHalfSize(); for (int i = 0; i < substeps; i++) { mPosition.x += delta.x; int x1 = (int)((mPosition.x - halfSize.x) / mRoom->getTileWidth()); int x2 = (int)((mPosition.x + halfSize.x) / mRoom->getTileWidth()); int y1n = (int)((mPosition.y - halfSize.y + 0.01f) / mRoom->getTileHeight()); int y2n = (int)((mPosition.y + halfSize.y - 0.01f) / mRoom->getTileHeight()); if (delta.x > 0) { for (int y = y1n; y <= y2n; y++) { if (mRoom->isCollidable(x2, y)) { delta.x = 0; result |= Direction_Right; mPosition.x = x2 * mRoom->getTileWidth() - halfSize.x; break; } } } else if (delta.x < 0) { for (int y = y1n; y <= y2n; y++) { if (mRoom->isCollidable(x1, y)) { delta.x = 0; result |= Direction_Left; mPosition.x = (x1 + 1) * mRoom->getTileWidth() + halfSize.x; break; } } } mPosition.y += delta.y; int y1 = (int)((mPosition.y - halfSize.y) / mRoom->getTileHeight()); int y2 = (int)((mPosition.y + halfSize.y) / mRoom->getTileHeight()); int x1n = (int)((mPosition.x - halfSize.x + 0.01f) / mRoom->getTileWidth()); int x2n = (int)((mPosition.x + halfSize.x - 0.01f) / mRoom->getTileWidth()); if (delta.y > 0) { for (int x = x1n; x <= x2n; x++) { if (mRoom->isCollidable(x, y2)) { delta.y = 0; result |= Direction_Down; mPosition.y = y2 * mRoom->getTileHeight() - halfSize.y; break; } } } else if (delta.y < 0) { for (int x = x1n; x <= x2n; x++) { if (mRoom->isCollidable(x, y1)) { delta.y = 0; result |= Direction_Up; mPosition.y = (y1 + 1) * mRoom->getTileHeight() + halfSize.y; } } } } return result; }
void SimpleWalkingMonster::update() { switch(mState) { case State_Walking: { mVelocity.y += 6.0f; mVelocity.x = 20.0f * ((mFacing==Facing_Left)?-1:1); setVelocity(mVelocity); int bumps = moveWithCollision(); if ((bumps & (Direction_Up | Direction_Down)) != 0) { mVelocity.y = 0; } if ((bumps & (Direction_Left)) != 0) { mFacing = Facing_Right; } if ((bumps & (Direction_Right)) != 0) { mFacing = Facing_Left; } int offsetX = (mState==Facing_Right)?-getHalfSize().x-2:getHalfSize().x+2; int offsetY = getHalfSize().y+2; float2 position = getPosition(); int x = (position.x+offsetX) / (float)mRoom->getTileWidth(); int y = (position.y+offsetY) / (float)mRoom->getTileHeight(); if (!mRoom->isCollidable(x, y)) { if (mFacing == Facing_Left) { mFacing = Facing_Right; } else { mFacing = Facing_Left; } } if (mRand.getFloat(1.0f) < WALK_TO_IDLE_CHANCE) { mState = State_Idling; } } break; case State_Idling: if (mRand.getFloat(1.0f) < IDLE_TO_WALK_CHANCE) { if (mRand.getFloat(1.0f) > 0.5) { mFacing = Facing_Left; } else { mFacing = Facing_Right; } mState = State_Walking; } break; } Hero* hero = mRoom->getHero(); if (Collides(hero->getCollisionRect(), getCollisionRect())) { hero->kill(); } mFrame++; }
void Spike::draw( BITMAP *buffer, int offsetX, int offsetY, int layer ) { float2 pos = getPosition()-getHalfSize(); mSpikeTile.onDraw(buffer, offsetX+pos.x, offsetY+pos.y); }