//--------------------------- Render -------------------------------------
//
//------------------------------------------------------------------------
void Raven_Bot::Render()
{
//when a bot is hit by a projectile this value is set to a constant user
//defined value which dictates how long the bot should have a thick red
//circle drawn around it (to indicate it's been hit) The circle is drawn
//as long as this value is positive. (see Render)
m_iNumUpdatesHitPersistant--;
if (isDead() || isSpawning()) return;
gdi->BluePen();
m_vecBotVBTrans = WorldTransform(m_vecBotVB,
Pos(),
Facing(),
Facing().Perp(),
Scale());
gdi->ClosedShape(m_vecBotVBTrans);
//draw the head
(gdi->*(m_pTeam->GetPen()))();
gdi->Circle(Pos(), 6.0 * Scale().x);
//render the bot's weapon
m_pWeaponSys->RenderCurrentWeapon();
//render a thick red circle if the bot gets hit by a weapon
if (m_bHit)
{
gdi->ThickRedPen();
gdi->HollowBrush();
gdi->Circle(m_vPosition, BRadius()+1);
if (m_iNumUpdatesHitPersistant <= 0)
{
m_bHit = false;
}
}
gdi->TransparentText();
gdi->TextColor(0,255,0);
if (UserOptions->m_bShowBotIDs)
{
gdi->TextAtPos(Pos().x -10, Pos().y-20, ttos(ID()));
}
if (UserOptions->m_bShowBotHealth)
{
gdi->TextAtPos(Pos().x-40, Pos().y-5, "H:"+ ttos(Health()));
}
if (UserOptions->m_bShowScore)
{
gdi->TextAtPos(Pos().x-40, Pos().y+10, "Scr:"+ ttos(Score()));
}
}
bool Raven_Bot::canStepBackward(Vector2D& PositionOfStep)const
{
static const double StepDistance = BRadius() * 2;
PositionOfStep = Pos() - Facing() * StepDistance - Facing() * BRadius();
return canWalkTo(PositionOfStep);
}
bool Raven_Bot::canStepRight(Vector2D& PositionOfStep)const
{
static const double StepDistance = BRadius() * 2;
PositionOfStep = Pos() + Facing().Perp() * StepDistance + Facing().Perp() * BRadius();
return canWalkTo(PositionOfStep);
}
void ParticleHandler::spawnPoof(const std::shared_ptr<Object> &object)
{
Facing facing_z = object->ori.facing_z;
for (int cnt = 0; cnt < object->getProfile()->getParticlePoofAmount(); cnt++)
{
ParticleHandler::get().spawnParticle(object->getOldPosition(), facing_z, object->getProfile()->getSlotNumber(), object->getProfile()->getParticlePoofProfile(),
ObjectRef::Invalid, GRIP_LAST, object->team, object->ai.owner, ParticleRef::Invalid, cnt);
facing_z += Facing(object->getProfile()->getParticlePoofFacingAdd());
}
}
void NLight::GenerateShadowBuffers()
{
//oh boy why didn't i comment this while i coded it; it's pretty damn complicated. I'll try my best to reinterpret and explain what i was thinking.
if (!Texture)
{
return;
}
//Compares it's current position and scale from memory, if it hasn't changed from last generation then don't regenerate it!
if (PositionMemory == GetRealPos() && ScaleMemory == GetScale())
{
return;
}
glm::vec3 Pos = GetRealPos();
Shadows.clear();
//Figures out what size of a box of map tiles we should loop through. FIXME: Make it more accurately decide which map tiles to loop through.
float Max = std::max(GetScale().x, GetScale().y);
//For every map tile in a massive area around the light...
for (float x = -Max;x<Max;x+=GetGame()->GetMap()->GetTileSize())
{
for (float y = -Max;y<Max;y+=GetGame()->GetMap()->GetTileSize())
{
//Get the tile object at the current loop position
NTile* Tile = GetGame()->GetMap()->GetTile(Pos+glm::vec3(x,y,0));
//If the tile doesn't block light or doesn't exist, skip it!
if (Tile == NULL || !Tile->IsOpaque())
{
continue;
}
float TS = GetGame()->GetMap()->GetTileSize()/2.f;
//Generate points in the four corners of the tile.
glm::vec3 TPos = GetGame()->GetMap()->TilePos(Pos+glm::vec3(x,y,0));
glm::vec3 Points[4];
Points[0] = TPos+glm::vec3(TS,TS,0);
Points[1] = TPos+glm::vec3(TS,-TS,0);
Points[2] = TPos+glm::vec3(-TS,-TS,0);
Points[3] = TPos+glm::vec3(-TS,TS,0);
std::vector<glm::vec4> Faces;
//Generate faces (two points = face, each tile has 4 faces)
NTile* CheckTile = GetGame()->GetMap()->GetTile(Tile->X,Tile->Y-1,Tile->Z);
if ((CheckTile && !CheckTile->IsOpaque()) || !CheckTile)
{
Faces.push_back(glm::vec4(Points[1].x,Points[1].y,Points[2].x,Points[2].y));
}
CheckTile = GetGame()->GetMap()->GetTile(Tile->X,Tile->Y+1,Tile->Z);
if ((CheckTile && !CheckTile->IsOpaque()) || !CheckTile)
{
Faces.push_back(glm::vec4(Points[3].x,Points[3].y,Points[0].x,Points[0].y));
}
CheckTile = GetGame()->GetMap()->GetTile(Tile->X-1,Tile->Y,Tile->Z);
if ((CheckTile && !CheckTile->IsOpaque()) || !CheckTile)
{
Faces.push_back(glm::vec4(Points[2].x,Points[2].y,Points[3].x,Points[3].y));
}
CheckTile = GetGame()->GetMap()->GetTile(Tile->X+1,Tile->Y,Tile->Z);
if ((CheckTile && !CheckTile->IsOpaque()) || !CheckTile)
{
Faces.push_back(glm::vec4(Points[0].x,Points[0].y,Points[1].x,Points[1].y));
}
for (unsigned int i=0;i<Faces.size();i++)
{
//Remove front faces
if (!Facing(glm::vec2(Pos.x,Pos.y),Faces[i]))
{
continue;
}
//Generate shadow mesh by extruding back faces.
float Radians = -atan2(Pos.x-Faces[i].x,Pos.y-Faces[i].y)-PI/2.f;
float BRadians = -atan2(Pos.x-Faces[i].z,Pos.y-Faces[i].w)-PI/2.f;
Shadows.push_back(glm::vec3(Faces[i].x,Faces[i].y,TPos.z));
Shadows.push_back(glm::vec3(Faces[i].z,Faces[i].w,TPos.z));
Shadows.push_back(glm::vec3(Faces[i].z+cos(BRadians)*GetScale().x,Faces[i].w+sin(BRadians)*GetScale().y,TPos.z));
Shadows.push_back(glm::vec3(Faces[i].x+cos(Radians)*GetScale().x,Faces[i].y+sin(Radians)*GetScale().y,TPos.z));
}
}
}
//3d lighting time, honestly the 2d doesn't work when there's any openings between floors.
/*for (float x = -Max;x<Max;x+=GetGame()->GetMap()->GetTileSize())
{
for (float y = -Max;y<Max;y+=GetGame()->GetMap()->GetTileSize())
{
for (float z = -Max;z<Max;z+=GetGame()->GetMap()->GetTileSize())
{
//Get the tile object at the current loop position
NTile* Tile = GetGame()->GetMap()->GetTile(Pos+glm::vec3(x,y,z));
//If the tile doesn't block light or doesn't exist, skip it!
if (Tile == NULL || !Tile->IsOpaque())
{
continue;
}
float TS = GetGame()->GetMap()->GetTileSize()/2.f;
//Generate points in the eight verts of the tile.
glm::vec3 TPos = GetGame()->GetMap()->TilePos(Pos+glm::vec3(x,y,z));
glm::vec3 Points[8];
Points[0] = TPos+glm::vec3(TS,TS,0);
Points[1] = TPos+glm::vec3(TS,-TS,0);
Points[2] = TPos+glm::vec3(-TS,-TS,0);
Points[3] = TPos+glm::vec3(-TS,TS,0);
Points[4] = TPos+glm::vec3(TS,TS,TS*2.f);
Points[5] = TPos+glm::vec3(TS,-TS,TS*2.f);
Points[6] = TPos+glm::vec3(-TS,-TS,TS*2.f);
Points[7] = TPos+glm::vec3(-TS,TS,TS*2.f);
std::vector< std::vector<glm::vec3> > Faces;
//Generate faces (four points = face, each tile has 6 faces)
NTile* CheckTile = GetGame()->GetMap()->GetTile(Tile->X,Tile->Y-1,Tile->Z);
if ((CheckTile && !CheckTile->IsOpaque()) || !CheckTile)
{
//Faces.push_back(glm::vec4(Points[1].x,Points[1].y,Points[2].x,Points[2].y));
std::vector<glm::vec3> Face;
Face.push_back(Points[1]);
Face.push_back(Points[2]);
Face.push_back(Points[6]);
Face.push_back(Points[5]);
Faces.push_back(Face);
}
CheckTile = GetGame()->GetMap()->GetTile(Tile->X,Tile->Y+1,Tile->Z);
if ((CheckTile && !CheckTile->IsOpaque()) || !CheckTile)
{
//Faces.push_back(glm::vec4(Points[3].x,Points[3].y,Points[0].x,Points[0].y));
std::vector<glm::vec3> Face;
Face.push_back(Points[3]);
Face.push_back(Points[0]);
Face.push_back(Points[4]);
Face.push_back(Points[7]);
Faces.push_back(Face);
}
CheckTile = GetGame()->GetMap()->GetTile(Tile->X-1,Tile->Y,Tile->Z);
if ((CheckTile && !CheckTile->IsOpaque()) || !CheckTile)
{
//Faces.push_back(glm::vec4(Points[2].x,Points[2].y,Points[3].x,Points[3].y));
std::vector<glm::vec3> Face;
Face.push_back(Points[2]);
Face.push_back(Points[3]);
Face.push_back(Points[7]);
Face.push_back(Points[6]);
Faces.push_back(Face);
}
CheckTile = GetGame()->GetMap()->GetTile(Tile->X+1,Tile->Y,Tile->Z);
if ((CheckTile && !CheckTile->IsOpaque()) || !CheckTile)
{
//Faces.push_back(glm::vec4(Points[0].x,Points[0].y,Points[1].x,Points[1].y));
std::vector<glm::vec3> Face;
Face.push_back(Points[0]);
Face.push_back(Points[1]);
Face.push_back(Points[5]);
Face.push_back(Points[4]);
Faces.push_back(Face);
}
CheckTile = GetGame()->GetMap()->GetTile(Tile->X,Tile->Y,Tile->Z-1);
if ((CheckTile && !CheckTile->IsOpaque()) || !CheckTile)
{
std::vector<glm::vec3> Face;
Face.push_back(Points[0]);
Face.push_back(Points[1]);
Face.push_back(Points[3]);
Face.push_back(Points[2]);
Faces.push_back(Face);
}
CheckTile = GetGame()->GetMap()->GetTile(Tile->X,Tile->Y,Tile->Z+1);
if ((CheckTile && !CheckTile->IsOpaque()) || !CheckTile)
{
std::vector<glm::vec3> Face;
Face.push_back(Points[4]);
Face.push_back(Points[5]);
Face.push_back(Points[7]);
Face.push_back(Points[6]);
Faces.push_back(Face);
}
for (unsigned int i=0;i<Faces.size();i++)
{
//Remove front faces
if (Facing(glm::vec3(Pos.x,Pos.y,Pos.z),Faces[i]))
{
continue;
}
//Generate shadow mesh by extruding back faces.
//float Radians = -atan2(Pos.x-Faces[i].x,Pos.y-Faces[i].y)-PI/2.f;
//float BRadians = -atan2(Pos.x-Faces[i].z,Pos.y-Faces[i].w)-PI/2.f;
glm::vec3 ExtrudeA = glm::normalize(Faces[i][0]-Pos);
glm::vec3 ExtrudeB = glm::normalize(Faces[i][1]-Pos);
Shadows.push_back(Faces[i][0]);
Shadows.push_back(Faces[i][1]);
Shadows.push_back(Faces[i][0]+ExtrudeA*GetScale()); //these go very far away so shadows are long
Shadows.push_back(Faces[i][1]+ExtrudeB*GetScale());
glm::vec3 ExtrudeA = glm::normalize(Faces[i][1]-Pos);
glm::vec3 ExtrudeB = glm::normalize(Faces[i][2]-Pos);
Shadows.push_back(Faces[i][1]);
Shadows.push_back(Faces[i][2]);
Shadows.push_back(Faces[i][1]+ExtrudeA*GetScale());
Shadows.push_back(Faces[i][2]+ExtrudeB*GetScale());
ExtrudeA = glm::normalize(Faces[i][2]-Pos);
ExtrudeB = glm::normalize(Faces[i][3]-Pos);
Shadows.push_back(Faces[i][2]);
Shadows.push_back(Faces[i][3]);
Shadows.push_back(Faces[i][2]+ExtrudeA*GetScale());
Shadows.push_back(Faces[i][3]+ExtrudeB*GetScale());
ExtrudeA = glm::normalize(Faces[i][3]-Pos);
ExtrudeB = glm::normalize(Faces[i][0]-Pos);
Shadows.push_back(Faces[i][3]);
Shadows.push_back(Faces[i][0]);
Shadows.push_back(Faces[i][3]+ExtrudeA*GetScale());
Shadows.push_back(Faces[i][0]+ExtrudeB*GetScale());
}
}
}
}*/
glBindBuffer(GL_ARRAY_BUFFER,Buffers[2]);
glBufferData(GL_ARRAY_BUFFER,Shadows.size()*sizeof(glm::vec3),&Shadows[0],GL_STATIC_DRAW);
PositionMemory = GetRealPos();
ScaleMemory = GetScale();
}
bool spawn_file_read(ReadContext& ctxt, spawn_file_info_t& info)
{
info = spawn_file_info_t();
// Until we hit something else than newlines, whitespaces or comments.
while (true)
{
ctxt.skipWhiteSpaces();
ctxt.skipNewLines();
if (ctxt.is('/'))
{
ctxt.readSingleLineComment(); /// @todo Add and use ReadContext::skipSingleLineComment().
continue;
}
if (!ctxt.isWhiteSpace() && !ctxt.isNewLine() && !ctxt.is('/'))
{
break;
}
}
if (ctxt.isAlpha()||ctxt.is('%')||ctxt.is('_'))
{
ctxt._buffer.clear();
// Read everything into the buffer until a ':', a new line, an error or the end of the input is reached.
do
{
ctxt.saveAndNext();
} while (!ctxt.is(':') && !ctxt.isNewLine() && !ctxt.is(ReadContext::Traits::endOfInput()) &&
!ctxt.is(ReadContext::Traits::error()));
if (ctxt.is(ReadContext::Traits::error()))
{
throw Id::LexicalErrorException(__FILE__, __LINE__, Ego::Script::Location(ctxt.getFileName(), ctxt.getLineNumber()),
"read error");
}
if (ctxt.is(ReadContext::Traits::endOfInput()))
{
return false;
}
if (!ctxt.is(':'))
{
throw Id::LexicalErrorException(__FILE__, __LINE__, Ego::Script::Location(ctxt.getFileName(), ctxt.getLineNumber()),
"expected `:`");
}
ctxt.next();
info.spawn_comment = Ego::trim_ws(ctxt._buffer.toString());
info.do_spawn = true;
vfs_read_string_lit(ctxt, info.spawn_name);
info.pname = &(info.spawn_name);
if (info.spawn_name == "NONE")
{
// A random name is selected.
info.pname = nullptr;
}
info.slot = ctxt.readIntegerLiteral();
info.pos[kX] = ctxt.readRealLiteral() * Info<float>::Grid::Size();
info.pos[kY] = ctxt.readRealLiteral() * Info<float>::Grid::Size();
info.pos[kZ] = ctxt.readRealLiteral() * Info<float>::Grid::Size();
info.facing = Facing::FACE_NORTH;
info.attach = ATTACH_NONE;
char chr = ctxt.readPrintable();
switch (Ego::toupper(chr))
{
case 'S': info.facing = Facing::FACE_SOUTH; break;
case 'E': info.facing = Facing::FACE_EAST; break;
case 'W': info.facing = Facing::FACE_WEST; break;
case 'N': info.facing = Facing::FACE_NORTH; break;
case '?': info.facing = Facing(FACE_RANDOM); break;
case 'L': info.attach = ATTACH_LEFT; break;
case 'R': info.attach = ATTACH_RIGHT; break;
case 'I': info.attach = ATTACH_INVENTORY; break;
default:
{
throw Id::SyntacticalErrorException(__FILE__, __LINE__, Id::Location(ctxt.getFileName(), ctxt.getLineNumber()),
"invalid enumeration element");
}
};
info.money = ctxt.readIntegerLiteral();
//If the skin type is a '?' character then it means random skin else it's an integer
ctxt.skipWhiteSpaces();
if(ctxt.is('?')) {
info.skin = ObjectProfile::NO_SKIN_OVERRIDE;
ctxt.next();
}
else {
info.skin = ctxt.readIntegerLiteral();
}
info.passage = ctxt.readIntegerLiteral();
info.content = ctxt.readIntegerLiteral();
info.level = ctxt.readIntegerLiteral();
info.stat = ctxt.readBool();
ctxt.readPrintable(); ///< BAD! Unused ghost value
chr = ctxt.readPrintable();
info.team = (chr - 'A') % Team::TEAM_MAX;
return true;
}
else if (ctxt.is('#'))
{
ctxt.next();
info.do_spawn = false;
std::string what = ctxt.readName();
if (what != "dependency")
{
throw Id::SyntacticalErrorException(__FILE__, __LINE__, Id::Location(ctxt.getFileName(),ctxt.getLineNumber()),
"syntax error");
}
std::string who;
ctxt.skipWhiteSpaces();
if (ctxt.is('%'))
{
who = ctxt.readReference();
}
else
{
who = ctxt.readName();
}
if (who.empty()) /// @todo Verify that this is unnecessary based on the definition of readName.
{
throw Id::SyntacticalErrorException(__FILE__, __LINE__, Id::Location(ctxt.getFileName(), ctxt.getLineNumber()),
"syntax error");
}
int slot = ctxt.readIntegerLiteral();
// Store the data.
info.spawn_comment = who;
info.slot = slot;
return true;
}
else if (!ctxt.is(ReadContext::Traits::endOfInput()))
{
throw Id::LexicalErrorException(__FILE__, __LINE__, Id::Location(ctxt.getFileName(), ctxt.getLineNumber()),
"junk after end of spawn file");
}
return false;
}
