thirdpartymirrors/RingRacers
1
0
Fork 0
mirror of https://github.com/KartKrewDev/RingRacers.git synced 2025-10-30 08:01:28 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

New turning towards objects style

Browse source
This commit is contained in:
Sally Coolatta 2021-02-26 01:58:13 -05:00
parent 5ac116dc12
commit 43a92892e9
3 changed files with 109 additions and 130 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
src/k_bot.c
View file

@ -936,6 +936,9 @@ void K_BuildBotTiccmd(player_t *player, ticcmd_t *cmd)
else else
{ {
predict = K_CreateBotPrediction(player); predict = K_CreateBotPrediction(player);
K_NudgePredictionTowardsObjects(predict, player);
destangle = R_PointToAngle2(player->mo->x, player->mo->y, predict->x, predict->y); destangle = R_PointToAngle2(player->mo->x, player->mo->y, predict->x, predict->y);
} }
@ -1033,11 +1036,6 @@ void K_BuildBotTiccmd(player_t *player, ticcmd_t *cmd)
cmd->forwardmove /= 2; cmd->forwardmove /= 2;
cmd->buttons |= BT_BRAKE; cmd->buttons |= BT_BRAKE;
} }
else if (dirdist <= realrad)
{
// Steer towards/away from objects!
turnamt += K_BotFindObjects(player, turnamt);
}
} }
} }

4
src/k_bot.h
View file

@ -198,7 +198,7 @@ fixed_t K_BotReducePrediction(player_t *player);
/*-------------------------------------------------- /*--------------------------------------------------
INT16 K_BotFindObjects(player_t *player, INT16 turn); void K_NudgePredictionTowardsObjects(botprediction_t *predict, player_t *player);
Generates a sum for objects to steer towards/away from. Generates a sum for objects to steer towards/away from.
@ -210,7 +210,7 @@ fixed_t K_BotReducePrediction(player_t *player);
Turn amount sum to add to final product. Turn amount sum to add to final product.
--------------------------------------------------*/ --------------------------------------------------*/
INT16 K_BotFindObjects(player_t *player, INT16 turn); void K_NudgePredictionTowardsObjects(botprediction_t *predict, player_t *player);
/*-------------------------------------------------- /*--------------------------------------------------

227
src/k_botsearch.c
View file

@ -31,12 +31,16 @@
struct globalsmuggle struct globalsmuggle
{ {
mobj_t *botmo; mobj_t *botmo;
botprediction_t *predict;
fixed_t distancetocheck; fixed_t distancetocheck;
fixed_t closestlinedist; INT64 gotoAvgX, gotoAvgY;
UINT32 gotoObjs;
INT16 curturn; INT64 avoidAvgX, avoidAvgY;
INT16 steer; UINT32 avoidObjs;
fixed_t closestlinedist;
fixed_t eggboxx, eggboxy; fixed_t eggboxx, eggboxy;
UINT8 randomitems; UINT8 randomitems;
@ -419,83 +423,7 @@ fixed_t K_BotReducePrediction(player_t *player)
} }
/*-------------------------------------------------- /*--------------------------------------------------
static void K_SteerFromObject(mobj_t *bot, mobj_t *thing, fixed_t fulldist, fixed_t xdist, boolean towards, INT16 amount) static boolean K_FindObjectsForNudging(mobj_t *thing)
Handles steering away/towards the specified object.
Input Arguments:-
bot - Bot's mobj.
thing - Mobj to steer towards/away from.
fulldist - Distance away from object.
xdist - Horizontal distance away from object.
towards - If true, steer towards the object. Otherwise, steer away.
amount - How hard to turn.
Return:-
None
--------------------------------------------------*/
static void K_SteerFromObject(mobj_t *bot, mobj_t *thing, fixed_t fulldist, fixed_t xdist, boolean towards, INT16 amount)
{
angle_t destangle = R_PointToAngle2(bot->x, bot->y, thing->x, thing->y);
angle_t angle;
SINT8 flip = 1;
amount = (amount * FixedDiv(globalsmuggle.distancetocheck - fulldist, globalsmuggle.distancetocheck)) / FRACUNIT;
if (amount == 0)
{
// Shouldn't happen
return;
}
if (towards)
{
if (xdist < FixedHypot(bot->radius, thing->radius))
{
// Don't need to turn any harder!
if (abs(globalsmuggle.steer) <= amount)
{
globalsmuggle.steer = 0;
}
else
{
if (globalsmuggle.steer > 0)
{
globalsmuggle.steer -= amount;
}
else if (globalsmuggle.steer < 0)
{
globalsmuggle.steer += amount;
}
}
return;
}
// Still turning towards it, flip.
flip = -flip;
}
angle = (bot->angle - destangle);
if (angle < ANGLE_180)
{
flip = -flip;
}
// If going in the opposite direction of where you wanted to turn,
// then reduce the amount that you can turn in that direction.
if ((flip == 1 && globalsmuggle.curturn < 0)
|| (flip == -1 && globalsmuggle.curturn > 0))
{
amount /= 4;
}
globalsmuggle.steer += amount * flip;
}
/*--------------------------------------------------
static boolean K_BotSteerObjects(mobj_t *thing)
Blockmap search function. Blockmap search function.
Finds objects around the bot to steer towards/away from. Finds objects around the bot to steer towards/away from.
@ -506,20 +434,18 @@ static void K_SteerFromObject(mobj_t *bot, mobj_t *thing, fixed_t fulldist, fixe
Return:- Return:-
true continues searching, false ends the search early. true continues searching, false ends the search early.
--------------------------------------------------*/ --------------------------------------------------*/
static boolean K_BotSteerObjects(mobj_t *thing) static boolean K_FindObjectsForNudging(mobj_t *thing)
{ {
INT16 anglediff; INT16 anglediff;
fixed_t xdist, ydist, fulldist; fixed_t fulldist;
angle_t destangle, angle; angle_t destangle, angle, predictangle;
INT16 attack = ((9 - globalsmuggle.botmo->player->kartspeed) * KART_FULLTURN) / 8; // Acceleration chars are more aggressive
INT16 dodge = ((9 - globalsmuggle.botmo->player->kartweight) * KART_FULLTURN) / 8; // Handling chars dodge better
if (!globalsmuggle.botmo || P_MobjWasRemoved(globalsmuggle.botmo) || !globalsmuggle.botmo->player) if (!globalsmuggle.botmo || P_MobjWasRemoved(globalsmuggle.botmo) || !globalsmuggle.botmo->player)
{ {
return false; return false;
} }
if (!thing->health) if (thing->health <= 0)
{ {
return true; return true;
} }
@ -529,19 +455,7 @@ static boolean K_BotSteerObjects(mobj_t *thing)
return true; return true;
} }
xdist = K_DistanceOfLineFromPoint( fulldist = R_PointToDist2(globalsmuggle.predict->x, globalsmuggle.predict->y, thing->x, thing->y);
globalsmuggle.botmo->x, globalsmuggle.botmo->y,
globalsmuggle.botmo->x + FINECOSINE(globalsmuggle.botmo->angle >> ANGLETOFINESHIFT), globalsmuggle.botmo->y + FINESINE(globalsmuggle.botmo->angle >> ANGLETOFINESHIFT),
thing->x, thing->y
) / 2; // weight x dist more heavily than y dist
ydist = K_DistanceOfLineFromPoint(
globalsmuggle.botmo->x, globalsmuggle.botmo->y,
globalsmuggle.botmo->x + FINECOSINE((globalsmuggle.botmo->angle + ANGLE_90) >> ANGLETOFINESHIFT), globalsmuggle.botmo->y + FINESINE((globalsmuggle.botmo->angle + ANGLE_90) >> ANGLETOFINESHIFT),
thing->x, thing->y
);
fulldist = FixedHypot(xdist, ydist);
if (fulldist > globalsmuggle.distancetocheck) if (fulldist > globalsmuggle.distancetocheck)
{ {
@ -553,8 +467,9 @@ static boolean K_BotSteerObjects(mobj_t *thing)
return true; return true;
} }
predictangle = R_PointToAngle2(globalsmuggle.botmo->x, globalsmuggle.botmo->y, globalsmuggle.predict->x, globalsmuggle.predict->y);
destangle = R_PointToAngle2(globalsmuggle.botmo->x, globalsmuggle.botmo->y, thing->x, thing->y); destangle = R_PointToAngle2(globalsmuggle.botmo->x, globalsmuggle.botmo->y, thing->x, thing->y);
angle = (globalsmuggle.botmo->angle - destangle); angle = (predictangle - destangle);
if (angle < ANGLE_180) if (angle < ANGLE_180)
{ {
@ -567,14 +482,24 @@ static boolean K_BotSteerObjects(mobj_t *thing)
anglediff = abs(anglediff); anglediff = abs(anglediff);
#define AddAttackObj(thing) \
globalsmuggle.gotoAvgX += thing->x / mapobjectscale; \
globalsmuggle.gotoAvgY += thing->y / mapobjectscale; \
globalsmuggle.gotoObjs++;
#define AddDodgeObj(thing) \
globalsmuggle.avoidAvgX += thing->x / mapobjectscale; \
globalsmuggle.avoidAvgY += thing->y / mapobjectscale; \
globalsmuggle.avoidObjs++;
#define PlayerAttackSteer(botcond, thingcond) \ #define PlayerAttackSteer(botcond, thingcond) \
if ((botcond) && !(thingcond)) \ if ((botcond) && !(thingcond)) \
{ \ { \
K_SteerFromObject(globalsmuggle.botmo, thing, fulldist, xdist, true, 2 * (KART_FULLTURN + attack)); \ AddAttackObj(thing) \
} \ } \
else if ((thingcond) && !(botcond)) \ else if ((thingcond) && !(botcond)) \
{ \ { \
K_SteerFromObject(globalsmuggle.botmo, thing, fulldist, xdist, false, 2 * (KART_FULLTURN + dodge)); \ AddDodgeObj(thing) \
} }
switch (thing->type) switch (thing->type)
@ -593,7 +518,7 @@ static boolean K_BotSteerObjects(mobj_t *thing)
case MT_BALLHOG: case MT_BALLHOG:
case MT_SPB: case MT_SPB:
case MT_BUBBLESHIELDTRAP: case MT_BUBBLESHIELDTRAP:
K_SteerFromObject(globalsmuggle.botmo, thing, fulldist, xdist, false, 2 * (KART_FULLTURN + dodge)); AddDodgeObj(thing)
break; break;
case MT_RANDOMITEM: case MT_RANDOMITEM:
if (anglediff >= 60) if (anglediff >= 60)
@ -603,7 +528,7 @@ static boolean K_BotSteerObjects(mobj_t *thing)
if (P_CanPickupItem(globalsmuggle.botmo->player, 1)) if (P_CanPickupItem(globalsmuggle.botmo->player, 1))
{ {
K_SteerFromObject(globalsmuggle.botmo, thing, fulldist, xdist, true, KART_FULLTURN + attack); AddAttackObj(thing)
} }
break; break;
case MT_EGGMANITEM: case MT_EGGMANITEM:
@ -619,11 +544,11 @@ static boolean K_BotSteerObjects(mobj_t *thing)
if (stealth >= requiredstealth) if (stealth >= requiredstealth)
{ {
K_SteerFromObject(globalsmuggle.botmo, thing, fulldist, xdist, true, 2 * (KART_FULLTURN + attack)); AddAttackObj(thing)
} }
else else
{ {
K_SteerFromObject(globalsmuggle.botmo, thing, fulldist, xdist, false, 2 * (KART_FULLTURN + dodge)); AddDodgeObj(thing)
} }
} }
break; break;
@ -635,7 +560,7 @@ static boolean K_BotSteerObjects(mobj_t *thing)
if (P_CanPickupItem(globalsmuggle.botmo->player, 3)) if (P_CanPickupItem(globalsmuggle.botmo->player, 3))
{ {
K_SteerFromObject(globalsmuggle.botmo, thing, fulldist, xdist, true, KART_FULLTURN + attack); AddAttackObj(thing)
} }
break; break;
case MT_RING: case MT_RING:
@ -650,11 +575,7 @@ static boolean K_BotSteerObjects(mobj_t *thing)
&& !thing->extravalue1 && !thing->extravalue1
&& (globalsmuggle.botmo->player->kartstuff[k_itemtype] != KITEM_THUNDERSHIELD)) && (globalsmuggle.botmo->player->kartstuff[k_itemtype] != KITEM_THUNDERSHIELD))
{ {
K_SteerFromObject(globalsmuggle.botmo, thing, fulldist, xdist, true, AddAttackObj(thing)
(RINGTOTAL(globalsmuggle.botmo->player) < 3
? (4 * (KART_FULLTURN + attack))
: (KART_FULLTURN + attack))
);
} }
break; break;
case MT_PLAYER: case MT_PLAYER:
@ -716,11 +637,11 @@ static boolean K_BotSteerObjects(mobj_t *thing)
if (weightdiff > mapobjectscale) if (weightdiff > mapobjectscale)
{ {
K_SteerFromObject(globalsmuggle.botmo, thing, fulldist, xdist, true, KART_FULLTURN + attack); AddAttackObj(thing)
} }
else else
{ {
K_SteerFromObject(globalsmuggle.botmo, thing, fulldist, xdist, false, KART_FULLTURN + dodge); AddDodgeObj(thing)
} }
} }
} }
@ -733,16 +654,16 @@ static boolean K_BotSteerObjects(mobj_t *thing)
if (thing->extravalue1 == 0) if (thing->extravalue1 == 0)
{ {
K_SteerFromObject(globalsmuggle.botmo, thing, fulldist, xdist, false, thing->extravalue2 * (KART_FULLTURN + dodge)); AddDodgeObj(thing)
} }
{ {
K_SteerFromObject(globalsmuggle.botmo, thing, fulldist, xdist, true, thing->extravalue2 * (KART_FULLTURN + attack)); AddAttackObj(thing)
} }
break; break;
default: default:
if (thing->flags & (MF_SOLID|MF_ENEMY|MF_BOSS|MF_PAIN|MF_MISSILE)) if (thing->flags & (MF_SOLID|MF_ENEMY|MF_BOSS|MF_PAIN|MF_MISSILE))
{ {
K_SteerFromObject(globalsmuggle.botmo, thing, fulldist, xdist, false, 2 * (KART_FULLTURN + dodge)); AddDodgeObj(thing)
} }
break; break;
} }
@ -751,19 +672,31 @@ static boolean K_BotSteerObjects(mobj_t *thing)
} }
/*-------------------------------------------------- /*--------------------------------------------------
INT16 K_BotFindObjects(player_t *player, INT16 turn) void K_NudgePredictionTowardsObjects(botprediction_t *predict, player_t *player)
See header file for description. See header file for description.
--------------------------------------------------*/ --------------------------------------------------*/
INT16 K_BotFindObjects(player_t *player, INT16 turn) void K_NudgePredictionTowardsObjects(botprediction_t *predict, player_t *player)
{ {
INT32 xl, xh, yl, yh, bx, by; INT32 xl, xh, yl, yh, bx, by;
globalsmuggle.steer = 0; const fixed_t baseNudge = 8 * mapobjectscale;
fixed_t avgX = 0, avgY = 0;
fixed_t avgDist = 0;
fixed_t nudgeDist = 0;
angle_t nudgeDir = 0;
globalsmuggle.botmo = player->mo; globalsmuggle.botmo = player->mo;
globalsmuggle.curturn = turn; globalsmuggle.predict = predict;
globalsmuggle.distancetocheck = (player->mo->radius * 32) + (player->speed * 4); globalsmuggle.distancetocheck = (player->mo->radius * 32) + (player->speed * 4);
globalsmuggle.gotoAvgX = globalsmuggle.gotoAvgY = 0;
globalsmuggle.gotoObjs = 0;
globalsmuggle.avoidAvgX = globalsmuggle.avoidAvgY = 0;
globalsmuggle.avoidObjs = 0;
xl = (unsigned)(globalsmuggle.botmo->x - globalsmuggle.distancetocheck - bmaporgx)>>MAPBLOCKSHIFT; xl = (unsigned)(globalsmuggle.botmo->x - globalsmuggle.distancetocheck - bmaporgx)>>MAPBLOCKSHIFT;
xh = (unsigned)(globalsmuggle.botmo->x + globalsmuggle.distancetocheck - bmaporgx)>>MAPBLOCKSHIFT; xh = (unsigned)(globalsmuggle.botmo->x + globalsmuggle.distancetocheck - bmaporgx)>>MAPBLOCKSHIFT;
yl = (unsigned)(globalsmuggle.botmo->y - globalsmuggle.distancetocheck - bmaporgy)>>MAPBLOCKSHIFT; yl = (unsigned)(globalsmuggle.botmo->y - globalsmuggle.distancetocheck - bmaporgy)>>MAPBLOCKSHIFT;
@ -775,9 +708,57 @@ INT16 K_BotFindObjects(player_t *player, INT16 turn)
{ {
for (by = yl; by <= yh; by++) for (by = yl; by <= yh; by++)
{ {
P_BlockThingsIterator(bx, by, K_BotSteerObjects); P_BlockThingsIterator(bx, by, K_FindObjectsForNudging);
} }
} }
return globalsmuggle.steer; if (globalsmuggle.avoidObjs > 0)
{
avgX = (globalsmuggle.avoidAvgX / globalsmuggle.avoidObjs) * mapobjectscale;
avgY = (globalsmuggle.avoidAvgY / globalsmuggle.avoidObjs) * mapobjectscale;
avgDist = R_PointToDist2(
globalsmuggle.avoidAvgX, globalsmuggle.avoidAvgY,
predict->x, predict->y
);
nudgeDist = ((9 - globalsmuggle.botmo->player->kartweight) + 1) * baseNudge;
nudgeDir = R_PointToAngle2(
globalsmuggle.avoidAvgX, globalsmuggle.avoidAvgY,
predict->x, predict->y
);
predict->x += FixedMul(nudgeDist, FINECOSINE(nudgeDir >> ANGLETOFINESHIFT));
predict->y += FixedMul(nudgeDist, FINESINE(nudgeDir >> ANGLETOFINESHIFT));
}
if (globalsmuggle.gotoObjs > 0)
{
avgX = (globalsmuggle.gotoAvgX / globalsmuggle.gotoObjs) * mapobjectscale;
avgY = (globalsmuggle.gotoAvgY / globalsmuggle.gotoObjs) * mapobjectscale;
avgDist = R_PointToDist2(
predict->x, predict->y,
globalsmuggle.gotoAvgX, globalsmuggle.gotoAvgY
);
nudgeDist = ((9 - globalsmuggle.botmo->player->kartspeed) + 1) * baseNudge;
if (avgDist <= nudgeDist)
{
predict->x = avgX;
predict->y = avgY;
}
else
{
nudgeDir = R_PointToAngle2(
predict->x, predict->y,
globalsmuggle.gotoAvgX, globalsmuggle.gotoAvgY
);
predict->x += FixedMul(nudgeDist, FINECOSINE(nudgeDir >> ANGLETOFINESHIFT));
predict->y += FixedMul(nudgeDist, FINESINE(nudgeDir >> ANGLETOFINESHIFT));
}
}
} }