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);
}
