Bomb.cpp/.h
The bomb files are the bomb entity in game. As it is a model based entity and takes the form of a model in world, it has to inherit from the class CbaseAnimating, the class also inherits from CdefaultPlayerPickupVPhysics. This was so the functions OnPhysGunDrop , OnPhysGunPickup and OnAttemptPhysGunPickup could be used to detect when the bomb is picked up by a players gravity gun. These functions get automatically called when a player tries to interact with the bomb using the gravity gun, from there code can be added to manipulate the player who controls the bomb.
These functions are used to disable the player from punting the bomb, by checking what reason they want to pick up the for. The code checks if a player who attempts to pick up a bomb is the correct team or not, when a player picks up the bomb, they get sprint disabled also so as to limit their movement with the bomb. Inside each of these functions a bool is toggled to let the function IdleThink know the bomb is being held and isnt idle. When the bomb is dropped by the gravity gun the think function IdleThink is set to run after X seconds.
The think function Idle Think checks two bool values,  if they are both false the bomb explodes, one of these bools are set true when the bomb is inside the teams safe zone, the other is set true when the bomb is being held by the gravity gun.
The functions Explode and BaseExplode create an explosion at the bombs position, however the base explosion deals double the damage and radius. They also call the Respawn function after the explosion.
The Respawn function changed from the initial idea, Instead of deleting the bomb and making a new one. The current one simply explodes, then goes invisible and collisions are disabled, then is placed back at the respawn point, finally any decals (blood and such) get removed and then the think function Materialize is called after X time.
The Materialize think function checks if the bomb is invisible, if so the bomb is made visible again, along with collisions being set back to normal, finally a sound is emitted to let players know the bomb respawned.
The Spawn function gets called on any entity when it first loads in game, from there the function sets a few values to some variables, along with assigning two variables to a ConVar. The Precache function is called also, then the correct team model is loaded, finally the collisions and move types are set.

The Precache function is used once to load the models into the engine, it loads the rebel and combine bomb which are declared in a variable just above this function.
The DATADESC of an entity is a half life 2 specific macro, it is used to setup think functions and keyfeilds which can be edited by map designers in Hammer. The variable m_iTeam is declared as a keyfeild, this is so it can be changed in hammer, placed as a rebel or a combine bomb. The Think functions IdleThink and Materialize are setup here also.
Two ConVars are then declared using the respawn time and idle time variables, this is so they can be changed in game by server admins.

Bomb_Zone.cpp/h
The purpose of this entity is to function as the target zone players have to take their bomb to so they can plant it.
The entity is a brush entity so it has to inherit from the class CbaseTrigger, this allows the code to use the function BrushTouch, this function runs multiple times a second, and any other entity that touches, or is inside this entity, is passed through the function as a pointer.
Inside the BrushTouch function the pointer pOther is cast into a type Cbomb, this is so when the bomb entity touches the bomb zone, it can be accessed.
Before the bomb explodes there are a lot of nested if statements to go through, the first checks that the casting is correct and there is a bomb in the zone, then the bomb is used to get the player carrying it, which is then checked if the player exists or not, the players team is then checked, then he is told he can set his HUD red. The player is then checked If he is ducking with the bomb or not, if so a bool is set true for the function CheckCrouch, finally when the bomb counter reaches the bomb threshold, the bomb can be exploded, and players/teams awarded points.
The think function CheckCrouch checks if the player is crouching using a bool value, then adds to the counter, and plays a sound to signal to the player 1 second. This function runs every second, constantly checking if the player is in the zone and crouching.
The Spawn is much the same as the bombs spawn function, its used to set up some variables, along with setting up collisions and telling the think function to think now.
The Precache function here is used to load the sound that the bomb plays each second when crouched.
The DATADESC of this entity is used to set up the think function CheckCrouch, along with setting up the BrushTouch function, finally the keyfield for the zones team is set so it can be used in hammer.

Bomb_base.cpp/h
This entity is a brush entity so it has to inherit from the class CbaseTrigger. Its purpose is to check if a bomb is inside it, if so, and its in its team, the bomb’s idle bool is set true, this entity prevents the bomb from exploding inside its own base.
The DATADESC of this entity sets up the keyfield for its team, along with setting up the BrushTouch function used to catch the bomb.
The BrushTouch function casts any object passed into it to CBomb, then if the bomb exists, and its on the same team as itself, the function  SetIdle is passed the value true, which tells the bomb its in its own base, and not to explode.
The Spawn function for this entity just sets up the collisions and movetypes.

Hud_bomb.cpp/h
Like all other HUD items, this script is client side. This is the script that draws the bomb icon on the lower middle section of the screen, it changes red when a player enters the bomb zone with the bomb.
As this script is  HUD item, it has to inherit from valves HUD classes,  CHudElement and Panel.
There isn’t any DATADESC for a HUD object, so the first function  CHudBomb, is used to set up the textures ready for being drawn on screen later. The HUD object also has to have a parent object, so that is set up, along with the alpha. Both textures of the red and yellow bomb are saved to a integer in the form of a texture ID, this is so they can be drawn on screen in the Paint function.
The Paint function is run multiple times a second and is used to draw VGUI elements to the screen, in this case, it draws either the red bomb texture or the yellow one depending on the bool m_bInZone, this bool is set by getting the local player that this HUD object is for, and checking if he is in the bomb zone or not, this is one end of a large networked variable which is inside the player script.
There is a HUD think function running, which changes the bool m_bInZone back to false, however this think function isnt run as often as the paint function, so if the player is in the bomb zone, no noticeable change is seen in the texture showing, it only reverts the texture back to yellow should he leave it.

Only thing to note was i had a bug where the player couldnt punt objects from the gravity gun after droping the bomb, this was due to how i disabled the bomb being punted. It caused other objects to be droped before they got punted, so it would, drop > punt. instead of just punting, this caused objects to be launched with less force. I fixed this by turning off the force drop when the player is no longer holding the bomb.

Other than that, lighting effects and weather has been added to td_city, along with some minor changes/fixes.

Instead, I included the bomb.h file into the weapon_physcannon.cpp file, then i found the LaunchObject function which is what fires the object that is picked up, I used the player and object variables that the function requires, and casted the picked up object into the CBomb class, then set up an if statement so that whenever the bomb picked up is of CBomb class, then i could disable punting the bomb. This required me to move the Bomb files into the shared folder for client/server scripts, along with a few others to make everything work properly.

Aditionaly i designed a few textures to show the direction to each teams bases which i placed around the map. Theres a screenshot below with all the textures on the wall.

I also activated the ChooseTeam interface that is defaulty disabled within the mod. I only had to add a few lines of my own code, but most of it was allready there, just commented out and not in use. I added the .res file which sorted out its interface, and its all set to go now. Aditionaly the chooseteam function is bound to M ingame, so players can just swap teams using that button.

Next step i think is to add a bomb plant time, and work on ending the map when X total bomb explosions have happened.

Last there were a few faces that unpacked correctly and were rotated incorectly, you can see those in the screenshots where i coloured in a few faces to show how the faces rotated wrongly, That took a while to sort out.

But the final version of the bomb is ingame now, I may change the physics mesh if i find this one to be annoying, as the bomb’s mesh is just a circle with 4 little blobs sticking out of it. whereas i first off tried to use a triangle that had 4 flat edges, much easier for the game to predict collisions on as theres like 8X less faces.

I tried to add a few scuff marks to the edges of the bomb’s texture to look like its been scraped about the floor loosing paint and such, Its a bit difficult to do with a lack of photoshop and some decent brush’s to paint some nice marks on. So i had to make do with airbrushing a circle on lightly with different colour layers to add different levels of wear. It doesnt show so well in blender as its the only thing in the scene, but i feel it should look good ingame with a different lightset on it.

For some reason it isnt letting me upload the TGA file containing the flat UV map for the bomb, so sadly i cant show that.

The Physics mesh was totaly wrong first time around, But thats easily fixed by setting the orirgin of the bomb and its physics mesh to their centres so they align correctly ingame.

Heres the UV texture also:

i was trying to keep the vertex count down to a as small as possible, i could cut a few hundred off it if i needed, but i wanna keep some of the bomb with hidden faces so i can use these as Gibs when the bomb explodes, aditionaly, there will only be 2 bombs in the game at one time, and i dont think they will cause any FPS issues unless someone feels like spawning a load of them and shooting them about.

The rebel bomb i had to remmber to keep it looking as if its just been mashed together using whatever they could find, The casing for it is wooden, and the small pipe bombs in the edges of it also are hooked up to the simple detonator in the middle.

It should look alot better when its textxured, which means im going to have to brush up on my Unpacking skills to get a decent looking UV map, aswell as my Graphics skills to actualy come up with a decent texture for it.

Combine bomb will follow. Once ive dabbled with the rebel bomb.

This wasnt as simple as i thought it would be, I had to use the “getDefinition” and “getDeclaration” in VC++ alot, to track back from how players add score to their bomb explosions which i also added. The bombs variable had to be declared in the scoreboard, the player, the team and gamerules Scripts, and in their coresponding client side scripts. There needed to be some communication between the client/server scripts where the score and bombs were updated between them, aswell as alot of accessor functions being created for data access.

With the whole comuncations of data sorted out, all i have to do now to add to the score or bombs are theses simple (once i finaly figgured them out) lines:

pBomb->GetPlayer()->AddPoints( GetExplPoints() , false );

pBomb->GetPlayer()->AddPointsToTeam( GetExplPoints() , false );

pBomb->GetPlayer()->IncrementBombCount( 1 );

pBomb->GetPlayer()->IncrementBombCountToTeam( 1 );

I didnt realise at first that adding points to the team was different than just adding points. As total kills/bombs/deaths etc are contained on the player himself, and the scoreboard takes the data from him to update itself. This means if a player joins or leaves a server they need to clear any previous games data, Also if they leave then the scoreboard has to maintain a stable level of total bomb explosions.  As if a player leaves who scored 2 boms, the server needs to have the bomb explosions kept tallyed up in the Team rather than adding up each teams total.

What i didnt want to happen was players swaping sides or leaving and that changing the total scores/bombs.

Next step is still figuring out how to disable punting the bombs while someone holds them, thats the only thing the bomb needs changing so far.

Meanwhile i think i can start designing the custom bomb models for the combine and rebel bombs.

Mabye also looking at a single bomb version, where theres only one bomb in the middle that both teams fight over ? i can implement this if i have the free time.

Pics of the scoreboard below as i make changes to it.

Fixed now anyways.