]> de.git.xonotic.org Git - xonotic/netradiant.git/blobdiff - contrib/bobtoolz/DShape.cpp
reformat code! now the code is only ugly on the *inside*
[xonotic/netradiant.git] / contrib / bobtoolz / DShape.cpp
index 8c675ff9476e77fe175f5d373471a0b547d9cded..aa76888903a137d0b0b620c80c9721474577ff9d 100644 (file)
 
 bool bFacesAll[6] = {true, true, true, true, true, true};
 
-DShape::DShape(){
-       m_nNextBrush = 0;
+DShape::DShape()
+{
+    m_nNextBrush = 0;
 }
 
-DShape::~DShape(){
+DShape::~DShape()
+{
 
 }
 
-void DShape::BuildRegularPrism( vec3_t min, vec3_t max, int nSides, bool bAlignTop ){
-       vec3_t vc[MAX_POLYGON_FACES + 2], vd[MAX_POLYGON_FACES + 2];
+void DShape::BuildRegularPrism(vec3_t min, vec3_t max, int nSides, bool bAlignTop)
+{
+    vec3_t vc[MAX_POLYGON_FACES + 2], vd[MAX_POLYGON_FACES + 2];
 
-       vec3_t radius;
-       vec3_t origin;
+    vec3_t radius;
+    vec3_t origin;
 
-       VectorSubtract( max, min, radius );
-       VectorScale( radius, 0.5f, radius );
-       // calc 3d radius and origin
-       VectorAdd( max, min, origin );
-       VectorScale( origin, 0.5f, origin );
+    VectorSubtract(max, min, radius);
+    VectorScale(radius, 0.5f, radius);
+    // calc 3d radius and origin
+    VectorAdd(max, min, origin);
+    VectorScale(origin, 0.5f, origin);
 
-       float phase = 0.0f;
+    float phase = 0.0f;
 
-       if ( bAlignTop ) {
-               phase = -( Q_PI / nSides );
-               VectorScale( radius, static_cast<float>( 1.0 / cos( phase ) ), radius );
-       }
+    if (bAlignTop) {
+        phase = -(Q_PI / nSides);
+        VectorScale(radius, static_cast<float>( 1.0 / cos(phase)), radius);
+    }
 
-       //----- Build Polygon Vertices -----
+    //----- Build Polygon Vertices -----
 
-       int i;
-       for ( i = 0; i < nSides; i++ )
-       {
-               VectorCopy( origin, vc[i] );
-               VectorCopy( origin, vd[i] );
+    int i;
+    for (i = 0; i < nSides; i++) {
+        VectorCopy(origin, vc[i]);
+        VectorCopy(origin, vd[i]);
 
-               vc[i][2] = min[2];
-               vd[i][2] = max[2];
+        vc[i][2] = min[2];
+        vd[i][2] = max[2];
 
-               vc[i][0] += radius[0] * sinf( ( 2 * Q_PI * i / nSides ) + phase );
-               vc[i][1] += radius[1] * cosf( ( 2 * Q_PI * i / nSides ) + phase );
+        vc[i][0] += radius[0] * sinf((2 * Q_PI * i / nSides) + phase);
+        vc[i][1] += radius[1] * cosf((2 * Q_PI * i / nSides) + phase);
 
-               vd[i][0] = vc[i][0];
-               vd[i][1] = vc[i][1];
-       }
+        vd[i][0] = vc[i][0];
+        vd[i][1] = vc[i][1];
+    }
 
-       VectorCopy( vc[0], vc[nSides] );
-       VectorCopy( vd[0], vd[nSides] );
-       VectorCopy( vc[1], vc[nSides + 1] );
-       VectorCopy( vd[1], vd[nSides + 1] );
+    VectorCopy(vc[0], vc[nSides]);
+    VectorCopy(vd[0], vd[nSides]);
+    VectorCopy(vc[1], vc[nSides + 1]);
+    VectorCopy(vd[1], vd[nSides + 1]);
 
-       //----------------------------------
+    //----------------------------------
 
-       DBrush* pB = m_Container.GetWorldSpawn()->NewBrush( m_nNextBrush++ );
+    DBrush *pB = m_Container.GetWorldSpawn()->NewBrush(m_nNextBrush++);
 
-       for ( i = 1; i <= nSides; i++ )
-               pB->AddFace( vc[i - 1], vc[i], vd[i], GetCurrentTexture(), false );
+    for (i = 1; i <= nSides; i++) {
+        pB->AddFace(vc[i - 1], vc[i], vd[i], GetCurrentTexture(), false);
+    }
 
-       pB->AddFace( vc[2], vc[1], vc[0], "textures/common/caulk", false );
-       pB->AddFace( vd[0], vd[1], vd[2], "textures/common/caulk", false );
+    pB->AddFace(vc[2], vc[1], vc[0], "textures/common/caulk", false);
+    pB->AddFace(vd[0], vd[1], vd[2], "textures/common/caulk", false);
 }
 
-void DShape::Commit(){
-       m_Container.GetWorldSpawn()->FixBrushes();
-       m_Container.BuildInRadiant( true );
+void DShape::Commit()
+{
+    m_Container.GetWorldSpawn()->FixBrushes();
+    m_Container.BuildInRadiant(true);
 }
 
-void DShape::BuildInversePrism( vec3_t min, vec3_t max, int nSides, bool bAlignTop ){
-       vec3_t va[MAX_POLYGON_FACES + 1], vb[MAX_POLYGON_FACES + 1];
-       vec3_t radius;
-       vec3_t origin;
-
-       VectorSubtract( max, min, radius );
-       VectorScale( radius, 0.5f, radius );
-       // calc 3d radius and origin
-       VectorAdd( max, min, origin );
-       VectorScale( origin, 0.5f, origin );
-
-       float phase = 0.0f;
-
-       if ( bAlignTop ) {
-               phase = -( Q_PI / nSides );
-               VectorScale( radius, static_cast<float>( 1.0 / cos( phase ) ), radius );
-       }
-
-       //----- Build Polygon Vertices -----
-
-       int i;
-       for ( i = 0; i < nSides; i++ )
-       {
-               VectorCopy( origin, va[i] );
-               VectorCopy( origin, vb[i] );
-
-               va[i][2] = min[2];
-               vb[i][2] = max[2];
-
-               va[i][0] += radius[0] * sinf( ( 2 * Q_PI * i / nSides ) + phase );
-               va[i][1] += radius[1] * cosf( ( 2 * Q_PI * i / nSides ) + phase );
-
-               vb[i][0] = va[i][0];
-               vb[i][1] = va[i][1];
-       }
-
-       VectorCopy( va[0], va[nSides] );
-       VectorCopy( vb[0], vb[nSides] );
-
-       //----------------------------------
-
-       for ( i = 1; i <= nSides; i++ )
-       {
-               DBrush* pB = GetBoundingCube( min, max, "textures/common/caulk" );
-
-               vec3_t top, bottom;
-               VectorCopy( va[i - 1], top );
-               VectorCopy( va[i], bottom );
-
-               if ( va[i - 1][1] > va[i][1] ) {
-                       top[0] += 5;
-                       bottom[0] += 5;
-               }
-               else    // flip direction of plane on crossover
-               {
-                       top[0] -= 5;
-                       bottom[0] -= 5;
-               }
-
-               if ( top[1] != bottom[1] ) { // internal line is flat already if true
-                       pB->AddFace( va[i - 1], top, vb[i - 1], "textures/common/caulk", false );
-                       pB->AddFace( va[i], vb[i], bottom, "textures/common/caulk", false );
-               }   // add cut-off planes
-
-               pB->AddFace( va[i - 1], vb[i - 1], vb[i], GetCurrentTexture(), false );
-               // add internal polygon plane
-       }
+void DShape::BuildInversePrism(vec3_t min, vec3_t max, int nSides, bool bAlignTop)
+{
+    vec3_t va[MAX_POLYGON_FACES + 1], vb[MAX_POLYGON_FACES + 1];
+    vec3_t radius;
+    vec3_t origin;
+
+    VectorSubtract(max, min, radius);
+    VectorScale(radius, 0.5f, radius);
+    // calc 3d radius and origin
+    VectorAdd(max, min, origin);
+    VectorScale(origin, 0.5f, origin);
+
+    float phase = 0.0f;
+
+    if (bAlignTop) {
+        phase = -(Q_PI / nSides);
+        VectorScale(radius, static_cast<float>( 1.0 / cos(phase)), radius);
+    }
+
+    //----- Build Polygon Vertices -----
+
+    int i;
+    for (i = 0; i < nSides; i++) {
+        VectorCopy(origin, va[i]);
+        VectorCopy(origin, vb[i]);
+
+        va[i][2] = min[2];
+        vb[i][2] = max[2];
+
+        va[i][0] += radius[0] * sinf((2 * Q_PI * i / nSides) + phase);
+        va[i][1] += radius[1] * cosf((2 * Q_PI * i / nSides) + phase);
+
+        vb[i][0] = va[i][0];
+        vb[i][1] = va[i][1];
+    }
+
+    VectorCopy(va[0], va[nSides]);
+    VectorCopy(vb[0], vb[nSides]);
+
+    //----------------------------------
+
+    for (i = 1; i <= nSides; i++) {
+        DBrush *pB = GetBoundingCube(min, max, "textures/common/caulk");
+
+        vec3_t top, bottom;
+        VectorCopy(va[i - 1], top);
+        VectorCopy(va[i], bottom);
+
+        if (va[i - 1][1] > va[i][1]) {
+            top[0] += 5;
+            bottom[0] += 5;
+        } else    // flip direction of plane on crossover
+        {
+            top[0] -= 5;
+            bottom[0] -= 5;
+        }
+
+        if (top[1] != bottom[1]) { // internal line is flat already if true
+            pB->AddFace(va[i - 1], top, vb[i - 1], "textures/common/caulk", false);
+            pB->AddFace(va[i], vb[i], bottom, "textures/common/caulk", false);
+        }   // add cut-off planes
+
+        pB->AddFace(va[i - 1], vb[i - 1], vb[i], GetCurrentTexture(), false);
+        // add internal polygon plane
+    }
 }
 
-void DShape::BuildBorderedPrism( vec3_t min, vec3_t max, int nSides, int nBorder, bool bAlignTop ){
-       vec3_t va[MAX_POLYGON_FACES + 2], vb[MAX_POLYGON_FACES + 2];
-       vec3_t vc[MAX_POLYGON_FACES + 2], vd[MAX_POLYGON_FACES + 2];
+void DShape::BuildBorderedPrism(vec3_t min, vec3_t max, int nSides, int nBorder, bool bAlignTop)
+{
+    vec3_t va[MAX_POLYGON_FACES + 2], vb[MAX_POLYGON_FACES + 2];
+    vec3_t vc[MAX_POLYGON_FACES + 2], vd[MAX_POLYGON_FACES + 2];
 
-       vec3_t radius;
-       vec3_t origin;
+    vec3_t radius;
+    vec3_t origin;
 
-       VectorSubtract( max, min, radius );
-       VectorScale( radius, 0.5f, radius );
-       // calc 3d radius and origin
-       VectorAdd( max, min, origin );
-       VectorScale( origin, 0.5f, origin );
+    VectorSubtract(max, min, radius);
+    VectorScale(radius, 0.5f, radius);
+    // calc 3d radius and origin
+    VectorAdd(max, min, origin);
+    VectorScale(origin, 0.5f, origin);
 
-       if ( nBorder >= Min( radius[0], radius[1] ) ) {
+    if (nBorder >= Min(radius[0], radius[1])) {
 //             DoMessageBox("Border is too large", "Error", MB_OK);
-               return;
-       }
-
-       float phase = 0.0f;
+        return;
+    }
 
-       if ( bAlignTop ) {
-               phase = -( Q_PI / nSides );
-               VectorScale( radius, static_cast<float>( 1.0 / cos( phase ) ), radius );
-       }
+    float phase = 0.0f;
 
-       //----- Build Polygon Vertices -----
+    if (bAlignTop) {
+        phase = -(Q_PI / nSides);
+        VectorScale(radius, static_cast<float>( 1.0 / cos(phase)), radius);
+    }
 
-       int i;
-       for ( i = 0; i < nSides; i++ )
-       {
-               VectorCopy( origin, va[i] );
-               VectorCopy( origin, vb[i] );
-               VectorCopy( origin, vc[i] );
-               VectorCopy( origin, vd[i] );
+    //----- Build Polygon Vertices -----
 
-               va[i][2] = min[2];
-               vb[i][2] = max[2];
+    int i;
+    for (i = 0; i < nSides; i++) {
+        VectorCopy(origin, va[i]);
+        VectorCopy(origin, vb[i]);
+        VectorCopy(origin, vc[i]);
+        VectorCopy(origin, vd[i]);
 
-               va[i][0] += ( radius[0] - nBorder ) * sinf( ( 2 * Q_PI * i / nSides ) + phase );
-               va[i][1] += ( radius[1] - nBorder ) * cosf( ( 2 * Q_PI * i / nSides ) + phase );
+        va[i][2] = min[2];
+        vb[i][2] = max[2];
 
-               vb[i][0] = va[i][0];
-               vb[i][1] = va[i][1];
+        va[i][0] += (radius[0] - nBorder) * sinf((2 * Q_PI * i / nSides) + phase);
+        va[i][1] += (radius[1] - nBorder) * cosf((2 * Q_PI * i / nSides) + phase);
 
+        vb[i][0] = va[i][0];
+        vb[i][1] = va[i][1];
 
 
-               vc[i][2] = min[2];
-               vd[i][2] = max[2];
+        vc[i][2] = min[2];
+        vd[i][2] = max[2];
 
-               vc[i][0] += radius[0] * sinf( ( 2 * Q_PI * i / nSides ) + phase );
-               vc[i][1] += radius[1] * cosf( ( 2 * Q_PI * i / nSides ) + phase );
+        vc[i][0] += radius[0] * sinf((2 * Q_PI * i / nSides) + phase);
+        vc[i][1] += radius[1] * cosf((2 * Q_PI * i / nSides) + phase);
 
-               vd[i][0] = vc[i][0];
-               vd[i][1] = vc[i][1];
-       }
+        vd[i][0] = vc[i][0];
+        vd[i][1] = vc[i][1];
+    }
 
-       VectorCopy( va[0], va[nSides] );
-       VectorCopy( vb[0], vb[nSides] );
-       VectorCopy( va[1], va[nSides + 1] );
-       VectorCopy( vb[1], vb[nSides + 1] );
+    VectorCopy(va[0], va[nSides]);
+    VectorCopy(vb[0], vb[nSides]);
+    VectorCopy(va[1], va[nSides + 1]);
+    VectorCopy(vb[1], vb[nSides + 1]);
 
-       VectorCopy( vc[0], vc[nSides] );
-       VectorCopy( vd[0], vd[nSides] );
-       VectorCopy( vc[1], vc[nSides + 1] );
-       VectorCopy( vd[1], vd[nSides + 1] );
+    VectorCopy(vc[0], vc[nSides]);
+    VectorCopy(vd[0], vd[nSides]);
+    VectorCopy(vc[1], vc[nSides + 1]);
+    VectorCopy(vd[1], vd[nSides + 1]);
 
-       //----------------------------------
+    //----------------------------------
 
-       for ( i = 1; i <= nSides; i++ )
-       {
-               DBrush* pB = GetBoundingCube( min, max, "textures/common/caulk" );
+    for (i = 1; i <= nSides; i++) {
+        DBrush *pB = GetBoundingCube(min, max, "textures/common/caulk");
 
-               pB->AddFace( origin, vc[i - 1], vd[i - 1], "textures/common/caulk", false );
-               pB->AddFace( origin, vd[i], vc[i], "textures/common/caulk", false );
+        pB->AddFace(origin, vc[i - 1], vd[i - 1], "textures/common/caulk", false);
+        pB->AddFace(origin, vd[i], vc[i], "textures/common/caulk", false);
 
-               pB->AddFace( vc[i - 1], vc[i], vd[i], GetCurrentTexture(), false );
-               pB->AddFace( vb[i], va[i], va[i - 1], GetCurrentTexture(), false );
-       }
+        pB->AddFace(vc[i - 1], vc[i], vd[i], GetCurrentTexture(), false);
+        pB->AddFace(vb[i], va[i], va[i - 1], GetCurrentTexture(), false);
+    }
 }
 
-DBrush* DShape::GetBoundingCube_Ext( vec3_t min, vec3_t max, const char *textureName, bool* bUseFaces, bool detail ){
-       DBrush* pB = new DBrush;
-       //----- Build Outer Bounds ---------
-
-       vec3_t v1, v2, v3, v5, v6, v7;
-       VectorCopy( min, v1 );
-       VectorCopy( min, v2 );
-       VectorCopy( min, v3 );
-       VectorCopy( max, v5 );
-       VectorCopy( max, v6 );
-       VectorCopy( max, v7 );
-
-       v2[0] = max[0];
-       v3[1] = max[1];
-
-       v6[0] = min[0];
-       v7[1] = min[1];
-
-       //----------------------------------
-
-       //----- Add Six Cube Faces ---------
-
-       if ( bUseFaces[0] ) {
-               pB->AddFace( v1, v2, v3, textureName, detail );
-       }
-       if ( bUseFaces[1] ) {
-               pB->AddFace( v1, v3, v6, textureName, detail );
-       }
-       if ( bUseFaces[2] ) {
-               pB->AddFace( v1, v7, v2, textureName, detail );
-       }
-
-       if ( bUseFaces[3] ) {
-               pB->AddFace( v5, v6, v3, textureName, detail );
-       }
-       if ( bUseFaces[4] ) {
-               pB->AddFace( v5, v2, v7, textureName, detail );
-       }
-       if ( bUseFaces[5] ) {
-               pB->AddFace( v5, v7, v6, textureName, detail );
-       }
-
-       //----------------------------------
-
-       return pB;
+DBrush *DShape::GetBoundingCube_Ext(vec3_t min, vec3_t max, const char *textureName, bool *bUseFaces, bool detail)
+{
+    DBrush *pB = new DBrush;
+    //----- Build Outer Bounds ---------
+
+    vec3_t v1, v2, v3, v5, v6, v7;
+    VectorCopy(min, v1);
+    VectorCopy(min, v2);
+    VectorCopy(min, v3);
+    VectorCopy(max, v5);
+    VectorCopy(max, v6);
+    VectorCopy(max, v7);
+
+    v2[0] = max[0];
+    v3[1] = max[1];
+
+    v6[0] = min[0];
+    v7[1] = min[1];
+
+    //----------------------------------
+
+    //----- Add Six Cube Faces ---------
+
+    if (bUseFaces[0]) {
+        pB->AddFace(v1, v2, v3, textureName, detail);
+    }
+    if (bUseFaces[1]) {
+        pB->AddFace(v1, v3, v6, textureName, detail);
+    }
+    if (bUseFaces[2]) {
+        pB->AddFace(v1, v7, v2, textureName, detail);
+    }
+
+    if (bUseFaces[3]) {
+        pB->AddFace(v5, v6, v3, textureName, detail);
+    }
+    if (bUseFaces[4]) {
+        pB->AddFace(v5, v2, v7, textureName, detail);
+    }
+    if (bUseFaces[5]) {
+        pB->AddFace(v5, v7, v6, textureName, detail);
+    }
+
+    //----------------------------------
+
+    return pB;
 }
 
-DBrush* DShape::GetBoundingCube( vec3_t min, vec3_t max, const char *textureName, DEntity* ent, bool* bUseFaces ){
-       DBrush* pB;
-       if ( ent == NULL ) {
-               pB = m_Container.GetWorldSpawn()->NewBrush( m_nNextBrush++ );
-       }
-       else{
-               pB = ent->NewBrush( m_nNextBrush++ );
-       }
-
-       //----- Build Outer Bounds ---------
-
-       vec3_t v1, v2, v3, v5, v6, v7;
-       VectorCopy( min, v1 );
-       VectorCopy( min, v2 );
-       VectorCopy( min, v3 );
-       VectorCopy( max, v5 );
-       VectorCopy( max, v6 );
-       VectorCopy( max, v7 );
-
-       v2[0] = max[0];
-       v3[1] = max[1];
-
-       v6[0] = min[0];
-       v7[1] = min[1];
-
-       //----------------------------------
-
-       //----- Add Six Cube Faces ---------
-
-       if ( bUseFaces[0] ) {
-               pB->AddFace( v1, v2, v3, textureName, false );
-       }
-       if ( bUseFaces[1] ) {
-               pB->AddFace( v1, v3, v6, textureName, false );
-       }
-       if ( bUseFaces[2] ) {
-               pB->AddFace( v1, v7, v2, textureName, false );
-       }
-
-       if ( bUseFaces[3] ) {
-               pB->AddFace( v5, v6, v3, textureName, false );
-       }
-       if ( bUseFaces[4] ) {
-               pB->AddFace( v5, v2, v7, textureName, false );
-       }
-       if ( bUseFaces[5] ) {
-               pB->AddFace( v5, v7, v6, textureName, false );
-       }
-
-       //----------------------------------
-
-       return pB;
+DBrush *DShape::GetBoundingCube(vec3_t min, vec3_t max, const char *textureName, DEntity *ent, bool *bUseFaces)
+{
+    DBrush *pB;
+    if (ent == NULL) {
+        pB = m_Container.GetWorldSpawn()->NewBrush(m_nNextBrush++);
+    } else {
+        pB = ent->NewBrush(m_nNextBrush++);
+    }
+
+    //----- Build Outer Bounds ---------
+
+    vec3_t v1, v2, v3, v5, v6, v7;
+    VectorCopy(min, v1);
+    VectorCopy(min, v2);
+    VectorCopy(min, v3);
+    VectorCopy(max, v5);
+    VectorCopy(max, v6);
+    VectorCopy(max, v7);
+
+    v2[0] = max[0];
+    v3[1] = max[1];
+
+    v6[0] = min[0];
+    v7[1] = min[1];
+
+    //----------------------------------
+
+    //----- Add Six Cube Faces ---------
+
+    if (bUseFaces[0]) {
+        pB->AddFace(v1, v2, v3, textureName, false);
+    }
+    if (bUseFaces[1]) {
+        pB->AddFace(v1, v3, v6, textureName, false);
+    }
+    if (bUseFaces[2]) {
+        pB->AddFace(v1, v7, v2, textureName, false);
+    }
+
+    if (bUseFaces[3]) {
+        pB->AddFace(v5, v6, v3, textureName, false);
+    }
+    if (bUseFaces[4]) {
+        pB->AddFace(v5, v2, v7, textureName, false);
+    }
+    if (bUseFaces[5]) {
+        pB->AddFace(v5, v7, v6, textureName, false);
+    }
+
+    //----------------------------------
+
+    return pB;
 }
 
-bool DShape::BuildPit( vec3_t min, vec3_t max ){
-       if ( ( max[2] - min[2] ) < 196 ) {
-               return false;
-       }
+bool DShape::BuildPit(vec3_t min, vec3_t max)
+{
+    if ((max[2] - min[2]) < 196) {
+        return false;
+    }
 
-       srand( time( NULL ) );
+    srand(time(NULL));
 
-       vec3_t centre;
-       VectorAdd( min, max, centre );
-       VectorScale( centre, 0.5f, centre );
+    vec3_t centre;
+    VectorAdd(min, max, centre);
+    VectorScale(centre, 0.5f, centre);
 
-       char buffer[256];
+    char buffer[256];
 
-       int team = ( rand() % 10000 ) + 5000;
+    int team = (rand() % 10000) + 5000;
 
 // ************* SPEAKER ***************
-       sprintf( buffer, "t%i_1", team );
+    sprintf(buffer, "t%i_1", team);
 
 // trigger for speaker
-       vec3_t triggerVoiceBtm;
-       VectorCopy( min, triggerVoiceBtm );
-       triggerVoiceBtm[2] = max[2] - 16;
+    vec3_t triggerVoiceBtm;
+    VectorCopy(min, triggerVoiceBtm);
+    triggerVoiceBtm[2] = max[2] - 16;
 
-       DEntity* triggerVoice = m_Container.AddEntity( "trigger_multiple" );
-       GetBoundingCube( triggerVoiceBtm, max, "textures/common/trigger", triggerVoice );
-       triggerVoice->AddEPair( "target", buffer );
+    DEntity *triggerVoice = m_Container.AddEntity("trigger_multiple");
+    GetBoundingCube(triggerVoiceBtm, max, "textures/common/trigger", triggerVoice);
+    triggerVoice->AddEPair("target", buffer);
 //--------------------
 
 // target for speaker
-       vec3_t voiceOrigin;
-       VectorCopy( centre, voiceOrigin );
-       voiceOrigin[2] = max[2] + 16;
+    vec3_t voiceOrigin;
+    VectorCopy(centre, voiceOrigin);
+    voiceOrigin[2] = max[2] + 16;
 
 
-       DEntity* targetVoice = m_Container.AddEntity( "target_speaker" );
-       targetVoice->AddEPair( "targetname", buffer );
+    DEntity *targetVoice = m_Container.AddEntity("target_speaker");
+    targetVoice->AddEPair("targetname", buffer);
 
-       sprintf( buffer, "%f %f %f", voiceOrigin[0], voiceOrigin[1], voiceOrigin[2] );
-       targetVoice->AddEPair( "origin", buffer );
-       targetVoice->AddEPair( "spawnflags", "8" );
-       targetVoice->AddEPair( "noise", "*falling1.wav" );
+    sprintf(buffer, "%f %f %f", voiceOrigin[0], voiceOrigin[1], voiceOrigin[2]);
+    targetVoice->AddEPair("origin", buffer);
+    targetVoice->AddEPair("spawnflags", "8");
+    targetVoice->AddEPair("noise", "*falling1.wav");
 //--------------------
 
 // *********** END SPEAKER *************
 
 // ********* POWERUP REMOVAL ***********
-       sprintf( buffer, "t%i_2", team );
+    sprintf(buffer, "t%i_2", team);
 
 // trigger for powerup removal
-       vec3_t triggerPwrRmvTop, triggerPwrRmvBtm;
-       VectorCopy( min, triggerPwrRmvBtm );
-       VectorCopy( max, triggerPwrRmvTop );
+    vec3_t triggerPwrRmvTop, triggerPwrRmvBtm;
+    VectorCopy(min, triggerPwrRmvBtm);
+    VectorCopy(max, triggerPwrRmvTop);
 
-       triggerPwrRmvTop[2] = triggerVoiceBtm[2] - 64;
-       triggerPwrRmvBtm[2] = triggerPwrRmvTop[2] - 16;
+    triggerPwrRmvTop[2] = triggerVoiceBtm[2] - 64;
+    triggerPwrRmvBtm[2] = triggerPwrRmvTop[2] - 16;
 
-       DEntity* triggerPwrRmv = m_Container.AddEntity( "trigger_multiple" );
-       GetBoundingCube( triggerPwrRmvBtm, triggerPwrRmvTop, "textures/common/trigger", triggerPwrRmv );
-       triggerPwrRmv->AddEPair( "target", buffer );
+    DEntity *triggerPwrRmv = m_Container.AddEntity("trigger_multiple");
+    GetBoundingCube(triggerPwrRmvBtm, triggerPwrRmvTop, "textures/common/trigger", triggerPwrRmv);
+    triggerPwrRmv->AddEPair("target", buffer);
 //--------------------
 
 // target for powerup removal
-       vec3_t pwrRmvOrigin;
-       VectorCopy( centre, pwrRmvOrigin );
-       pwrRmvOrigin[2] = triggerPwrRmvTop[2] + 16;
+    vec3_t pwrRmvOrigin;
+    VectorCopy(centre, pwrRmvOrigin);
+    pwrRmvOrigin[2] = triggerPwrRmvTop[2] + 16;
 
-       DEntity* targetPwrRmv = m_Container.AddEntity( "target_remove_powerups" );
-       targetPwrRmv->AddEPair( "targetname", buffer );
+    DEntity *targetPwrRmv = m_Container.AddEntity("target_remove_powerups");
+    targetPwrRmv->AddEPair("targetname", buffer);
 
-       sprintf( buffer, "%f %f %f", pwrRmvOrigin[0], pwrRmvOrigin[1], pwrRmvOrigin[2] );
-       targetPwrRmv->AddEPair( "origin", buffer );
+    sprintf(buffer, "%f %f %f", pwrRmvOrigin[0], pwrRmvOrigin[1], pwrRmvOrigin[2]);
+    targetPwrRmv->AddEPair("origin", buffer);
 //--------------------
 
 // ****** END POWERUP REMOVAL ********
@@ -439,31 +441,31 @@ bool DShape::BuildPit( vec3_t min, vec3_t max ){
 // ********* DAMAGE ***********
 
 // trigger for damage
-       vec3_t triggerDmgTop, triggerDmgBtm;
-       VectorCopy( min, triggerDmgBtm );
-       VectorCopy( max, triggerDmgTop );
+    vec3_t triggerDmgTop, triggerDmgBtm;
+    VectorCopy(min, triggerDmgBtm);
+    VectorCopy(max, triggerDmgTop);
 
-       triggerDmgBtm[2] = min[2] + 64;
-       triggerDmgTop[2] = triggerDmgBtm[2] + 16;
+    triggerDmgBtm[2] = min[2] + 64;
+    triggerDmgTop[2] = triggerDmgBtm[2] + 16;
 
-       DEntity* triggerDmg = m_Container.AddEntity( "trigger_hurt" );
-       GetBoundingCube( triggerDmgBtm, triggerDmgTop, "textures/common/trigger", triggerDmg );
-       triggerDmg->AddEPair( "dmg", "9999" );
-       triggerDmg->AddEPair( "spawnflags", "12" );
+    DEntity *triggerDmg = m_Container.AddEntity("trigger_hurt");
+    GetBoundingCube(triggerDmgBtm, triggerDmgTop, "textures/common/trigger", triggerDmg);
+    triggerDmg->AddEPair("dmg", "9999");
+    triggerDmg->AddEPair("spawnflags", "12");
 //--------------------
 
 // ****** END DAMAGE ********
 
 // ********* NODROP ***********
 
-       vec3_t nodropTop;
-       VectorCopy( max, nodropTop );
+    vec3_t nodropTop;
+    VectorCopy(max, nodropTop);
 
-       nodropTop[2] = min[2] + 64;
+    nodropTop[2] = min[2] + 64;
 
-       GetBoundingCube( min, nodropTop, "textures/common/nodrop" );
+    GetBoundingCube(min, nodropTop, "textures/common/nodrop");
 
 // ****** END NODROP ********
 
-       return true;
+    return true;
 }