DrawableSprite::DrawableSprite() : Sprite ( Coord(), Coord ( 1, 1 ), 0, 1 )
{
//ctor
}
Coord Widget::toLocal( const Coord& coord ) const
{
Coord c = globalPos();
return Coord( coord.x - c.x, coord.y - c.y );
}
void Menubar::_render( GfxDevice * pDevice, const Rect& _canvas, const Rect& _window, const Rect& _clip )
{
Widget::_render(pDevice,_canvas,_window,_clip);
// Take backgrounds content borders into account
Rect window;
Rect clip;
if( m_pSkin )
{
window = m_pSkin->contentRect( _canvas, m_state );
clip.intersection( window, _clip );
}
else
{
window = _canvas;
clip = _clip;
}
// Go throught the MenuBarItems and print their text and render their rectangles.
MenuBarItem * pI = m_items.first();
uint32_t posX = window.x;
Pen pen;
TextAttr attr;
TextTool::addPropAttributes( attr, Base::getDefaultTextprop(), StateEnum::Normal);
TextTool::addPropAttributes( attr, m_pTextProp, StateEnum::Normal);
pen.setAttributes( attr );
pen.setClipRect( clip );
pen.setDevice( pDevice );
uint32_t printPosY = window.y + ( window.h - pen.getLineHeight() )/2 + pen.getBaseline();
uint32_t itemNb = 1;
while( pI )
{
if( pI->isVisible() )
{
State state = StateEnum::Disabled;
if( m_state.isEnabled() && pI->m_bEnabled )
{
state = StateEnum::Normal;
if( itemNb == m_selectedItem )
state = StateEnum::Pressed;
else if( itemNb == m_markedItem )
state = StateEnum::Hovered;
}
Border b = _getEntryBorder();
// ColorsetPtr pTextColors;
// if( m_pSkin )
// pTextColors = m_pSkin->TextColors();
if( m_pEntrySkin )
{
Rect dest( posX, window.y, pI->m_width + b.width(), window.h );
m_pEntrySkin->render( pDevice, dest, state, clip );
// pTextColors = m_pEntrySkin->TextColors();
}
pen.setPos( Coord(posX + b.left, printPosY) );
TextAttr attr;
TextTool::addPropAttributes( attr, Base::getDefaultTextprop(), state );
// TextTool::setAttrColor( attr, pTextColors, mode );
TextTool::addPropAttributes( attr, m_pTextProp, state );
pen.setAttributes( attr );
pDevice->printLine( pen, attr, pI->m_pText );
posX += pI->m_width + b.width();
}
itemNb++;
pI = pI->next();
}
}
/**
* Applique l'opérateur modulo sur les deux coordonnées.
*/
Coord Coord::operator%(const int n) const
{
return Coord(this->x % n, this->y % n);
}
/**
This function returns the size of the specified item.
\param ItemID the id of the item (e.g. Structure_HeavyFactory)
\return a Coord containg the size (e.g. (3,2) ). Returns (0,0) on error.
*/
Coord getStructureSize(int itemID) {
switch(itemID) {
case Structure_Barracks: return Coord(2,2); break;
case Structure_ConstructionYard: return Coord(2,2); break;
case Structure_GunTurret: return Coord(1,1); break;
case Structure_HeavyFactory: return Coord(3,2); break;
case Structure_HighTechFactory: return Coord(3,2); break;
case Structure_IX: return Coord(2,2); break;
case Structure_LightFactory: return Coord(2,2); break;
case Structure_Palace: return Coord(3,3); break;
case Structure_Radar: return Coord(2,2); break;
case Structure_Refinery: return Coord(3,2); break;
case Structure_RepairYard: return Coord(3,2); break;
case Structure_RocketTurret: return Coord(1,1); break;
case Structure_Silo: return Coord(2,2); break;
case Structure_StarPort: return Coord(3,3); break;
case Structure_Slab1: return Coord(1,1); break;
case Structure_Slab4: return Coord(2,2); break;
case Structure_Wall: return Coord(1,1); break;
case Structure_WindTrap: return Coord(2,2); break;
case Structure_WOR: return Coord(2,2); break;
default: return Coord(0,0); break;
}
return Coord(0,0);
}
/**
* Soustrait deux coordonnées.
*/
Coord Coord::operator-(const Coord& c) const
{
return Coord(this->x - c.x, this->y - c.y);
}
/**
* Divise une coordonnée par une valeur entière.
*/
Coord Coord::operator/(const int n) const
{
return Coord(this->x / n, this->y / n);
}
Coord operator-(Coord coord1,Coord coord2){
return Coord(coord1.x()-coord2.x(),coord1.y()-coord2.y(),coord1.z()-coord2.z(),coord1.ex()-coord2.ex(),coord1.ey()-coord2.ey(),coord1.ez()-coord2.ez());
}
Coord operator*(float value,Coord coord2){
return Coord(coord2.x()*value,coord2.y()*value,coord2.z()*value,coord2.ex()*value,coord2.ey()*value,coord2.ez()*value);
}
Apple() {
_value = 10;
_type = NORMAL_APPLE;
_pos = Coord(0, 0);
}
void GlAxisBoxPlot::draw(float lod,Camera* camera) {
float rotationAngle = axis->getRotationAngle();
if (rotationAngle != 0) {
glPushMatrix();
glRotatef(rotationAngle, 0.0f, 0.0f, 1.0f);
}
bottomOutlierCoord = axis->getBottomOutlierCoord();
firstQuartileCoord = axis->getFirstQuartileCoord();
medianCoord = axis->getMedianCoord();
thirdQuartileCoord = axis->getThirdQuartileCoord();
topOutlierCoord = axis->getTopOutlierCoord();
Coord interQuartileRangeBoxCoords[4];
if (axis->hasAscendingOrder()) {
boundingBox.expand(Coord(bottomOutlierCoord.getX() - boxWidth / 2.0f, bottomOutlierCoord.getY(), 0.0f));
boundingBox.expand(Coord(topOutlierCoord.getX() + boxWidth / 2.0f, topOutlierCoord.getY(), 0.0f));
interQuartileRangeBoxCoords[0] = Coord(thirdQuartileCoord.getX() - boxWidth / 2.0f, thirdQuartileCoord.getY(), 0.0f);
interQuartileRangeBoxCoords[1] = Coord(thirdQuartileCoord.getX() + boxWidth / 2.0f, thirdQuartileCoord.getY(), 0.0f);
interQuartileRangeBoxCoords[2] = Coord(firstQuartileCoord.getX() + boxWidth / 2.0f, firstQuartileCoord.getY(), 0.0f);
interQuartileRangeBoxCoords[3] = Coord(firstQuartileCoord.getX() - boxWidth / 2.0f, firstQuartileCoord.getY(), 0.0f);
}
else {
boundingBox.expand(Coord(topOutlierCoord.getX() - boxWidth / 2.0f, topOutlierCoord.getY(), 0.0f));
boundingBox.expand(Coord(bottomOutlierCoord.getX() + boxWidth / 2.0f, bottomOutlierCoord.getY(), 0.0f));
interQuartileRangeBoxCoords[0] = Coord(firstQuartileCoord.getX() - boxWidth / 2.0f, firstQuartileCoord.getY(), 0.0f);
interQuartileRangeBoxCoords[1] = Coord(firstQuartileCoord.getX() + boxWidth / 2.0f, firstQuartileCoord.getY(), 0.0f);
interQuartileRangeBoxCoords[2] = Coord(thirdQuartileCoord.getX() + boxWidth / 2.0f, thirdQuartileCoord.getY(), 0.0f);
interQuartileRangeBoxCoords[3] = Coord(thirdQuartileCoord.getX() - boxWidth / 2.0f, thirdQuartileCoord.getY(), 0.0f);
}
GlQuad interQuartileRangeBox(interQuartileRangeBoxCoords[0], interQuartileRangeBoxCoords[1],
interQuartileRangeBoxCoords[2], interQuartileRangeBoxCoords[3], fillColor);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA,GL_SRC_COLOR);
glEnable(GL_LIGHTING);
interQuartileRangeBox.draw(lod, camera);
glDisable(GL_BLEND);
glDisable(GL_LIGHTING);
glEnable(GL_BLEND);
glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
GlLines::glDrawLine(interQuartileRangeBoxCoords[0], interQuartileRangeBoxCoords[1], 2, GlLines::TLP_PLAIN, outlineColor, outlineColor);
GlLines::glDrawLine(interQuartileRangeBoxCoords[1], interQuartileRangeBoxCoords[2], 2, GlLines::TLP_PLAIN, outlineColor, outlineColor);
GlLines::glDrawLine(interQuartileRangeBoxCoords[2], interQuartileRangeBoxCoords[3], 2, GlLines::TLP_PLAIN, outlineColor, outlineColor);
GlLines::glDrawLine(interQuartileRangeBoxCoords[3], interQuartileRangeBoxCoords[0], 2, GlLines::TLP_PLAIN, outlineColor, outlineColor);
GlLines::glDrawLine(bottomOutlierCoord + Coord(-(boxWidth / 2.0f), 0.0f, 0.0f), bottomOutlierCoord + Coord(boxWidth / 2.0f, 0.0f, 0.0f), 2, GlLines::TLP_PLAIN, outlineColor, outlineColor);
GlLines::glDrawLine(medianCoord + Coord(-(boxWidth / 2.0f), 0.0f, 0.0f), medianCoord + Coord(boxWidth / 2.0f, 0.0f, 0.0f), 2, GlLines::TLP_PLAIN, outlineColor, outlineColor);
GlLines::glDrawLine(topOutlierCoord + Coord(-(boxWidth / 2.0f), 0.0f, 0.0f), topOutlierCoord + Coord(boxWidth / 2.0f, 0.0f, 0.0f), 2, GlLines::TLP_PLAIN, outlineColor, outlineColor);
GlLines::glDrawLine(bottomOutlierCoord, firstQuartileCoord, 2, GlLines::TLP_DASHED, outlineColor, outlineColor);
GlLines::glDrawLine(thirdQuartileCoord, topOutlierCoord, 2, GlLines::TLP_DASHED, outlineColor, outlineColor);
glDisable(GL_BLEND);
drawLabel(bottomOutlierCoord, axis->getBottomOutlierStringValue(),camera);
drawLabel(firstQuartileCoord, axis->getFirstQuartileStringValue(),camera);
drawLabel(medianCoord, axis->getMedianStringValue(),camera);
drawLabel(thirdQuartileCoord, axis->getThirdQuartileStringValue(),camera);
drawLabel(topOutlierCoord, axis->getTopOutlierStringValue(),camera);
if (highlightRangeLowBound != NULL && highlightRangeHighBound != NULL) {
Coord highlightBoxCoords[4] = { Coord(highlightRangeHighBound->getX() - boxWidth / 2.0f, highlightRangeHighBound->getY(), 0.0f),
Coord(highlightRangeHighBound->getX() + boxWidth / 2.0f, highlightRangeHighBound->getY(), 0.0f),
Coord(highlightRangeLowBound->getX() + boxWidth / 2.0f, highlightRangeLowBound->getY(), 0.0f),
Coord(highlightRangeLowBound->getX() - boxWidth / 2.0f, highlightRangeLowBound->getY(), 0.0f)
};
Color outlineColorTranslucent(outlineColor);
outlineColorTranslucent.setA(10);
GlQuad highlightBox(highlightBoxCoords[0], highlightBoxCoords[1], highlightBoxCoords[2], highlightBoxCoords[3], outlineColorTranslucent);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA,GL_SRC_COLOR);
glEnable(GL_LIGHTING);
highlightBox.draw(lod, camera);
glDisable(GL_BLEND);
glDisable(GL_LIGHTING);
highlightRangeLowBound = NULL;
highlightRangeHighBound = NULL;
}
if (rotationAngle != 0.0f) {
glPopMatrix();
}
}
static inline
Coord __compute_up(unit_t NX, unit_t NY)
{
return Coord(NX,__half_NY(NY)-1);
}
static inline
Coord __compute_lo(unit_t NY)
{
return Coord(0,-__half_NY(NY) );
}
inline Coord latlonInverse(const QPointF& point) const
{
return Coord(point.x()/*/EQUATORIALMETERPERDEGREE*/, point.y()/*/EQUATORIALMETERPERDEGREE*/);
}
virtual void SetUp() {
ModuleNodePointer module = Utility::getPointer(new RectangularModuleFactory("module1"));
module->addShape(Utility::getPointer(new RectangularShape("0", Coord(1, 1, 1))));
module->addShape(Utility::getPointer(new RectangularShape("1", Coord(1, 1, 2))));
graph->add(module);
}
Coord operator/(Coord coord1,float value){
return Coord(coord1.x()/value,coord1.y()/value,coord1.z()/value,coord1.ex()/value,coord1.ey()/value,coord1.ez()/value);
}
/**
* Additionne deux coordonnées.
*/
Coord Coord::operator+(const Coord& c) const
{
return Coord(this->x + c.x, this->y + c.y);
}
Coord operator/(float value,Coord coord2){
return Coord(value/coord2.x(),value/coord2.y(),value/coord2.z(),value/coord2.ex(),value/coord2.ey(),value/coord2.ez());
}
/**
* Multiplie une coordonnée par une valeur entière.
*/
Coord Coord::operator*(const int n) const
{
return Coord(this->x * n, this->y * n);
}
Coord Coord::operator+( const Coord& src ) const
{
return Coord( this->x + src.x, this->y + src.y, this->z + src.z, this->map );
}
/**
* Applique l'opérateur modulo entre les coordonnées correspondantes.
*/
Coord Coord::operator%(const Coord& c) const
{
return Coord(this->x % c.x, this->y % c.y);
}
Coord Coord::operator-( const Coord& src ) const
{
return Coord( this->x - src.x, this->y - src.y, this->z - src.z, this->map );
}
// かならず、listCharacterが先に呼ばれてロードされていることが前提。
// load失敗していたらNOTLOADエラー返す
void KServer::recv_login( const char *characterName )
{
if( !m_authenticationSuccess )return;
m_lastFunction = FUNCTION_LOGIN;
m_usingPCName = std::string( characterName );
db_proto::PlayerCharacter *dbpc = getDBPC();
if(!dbpc){
send_loginResult( FAIL,0);
std::cerr << "character not found:" << characterName << std::endl;
return;
}
Floor *f = World::getFloor( dbpc->floorID );
if(!f || Coord( dbpc->x, dbpc->y ).insideFloor() == false ){
send_loginResult( FAIL,0);
std::cerr << "invalid location:" << dbpc->floorID << "," << dbpc->x << "," << dbpc->y << std::endl;
return;
}
// このサーバの担当領域か？
Coord logoutCoord = Coord(dbpc->x,dbpc->y);
if( !Zone::inThisZone( dbpc->floorID, logoutCoord) ){
// 領域外でも、１タイル分だけ外れているなら、位置を修正してログインさせる。
// 厳密に１タイルではなくもうちょっとマージンが広くても良い。
Coord c0 = logoutCoord.translate(1,0);
Coord c1 = logoutCoord.translate(0,1);
Coord c2 = logoutCoord.translate(0,-1);
Coord c3 = logoutCoord.translate(-1,0);
bool b0 = Zone::inThisZone( dbpc->floorID, c0 );
bool b1 = Zone::inThisZone( dbpc->floorID, c1 );
bool b2 = Zone::inThisZone( dbpc->floorID, c2 );
bool b3 = Zone::inThisZone( dbpc->floorID, c3 );
if( b0 ){ dbpc->x = c0.x; dbpc->y = c0.y; }
if( b1 ){ dbpc->x = c1.x; dbpc->y = c1.y; }
if( b2 ){ dbpc->x = c2.x; dbpc->y = c2.y; }
if( b3 ){ dbpc->x = c3.x; dbpc->y = c3.y; }
bool resolved = b0 || b1 || b2 || b3;
if( !resolved ){
send_loginResult( FAIL, 0 );
std::cerr << "location is not in this zone." << std::endl;
return;
}
}
// キャラクターを生成して存在するようにする
m_pc = World::allocPlayerCharacter( World::getFloor(dbpc->floorID),
Coord( dbpc->x, dbpc->y ),
this );
assert(m_pc);
m_pc->stat = CharStat( dbpc->hp, dbpc->maxhp, dbpc->level, dbpc->exp );
// 最終的に結果送信
send_loginResult( SUCCESS, m_pc->id );
m_loginSuccess = true;
m_pc->notify( k_proto::FUNCTION_MOVENOTIFY );
// アイテム、スキル、クエストをロードする(遅延して後で読み込まれる)
g_dbcli->send_get_CharacterItem_by_characterID( uID, dbpc->id );
g_dbcli->send_get_CharacterSkill_by_characterID( uID, dbpc->id );
// DEBUG: 敵つくる
if( dbpc->exp == 0 ){
int cnt =0 ;
while(true){
if( World::allocEnemy( m_pc->floor,
m_pc->coord.translate( -5 + ( random() %11 ),
-5 + ( random() %11 ) ),
MOVABLE_GOBLIN ) ){
cnt++;
if(cnt==10)break;
}
}
}
return;
}
int StateLobby::OnSelectCharacter (IPacket &packet)
{
std::string name = packet.Read();
if (!packet.EndOfStream())
return MSG_ERROR_SIZE;
World *world = m_server->GetWorld();
player_iterator i = FindCharacterIndex(name);
if ( i != m_player_list.end() )
{
boost::shared_ptr<Player> player = *i;
if (!player)
return MSG_ERROR;
DB::MASTERY::Select mselect;
MasteryTree tree = mselect(m_server->DBConnection(),player->ID(),player->level(),player->race());
player->set_mastery_tree(tree);
DB::SKILL::Select sselect;
std::set<uint32_t> skill_list = sselect(m_server->DBConnection(),player->ID());
player->set_skill_list(skill_list);
boost::shared_ptr<Storage> ml = player->get_storage(STORAGE_MAIN);
DB::ITEM::Select iobj;
std::vector<Item::extended_type> item_list = iobj(m_server->DBConnection(),player->ID(),STORAGE_MAIN);
for (std::vector<Item::extended_type>::const_iterator i = item_list.begin(); i != item_list.end(); ++i)
{
try
{
ml->InsertItem(world->GetItemFactory()->Create(i->id,*i));
}
catch (Exception::InvalidItemID &error)
{
syslog(LOG_INFO,"Lobby::LoadCharacters() - Error while cloning item with ID = %i",i->id);
}
}
DB::JOB::Select jb_sl_query;
Job job = jb_sl_query(m_server->DBConnection(),player->ID());
player->set_job(job);
boost::shared_ptr<OPacket> pkt(new OPacket);
srv_pkt::RequestIngame(pkt);
m_connection->Send(pkt);
DB::PLAYER::State st_query;
st_query(m_server->DBConnection(),player->ID(),true);
pkt.reset(new OPacket);
srv_pkt::InitScreen(pkt);
m_connection->Send(pkt);
DB::HOTKEY::Select hotkey_query;
player->m_Hotkeys = hotkey_query(m_server->DBConnection(),player->ID());
DB::BLOCK::Select block_query;
player->m_BlockList = block_query(m_server->DBConnection(),player->ID());
DB::PLAYER::Autopot autopot_query;
player->m_Autopot = autopot_query(m_server->DBConnection(),player->ID());
if (player->IsDead())
{
player->resurrect(false,false,0,false);
Teleport tlp = m_server->GetWorld()->FindTeleport(player->get_return_point());
if (!tlp.ID)
{
syslog(LOG_INFO,"Invalid Return Point - %i",player->get_return_point());
return MSG_ERROR;
}
player->set_position(Coord(tlp.x,tlp.y,tlp.z,tlp.Zone));
}
pkt.reset(new OPacket);
srv_pkt::PlayerInfo(pkt,player,static_cast<srv::Connection*>(m_connection)->AccountID());
m_connection->Send(pkt);
pkt.reset(new OPacket);
srv_pkt::EndScreen(pkt);
m_connection->Send(pkt);
pkt.reset(new OPacket);
srv_pkt::PlayerID(pkt,player);
m_connection->Send(pkt);
/// ADD SKILL PASSIVES
boost::shared_ptr<Skill> skill;
for (std::set<uint32_t>::const_iterator it = skill_list.begin(); it != skill_list.end(); ++it)
{
skill = m_server->GetWorld()->GetSkillManager()->find(*it);
if (skill && skill->type() == SKT_PASSIVE)
{
Buff buff;
buff.passive = true;
buff.persistent = true;
buff.Level = skill->level();
buff.GroupID = skill->group_id();
buff.Effects = skill->buff_list();
buff.ReqShield = skill->require_shield();
buff.ReqDevil = skill->require_devil();
buff.ReqWeapon = skill->required_weapons();
if (player->is_buff_stackable(buff))
{
player->RemoveLesserBuffs(buff);
player->insert_buff(buff);
}
}
}
m_connection->SetState(srv::STATE_GAME);
static_cast<srv::Connection*>(m_connection)->SetPlayer(player);
}
else
return MSG_ERROR_ARG;
return MSG_SUCCESS;
}
void WelcomeScreen::removeButton(int x, int y)
{
Button* button = m_buttons.take(Coord(x, y));
delete button;
update();
}
std::vector<Coord> AStar( std::vector< std::vector< int > > grid, Point start, Point end )
{
//The current 'focal' point.
Point *cur;
//The open and closed lists.
std::vector< Point* > closed;
std::vector< Point* > open;
//Start by adding the starting position to the list.
open.push_back( &start );
//Just so it knows whether or not to try and reconstruct a path.
bool error = true;
while( open.size() > 0 )
{
//The current point is the first entry in the open list.
cur = open.at(0);
if( cur->getPos() == end.getPos() )
{
error = false;
break;
}
//Add in all the neighbors of the current point.
for( int y = -1; y <= 1; y++ )
{
for( int x = -1; x <= 1; x++ )
{
int curX = cur->getPos().x+x;
int curY = cur->getPos().y+y;
int movCost = 10;
//If it is a diagonal, make it cost 14 instead of 10.
if( (y == -1 && x == -1)||
(y == 1 && x == -1)||
(y == -1 && x == 1)||
(y == 1 && x == 1))
{
movCost = 14;
//continue;
}
Coord temp( curX, curY );
bool make = true;
//If it is outside the range of the map, continue.
if( curY >= grid.size() ||
curX >= grid.size() )
{
continue;
}
/*
These two loops are to check whether or not the point's neighbors already exist.
This feels really sloppy to me. Please tell me if there is a better way.
*/
for( int i = 0; i < open.size(); i++ )
{
if( temp == open.at(i)->getPos() )
{
make = false;
break;
}
}
for( int i = 0; i < closed.size(); i++ )
{
if( temp == closed.at(i)->getPos() )
{
make = false;
break;
}
}
//If the point in the map is a zero, then it is a wall. Continue.
if( (grid.at(temp.x).at(temp.y) == 0 ) ||
( temp.x<0 || temp.y < 0 ) )
{
continue;
}
//If it is allowed to make a new point, it adds it to the open list.
if( make )
{
int gScore = cur->getCost();
int hScore = manhattan( end.getPos(), Coord( curX, curY ) );
int tileCost = grid[curX][curY];
int fScore = gScore+hScore+tileCost+movCost;
open.push_back( new Point( curX, curY, fScore, cur ) );
}
}
}
//It then pushes back the current into the closed set as well as erasing it from the open set.
closed.push_back( cur );
open.erase( open.begin() );
//Heapsort works, guranteed. Not sure if it's a stable sort, though. From what I can tell that shouldn't matter, though.
open = heapsort( open );
}
std::vector<Coord> path;
if( error )
{
return path;
}
//Reconstruct a path by tracing through the parents.
while( cur->getParent() != nullptr )
{
path.push_back( cur->getPos() );
cur = cur->getParent();
}
path.push_back( cur->getPos() );
return path;
}
void Action_Wander::execute()
{
m_npc->fight( 0 );
// If the next wandertype hasn't come yet.
if ( m_npc->nextMoveTime() > Server::instance()->time() )
{
return;
}
m_npc->setNextMoveTime();
if ( m_npc->wanderType() == enHalt )
{
return;
}
switch ( m_npc->wanderType() )
{
case enWanderSpawnregion:
{
// Only try to walk if we're not already out of the spawnregion
// Otherwise fall trough to enFreely
cSpawnRegion* region = m_npc->spawnregion();
if ( region && region->isValidSpot( m_npc->pos() ) )
{
// Calculate the field we're facing.
unsigned char dir = m_npc->direction();
// There is a 5% chance of changing the direction
if ( !RandomNum( 0, 19 ) )
{
dir = RandomNum( 0, 7 );
}
Coord newpos = Movement::instance()->calcCoordFromDir( dir, m_npc->pos() );
// Calculate a new direction.
if ( !region->isValidSpot( newpos ) )
{
unsigned char newdir = RandomNum( 0, 7 );
// Make sure we're not trying to walk in the same
// direction or the directions directly beneath if we met the border of a
// spawnregion. But we don't want to turn around exactly either. (Looks
// to mechanically)
while ( newdir == dir || newdir == ( ( dir == 0 ) ? 7 : dir - 1 ) || newdir == ( ( dir == 7 ) ? 0 : dir + 1 ) )
{
newdir += RandomNum( 0, 1 ) ? -1 : 1;
}
dir = newdir;
newpos = Movement::instance()->calcCoordFromDir( dir, m_npc->pos() ); // Recalculate the new one
// See if it's still invalid
if ( !region->isValidSpot( newpos ) )
{
return;
}
}
// Change our current heading first.
if ( m_npc->direction() != dir )
{
Movement::instance()->Walking( m_npc, dir, 0xFF );
}
// Walk in the same direction or if the direction has changed simply turn around.
// If there's a obstacle, change the direction slightly to see if we can get
// around it.
if ( !Movement::instance()->Walking( m_npc, dir, 0xFF ) )
{
signed char newdir = dir;
newdir += RandomNum( 0, 1 ) ? -1 : 1;
if ( newdir < 0 )
{
newdir = 7;
}
else if ( newdir > 7 )
{
newdir = 0;
}
Movement::instance()->Walking( m_npc, newdir, 0xFF );
}
break;
}
}
case enFreely:
{
Q_UINT8 dir = m_npc->direction();
if ( RandomNum( 0, 100 ) < 20 )
dir = RandomNum( 0, 7 );
Movement::instance()->Walking( m_npc, dir, 0xFF );
break;
}
case enRectangle:
{
// get any point out of the rectangle and calculate the direction to it
Q_UINT16 rndx = RandomNum( m_npc->wanderX1(), m_npc->wanderX2() );
Q_UINT16 rndy = RandomNum( m_npc->wanderY1(), m_npc->wanderY2() );
Q_UINT8 dir = m_npc->pos().direction( Coord( rndx, rndy ) );
Movement::instance()->Walking( m_npc, dir, 0xFF );
break;
}
case enCircle:
{
Coord pos = m_npc->pos();
pos.x = m_npc->wanderX1();
pos.y = m_npc->wanderY1();
// get any point within the circle and calculate the direction to it
// first a random distance which can be max. the length of the radius
float rnddist = ( float ) RandomNum( 1, m_npc->wanderRadius() );
// now get a point on this circle around the m_npc
float rndphi = ( float ) RandomNum( 0, 100 ) / 100.0f * 2.0f * 3.14159265358979323846f;
pos.x = pos.x + ( Q_INT16 ) floor( cos( rndphi ) * rnddist );
pos.y = pos.y + ( Q_INT16 ) floor( sin( rndphi ) * rnddist );
Q_UINT8 dir = m_npc->pos().direction( pos );
if ( m_npc->direction() != dir )
{
Movement::instance()->Walking( m_npc, dir, 0xFF );
}
Movement::instance()->Walking( m_npc, dir, 0xFF );
break;
}
case enFollowTarget:
{
if ( Config::instance()->pathfind4Follow() )
{
P_CHAR pTarget = m_npc->wanderFollowTarget();
if ( pTarget )
{
if ( m_npc->dist( pTarget ) < 4 )
{
movePath( pTarget->pos() );
}
else
{
moveTo( pTarget->pos() );
}
}
}
else
{
P_CHAR pTarget = m_npc->wanderFollowTarget();
if ( pTarget )
{
moveTo( pTarget->pos() );
}
}
break;
}
case enDestination:
{
if ( m_npc->pos().distance( m_npc->wanderDestination() ) < 6 )
{
movePath( m_npc->wanderDestination() );
}
else
{
moveTo( m_npc->wanderDestination() );
}
break;
}
default:
break;
}
return;
}
// |----------------------------------------------------------------------------|
// | Initialize |
// |----------------------------------------------------------------------------|
bool Player::Initialize() {
GameObject::Initialize();
// Set up ship
Graphic* graphic = new Graphic;
graphic->SetTint(1.0f,1.0f,1.0f,1.0f);
graphic->SetShader("Texture");
graphic->SetShader("Light");
graphic->SetTexture("shiptexture");
graphic->SetModel("ship");
graphic->SetScale(Coord(0.01f,0.01f,0.01f));
graphic->SetReflectiveness(0.95f);
graphic->Initialize();
m_ship = new GameObject;
m_ship->Initialize();
m_ship->SetGraphic(graphic);
m_ship->SetPosition(Coord(0.0f,0.0f,0.0f));
m_ship->SetOrientation(Coord(0.0f,0.0f,0.0f));
// Set up left thruster
m_leftThruster = new ParticleSystem;
m_leftThruster->Initialize();
graphic = new Billboard;
graphic->SetShader("Texture");
graphic->SetTexture("fireball");
graphic->SetAlphaBlend(true);
graphic->SetScale(Coord(0.003f,0.003f,0.003f));
graphic->Initialize();
m_leftThruster->SetGraphic(graphic);
m_leftThruster->SetPosition(Coord(-0.6f,0.0f,-0.7f));
m_leftThruster->SetParticleVelocity(Coord(0.0f,0.0f,-2.0f));
m_leftThruster->SetParticleVelocityVariation(Coord(0.5f,0.5f,0.5f));
m_leftThruster->SetParticleSpawnFrequency(0.01f);
m_leftThruster->SetParticleDeviation(Coord(0.0f,0.0f,0.0f));
m_leftThruster->SetParticleLifetime(0.5f);
m_leftThruster->SetParticleFadeout(0.2f);
m_leftThruster->SetMaxParticles(100);
m_leftThruster->SetTint(0.8f,0.9f,1.0f);
m_leftThruster->SetTintVar(0.2f,0.2f,0.2f);
// Set up right thruster
m_rightThruster = new ParticleSystem;
m_rightThruster->Initialize();
graphic = new Billboard;
graphic->SetShader("Texture");
graphic->SetTexture("fireball");
graphic->SetAlphaBlend(true);
graphic->SetScale(Coord(0.003f,0.003f,0.003f));
graphic->Initialize();
m_rightThruster->SetGraphic(graphic);
m_rightThruster->SetPosition(Coord(0.6f,0.0f,-0.7f));
m_rightThruster->SetParticleVelocity(Coord(0.0f,0.0f,-2.0f));
m_rightThruster->SetParticleVelocityVariation(Coord(0.5f,0.5f,0.5f));
m_rightThruster->SetParticleSpawnFrequency(0.001f);
m_rightThruster->SetParticleDeviation(Coord(0.0f,0.0f,0.0f));
m_rightThruster->SetParticleLifetime(0.5f);
m_rightThruster->SetParticleFadeout(0.2f);
m_rightThruster->SetMaxParticles(100);
m_rightThruster->SetTint(0.8f,0.9f,1.0f);
m_rightThruster->SetTintVar(0.2f,0.2f,0.2f);
DebugLog ("Player: object initialized.");
return true;
}
Coord MacPrinterCanvas::width() const {
return Coord(hres_)/float(lpx_)*72.;
}
Coord shift( const Move & move ) const {
return Coord( this->x + move.dx, this->y + move.dy );
}
