It means if you do...

in your Update()..

{  TurnRight(TURN_SLOW);  // ... more code here ...  TurnLeft(TURN_SLOW);

Then only the TurnRight(TURN_SLOW); line will be executed. All other commands dealing with turns will be thrown away. Now, if you do:

{  TurnRight(TURN_SLOW);  SetSpeed(SET_NORMAL_SPEED);  // ... more code here ...  TurnLeft(TURN_SLOW);}

Your bot will turn right at the slow rate and move forward at the normal speed. The TurnLeft() is tossed out.

If you do:

{  SetSpeed(SET_NORMAL_SPEED);  Strafe(STRAFE_LEFT);    // ... more code here ...  TurnRight(TURN_FAST);  SetSpeed(SET_HIGH_SPEED);}

Your bot will walk forward at the normal rate and strafe to the left while also turning at a fast rate to the right. The SET_HIGH_SPEED is tossed out.

Basically, Turn*() and SetSpeed() are independent of each other, but you can only set one rate per update (the first one you set). Strafe() is independent of both of those.

Weapon selection and firing works the same way. The first time you call SelectWeapon() during an update is the only time it will actually execute. All calls to SelectWeapon() after that will be ignored by the arena. Same with Fire() and SetWeaponAngle(). This way, you can''t do this in one Update() cycle:

{   // fire 50 grenades and 50 bullets in this Update() cycle   for (int idx = 0; idx < 100; idx++)   {       if (idx % 2)           g_pCore->SelectWeapon(WEAPON_GUN);       else           g_pCore->SelectWeapon(WEAPON_GRENADE);       g_pCore->Fire();   }}

...or some other variation. Essentially, this gives you one shot per frame, particularly when you take into account recoil and reload times.

I hope that explains things..

quote:Original post by Russell
Ok, this is how I currently understand things. Basically only the first call of any of these will actually get run from Update():


bool TurnLeft(int rate); or bool TurnRight(int rate);
bool SetSpeed(int speed);
bool Strafe(int strafe);
bool SelectWeapon(int weaponType);
void SetWeaponAngle(float angle);
bool Fire();
int GetNumObjectsInSight();
bool GetObjectsInSight(int objIdx, int &objectType, float &direction, float &distance);
bool Taunt(const char *tauntStr);
int GetMyHealth();
int GetMyAmmoCount();
int GetMyGrenadeCount();


Also, I assume only the first call to Taunt() or GetMy*() also only get run once, which would make it good practice to only Taunt() once per Update(), as well as save all of the health/ammo/grendate/objects-in-sight-info/etc. at the beginning of Update() and work with that instead of making multiple calls to those functions if that data is needed in multiple spots in Update(). Tell me if I understand correctly now

Nope.. unless I''m misunderstanding you..

You should just run some experiments. You will see that you can''t turn multiple times, you can''t set the speed multiple times, and you can''t strafe in opposite directions. You also can''t fire your weapon more than once, and you can only select your weapon one time. You can do all that stuff together, but you can only do each thing once. As for taunts, if you are in debug mode, you can set it as often as you''d like, but that would be pretty difficult to read. If you are in release mode, the taunt will last 1.5 seconds before it will update again. All the Get*()''s can be executed as often as you want. You just can''t try to move multiple times, turn multiple times, select and fire your weapon multiple times, or do any other thing multiple times that might affect the realtime nature of the arena.

quote:Original post by Anonymous Poster
mind another question re: Update SelectWeapon() and Fire() operability?

if a bot already has a selected weapon (gun) and calls Fire() followed by a SelectWeapon(grenade), will the Fire() be dumped due to the weapon change or will it trigger a use of the gun first followed by the weapon change?

no problem if you don''t know as i''ll be testing this soon anyway.

At the end of the Update(), your selected weapon will be gun, and you will have fired one shot. The second SelectWeapon() will be ignored.