void DDDFrigateAttack(Ship *ship,SpaceObjRotImpTarg *target,real32 maxdist)
{
ShipStaticInfo *shipstatic = (ShipStaticInfo *)ship->staticinfo;
DDDFrigateStatics *dddstatics = (DDDFrigateStatics *)shipstatic->custstatinfo;
DDDFrigateSpec *spec = (DDDFrigateSpec *)ship->ShipSpecifics;
vector trajectory;
real32 range;
bool inRange = FALSE;
aishipGetTrajectory(ship,target,&trajectory);
range = RangeToTarget(ship,target,&trajectory);
if (range > dddstatics->attackRange)
{
// too far away, so fly in
aishipFlyToShipAvoidingObjsWithVel(ship,target,AISHIP_FirstPointInDirectionFlying+AISHIP_PointInDirectionFlying+AISHIP_CarTurn+AISHIP_FastAsPossible,0.0f,&target->posinfo.velocity);
}
else if (range > dddstatics->tooCloseRange)
{
// about right range
aishipFlyToShipAvoidingObjsWithVel(ship,target,AISHIP_FirstPointInDirectionFlying+AISHIP_PointInDirectionFlying+AISHIP_CarTurn+AISHIP_FastAsPossible,0.0f,&target->posinfo.velocity);
inRange = TRUE;
}
else
{
// too close
aitrackZeroVelocity(ship);
inRange = TRUE;
}
if ((inRange) && (spec->DDDstate == DDDSTATE_ALLINSIDE))
{
DDDFrigateSpecialActivate(ship);
}
}
void P2MultiBeamFrigateAttackDoAttack(Ship *ship,SpaceObjRotImpTarg *target,real32 maxdist,bool PassiveAttack)
{
ShipStaticInfo *shipstaticinfo = (ShipStaticInfo *)ship->staticinfo;
P2MultiBeamFrigateStatics *frigstat = (P2MultiBeamFrigateStatics *)shipstaticinfo->custstatinfo;
P2MultiBeamFrigateSpec *spec = (P2MultiBeamFrigateSpec *)ship->ShipSpecifics;
vector trajectory;
vector shipRightVec;
real32 range;
spec->aiattacklast = universe.totaltimeelapsed;
ship->autostabilizeship = FALSE;
aishipGetTrajectory(ship, target, &trajectory);
range = RangeToTarget(ship,target,&trajectory);
if (range > frigstat->MultiBeamRange[ship->tacticstype])
{
//not in range
if(!PassiveAttack)
{
//do aiship fly to stuff here
//if not in range...fly to the ship
//else track zero velocity
aishipFlyToShipAvoidingObjs(ship,target,AISHIP_PointInDirectionFlying + AISHIP_CarTurn,0.0f);
}
return;
}
//we are in range
vecNormalize(&trajectory);
if(!PassiveAttack)
{
aitrackZeroVelocity(ship);
}
matGetVectFromMatrixCol2(shipRightVec,ship->rotinfo.coordsys);
aitrackHeadingAndUp(ship,&trajectory,&shipRightVec,0.9999f);
if(vecMagnitudeSquared(ship->rotinfo.rotspeed) > frigstat->AttackRotationSpeed)
{
if(aitrackHeadingWithFlags(ship,&trajectory,0.99f,AITRACKHEADING_IGNOREUPVEC|AITRACK_DONT_ZERO_ME))
{
//rotation speed reached
//lets fire guns if we can
P2MultiBeamFrigateFire(ship,target);
}
}
}
void DDDFrigatePassiveAttack(Ship *ship,Ship *target,bool rotate)
{
DDDFrigateStatics *dddstatics = (DDDFrigateStatics *)ship->staticinfo->custstatinfo;
DDDFrigateSpec *spec = (DDDFrigateSpec *)ship->ShipSpecifics;
vector trajectory;
real32 range;
if (spec->DDDstate == DDDSTATE_ALLINSIDE)
{
aishipGetTrajectory(ship,(SpaceObjRotImpTarg *)target,&trajectory);
range = RangeToTarget(ship,(SpaceObjRotImpTarg *)target,&trajectory);
if (range <= dddstatics->attackRange)
{
DDDFrigateSpecialActivate(ship);
}
}
}
void DefenseFighterAttack(Ship *ship,SpaceObjRotImpTarg *target,real32 maxdist)
{
vector trajectory;
real32 range;
aishipGetTrajectory(ship,target,&trajectory);
range = RangeToTarget(ship,target,&trajectory);
if (range < 1000.0f)
{
aitrackZeroVelocity(ship);
vecNormalize(&trajectory);
aitrackHeading(ship,&trajectory,0.9999f);
}
else
{
aishipFlyToPointAvoidingObjs(ship,&target->posinfo.position,AISHIP_PointInDirectionFlying,0.0f);
}
}
void P2MultiBeamFrigateAttackPassive(Ship *ship,Ship *target,bool rotate)
{
ShipStaticInfo *shipstaticinfo = (ShipStaticInfo *)ship->staticinfo;
P2MultiBeamFrigateSpec *spec = (P2MultiBeamFrigateSpec *)ship->ShipSpecifics;
P2MultiBeamFrigateStatics *frigstat = (P2MultiBeamFrigateStatics *)shipstaticinfo->custstatinfo;
vector trajectory;
vector heading, temp;
real32 range;
P2MultiBeamFrigateAttackDoAttack(ship,(SpaceObjRotImpTarg *)target,1000.0f,TRUE);
return;
aishipGetTrajectory(ship, (SpaceObjRotImpTarg *)target, &trajectory);
range = RangeToTarget(ship,(SpaceObjRotImpTarg *)target,&trajectory);
if ( (range < frigstat->MultiBeamRange[ship->tacticstype]) && (rotate) )
{
temp = trajectory;
temp.z+=5;
temp.y+=5;
temp.x+=5;
vecCrossProduct(heading,trajectory,temp);
vecNormalize(&heading);
vecNormalize(&trajectory);
if (aitrackHeadingAndUp(ship,&heading,&trajectory,0.99f))
{
if (!spec->steady) aitrackForceHeading(ship,&heading,&trajectory);
spec->steady = TRUE;
}
else
spec->steady = FALSE;
}
shipstaticinfo->custshipheader.CustShipFire(ship, (SpaceObjRotImpTarg *)target);
}
void MineLayerAttackRun(Ship *ship,SpaceObjRotImpTarg *target,AttackSideStep *attacksidestep,AttackSideStepParameters *parameters)
{
vector trajectory;
//real32 dist;
real32 range;
//real32 temp;
// bool didshoot;
ShipStaticInfo *shipstaticinfo = (ShipStaticInfo *)ship->staticinfo;
Gun *gun;
udword numGuns,target_class;
GunInfo *guninfo = ship->gunInfo;
//vector tmpvec;
//real32 randegf;
//sdword randeg;
//matrix tmpmat;
//vector targetheading;
MinelayerCorvetteSpec *spec = (MinelayerCorvetteSpec *)ship->ShipSpecifics;
MinelayerCorvetteStatics *minelayercorvettestatics;
minelayercorvettestatics = (MinelayerCorvetteStatics *) ((ShipStaticInfo *)(ship->staticinfo))->custstatinfo;
numGuns = guninfo->numGuns;
gun = &guninfo->guns[0];
if(target != NULL)
{
if(target->objtype == OBJ_ShipType)
target_class = ((Ship *)target)->staticinfo->shipclass;
else
target_class = CLASS_NonCombat;
}
switch (ship->aistateattack)
{
case ATTACK_INIT:
case APPROACH:
#ifdef DEBUG_ATTACK
dbgMessagef("\nShip %x MINELAYER_ATTACK_APPROACH",(udword)ship);
#endif
aishipGetTrajectory(ship,target,&trajectory);
aishipFlyToShipAvoidingObjs(ship,target,AISHIP_PointInDirectionFlying,0.0f);
range = RangeToTarget(ship,target,&trajectory);
//lets check if we want to force drop...
if(target->objtype == OBJ_ShipType)
{
if(((Ship *)target)->shiptype == Mothership)
{
//its a mothership
vector tempvec;
real32 tempreal;
vecSub(tempvec,target->collInfo.collPosition,ship->collInfo.collPosition);
tempreal = vecMagnitudeSquared(tempvec);
if(tempreal < mothershipDistSqr)
{
//we're within range of force dropping!
ship->aistateattack = DROP_MOTHERSHIP;
}
break;
}
}
if (range < minelayercorvettestatics->breakInAwayDist)
{
ship->aistateattack = BREAKPOSITION;
spec->aivec.x = 0.0f;
spec->aivec.y = 0.0f;
spec->aivec.z = 0.0f;
}
break;
case DROP_MOTHERSHIP:
{
vector tempvec;
real32 tempreal;
vecSub(tempvec,ship->collInfo.collPosition,target->collInfo.collPosition);
tempreal = vecMagnitudeSquared(tempvec);
vecNormalize(&tempvec);
if(tempreal > mothershipDistSqr2)
{
ship->aistateattack = ATTACK_INIT;
}
if(aitrackHeadingWithFlags(ship,&tempvec,0.97f,AITRACKHEADING_IGNOREUPVEC))
{
if(MinelayerCorvetteStaticMineDrop(ship,target)) //problem...there will be other targets...bah..lets see..
{
MinelayerCorvetteOrderChangedCleanUp(ship);
}
}
break;
}
case BREAKPOSITION:
#ifdef DEBUG_ATTACK
dbgMessagef("\nShip %x BREAKPOSITION",(udword)ship);
#endif
aishipGetTrajectory(ship,target,&trajectory);
range = RangeToTarget(ship,target,&trajectory);
vecNormalize(&trajectory);
SetAIVecHeading(ship,target,&trajectory);
ship->aistateattack = BREAK1;
case BREAK1:
#ifdef DEBUG_ATTACK
dbgMessagef("\nShip %x BREAK1",(udword)ship);
#endif
aishipGetTrajectory(ship,target,&trajectory);
range = RangeToTarget(ship,target,&trajectory);
//aishipFlyToPointAvoidingObjs(ship,&spec->aivec,AISHIP_FastAsPossible | AISHIP_PointInDirectionFlying,INTERCEPTORBREAK_MINVELOCITY);
aishipFlyToPointAvoidingObjs(ship,&target->posinfo.position,AISHIP_FastAsPossible | AISHIP_PointInDirectionFlying,INTERCEPTORBREAK_MINVELOCITY);
if(range < minelayercorvettestatics->DropRange)
{
//temp
vecNormalize(&trajectory);
SetAIVecHeading(ship,target,&trajectory);
//temp
ship->aistateattack = KILL; //within mining range so start dropping
spec->aispheretime=0.0f; //reset time;
}
break;
case KILL:
#ifdef DEBUG_ATTACK
dbgMessagef("\nShip %x KILL",(udword)ship);
#endif
aishipGetTrajectory(ship,target,&trajectory);
range = RangeToTarget(ship,target,&trajectory);
spec->aispheretime += universe.phystimeelapsed;
if(gunCanShoot(ship, gun))
{
if(gun->numMissiles > 0)
{
spec->mineaistate = MINE_DROP_ATTACK;
MinelayerCorvetteFire(ship,target);
}
}
if(range > minelayercorvettestatics->DropStopRange)
{ //out of range....
ship->aistateattack = BREAK2;
}
if(spec->aispheretime > minelayercorvettestatics->Break2SphereizeFreq)
{ //time to sphereize;
spec->aivec.x =0.0f;
spec->aivec.y =0.0f;
spec->aivec.z =0.0f;
spec->aispheretime = -1000000.0f; // Reset, and never do again till next attack pass...
vecNormalize(&trajectory);
SetAIVecHeading(ship,target,&trajectory);
#ifdef DEBUG_ATTACK
dbgMessagef("\nShip %x KILL: Adjust for Break2 Sphereizing Godliness Maneuver :)",(udword)ship);
#endif
}
aishipFlyToPointAvoidingObjs(ship,&spec->aivec,AISHIP_FastAsPossible | AISHIP_PointInDirectionFlying,INTERCEPTORBREAK_MINVELOCITY);
break;
case BREAK2:
#ifdef DEBUG_ATTACK
dbgMessagef("\nShip %x BREAK2",(udword)ship);
#endif
aishipGetTrajectory(ship,target,&trajectory);
range = RangeToTarget(ship,target,&trajectory);
aishipFlyToPointAvoidingObjs(ship,&spec->aivec,AISHIP_FastAsPossible | AISHIP_PointInDirectionFlying,INTERCEPTORBREAK_MINVELOCITY);
if(range > minelayercorvettestatics->FlyAwayDist[target_class] ||
(MoveReachedDestinationVariable(ship,&spec->aivec,minelayercorvettestatics->FlyAwayTolerance)))
{ //turn around and start over
ship->aistateattack = APPROACH;
}
break;
default:
dbgAssert(FALSE);
break;
}
}
bool refuelRepairShips(Ship *ship, SelectAnyCommand *targets,real32 rangetoRefuel)
{
//remove unwantedships from this selection
//optimize by doing only once for this ship
SelectCommand selectOne;
sdword i;
SpaceObjRotImpTarg *target,*targettemp;
vector trajectory,curheading;
real32 range,dotprod;
CommandToDo *targetCommand;
//filter target list for unrepairable ships!
for(i=0;i<targets->numTargets;)
{
if(targets->TargetPtr[i]->objtype != OBJ_ShipType)
{
targets->numTargets--;
targets->TargetPtr[i] = targets->TargetPtr[targets->numTargets];
continue;
}
targetCommand = getShipAndItsCommand(&universe.mainCommandLayer,(Ship *)targets->TargetPtr[i]);
if(targetCommand != NULL)
{
if(targetCommand->ordertype.order == COMMAND_DOCK)
{
//remove docking ships from the list
if(((Ship *)targets->TargetPtr[i])->dockingship != NULL)
{
//only if in final stages
targets->numTargets--;
targets->TargetPtr[i] = targets->TargetPtr[targets->numTargets];
continue;
}
}
}
//object is a ship
if((((Ship *)targets->TargetPtr[i])->staticinfo->shipclass != CLASS_Fighter &&
((Ship *)targets->TargetPtr[i])->staticinfo->shipclass != CLASS_Corvette) ||
((Ship *)targets->TargetPtr[i])->playerowner != ship->playerowner)
{
if(ship->staticinfo->repairBeamCapable)
{
//repair corvette can repair capital ships!
//class doesn't matter
if(((Ship *)targets->TargetPtr[i])->playerowner == ship->playerowner)
{
//ship is not a fighter or a corvette, but is ours, so we can fix it!
i++;
continue;
}
}
targets->numTargets--;
targets->TargetPtr[i] = targets->TargetPtr[targets->numTargets];
}
else
{
i++;
}
}
if (targets->numTargets <= 0)
{
return TRUE;
}
target = targets->TargetPtr[0];
//need to add
//repairBeamCapable
// real32 healthPerSecond,CapitalDistanceRepairStart;
// real32 CapitalDistanceRepairStart2;
if(ship->staticinfo->repairBeamCapable)
{
//assume target is a ship!!!!
//targets might be a capital ship
if(((Ship *)target)->staticinfo->shipclass != CLASS_Fighter)
{
//target is such that it should be BEAM repaired!
//so lets fly upto it and ZAP repair it!
real32 range1,range2;
aishipGetTrajectory(ship,target,&trajectory);
range = RangeToTarget(ship,target,&trajectory);
vecNormalize(&trajectory);
aitrackHeading(ship,&trajectory,0.999f);
if(((Ship *)target)->shiptype == Mothership)
{
range1 = 2*ship->staticinfo->CapitalDistanceRepairStart;
range2 = 2*ship->staticinfo->CapitalDistanceRepairStart2;
}
else
{
range1 = ship->staticinfo->CapitalDistanceRepairStart;
range2 = ship->staticinfo->CapitalDistanceRepairStart2;
}
//we add 300 to the range checker for a sort of hysterysis!
if(range > range1)
{
aishipFlyToShipAvoidingObjs(ship,target,AISHIP_PointInDirectionFlying + AISHIP_FastAsPossible,0.0f);
if(range > range2)
{
//far enough away to stop the effect and ONLY fly towards ship
if(ship->rceffect != NULL)
{
//turn off ships effect
stopRepairEffect(ship);
}
return FALSE;
}
}
else
{
aitrackZeroVelocity(ship);
}
//in range to repair this li'l ship
matGetVectFromMatrixCol3(curheading,ship->rotinfo.coordsys);
dotprod = vecDotProduct(trajectory,curheading);
if(!areAllHealthy(ship,targets))
{
if(dotprod > ship->staticinfo->AngleDotProdThreshold)
{
//within angle of 'repair beam'
if(ship->rceffect == NULL)
{
//turn on effect if we should!
startRepairEffect(ship,target,&trajectory,range);
}
else
{
//fix up effect
ModifyRepairEffect(ship->rceffect,ship,&trajectory,range, target);
}
target->health+=ship->staticinfo->healthPerSecond*universe.phystimeelapsed;
if(((Ship *)target)->health > ((Ship *)target)->staticinfo->maxhealth)
{
if(ship->rceffect != NULL)
{
//turn off ships effect
stopRepairEffect(ship);
}
target->health = ((Ship *)target)->staticinfo->maxhealth;
//fix this in a bit
targettemp = targets->TargetPtr[0];
for(i=0;i<(targets->numTargets-1);i++)
{
targets->TargetPtr[i]=targets->TargetPtr[i+1];
}
targets->TargetPtr[targets->numTargets-1] = targettemp;
//if(targets->numTargets <= 0)
// return TRUE;
//targets->TargetPtr[0] = targets->TargetPtr[targets->numTargets];
return FALSE;
}
}
else
{
//not pointing at ship, turn off effect and other
//needed things!
if(ship->rceffect != NULL)
{
//turn off ships effect
stopRepairEffect(ship);
}
}
}
else
{
if(ship->rceffect != NULL)
{
//turn off ships effect
stopRepairEffect(ship);
}
}
return FALSE;
}
}
aishipGetTrajectory(ship,target,&trajectory);
aishipFlyToShipAvoidingObjs(ship,target,AISHIP_PointInDirectionFlying + AISHIP_FastAsPossible +AISHIP_FirstPointInDirectionFlying,0.0f);
range = RangeToTarget(ship,target,&trajectory);
if(range <= rangetoRefuel)
{
//within repair range
selectOne.numShips = 1;
selectOne.ShipPtr[0] = (Ship *) target;
if(target->objtype == OBJ_ShipType)
{
((Ship *)target)->fuel += 300.0f; //??? appropriate ammount?
if(((Ship *)target)->fuel > ((Ship *)target)->staticinfo->maxfuel)
((Ship *)target)->fuel = ((Ship *)target)->staticinfo->maxfuel;
//"speech event? Switching to Emergency Docking Fuel Supply?
//cldock
clDock(&universe.mainCommandLayer,&selectOne,DOCK_AT_SPECIFIC_SHIP,ship);
}
targets->numTargets--;
if(targets->numTargets <= 0)
return TRUE;
targets->TargetPtr[0] = targets->TargetPtr[targets->numTargets];
}
return FALSE;
}
void P2MultiBeamFrigateAttackDoAttack(Ship *ship,SpaceObjRotImpTarg *target,real32 maxdist,bool PassiveAttack)
{
ShipStaticInfo *shipstaticinfo = (ShipStaticInfo *)ship->staticinfo;
P2MultiBeamFrigateStatics *frigstat = (P2MultiBeamFrigateStatics *)shipstaticinfo->custstatinfo;
P2MultiBeamFrigateSpec *spec = (P2MultiBeamFrigateSpec *)ship->ShipSpecifics;
vector trajectory;
vector shipRightVec;
real32 range;
spec->aiattacklast = universe.totaltimeelapsed;
ship->autostabilizeship = FALSE;
aishipGetTrajectory(ship, target, &trajectory);
range = RangeToTarget(ship,target,&trajectory);
if (range > frigstat->MultiBeamRange[ship->tacticstype])
{
//not in range
if(!PassiveAttack)
{
//do aiship fly to stuff here
//if not in range...fly to the ship
//else track zero velocity
aishipFlyToShipAvoidingObjs(ship,target,AISHIP_PointInDirectionFlying + AISHIP_CarTurn,0.0f);
}
return;
}
//we are in range
vecNormalize(&trajectory);
if(!PassiveAttack)
{
aitrackZeroVelocity(ship);
}
matGetVectFromMatrixCol2(shipRightVec,ship->rotinfo.coordsys);
aitrackHeadingAndUp(ship,&trajectory,&shipRightVec,0.9999f);
if(vecMagnitudeSquared(ship->rotinfo.rotspeed) > frigstat->AttackRotationSpeed)
{
if(aitrackHeadingWithFlags(ship,&trajectory,0.99f,AITRACKHEADING_IGNOREUPVEC|AITRACK_DONT_ZERO_ME))
{
//rotation speed reached
//lets fire guns if we can
P2MultiBeamFrigateFire(ship,target);
}
}
/* OLD SCHOOL CODE */
/*
switch (ship->aistateattack)
{
case STATE_INIT:
// deliberatly fall through to state_approach
// spec->steady = FALSE;
ship->aistateattack=STATE_APPROACH;
case STATE_APPROACH:
#ifdef DEBUG_FRIGATEATTACK
dbgMessagef("\nShip %x STATE_APPROACH", (udword)ship);
#endif
if (spec->spining)
{
ship->aistateattack = STATE_SPINDOWN;
break;
}
aishipGetTrajectory(ship, target, &trajectory);
range = RangeToTarget(ship,target,&trajectory);
if (range < frigstat->MultiBeamRange[ship->tacticstype] || PassiveAttack)
{
temp = trajectory;
temp.z+=5;
temp.y+=5;
temp.x+=5;
//vecCrossProduct(heading,trajectory,temp);
//vecNormalize(&heading);
vecNormalize(&trajectory);
if(!PassiveAttack)
{
aitrackZeroVelocity(ship);
}
if (aitrackHeadingWithFlags(ship,&trajectory,0.99f,AITRACKHEADING_IGNOREUPVEC))
{
ship->aistateattack = STATE_SPINUP;
//get up vector
matGetVectFromMatrixCol1(temp,ship->rotinfo.coordsys);
aitrackForceHeading(ship,&trajectory,&temp);
}
}
else
{
aishipFlyToShipAvoidingObjs(ship,target,AISHIP_PointInDirectionFlying + AISHIP_CarTurn,0.0f);
}
break;
case STATE_SPINUP:
#ifdef DEBUG_FRIGATEATTACK
dbgMessagef("\nShip %x STATE_SPINUP", (udword)ship);
#endif
desiredrotspeed = frigstat->AttackRotationSpeed;
if(!PassiveAttack)
{
aitrackZeroVelocity(ship);
}
aitrackHeadingAndUp(ship,&heading,&shipRightVec,0.99f);
if (aitrackRotationSpeed(ship,desiredrotspeed,ROT_ABOUTZCCW))
{
ship->aistateattack = STATE_FIRE;
spec->spining = TRUE;
spec->aifirestarttime = universe.totaltimeelapsed + frigstat->BeamFireTime;
}
break;
case STATE_FIRE:
#ifdef DEBUG_FRIGATEATTACK
dbgMessagef("\nShip %x STATE_FIRE", (udword)ship);
#endif
shipstaticinfo->custshipheader.CustShipFire(ship, target);
if(!PassiveAttack)
{
aitrackZeroVelocity(ship);
}
aishipGetTrajectory(ship,target,&trajectory);
range = RangeToTarget(ship,target,&trajectory);
if (range > frigstat->MultiBeamRange[ship->tacticstype])
ship->aistateattack = STATE_INIT;
temp = trajectory;
temp.z+=5;
temp.y+=5;
temp.x+=5;
vecCrossProduct(heading,trajectory,temp);
vecNormalize(&heading);
vecNormalize(&trajectory);
//if (aitrackHeadingWithFlags(ship,&heading,0.99f,AITRACKHEADING_IGNOREUPVEC))
// {
// ship->aistateattack = STATE_INIT;
// }
desiredrotspeed = frigstat->AttackRotationSpeed;
aitrackRotationSpeed(ship,desiredrotspeed,ROT_ABOUTZCCW);
if(universe.totaltimeelapsed > spec->aifirestarttime)
{
//fire time up! start spindown
ship->aistateattack = STATE_SPINDOWN;
spec->aifirestarttime = universe.totaltimeelapsed + frigstat->fireDownTime;
}
break;
case STATE_SPINDOWN:
#ifdef DEBUG_FRIGATEATTACK
dbgMessagef("\nShip %x STATE_SPINDOWN", (udword)ship);
#endif
desiredrotspeed = 0;
if(!PassiveAttack)
{
aitrackZeroVelocity(ship);
}
if (aitrackRotationSpeed(ship,desiredrotspeed,ROT_ABOUTZCCW) &&
universe.totaltimeelapsed > spec->aifirestarttime)
{
ship->aistateattack = STATE_INIT;
spec->spining = FALSE;
}
break;
}
*/
}