Suppose that the binary form of var a is:
`var a = 0b11101101`
How can I check and receive the state of a particular bit as output?
Example: Imagine there is a operation "state" that outputs the nth digit of the variable a:

``````state(n, a)
``````

Then, something like:

``````func _ready():
print(state(3, a))
------------------------------
OUTPUT: 1
``````

Prints the 3rd digit of the number. (In this case, 1)

Sorry for the convoluted question

Godot version 3.2.3
in Engine

Out of curiosity, what's your end goal here? If your goal is to check a list of bit flags for a particular flag, this can be achieved using bitwise operators like `&` (AND), `|` (OR) and `^` (XOR).

I haven't found a real solution to your problem.

I have tried the obvious, i.e., converting `a` to a string. However, `String(a)` returns "237" and not "0b11101101". So it does not work.

A workaround could be, if it is possible in your project, to define `a` as a String (`var a = 0b11101101`) and then get the value at a particular position by just calling `a[n]`.

by (23 points)

Hi,
Convert the number to binary, shove the bits in an array and return the bit

``````extends Node2D

var a = 0b11101101

print(state(3, a))

func state(n, q):
var bits = [0, 0, 0, 0, 0, 0, 0, 0]
var bit = 7
while q > 0:
bits[bit] = (q % 2)
q /= 2
bit -= 1
return(bits[7-n])
``````
by (1,653 points)

It sounds like you're trying to check for the presence of specific flags in a bitfield.

``````extends Node2D

# The `<<` operators performs a bit shift to the left, which can be used to elevate a number to the power of the righthand side quickly (when used with `1` on the lefthand side).
const FLAG_FALLING = 1 << 0  # 1
const FLAG_FLAMMABLE = 1 << 1  # 2
const FLAG_SLIPPERY = 1 << 2  # 4
const FLAG_NONSOLID = 1 << 3  # 8

# The bitwise `|` operator can be used to combine flags safely.
# `+` can also be used, but it's less safe as it won't prevent you from adding the same flag multiple times (which is invalid).
var block_flags = FLAG_FALLING | FLAG_SLIPPERY

print("Falling: ", has_flag(block_flags, FLAG_FALLING))
print("Flammable: ", has_flag(block_flags, FLAG_FLAMMABLE))
print("Slippery: ", has_flag(block_flags, FLAG_SLIPPERY))
print("Nonsolid: ", has_flag(block_flags, FLAG_NONSOLID))

func has_flag(bitfield, flag):
# The bitwise `&` operator will return a number with all bits "in common" between the two numbers set to `1`, and all other bits set to `0`. If no flags match, the returned number will be `0` since there will be no bits in common between the two numbers.
# Here, we convert it to a boolean since we are only interested in whether
return bool(bitfield & flag)
``````

This prints:

``````Falling: True
Flammable: False
Slippery: True
Nonsolid: False
``````
by (9,328 points)
``````func set_state(n:int,value:int)->int:
value  |= (1 << n)
return value

func get_state(n : int,value: int  )->int:
var _state : bool = value & (1 << n) !=0
return 1 if _state else 0

func toggle_state(n:int ,value:int)->int:
value ^= (1 << value)
return value
``````

& is bitwise and
| is bitwise or
<< is left shift

by (280 points)