unsigned int CCategoryHandler::GetCategory(std::string name)
{
StringTrimInPlace(name);
StringToLowerInPlace(name);
if (name.empty())
return 0; // the empty category
unsigned int cat = 0;
GML_STDMUTEX_LOCK(cat); // GetCategory
if (categories.find(name) == categories.end()) {
// this category is yet unknown
if (firstUnused >= CCategoryHandler::GetMaxCategories()) {
// skip this category
LOG_L(L_WARNING, "too many unit categories (%i), skipping %s",
firstUnused, name.c_str());
cat = 0;
} else {
// create the category (bit field value)
cat = (1 << firstUnused);
//LOG_L(L_DEBUG, "New unit-category %s #%i", name.c_str(), firstUnused);
}
// if (cat == 0), this will prevent further warnings for this category
categories[name] = cat;
firstUnused++;
} else {
// this category is already known
cat = categories[name];
}
return cat;
}
void CAICallback::DrawUnit(const char* unitName, const float3& pos,
float rotation, int lifetime, int teamId, bool transparent,
bool drawBorder, int facing)
{
CUnitDrawer::TempDrawUnit tdu;
tdu.unitdef = unitDefHandler->GetUnitDefByName(unitName);
if (!tdu.unitdef) {
LOG_L(L_WARNING, "Unknown unit in CAICallback::DrawUnit %s", unitName);
return;
}
tdu.pos = pos;
tdu.rotation = rotation;
tdu.team = teamId;
tdu.drawBorder = drawBorder;
tdu.facing = facing;
std::pair<int, CUnitDrawer::TempDrawUnit> tp(gs->frameNum + lifetime, tdu);
GML_STDMUTEX_LOCK(temp); // DrawUnit
if (transparent) {
unitDrawer->tempTransparentDrawUnits.insert(tp);
} else {
unitDrawer->tempDrawUnits.insert(tp);
}
}
bool CInMapDrawModel::AddPoint(const float3& constPos, const std::string& label, int playerID)
{
if (!playerHandler->IsValidPlayer(playerID)) {
return false;
}
GML_STDMUTEX_LOCK(inmap); // LocalPoint
// GotNetMsg() alreadys checks validity of playerID
const CPlayer* sender = playerHandler->Player(playerID);
const bool allowed = AllowedMsg(sender);
float3 pos = constPos;
pos.ClampInBounds();
pos.y = ground->GetHeightAboveWater(pos.x, pos.z, false) + 2.0f;
// event clients may process the point
// if their owner is allowed to see it
if (allowed && eventHandler.MapDrawCmd(playerID, MAPDRAW_POINT, &pos, NULL, &label)) {
return false;
}
// let the engine handle it (disallowed
// points added here are filtered while
// rendering the quads)
MapPoint point(sender->spectator, sender->team, sender, pos, label);
const int quad = int(pos.z * QUAD_SCALE) * drawQuadsX +
int(pos.x * QUAD_SCALE);
drawQuads[quad].points.push_back(point);
numPoints++;
return true;
}
bool CInMapDrawModel::AddLine(const float3& constPos1, const float3& constPos2, int playerID)
{
if (!playerHandler->IsValidPlayer(playerID)) {
return false;
}
GML_STDMUTEX_LOCK(inmap); // LocalLine
const CPlayer* sender = playerHandler->Player(playerID);
float3 pos1 = constPos1;
float3 pos2 = constPos2;
pos1.ClampInBounds();
pos2.ClampInBounds();
pos1.y = ground->GetHeightAboveWater(pos1.x, pos1.z, false) + 2.0f;
pos2.y = ground->GetHeightAboveWater(pos2.x, pos2.z, false) + 2.0f;
if (AllowedMsg(sender) && eventHandler.MapDrawCmd(playerID, MAPDRAW_LINE, &pos1, &pos2, NULL)) {
return false;
}
MapLine line(sender->spectator, sender->team, sender, pos1, pos2);
const int quad = int(pos1.z * QUAD_SCALE) * drawQuadsX +
int(pos1.x * QUAD_SCALE);
drawQuads[quad].lines.push_back(line);
numLines++;
return true;
}
void CConsoleHistory::ResetPosition()
{
GML_STDMUTEX_LOCK(hist); // ResetPosition
pos = lines.end();
return;
}
std::string CConsoleHistory::PrevLine(const std::string& current)
{
GML_STDMUTEX_LOCK(hist); // PrevLine
std::string prefix, message;
if ((current.find_first_of("aAsS") == 0) && (current[1] == ':')) {
prefix = current.substr(0, 2);
message = current.substr(2);
} else {
message = current;
}
if (pos == lines.begin()) {
if (*pos != message) {
AddLineRaw(message);
pos = lines.begin();
}
return prefix;
}
if ((pos == lines.end()) || (*pos != message)) {
AddLineRaw(message);
if (pos == lines.begin()) {
return prefix; // AddLineRaw() will adjust begin() iterators when it rolls
}
}
--pos;
return prefix + *pos;
}
void CLogOutput::Output(const std::string& str)
{
GML_STDMUTEX_LOCK(log); // Output
std::string msg;
#if !defined UNITSYNC && !defined DEDICATED
if (gs) {
msg += IntToString(gs->frameNum, "[f=%07d] ");
}
#endif
msg += str;
if (!initialized) {
ToStderr(msg);
preInitLog().push_back(msg);
return;
}
#ifdef _MSC_VER
int index = strlen(str.c_str()) - 1;
bool newline = ((index < 0) || (str[index] != '\n'));
OutputDebugString(msg.c_str());
if (newline) {
OutputDebugString("\n");
}
#endif // _MSC_VER
ToFile(msg);
ToStderr(msg);
}
void CInMapDraw::LocalLine(const float3& constPos1, const float3& constPos2,
int playerID)
{
if (!playerHandler->IsValidPlayer(playerID))
return;
GML_STDMUTEX_LOCK(inmap); // LocalLine
const CPlayer* sender = playerHandler->Player(playerID);
float3 pos1 = constPos1;
float3 pos2 = constPos2;
pos1.CheckInBounds();
pos2.CheckInBounds();
pos1.y = ground->GetHeight(pos1.x, pos1.z) + 2.0f;
pos2.y = ground->GetHeight(pos2.x, pos2.z) + 2.0f;
if (AllowedMsg(sender) && eventHandler.MapDrawCmd(playerID, MAPDRAW_LINE, &pos1, &pos2, NULL)) {
return;
}
MapLine line;
line.pos = pos1;
line.pos2 = pos2;
line.color = sender->spectator ? color4::white : teamHandler->Team(sender->team)->color;
line.senderAllyTeam = teamHandler->AllyTeam(sender->team);
line.senderSpectator = sender->spectator;
const int quad = int(pos1.z * quadScale) * drawQuadsX +
int(pos1.x * quadScale);
drawQuads[quad].lines.push_back(line);
}
void EventBatchHandler::UpdateDrawUnits() {
GML_STDMUTEX_LOCK(runit); // UpdateDrawUnits
unitCreatedDestroyedEventBatch.execute();
unitCloakStateChangedEventBatch.execute();
unitLOSStateChangedEventBatch.execute();
}
void CUnitHandler::RemoveBuilderCAI(CBuilderCAI* b)
{
GML_STDMUTEX_LOCK(cai); // RemoveBuilderCAI
// called from ~CUnit --> owner is still valid
assert(b->owner != NULL);
builderCAIs.erase(b->owner->id);
}
/**
* @brief Process the queue of pending fartexture creation requests.
* This loops through the queue calling ReallyCreateFarTexture() on each entry,
* and empties the queue afterwards.
*/
void CFartextureHandler::CreateFarTextures()
{
GML_STDMUTEX_LOCK(tex); // CreateFarTextures
for(std::vector<S3DModel*>::const_iterator it = pending.begin(); it != pending.end(); ++it) {
ReallyCreateFarTexture(*it);
}
pending.clear();
}
void EventBatchHandler::UpdateObjects() {
{
GML_STDMUTEX_LOCK(runit); // UpdateObjects
UpdateUnits();
}
{
GML_STDMUTEX_LOCK(rfeat); // UpdateObjects
UpdateFeatures();
}
{
GML_STDMUTEX_LOCK(rproj); // UpdateObjects
UpdateProjectiles();
}
}
void CBasicTreeDrawer::Draw(float treeDistance,bool drawReflection)
{
glBindTexture(GL_TEXTURE_2D, treetex);
glEnable(GL_ALPHA_TEST);
int cx=(int)(camera->pos.x/(SQUARE_SIZE*TREE_SQUARE_SIZE));
int cy=(int)(camera->pos.z/(SQUARE_SIZE*TREE_SQUARE_SIZE));
CBasicTreeSquareDrawer drawer;
drawer.td = this;
drawer.cx = cx;
drawer.cy = cy;
drawer.treeDistance = treeDistance;
GML_STDMUTEX_LOCK(tree); // Draw
readmap->GridVisibility (camera, TREE_SQUARE_SIZE, treeDistance*2*SQUARE_SIZE*TREE_SQUARE_SIZE, &drawer);
int startClean=lastListClean*20%nTrees;
lastListClean=gs->frameNum;
int endClean=gs->frameNum*20%nTrees;
if(startClean>endClean){
for(TreeSquareStruct *pTSS=trees+startClean; pTSS<trees+nTrees; ++pTSS) {
if(pTSS->lastSeen<gs->frameNum-50 && pTSS->displist){
glDeleteLists(pTSS->displist,1);
pTSS->displist=0;
}
if(pTSS->lastSeenFar<gs->frameNum-50 && pTSS->farDisplist){
glDeleteLists(pTSS->farDisplist,1);
pTSS->farDisplist=0;
}
}
for(TreeSquareStruct *pTSS=trees; pTSS<trees+endClean; ++pTSS) {
if(pTSS->lastSeen<gs->frameNum-50 && pTSS->displist){
glDeleteLists(pTSS->displist,1);
pTSS->displist=0;
}
if(pTSS->lastSeenFar<gs->frameNum-50 && pTSS->farDisplist){
glDeleteLists(pTSS->farDisplist,1);
pTSS->farDisplist=0;
}
}
} else {
for(TreeSquareStruct *pTSS=trees+startClean; pTSS<trees+endClean; ++pTSS) {
if(pTSS->lastSeen<gs->frameNum-50 && pTSS->displist){
glDeleteLists(pTSS->displist,1);
pTSS->displist=0;
}
if(pTSS->lastSeenFar<gs->frameNum-50 && pTSS->farDisplist){
glDeleteLists(pTSS->farDisplist,1);
pTSS->farDisplist=0;
}
}
}
glDisable(GL_BLEND);
glDisable(GL_ALPHA_TEST);
}
void CGroup::RemoveUnit(CUnit *unit)
{
GML_STDMUTEX_LOCK(group); // RemoveUnit
eventHandler.GroupChanged(id);
if(ai)
ai->RemoveUnit(unit->id);
units.erase(unit);
}
void CDynWater::AddExplosion(const float3& pos, float strength, float size)
{
if(pos.y>size || size < 8)
return;
GML_STDMUTEX_LOCK(water); // AddExplosion
explosions.push_back(Explosion(pos,std::min(size*20,strength),size));
}
void CGroup::ClearUnits(void)
{
GML_STDMUTEX_LOCK(group); // ClearUnits
eventHandler.GroupChanged(id);
while(!units.empty()){
(*units.begin())->SetGroup(0);
}
}
void CNetProtocol::InitLocalClient()
{
GML_STDMUTEX_LOCK(net); // InitLocalClient
serverConn.reset(new netcode::CLocalConnection);
serverConn->Flush();
logOutput.Print("Connecting to local server");
}
void CInMapDraw::Draw(void)
{
GML_STDMUTEX_LOCK(inmap); //! Draw
CVertexArray* va = GetVertexArray();
va->Initialize();
CVertexArray* lineva = GetVertexArray();
lineva->Initialize();
InMapDraw_QuadDrawer drawer;
drawer.imd = this;
drawer.lineva = lineva;
drawer.va = va;
drawer.visLabels = &visibleLabels;
glDepthMask(0);
glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_BLEND);
glBindTexture(GL_TEXTURE_2D, texture);
readmap->GridVisibility(camera, DRAW_QUAD_SIZE, 3000.0f, &drawer);
glDisable(GL_TEXTURE_2D);
glLineWidth(3.f);
lineva->DrawArrayC(GL_LINES); //! draw lines
// XXX hopeless drivers, retest in a year or so...
// width greater than 2 causes GUI flicker on ATI hardware as of driver version 9.3
// so redraw lines with width 1
if (globalRendering->atiHacks) {
glLineWidth(1.f);
lineva->DrawArrayC(GL_LINES);
}
// draw points
glLineWidth(1);
glEnable(GL_TEXTURE_2D);
va->DrawArrayTC(GL_QUADS); //! draw point markers
if (!visibleLabels.empty()) {
font->SetColors(); //! default
//! draw point labels
for (std::vector<MapPoint*>::iterator pi = visibleLabels.begin(); pi != visibleLabels.end(); ++pi) {
float3 pos = (*pi)->pos;
pos.y += 111.0f;
font->SetTextColor((*pi)->color[0]/255.0f, (*pi)->color[1]/255.0f, (*pi)->color[2]/255.0f, 1.0f); //FIXME (overload!)
font->glWorldPrint(pos, 26.0f, (*pi)->label);
}
visibleLabels.clear();
}
glDepthMask(1);
}
void CGroupHandler::GroupCommand(int num, const std::string& cmd)
{
GML_RECMUTEX_LOCK(sel); // GroupCommand
GML_STDMUTEX_LOCK(group); // GroupCommand
if ((cmd == "set") || (cmd == "add")) {
if (cmd == "set") {
groups[num]->ClearUnits();
}
const CUnitSet& selUnits = selectedUnits.selectedUnits;
CUnitSet::const_iterator ui;
for(ui = selUnits.begin(); ui != selUnits.end(); ++ui) {
(*ui)->SetGroup(groups[num]);
}
}
else if (cmd == "selectadd") {
// do not select the group, just add its members to the current selection
CUnitSet::const_iterator gi;
for (gi = groups[num]->units.begin(); gi != groups[num]->units.end(); ++gi) {
selectedUnits.AddUnit(*gi);
}
return;
}
else if (cmd == "selectclear") {
// do not select the group, just remove its members from the current selection
CUnitSet::const_iterator gi;
for (gi = groups[num]->units.begin(); gi != groups[num]->units.end(); ++gi) {
selectedUnits.RemoveUnit(*gi);
}
return;
}
else if (cmd == "selecttoggle") {
// do not select the group, just toggle its members with the current selection
const CUnitSet& selUnits = selectedUnits.selectedUnits;
CUnitSet::const_iterator gi;
for (gi = groups[num]->units.begin(); gi != groups[num]->units.end(); ++gi) {
if (selUnits.find(*gi) == selUnits.end()) {
selectedUnits.AddUnit(*gi);
} else {
selectedUnits.RemoveUnit(*gi);
}
}
return;
}
if(selectedUnits.selectedGroup==num && !groups[num]->units.empty()){
float3 p(0,0,0);
for(CUnitSet::iterator gi=groups[num]->units.begin();gi!=groups[num]->units.end();++gi){
p+=(*gi)->pos;
}
p/=groups[num]->units.size();
camHandler->GetCurrentController().SetPos(p);
}
selectedUnits.SelectGroup(num);
}
void EventBatchHandler::UpdateDrawProjectiles() {
GML_STDMUTEX_LOCK(rproj); // UpdateDrawProjectiles
#if DETACH_SYNCED
syncedProjectileCreatedDestroyedEventBatch.delete_delayed();
#endif
syncedProjectileCreatedDestroyedEventBatch.add_delayed();
unsyncedProjectileCreatedDestroyedEventBatch.delete_delayed();
unsyncedProjectileCreatedDestroyedEventBatch.add_delayed();
}
void ITreeDrawer::Update() {
GML_STDMUTEX_LOCK(tree); // Update
std::vector<GLuint>::iterator i;
for (i = delDispLists.begin(); i != delDispLists.end(); ++i) {
glDeleteLists(*i, 1);
}
delDispLists.clear();
}
void CNetProtocol::InitClient(const char *server_addr, unsigned portnum,unsigned sourceport, const std::string& myName, const std::string& myPasswd, const std::string& myVersion)
{
GML_STDMUTEX_LOCK(net); // InitClient
netcode::UDPConnection* conn = new netcode::UDPConnection(sourceport, server_addr, portnum);
conn->SetMTU(configHandler->Get("MaximumTransmissionUnit", 0));
serverConn.reset(conn);
serverConn->SendData(CBaseNetProtocol::Get().SendAttemptConnect(myName, myPasswd, myVersion));
serverConn->Flush(true);
logOutput.Print("Connecting to %s:%i using name %s", server_addr, portnum, myName.c_str());
}
void CAdvTreeDrawer::DeleteTree(float3 pos)
{
GML_STDMUTEX_LOCK(tree); // DeleteTree
int hash=(int)pos.x+((int)(pos.z))*20000;
int square=((int)pos.x)/(SQUARE_SIZE*TREE_SQUARE_SIZE)+((int)pos.z)/(SQUARE_SIZE*TREE_SQUARE_SIZE)*treesX;
trees[square].trees.erase(hash);
ResetPos(pos);
}
void CAdvTreeDrawer::AddTree(int type, float3 pos, float size)
{
GML_STDMUTEX_LOCK(tree); // AddTree
TreeStruct ts;
ts.pos=pos;
ts.type=type;
int hash=(int)pos.x+((int)(pos.z))*20000;
int square=((int)pos.x)/(SQUARE_SIZE*TREE_SQUARE_SIZE)+((int)pos.z)/(SQUARE_SIZE*TREE_SQUARE_SIZE)*treesX;
trees[square].trees[hash]=ts;
ResetPos(pos);
}
bool CConsoleHistory::AddLine(const std::string& msg)
{
GML_STDMUTEX_LOCK(hist);
std::string message;
if ((msg.find_first_of("aAsS") == 0) && (msg[1] == ':')) {
message = msg.substr(2);
} else {
message = msg;
}
return AddLineRaw(message);
}
void CNetProtocol::InitLocalClient(const unsigned wantedNumber)
{
GML_STDMUTEX_LOCK(net);
server.reset(new netcode::CLocalConnection);
server->Flush();
if (!localDemoPlayback)
{
record.reset(new CDemoRecorder());
}
logOutput.Print("Connecting to local server using number %i", wantedNumber);
}
void CAdvTreeDrawer::DeleteTree(const float3& pos)
{
GML_STDMUTEX_LOCK(tree); // DeleteTree
const int hash = (int)pos.x + ((int)pos.z * 20000);
const int square =
((int)pos.x / (SQUARE_SIZE * TREE_SQUARE_SIZE)) +
((int)pos.z / (SQUARE_SIZE * TREE_SQUARE_SIZE) * treesX);
trees[square].trees.erase(hash);
ResetPos(pos);
}
void C3DModelParser::Update() {
GML_STDMUTEX_LOCK(model); // Update
units3oparser->Update();
unit3doparser->Update();
for(std::set<CUnit *>::iterator i=fixLocalModels.begin(); i!=fixLocalModels.end(); ++i)
FixLocalModel(*i);
fixLocalModels.clear();
for(std::vector<LocalS3DOModel *>::iterator i=deleteLocalModels.begin(); i!=deleteLocalModels.end(); ++i)
delete *i;
deleteLocalModels.clear();
}
void CInMapDrawModel::EraseNear(const float3& constPos, int playerID)
{
if (!playerHandler->IsValidPlayer(playerID))
return;
GML_STDMUTEX_LOCK(inmap); // LocalErase
const CPlayer* sender = playerHandler->Player(playerID);
float3 pos = constPos;
pos.ClampInBounds();
pos.y = ground->GetHeightAboveWater(pos.x, pos.z, false) + 2.0f;
if (AllowedMsg(sender) && eventHandler.MapDrawCmd(playerID, MAPDRAW_ERASE, &pos, NULL, NULL)) {
return;
}
const float radius = 100.0f;
const int maxY = drawQuadsY - 1;
const int maxX = drawQuadsX - 1;
const int yStart = (int) std::max(0, int((pos.z - radius) * QUAD_SCALE));
const int xStart = (int) std::max(0, int((pos.x - radius) * QUAD_SCALE));
const int yEnd = (int) std::min(maxY, int((pos.z + radius) * QUAD_SCALE));
const int xEnd = (int) std::min(maxX, int((pos.x + radius) * QUAD_SCALE));
for (int y = yStart; y <= yEnd; ++y) {
for (int x = xStart; x <= xEnd; ++x) {
DrawQuad* dq = &drawQuads[(y * drawQuadsX) + x];
std::list<MapPoint>::iterator pi;
for (pi = dq->points.begin(); pi != dq->points.end(); /* none */) {
if (pi->GetPos().SqDistance2D(pos) < (radius*radius) && (pi->IsBySpectator() == sender->spectator)) {
pi = dq->points.erase(pi);
numPoints--;
} else {
++pi;
}
}
std::list<MapLine>::iterator li;
for (li = dq->lines.begin(); li != dq->lines.end(); /* none */) {
// TODO maybe erase on pos2 too?
if (li->GetPos1().SqDistance2D(pos) < (radius*radius) && (li->IsBySpectator() == sender->spectator)) {
li = dq->lines.erase(li);
numLines--;
} else {
++li;
}
}
}
}
}
void CGroupHandler::RemoveGroup(CGroup* group)
{
GML_RECMUTEX_LOCK(sel); // RemoveGroup
GML_STDMUTEX_LOCK(group); // RemoveGroup
if(group->id<10){
logOutput.Print("Warning trying to remove hotkey group %i",group->id);
return;
}
if(selectedUnits.selectedGroup==group->id)
selectedUnits.ClearSelected();
groups[group->id]=0;
freeGroups.push_back(group->id);
delete group;
}