CnC_Remastered_Collection

REINF.CPP (26376B)

---

 //
 // Copyright 2020 Electronic Arts Inc.
 //
 // TiberianDawn.DLL and RedAlert.dll and corresponding source code is free 
 // software: you can redistribute it and/or modify it under the terms of 
 // the GNU General Public License as published by the Free Software Foundation, 
 // either version 3 of the License, or (at your option) any later version.
 
 // TiberianDawn.DLL and RedAlert.dll and corresponding source code is distributed 
 // in the hope that it will be useful, but with permitted additional restrictions 
 // under Section 7 of the GPL. See the GNU General Public License in LICENSE.TXT 
 // distributed with this program. You should have received a copy of the 
 // GNU General Public License along with permitted additional restrictions 
 // with this program. If not, see https://github.com/electronicarts/CnC_Remastered_Collection
 
 /* $Header:   F:\projects\c&c\vcs\code\reinf.cpv   2.17   16 Oct 1995 16:48:58   JOE_BOSTIC  $ */
 /***********************************************************************************************
  ***             C O N F I D E N T I A L  ---  W E S T W O O D   S T U D I O S               *** 
  ***********************************************************************************************
  *                                                                                             *
  *                 Project Name : Command & Conquer                                            *
  *                                                                                             *
  *                    File Name : REINF.CPP                                                    *
  *                                                                                             *
  *                   Programmer : Joe L. Bostic                                                *
  *                                                                                             *
  *                   Start Date : May 24, 1994                                                 *
  *                                                                                             *
  *                  Last Update : July 4, 1995 [JLB]                                           *
  *                                                                                             *
  *---------------------------------------------------------------------------------------------*
  * Functions:                                                                                  *
  *   Create_Air_Reinforcement -- Creates air strike reinforcement                              * 
  *   Create_Special_Reinforcement -- Ad hoc reinforcement handler.                             * 
  *   Do_Reinforcements -- Create and place a reinforcement team.                               * 
  * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
 
 #include	"function.h"
 
 
 /*********************************************************************************************** 
  * Do_Reinforcements -- Create and place a reinforcement team.                                 * 
  *                                                                                             * 
  *    This routine is called when a reinforcement team must be created and placed on the map.  * 
  *    It will create all members of the team and place them at the location determined from    * 
  *    the team composition. The reinforcement team should follow team orders until overriden   * 
  *    by AI or player intervention.                                                            * 
  *                                                                                             * 
  * INPUT:   teamtype -- Pointer to the team type to create as a reinforcement.                 * 
  *                                                                                             * 
  * OUTPUT:  Was the reinforcement successfully created and placed?                             * 
  *                                                                                             * 
  * WARNINGS:   none                                                                            * 
  *                                                                                             * 
  * HISTORY:                                                                                    * 
  *   05/08/1995 JLB : Created.                                                                 * 
  *   05/18/1995 JLB : Returns success or failure condition.                                    * 
  *   06/19/1995 JLB : Announces reinforcements.                                                * 
  *=============================================================================================*/
 bool Do_Reinforcements(TeamTypeClass *teamtype)
 {
 	/*
 	**	preform some preliminary checks for validity.
 	*/
 	if (!teamtype || !teamtype->ClassCount) return(false);
 
 	/*
 	**	Create the controlling team. All the objects are grouped
 	**	under this team control. If there are no missions for this team
 	**	then don't actually create the team -- it won't serve a purpose.
 	*/
 	TeamClass * team = NULL;
 	if (teamtype->MissionCount) {
 		team = new TeamClass(teamtype, HouseClass::As_Pointer(teamtype->House));
 		if (!team) return(false);
 		team->Force_Active();
 	}
 
 	/*
 	**	Determine if this team contains its own transport. In such a case, the
 	**	transport is used as a loaner. This is only true, if there is other
 	**	objects to be transport. Without such cargo objects, then the transport
 	**	is presumed to be the reinforcement itself and thus should not be a
 	**	loaner.
 	*/
 	bool okvoice = true;						// Presume ok to announce reinforcement?
 	bool airtransport = false;				// Transport can fly in?
 	bool watertransport = false;			// Transport needs a beach to land at?
 	bool onlytransport = true;				// Just transport is in reinforcement?
 	bool hastransport = false;				// Group comes with transport?
 	int index;
 	for (index=0; index < teamtype->ClassCount; index++) {
 		if (teamtype->Class[index]->IsTransporter || teamtype->Class[index]->What_Am_I() == RTTI_AIRCRAFTTYPE) {
 			hastransport = true;
 			if (teamtype->Class[index]->What_Am_I() == RTTI_AIRCRAFTTYPE) {
 				airtransport = true;
 			} else {
 				watertransport = (((UnitTypeClass const *)teamtype->Class[index])->Type == UNIT_HOVER);
 			}
 		} else {
 			onlytransport = false;
 		}
 	}
 
 	/*
 	**	Now determine how the reinforcement should be delivered. This is largely determined
 	**	by whether there is a transport with the reinforcements.
 	*/
 	SourceType source = SOURCE_NONE;
 	if (airtransport) {
 		source = SOURCE_AIR;
 	} else {
 
 		if (watertransport) {
 			source = SOURCE_BEACH;
 		} else {
 			
 			/*
 			**	Special case for the gunboat. It always arrives according to the shipping source.
 			*/
 			if (teamtype->Class[0]->What_Am_I() == RTTI_UNITTYPE && ((UnitTypeClass const *)teamtype->Class[0])->Type == UNIT_GUNBOAT) {
 				source = SOURCE_SHIPPING;
 			} else {
 				source = HouseClass::As_Pointer(teamtype->House)->Edge;
 			}
 		}
 	}
 
 	/*
 	**	If we can't determine where the reinforcement should come from, then delete it
 	**	and return a failure condition.
 	*/
 	if (source == SOURCE_NONE) {
 		if (team) delete team;
 		return(false);
 	}
 
 	/*
 	**	Now that the official source for the reinforcement has been determined, the 
 	**	objects themselves must be created.
 	*/
 	TechnoClass * transport = NULL;
 	TechnoClass * object = NULL;
 	for (index = 0; index < teamtype->ClassCount; index++) {
 		TechnoTypeClass const * tclass = teamtype->Class[index];
 
 		for (int sub = 0; sub < teamtype->DesiredNum[index]; sub++) {
 			ScenarioInit++;
 			FootClass * temp = (FootClass *)tclass->Create_One_Of(HouseClass::As_Pointer(teamtype->House));
 			ScenarioInit--;
 
 			if (temp) {
 
 				/*
 				**	Add the object to the team. This is true even for the transports. The one
 				**	exception is for the hover lander which never becomes part of the team.
 				*/
 				if (team && (temp->What_Am_I() != RTTI_UNIT || *((UnitClass*)temp) != UNIT_HOVER)) {
 					ScenarioInit++;
 					team->Add(temp);
 					ScenarioInit--;
 				}
 
 				/*
 				**	Build the list of transporters and passengers.
 				*/
 				if (tclass->IsTransporter && (!airtransport || tclass->What_Am_I() == RTTI_AIRCRAFTTYPE)) {
 
 					/*
 					**	Transports are considered loaners if they are transporting 
 					**	something. They are presumed to only serve as a delivery
 					**	agent.
 					*/
 					if (!onlytransport && temp->What_Am_I() != RTTI_UNIT) {
 						temp->IsALoaner = true;
 					}
 
 					/*
 					**	Link to the list of transports.
 					*/
 					temp->Next = transport;
 					transport = temp;
 				} else {
 
 					/*
 					**	A-10s are always considered loaners since the player should
 					**	never be allowed to control them.
 					*/
 					if (temp->What_Am_I() == RTTI_AIRCRAFT && *((AircraftClass *)temp) == AIRCRAFT_A10) {
 						temp->IsALoaner = true;
 					}
 
 					/*
 					**	Link to the list of normal objects.
 					*/
 					temp->Next = object;
 					object = temp;
 				}
 			}
 		}
 	}
 
 	/*
 	**	Bail on this reinforcement if no reinforcements could be created.
 	**	This is probably because the object maximum was reached.
 	*/
 	if (!object && !transport) {
 		if (team) delete team;
 		return(false);
 	}
 
 	/*
 	**	Now it is time to place the objects on the map. If there is a transport, then the
 	**	transported objects must be placed inside the transport at this time as well.
 	*/
 	if (transport) {
 		if (object) {
 
 			/*
 			**	For cargo planes that carry reinforcements, don't announce arrival
 			**	when the transport is created. The announcement will occur when the
 			**	transport unloads.
 			*/
 			if (transport->What_Am_I() == RTTI_AIRCRAFT && *((AircraftClass *)transport) == AIRCRAFT_CARGO) {
 				okvoice = false;
 			}
 
 			transport->Attach((FootClass *)object);
 		}
 		object = transport;
 	}
 
 	/*
 	**	Pick the location where the reinforcements appear and then place
 	**	them there.
 	*/
 	bool placed = false;
 	CELL cell = 0;
 	FacingType eface;
 	switch (source) {
 
 		case SOURCE_SHIPPING:
 			cell = Map.Calculated_Cell(source, teamtype->House);
 			object->IsALoaner = true;
 			if (object->Unlimbo(Cell_Coord(cell), DIR_W)) {
 				object->Assign_Mission(MISSION_GUARD);
 				object->Assign_Destination(::As_Target(XY_Cell(Map.MapCellX-1, Cell_Y(Coord_Cell(object->Coord)) )));
 			} else {
 				if (team) delete team;
 				delete object;
 				return(false);
 			}
 			break;
 
 		case SOURCE_NORTH:
 		case SOURCE_SOUTH:
 		case SOURCE_EAST:
 		case SOURCE_WEST: {
 			eface = (FacingType)(source << 1);	// Facing to enter map.
 
 			if (airtransport) ScenarioInit++;
 			cell = Map.Calculated_Cell(source, teamtype->House);
 			if (airtransport) ScenarioInit--;
 			CELL newcell = cell;
 
 			FootClass * o = (FootClass *)object->Next;
 			object->Next = 0;
 			bool ok = true;
 			while (newcell > 0 && object) {
 				DirType desiredfacing = Facing_Dir(eface);
 				if (object->What_Am_I() == RTTI_AIRCRAFT) {
 					desiredfacing = Random_Pick(DIR_N, DIR_MAX);
 				}
 
 				if (ok && object->Unlimbo(Cell_Coord(newcell), desiredfacing)) {
 
 					/*
 					**	If this object is part of a team, then the mission for this
 					**	object will be guard. The team handler will assign the proper 
 					**	mission that it should follow.
 					*/
 					if (object->What_Am_I() == RTTI_AIRCRAFT) {
 						ok = false;
 					} else {
 						if (team) {
 							object->Assign_Mission(MISSION_GUARD);
 						} else {
 							object->Assign_Mission(MISSION_MOVE);
 							object->Assign_Destination(Adjacent_Cell(newcell, eface));
 						}
 						object->Commence();
 					}
 
 				} else {
 					ok = true;
 					
 					/*
 					**	Could not unlimbo at location specified so find an adjacent location that it can
 					**	be unlimboed at. If this fails, then abort the whole placement process.
 					*/
 					FacingType adj;
 					for (adj = FACING_N; adj < FACING_COUNT; adj++) {
 						CELL trycell = Adjacent_Cell(newcell, adj);
 						if (!Map.In_Radar(trycell) && object->Can_Enter_Cell(trycell, adj) == MOVE_OK) {
 							newcell = trycell;
 							break;
 						}
 					}
 					if (adj < FACING_COUNT) continue;
 					newcell = -1;
 				}
 
 				object = o;
 				if (object) {
 					o = (FootClass *)object->Next;
 					object->Next = 0;
 				}
 			}
 
 			/*
 			**	If there are still objects that could not be placed, then delete them.
 			*/
 			if (o) {
 				while (o) {
 					FootClass * old = o;
 					o = (FootClass *)o->Next;
 					old->Next = 0;
 
 					delete old;
 				}
 
 			}
 		}
 		break;
 
 		/*
 		**	Bring out the aircraft as separate "groups" of one.
 		*/
 		case SOURCE_AIR: {
 			AircraftClass * thisone = (AircraftClass *)object;
 			TARGET target = TARGET_NONE;
 			while (thisone) {
 				AircraftClass * next = (AircraftClass *)thisone->Next;
 
 				/*
 				**	Find a suitable map entry location. Cargo planes will try to find a cell that
 				**	exactly lines up with the airfield they will unload at.
 				*/
 				COORDINATE newcoord;
 				long reinforcement_delay = -1;
 				ScenarioInit++;
 				newcoord = Cell_Coord(Map.Calculated_Cell(HouseClass::As_Pointer(teamtype->House)->Edge, teamtype->House));
 				ScenarioInit--;
 				if (*thisone == AIRCRAFT_CARGO) {
 					BuildingClass const * building = thisone->Find_Docking_Bay(STRUCT_AIRSTRIP, false);
 					if (building) {
 						COORDINATE docking_coord = building->Docking_Coord();
 						const int border_x = Cell_To_Lepton(Map.MapCellX + Map.MapCellWidth) | 0x80;
 						if (Special.ModernBalance) {
 							/*
 							** Cargo plane takes 5 seconds to reach the airstrip on Normal (1.5x legacy), or (75 / 10) seconds at speed.
 							** Assumes a 45ms (1000 / 45 ticks per second) service rate.
 							*/
 							const int speed = AircraftTypeClass::As_Reference(AIRCRAFT_CARGO).MaxSpeed;
 							int spawn_x = Coord_X(docking_coord) + ((speed * 1000 * 75) / (45 * 10));
 							if (spawn_x > border_x) {
 								reinforcement_delay = (spawn_x - border_x) / speed;
 								spawn_x = border_x;
 							}
 							newcoord = XY_Coord(spawn_x, Coord_Y(docking_coord));
 						} else {
 							newcoord = XY_Coord(border_x, Coord_Y(docking_coord));
 						}
 						if (teamtype->MissionCount) {
 							teamtype->MissionList[0].Argument = building->As_Target();
 						}
 					} 
 				}
 				thisone->Next = 0;
 
 				ScenarioInit++;
 				placed = thisone->Unlimbo(newcoord, DIR_W);
 				if (Special.ModernBalance && reinforcement_delay >= 0) {
 					thisone->Set_Reinforcement_Delay(reinforcement_delay);
 				}
 				ScenarioInit--;
 				if (placed) {
 					if (!team) {
 						if (thisone->Class->IsFixedWing) {
 							thisone->Assign_Mission(MISSION_HUNT);
 							if (*thisone == AIRCRAFT_A10) {
 								/*
 								**	Groups of A10s always go after the same target initally.
 								*/
 								if (target == TARGET_NONE) {
 									target = thisone->Greatest_Threat(THREAT_NORMAL);
 								}
 								thisone->Assign_Target(target);
 							}
 						} else {
 							if (thisone->Class->IsTransporter && thisone->Is_Something_Attached()) {
 								thisone->Assign_Mission(MISSION_UNLOAD);
 							} else {
 								thisone->Assign_Mission(MISSION_MOVE);
 							}
 							thisone->Assign_Destination(::As_Target(Map.Calculated_Cell(source, teamtype->House)));
 						}
 						thisone->Commence();
 					}
 				} else {
 					delete thisone;
 				}
 
 				thisone = next;
 			}
 			if (!placed && team) delete team;
 
 
 			/*
 			**	Fixes bug that can happen if the reinforcement cannot be created.
 			**	This prevent "phantom" teams and team types from being left around.
 			*/
 			if (GameToPlay == GAME_NORMAL && !placed) return(false);
 
 		}
 		break;
 
 		case SOURCE_OCEAN:
 		case SOURCE_BEACH:
 			cell = Map.Calculated_Cell(SOURCE_BEACH, teamtype->House);
 			if (cell) {
 				CELL edge = XY_Cell(Cell_X(cell), Map.MapCellY+Map.MapCellHeight);
 
 				placed = object->Unlimbo(Cell_Coord(edge), DIR_N);
 				if (placed) {
 					if (!team) {
 						object->IsLocked = false;
 						object->Assign_Mission(MISSION_UNLOAD);
 						object->Commence();
 						object->Assign_Destination(::As_Target(cell));
 					}
 				} else {
 					if (team) delete team;
 					delete object;
 					return(false);
 				}
 			}
 			break;
 
 		default:
 			break;
 	}
 
 	/*
 	**	Announce when the reinforcements have arrived.
 	*/
 	if (okvoice && teamtype->House == PlayerPtr->Class->House) {
 		Speak(VOX_REINFORCEMENTS, NULL, cell ? Cell_Coord(cell) : 0);
 	}
 
 	return(true);
 }			
 
 
 /*********************************************************************************************** 
  * Create_Special_Reinforcement -- Ad hoc reinforcement handler.                               * 
  *                                                                                             * 
  *    Use this routine to bring on a reinforcement that hasn't been anticipated by the trigger * 
  *    system. An example of this would be replacement harvesters or airfield ordered units.    * 
  *    The appropriate transport is created (if necessary) and a mission is assigned such that  * 
  *    the object will legally bring itself onto the playing field.                             * 
  *                                                                                             * 
  * INPUT:   house    -- The owner of this reinforcement.                                       * 
  *                                                                                             * 
  *          type     -- The object to bring on.                                                * 
  *                                                                                             * 
  *          another  -- This is reserved for the transport class in those cases where the      * 
  *                      transport MUST be forced to a specific type.                           * 
  *                                                                                             * 
  *          mission  -- The mission to assign this reinforcement team.                         * 
  *                                                                                             * 
  *          argument -- Optional team mission argument (usually a waypoint).                   * 
  *                                                                                             * 
  * OUTPUT:  Was the special reinforcement created without error?                               * 
  *                                                                                             * 
  * WARNINGS:   This routine will fail if a team type cannot be created.                        * 
  *                                                                                             * 
  * HISTORY:                                                                                    * 
  *   07/04/1995 JLB : Created.                                                                 * 
  *=============================================================================================*/
 bool Create_Special_Reinforcement(HouseClass * house, TechnoTypeClass const * type, TechnoTypeClass const * another, TeamMissionType mission, int argument)
 {
 	if (house && type) {
 		TeamTypeClass * team = new TeamTypeClass();
 
 		if (team) {
 
 			/*
 			**	If a ground based reinforcement is desired, but the edge of the map that the
 			**	reinforcement will arrive at is completely covered with water, then add
 			**	a hover lander for transport.
 			*/
 			if (!another && (type->What_Am_I() == RTTI_UNITTYPE || type->What_Am_I() == RTTI_INFANTRYTYPE)) {
 
 				/*
 				**	Hover lander reinforcements can only arrive from the south. Yes, this is an
 				**	arbitrary limitation, but that's the way it is (for now).
 				*/
 				if (house->Edge == SOURCE_SOUTH) {
 					bool found = false;
 					for (int index = Map.MapCellX; index < Map.MapCellX+Map.MapCellWidth-1; index++) {
 						CELL cell = XY_Cell(index, Map.MapCellY+Map.MapCellHeight);
 						if (Map[cell].Is_Generally_Clear() && Map[cell-MAP_CELL_W].Is_Generally_Clear()) {
 							found = true;
 							break;
 						}
 					}
 
 					/*
 					**	No land route was found for the reinforcement to drive itself onto the
 					**	map. Assign it a hover lander. This presumes that if the south edge is
 					**	non drivable, it will have water there instead. Risky, but is not a 
 					**	problem with the current C&C maps.
 					*/
 					if (!found) {
 						mission = TMISSION_NONE;
 						another = &UnitTypeClass::As_Reference(UNIT_HOVER);
 					}
 				}
 
 				if (!another) {
 					mission = TMISSION_MOVECELL;
 					argument = Map.Calculated_Cell(SOURCE_AIR, house->Class->House);
 				}
 			}
 
 			/*
 			**	If there is no overridden mission assign to this special reinforcement, then
 			**	we must assign something. If not, the reinforcement will just sit at the edge
 			**	of the map.
 			*/
 			if (!another && mission == TMISSION_NONE) {
 				mission = TMISSION_MOVECELL;
 				argument = Map.Calculated_Cell(SOURCE_AIR, house->Class->House);
 			}
 
 			/*
 			**	Fill in the team characteristics.
 			*/
 			strcpy((char *)&team->IniName[0], "TEMP");
 			team->IsReinforcable = false;
 			team->IsTransient = true;
 			team->ClassCount = 1;
 			team->Class[0] = type;
 			team->DesiredNum[0] = 1;
 			team->MissionCount = 1;
 			if (mission == TMISSION_NONE) {
 				if (another && (another->What_Am_I() != RTTI_UNITTYPE || ((UnitTypeClass const *)another)->Type != UNIT_HOVER)) {
 					team->MissionList[0].Mission	= TMISSION_UNLOAD;
 					team->MissionList[0].Argument = WAYPT_REINF;
 				}
 			} else {
 				team->MissionList[0].Mission	= mission;
 				team->MissionList[0].Argument = argument;
 			}
 			team->House = house->Class->House;
 			if (another) {
 				team->ClassCount++;
 				team->Class[1] = another;
 				team->DesiredNum[1] = 1;
 			}
 
 			bool ok = Do_Reinforcements(team);
 			if (!ok && GameToPlay == GAME_NORMAL) {
 				delete team;
 			}
 			return(ok);
 		}
 	}
 	return(false);
 }
 
 
 /*********************************************************************************************** 
  * Create_Air_Reinforcement -- Creates air strike reinforcement                                * 
  *                                                                                             * 
  *    This routine is used to launch an airstrike. It will create the necessary aircraft and   * 
  *    assign them to attack the target specified. This routine bypasses the normal             * 
  *    reinforcement logic since it doesn't need the sophistication of unloading and following  * 
  *    team mission lists.                                                                      * 
  *                                                                                             * 
  * INPUT:   house    -- The purpetrator of this air strike.                                    * 
  *                                                                                             * 
  *          air      -- The type of aircraft to make up this airstrike.                        * 
  *                                                                                             * 
  *          number   -- The number of aircraft in this airstrike.                              * 
  *                                                                                             * 
  *          mission  -- The mission to assign the aircraft.                                    * 
  *                                                                                             * 
  *          tarcom   -- The target to assign these aircraft.                                   * 
  *                                                                                             * 
  *          navcom   -- The navigation target to assign (if necessary).                        * 
  *                                                                                             * 
  * OUTPUT:  Returns the number of aircraft created for this airstrike.                         * 
  *                                                                                             * 
  * WARNINGS:   none                                                                            * 
  *                                                                                             * 
  * HISTORY:                                                                                    * 
  *   07/04/1995 JLB : Commented.                                                               * 
  *=============================================================================================*/
 int Create_Air_Reinforcement(HouseClass *house, AircraftType air, int number, MissionType mission, TARGET tarcom, TARGET navcom)
 {
 	/*
 	** Get a pointer to the class of the object that we are going to create.
 	*/
 	TechnoTypeClass const * type = (TechnoTypeClass *)&AircraftTypeClass::As_Reference(air);
 
 	/*
 	** Loop through the number of objects we are supposed to create and
 	** 	create and place them on the map.
 	*/
 	int sub;
 	for (sub = 0; sub < number; sub++) {
 
 		/*
 		** Create one of the required objects.  If this fails we could have
 		** a real problem.
 		*/
 		ScenarioInit++;
 		TechnoClass * obj = (TechnoClass *)type->Create_One_Of(house);
 		ScenarioInit--;
 		if (!obj) return(sub);
 
 		/*
 		** Flying objects always have the IsALoaner bit set.
 		*/
 		obj->IsALoaner = true;
 
 		/* 
 		** Find a cell for the object to come in on.  This is stolen from the
 		** the code that handles a SOURCE_AIR in the normal logic.
 		*/
 		SourceType source = house->Edge;
 		switch (source) {
 			case SOURCE_NORTH:
 			case SOURCE_EAST:
 			case SOURCE_SOUTH:
 			case SOURCE_WEST:
 				break;
 
 			default:
 				source = SOURCE_NORTH;
 				break;
 		}
 		CELL newcell = Map.Calculated_Cell(source, house->Class->House);
 
 		/* 
 		** Try and place the object onto the map.
 		*/
 		ScenarioInit++;
 		int placed = obj->Unlimbo(Cell_Coord(newcell), DIR_N);
 		ScenarioInit--;
 		if (placed) {
 
 			/*
 			** If we suceeded in placing the obj onto the map then
 			** now we need to give it a mission and destination.
 			*/
 			obj->Assign_Mission(mission);
 
 			/*
 			** If a navcom was specified then set it.
 			*/
 			if (navcom != TARGET_NONE) {
 				obj->Assign_Destination(navcom);
 			}
 
 			/*
 			** If a tarcom was specified then set it.
 			*/
 			if (tarcom != TARGET_NONE) {
 				obj->Assign_Target(tarcom);
 			}
 
 			/*
 			** Start the object into action.
 			*/
 			obj->Commence();
 		} else {
 			delete obj;
 			sub--;
 			return(sub);
 		}
 	}
 	return(sub);
 }