hedgewars: comparison hedgewars/uAI.pas

equal deleted inserted replaced

-:5e4df5413e1e
+:8736f3a0ff7f
 end;
 const cBranchStackSize = 12;
 type TStackEntry = record
-WastedTicks: Longword;
 MadeActions: TActions;
 Hedgehog: TGear;
 end;
 var Stack: record
 Count: Longword;
 States: array[0..Pred(cBranchStackSize)] of TStackEntry;
 end;
-function Push(Ticks: Longword; const Actions: TActions; const Me: TGear; Dir: integer): boolean;
+function Push(const Actions: TActions; const Me: TGear; Dir: integer): boolean;
 var bRes: boolean;
 begin
 bRes:= (Stack.Count < cBranchStackSize) and (Actions.Count < MAXACTIONS - 5);
 if bRes then
 with Stack.States[Stack.Count] do
 begin
-WastedTicks:= Ticks;
 MadeActions:= Actions;
 Hedgehog:= Me;
 Hedgehog.Message:= Dir;
 inc(Stack.Count)
 end;
 Push:= bRes
 end;
-procedure Pop(var Ticks: Longword; var Actions: TActions; var Me: TGear);
+procedure Pop(var Actions: TActions; var Me: TGear);
 begin
 dec(Stack.Count);
 with Stack.States[Stack.Count] do
 begin
-Ticks:= WastedTicks;
 Actions:= MadeActions;
 Me:= Hedgehog
 end
 end;
 end;
 procedure Walk(Me: PGear; var Actions: TActions);
 const FallPixForBranching = cHHRadius;
 var
-ticks, maxticks, oldticks, steps, tmp: Longword;
+maxticks, oldticks, steps, tmp: Longword;
 BaseRate, BestRate, Rate: LongInt;
 GoInfo: TGoInfo;
 CanGo: boolean;
 AltMe: TGear;
 BotLevel: Byte;
 a: TAmmoType;
-begin
+isAfterAttack: boolean;
-ticks:= 0;
+begin
+Actions.ticks:= 0;
 oldticks:= 0; // avoid compiler hint
 Stack.Count:= 0;
 clearAllMarks;
 for a:= Low(TAmmoType) to High(TAmmoType) do
 CanUseAmmo[a]:= Assigned(AmmoTests[a].proc) and (HHHasAmmo(Me^.Hedgehog^, a) > 0);
 BotLevel:= Me^.Hedgehog^.BotLevel;
-if (Me^.State and gstAttacked) = 0 then
+isAfterAttack:= ((Me^.State and gstAttacked) <> 0) and ((GameFlags and gfInfAttack) = 0);
-maxticks:= Max(0, TurnTimeLeft - 5000 - LongWord(4000 * BotLevel))
+if isAfterAttack then
+maxticks:= Max(0, TurnTimeLeft - 500)
 else
-maxticks:= TurnTimeLeft;
+maxticks:= Max(0, TurnTimeLeft - 5000 - LongWord(4000 * BotLevel));
-if (Me^.State and gstAttacked) = 0 then
+if not isAfterAttack then
 TestAmmos(Actions, Me, false);
 BestRate:= RatePlace(Me);
 BaseRate:= Max(BestRate, 0);
 if ((CurrentHedgehog^.MultiShootAttacks = 0) or ((Ammoz[Me^.Hedgehog^.CurAmmoType].Ammo.Propz and ammoprop_NoMoveAfter) = 0))
 and (CurrentHedgehog^.Effects[heArtillery] = 0) and (cGravityf <> 0) then
 begin
 tmp:= random(2) + 1;
-Push(0, Actions, Me^, tmp);
+Push(Actions, Me^, tmp);
-Push(0, Actions, Me^, tmp xor 3);
+Push(Actions, Me^, tmp xor 3);
 while (Stack.Count > 0) and (not StopThinking) do
 begin
-Pop(ticks, Actions, Me^);
+Pop(Actions, Me^);
 AddAction(Actions, Me^.Message, aim_push, 250, 0, 0);
 if (Me^.Message and gmLeft) <> 0 then
 AddAction(Actions, aia_WaitXL, hwRound(Me^.X), 0, 0, 0)
 else
 while (not StopThinking) do
 begin
 {$HINTS OFF}
 CanGo:= HHGo(Me, @AltMe, GoInfo);
 {$HINTS ON}
-oldticks:= ticks;
+oldticks:= Actions.ticks;
-inc(ticks, GoInfo.Ticks);
+inc(Actions.ticks, GoInfo.Ticks);
-if ticks > maxticks then
+if (Actions.ticks > maxticks) or (TurnTimeLeft < BestActions.ticks + 5000) then
+begin
+if (BotLevel < 5)
+and (not isAfterAttack)
+and (BestActions.Score > 0) // we have a good move
+and (TurnTimeLeft < BestActions.ticks + 5000) // we won't have a lot of time after attack
+and (HHHasAmmo(Me^.Hedgehog^, amExtraTime) > 0) // but can use extra time
+then
+begin
+BestActions.Count:= 0;
+AddAction(BestActions, aia_Weapon, Longword(amExtraTime), 80, 0, 0);
+AddAction(BestActions, aia_attack, aim_push, 10, 0, 0);
+AddAction(BestActions, aia_attack, aim_release, 10, 0, 0);
+end;
 break;
+end;
 if (BotLevel < 5)
 and (GoInfo.JumpType = jmpHJump)
 and (not checkMark(hwRound(Me^.X), hwRound(Me^.Y), markHJumped))
 then // hjump support
 begin
 // check if we could go backwards and maybe ljump over a gap after this hjump
 addMark(hwRound(Me^.X), hwRound(Me^.Y), markHJumped);
-if Push(ticks, Actions, AltMe, Me^.Message xor 3) then
+if Push(Actions, AltMe, Me^.Message xor 3) then
 begin
 with Stack.States[Pred(Stack.Count)] do
 begin
 if (Me^.Message and gmLeft) <> 0 then
 AddAction(MadeActions, aia_LookRight, 0, 200, 0, 0)
 AddAction(MadeActions, aia_HJump, 0, 305 + random(50), 0, 0);
 AddAction(MadeActions, aia_HJump, 0, 350, 0, 0);
 end;
 // but first check walking forward
-Push(ticks, Stack.States[Pred(Stack.Count)].MadeActions, AltMe, Me^.Message)
+Push(Stack.States[Pred(Stack.Count)].MadeActions, AltMe, Me^.Message)
 end;
 end;
 if (BotLevel < 3)
 and (GoInfo.JumpType = jmpLJump)
 and (not checkMark(hwRound(Me^.X), hwRound(Me^.Y), markLJumped))
 then // ljump support
 begin
 addMark(hwRound(Me^.X), hwRound(Me^.Y), markLJumped);
 // at final check where we go after jump walking backward
-if Push(ticks, Actions, AltMe, Me^.Message xor 3) then
+if Push(Actions, AltMe, Me^.Message xor 3) then
 with Stack.States[Pred(Stack.Count)] do
 begin
 if (Me^.Message and gmLeft) <> 0 then
 AddAction(MadeActions, aia_LookLeft, 0, 200, 0, 0)
 else
 AddAction(MadeActions, aia_LJump, 0, 305 + random(50), 0, 0);
 end;
 // push current position so we proceed from it after checking jump+forward walk opportunities
-if CanGo then Push(ticks, Actions, Me^, Me^.Message);
+if CanGo then Push(Actions, Me^, Me^.Message);
 // first check where we go after jump walking forward
-if Push(ticks, Actions, AltMe, Me^.Message) then
+if Push(Actions, AltMe, Me^.Message) then
 with Stack.States[Pred(Stack.Count)] do
 AddAction(MadeActions, aia_LJump, 0, 305 + random(50), 0, 0);
 break
 end;
 // 'not CanGO' means we cannot go straight, possible jumps are checked above
 if not CanGo then
 if Rate > BestRate then
 begin
 BestActions:= Actions;
 BestActions.isWalkingToABetterPlace:= true;
 BestRate:= Rate;
-Me^.State:= Me^.State or gstAttacked // we have better place, go there and do not use ammo
+isAfterAttack:= true // we have better place, go there and do not use ammo
 end
 else if Rate < BestRate then
 break;
-if ((Me^.State and gstAttacked) = 0) and ((steps mod 4) = 0) then
+if (not isAfterAttack) and ((steps mod 4) = 0) then
 begin
 if (steps > 4) and checkMark(hwRound(Me^.X), hwRound(Me^.Y), markWalkedHere) then
 break;
 addMark(hwRound(Me^.X), hwRound(Me^.Y), markWalkedHere);
-TestAmmos(Actions, Me, ticks shr 12 = oldticks shr 12);
+TestAmmos(Actions, Me, Actions.ticks shr 12 = oldticks shr 12);
 end;
 if GoInfo.FallPix >= FallPixForBranching then
-Push(ticks, Actions, Me^, Me^.Message xor 3); // aia_Left xor 3 = aia_Right
+Push(Actions, Me^, Me^.Message xor 3); // aia_Left xor 3 = aia_Right
-if (StartTicks > GameTicks - 1500) and (not StopThinking) then
-SDL_Delay(1000);
 end {while};
 if BestRate > BaseRate then
 exit
 end {while}
 until (not (switchImmediatelyAvailable or (switchCount > 0)))
 or StopThinking
 or (itHedgehog = currHedgehogIndex)
 or BestActions.isWalkingToABetterPlace;
 if (StartTicks > GameTicks - 1500) and (not StopThinking) then
 SDL_Delay(700);
 if (BestActions.Score < -1023) and (not BestActions.isWalkingToABetterPlace) then
 begin
 BestActions.Count:= 0;
 begin
 OutError('AI: no targets!?', false);
 exit
 end;
-FillBonuses(((Me^.State and gstAttacked) <> 0) and (not isInMultiShoot));
+FillBonuses(((Me^.State and gstAttacked) <> 0) and (not isInMultiShoot) and ((GameFlags and gfInfAttack) = 0));
 SDL_LockMutex(ThreadLock);
 ThinkThread:= SDL_CreateThread(@Think, PChar('think'), Me);
 SDL_UnlockMutex(ThreadLock);
 end;
 const cStopThinkTime = 40;
 begin
 with CurrentHedgehog^ do
 if (Gear <> nil)
 and ((Gear^.State and gstHHDriven) <> 0)
-and (TurnTimeLeft < cHedgehogTurnTime - 50) then
+and ((TurnTimeLeft < cHedgehogTurnTime - 50) or (TurnTimeLeft > cHedgehogTurnTime)) then
 if ((Gear^.State and gstHHThinking) = 0) then
 if (BestActions.Pos >= BestActions.Count)
 and (TurnTimeLeft > cStopThinkTime) then
 begin
 if Gear^.Message <> 0 then

branch	0.9.25
changeset 14585	8736f3a0ff7f
parent 14226	545b85c0f2e3
child 14586	e54e41554529