void WeaponSystem::Process(float _deltaTime, SystemRequierements& _provided)
{
//loading times and energy given are proportional
float energyRatio = m_energyIn / m_energyDemand;
//load weapons with the given energy
for (auto& weapon : m_weapons)
weapon.cooldown -= ei::min(weapon.cooldown, _deltaTime / weapon.cooldownBase * energyRatio);
//fire when commanded
if (!m_firing) return;
for (auto& weapon : m_weapons)
{
if (weapon.cooldown <= 0.f)
{
weapon.cooldown = weapon.cooldownBase;
Ray ray(weapon.position, m_ship.GetRotationMatrix() * Vec3(0.f, 0.f, 1.f)/*zaxis(m_ship.GetRotation())*/);
ray.origin = m_ship.GetRotationMatrix() * ray.origin;
//when the player ship is not in the way
// if (!m_ship.GetVoxelTree().RayCast(ray, 1, hit, distance))
{
Vec3 basePos(m_ship.GetPosition() - m_particles.GetPosition());
basePos += ray.origin;
Math::WorldRay wRay;
wRay.origin = m_ship.GetPosition();
wRay.origin.x += Math::Fix(ray.origin.x);
wRay.origin.y += Math::Fix(ray.origin.y);
wRay.origin.z += Math::Fix(ray.origin.z);
wRay.direction = ray.direction;
float d = g_fireManager->FireRay(FireRayInfo(wRay, weapon.damage));
for (int i = 0; i < 10; ++i)
m_particles.AddParticle(basePos, //position
ray.direction * c_projVel * i / 10.f,// velocity
d / c_projVel, //life time
Utils::Color8U(0.4f, 0.1f, 0.8f).RGBA(),
1.f);
//temporary, hit feedback should be done by the model?
if (d != 100.f)
{
static Generators::Random rng(351298);
Vec3 hitPos(basePos + ray.direction * d);
for (int i = 0; i < 50; ++i)
m_particles.AddParticle(hitPos, //position
Vec3(rng.Uniform(0.1f, 3.0f), rng.Uniform(0.1f,3.0f), rng.Uniform(0.1f, 3.0f)),// velocity
rng.Uniform(0.2f, 1.f), //life time
Utils::Color8U(0.15f, 0.2f, 0.2f).RGBA(),
0.5f);
}
}
}
}
}
CompoundBodiesDemo::CompoundBodiesDemo(hkDemoEnvironment* env)
: hkDefaultPhysicsDemo(env)
{
//
// Setup the camera
//
{
hkVector4 from(0.0f, 10.0f, 30.0f);
hkVector4 to (0.0f, 0.0f, 0.0f);
hkVector4 up (0.0f, 1.0f, 0.0f);
setupDefaultCameras( env, from, to, up );
}
//
// Create the world
//
{
hkpWorldCinfo info;
info.setBroadPhaseWorldSize( 100.0f );
info.setupSolverInfo(hkpWorldCinfo::SOLVER_TYPE_4ITERS_MEDIUM);
m_world = new hkpWorld( info );
m_world->lock();
// Register ALL agents (though some may not be necessary)
hkpAgentRegisterUtil::registerAllAgents(m_world->getCollisionDispatcher());
setupGraphics();
}
// Create the base
{
hkVector4 baseSize( 20.0f, 1.0f, 20.0f);
hkVector4 basePos( 0.0f,-0.5f, 0.0f);
hkpRigidBody* baseRigidBody = GameUtils::createBox(baseSize, 0.0f, basePos);
m_world->addEntity( baseRigidBody );
baseRigidBody->removeReference();
}
hkPseudoRandomGenerator generator(747);
// Create 10 wibblies
for(int i = 0; i < 10; i++)
{
hkVector4 pos( generator.getRandRange(-3.0f,3.0f) , i * 3.0f + 1.5f, generator.getRandRange(-3.0f,3.0f));
hkpRigidBody* wibbly = createWibbly(pos, &generator);
m_world->addEntity( wibbly );
wibbly->removeReference();
hkVector4 vel(generator.getRandRange(-2.0f,2.0f), generator.getRandRange(-2.0f,2.0f), generator.getRandRange(-2.0f,2.0f));
wibbly->setAngularVelocity(vel);
}
m_world->unlock();
}
void CGrassDrawer::CreateGrassDispList(int listNum)
{
CVertexArray* va = GetVertexArray();
va->Initialize();
for (int a = 0; a < strawPerTurf; ++a) {
const float maxAng = mapInfo->grass.bladeAngle * rng.RandFloat();
const float length = mapInfo->grass.bladeHeight + mapInfo->grass.bladeHeight * rng.RandFloat();
float3 sideVect(rng.RandFloat() - 0.5f, 0.0f, rng.RandFloat() - 0.5f);
sideVect.ANormalize();
float3 forwardVect = sideVect.cross(UpVector);
sideVect *= mapInfo->grass.bladeWidth;
float3 basePos(30.0f, 0.0f, 30.0f);
while (basePos.SqLength2D() > (turfSize * turfSize / 4)) {
basePos = float3(rng.RandFloat() - 0.5f, 0.f, rng.RandFloat() - 0.5f) * turfSize;
}
const float xtexCoord = int(14.9999f * rng.RandFloat()) / 16.0f;
const int numSections = 1 + int(maxAng * 5.0f);
// draw single blade
for (float h = 0; h <= 1.0f; h += (1.0f / numSections)) {
const float ang = maxAng * h;
const float3 edgePos = (UpVector * std::cos(ang) + forwardVect * std::sin(ang)) * length * h;
const float3 edgePosL = edgePos - sideVect * (1.0f - h);
const float3 edgePosR = edgePos + sideVect * (1.0f - h);
if (h == 0.0f) {
// start with a degenerated triangle
va->AddVertexT(basePos + edgePosR - float3(0.0f, 0.1f, 0.0f), xtexCoord, h);
va->AddVertexT(basePos + edgePosR - float3(0.0f, 0.1f, 0.0f), xtexCoord, h);
} else {
va->AddVertexT(basePos + edgePosR, xtexCoord, h);
}
va->AddVertexT(basePos + edgePosL, xtexCoord + (1.0f / 16), h);
}
// end with a degenerated triangle
// -> this way we can render multiple blades in a single GL_TRIANGLE_STRIP
const float3 edgePos = (UpVector * std::cos(maxAng) + forwardVect * std::sin(maxAng)) * length;
va->AddVertexT(basePos + edgePos, xtexCoord + (1.0f / 32), 1.0f);
va->AddVertexT(basePos + edgePos, xtexCoord + (1.0f / 32), 1.0f);
}
glNewList(listNum, GL_COMPILE);
va->DrawArrayT(GL_TRIANGLE_STRIP);
glEndList();
}
// ============================================================================
// Constructor
AntiAirBattery::AntiAirBattery ( World* pWorld, double location, double angle ) : Machine ( pWorld )
{
setLayers( PhysLayerBuildings );
setRenderLayer( LayerBuildings );
setName("Flak");
double locationY = world()->ground()->height( location );
b2Vec2 basePos( location, locationY );
b2Vec2 bodyPos( location, locationY + 1.5 );
// create damage manager
_dmMain = new DamageManager();
addDamageManager( _dmMain );
_bodyMain = BodyProvider::loadBody( "installations/flak1-body.body" );
_bodyMain->setPosition( bodyPos );
_bodyMain->create( pWorld );
addBody( _bodyMain, BodyRendered1 );
_bodyBase = BodyProvider::loadBody( "installations/flak1-base.body" );
_bodyBase->setPosition( basePos );
_bodyBase->create( pWorld );
addBody( _bodyBase, BodyRendered1 );
setMainBody( _bodyBase );
_bodyMain->setDamageManager( _dmMain );
// create gun
_sysGun = Gun::berezin( this, "Gun" );
_sysGun->setBody( _bodyMain );
_sysGun->setMuzzle( QPointF( 0.0, 0.0 ) );
_sysGun->setMuzzleShift( 4.0 );
_sysGun->setNormal( QPointF( cos( angle), sin(angle) ) );
addSystem( _sysGun, SystemSimulated );
// create operator
_sysOperator = new AntiAirGunOperator( this, "operator" );
_sysOperator->setGun( _sysGun );
_sysOperator->setMinAngle( 0.5 );
_sysOperator->setMaxAngle( M_PI/2 );
_sysOperator->setDamageCapacity( 100E3 );
addSystem( _sysOperator, SystemSimulated );
_lastDisplayedAngle = 0.5; // min angle from zenith;
// add systems to damage manager
_dmMain->addSystem( _sysGun, 1 );
_dmMain->addSystem( _sysOperator, 1 );
_dmMain->addSystem( NULL, 2 );
}
void Line::computeVertices()
{
Matrix<double> eff_pos_a = effectivePosA();
Matrix<double> eff_pos_b = effectivePosB();
Matrix<double> base_pos = basePos();
p_vertices[0] = eff_pos_a[0];
p_vertices[1] = eff_pos_a[1];
p_vertices[2] = eff_pos_a[2];
p_vertices[3] = eff_pos_b[0];
p_vertices[4] = eff_pos_b[1];
p_vertices[5] = eff_pos_b[2];
p_vertices[6] = base_pos[0];
p_vertices[7] = base_pos[1];
p_vertices[8] = base_pos[2];
p_vertices[9] = base_pos[0] + p_a[0];
p_vertices[10] = base_pos[1] + p_a[1];
p_vertices[11] = base_pos[2] + p_a[2];
p_vertices[12] = base_pos[0] + p_b[0];
p_vertices[13] = base_pos[1] + p_b[1];
p_vertices[14] = base_pos[2] + p_b[2];
p_vertices[15] = base_pos[0] + p_c[0];
p_vertices[16] = base_pos[1] + p_c[1];
p_vertices[17] = base_pos[2] + p_c[2];
p_vertices[18] = base_pos[0] + p_a[0] + p_b[0];
p_vertices[19] = base_pos[1] + p_a[1] + p_b[1];
p_vertices[20] = base_pos[2] + p_a[2] + p_b[2];
p_vertices[21] = base_pos[0] + p_b[0] + p_c[0];
p_vertices[22] = base_pos[1] + p_b[1] + p_c[1];
p_vertices[23] = base_pos[2] + p_b[2] + p_c[2];
p_vertices[24] = base_pos[0] + p_c[0] + p_a[0];
p_vertices[25] = base_pos[1] + p_c[1] + p_a[1];
p_vertices[26] = base_pos[2] + p_c[2] + p_a[2];
p_vertices[27] = base_pos[0] + p_a[0] + p_b[0] + p_c[0];
p_vertices[28] = base_pos[1] + p_a[1] + p_b[1] + p_c[1];
p_vertices[29] = base_pos[2] + p_a[2] + p_b[2] + p_c[2];
p_verts_computed = true;
}
//----------------------------------------------------------------------------//
void ScrollablePane::updateContainerPosition(void)
{
// basePos is the position represented by the scrollbars
// (these are negated so pane is scrolled in the correct directions)
UVector2 basePos(cegui_absdim(-getHorzScrollbar()->getScrollPosition()),
cegui_absdim(-getVertScrollbar()->getScrollPosition()));
// this bias is the absolute position that 0 on the scrollbars represent.
// Allows the pane to function correctly with negatively positioned content.
UVector2 bias(cegui_absdim(d_contentRect.d_min.d_x),
cegui_absdim(d_contentRect.d_min.d_y));
// set the new container pane position to be what the scrollbars request
// minus any bias generated by the location of the content.
getScrolledContainer()->setPosition(basePos - bias);
}
void ScrollablePane::updateContainerPosition(void)
{
assert(d_container != 0);
assert(d_horzScrollbar != 0);
assert(d_vertScrollbar != 0);
// basePos is the position represented by the scrollbars
// (these are negated so pane is scrolled in the correct directions)
Point basePos(-d_horzScrollbar->getScrollPosition(), -d_vertScrollbar->getScrollPosition());
// this bias is the absolute position that 0 on the scrollbars represent.
// effectively removes un-used empty space from the pane.
Point bias(d_contentRect.d_left, d_contentRect.d_top);
// set the new container pane position to be what the scrollbars request
// minus any bias generated by the location of the content.
d_container->setPosition(Absolute, basePos - bias);
}
/*! @brief Determines the IDs of mobile objects that should be visible for a given field position.
@param x x position of observer.
@param y y position of observer.
@param heading Heading of observer.
@param headYaw Additional yaw caused by head position relative to body.
@param headPitch Additional pitch caused by head position relative to body.
@param FoV_x Horizontal field of view of the observer.
@param FoV_y Vertical field of view of the observer.
@return A vector of IDs representing the stationary field objects expected to be visible.
*/
std::vector<FieldObjects::MobileFieldObjectID> FieldObjects::GetPossibleMobileObservationIds(float x, float y, float heading,
float headYaw, float headPitch,
float FoV_x, float FoV_y)
{
// Calculate limits.
// Note: These limits assume that the camera is flat horizontally.
float maxAngle = heading + headYaw + FoV_x / 2.0f; // Radians
float minAngle = heading + headYaw - FoV_x / 2.0f; // Radians
float minDistance = 0; // cm
float maxDistance = 200; // cm
// Create temporary variables for use inside loop.
std::vector<MobileFieldObjectID> visibleIds;
Vector2<float> basePos(x,y), targetPosition;
float distance, angle;
bool expectedVisible;
visibleIds.clear(); // Make sure list is empty.
std::vector<MobileObject>::iterator stat_obj_iterator;
// Check all objects.
for(stat_obj_iterator = mobileFieldObjects.begin();
stat_obj_iterator != mobileFieldObjects.end();
stat_obj_iterator++)
{
// Get position of current field object.
targetPosition = stat_obj_iterator->getEstimatedFieldLocation();
// Calculate expected measurments.
distance = DistanceBetweenPoints(basePos,targetPosition);
angle = AngleBetweenPoints(basePos,targetPosition);
// Check if within limits.
expectedVisible = (angle > minAngle) and (angle < maxAngle) and (distance > minDistance) and (distance < maxDistance);
// If expected to be visible put on list.
if(expectedVisible)
visibleIds.push_back(MobileFieldObjectID(stat_obj_iterator->getID()));
}
return visibleIds;
}
void SimpleEnemyShoot::operator() (BulletStage* stage, vec2f position) {
float jumpRate = 360/30.0;
vec2f basePos(0, 20);
vec2f baseDir(0, 1);
float baseSpeed = 240;
float speed1 = baseSpeed;
float speed2 = baseSpeed / 5 * 4;
float speed3 = baseSpeed * 1.5;
float speed4 = speed2 * 2.5;
//float speed5 = speed3 / 2;
sf::Color blue(0, 170, 255);
sf::Color green(170, 255, 0);
for(int i=0; i<30; i++)
{
float blueAngle = bluePos + (i*jumpRate);
vec2f actualBluePos = rotate(basePos, blueAngle);
vec2f actualBlueDir = rotate(baseDir, blueAngle);
float greenAngle = greenPos + (i*jumpRate);
vec2f actualGreenPos = rotate(basePos, greenAngle);
vec2f actualGreenDir = rotate(baseDir, greenAngle);
stage->addEnemyBullet(new BasicEnemyBullet(stage, position+actualBluePos, actualBlueDir, speed1, blue));
stage->addEnemyBullet(new BasicEnemyBullet(stage, position+actualBluePos, actualBlueDir, speed2, blue));
stage->addEnemyBullet(new BasicEnemyBullet(stage, position+actualBluePos, actualBlueDir, speed3, green));
stage->addEnemyBullet(new BasicEnemyBullet(stage, position+actualBluePos, actualBlueDir, speed4, green));
//stage->addEnemyBullet(new BasicEnemyBullet(stage, position+actualGreenPos, actualGreenDir, speed2, green));
//stage->addEnemyBullet(new BasicEnemyBullet(stage, position+actualBluePos, actualBlueDir, speed3, blue));
//stage->addEnemyBullet(new BasicEnemyBullet(stage, position+actualGreenPos, actualGreenDir, speed4, green));
}
}
bool CStar97PrizeLayer::init()
{
if (!CCLayer::init())
return false;
CCLayerColor * pBgLayer = CCLayerColor::create(ccc4(0,0,0,128), WINDOW_WIDTH, CONTENTS_HEIGHT);
this->addChild(pBgLayer);
if (m_pResManager->GenerateNodeByCfgID(eSpriteType_Base, Star97_Bg_BigPrize_Bg, m_pPrize))
{
m_pPrize->setAnchorPoint(CCPointZero);
#ifndef ANDROID_GAME
m_pPrize->setPosition(ccp(35, 78));
#else
m_pPrize->setPosition(ccp(220, 20));
#endif
this->addChild(m_pPrize);
}
//添加中奖个数
CCPoint basePos(383.0f, 150.0f);
if (m_pResManager->GenerateNodeByCfgID(eSpriteType_Cfg, Star97_Font_Record, m_pFontAnyBar))
{
m_pFontAnyBar->setAnchorPoint(ccp(0, 0.5f));
m_pFontAnyBar->setPosition(basePos);
m_pFontAnyBar->setString("0");
m_pPrize->addChild(m_pFontAnyBar);
}
if (m_pResManager->GenerateNodeByCfgID(eSpriteType_Cfg, Star97_Font_Record, m_pFontOrange))
{
m_pFontOrange->setAnchorPoint(ccp(0, 0.5f));
m_pFontOrange->setPosition(ccp(basePos.x, basePos.y + 48 * 1));
m_pFontOrange->setString("0");
m_pPrize->addChild(m_pFontOrange);
}
if (m_pResManager->GenerateNodeByCfgID(eSpriteType_Cfg, Star97_Font_Record, m_pFontPawpaw))
{
m_pFontPawpaw->setAnchorPoint(ccp(0, 0.5f));
m_pFontPawpaw->setPosition(ccp(basePos.x, basePos.y + 48 * 2));
m_pFontPawpaw->setString("0");
m_pPrize->addChild(m_pFontPawpaw);
}
if (m_pResManager->GenerateNodeByCfgID(eSpriteType_Cfg, Star97_Font_Record, m_pFontBell))
{
m_pFontBell->setAnchorPoint(ccp(0, 0.5f));
m_pFontBell->setPosition(ccp(basePos.x, basePos.y + 48 * 3));
m_pFontBell->setString("0");
m_pPrize->addChild(m_pFontBell);
}
if (m_pResManager->GenerateNodeByCfgID(eSpriteType_Cfg, Star97_Font_Record, m_pFontTsama))
{
m_pFontTsama->setAnchorPoint(ccp(0, 0.5f));
m_pFontTsama->setPosition(ccp(basePos.x, basePos.y + 48 * 4));
m_pFontTsama->setString("0");
m_pPrize->addChild(m_pFontTsama);
}
if (m_pResManager->GenerateNodeByCfgID(eSpriteType_Cfg, Star97_Font_Record, m_pFontBarY))
{
m_pFontBarY->setAnchorPoint(ccp(0, 0.5f));
m_pFontBarY->setPosition(ccp(basePos.x, basePos.y + 48 * 5));
m_pFontBarY->setString("0");
m_pPrize->addChild(m_pFontBarY);
}
if (m_pResManager->GenerateNodeByCfgID(eSpriteType_Cfg, Star97_Font_Record, m_pFontLeech))
{
m_pFontLeech->setAnchorPoint(ccp(0, 0.5f));
m_pFontLeech->setPosition(ccp(basePos.x, basePos.y + 48 * 6));
m_pFontLeech->setString("0");
m_pPrize->addChild(m_pFontLeech);
}
if (m_pResManager->GenerateNodeByCfgID(eSpriteType_Cfg, Star97_Font_Record, m_pFontBarR))
{
m_pFontBarR->setAnchorPoint(ccp(0, 0.5f));
m_pFontBarR->setPosition(ccp(basePos.x, basePos.y + 48 * 7));
m_pFontBarR->setString("0");
m_pPrize->addChild(m_pFontBarR);
}
if (m_pResManager->GenerateNodeByCfgID(eSpriteType_Cfg, Star97_Font_Record, m_pFontBarB))
{
m_pFontBarB->setAnchorPoint(ccp(0, 0.5f));
m_pFontBarB->setPosition(ccp(basePos.x, basePos.y + 48 * 8));
m_pFontBarB->setString("0");
m_pPrize->addChild(m_pFontBarB);
}
basePos.setPoint(730.0f, 438.0f);
if (m_pResManager->GenerateNodeByCfgID(eSpriteType_Cfg, Star97_Font_Record, m_pFont7Num7))
{
m_pFont7Num7->setAnchorPoint(ccp(0, 0.5f));
m_pFont7Num7->setPosition(basePos);
m_pFont7Num7->setString("0");
m_pPrize->addChild(m_pFont7Num7);
}
if (m_pResManager->GenerateNodeByCfgID(eSpriteType_Cfg, Star97_Font_Record, m_pFont8Num7))
{
m_pFont8Num7->setAnchorPoint(ccp(0, 0.5f));
m_pFont8Num7->setPosition(ccp(basePos.x, basePos.y + 48 * 1));
m_pFont8Num7->setString("0");
m_pPrize->addChild(m_pFont8Num7);
}
if (m_pResManager->GenerateNodeByCfgID(eSpriteType_Cfg, Star97_Font_Record, m_pFont9Num7))
{
m_pFont9Num7->setAnchorPoint(ccp(0, 0.5f));
m_pFont9Num7->setPosition(ccp(basePos.x, basePos.y + 48 * 2));
m_pFont9Num7->setString("0");
m_pPrize->addChild(m_pFont9Num7);
}
//添加额外奖励分数
basePos.setPoint(693.0f, 355.0f);
if (m_pResManager->GenerateNodeByCfgID(eSpriteType_Cfg, Star97_Font_Extra_Info, m_pFontExtraAllHalf))
{
m_pFontExtraAllHalf->setAnchorPoint(ccp(0.5f, 0.5f));
m_pFontExtraAllHalf->setPosition(basePos);
m_pFontExtraAllHalf->setString("0");
m_pPrize->addChild(m_pFontExtraAllHalf);
}
if (m_pResManager->GenerateNodeByCfgID(eSpriteType_Cfg, Star97_Font_Extra_Info, m_pFontExtraAllWhole))
{
m_pFontExtraAllWhole->setAnchorPoint(ccp(0.5f, 0.5f));
m_pFontExtraAllWhole->setPosition(ccp(basePos.x, basePos.y - 31 * 1));
m_pFontExtraAllWhole->setString("0");
m_pPrize->addChild(m_pFontExtraAllWhole);
}
if (m_pResManager->GenerateNodeByCfgID(eSpriteType_Cfg, Star97_Font_Extra_Info, m_pFontExtra9Num7))
{
m_pFontExtra9Num7->setAnchorPoint(ccp(0.5f, 0.5f));
m_pFontExtra9Num7->setPosition(ccp(basePos.x, basePos.y - 31 * 2));
m_pFontExtra9Num7->setString("0");
m_pPrize->addChild(m_pFontExtra9Num7);
}
if (m_pResManager->GenerateNodeByCfgID(eSpriteType_Cfg, Star97_Font_Extra_Info, m_pFontExtra8Num7))
{
m_pFontExtra8Num7->setAnchorPoint(ccp(0.5f, 0.5f));
m_pFontExtra8Num7->setPosition(ccp(basePos.x, basePos.y - 31 * 3));
m_pFontExtra8Num7->setString("0");
m_pPrize->addChild(m_pFontExtra8Num7);
}
if (m_pResManager->GenerateNodeByCfgID(eSpriteType_Cfg, Star97_Font_Extra_Info, m_pFontExtra7Num7))
{
m_pFontExtra7Num7->setAnchorPoint(ccp(0.5f, 0.5f));
m_pFontExtra7Num7->setPosition(ccp(basePos.x, basePos.y - 31 * 4));
m_pFontExtra7Num7->setString("0");
m_pPrize->addChild(m_pFontExtra7Num7);
}
if (m_pResManager->GenerateNodeByCfgID(eSpriteType_Cfg, Star97_Font_Extra_Info, m_pFontExtraAnyBar))
{
m_pFontExtraAnyBar->setAnchorPoint(ccp(0.5f, 0.5f));
m_pFontExtraAnyBar->setPosition(ccp(basePos.x, basePos.y - 31 * 5));
m_pFontExtraAnyBar->setString("0");
m_pPrize->addChild(m_pFontExtraAnyBar);
}
//总下注、总赢分
if (m_pResManager->GenerateNodeByCfgID(eSpriteType_Cfg, Star97_Font_Table_Winlose, m_pFontAllJetton))
{
m_pFontAllJetton->setAnchorPoint(ccp(0, 0.5f));
m_pFontAllJetton->setPosition(ccp(192, 77));
m_pFontAllJetton->setString("0");
m_pPrize->addChild(m_pFontAllJetton);
}
if (m_pResManager->GenerateNodeByCfgID(eSpriteType_Cfg, Star97_Font_Table_Winlose, m_pFontAllWin))
{
m_pFontAllWin->setAnchorPoint(ccp(0, 0.5f));
m_pFontAllWin->setPosition(ccp(544, 77));
m_pFontAllWin->setString("0");
m_pPrize->addChild(m_pFontAllWin);
}
//使用触摸
setTouchEnabled(true);
setTouchMode(kCCTouchesOneByOne);
return true;
}
void PlayPen_testProjectSphere::setupContent()
{
mSceneMgr->setAmbientLight(ColourValue::White);
Plane plane;
plane.normal = Vector3::UNIT_Y;
plane.d = 0;
MeshManager::getSingleton().createPlane("Myplane",
TRANSIENT_RESOURCE_GROUP, plane,
4500,4500,10,10,true,1,5,5,Vector3::UNIT_Z);
Entity* pPlaneEnt = mSceneMgr->createEntity( "plane", "Myplane" );
pPlaneEnt->setMaterialName("Examples/GrassFloor");
pPlaneEnt->setCastShadows(false);
mSceneMgr->getRootSceneNode()->createChildSceneNode()->attachObject(pPlaneEnt);
mProjectionSphere = new Sphere(Vector3(0, 2000, 0), 1500.0);
ManualObject* debugSphere = mSceneMgr->createManualObject("debugSphere");
debugSphere->begin("BaseWhiteNoLighting", RenderOperation::OT_LINE_STRIP);
for (int i = 0; i <= 20; ++i)
{
Vector3 basePos(mProjectionSphere->getRadius(), 0, 0);
Quaternion quat;
quat.FromAngleAxis(Radian(((float)i/(float)20)*Math::TWO_PI), Vector3::UNIT_Y);
basePos = quat * basePos;
debugSphere->position(basePos);
}
for (int i = 0; i <= 20; ++i)
{
Vector3 basePos(mProjectionSphere->getRadius(), 0, 0);
Quaternion quat;
quat.FromAngleAxis(Radian(((float)i/(float)20)*Math::TWO_PI), Vector3::UNIT_Z);
basePos = quat * basePos;
debugSphere->position(basePos);
}
debugSphere->end();
mSceneMgr->getRootSceneNode()->createChildSceneNode(Vector3(0,2000,0))->attachObject(debugSphere);
MaterialPtr mat = MaterialManager::getSingleton().create("scissormat",
TRANSIENT_RESOURCE_GROUP);
Pass* p = mat->getTechnique(0)->getPass(0);
p->setDepthWriteEnabled(false);
p->setSceneBlending(SBT_TRANSPARENT_ALPHA);
TextureUnitState* t = p->createTextureUnitState();
t->setColourOperationEx(LBX_SOURCE1, LBS_MANUAL, LBS_CURRENT,
ColourValue::Red);
t->setAlphaOperation(LBX_SOURCE1, LBS_MANUAL, LBS_CURRENT, 0.5f);
mScissorRect = mSceneMgr->createManualObject("mScissorRect");
mScissorRect->setUseIdentityProjection(true);
mScissorRect->setUseIdentityView(true);
AxisAlignedBox aabb;
aabb.setInfinite();
mScissorRect->setBoundingBox(aabb);
mScissorRect->begin(mat->getName());
mScissorRect->position(Vector3::ZERO);
mScissorRect->position(Vector3::ZERO);
mScissorRect->position(Vector3::ZERO);
mScissorRect->quad(0, 1, 2, 3);
mScissorRect->end();
mSceneMgr->getRootSceneNode()->createChildSceneNode()->attachObject(mScissorRect);
mCamera->setPosition(0,3000,5000);
mCamera->lookAt(mProjectionSphere->getCenter());
}
class btMultiBody* MultiBodyVehicleSetup::createMultiBodyVehicle()
{
class btMultiBodyDynamicsWorld* world = m_dynamicsWorld;
int numWheels = 4;
int totalLinks = numWheels;//number of body parts (links) (in)directly attached to the base, NOT including the base/root itself
btCollisionShape* chassis = new btBoxShape(gVehicleBaseHalfExtents);//CUBE_HALF_EXTENTS,CUBE_HALF_EXTENTS,CUBE_HALF_EXTENTS));
m_collisionShapes.push_back(chassis);
btCollisionShape* wheel = new btCylinderShapeX(gVehicleWheelHalfExtents);//CUBE_HALF_EXTENTS,CUBE_HALF_EXTENTS,CUBE_HALF_EXTENTS));
m_collisionShapes.push_back(wheel);
btVector3 baseLocalInertia(0, 0, 0);
chassis->calculateLocalInertia(gVehicleBaseMass, baseLocalInertia);
bool multiDof = false;
bool isFixedBase = false;
bool canSleep = false;
btMultiBody * bod = new btMultiBody(totalLinks, gVehicleBaseMass, baseLocalInertia, isFixedBase, canSleep);// , multiDof);
bod->setHasSelfCollision(false);
btQuaternion baseOrn(0, 0, 0, 1);
btVector3 basePos(0, 0, 0);
bod->setBasePos(basePos);
bod->setWorldToBaseRot(baseOrn);
btVector3 vel(0, 0, 0);
bod->setBaseVel(vel);
{
int linkNum = 0;
btVector3 wheelJointAxisWorld(1, 0, 0);
btQuaternion parent_to_child = baseOrn.inverse();//??
for (int j = 0; j < numWheels; j++, linkNum++)
{
int parent_link_num = -1;
float initial_joint_angle = 0.0;
btVector3 localWheelInertia(0, 0, 0);
wheel->calculateLocalInertia(gVehicleWheelMass, localWheelInertia);
bool disableParentCollision = true;
btVector3 pivotToChildCOM(0, 0, 0.25);
btVector3 pivotToWheelCOM(0, 0, 0);
{
bod->setupRevolute(linkNum, gVehicleWheelMass, localWheelInertia, parent_link_num, parent_to_child, wheelJointAxisWorld,
wheelAttachmentPosInWorld[j], pivotToWheelCOM, disableParentCollision);
}
bod->setJointPos(linkNum, initial_joint_angle);
if (j<2)
{
btMultiBodyJointMotor* con = new btMultiBodyJointMotor(bod, linkNum, 1., 50);
world->addMultiBodyConstraint(con);
}
}
}
//add a collider for the base
{
btAlignedObjectArray<btQuaternion> world_to_local;
world_to_local.resize(totalLinks + 1);
btAlignedObjectArray<btVector3> local_origin;
local_origin.resize(totalLinks + 1);
world_to_local[0] = bod->getWorldToBaseRot();
local_origin[0] = bod->getBasePos();
{
float pos[4] = { local_origin[0].x(), local_origin[0].y(), local_origin[0].z(), 1 };
float quat[4] = { -world_to_local[0].x(), -world_to_local[0].y(), -world_to_local[0].z(), world_to_local[0].w() };
if (1)
{
btMultiBodyLinkCollider* col = new btMultiBodyLinkCollider(bod, -1);
col->setCollisionShape(chassis);
btTransform tr;
tr.setIdentity();
tr.setOrigin(local_origin[0]);
tr.setRotation(btQuaternion(quat[0], quat[1], quat[2], quat[3]));
col->setWorldTransform(tr);
world->addCollisionObject(col, btBroadphaseProxy::DefaultFilter, btBroadphaseProxy::AllFilter);// 2, 1 + 2);
col->setFriction(friction);
bod->setBaseCollider(col);
}
}
//initialize local coordinate frames, relative to parent
for (int i = 0; i<bod->getNumLinks(); i++)
{
const int parent = bod->getParent(i);
world_to_local[i + 1] = bod->getParentToLocalRot(i) * world_to_local[parent + 1];
local_origin[i + 1] = local_origin[parent + 1] + (quatRotate(world_to_local[i + 1].inverse(), bod->getRVector(i)));
}
int linkIndex = 0;
for (int j = 0; j<numWheels; j++, linkIndex++)
{
btVector3 posr = local_origin[linkIndex + 1];
float pos[4] = { posr.x(), posr.y(), posr.z(), 1 };
float quat[4] = { -world_to_local[linkIndex + 1].x(), -world_to_local[linkIndex + 1].y(), -world_to_local[linkIndex + 1].z(), world_to_local[linkIndex + 1].w() };
btMultiBodyLinkCollider* col = new btMultiBodyLinkCollider(bod, linkIndex);
col->setCollisionShape(wheel);
btTransform tr;
tr.setIdentity();
tr.setOrigin(posr);
tr.setRotation(btQuaternion(quat[0], quat[1], quat[2], quat[3]));
col->setWorldTransform(tr);
col->setFriction(friction);
world->addCollisionObject(col, btBroadphaseProxy::DefaultFilter, btBroadphaseProxy::AllFilter);// 2, 1 + 2);
bod->getLink(linkIndex).m_collider = col;
}
}
world->addMultiBody(bod);
// world->setGravity(btVector3(0,0,0));
return bod;
}
////////////////////////////////////////////////////////////
///Entrypoint of application
////////////////////////////////////////////////////////////
int main() {
const int size=4;
const int noOfElements=5;
int popBallon[5]={0,0,0,0,0};
int i=0;
float moveSpeed = 3.f, roateAngleRight=5.f, roateAngleLeft=-5.f;
float rotation[4]={0.f,0.f,0.f,0.f};
float ballonRad=20.f;
// Create the main window
sf::RenderWindow window(sf::VideoMode(800, 600, 32), "SFML First Program");
window.setFramerateLimit(60);
//load a font
sf::Font font;
font.loadFromFile("C:\\Windows\\Fonts\\GARA.TTF");
//get Textures
sf::Texture bcg;
if (!bcg.loadFromFile("background.png")){}
sf::Texture body;
if (!body.loadFromFile("body.png")){}
sf::Texture mainArm;
if (!mainArm.loadFromFile("mainArm.png")){}
sf::Texture secondArm;
if (!secondArm.loadFromFile("secondArm.png")){}
sf::Texture clause;
if (!clause.loadFromFile("clause.png")){}
//Create sprite for background
sf::Sprite bcgImg;
bcgImg.setTexture(bcg);
//Create objects
//Base
sf::VertexArray baseLines(sf::Quads, size);
sf::Vector2f quad[size];
quad[0] = sf::Vector2f(0 , 0);
quad[1] = sf::Vector2f(160, 0);
quad[2] = sf::Vector2f(160, 228);
quad[3] = sf::Vector2f(0 , 228);
baseLines[0].texCoords = sf::Vector2f(0 , 0);
baseLines[1].texCoords = sf::Vector2f(160, 0);
baseLines[2].texCoords = sf::Vector2f(160, 228);
baseLines[3].texCoords = sf::Vector2f(0 , 228);
sf::Vector2f basePos(150.f, 330.f);
//Main (Bottom) Arm
sf::VertexArray mainArmLines(sf::Quads, size);
sf::Vector2f points2[size];
points2[0]=sf::Vector2f(-21,-132);
points2[1]=sf::Vector2f(100,-132);
points2[2]=sf::Vector2f(100,20);
points2[3]=sf::Vector2f(-21,20);
mainArmLines[0].texCoords = sf::Vector2f(0,0);
mainArmLines[1].texCoords = sf::Vector2f(121,0);
mainArmLines[2].texCoords = sf::Vector2f(121,152);
mainArmLines[3].texCoords = sf::Vector2f(0,152);
sf::Vector2f mArmPos(70.f, 15.f);
//Second (Top) Arm
sf::VertexArray secondArmLines(sf::Quads, size);
sf::Vector2f points3[size];
points3[0]=sf::Vector2f(0,0);
points3[1]=sf::Vector2f(113,0);
points3[2]=sf::Vector2f(113,150);
points3[3]=sf::Vector2f(0,150);
secondArmLines[0].texCoords = sf::Vector2f(0, 0);
secondArmLines[1].texCoords = sf::Vector2f(113, 0);
secondArmLines[2].texCoords = sf::Vector2f(113, 150);
secondArmLines[3].texCoords = sf::Vector2f(0, 150);
sf::Vector2f sArmPos(83.f, -117.f);
//Right Clause
sf::VertexArray rightFinLines(sf::Quads, size);
sf::Vector2f points4[size];
points4[0]=sf::Vector2f(0,0);
points4[1]=sf::Vector2f(13,0);
points4[2]=sf::Vector2f(13,38);
points4[3]=sf::Vector2f(0,38);
rightFinLines[0].texCoords = sf::Vector2f(0, 0);
rightFinLines[1].texCoords = sf::Vector2f(13, 0);
rightFinLines[2].texCoords = sf::Vector2f(13, 38);
rightFinLines[3].texCoords = sf::Vector2f(0, 38);
sf::Vector2f rfArmPos(101.f,150.f);
//Left Clause
sf::VertexArray leftFinLines(sf::Quads, size);
sf::Vector2f points5[size];
points5[0]=sf::Vector2f(0,0);
points5[1]=sf::Vector2f(-13,0);
points5[2]=sf::Vector2f(-13,38);
points5[3]=sf::Vector2f(0,38);
leftFinLines[0].texCoords = sf::Vector2f(0, 0);
leftFinLines[1].texCoords = sf::Vector2f(13, 0);
leftFinLines[2].texCoords = sf::Vector2f(13, 38);
leftFinLines[3].texCoords = sf::Vector2f(0, 38);
sf::Vector2f lfArmPos(101.f,150.f);
//Initialize ballons
sf::CircleShape ballon[5];
sf::Vector2f ballonPos[5];
ballonPos[0].x=650.f; ballonPos[0].y=450.f;
ballonPos[1].x=125.f; ballonPos[1].y=90.f;
ballonPos[2].x=340.f; ballonPos[2].y=150.f;
ballonPos[3].x=600.f; ballonPos[3].y=250.f;
ballonPos[4].x=540.f; ballonPos[4].y=50.f;
ballon[0].setFillColor(sf::Color::Red);
ballon[1].setFillColor(sf::Color::Green);
ballon[2].setFillColor(sf::Color::Blue);
ballon[3].setFillColor(sf::Color::Magenta);
ballon[4].setFillColor(sf::Color::Yellow);
//Set properties for ballons
for (i=0; i<noOfElements; i++){
ballon[i].setRadius(ballonRad);
ballon[i].setOrigin(ballonRad,ballonRad);
ballon[i].setPosition(ballonPos[i]);
}
// Create a text for Timer and Start it
sf::Text text("", font);
text.setCharacterSize(30);
text.setColor(sf::Color::White);
std::clock_t start;
start = std::clock();
int minutes=0,hours=0;
double seconds;
// Start game loop
while (window.isOpen()){
int poppedBaloons=popBallon[0]+popBallon[1]+popBallon[2]+popBallon[3]+popBallon[4];
if (poppedBaloons != 5){
//calculate, time and convert it to string
seconds = ( std::clock() - start ) / (double) CLOCKS_PER_SEC;
hours=(int)seconds/(24*60); seconds=(int)seconds%(24*60); minutes=(int)seconds/60; seconds=(int)seconds%60;
std::string hrs = std::to_string(hours);
std::string mins = std::to_string(minutes);
std::string secs = std::to_string((int)seconds);
if (seconds<10) secs="0"+secs; if (minutes<10) mins="0"+mins; if (hours<10) hrs="0"+hrs;
std::string s = hrs+":"+mins+":"+secs;
text.setString(s);
}
// Process events
sf::Event Event;
while (window.pollEvent(Event)){
// Close window : exit
if (Event.type == sf::Event::Closed)
window.close();
// Escape key : exit
if ((Event.type == sf::Event::KeyPressed) && (Event.key.code == sf::Keyboard::Escape))
window.close();
if ((Event.type == sf::Event::KeyPressed) && (Event.key.code == sf::Keyboard::Right)){
if (basePos.x<500)//stop base from moving over 500 (so it will look good with background image)
basePos.x+=moveSpeed;
}
if ((Event.type == sf::Event::KeyPressed) && (Event.key.code == sf::Keyboard::Left)){
basePos.x-=moveSpeed;
}
if ((Event.type == sf::Event::KeyPressed) && (Event.key.code == sf::Keyboard::Up)){
if (rotation[0] > -139)
rotation[0]-=moveSpeed;
}
if ((Event.type == sf::Event::KeyPressed) && (Event.key.code == sf::Keyboard::Down)){
if (rotation[0] < 81)
rotation[0]+=moveSpeed;
}
if ((Event.type == sf::Event::KeyPressed) && (Event.key.code == sf::Keyboard::A)){
if (rotation[1] > -246)
rotation[1]-=moveSpeed;
}
if ((Event.type == sf::Event::KeyPressed) && (Event.key.code == sf::Keyboard::D)){
if (rotation[1] < 30)
rotation[1]+=moveSpeed;
}
if ((Event.type == sf::Event::KeyPressed) && (Event.key.code == sf::Keyboard::W)){
if (rotation[2] > -50){
rotation[2]-=moveSpeed;
rotation[3]+=moveSpeed;
}
}
if ((Event.type == sf::Event::KeyPressed) && (Event.key.code == sf::Keyboard::S)){
if (rotation[2] < 0){
rotation[2]+=moveSpeed;
rotation[3]-=moveSpeed;
}
}
}
//Body transformation
sf::Transform T;
T.translate(basePos);
//main Arm transformation & rotation
sf::Transform T2;
T2.translate(mArmPos);
sf::Transform R2;
R2.rotate(rotation[0]);
sf::Transform M2=T*T2*R2;
//second Arm transformation & rotation
sf::Transform T3;
T3.translate(sArmPos);
sf::Transform R3;
R3.rotate(rotation[1]);
sf::Transform M3=M2*T3*R3;
//right finger transformation & rotation
sf::Transform T4;
T4.translate(rfArmPos);
sf::Transform R4;
R4.rotate(rotation[2]);
sf::Transform M4=M3*T4*R4;
//left finger transformation & rotation
sf::Transform T5;
T5.translate(lfArmPos);
sf::Transform R5;
R5.rotate(rotation[3]);
sf::Transform M5=M3*T5*R5;
//update baseLines & check for collisions
for(i=0;i<size;i++) {
baseLines[i].position=T.transformPoint(quad[i]);
mainArmLines[i].position=M2.transformPoint(points2[i]);
secondArmLines[i].position=M3.transformPoint(points3[i]);
rightFinLines[i].position=M4.transformPoint(points4[i]);
leftFinLines[i].position=M5.transformPoint(points5[i]);
//check does any of four points of each clause is in the circle, I do that by calculating distance from clause points to ballon origin
for (int c=0; c<noOfElements; c++) {
//right finger popping ballons
float dist = sqrt(pow((ballonPos[c].x-rightFinLines[i].position.x), 2) + pow((ballonPos[c].y-rightFinLines[i].position.y), 2));
//now check if distance is smaller than ballon radius, and if it is less than radius then set ballon as popped
if (dist < ballonRad)
popBallon[c]=1;
//left finger popping ballons (as above)
dist = sqrt(pow((ballonPos[c].x-leftFinLines[i].position.x), 2) + pow((ballonPos[c].y-leftFinLines[i].position.y), 2));
if (dist < ballonRad)
popBallon[c]=1;
}
}
window.clear();
//draw frame items
window.draw(bcgImg);
window.draw(baseLines, &body);
window.draw(rightFinLines, &clause);
window.draw(leftFinLines, &clause);
window.draw(secondArmLines, &secondArm);
window.draw(mainArmLines, &mainArm);
//if ballon is not popped draw it
for (i=0; i<noOfElements; i++) {
if (popBallon[i]==0)
window.draw(ballon[i]);
}
window.draw(text);
// Finally, display rendered frame on screen
window.display();
} //loop back for next frame
return EXIT_SUCCESS;
}
void CloudsHUDController::drawLayer3D(CloudsHUDLayerSet layer, ofCamera* cam, ofVec2f& offset){
ofPushMatrix();
// Hook up to the camera to keep the layer steady.
ofMatrix4x4 baseRotation;
ofTranslate(cam->getPosition());
baseRotation.makeRotationMatrix(cam->getOrientationQuat());
ofMultMatrix(baseRotation);
ofVec3f camPos = ofVec3f(); //cam->getPosition();
// Calculate the base position.
static ofVec3f yAxis = ofVec3f(0.0, 1.0, 0.0);
static ofVec3f xAxis = ofVec3f(1.0, 0.0, 0.0);
// ofVec3f basePos = camPos + (cam->getLookAtDir().getScaled(layerDistance[layer]));
// ofVec3f basePos(0, 0, -layerDistance[layer]);
ofVec3f basePos(offset.x, offset.y, -layerDistance[layer]);
basePos.rotate(layerRotationH[layer], camPos, yAxis);
basePos.rotate(layerRotationV[layer], camPos, xAxis);
// Get the total layer bounds.
ofRectangle layerBounds;
for(int i = 0; i < layerSets[layer].size(); i++){
if (i == 0) layerBounds = layerSets[layer][i]->svg.getBounds();
else layerBounds.growToInclude(layerSets[layer][i]->svg.getBounds());
}
// Translate to the layer center pos.
ofVec3f layerPos = basePos + (getCenter(false) - layerBounds.getCenter());
ofTranslate(layerPos);
if (layerBillboard[layer] == CLOUDS_HUD_BILLBOARD_OCULUS) {
// Billboard rotation using the Oculus orientation.
float angle;
ofVec3f axis;
CloudsVisualSystem::getOculusRift().getOrientationQuat().getRotate(angle, axis);
ofRotate(angle, axis.x, axis.y, axis.z);
ofScale(-1, 1, 1);
}
else if (layerBillboard[layer] == CLOUDS_HUD_BILLBOARD_CAMERA) {
// Billboard rotation using the camera.
ofNode node;
node.setPosition(layerPos);
node.lookAt(camPos);
ofVec3f axis;
float angle;
node.getOrientationQuat().getRotate(angle, axis);
ofRotate(angle, axis.x, axis.y, axis.z);
}
else {
// ofRotateY(layerRotationH[layer]);
// ofRotateX(layerRotationV[layer]);
ofScale(-1, 1, 1);
}
// Debug circle.
// ofSetColor(255);
// ofCircle(0, 0, 25);
// Transform for rendering the layer.
ofScale(-scaleAmt, -scaleAmt, 1);
ofTranslate(-layerBounds.getCenter());
// Draw the video player if we're on the right layer.
if (layer == CLOUDS_HUD_PROJECT_EXAMPLE && videoPlayer.isPlaying()) {
ofSetColor(255, 255, 255, 255*0.7);
if( !bSkipAVideoFrame ){
// videoPlayer.draw( videoBounds.x, videoBounds.y, videoBounds.width, videoBounds.height );
}
}
// Draw the layer.
ofSetColor(255);
drawLayer(layer);
// Draw the home button if we're on the right layer.
if (layer == CLOUDS_HUD_LOWER_THIRD && bDrawHome && hudOpenMap[CLOUDS_HUD_LOWER_THIRD]) {
home.draw();
}
// Draw the associated text labels.
for( map<string, CloudsHUDLabel*>::iterator it=hudLabelMap.begin(); it!= hudLabelMap.end(); ++it ){
bool bFound = false;
for(int i = 0; i < layerSets[layer].size(); i++){
if (layerSets[layer][i]->svg.getMeshByID(it->first) != NULL) {
bFound = true;
break;
}
}
if (bFound) {
(it->second)->draw();
}
}
ofPopMatrix();
}
void connectSpriteActions(
Triggers::TriggerGroup* editorTriggers,
Input::InputManager& inputManager,
Graphics::LevelSprite*& hoveredSprite,
Graphics::LevelSprite*& selectedSprite,
Graphics::LevelSpriteHandlePoint*& selectedHandlePoint,
Scene::Scene& world,
System::Cursor &cursor,
Editor::EditorGrid& editorGrid,
int& selectedSpriteOffsetX,
int& selectedSpriteOffsetY,
Editor::Tooltip& tooltip,
Transform::Units& editorUnit)
{
inputManager.getAction("MoveHandlePoint").connect([editorTriggers, &selectedHandlePoint, &cursor, &world](const Input::InputActionEvent& event)
{
Transform::UnitVector pixelCamera = world.getCamera()->getPosition().to<Transform::Units::ScenePixels>();
if (selectedHandlePoint != nullptr)
{
selectedHandlePoint->moveTo(cursor.getPosition(), pixelCamera);
editorTriggers->pushParameter("SpriteHandlePointMoved", "handlePoint", selectedHandlePoint);
editorTriggers->trigger("SpriteHandlePointMoved");
}
});
inputManager.getAction("ReleaseHandlePoint").connect([editorTriggers, &selectedHandlePoint](const Input::InputActionEvent& event)
{
if (selectedHandlePoint != nullptr)
{
editorTriggers->pushParameter("SpriteHandlePointReleased", "handlePoint", selectedHandlePoint);
editorTriggers->trigger("SpriteHandlePointReleased");
selectedHandlePoint = nullptr;
}
});
inputManager.getAction("SpritePick").connect(
[editorTriggers,
&selectedSprite,
&selectedSpriteOffsetX,
&selectedSpriteOffsetY,
&cursor,
&selectedHandlePoint,
&hoveredSprite,
&tooltip,
&world]
(const Input::InputActionEvent& event)
{
Transform::UnitVector pixelCamera = world.getCamera()->getPosition().to<Transform::Units::ScenePixels>();
if (selectedSprite != nullptr && selectedHandlePoint == nullptr)
{
selectedHandlePoint = selectedSprite->getHandlePoint(pixelCamera, cursor.getX(), cursor.getY());
if (selectedHandlePoint != nullptr)
{
editorTriggers->pushParameter("SpriteHandlePointPicked", "handlePoint", selectedHandlePoint);
editorTriggers->pushParameter("SpriteHandlePointPicked", "pos",
pixelCamera + cursor.getPosition());
editorTriggers->trigger("SpriteHandlePointPicked");
hoveredSprite = nullptr;
}
else if (hoveredSprite != selectedSprite)
{
editorTriggers->pushParameter("SpriteUnselect", "sprite", selectedSprite);
editorTriggers->trigger("SpriteUnselect");
selectedSprite->setColor(sf::Color::White);
selectedSprite->unselect();
tooltip.clear();
selectedSprite = nullptr;
selectedSpriteOffsetX = 0;
selectedSpriteOffsetY = 0;
}
}
if (hoveredSprite != nullptr && selectedHandlePoint == nullptr)
{
selectedSprite = hoveredSprite;
Transform::UnitVector selectedSpriteOffset = selectedSprite->getPositionTransformer()(
cursor.getPosition() - selectedSprite->getPosition(),
-pixelCamera,
selectedSprite->getLayer()).to<Transform::Units::ScenePixels>();
selectedSpriteOffsetX = selectedSpriteOffset.x;
selectedSpriteOffsetY = selectedSpriteOffset.y;
editorTriggers->pushParameter("SpriteSelect", "sprite", selectedSprite);
editorTriggers->pushParameter("SpriteSelect", "offset", Transform::UnitVector(selectedSpriteOffsetX, selectedSpriteOffsetY, Transform::Units::ScenePixels));
editorTriggers->pushParameter("SpriteSelect", "pos",
pixelCamera + Transform::UnitVector(cursor.getX(), cursor.getY(), Transform::Units::ScenePixels));
editorTriggers->trigger("SpriteSelect");
selectedSprite->select();
selectedSprite->setColor(sf::Color(100, 255, 100));
}
});
inputManager.getAction("SpriteMove").connect(
[editorTriggers,
&selectedSprite,
&cursor,
&selectedSpriteOffsetX,
&selectedSpriteOffsetY,
&selectedHandlePoint,
&tooltip,
&world,
&editorUnit]
(const Input::InputActionEvent& event)
{
if (selectedSprite != nullptr && selectedHandlePoint == nullptr)
{
editorTriggers->pushParameter("SpriteMoved", "sprite", selectedSprite);
editorTriggers->pushParameter("SpriteMoved", "oldPos", selectedSprite->getPosition());
Transform::UnitVector pixelCamera = world.getCamera()->getPosition().to<Transform::Units::ScenePixels>();
Transform::UnitVector basePos(cursor.getConstrainedX() - selectedSpriteOffsetX, cursor.getConstrainedY() - selectedSpriteOffsetY, Transform::Units::ScenePixels);
Transform::UnitVector newPosition = selectedSprite->getPositionTransformer()(basePos, -pixelCamera, selectedSprite->getLayer());
selectedSprite->setPosition(newPosition);
editorTriggers->pushParameter("SpriteMoved", "pos", selectedSprite->getPosition());
editorTriggers->pushParameter("SpriteMoved", "offset", Transform::UnitVector(selectedSpriteOffsetX, selectedSpriteOffsetY, Transform::Units::ScenePixels));
editorTriggers->trigger("SpriteMoved");
tooltip.setText("Selected Sprite : \n"
" Id : {}\n"
" Name : {}\n"
" Pos : {}, {}\n"
" Size : {}, {}\n"
" Rot : {}\n"
" Layer / Z : {}, {}\n",
selectedSprite->getId(),
selectedSprite->getPath(),
selectedSprite->getPosition().to(editorUnit).x, selectedSprite->getPosition().to(editorUnit).y,
selectedSprite->getSize().to(editorUnit).x, selectedSprite->getSize().to(editorUnit).y,
selectedSprite->getRotation(),
selectedSprite->getLayer(), selectedSprite->getZDepth()); // <REVISION> Duplicated code (See MapEditor.cpp)
tooltip.setPosition(cursor.getX() + 40, cursor.getY());
}
});
inputManager.getAction("SpriteRemove").connect(
[editorTriggers, &selectedSprite, &world, &tooltip, &hoveredSprite, &selectedSpriteOffsetX, &selectedSpriteOffsetY]
(const Input::InputActionEvent& event)
{
if (selectedSprite != nullptr)
{
editorTriggers->pushParameter("SpriteRemoved", "id", selectedSprite->getId());
editorTriggers->trigger("SpriteRemoved");
world.removeLevelSprite(selectedSprite->getId());
selectedSprite = nullptr;
tooltip.clear();
hoveredSprite = nullptr;
selectedSpriteOffsetX = 0;
selectedSpriteOffsetY = 0;
}
});
inputManager.getAction("SpriteCancelOffset").connect(
[&selectedSprite, &cursor, &editorGrid, &selectedSpriteOffsetX, &selectedSpriteOffsetY, &selectedHandlePoint](const Input::InputActionEvent& event)
{
if (selectedSprite != nullptr && selectedHandlePoint == nullptr)
{
selectedSpriteOffsetX = 0;
selectedSpriteOffsetY = 0;
}
});
}
void EnemyShoot::operator() (BulletStage* stage, vec2f position) {
vec2f basePos(0, 20);
vec2f baseDir(0, 1);
float baseSpeed = 240;
//float speed5 = speed3 / 2;
sf::Color blue(0, 170, 255);
sf::Color green(170, 255, 0);
if(stage-> timer <30)
{
float jumpRate = 360/8.0;
float rotateRate = 360/15.0 + 5;
float speed1 = baseSpeed;
float speed2 = baseSpeed / 5 * 4;
float speed3 = baseSpeed / 3 * 2;
float speed4 = speed2 / 4 * 3;
greenPos -= rotateRate * dt;
if(greenPos<0)
greenPos += 360;
bluePos += rotateRate * dt;
if(bluePos>360)
bluePos -= 360;
for(int i=0; i<8; i++)
{
float blueAngle = bluePos + (i*jumpRate);
vec2f actualBluePos = rotate(basePos, blueAngle);
vec2f actualBlueDir = rotate(baseDir, blueAngle);
float greenAngle = greenPos + (i*jumpRate);
vec2f actualGreenPos = rotate(basePos, greenAngle);
vec2f actualGreenDir = rotate(baseDir, greenAngle);
stage->addEnemyBullet(new BasicEnemyBullet(stage, position+actualBluePos, actualBlueDir, speed1, blue));
stage->addEnemyBullet(new BasicEnemyBullet(stage, position+actualGreenPos, actualGreenDir, speed2, green));
stage->addEnemyBullet(new BasicEnemyBullet(stage, position+actualBluePos, actualBlueDir, speed3, blue));
stage->addEnemyBullet(new BasicEnemyBullet(stage, position+actualGreenPos, actualGreenDir, speed4, green));
}
}
else
{
float jumpRate = 360/90.0;
float speed1 = baseSpeed / 6 * 5;
float speed2 = baseSpeed / 5 * 4;
float speed3 = baseSpeed / 3 * 2;
float speed4 = speed2 / 4 * 3;
for(int i=0; i<90; i++)
{
float blueAngle = bluePos + (i*jumpRate);
vec2f actualBluePos = rotate(basePos, blueAngle);
vec2f actualBlueDir = rotate(baseDir, blueAngle);
float greenAngle = greenPos + (i*jumpRate);
vec2f actualGreenPos = rotate(basePos, greenAngle);
vec2f actualGreenDir = rotate(baseDir, greenAngle);
stage->addEnemyBullet(new BasicEnemyBullet(stage, position+actualBluePos, actualBlueDir, speed1, blue));
//stage->addEnemyBullet(new BasicEnemyBullet(stage, position+actualGreenPos, actualGreenDir, speed2, green));
//stage->addEnemyBullet(new BasicEnemyBullet(stage, position+actualBluePos, actualBlueDir, speed3, blue));
//stage->addEnemyBullet(new BasicEnemyBullet(stage, position+actualGreenPos, actualGreenDir, speed4, green));
}
}
}
void Light::OnUpdate(sf::Time interval) {
std::lock_guard<std::recursive_mutex> lg(m_mutex);
if (!m_active || !m_render || !GetParent()->IsRender()) return;
sf::Vector2f pos = GetGlobalPosition();
const auto& view = m_scene->GetGame()->GetWindow()->getView();
auto vr = sf::FloatRect(view.getCenter().x - view.getSize().x / 2, view.getCenter().y - view.getSize().y / 2,
view.getSize().x,
view.getSize().y);
if (!vr.intersects(sf::Rect<float>(pos.x - m_radius, pos.y - m_radius, 2 * m_radius, 2 * m_radius))) {
m_blocked = true;
return;
}
b2AABB center;
center.lowerBound.x = pos.x / m_scene->GetPixelMeterRatio();
center.lowerBound.y = pos.y / m_scene->GetPixelMeterRatio();
float onep = (1.f / m_scene->GetPixelMeterRatio());
center.upperBound.x = center.lowerBound.x + onep;
center.upperBound.y = center.lowerBound.y + onep;
CenterQuery cq(center.lowerBound.x, center.lowerBound.y);
GetScene()->GetWorld()->QueryAABB(&cq, center);
if (cq.hit) {
cq.node->OnLightRay.Fire(this);
m_blocked = true;
return;
}
m_blocked = false;
float rayDistance =
(2 - cosf(m_openingAngle / (m_rayCount - 1))) * m_radius / m_scene->GetPixelMeterRatio();
b2Vec2 basePos(pos.x / m_scene->GetPixelMeterRatio(),
pos.y / m_scene->GetPixelMeterRatio());
struct edgeData {
b2Vec2 pos;
b2Fixture* fixture;
int vertex;
};
std::map<int, edgeData> edges;
auto EdgeFromPos = [&, this](const b2Vec2& p) -> edgeData* {
float angle = atan2f(basePos.y - p.y, basePos.x - p.x) + fPI;
if (angle > m_angle + m_openingAngle || angle < m_angle) {
return nullptr;
}
int i = static_cast<int>(angle / fPI * 180) % 360;
auto it = edges.find(i);
if (it == edges.end()) {
float r = m_radius / m_scene->GetPixelMeterRatio();
edgeData def{basePos + b2Vec2(r, r), nullptr, 0};
edges.insert(std::make_pair(i, def));
return &edges.find(i)->second;
}
return &it->second;
};
auto aabbCallback = engine::MakeAABBQueryCallback([&, this](b2Fixture* fixture) -> bool {
if (!fixture->GetBody()->GetUserData() ||
static_cast<Node*>(fixture->GetBody()->GetUserData())->IsOpaque())
return true;
if (fixture->GetShape()->GetType() == b2Shape::e_polygon) {
b2PolygonShape* shape = static_cast<b2PolygonShape*>(fixture->GetShape());
for (size_t i = 0; i < shape->GetVertexCount(); i++) {
const b2Vec2& vertex = shape->GetVertex(i);
b2Vec2 vertexPos = b2Mul(fixture->GetBody()->GetTransform(), vertex);
auto vLen = (vertexPos - basePos).Length();
if (vLen < m_radius / m_scene->GetPixelMeterRatio()) {
auto edge = EdgeFromPos(vertexPos);
if (!edge) continue;
// Is the vertex we found better
b2Vec2 dif = edge->pos - basePos;
if (vLen < dif.Length()) {
edge->pos = vertexPos;
}
edge->fixture = fixture;
edge->vertex = i;
}
}
}
return true;
});
b2AABB aabb;
aabb.lowerBound = b2Vec2((pos.x - m_radius) / m_scene->GetPixelMeterRatio(),
(pos.y - m_radius) / m_scene->GetPixelMeterRatio());
aabb.upperBound = b2Vec2((pos.x + m_radius) / m_scene->GetPixelMeterRatio(),
(pos.y + m_radius) / m_scene->GetPixelMeterRatio());
m_scene->GetWorld()->QueryAABB(&aabbCallback, aabb);
float step = m_openingAngle / static_cast<float> (m_rayCount - 1);
float angle = m_angle;
auto it = edges.begin();
m_vertices.resize(1); // keep the center vertex
float f = 1.0;
Node* hitNode = nullptr;
auto rayCastCallback = MakeRayCastCallback([&](b2Fixture* fixture, const b2Vec2& point,
const b2Vec2& normal, float32 fraction) {
Node* n = static_cast<Node*> (fixture->GetBody()->GetUserData());
if (n && !n->IsOpaque() && fraction < f) {
f = fraction;
hitNode = n;
}
return f;
});
sf::Vertex v;
float edgeAngle = 0;
v.position.x = cosf(angle) * m_radius;
v.position.y = sinf(angle) * m_radius;
f = 1.0;
m_scene->GetWorld()->RayCast(&rayCastCallback, basePos, basePos + b2Vec2(v.position.x /
m_scene->GetPixelMeterRatio(),
v.position.y /
m_scene->GetPixelMeterRatio()));
if (hitNode) hitNode->OnLightRay.Fire(this);
v.position.x *= f;
v.position.y *= f;
AssignLightColor(v, f, m_lightColor);
m_vertices.push_back(v);
angle += step;
for (size_t i = 2; i < m_rayCount + 1; i++, angle += step) {
bool had = false;
while (it != edges.end()) {
edgeAngle = b2Angle(basePos, it->second.pos);
if (edgeAngle < 0) edgeAngle += fPI * 2;
if (angle < edgeAngle || edgeAngle >= angle + step) {
break;
}
if (it->second.fixture == nullptr) {
++it;
continue;
}
f = 1.0;
m_scene->GetWorld()->RayCast(&rayCastCallback, basePos, it->second.pos);
// Check if this edge is blocked, skip if it is
if (f < 1.0 - 10.0f / m_radius) {
++it;
continue;
}
if (hitNode) hitNode->OnLightRay.Fire(this);
had = true;
float edgeLengthPct =
m_scene->MeterToPixel((basePos - it->second.pos).Length()) / m_radius + (10.0f / m_radius);
auto addPoint = [&, this](b2Vec2 point) {
v.position.x = m_scene->MeterToPixel(point.x) - pos.x;
v.position.y = m_scene->MeterToPixel(point.y) - pos.y;
f = sqrtf(v.position.x * v.position.x + v.position.y * v.position.y) / m_radius;
AssignLightColor(v, f, m_lightColor);
m_vertices.push_back(v);
};
// Check surrounding edges by using half a degree differences
float checkAngle = edgeAngle - (fPI / 840.f);
if (checkAngle > 0) {
f = 1.0;
b2Vec2 edge = b2Vec2(cosf(edgeAngle - (fPI / 840.f)),
sinf(edgeAngle - (fPI / 840.f)));
edge *= (m_radius / m_scene->GetPixelMeterRatio());
edge += basePos;
m_scene->GetWorld()->RayCast(&rayCastCallback, basePos, edge);
if (f > edgeLengthPct) {
b2Vec2 p = (basePos - edge);
p *= -f;
addPoint(basePos + p);
}
}
addPoint(it->second.pos);
f = 1.0;
checkAngle = edgeAngle + (fPI / 840.f);
if (checkAngle < fPI * 2) {
b2Vec2 edge =
b2Vec2(cosf(checkAngle),
sinf(checkAngle));
edge *= (m_radius / m_scene->GetPixelMeterRatio());
edge += basePos;
m_scene->GetWorld()->RayCast(&rayCastCallback, basePos, edge);
if (f > edgeLengthPct) {
b2Vec2 p = (basePos - edge);
p *= -f;
addPoint(basePos + p);
}
}
++it;
}
// Prevent overlapping rays
if (!had || had && !floatEqual(edgeAngle, angle, fPI / 180.0f) || i == 1 ||
i == m_rayCount) {
v.position.x = cosf(angle) * m_radius;
v.position.y = sinf(angle) * m_radius;
f = 1.0;
m_scene->GetWorld()->RayCast(&rayCastCallback, basePos, basePos + b2Vec2(v.position.x /
m_scene->GetPixelMeterRatio(),
v.position.y /
m_scene->GetPixelMeterRatio()));
if (hitNode) hitNode->OnLightRay.Fire(this);
v.position.x *= f;
v.position.y *= f;
AssignLightColor(v, f, m_lightColor);
m_vertices.push_back(v);
}
}
}
