[Black Rose]

This is a horrible idea no matter how you look at it.

public function() {
    new PlayerBitsum = GetPlayersBitsum();
    new IsDedicatedServer = is_dedicated_server();

    for ( new i = 0 ; i < 32 ; i++ ) {
        if ( PlayerBitsum & (1<<i) )
            client_print(i + IsDedicatedServer, print_chat, "Hello!");
    }
}

public function(id) {
    new PlayerBitsum = GetPlayersBitsum("a");
    new IsDedicatedServer = is_dedicated_server();

    if ( PlayerBitsum & id - IsDedicatedServer )
        client_print(id, print_chat, "Hello!");
}

stock GetPlayersBitsum(const flags[]="", const team[]="") {

    new Players[32], PlayersNum, PlayersBitsum, IsDedicatedServer = is_dedicated_server();
    get_players(Players, PlayersNum, flags, team);

    for ( new i ; i < PlayersNum ; i++ )
        PlayersBitsum |= 1 << Players[i] - IsDedicatedServer;

    return PlayersBitsum;
}

[Bugsy]

You can do PlayersBitsum |= 1 << ( Players[i] & 31 ) to handle index 32.

[Craxor]

@Depresie: You still sleeping ?

@Black Rose: That's what i'm scared of, to create AGAIN the loop, it's stupid, i will just leave it ...

@Bugsy: That's an example how to handle the index 32 ( last player ) ... but no way to check all of them?

Like:

new szName[32];
get_user_name( PlayersBitsum, szName ..............

You know what i mean ..

[Bugsy]

Originally Posted by Craxor @Depresie: You still sleeping ? @Black Rose: That's what i'm scared of, to create AGAIN the loop, it's stupid, i will just leave it ... @Bugsy: That's an example how to handle the index 32 ( last player ) ... but no way to check all of them? Like: new szName[32]; get_user_name( PlayersBitsum, szName .............. You know what i mean ..

No, I don't know what you mean. PlayersBitsum is not equal to a individual player indexes. It stores all player indexes using a single bit of memory to represent each slot that has a player connected; A bit has a value of 0 or 1. There are 32 bits of memory in a single cell/variable. Read the bitsum tut for more info. With that said, you cannot call any player natives/functions using this as the player index. What makes you think you can store multiple player names within al single string variable? That makes no logical sense.

[Craxor]

Yes, i get it, after i test all the previous night this stock )

The only thing i can do with, is to test if a 'index' is inside of a bit-field, if that bit-field contain that specific index, and that's useless.

Maybe if i would understand in a deep way how bits works i can make a way to 'convert' these, but i im not realy good at matematics so i don't think is any chance... i can learn only in a practical way ...

[Bugsy]

Originally Posted by Craxor Yes, i get it, after i test all the previous night this stock ) The only thing i can do with, is to test if a 'index' is inside of a bit-field, if that bit-field contain that specific index, and that's useless. Maybe if i would understand in a deep way how bits works i can make a way to 'convert' these, but i im not realy good at matematics so i don't think is any chance... i can learn only in a practical way ...

Bits/bitfields are not specific to AMX-X so you can find info all over the web. I did write a relatively basic tutorial that may help you.

https://forums.alliedmods.net/showthread.php?t=139916

[PRoSToTeM@]

Originally Posted by Bugsy You can do PlayersBitsum |= 1 << ( Players[i] & 31 ) to handle index 32.

You can just use 1 << Players[i] because (1 << 32) works as (1 << 0).

[Bugsy]

Originally Posted by PRoSToTeM@ You can just use 1 << Players[i] because (1 << 32) works as (1 << 0).

The bit will fall off of the end. You cannot use the logic 'if BitSum == 0 then slot 32 is connected'.

Also (assuming a 32 bit):
1 << 32 = 0
1 << 0 = 1

Blue are valid bits within a cell (32). 1 << 32 goes to the 33rd bit, which doesn't exist in a 32-bit cell.
[0000 0001] [0000 0000] [0000 0000] [0000 0000] [0000 0000]

[PRoSToTeM@]

@Bugsy the shift count is given by the low-order five bits of the second operand (& 31).

    register_clcmd("say", "OnClientCommand_Say_BitShift");
}

public OnClientCommand_Say_BitShift(clientEntIndex) {
    new args[128];
    read_args(args, charsmax(args));
    remove_quotes(args);
    
    new cmd[32];
    new value[32];
    parse(args, cmd, charsmax(cmd), value, charsmax(value));
    
    if (!equal(cmd, "/bitshift")) {
        return;
    }
    
    new shiftCount = str_to_num(value);
    
    client_print(clientEntIndex, print_chat, "(1 << %d) = %d", shiftCount, (1 << shiftCount));
}

Prints:

(1 << 0) = 1
PRoSToC0der :  /bitshift 0

(1 << 32) = 1
PRoSToC0der :  /bitshift 32

[fysiks]

Originally Posted by https://en.wikipedia.org/wiki/Logical_shift All currently relevant C standards (ISO/IEC 9899:1999 to 2011) leave a definition gap for cases where the number of shifts is equal to or bigger than the number of bits in the operands in a way that the result is undefined.

This means that shifting the bits farther than available bits is not defined. Thus, the behavior can be unpredictable. You should never rely on something that is not defined by a standard (unless you yourself are able to control how it is handled; in this case you can't control it) and is why you should do it the proper way with what Bugsy suggested.

In other words, just because it works empirically for now, doesn't mean that a future update won't break it.