[fysiks]

Currently I have this:

public ham_player_killed( victim, killer, gib)
{
 if(!is_user_bot(killer) || victim == killer || get_user_team(killer) != get_user_team(victim))
  return HAM_IGNORED
...

Does the if statement check all three conditions every time even if the first and/or second returns true?

If not, I was thinking I should put the most common situation first and least for last. The idea being to do the least amount of work possible.

If so, would it be more beneficial to make three if statements in sequence with the most common occuring situation first?

[Arkshine]

if the first is wrong, it will check the second, otherwise it will return ham_ignored.
if the second is wrong it will check the third, otherwise it will return ham_ignored.
if the third is wrong you have passed all the check and you will continue, otherwise it will return ham_ignored.

So yeah, conditions are read in sequence.

[Brad]

Originally Posted by fysiks would it be more beneficial to make three if statements in sequence with the most common occuring situation first?

Yes.

[fysiks]

It seems to me that these two responses are contradicting.

I'll give both code situations explicitly if my wording was misinterpreted:

1 (rearranged from the first post):

 if(get_user_team(killer) != get_user_team(victim) || !is_user_bot(killer) || victim == killer)
  return HAM_IGNORED

2:

if(get_user_team(killer) != get_user_team(victim))
 return HAM_IGNORED
if(!is_user_bot(killer))
 return HAM_IGNORED
if(victim == killer)
 return HAM_IGNORED

Bottom Line: Which is fastest (to return HAM_IGNORED) when the kill is not a teamkill?

In code 2 if it's not a teamkill it will return HAM_INGNORED before it has a chance to evaluate !is_user_bot(killer) and victim == killer.

I posted because I assumed code 1 would evaluate all three conditions before returning HAM_IGNORED meaning code 2 would be faster in situations where it was not a team kill and is not a bot. I think this is what Brad said yes to.

[Exolent[jNr]]

if(get_user_team(killer) != get_user_team(victim))
 return HAM_IGNORED
if(!is_user_bot(killer))
 return HAM_IGNORED
if(victim == killer)
 return HAM_IGNORED

I would use this order:
Check if the killer is the victim.
Check if the killer is not a bot.
Check if the killer and the victim are on different teams.

if(victim == killer || !is_user_bot(killer) || get_user_team(killer) != get_user_team(victim))
    return HAM_IGNORED;

Reasoning:
1st check doesn't use any natives, only variable checks.
2nd check only uses 1 native.
3rd check uses 2 natives.

[fysiks]

Ok, I understand your reason for order but my question is: should I use if if if or just the single if?

You posted code in both forms (one with your order and one without) which has confused me .

If I assumed something I would assume the if if if with your order would be most efficient.

[danielkza]

Originally Posted by fysiks Ok, I understand your reason for order but my question is: should I use if if if or just the single if? You posted code in both forms (one with your order and one without) which has confused me . If I assumed something I would assume the if if if with your order would be most efficient.

Since the Pawn compiler is dumb (does no optimizations) using a single if() statement with multiple conditions should generate less code than separated statements. That'd not be the case in any 'good' compiler.