question bitmask?

Question

Je le suivi:

public static final int LIMIT_ONE = 1;
public static final int TRADEABLE = (1 << 1);
public static final int SELLABLE = (1 << 2);
public static final int STORABLE = (1 << 3);
public static final int STORABLE_IN_WH = (1 << 4);
public static final int STORABLE_IN_LEGION_WH = (1 << 5);
public static final int BREAKABLE = (1 << 6);
public static final int SOUL_BOUND = (1 << 7);
public static final int UNK9 = (1 << 8);
public static final int UNK10 = (1 << 9);
public static final int UNK11 = (1 << 10);
public static final int CAN_COMPOSITE_WEAPON = (1 << 11);
public static final int BLACK_CLOUD_TRADERS = (1 << 12);
public static final int CAN_SPLIT = (1 << 13);
public static final int UNK15 = (1 << 14);
public static final int UNK16 = (1 << 15);

et je voulais comprendre comment il est calculé pour donner le résultat de suivi, par exemple: 12414

Je suis vraiment aucune idée sur la façon dont le travail de bitmask et si quelqu'un pourrait peut-être donner quelques conseils et expliquer comment ça se passe à ce numéro, je vous serais reconnaissant de bien.

Answer 1

L'expression (1 << n) est équivalente à 2 élevé à la puissance n.

Lorsque vous écrivez ce (1 << n) | (1 << m) est le même que (1 << n) + (1 << m) aussi longtemps que n et m sont différents. Alors vous pouvez penser en termes d'additions simples si vous le souhaitez.

Le nombre de 12414 en binaire est 11000001111110 il est donc la somme (ou au niveau du bit OR) des drapeaux suivants:

TRADEABLE                1 << 1  =     2
SELLABLE                 1 << 2  =     4
STORABLE                 1 << 3  =     8
STORABLE_IN_WH           1 << 4  =    16
STORABLE_IN_LEGION_WH    1 << 5  =    32
BREAKABLE                1 << 6  =    64
BLACK_CLOUD_TRADERS      1 << 12 =  4096
CAN_SPLIT                1 << 13 =  8192
========================================
                         Total   = 12414

Notez que les drapeaux qui sont inclus correspondent aux bits qui sont définis dans la représentation binaire de 12414, lorsqu'ils sont lus de droite à gauche.

Answer 2

12414 binaire est:

Binary number: 1  1  0  0  0  0  0  1  1  1  1  1  1  0
-------------------------------------------------------
Bit positions: 13 12 11 10 9  8  7  6  5  4  3  2  1  0

Regardez quels bits 1. Ce sont les drapeaux qui sont définis dans le masque de bits, qui est créée en utilisant l'opérateur OR pour combiner les drapeaux:

bitmask = TRADEABLE | SELLABLE | STORABLE | STORABLE_IN_WH | STORABLE_IN_LEGION_WH | BREAKABLE | BLACK_CLOUD_TRADERS | CAN_SPLIT;

Pour expliquer plus loin, des moyens de STORABLE = (1 << 3); que STORABLE est égal au nombre de une (1 binaire, tombant seulement dans la position de bit 0) décalée vers la gauche par 3 places. Notez que STORABLE = Math.pow(2, 3); serait équivalent. Étant donné qu'aucun des bits se chevauchent entre les drapeaux, nous pouvons combiner tous en un seul int puis les fendit plus tard.

Nous pouvons vérifier l'existence de drapeaux à l'aide de l'opérateur au niveau du bit, qui renvoie une valeur non nulle si l'indicateur est défini et une valeur zéro si le drapeau est pas défini:

if(bitmask & TRADEABLE != 0) {
    // This item can be traded
} else {
    // This item cannot be traded
}

Nous pouvons définir, clair ou drapeaux bascule comme ceci:

bitmask |= TRADEABLE; // Sets the flag using bitwise OR
bitmask &= ~TRADEABLE; // Clears the flag using bitwise AND and NOT
bitmask ^= TRADEABLE; // Toggles the flag using bitwise XOR 

Answer 3

a << b décale les bits dans les valeurs de a de b vers la gauche, le rembourrage des nouveaux bits à droite avec des zéros. 1 << n équivaut à un nombre entier avec seulement le bit nth (comptage de 0 à partir de la droite) ensemble, ce qui équivaut à 2 ⁿ .

12414 est 11000001111110 en binaire. Il est donc produit en additionnant les constantes énumérées ci-dessous. Vous pouvez travailler cela en voyant le bit 1 du droit est donc TRADEABLE est « ensemble »; bit 7 est pas défini (il est 0), donc SOUL_BOUND n'est pas « ensemble ». Notez comment les numéros de bits associent les valeurs déclarées de (1 << n).

TRADEABLE
SELLABLE
STORABLE
STORABLE_IN_WH
STORABLE_IN_LEGION_WH
BREAKABLE
BLACK_CLOUD_TRADERS
CAN_SPLIT

Answer 4

Je ne comprends pas la question « comment il est calculé pour donner le résultat de suivi ». (Ce qui est calculé?)

La principale chose à comprendre est que toutes les valeurs informatiques sont stockées en binaire. Un nombre quelconque sera une combinaison de bits 0 et 1. Quelques chiffres ont seulement un 1 bit.

http://en.wikipedia.org/wiki/Mask_(computing )

Answer 5

Je dirais que vous prenez un certain nombre, comme votre exemple 12414, et de déterminer quelles sont les propriétés sont contenues à l'intérieur.

Par exemple, étant donné que 12414 est 11000001111110 en binaire, quel qu'il soit attaché à est négociable, parce Anding ce numéro avec le masque vous donnera un 1 dans le second bit.

Answer 6

En binaire, 12414 est 11000001111110. LIMIT_ONE en binaire est 1 et le <<, qui est l'opérateur de Bitshift déplace le zéro pour le rembourrage gauche avec un zéro sur la droite. Par conséquent, en binaire est échangeable 10 et ainsi de suite jusqu'à unk16, qui finit par être 1000000000000000. Maintenant, vous mettez ensemble ces valeurs OU binaire, qui met essentiellement un 1 sur chaque position dans laquelle au moins un de ses opérandes a une sur cette position (l'opérateur pipe '|' est utilisé dans la plupart des langues).

Exemple:

100 | 10 = 110

Par conséquent, pour se rendre à 12414, vous devez faire une opération de bits ou sur les variables suivantes: unk16, unk15, négociables, selleable, stockable, stockable en Wh, stockable dans légion wh et cassants. La combinaison de celles sur les différentes positions dans chacune de ces variables vous donne 11000001111110 binaire, qui se révèle être 12414 en décimal.

Ceci est probablement le moyen le plus simple de l'expliquer, si vous voulez en savoir plus, vous devriez lire sur la façon dont les opérateurs et au niveau du bit représentation binaire des œuvres numéros.

Pour en savoir lequel des drapeaux le numéro 12414 a, vous pouvez utiliser l'opérateur & (au niveau du bit) et faire une vérification zéro. Par exemple:

6 & 2 = 2 (110 has a 1 on the same position as 2, which is 010)
6 & 1 = 0 (110 does not have a 1 on the same position as 1, which is 001)