bool Creature::sees( const tripoint &t, bool is_player ) const
{
// TODO: FoV update
if( posz() != t.z ) {
return false;
}
const int range_cur = sight_range( g->m.ambient_light_at(t) );
const int range_day = sight_range( DAYLIGHT_LEVEL );
const int range_min = std::min( range_cur, range_day );
const int wanted_range = rl_dist( pos3(), t );
if( wanted_range <= range_min ||
( wanted_range <= range_day &&
g->m.ambient_light_at( t ) > g->natural_light_level( t.z ) ) ) {
int range = 0;
if( g->m.ambient_light_at( t ) > g->natural_light_level( t.z ) ) {
range = wanted_range;
} else {
range = range_min;
}
if( is_player ) {
// Special case monster -> player visibility, forcing it to be symmetric with player vision.
return range >= wanted_range &&
g->m.get_cache_ref(pos().z).seen_cache[pos().x][pos().y] > LIGHT_TRANSPARENCY_SOLID;
} else {
return g->m.sees( pos3(), t, range );
}
} else {
return false;
}
}
/* Random walking even when we've moved
* To simulate zombie stumbling and ineffective movement
* Note that this is sub-optimal; stumbling may INCREASE a zombie's speed.
* Most of the time (out in the open) this effect is insignificant compared to
* the negative effects, but in a hallway it's perfectly even
*/
void monster::stumble( bool moved )
{
// don't stumble every turn. every 3rd turn, or 8th when walking.
if( ( moved && !one_in( 8 ) ) || !one_in( 3 ) ) {
return;
}
std::vector<tripoint> valid_stumbles;
const bool avoid_water = has_flag( MF_NO_BREATHE ) && !has_flag( MF_SWIMS ) && !has_flag( MF_AQUATIC );
for( int i = -1; i <= 1; i++ ) {
for( int j = -1; j <= 1; j++ ) {
tripoint dest( posx() + i, posy() + j, posz() );
if( ( i || j ) && can_move_to( dest ) &&
//Stop zombies and other non-breathing monsters wandering INTO water
//(Unless they can swim/are aquatic)
//But let them wander OUT of water if they are there.
!( avoid_water &&
g->m.has_flag( "SWIMMABLE", dest ) &&
!g->m.has_flag( "SWIMMABLE", pos3() ) ) &&
g->critter_at( dest ) == nullptr ) {
valid_stumbles.push_back( dest );
}
}
}
if( g->m.has_zlevels() ) {
tripoint below( posx(), posy(), posz() - 1 );
tripoint above( posx(), posy(), posz() + 1 );
if( g->m.valid_move( pos(), below, false, true ) && can_move_to( below ) ) {
valid_stumbles.push_back( below );
}
// More restrictions for moving up
// It should happen during "shambling around", but not as actual stumbling
if( !moved && one_in( 5 ) && has_flag( MF_FLIES ) &&
g->m.valid_move( pos(), above, false, true ) && can_move_to( above ) ) {
valid_stumbles.push_back( above );
}
}
if( valid_stumbles.empty() ) { //nowhere to stumble?
return;
}
move_to( random_entry( valid_stumbles ), false );
// Here we have to fix our plans[] list,
// acquiring a new path to the previous target.
// target == either end of current plan, or the player.
int bresenham_slope, junk;
if( !plans.empty() ) {
if( g->m.sees( pos3(), plans.back(), -1, bresenham_slope, junk ) ) {
set_dest( plans.back(), bresenham_slope );
} else if( sees( g->u, bresenham_slope ) ) {
set_dest( g->u.pos(), bresenham_slope );
} else { //durr, i'm suddenly calm. what was i doing?
plans.clear();
}
}
}
float monster::rate_target( Creature &c, float best, bool smart ) const
{
const int d = rl_dist( pos3(), c.pos3() );
if( d <= 0 ) {
return INT_MAX;
}
// Check a very common and cheap case first
if( !smart && d >= best ) {
return INT_MAX;
}
if( !sees( c ) ) {
return INT_MAX;
}
float power = c.power_rating();
monster *mon = dynamic_cast< monster * >( &c );
// Their attitude to us and not ours to them, so that bobcats won't get gunned down
if( mon != nullptr && mon->attitude_to( *this ) == Attitude::A_HOSTILE ) {
power += 2;
}
if( power > 0 ) {
return d / power;
}
return INT_MAX;
}
/**
* This function gets information text about a point at pos.
*
* @param pos The position (in client coordinates) to get information
* about.
* @param chunkText This is set to information about the chunk at this
* position.
* @param posText This is set to information about the given position.
* @returns True if information could be obtained.
*/
bool
ChunkWatchControl::getInfoText
(
CPoint const &pos,
std::string &chunkText,
std::string &posText
) const
{
float wx, wz;
if (screenToWorld(pos, &wx, &wz))
{
Vector3 pos3(wx, 0.0f, wz);
posText = sformat("({0}, {1})", wx, wz);
Chunk *chunk =
ChunkManager::instance().cameraSpace()->findChunkFromPoint(pos3);
if (chunk != NULL)
chunkText = chunk->identifier();
else
chunkText = L("WORLDEDITOR/GUI/CONTROLS/CHUNK_WATCH_CONTROL/NOT_LOADED_STRING");
return true;
}
else
{
return false;
}
}
void test_panning_sine_mix() {
Sine vox1(431); // sine osc
Sine pos1(0.5); // sine LFO for panner
// Panner pan1(&vox1, -1.0, 0.1); // scaling panner
Panner pan1(vox1, pos1, 0.1); // scaling panner
Sine vox2(170);
Sine pos2(0.3);
// Panner pan2(&vox2, -0.3, 0.1);
Panner pan2(vox2, pos2, 0.1);
Sine vox3(267);
Sine pos3(0.4);
// Panner pan3(&vox3, 0.3, 0.1);
Panner pan3(vox3, pos3, 0.1);
Sine vox4(224);
Sine pos4(0.7);
// Panner pan4(&vox4, 1.0, 0.1);
Panner pan4(vox4, pos4, 0.1);
Mixer mix(2); // create a stereo mixer
mix.add_input(pan1); // add the panners to the mixer
mix.add_input(pan2);
mix.add_input(pan3);
mix.add_input(pan4);
logMsg("playing panning mix of 4 sines...");
run_test(mix, 9);
logMsg("mix done.");
}
bool WindowsManager::addSquareFace (const char* faceNameCorba,
const value_type* posCorba1,
const value_type* posCorba2,
const value_type* posCorba3,
const value_type* posCorba4,
const value_type* colorCorba)
{
std::string faceName (faceNameCorba);
if (nodes_.find (faceName) != nodes_.end ()) {
std::cout << "You need to chose an other name, \"" << faceName
<< "\" already exist." << std::endl;
return false;
}
else {
mtx_.lock();
osgVector3 pos1 (posCorba1[0], posCorba1[1], posCorba1[2]);
osgVector3 pos2 (posCorba2[0], posCorba2[1], posCorba2[2]);
osgVector3 pos3 (posCorba3[0], posCorba3[1], posCorba3[2]);
osgVector3 pos4 (posCorba4[0], posCorba4[1], posCorba4[2]);
LeafNodeFacePtr_t face = LeafNodeFace::create
(faceName, pos1, pos2, pos3, pos3, getColor (colorCorba));
WindowsManager::initParent (faceName, face);
addNode (faceName, face);
mtx_.unlock();
return true;
}
}
void
AirController::doWork()
{
std::list<Flight*> flights = Airport::getInstance()->getFlights();
std::list<Flight*>::iterator it;
Position pos0(3500.0, 0.0, 100.0);
Position pos1(1500.0, 0.0, 50.0);
Position pos2(200.0, 0.0, 25.0);
Position pos3(-750.0, 0.0, 25.0);
Route r0, r1, r2, r3;
r0.pos = pos0;
r0.speed = 500.0;
r1.pos = pos1;
r1.speed = 100.0;
r2.pos = pos2;
r2.speed = 19.0;
r3.pos = pos3;
r3.speed = 15.0;
for(it = flights.begin(); it!=flights.end(); ++it)
{
if((*it)->getRoute()->empty())
{
(*it)->getRoute()->push_back(r3);
(*it)->getRoute()->push_front(r2);
(*it)->getRoute()->push_front(r1);
(*it)->getRoute()->push_front(r0);
}
}
}
bool Creature::sees( const Creature &critter, int &bresen1, int &bresen2 ) const
{
if( critter.is_hallucination() ) {
// hallucinations are imaginations of the player character, npcs or monsters don't hallucinate.
// Invisible hallucinations would be pretty useless (nobody would see them at all), therefor
// the player will see them always.
return is_player();
}
const auto p = dynamic_cast< const player* >( &critter );
if( p != nullptr && p->is_invisible() ) {
// Let invisible players see themselves (simplifies drawing)
return p == this;
}
if( posz() != critter.posz() && !debug_mode ) {
return false; // TODO: Remove this
}
const int wanted_range = rl_dist( pos3(), critter.pos3() );
if( wanted_range <= 1 ) {
return true;
} else if( ( wanted_range > 1 && critter.digging() ) ||
( g->m.is_divable( critter.pos3() ) && critter.is_underwater() && !is_underwater() ) ) {
return false;
}
return sees( critter.pos3(), bresen1, bresen2 );
}
/**
* Graba la animación a fichero
*/
void CameraAnimation::save(const osg::AnimationPath *ap, const std::string &filename)
{
osg::AnimationPath::TimeControlPointMap::const_iterator it;
std::ofstream output(filename.c_str());
osg::Quat quat_yup2zup;
quat_yup2zup.makeRotate( osg::Vec3(0.0, 0.0, 1.0), osg::Vec3(0.0, 1.0, 0.0) );
osg::Matrix mat_yup2zup( quat_yup2zup );
for(it=ap->getTimeControlPointMap().begin(); it!=ap->getTimeControlPointMap().end() ; it++){
double time = it->first;
osg::AnimationPath::ControlPoint cp = it->second;
if ( Config::instance()->getYUp2ZUp() ) {
osg::Vec4 pos = mat_yup2zup * osg::Vec4(cp.getPosition(), 1.0);
osg::Vec3 pos3(pos.x(), pos.y(), pos.z());
// We must post-multiply the quaternion with the conjugate
// of yup2zup quaternion, even though I don't really know exactly why... :-m
osg::Quat rot = cp.getRotation() * quat_yup2zup.conj();
output << std::setprecision(10) << time << " " << pos3 << " " << rot << std::endl;
}
else {
output << std::setprecision(10) << time << " " << cp.getPosition() << " " << cp.getRotation() << std::endl;
}
}
}
void CObject::setPosition(const Vector2& pos)
{
Vector3 pos3(pos.x,0,pos.y);
if( CWorld::instance()->loaded() )
{
pos3.y = CWorld::instance()->heightAt(pos3);
Real y = CWorld::instance()->heightAt(pos3);
y = 5;
}
setPosition(pos3);
};
void CObject::setPosition(const Vector2& pos)
{
Vector3 pos3(pos.x,0,pos.y);
if( I_WORLD->loaded() )
{
pos3.y = I_WORLD->heightAt(pos3);
Real y = I_WORLD->heightAt(pos3);
y = 5;
}
setPosition(pos3);
};
/* will_reach() is used for determining whether we'll get to stairs (and
* potentially other locations of interest). It is generally permissive.
* TODO: Pathfinding;
Make sure that non-smashing monsters won't "teleport" through windows
Injure monsters if they're gonna be walking through pits or whatevs
*/
bool monster::will_reach( int x, int y )
{
monster_attitude att = attitude( &( g->u ) );
if( att != MATT_FOLLOW && att != MATT_ATTACK && att != MATT_FRIEND && att != MATT_ZLAVE ) {
return false;
}
if( has_flag( MF_DIGS ) || has_flag( MF_AQUATIC ) ) {
return false;
}
if( has_flag( MF_IMMOBILE ) && ( posx() != x || posy() != y ) ) {
return false;
}
std::vector<tripoint> path = g->m.route( pos(), tripoint(x, y, posz()), 0, 100 );
if( path.empty() ) {
return false;
}
if( has_flag( MF_SMELLS ) && g->scent( pos3() ) > 0 &&
g->scent( { x, y, posz() } ) > g->scent( pos3() ) ) {
return true;
}
if( can_hear() && wandf > 0 && rl_dist( wander_pos.x, wander_pos.y, x, y ) <= 2 &&
rl_dist( posx(), posy(), wander_pos.x, wander_pos.y ) <= wandf ) {
return true;
}
int t;
if( can_see() && g->m.sees( posx(), posy(), x, y, g->light_level(), t ) ) {
return true;
}
return false;
}
bool Creature::sees( const tripoint &t, int &bresen1, int &bresen2 ) const
{
// TODO: FoV update
bresen2 = 0;
if( posz() != t.z ) {
return false;
}
const int range_cur = sight_range( g->m.ambient_light_at(t) );
const int range_day = sight_range( DAYLIGHT_LEVEL );
const int range_min = std::min( range_cur, range_day );
const int wanted_range = rl_dist( pos3(), t );
if( wanted_range <= range_min ||
( wanted_range <= range_day &&
g->m.ambient_light_at( t ) > g->natural_light_level() ) ) {
if( g->m.ambient_light_at( t ) > g->natural_light_level() ) {
return g->m.sees( pos3(), t, wanted_range, bresen1, bresen2 );
} else {
return g->m.sees( pos3(), t, range_min, bresen1, bresen2 );
}
} else {
return false;
}
}
/**
* Stumble in a random direction, but with some caveats.
*/
void monster::stumble( )
{
// Only move every 3rd turn.
if( !one_in( 3 ) ) {
return;
}
std::vector<tripoint> valid_stumbles;
const bool avoid_water = has_flag( MF_NO_BREATHE ) &&
!has_flag( MF_SWIMS ) && !has_flag( MF_AQUATIC );
for( int i = -1; i <= 1; i++ ) {
for( int j = -1; j <= 1; j++ ) {
tripoint dest( posx() + i, posy() + j, posz() );
if( ( i || j ) && can_move_to( dest ) &&
//Stop zombies and other non-breathing monsters wandering INTO water
//(Unless they can swim/are aquatic)
//But let them wander OUT of water if they are there.
!( avoid_water &&
g->m.has_flag( TFLAG_SWIMMABLE, dest ) &&
!g->m.has_flag( TFLAG_SWIMMABLE, pos3() ) ) &&
( g->critter_at( dest, is_hallucination() ) == nullptr ) ) {
valid_stumbles.push_back( dest );
}
}
}
if( g->m.has_zlevels() ) {
tripoint below( posx(), posy(), posz() - 1 );
tripoint above( posx(), posy(), posz() + 1 );
if( g->m.valid_move( pos(), below, false, true ) && can_move_to( below ) ) {
valid_stumbles.push_back( below );
}
// More restrictions for moving up
if( one_in( 5 ) && has_flag( MF_FLIES ) &&
g->m.valid_move( pos(), above, false, true ) && can_move_to( above ) ) {
valid_stumbles.push_back( above );
}
}
if( valid_stumbles.empty() ) { //nowhere to stumble?
return;
}
move_to( random_entry( valid_stumbles ), false );
}
TEST(ALPose2DTest, getAngle)
{
const float eps = 1e-4f;
AL::Math::Pose2D pos1(1.5f, 0.0f, 0.0f);
EXPECT_NEAR(pos1.getAngle(), 0.0f, eps);
AL::Math::Pose2D pos2(1.5f, 0.0f, 2.0f);
EXPECT_NEAR(pos2.getAngle(), 0.0f, eps);
AL::Math::Pose2D pos3(1.0f, -1.0f, 2.0f);
EXPECT_NEAR(pos3.getAngle(), -AL::Math::PI_4, eps);
AL::Math::Pose2D pos4(0.0f, 1.0f, 1.0f);
EXPECT_NEAR(pos4.getAngle(), AL::Math::PI_2, eps);
AL::Math::Pose2D pos5(-2.0f, 1.0f, 2.0f);
EXPECT_NEAR(pos5.getAngle(), 2.67792f, eps);
}
int monster::group_bash_skill( const tripoint &target )
{
if( !has_flag( MF_GROUP_BASH ) ) {
return bash_skill();
}
int bashskill = 0;
// pileup = more bashskill, but only help bashing mob directly infront of target
const int max_helper_depth = 5;
const std::vector<tripoint> bzone = get_bashing_zone( target, pos3(), max_helper_depth );
for( const tripoint &candidate : bzone ) {
// Drawing this line backwards excludes the target and includes the candidate.
std::vector<tripoint> path_to_target = line_to( target, candidate, 0, 0 );
bool connected = true;
int mondex = -1;
for( const tripoint &in_path : path_to_target ) {
// If any point in the line from zombie to target is not a cooperating zombie,
// it can't contribute.
mondex = g->mon_at( in_path );
if( mondex == -1 ) {
connected = false;
break;
}
monster &helpermon = g->zombie( mondex );
if( !helpermon.has_flag( MF_GROUP_BASH ) || helpermon.is_hallucination() ) {
connected = false;
break;
}
}
if( !connected || mondex == -1 ) {
continue;
}
// If we made it here, the last monster checked was the candidate.
monster &helpermon = g->zombie( mondex );
// Contribution falls off rapidly with distance from target.
bashskill += helpermon.bash_skill() / rl_dist( candidate, target );
}
return bashskill;
}
int monster::turns_to_reach( int x, int y )
{
// This function is a(n old) temporary hack that should soon be removed
std::vector<tripoint> path = g->m.route( pos(), tripoint(x, y, posz()), 0, 100 );
if( path.empty() ) {
return 999;
}
double turns = 0.;
for( size_t i = 0; i < path.size(); i++ ) {
const tripoint &next = path[i];
if( g->m.move_cost( next ) == 0 ) {
// No bashing through, it looks stupid when you go back and find
// the doors intact.
return 999;
} else if( i == 0 ) {
turns += double( calc_movecost( pos3(), next ) ) / get_speed();
} else {
turns += double( calc_movecost( path[i - 1], next ) ) / get_speed();
}
}
return int( turns + .9 ); // Halve (to get turns) and round up
}
void RenderQuad()
{
if (quadVAO == 0)
{
// positions
glm::vec3 pos1(-1.0, 1.0, 0.0);
glm::vec3 pos2(-1.0, -1.0, 0.0);
glm::vec3 pos3(1.0, -1.0, 0.0);
glm::vec3 pos4(1.0, 1.0, 0.0);
// texture coordinates
glm::vec2 uv1(0.0, 1.0);
glm::vec2 uv2(0.0, 0.0);
glm::vec2 uv3(1.0, 0.0);
glm::vec2 uv4(1.0, 1.0);
// normal vector
glm::vec3 nm(0.0, 0.0, 1.0);
// calculate tangent/bitangent vectors of both triangles
glm::vec3 tangent1, bitangent1;
glm::vec3 tangent2, bitangent2;
// - triangle 1
glm::vec3 edge1 = pos2 - pos1;
glm::vec3 edge2 = pos3 - pos1;
glm::vec2 deltaUV1 = uv2 - uv1;
glm::vec2 deltaUV2 = uv3 - uv1;
GLfloat f = 1.0f / (deltaUV1.x * deltaUV2.y - deltaUV2.x * deltaUV1.y);
tangent1.x = f * (deltaUV2.y * edge1.x - deltaUV1.y * edge2.x);
tangent1.y = f * (deltaUV2.y * edge1.y - deltaUV1.y * edge2.y);
tangent1.z = f * (deltaUV2.y * edge1.z - deltaUV1.y * edge2.z);
tangent1 = glm::normalize(tangent1);
bitangent1.x = f * (-deltaUV2.x * edge1.x + deltaUV1.x * edge2.x);
bitangent1.y = f * (-deltaUV2.x * edge1.y + deltaUV1.x * edge2.y);
bitangent1.z = f * (-deltaUV2.x * edge1.z + deltaUV1.x * edge2.z);
bitangent1 = glm::normalize(bitangent1);
// - triangle 2
edge1 = pos3 - pos1;
edge2 = pos4 - pos1;
deltaUV1 = uv3 - uv1;
deltaUV2 = uv4 - uv1;
f = 1.0f / (deltaUV1.x * deltaUV2.y - deltaUV2.x * deltaUV1.y);
tangent2.x = f * (deltaUV2.y * edge1.x - deltaUV1.y * edge2.x);
tangent2.y = f * (deltaUV2.y * edge1.y - deltaUV1.y * edge2.y);
tangent2.z = f * (deltaUV2.y * edge1.z - deltaUV1.y * edge2.z);
tangent2 = glm::normalize(tangent2);
bitangent2.x = f * (-deltaUV2.x * edge1.x + deltaUV1.x * edge2.x);
bitangent2.y = f * (-deltaUV2.x * edge1.y + deltaUV1.x * edge2.y);
bitangent2.z = f * (-deltaUV2.x * edge1.z + deltaUV1.x * edge2.z);
bitangent2 = glm::normalize(bitangent2);
GLfloat quadVertices[] = {
// Positions // normal // TexCoords // Tangent // Bitangent
pos1.x, pos1.y, pos1.z, nm.x, nm.y, nm.z, uv1.x, uv1.y, tangent1.x, tangent1.y, tangent1.z, bitangent1.x, bitangent1.y, bitangent1.z,
pos2.x, pos2.y, pos2.z, nm.x, nm.y, nm.z, uv2.x, uv2.y, tangent1.x, tangent1.y, tangent1.z, bitangent1.x, bitangent1.y, bitangent1.z,
pos3.x, pos3.y, pos3.z, nm.x, nm.y, nm.z, uv3.x, uv3.y, tangent1.x, tangent1.y, tangent1.z, bitangent1.x, bitangent1.y, bitangent1.z,
pos1.x, pos1.y, pos1.z, nm.x, nm.y, nm.z, uv1.x, uv1.y, tangent2.x, tangent2.y, tangent2.z, bitangent2.x, bitangent2.y, bitangent2.z,
pos3.x, pos3.y, pos3.z, nm.x, nm.y, nm.z, uv3.x, uv3.y, tangent2.x, tangent2.y, tangent2.z, bitangent2.x, bitangent2.y, bitangent2.z,
pos4.x, pos4.y, pos4.z, nm.x, nm.y, nm.z, uv4.x, uv4.y, tangent2.x, tangent2.y, tangent2.z, bitangent2.x, bitangent2.y, bitangent2.z
};
// Setup plane VAO
glGenVertexArrays(1, &quadVAO);
glGenBuffers(1, &quadVBO);
glBindVertexArray(quadVAO);
glBindBuffer(GL_ARRAY_BUFFER, quadVBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(quadVertices), &quadVertices, GL_STATIC_DRAW);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 14 * sizeof(GLfloat), (GLvoid*)0);
glEnableVertexAttribArray(1);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 14 * sizeof(GLfloat), (GLvoid*)(3 * sizeof(GLfloat)));
glEnableVertexAttribArray(2);
glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 14 * sizeof(GLfloat), (GLvoid*)(6 * sizeof(GLfloat)));
glEnableVertexAttribArray(3);
glVertexAttribPointer(3, 3, GL_FLOAT, GL_FALSE, 14 * sizeof(GLfloat), (GLvoid*)(8 * sizeof(GLfloat)));
glEnableVertexAttribArray(4);
glVertexAttribPointer(4, 3, GL_FLOAT, GL_FALSE, 14 * sizeof(GLfloat), (GLvoid*)(11 * sizeof(GLfloat)));
}
glBindVertexArray(quadVAO);
glDrawArrays(GL_TRIANGLES, 0, 6);
glBindVertexArray(0);
}
void UpgradeUILayer::createWeaponUI()
{
std::string fontFile = "DS-Digital.ttf";//"arial.ttf";
int fontSize = 25;
auto infoColor = DIY_COLOR_BLUE5;
auto bk = Scale9Sprite::create("helpCellBG.png");
auto bkSize = panelSize - Size(30,150);
bk->setAnchorPoint(Point::ANCHOR_MIDDLE_TOP);
bk->setPosition(Point(panelSize.width/2,panelSize.height-70));
bk->setContentSize(bkSize);
_panel->addChild(bk);
Point pos1(60,bkSize.height/2+95);
Point pos2(220,bkSize.height/2+95);
Point pos3(350,bkSize.height/2+95);
Point pos4(400,bkSize.height/2+95);
Point offset(0,-50);
auto level_text = TextSprite::create(s_gameStrings.base->upgradeLevel,GameConfig::defaultFontName,fontSize);
level_text->setAnchorPoint(Point::ANCHOR_MIDDLE_LEFT);
level_text->setPosition(pos1);
bk->addChild(level_text);
auto level_before = TextSprite::create(Value(s_playerConfig.weaponslevel[_index-FIGHTER_MAX]+1).asString(),GameConfig::defaultFontName,fontSize);
level_before->setColor(infoColor);
level_before->setAnchorPoint(Point::ANCHOR_MIDDLE_LEFT);
level_before->setPosition(pos2);
bk->addChild(level_before);
auto arrow_upgrade_0 = Sprite::create("upgrade_arrow.png");
arrow_upgrade_0->setPosition(pos3);
bk->addChild(arrow_upgrade_0);
auto level_after = TextSprite::create(Value(s_playerConfig.weaponslevel[_index-FIGHTER_MAX]+2).asString(),GameConfig::defaultFontName,fontSize);
level_after->setColor(infoColor);
level_after->setAnchorPoint(Point::ANCHOR_MIDDLE_LEFT);
level_after->setPosition(pos4);
bk->addChild(level_after);
auto attack_text = TextSprite::create(s_gameStrings.base->upgradeAtt,GameConfig::defaultFontName,fontSize);
attack_text->setAnchorPoint(Point::ANCHOR_MIDDLE_LEFT);
attack_text->setPosition(pos1+offset);
bk->addChild(attack_text);
auto attack_before = TextSprite::create(Value(s_weaponConfigs[_index-FIGHTER_MAX][s_playerConfig.weaponslevel[_index-FIGHTER_MAX]].attack).asString(),GameConfig::defaultFontName,fontSize);
attack_before->setColor(infoColor);
attack_before->setAnchorPoint(Point::ANCHOR_MIDDLE_LEFT);
attack_before->setPosition(pos2+offset);
bk->addChild(attack_before);
auto arrow_upgrade_1 = Sprite::create("upgrade_arrow.png");
arrow_upgrade_1->setPosition(pos3+offset*1);
bk->addChild(arrow_upgrade_1);
auto attack_after = TextSprite::create(Value(s_weaponConfigs[_index-FIGHTER_MAX][s_playerConfig.weaponslevel[_index-FIGHTER_MAX]+1].attack).asString(),GameConfig::defaultFontName,fontSize);
attack_after->setColor(infoColor);
attack_after->setAnchorPoint(Point::ANCHOR_MIDDLE_LEFT);
attack_after->setPosition(pos4+offset);
bk->addChild(attack_after);
auto duration_text = TextSprite::create(s_gameStrings.base->upgradeDuration,GameConfig::defaultFontName,fontSize);
duration_text->setAnchorPoint(Point::ANCHOR_MIDDLE_LEFT);
duration_text->setPosition(pos1+offset*2);
bk->addChild(duration_text);
char p[30];
float duration_before_data = s_weaponConfigs[_index-FIGHTER_MAX][s_playerConfig.weaponslevel[_index-FIGHTER_MAX]].duration;
sprintf(p, "%.2f",duration_before_data);
auto duration_before = TextSprite::create(p,GameConfig::defaultFontName,fontSize);
duration_before->setColor(infoColor);
duration_before->setAnchorPoint(Point::ANCHOR_MIDDLE_LEFT);
duration_before->setPosition(pos2+offset*2);
bk->addChild(duration_before);
auto arrow_upgrade_2 = Sprite::create("upgrade_arrow.png");
arrow_upgrade_2->setPosition(pos3+offset*2);
bk->addChild(arrow_upgrade_2);
float duration_after_data = s_weaponConfigs[_index-FIGHTER_MAX][s_playerConfig.weaponslevel[_index-FIGHTER_MAX]+1].duration;
sprintf(p, "%.2f",duration_after_data);
auto duration_after = TextSprite::create(p,GameConfig::defaultFontName,fontSize);
duration_after->setColor(infoColor);
duration_after->setAnchorPoint(Point::ANCHOR_MIDDLE_LEFT);
duration_after->setPosition(pos4+offset*2);
bk->addChild(duration_after);
auto buyusegem_text = TextSprite::create(s_gameStrings.base->buyusegem,GameConfig::defaultFontName,fontSize);
buyusegem_text->setAnchorPoint(Point::ANCHOR_MIDDLE_LEFT);
buyusegem_text->setPosition(pos1+offset*3);
bk->addChild(buyusegem_text);
auto buyusegem_before = TextSprite::create(Value(s_weaponConfigs[_index-FIGHTER_MAX][s_playerConfig.weaponslevel[_index-FIGHTER_MAX]].costGem).asString(),GameConfig::defaultFontName,fontSize);
buyusegem_before->setColor(infoColor);
buyusegem_before->setAnchorPoint(Point::ANCHOR_MIDDLE_LEFT);
buyusegem_before->setPosition(pos2+offset*3);
bk->addChild(buyusegem_before);
auto arrow_upgrade_3 = Sprite::create("upgrade_arrow.png");
arrow_upgrade_3->setPosition(pos3+offset*3);
bk->addChild(arrow_upgrade_3);
auto buyusegem_after = TextSprite::create(Value(s_weaponConfigs[_index-FIGHTER_MAX][s_playerConfig.weaponslevel[_index-FIGHTER_MAX]+1].costGem).asString(),GameConfig::defaultFontName,fontSize);
buyusegem_after->setColor(infoColor);
buyusegem_after->setAnchorPoint(Point::ANCHOR_MIDDLE_LEFT);
buyusegem_after->setPosition(pos4+offset*3);
bk->addChild(buyusegem_after);
auto buymax_text = TextSprite::create(s_gameStrings.base->buymax,GameConfig::defaultFontName,fontSize);
buymax_text->setAnchorPoint(Point::ANCHOR_MIDDLE_LEFT);
buymax_text->setPosition(pos1+offset*4);
bk->addChild(buymax_text);
auto buymax_before = TextSprite::create(Value(s_weaponConfigs[_index-FIGHTER_MAX][s_playerConfig.weaponslevel[_index-FIGHTER_MAX]].capacity).asString(),GameConfig::defaultFontName,fontSize);
buymax_before->setColor(infoColor);
buymax_before->setAnchorPoint(Point::ANCHOR_MIDDLE_LEFT);
buymax_before->setPosition(pos2+offset*4);
bk->addChild(buymax_before);
auto arrow_upgrade_4 = Sprite::create("upgrade_arrow.png");
arrow_upgrade_4->setPosition(pos3+offset*4);
bk->addChild(arrow_upgrade_4);
auto buymax_after = TextSprite::create(Value(s_weaponConfigs[_index-FIGHTER_MAX][s_playerConfig.weaponslevel[_index-FIGHTER_MAX]+1].capacity).asString(),GameConfig::defaultFontName,fontSize);
buymax_after->setColor(infoColor);
buymax_after->setAnchorPoint(Point::ANCHOR_MIDDLE_LEFT);
buymax_after->setPosition(pos4+offset*4);
bk->addChild(buymax_after);
}
void UpgradeUILayer::createFlightUI()
{
std::string fontFile = "DS-Digital.ttf";//"arial.ttf";
int fontSize = 25;
auto infoColor = DIY_COLOR_BLUE5;
auto bk = Scale9Sprite::create("helpCellBG.png");
auto bkSize = panelSize - Size(30,150);
bk->setAnchorPoint(Point::ANCHOR_MIDDLE_TOP);
bk->setPosition(Point(panelSize.width/2,panelSize.height-70));
bk->setContentSize(bkSize);
_panel->addChild(bk);
Point pos1(80,bkSize.height/2+120);
Point pos2(260,bkSize.height/2+120);
Point pos3(360,bkSize.height/2+120);
Point pos4(400,bkSize.height/2+120);
Point offset(0,-40);
auto level_text = TextSprite::create(s_gameStrings.base->upgradeLevel,GameConfig::defaultFontName,fontSize);
level_text->setAnchorPoint(Point::ANCHOR_MIDDLE_LEFT);
level_text->setPosition(pos1);
bk->addChild(level_text);
auto level_before = TextSprite::create(Value(s_playerConfig.fighterslevel[_index]+1).asString(),GameConfig::defaultFontName,fontSize);
level_before->setColor(infoColor);
level_before->setAnchorPoint(Point::ANCHOR_MIDDLE_LEFT);
level_before->setPosition(pos2);
bk->addChild(level_before);
auto arrow_upgrade_0 = Sprite::create("upgrade_arrow.png");
arrow_upgrade_0->setPosition(pos3);
bk->addChild(arrow_upgrade_0);
auto level_after = TextSprite::create(Value(s_playerConfig.fighterslevel[_index]+2).asString(),GameConfig::defaultFontName,fontSize);
level_after->setColor(infoColor);
level_after->setAnchorPoint(Point::ANCHOR_MIDDLE_LEFT);
level_after->setPosition(pos4);
bk->addChild(level_after);
auto life_text = TextSprite::create(s_gameStrings.base->upgradeLife,GameConfig::defaultFontName,fontSize);
life_text->setAnchorPoint(Point::ANCHOR_MIDDLE_LEFT);
life_text->setPosition(pos1+offset);
bk->addChild(life_text);
auto life_before = TextSprite::create(Value(s_plainConfigs[_index][s_playerConfig.fighterslevel[_index]].life).asString(),GameConfig::defaultFontName,fontSize);
life_before->setColor(infoColor);
life_before->setAnchorPoint(Point::ANCHOR_MIDDLE_LEFT);
life_before->setPosition(pos2+offset);
bk->addChild(life_before);
auto arrow_upgrade_1 = Sprite::create("upgrade_arrow.png");
arrow_upgrade_1->setPosition(pos3+offset);
bk->addChild(arrow_upgrade_1);
auto life_after = TextSprite::create(Value(s_plainConfigs[_index][s_playerConfig.fighterslevel[_index]+1].life).asString(),GameConfig::defaultFontName,fontSize);
life_after->setColor(infoColor);
life_after->setAnchorPoint(Point::ANCHOR_MIDDLE_LEFT);
life_after->setPosition(pos4+offset);
bk->addChild(life_after);
auto attack_text = TextSprite::create(s_gameStrings.base->upgradeAtt,GameConfig::defaultFontName,fontSize);
attack_text->setAnchorPoint(Point::ANCHOR_MIDDLE_LEFT);
attack_text->setPosition(pos1+offset*2);
bk->addChild(attack_text);
auto attack_before = TextSprite::create(Value(s_plainConfigs[_index][s_playerConfig.fighterslevel[_index]].attack).asString(),GameConfig::defaultFontName,fontSize);
attack_before->setColor(infoColor);
attack_before->setAnchorPoint(Point::ANCHOR_MIDDLE_LEFT);
attack_before->setPosition(pos2+offset*2);
bk->addChild(attack_before);
auto arrow_upgrade_2 = Sprite::create("upgrade_arrow.png");
arrow_upgrade_2->setPosition(pos3+offset*2);
bk->addChild(arrow_upgrade_2);
auto attack_after = TextSprite::create(Value(s_plainConfigs[_index][s_playerConfig.fighterslevel[_index]+1].attack).asString(),GameConfig::defaultFontName,fontSize);
attack_after->setColor(infoColor);
attack_after->setAnchorPoint(Point::ANCHOR_MIDDLE_LEFT);
attack_after->setPosition(pos4+offset*2);
bk->addChild(attack_after);
auto defense_text = TextSprite::create(s_gameStrings.base->upgradeDef,GameConfig::defaultFontName,fontSize);
defense_text->setAnchorPoint(Point::ANCHOR_MIDDLE_LEFT);
defense_text->setPosition(pos1+offset*3);
bk->addChild(defense_text);
auto defense_before = TextSprite::create(Value(s_plainConfigs[_index][s_playerConfig.fighterslevel[_index]].defense).asString(),GameConfig::defaultFontName,fontSize);
defense_before->setColor(infoColor);
defense_before->setAnchorPoint(Point::ANCHOR_MIDDLE_LEFT);
defense_before->setPosition(pos2+offset*3);
bk->addChild(defense_before);
auto arrow_upgrade_3 = Sprite::create("upgrade_arrow.png");
arrow_upgrade_3->setPosition(pos3+offset*3);
bk->addChild(arrow_upgrade_3);
auto defense_after = TextSprite::create(Value(s_plainConfigs[_index][s_playerConfig.fighterslevel[_index]+1].defense).asString(),GameConfig::defaultFontName,fontSize);
defense_after->setColor(infoColor);
defense_after->setAnchorPoint(Point::ANCHOR_MIDDLE_LEFT);
defense_after->setPosition(pos4+offset*3);
bk->addChild(defense_after);
auto speed_text = TextSprite::create(s_gameStrings.base->upgradeSpd,GameConfig::defaultFontName,fontSize);
speed_text->setAnchorPoint(Point::ANCHOR_MIDDLE_LEFT);
speed_text->setPosition(pos1+offset*4);
bk->addChild(speed_text);
auto speed_before = TextSprite::create(Value(s_plainConfigs[_index][s_playerConfig.fighterslevel[_index]].speed).asString(),GameConfig::defaultFontName,fontSize);
speed_before->setColor(infoColor);
speed_before->setAnchorPoint(Point::ANCHOR_MIDDLE_LEFT);
speed_before->setPosition(pos2+offset*4);
bk->addChild(speed_before);
auto arrow_upgrade_4 = Sprite::create("upgrade_arrow.png");
arrow_upgrade_4->setPosition(pos3+offset*4);
bk->addChild(arrow_upgrade_4);
auto speed_after = TextSprite::create(Value(s_plainConfigs[_index][s_playerConfig.fighterslevel[_index]+1].speed).asString(),GameConfig::defaultFontName,fontSize);
speed_after->setColor(infoColor);
speed_after->setAnchorPoint(Point::ANCHOR_MIDDLE_LEFT);
speed_after->setPosition(pos4+offset*4);
bk->addChild(speed_after);
auto range_text = TextSprite::create(s_gameStrings.base->upgradeRange,GameConfig::defaultFontName,fontSize);
range_text->setAnchorPoint(Point::ANCHOR_MIDDLE_LEFT);
range_text->setPosition(pos1+offset*5);
bk->addChild(range_text);
auto range_before = TextSprite::create(Value(s_plainConfigs[_index][s_playerConfig.fighterslevel[_index]].range).asString(),GameConfig::defaultFontName,fontSize);
range_before->setColor(infoColor);
range_before->setAnchorPoint(Point::ANCHOR_MIDDLE_LEFT);
range_before->setPosition(pos2+offset*5);
bk->addChild(range_before);
auto arrow_upgrade_5 = Sprite::create("upgrade_arrow.png");
arrow_upgrade_5->setPosition(pos3+offset*5);
bk->addChild(arrow_upgrade_5);
auto range_after = TextSprite::create(Value(s_plainConfigs[_index][s_playerConfig.fighterslevel[_index]+1].range).asString(),GameConfig::defaultFontName,fontSize);
range_after->setColor(infoColor);
range_after->setAnchorPoint(Point::ANCHOR_MIDDLE_LEFT);
range_after->setPosition(pos4+offset*5);
bk->addChild(range_after);
auto usestone_text = TextSprite::create(s_gameStrings.base->useStone,GameConfig::defaultFontName,fontSize);
usestone_text->setAnchorPoint(Point::ANCHOR_MIDDLE_LEFT);
usestone_text->setPosition(pos1+offset*6);
bk->addChild(usestone_text);
auto usestone_before = TextSprite::create(Value(s_plainConfigs[_index][s_playerConfig.fighterslevel[_index]].sparForMake).asString(),GameConfig::defaultFontName,fontSize);
usestone_before->setColor(infoColor);
usestone_before->setAnchorPoint(Point::ANCHOR_MIDDLE_LEFT);
usestone_before->setPosition(pos2+offset*6);
bk->addChild(usestone_before);
auto arrow_upgrade_6 = Sprite::create("upgrade_arrow.png");
arrow_upgrade_6->setPosition(pos3+offset*6);
bk->addChild(arrow_upgrade_6);
auto usestone_after = TextSprite::create(Value(s_plainConfigs[_index][s_playerConfig.fighterslevel[_index]+1].sparForMake).asString(),GameConfig::defaultFontName,fontSize);
usestone_after->setColor(infoColor);
usestone_after->setAnchorPoint(Point::ANCHOR_MIDDLE_LEFT);
usestone_after->setPosition(pos4+offset*6);
bk->addChild(usestone_after);
}
void UpgradeUILayer::createStoneMaxUI()
{
std::string fontFile = "DS-Digital.ttf";//"arial.ttf";
int fontSize = 25;
auto infoColor = DIY_COLOR_BLUE5;
auto bk = Scale9Sprite::create("helpCellBG.png");
auto bkSize = panelSize - Size(30,150);
bk->setAnchorPoint(Point::ANCHOR_MIDDLE_TOP);
bk->setPosition(Point(panelSize.width/2,panelSize.height-70));
bk->setContentSize(bkSize);
_panel->addChild(bk);
Point pos1(60,bkSize.height/2+80);
Point pos2(260,bkSize.height/2+80);
Point pos3(360,bkSize.height/2+80);
Point pos4(400,bkSize.height/2+80);
Point offset(0,-70);
auto level_text = TextSprite::create(s_gameStrings.base->upgradeLevel,GameConfig::defaultFontName,fontSize);
level_text->setAnchorPoint(Point::ANCHOR_MIDDLE_LEFT);
level_text->setPosition(pos1);
bk->addChild(level_text);
auto level_before = TextSprite::create(Value(s_playerConfig.stonecapacitylevel+1).asString(),GameConfig::defaultFontName,fontSize);
level_before->setColor(infoColor);
level_before->setAnchorPoint(Point::ANCHOR_MIDDLE_LEFT);
level_before->setPosition(pos2);
bk->addChild(level_before);
auto arrow_upgrade_0 = Sprite::create("upgrade_arrow.png");
arrow_upgrade_0->setPosition(pos3);
bk->addChild(arrow_upgrade_0);
auto level_after = TextSprite::create(Value(s_playerConfig.stonecapacitylevel+2).asString(),GameConfig::defaultFontName,fontSize);
level_after->setColor(infoColor);
level_after->setAnchorPoint(Point::ANCHOR_MIDDLE_LEFT);
level_after->setPosition(pos4);
bk->addChild(level_after);
auto init_text = TextSprite::create(s_gameStrings.base->stoneinit,GameConfig::defaultFontName,fontSize);
init_text->setAnchorPoint(Point::ANCHOR_MIDDLE_LEFT);
init_text->setPosition(pos1+offset);
bk->addChild(init_text);
auto init_before = TextSprite::create(Value(s_stoneCapacity[s_playerConfig.stonecapacitylevel].initstone).asString(),GameConfig::defaultFontName,fontSize);
init_before->setColor(infoColor);
init_before->setAnchorPoint(Point::ANCHOR_MIDDLE_LEFT);
init_before->setPosition(pos2+offset);
bk->addChild(init_before);
auto arrow_upgrade_1 = Sprite::create("upgrade_arrow.png");
arrow_upgrade_1->setPosition(pos3+offset);
bk->addChild(arrow_upgrade_1);
auto init_after = TextSprite::create(Value(s_stoneCapacity[s_playerConfig.stonecapacitylevel+1].initstone).asString(),GameConfig::defaultFontName,fontSize);
init_after->setColor(infoColor);
init_after->setAnchorPoint(Point::ANCHOR_MIDDLE_LEFT);
init_after->setPosition(pos4+offset);
bk->addChild(init_after);
auto max_text = TextSprite::create(s_gameStrings.base->stonemax,GameConfig::defaultFontName,fontSize);
max_text->setAnchorPoint(Point::ANCHOR_MIDDLE_LEFT);
max_text->setPosition(pos1+offset*2);
bk->addChild(max_text);
auto max_before = TextSprite::create(Value(s_stoneCapacity[s_playerConfig.stonecapacitylevel].maxstone).asString(),GameConfig::defaultFontName,fontSize);
max_before->setColor(infoColor);
max_before->setAnchorPoint(Point::ANCHOR_MIDDLE_LEFT);
max_before->setPosition(pos2+offset*2);
bk->addChild(max_before);
auto arrow_upgrade_2 = Sprite::create("upgrade_arrow.png");
arrow_upgrade_2->setPosition(pos3+offset*2);
bk->addChild(arrow_upgrade_2);
auto max_after = TextSprite::create(Value(s_stoneCapacity[s_playerConfig.stonecapacitylevel+1].maxstone).asString(),GameConfig::defaultFontName,fontSize);
max_after->setColor(infoColor);
max_after->setAnchorPoint(Point::ANCHOR_MIDDLE_LEFT);
max_after->setPosition(pos4+offset*2);
bk->addChild(max_after);
}
bool monster::move_to( const tripoint &p, bool force, float slope )
{
const bool digs = digging();
const bool flies = has_flag( MF_FLIES );
const bool on_ground = !digs && !flies;
const bool climbs = has_flag( MF_CLIMBS ) && g->m.has_flag( TFLAG_NO_FLOOR, p );
// Allows climbing monsters to move on terrain with movecost <= 0
Creature *critter = g->critter_at( p, is_hallucination() );
if( g->m.has_flag( "CLIMBABLE", p ) ) {
if( g->m.move_cost( p ) == 0 && critter == nullptr ) {
if( flies ) {
moves -= 100;
force = true;
if (g->u.sees( *this )){
add_msg(_("The %1$s flies over the %2$s."), name().c_str(),
g->m.has_flag_furn("CLIMBABLE", p) ? g->m.furnname(p).c_str() : g->m.tername(p).c_str());
}
} else if (has_flag(MF_CLIMBS)) {
moves -= 150;
force = true;
if (g->u.sees( *this )){
add_msg(_("The %1$s climbs over the %2$s."), name().c_str(),
g->m.has_flag_furn("CLIMBABLE", p) ? g->m.furnname(p).c_str() : g->m.tername(p).c_str());
}
}
}
}
if( critter != nullptr && !force ) {
return false;
}
// Make sure that we can move there, unless force is true.
if( !force && !can_move_to( p ) ) {
return false;
}
if( !force ) {
// This adjustment is to make it so that monster movement speed relative to the player
// is consistent even if the monster stumbles,
// and the same regardless of the distance measurement mode.
const float stumble_multiplier = has_flag(MF_STUMBLES) ?
(trigdist ? 0.83 : 1.0 - (0.25 * slope)) : 1.0;
const int cost = stumble_multiplier *
(float)(climbs ? calc_climb_cost( pos(), p ) : calc_movecost( pos(), p ));
if( cost > 0 ) {
moves -= cost;
} else {
return false;
}
}
//Check for moving into/out of water
bool was_water = g->m.is_divable( pos3() );
bool will_be_water = on_ground && can_submerge() && g->m.is_divable( p );
if( was_water && !will_be_water && g->u.sees( p ) ) {
//Use more dramatic messages for swimming monsters
add_msg( m_warning, _( "A %1$s %2$s from the %3$s!" ), name().c_str(),
has_flag( MF_SWIMS ) || has_flag( MF_AQUATIC ) ? _( "leaps" ) : _( "emerges" ),
g->m.tername( pos() ).c_str() );
} else if( !was_water && will_be_water && g->u.sees( p ) ) {
add_msg( m_warning, _( "A %1$s %2$s into the %3$s!" ), name().c_str(),
has_flag( MF_SWIMS ) || has_flag( MF_AQUATIC ) ? _( "dives" ) : _( "sinks" ),
g->m.tername( p ).c_str() );
}
setpos( p );
footsteps( p );
underwater = will_be_water;
if( is_hallucination() ) {
//Hallucinations don't do any of the stuff after this point
return true;
}
// TODO: Make tanks stop taking damage from rubble, because it's just silly
if( type->size != MS_TINY && on_ground ) {
if( g->m.has_flag( "SHARP", pos() ) && !one_in( 4 ) ) {
apply_damage( nullptr, bp_torso, rng( 1, 10 ) );
}
if( g->m.has_flag( "ROUGH", pos() ) && one_in( 6 ) ) {
apply_damage( nullptr, bp_torso, rng( 1, 2 ) );
}
}
if( g->m.has_flag( "UNSTABLE", p ) && on_ground ) {
add_effect( "bouldering", 1, num_bp, true );
} else if( has_effect( "bouldering" ) ) {
remove_effect( "bouldering" );
}
g->m.creature_on_trap( *this );
if( !will_be_water && ( has_flag( MF_DIGS ) || has_flag( MF_CAN_DIG ) ) ) {
underwater = g->m.has_flag( "DIGGABLE", pos() );
}
// Diggers turn the dirt into dirtmound
if( digging() ) {
int factor = 0;
switch( type->size ) {
case MS_TINY:
factor = 100;
break;
case MS_SMALL:
factor = 30;
break;
case MS_MEDIUM:
factor = 6;
break;
case MS_LARGE:
factor = 3;
break;
case MS_HUGE:
factor = 1;
break;
}
if( has_flag( MF_VERMIN ) ) {
factor *= 100;
}
if( one_in( factor ) ) {
g->m.ter_set( pos(), t_dirtmound );
}
}
// Acid trail monsters leave... a trail of acid
if( has_flag( MF_ACIDTRAIL ) ) {
g->m.add_field( pos(), fd_acid, 3, 0 );
}
if( has_flag( MF_SLUDGETRAIL ) ) {
for( const tripoint &sludge_p : g->m.points_in_radius( pos(), 1 ) ) {
const int fstr = 3 - ( abs( sludge_p.x - posx() ) + abs( sludge_p.y - posy() ) );
if( fstr >= 2 ) {
g->m.add_field( sludge_p, fd_sludge, fstr, 0 );
}
}
}
if( has_flag( MF_LEAKSGAS ) ) {
if( one_in( 6 ) ) {
tripoint dest( posx() + rng( -1, 1 ), posy() + rng( -1, 1 ), posz() );
g->m.add_field( dest, fd_toxic_gas, 3, 0 );
}
}
return true;
}
void Result::showResultLose(int score){
int left = -320;
int right = 320;
int top = 240;
int bot = -240;
char strbuffer[64];
// L
Point pol1(left+60,top-80);
Point pol2(left+60,bot+220);
Point pol3(left+180,bot+220);
Point pol4(left+180,bot+270);
Point pol5(left+110,bot+270);
Point pol6(left+110,top-80);
Point polc((pol1.x+pol3.x)/2,(pol1.y+pol3.y)/2);
vector<Point> pol;
pol.push_back(pol1);
pol.push_back(pol2);
pol.push_back(pol3);
pol.push_back(pol4);
pol.push_back(pol5);
pol.push_back(pol6);
if (firsttime){
pol_l.setCorner(pol);
pol_l.setCenter(polc);
Transform scale = createScale(0.1, 0.1);
pol_l.applyTransform(scale);
}
// O
Point poo1(left+190,top-80);
Point poo2(left+190,bot+220);
Point poo3(left+310,bot+220);
Point poo4(left+310,top-80);
Point poo5(left+230,top-120);
Point poo6(left+230,bot+260);
Point poo7(left+270,bot+260);
Point poo8(left+270,top-120);
Point pooc((poo1.x+poo3.x)/2,(poo1.y+poo3.y)/2);
vector<Point> poo, poov;
poo.push_back(poo1);
poo.push_back(poo2);
poo.push_back(poo3);
poo.push_back(poo4);
poov.push_back(poo5);
poov.push_back(poo6);
poov.push_back(poo7);
poov.push_back(poo8);
if (firsttime){
pol_o.setCorner(poo);
pol_o.setCenter(pooc);
pol_o1.setCorner(poov);
pol_o1.setCenter(pooc);
Transform scale = createScale(0.1, 0.1);
pol_o.applyTransform(scale);
pol_o1.applyTransform(scale);
}
// S
Point pos1(left+320,top-80);
Point pos2(left+320,top-190);
Point pos3(left+410,top-190);
Point pos4(left+410,top-220);
Point pos5(left+320,top-220);
Point pos6(left+320,top-260);
Point pos7(left+450,top-260);
Point pos8(left+450,top-150);
Point pos9(left+360,top-150);
Point pos10(left+360,top-120);
Point pos11(left+450,top-120);
Point pos12(left+450,top-80);
Point posc((pos1.x+pos7.x)/2,(pos1.y+pos7.y)/2);
vector<Point> pos;
pos.push_back(pos1);
pos.push_back(pos2);
pos.push_back(pos3);
pos.push_back(pos4);
pos.push_back(pos5);
pos.push_back(pos6);
pos.push_back(pos7);
pos.push_back(pos8);
pos.push_back(pos9);
pos.push_back(pos10);
pos.push_back(pos11);
pos.push_back(pos12);
if (firsttime){
pol_s.setCorner(pos);
pol_s.setCenter(posc);
Transform scale = createScale(0.1, 0.1);
pol_s.applyTransform(scale);
}
// E
Point poe1(left+460,top-80);
Point poe2(left+460,bot+220);
Point poe3(left+580,bot+220);
Point poe4(left+580,bot+260);
Point poe5(left+510,bot+260);
Point poe6(left+510,bot+290);
Point poe7(left+580,bot+220+70);
Point poe8(left+580,bot+260+70);
Point poe9(left+510,bot+260+70);
Point poe10(left+510,bot+290+70);
Point poe11(left+580,bot+220+140);
Point poe12(left+580,bot+260+140);
Point poec((poe1.x+poe3.x)/2,(poe1.y+poe3.y)/2);
vector<Point> poe;
poe.push_back(poe1);
poe.push_back(poe2);
poe.push_back(poe3);
poe.push_back(poe4);
poe.push_back(poe5);
poe.push_back(poe6);
poe.push_back(poe7);
poe.push_back(poe8);
poe.push_back(poe9);
poe.push_back(poe10);
poe.push_back(poe11);
poe.push_back(poe12);
if (firsttime){
pol_e.setCorner(poe);
pol_e.setCenter(poec);
Transform scale = createScale(0.1, 0.1);
pol_e.applyTransform(scale);
}
// Other
Point pot1(left+60, top-40);
Point pot2(right-60, top-40);
Point pot3(right-60, top-60);
Point pot4(left+60, top-60);
Point potc((pot1.x+pot2.x)/2,(pot2.x+pot3.x)/2);
vector<Point> pot;
pot.push_back(pot1);
pot.push_back(pot2);
pot.push_back(pot3);
pot.push_back(pot4);
if (firsttime){
pol_pot1.setCorner(pot);
pol_pot1.setCenter(potc);
Transform scale = createScale(0.1, 0.1);
pol_pot1.applyTransform(scale);
}
pot1.set(left+60, bot+180);
pot2.set(right-60, bot+180);
pot3.set(right-60, bot+200);
pot4.set(left+60, bot+200);
potc.set((pot1.x+pot2.x)/2,(pot2.x+pot3.x)/2);
pot.clear();
pot.push_back(pot1);
pot.push_back(pot2);
pot.push_back(pot3);
pot.push_back(pot4);
if (firsttime){
pol_pot2.setCorner(pot);
pol_pot2.setCenter(potc);
Transform scale = createScale(0.1, 0.1);
pol_pot2.applyTransform(scale);
}
resultframe++;
if (resultframe >= 25)
resultframe = 25;
else {
Transform scale = createScale(1.1, 1.1);
pol_pot1.applyTransform(scale);
pol_pot2.applyTransform(scale);
pol_l.applyTransform(scale);
pol_o.applyTransform(scale);
pol_o1.applyTransform(scale);
pol_s.applyTransform(scale);
pol_e.applyTransform(scale);
}
pol_l.draw(WHITE);
fill_polygon(pol_l[0].x, pol_l[2].y, pol_l[2].x, pol_l[0].y,WHITE,WHITE);
pol_o.draw(WHITE);
fill_polygon(pol_o[0].x, pol_o[2].y, pol_o[2].x, pol_o[0].y,WHITE,WHITE);
pol_o1.draw(BLACK);
fill_polygon(pol_o1[0].x, pol_o1[2].y, pol_o1[2].x, pol_o1[0].y,BLACK,BLACK);
pol_s.draw(WHITE);
fill_polygon(pol_s[0].x, pol_s[6].y, pol_s[6].x, pol_s[0].y,WHITE,WHITE);
pol_e.draw(WHITE);
fill_polygon(pol_e[0].x, pol_e[2].y, pol_e[2].x, pol_e[0].y,WHITE,WHITE);
pol_pot1.draw(WHITE);
pol_pot2.draw(WHITE);
settextstyle(7,0,40);
setcolor(WHITE);
sprintf(strbuffer,"%d",score);
outtextxy(getmaxx()/2-50, getmaxy()/2+100, strbuffer);
firsttime = false;
}
void App::DisplayFrame(void) {
glClearColor(0, 0, 0, 1);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
bullet.getWorld()->stepSimulation(1);
glm::mat4 P =
glm::perspective(50.0f, width / static_cast<float>(height), 1.0f, 500.0f);
glm::mat4 M;
glm::mat4 V = glm::lookAt(cameraposition, cameraposition + cameratarget,
glm::vec3(0.0f, 1.0f, 0.0f));
glMatrixMode(GL_PROJECTION);
glLoadMatrixf(glm::value_ptr(P));
glMatrixMode(GL_MODELVIEW);
M = glm::mat4(1.0f);
glLoadMatrixf(glm::value_ptr(V));
GLfloat ambient[] = { 0.1f, 0.1f, 0.1f, 1.0f };
GLfloat diffuse[] = { 1.0f, 1.0f, 1.0f, 1.0f };
GLfloat specular[] = { 1.0f, 1.0f, 1.0f, 1.0f };
glLightfv(GL_LIGHT0, GL_AMBIENT, ambient);
glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse);
glLightfv(GL_LIGHT0, GL_SPECULAR, specular);
glLightfv(GL_LIGHT0, GL_POSITION, lightpos.data());
GLfloat ambient2[] = { 0.0f, 0.0f, 0.1f, 1.0f };
GLfloat diffuse2[] = { 0.0f, 0.0f, 1.0f, 1.0f };
GLfloat specular2[] = { 0.0f, 0.0f, 1.0f, 1.0f };
glLightfv(GL_LIGHT1, GL_AMBIENT, ambient2);
glLightfv(GL_LIGHT1, GL_DIFFUSE, diffuse2);
glLightfv(GL_LIGHT1, GL_SPECULAR, specular2);
glLightfv(GL_LIGHT1, GL_POSITION, lightpos2.data());
glLoadMatrixf(glm::value_ptr(V * M));
bullet.getWorld()->debugDrawWorld();
int texturenr = 0;
for (auto it = bullet.getGameObject().begin();
it != bullet.getGameObject().end(); ++it) {
texturenr = texturenr == 1 ? 0 : 1;
glBindTexture(GL_TEXTURE_2D, texture[texturenr]);
btTransform trans;
(*it)->GetTransform(trans);
M = glm::mat4(1.0f);
glm::vec3 translate =
glm::vec3(trans.getOrigin().getX(), trans.getOrigin().getY(),
trans.getOrigin().getZ());
glm::mat4 T = glm::translate(M, translate);
btMatrix3x3 rotMatrix = trans.getBasis();
float z, y, x;
rotMatrix.getEulerZYX(z, y, x);
M = glm::rotate(T, x, glm::vec3(1.0f, 0.0f, 0.0f));
M = glm::rotate(M, y, glm::vec3(0.0f, 1.0f, 0.0f));
M = glm::rotate(M, z, glm::vec3(0.0f, 0.0f, 1.0f));
glLoadMatrixf(glm::value_ptr(V * M));
(*it)->DrawShape();
if (shadowmode == false)
continue;
for(lightindex=0;lightindex<2;++lightindex){
if (it == bullet.getGameObject().begin())
continue;
glMatrixMode(GL_MODELVIEW);
glLoadMatrixf(glm::value_ptr(V));
std::vector<bool> visibleface;
glm::vec3 light;
if(lightindex==0)light = glm::vec3 (lightpos[0],lightpos[1],lightpos[2] );
else light =glm::vec3 (lightpos2[0],lightpos2[1],lightpos2[2] );
for (auto it = bullet.getSolidSphere().getVertices().begin();
it != bullet.getSolidSphere().getVertices().end(); it += 3) {
glm::vec4 pos4(*(it), *(it + 1), *(it + 2), 1);
pos4 = T * pos4;
glm::vec3 pos3(pos4.x, pos4.y, pos4.z);
glm::vec3 lightvec = light - pos3;
if (glm::dot(lightvec, (pos3 - translate) /
bullet.getSolidSphere().getRadius()) > 0) {
visibleface.push_back(true);
} else {
visibleface.push_back(false);
}
}
{
auto it = bullet.getSolidSphere().getVertices().begin();
CircularAccess ca(visibleface);
for (int i = 0; it != bullet.getSolidSphere().getVertices().end();
++i, it += 3) {
if (ca[i - 1] != ca[i] /*|ca[i+1]!=ca[i]*/
||
ca[i - bullet.getSolidSphere().getSectors()] != ca[i]
/*||ca[i+bullet.getSolidSphere().getSectors()]!=ca[i]*/) {
// if(ca[i]==true){
glm::vec4 pos4(*(it), *(it + 1), *(it + 2), 1);
pos4 = T * pos4;
shadow.push_back(pos4.x);
shadow.push_back(pos4.y);
shadow.push_back(pos4.z);
}
}
shadow.push_back(shadow[0]);
shadow.push_back(shadow[1]);
shadow.push_back(shadow[2]);
visibleface.clear();
}
if (shadow.empty() != true) {
DrawShadow();
}
}
}
glutSwapBuffers();
}
void EntryExitEvaluator::process(FrameList &frames)
{
frameCount++;
if (frameCount > numberOfFrames) {
return;
}
std::vector<inOutEvent> inOut;
for (std::vector<CameraObject>::size_type i = 0; i < frames.getCurrent().getCameras().size(); i++) {
inOutEvent temp;
temp.in = 0;
temp.out = 0;
inOut.push_back(temp);
}
// Save the values for entry and exit
for (std::vector<CameraObject>::size_type i = 0; i < frames.getCurrent().getCameras().size(); i++) {
// getEntered/getExited is the sum of all entrys and exits.
inOut[i].in = frames.getCurrent().getCameras()[i].getEntered() - prevEntered[i];
inOut[i].out = frames.getCurrent().getCameras()[i].getExited() - prevExited[i];
// Save current values for next iteration
prevEntered[i] = frames.getCurrent().getCameras()[i].getEntered();
prevExited[i] = frames.getCurrent().getCameras()[i].getExited();
// Sum ground truth enties and exits
sumEntryGT[i] = sumEntryGT[i] + groundTruth[i][frameCount].in;
sumExitGT[i] = sumExitGT[i] + groundTruth[i][frameCount].out;
//---------- Save data -----------
if(save == 10) {
saveAccuracyToFile(prevEntered[i], "/Users/erikfall/Desktop/entMeas.csv");
saveAccuracyToFile(prevExited[i], "/Users/erikfall/Desktop/exiMeas.csv");
saveAccuracyToFile(sumEntryGT[i], "/Users/erikfall/Desktop/entryGT.csv");
saveAccuracyToFile(sumExitGT[i], "/Users/erikfall/Desktop/exitGT.csv");
//--------------------------------
}
//Accuracy computation
if(sumEntryGT[i] != 0 && sumExitGT[i] != 0){
accuracyTot = 1 - float(std::abs(frames.getCurrent().getCameras()[i].getEntered()-
frames.getCurrent().getCameras()[i].getExited()-
(sumEntryGT[i]-sumExitGT[i])))/(sumEntryGT[i]+sumExitGT[i]);
accuracyIn = 1 - float(std::abs(frames.getCurrent().getCameras()[i].getEntered()-sumEntryGT[i])) / sumEntryGT[i];
accuracyOut = 1 - float(std::abs(frames.getCurrent().getCameras()[i].getExited()-sumExitGT[i])) / sumExitGT[i];
diffEntries[i] = sumEntryGT[i] - frames.getCurrent().getCameras()[i].getEntered();
diffExits[i] = sumExitGT[i] - frames.getCurrent().getCameras()[i].getExited();
diffTotalOfPeople[i] = (sumEntryGT[i] - sumExitGT[i])-
(frames.getCurrent().getCameras()[i].getEntered() - frames.getCurrent().getCameras()[i].getExited());
// Debug, print entry and exit information on the image.
if(frames.getCurrent().getCameras()[i].hasImage("debugImage"))
{
cv::Mat debugIm = frames.getCurrent().getCameras()[i].getImage("debugImage");
std::string accIn = "";
std::string accOut = "";
std::string accTotDiff = "";
std::string GTIn = "";
std::string GTOut = "";
std::string GTTotal = "";
int fontFace = cv::FONT_HERSHEY_PLAIN;
double fontScale = 1;
int thickness = 1;
cv::Point2d pos1(430,15);
cv::Point2d pos2(430,35);
cv::Point2d pos3(430,55);
cv::Point2d pos4(140,20);
cv::Point2d pos5(140,40);
cv::Point2d pos6(140,60);
accIn = "Accuracy In: " + std::to_string(int(round(accuracyIn*100))) + " %";
accOut = "Accuracy Out: " + std::to_string(int(round(accuracyOut*100))) + " %";
accTotDiff = "Accuracy TotDiff: " + std::to_string(int(round(accuracyTot*100))) + " %";
GTIn = "(" + std::to_string(sumEntryGT[i]) + ")";
GTOut = "(" + std::to_string(sumExitGT[i]) + ")";
GTTotal = "(" + std::to_string(sumEntryGT[i] - sumExitGT[i]) + ")";
putText(debugIm, accIn, pos1, fontFace, fontScale, cv::Scalar(0,255,0), thickness, 8);
putText(debugIm, accOut, pos2, fontFace, fontScale, cv::Scalar(0,255,0), thickness, 8);
putText(debugIm, accTotDiff, pos3, fontFace, fontScale, cv::Scalar(0,255,0), thickness, 8);
putText(debugIm, GTIn, pos4, fontFace, fontScale, cv::Scalar(0,255,0), thickness, 8);
putText(debugIm, GTOut, pos5, fontFace, fontScale, cv::Scalar(0,255,0), thickness, 8);
putText(debugIm, GTTotal, pos6, fontFace, fontScale, cv::Scalar(0,255,0), thickness, 8);
}
}
if(save == 10) {
saveAccuracyToFile(accuracyIn, "/Users/erikfall/Desktop/accuracyIn.csv");
saveAccuracyToFile(accuracyOut, "/Users/erikfall/Desktop/accuracyOut.csv");
saveAccuracyToFile(accuracyTot, "/Users/erikfall/Desktop/accuracyTot.csv");
}
if(save == 10) {
save = 0;
}
++ save;
}
}
void EntryExitCounter::process(FrameList &frames)
{
if(frames.hasPrevious())
{
for(unsigned int n = 0; n < frames.getCurrent().getCameras().size(); n++)
{
if(frames.hasDoorMask())
{
CameraObject *cameraCurr = &frames.getCurrent().getCameras()[n];
CameraObject *cameraPrev = &frames.getPrevious().getCameras()[n];
cameraCurr->setEntered(cameraPrev->getEntered()); //Get data from last frame
cameraCurr->setExited(cameraPrev->getExited()); //Get data from last frame
cv::Mat doorMask = frames.getDoorMask(); //Get the door mask
for(std::vector<Object>::iterator object = cameraCurr->getTransitionaryObjects().begin(); object != cameraCurr->getTransitionaryObjects().end(); object++)
{
cv::Point2d pos = object->exitPoint;
if(isInsidePolygon(doorMask, pos) && object->hasPassedMasksOne && object->hasPassedMasksTwo && object->hasPassedMasksThree)
{
cameraCurr->setExited(cameraCurr->getExited()+1);
}
}
cameraCurr->getTransitionaryObjects().clear();
for(std::vector<Object>::iterator object = cameraCurr->getObjects().begin(); object != cameraCurr->getObjects().end(); object++)
{
cv::Point2d entryPosition = object->entryPoint;
if(isInsidePolygon(doorMask, entryPosition) && object->hasPassedMasksOne && object->hasPassedMasksTwo && object->hasPassedMasksThree && !object->hasAlreadyEntered)
{
cameraCurr->setEntered(cameraCurr->getEntered()+1);
object->hasAlreadyEntered = true;
}
}
//Set population for a specific RoomID corresponding to the current camera.
std::string currentRoomID = frames.getCurrent().getCameras()[n].getRoomID();
int exitedThisFrame = cameraCurr->getExited()-cameraPrev->getExited();
int enteredThisFrame = cameraCurr->getEntered()-cameraPrev->getEntered();
int prevPopulation = frames.getPrevious().getPopulationInRoomID(currentRoomID);
frames.getCurrent().setPopulationInRoomID(prevPopulation+enteredThisFrame-exitedThisFrame, currentRoomID);
//------------------ Debug writes nr of people that enters/exits into debugImage ------------------//
if(!cameraCurr->hasImage("debugImage"))
cameraCurr->addImage("debugImage", cameraCurr->getImage("rawImage").clone());
cv::Mat debugImage = cameraCurr->getImage("debugImage");
std::string text = "";
std::string text2 = "";
int fontFace = cv::FONT_HERSHEY_PLAIN;
double fontScale = 1;
int thickness = 1;
cv::Point2d pos1(10,20);
cv::Point2d pos2(10,40);
text = "Entered: " + std::to_string(cameraCurr->getEntered());
putText(debugImage, text, pos1, fontFace, fontScale, cv::Scalar(0,255,0), thickness, 8);
text2 = "Exited: " + std::to_string(cameraCurr->getExited());
putText(debugImage, text2, pos2, fontFace, fontScale, cv::Scalar(0,255,0), thickness, 8);
//------------------------------------------------------------------------------------------------//
}
}
/* Sum all room populations into one. Since roomId's are always different from each other,
totalPopulation is really a debug variable that now is just printed. Works only
for one camera at the moment.*/
totalPopulation = 0;
for(unsigned int n = 0; n < frames.getCurrent().getCameras().size(); n++) {
std::string currentRoomID = frames.getCurrent().getCameras()[n].getRoomID();
totalPopulation = totalPopulation + frames.getCurrent().getPopulationInRoomID(currentRoomID);
}
//--------------------------------- Debug, writes population to debugImage --------------------------------//
std::vector<CameraObject> cameras = frames.getCurrent().getCameras();
if(cameras.size() > 0){
//CameraObject *cameraCurr = &frames.getCurrent().getCameras()[0];
CameraObject *cameraCurr = &cameras[0];
std::string text = "";
int fontFace = cv::FONT_HERSHEY_PLAIN;
double fontScale = 1;
text = "Is inside: " + std::to_string(totalPopulation);
cv::Point2d pos3(10,60);
cv::Mat debugImage = cameraCurr->getImage("debugImage");
putText(debugImage, text, pos3, fontFace, fontScale, cv::Scalar(0,255,0), 1, 8);
}
//--------------------------------------------------------------------------------------------------------//
}
}
// An Update() helper that draws the image.
void GameWindow::Draw()
{
//make sure the Direct3D device is valid
if (!m_d3ddev) return;
//create pointer to the back buffer
m_d3ddev->GetBackBuffer(0, 0, D3DBACKBUFFER_TYPE_MONO, &m_Backbuffer);
//if in game
if(m_bInGame){
//load sprite textures
m_wPlayer.m_Texture = Load_Texture(m_wPlayer.m_Image);
for(int i = 0; i < 7; i++){
if(m_eAllEnemies[i].m_bOnScreen){
m_eAllEnemies[i].m_Texture = Load_Texture(m_eAllEnemies[i].m_Image);
m_eAllEnemies[i].m_HPTexture = Load_Texture(m_eAllEnemies[i].m_HPimg);
}
}
for(int i = 0; i < 7; i++){
if(m_pProjectileList[i].m_bOnScreen){
m_pProjectileList[i].m_Texture = Load_Texture(m_pProjectileList[i].m_Image);
}
}
}
//start rendering
if (m_d3ddev->BeginScene())
{
//draw m_Surface to the m_Backbuffer
m_d3ddev->StretchRect(m_Surface, NULL, m_Backbuffer, NULL, D3DTEXF_NONE);
//begin drawing sprites
m_Sprite->Begin(D3DXSPRITE_ALPHABLEND);
//if in game
if(m_bInGame){
//Turn x and y into a vector. Eventually I will set all coordinates to be vectors
D3DXVECTOR3 pos1(m_wPlayer.m_X, m_wPlayer.m_Y, 0);
//draw player
m_Sprite->Draw(m_wPlayer.m_Texture, NULL, NULL, &pos1, D3DCOLOR_XRGB(255,255,255));
//draw player's spell icon
m_wPlayer.m_Texture = Load_Texture(m_wPlayer.m_SpellImage);
D3DXVECTOR3 spellpos(m_wPlayer.m_X+0.25f*m_wPlayer.m_Width, m_wPlayer.m_Y-48, 0);
m_Sprite->Draw(m_wPlayer.m_Texture, NULL, NULL, &spellpos, D3DCOLOR_XRGB(255,255,255));
//draw all enemies
for(int i = 0; i < 7; i++){
if(m_eAllEnemies[i].m_bOnScreen){
D3DXVECTOR3 pos2(m_eAllEnemies[i].m_X, m_eAllEnemies[i].m_Y, 0);
m_Sprite->Draw(m_eAllEnemies[i].m_Texture, NULL, NULL, &pos2, D3DCOLOR_XRGB(255,255,255));
//draw hp icons
D3DXVECTOR3 pos4(m_eAllEnemies[i].m_X, m_eAllEnemies[i].m_Y- 32, 0);
m_Sprite->Draw(m_eAllEnemies[i].m_HPTexture, NULL, NULL, &pos4, D3DCOLOR_XRGB(255,255,255));
}
}
//draw projectile spells
for(int i = 0; i < 10; i++){
if(m_pProjectileList[i].m_bOnScreen){
D3DXVECTOR3 pos3(m_pProjectileList[i].m_X, m_pProjectileList[i].m_Y, 0);
m_Sprite->Draw(m_pProjectileList[i].m_Texture, NULL, NULL, &pos3, D3DCOLOR_XRGB(255,255,255));
}
}
//draw powerups
D3DXVECTOR3 pos5(m_pPowerup.m_X, m_pPowerup.m_Y, 0);
m_Sprite->Draw(m_pPowerup.m_Texture, NULL, NULL, &pos5, D3DCOLOR_XRGB(255, 255, 255));
//draw hp ui
D3DXVECTOR3 HpPos(16, 684, 0);
m_Sprite->Draw(m_HpTexture, NULL, NULL, &HpPos, D3DCOLOR_XRGB(255,255,255));
if(m_wPlayer.m_Health > 1){
D3DXVECTOR3 HpPos(48, 684, 0);
m_Sprite->Draw(m_HpTexture, NULL, NULL, &HpPos, D3DCOLOR_XRGB(255,255,255));
}
if(m_wPlayer.m_Health > 2){
D3DXVECTOR3 HpPos(80, 684, 0);
m_Sprite->Draw(m_HpTexture, NULL, NULL, &HpPos, D3DCOLOR_XRGB(255,255,255));
}
}
else{
//write title
m_Font->DrawTextA(NULL, "Snape Simulator 2012", -1, &m_rTitle, DT_RIGHT, D3DCOLOR_XRGB(0, 0, 70));
//draw "press space to start" in center of screen
D3DXVECTOR3 StartPos(356, 256, 0);
m_Sprite->Draw(m_StartGameTexture, NULL, NULL, &StartPos, D3DCOLOR_XRGB(255, 255, 255));
}
//UI- draw scores
std::stringstream ss;//create a stringstream
ss << m_Score;//add number to the stream
std::string j = ss.str();
m_Font->DrawTextA(NULL, j.c_str(), -1, &m_rCurrScore, DT_RIGHT, D3DCOLOR_ARGB(255, 255, 255, 255));
std::stringstream ss2;
ss2 << m_Highscore;
j = ss2.str();
m_Font->DrawTextA(NULL, j.c_str(), -1, &m_rBest, DT_RIGHT, D3DCOLOR_ARGB(255, 255, 255, 255));
//stop rendering
m_Sprite->End();
m_d3ddev->EndScene();
m_d3ddev->Present(NULL, NULL, NULL, NULL);
}
}
bool Game::init()
{
mShouldExit = false;
//create Timers
mpLoopTimer = new Timer;
mpMasterTimer = new Timer;
//startup allegro
if(!al_init())
{
fprintf(stderr, "failed to initialize allegro!\n");
return false;
}
//create and init GraphicsSystem
mpGraphicsSystem = new GraphicsSystem();
bool goodGraphics = mpGraphicsSystem->init( WIDTH, HEIGHT );
if(!goodGraphics)
{
fprintf(stderr, "failed to initialize GraphicsSystem object!\n");
return false;
}
mpGraphicsBufferManager = new GraphicsBufferManager();
mpSpriteManager = new SpriteManager();
//startup a lot of allegro stuff
//load image loader addon
if( !al_init_image_addon() )
{
fprintf(stderr, "image addon failed to load!\n");
return false;
}
//install audio stuff
if( !al_install_audio() )
{
fprintf(stderr, "failed to initialize sound!\n");
return false;
}
if(!al_init_acodec_addon())
{
fprintf(stderr, "failed to initialize audio codecs!\n");
return false;
}
if (!al_reserve_samples(1))
{
fprintf(stderr, "failed to reserve samples!\n");
return false;
}
//should probably be done in the InputSystem!
if( !al_install_keyboard() )
{
printf( "Keyboard not installed!\n" );
return false;
}
//should probably be done in the InputSystem!
if( !al_install_mouse() )
{
printf( "Mouse not installed!\n" );
return false;
}
//should be somewhere else!
al_init_font_addon();
if( !al_init_ttf_addon() )
{
printf( "ttf font addon not initted properly!\n" );
return false;
}
//actually load the font
mpFont = al_load_ttf_font( "cour.ttf", 20, 0 );
if( mpFont == NULL )
{
printf( "ttf font file not loaded properly!\n" );
return false;
}
//show the mouse
if( !al_hide_mouse_cursor( mpGraphicsSystem->getDisplay() ) )
{
printf( "Mouse cursor not able to be hidden!\n" );
return false;
}
if( !al_init_primitives_addon() )
{
printf( "Primitives addon not added!\n" );
return false;
}
//load the sample
mpSample = al_load_sample( "clapping.wav" );
if (!mpSample)
{
printf( "Audio clip sample not loaded!\n" );
return false;
}
mpMessageManager = new GameMessageManager();
//load buffers
mBackgroundBufferID = mpGraphicsBufferManager->loadBuffer("wallpaper.bmp");
mPlayerIconBufferID = mpGraphicsBufferManager->loadBuffer("arrow.bmp");
mEnemyIconBufferID = mpGraphicsBufferManager->loadBuffer("enemy-arrow.bmp");
//setup sprites
GraphicsBuffer* pBackGroundBuffer = mpGraphicsBufferManager->getBuffer( mBackgroundBufferID );
if( pBackGroundBuffer != NULL )
{
mpSpriteManager->createAndManageSprite( BACKGROUND_SPRITE_ID, pBackGroundBuffer, 0, 0, pBackGroundBuffer->getWidth(), pBackGroundBuffer->getHeight() );
}
GraphicsBuffer* pPlayerBuffer = mpGraphicsBufferManager->getBuffer( mPlayerIconBufferID );
Sprite* pArrowSprite = NULL;
if( pPlayerBuffer != NULL )
{
pArrowSprite = mpSpriteManager->createAndManageSprite( PLAYER_ICON_SPRITE_ID, pPlayerBuffer, 0, 0, pPlayerBuffer->getWidth(), pPlayerBuffer->getHeight() );
}
GraphicsBuffer* pAIBuffer = mpGraphicsBufferManager->getBuffer( mEnemyIconBufferID );
Sprite* pEnemyArrow = NULL;
if( pAIBuffer != NULL )
{
pEnemyArrow = mpSpriteManager->createAndManageSprite( AI_ICON_SPRITE_ID, pAIBuffer, 0, 0, pAIBuffer->getWidth(), pAIBuffer->getHeight() );
}
//setup units
Vector2D pos( 0.0f, 0.0f );
Vector2D vel( 0.0f, 0.0f );
mpUnit = new KinematicUnit( pArrowSprite, pos, 1, vel, 0.0f, 200.0f, 10.0f );
Vector2D pos2( 1000.0f, 500.0f );
Vector2D vel2( 0.0f, 0.0f );
mpAIUnit = new KinematicUnit( pEnemyArrow, pos2, 1, vel2, 0.0f, 180.0f, 100.0f );
//give steering behavior
mpAIUnit->dynamicArrive( mpUnit );
Vector2D pos3( 500.0f, 500.0f );
mpAIUnit2 = new KinematicUnit( pEnemyArrow, pos3, 1, vel2, 0.0f, 180.0f, 100.0f );
//give steering behavior
mpAIUnit2->dynamicSeek( mpUnit );
return true;
}
/**
* This test does round-trip testing (format -> parse -> format -> parse -> etc.) of
* NumberFormat.
*/
void IntlTestNumberFormatAPI::testAPI(/* char* par */)
{
UErrorCode status = U_ZERO_ERROR;
// ======= Test constructors
logln("Testing NumberFormat constructors");
NumberFormat *def = NumberFormat::createInstance(status);
if(U_FAILURE(status)) {
errln("ERROR: Could not create NumberFormat (default)");
}
status = U_ZERO_ERROR;
NumberFormat *fr = NumberFormat::createInstance(Locale::getFrench(), status);
if(U_FAILURE(status)) {
errln("ERROR: Could not create NumberFormat (French)");
}
NumberFormat *cur = NumberFormat::createCurrencyInstance(status);
if(U_FAILURE(status)) {
errln("ERROR: Could not create NumberFormat (currency, default)");
}
status = U_ZERO_ERROR;
NumberFormat *cur_fr = NumberFormat::createCurrencyInstance(Locale::getFrench(), status);
if(U_FAILURE(status)) {
errln("ERROR: Could not create NumberFormat (currency, French)");
}
NumberFormat *per = NumberFormat::createPercentInstance(status);
if(U_FAILURE(status)) {
errln("ERROR: Could not create NumberFormat (percent, default)");
}
status = U_ZERO_ERROR;
NumberFormat *per_fr = NumberFormat::createPercentInstance(Locale::getFrench(), status);
if(U_FAILURE(status)) {
errln("ERROR: Could not create NumberFormat (percent, French)");
}
// ======= Test equality
if (per_fr != NULL && cur_fr != NULL)
{
logln("Testing equality operator");
if( *per_fr == *cur_fr || ! ( *per_fr != *cur_fr) ) {
errln("ERROR: == failed");
}
}
// ======= Test various format() methods
if (cur_fr != NULL)
{
logln("Testing various format() methods");
double d = -10456.0037;
int32_t l = 100000000;
Formattable fD(d);
Formattable fL(l);
UnicodeString res1, res2, res3, res4, res5, res6;
FieldPosition pos1(0), pos2(0), pos3(0), pos4(0);
res1 = cur_fr->format(d, res1);
logln( (UnicodeString) "" + (int32_t) d + " formatted to " + res1);
res2 = cur_fr->format(l, res2);
logln((UnicodeString) "" + (int32_t) l + " formatted to " + res2);
res3 = cur_fr->format(d, res3, pos1);
logln( (UnicodeString) "" + (int32_t) d + " formatted to " + res3);
res4 = cur_fr->format(l, res4, pos2);
logln((UnicodeString) "" + (int32_t) l + " formatted to " + res4);
status = U_ZERO_ERROR;
res5 = cur_fr->format(fD, res5, pos3, status);
if(U_FAILURE(status)) {
errln("ERROR: format(Formattable [double]) failed");
}
logln((UnicodeString) "" + (int32_t) fD.getDouble() + " formatted to " + res5);
status = U_ZERO_ERROR;
res6 = cur_fr->format(fL, res6, pos4, status);
if(U_FAILURE(status)) {
errln("ERROR: format(Formattable [long]) failed");
}
logln((UnicodeString) "" + fL.getLong() + " formatted to " + res6);
}
// ======= Test parse()
if (fr != NULL)
{
logln("Testing parse()");
double d = -10456.0037;
UnicodeString text("-10,456.0037");
Formattable result1, result2, result3;
ParsePosition pos(0), pos01(0);
fr->parseObject(text, result1, pos);
if(result1.getType() != Formattable::kDouble && result1.getDouble() != d) {
errln("ERROR: Roundtrip failed (via parse()) for " + text);
}
logln(text + " parsed into " + (int32_t) result1.getDouble());
fr->parse(text, result2, pos01);
if(result2.getType() != Formattable::kDouble && result2.getDouble() != d) {
errln("ERROR: Roundtrip failed (via parse()) for " + text);
}
logln(text + " parsed into " + (int32_t) result2.getDouble());
status = U_ZERO_ERROR;
fr->parse(text, result3, status);
if(U_FAILURE(status)) {
errln("ERROR: parse() failed");
}
if(result3.getType() != Formattable::kDouble && result3.getDouble() != d) {
errln("ERROR: Roundtrip failed (via parse()) for " + text);
}
logln(text + " parsed into " + (int32_t) result3.getDouble());
}
// ======= Test getters and setters
if (fr != NULL && def != NULL)
{
logln("Testing getters and setters");
int32_t count = 0;
const Locale *locales = NumberFormat::getAvailableLocales(count);
logln((UnicodeString) "Got " + count + " locales" );
for(int32_t i = 0; i < count; i++) {
UnicodeString name(locales[i].getName(),"");
logln(name);
}
fr->setParseIntegerOnly( def->isParseIntegerOnly() );
if(fr->isParseIntegerOnly() != def->isParseIntegerOnly() ) {
errln("ERROR: setParseIntegerOnly() failed");
}
fr->setGroupingUsed( def->isGroupingUsed() );
if(fr->isGroupingUsed() != def->isGroupingUsed() ) {
errln("ERROR: setGroupingUsed() failed");
}
fr->setMaximumIntegerDigits( def->getMaximumIntegerDigits() );
if(fr->getMaximumIntegerDigits() != def->getMaximumIntegerDigits() ) {
errln("ERROR: setMaximumIntegerDigits() failed");
}
fr->setMinimumIntegerDigits( def->getMinimumIntegerDigits() );
if(fr->getMinimumIntegerDigits() != def->getMinimumIntegerDigits() ) {
errln("ERROR: setMinimumIntegerDigits() failed");
}
fr->setMaximumFractionDigits( def->getMaximumFractionDigits() );
if(fr->getMaximumFractionDigits() != def->getMaximumFractionDigits() ) {
errln("ERROR: setMaximumFractionDigits() failed");
}
fr->setMinimumFractionDigits( def->getMinimumFractionDigits() );
if(fr->getMinimumFractionDigits() != def->getMinimumFractionDigits() ) {
errln("ERROR: setMinimumFractionDigits() failed");
}
}
// ======= Test getStaticClassID()
logln("Testing getStaticClassID()");
status = U_ZERO_ERROR;
NumberFormat *test = new DecimalFormat(status);
if(U_FAILURE(status)) {
errln("ERROR: Couldn't create a NumberFormat");
}
if(test->getDynamicClassID() != DecimalFormat::getStaticClassID()) {
errln("ERROR: getDynamicClassID() didn't return the expected value");
}
delete test;
delete def;
delete fr;
delete cur;
delete cur_fr;
delete per;
delete per_fr;
}
void worldmap_object_t::test<2>()
{
// Test 8 : reset()
try {
mWorld->reset();
} catch (...) {
fail("LLWorldMap::reset() at init test failed");
}
// Test 9 : Verify that all the region list is empty
LLWorldMap::sim_info_map_t list;
list = mWorld->getRegionMap();
ensure("LLWorldMap::getRegionMap() empty at init test failed", list.empty());
// Test 10 : Insert a region
bool success;
LLUUID id;
std::string name_sim = SIM_NAME_TEST;
success = mWorld->insertRegion( U32(X_WORLD_TEST),
U32(Y_WORLD_TEST),
name_sim,
id,
SIM_ACCESS_PG,
REGION_FLAGS_SANDBOX);
list = mWorld->getRegionMap();
ensure("LLWorldMap::insertRegion() failed", success && (list.size() == 1));
// Test 11 : Insert an item in the same region -> number of regions doesn't increase
std::string name_item = ITEM_NAME_TEST;
success = mWorld->insertItem( U32(X_WORLD_TEST + REGION_WIDTH_METERS/2),
U32(Y_WORLD_TEST + REGION_WIDTH_METERS/2),
name_item,
id,
MAP_ITEM_LAND_FOR_SALE,
0, 0);
list = mWorld->getRegionMap();
ensure("LLWorldMap::insertItem() in existing region failed", success && (list.size() == 1));
// Test 12 : Insert an item in another region -> number of regions increases
success = mWorld->insertItem( U32(X_WORLD_TEST + REGION_WIDTH_METERS*2),
U32(Y_WORLD_TEST + REGION_WIDTH_METERS*2),
name_item,
id,
MAP_ITEM_LAND_FOR_SALE,
0, 0);
list = mWorld->getRegionMap();
ensure("LLWorldMap::insertItem() in unexisting region failed", success && (list.size() == 2));
// Test 13 : simInfoFromPosGlobal() in region
LLVector3d pos1( X_WORLD_TEST + REGION_WIDTH_METERS*2 + REGION_WIDTH_METERS/2,
Y_WORLD_TEST + REGION_WIDTH_METERS*2 + REGION_WIDTH_METERS/2,
0.0f);
LLSimInfo* sim;
sim = mWorld->simInfoFromPosGlobal(pos1);
ensure("LLWorldMap::simInfoFromPosGlobal() test on existing region failed", sim != NULL);
// Test 14 : simInfoFromPosGlobal() outside region
LLVector3d pos2( X_WORLD_TEST + REGION_WIDTH_METERS*4 + REGION_WIDTH_METERS/2,
Y_WORLD_TEST + REGION_WIDTH_METERS*4 + REGION_WIDTH_METERS/2,
0.0f);
sim = mWorld->simInfoFromPosGlobal(pos2);
ensure("LLWorldMap::simInfoFromPosGlobal() test outside region failed", sim == NULL);
// Test 15 : simInfoFromName()
sim = mWorld->simInfoFromName(name_sim);
ensure("LLWorldMap::simInfoFromName() test on existing region failed", sim != NULL);
// Test 16 : simInfoFromHandle()
U64 handle = to_region_handle_global(X_WORLD_TEST, Y_WORLD_TEST);
sim = mWorld->simInfoFromHandle(handle);
ensure("LLWorldMap::simInfoFromHandle() test on existing region failed", sim != NULL);
// Test 17 : simNameFromPosGlobal()
LLVector3d pos3( X_WORLD_TEST + REGION_WIDTH_METERS/2,
Y_WORLD_TEST + REGION_WIDTH_METERS/2,
0.0f);
success = mWorld->simNameFromPosGlobal(pos3, name_sim);
ensure("LLWorldMap::simNameFromPosGlobal() test on existing region failed", success && (name_sim == SIM_NAME_TEST));
// Test 18 : reset()
try {
mWorld->reset();
} catch (...) {
fail("LLWorldMap::reset() at end test failed");
}
// Test 19 : Verify that all the region list is empty
list = mWorld->getRegionMap();
ensure("LLWorldMap::getRegionMap() empty at end test failed", list.empty());
}
