## unity – Physics2D.OverlapCircleAll with layerMask without detecting anything

The problem is quite simple and apparently has no solution.

When I use Physics2D.OverlapCircleAll without a layer mask it works fine, if I try to use a layer mask it won't detect anything.

I am sure that I configured the layers correctly and I am sure that the code is written correctly since I verified the documentation three times.

Essentially, it looks more like a mistake than anything else, but I thought maybe you knew a way to solve this without having to report it.

## computer networks – Probability of detecting errors in code words

I've been struggling with the next question for quite some time, and I don't have a pointer to move forward.

``````A certain Error Control Coding scheme using block codes takes an input block (dataword) of 500 bits
and appends a 50 bit code to produce a 550 bit codeword which is then transmitted across channel that
causes individual bits to flip with a probability of 0.1 independently. The pairwise Hamming distances
between all the codeword pairs is so large that the probability of an error occurring that converts one to the
other can be neglected, except as follows: two codewords C 1 and C 2 have a Hamming distance of 10, and
two codewords C 3 and C 4 have a Hamming distance of 6.
Assuming no knowledge about what datawords may be more or less likely to be desired to transmit, what is
the probability that a given block transmission will be corrupted by the channel but the error will go
undetected by the receiver? You may answer with an expression, but the answer has to be completely
numerical (no symbols).
``````

My thinking process on this question is that the probability should be calculated as such:
Pr (Selection of C1 or C2) * P (error in C1 or C2) + Pr (Selection of C3 or C4) * P (error in C3 or C4).
I feel that the Pr (error) is given by a binomial distribution of 55CX (0.1) ^ x (0.9) ^ 550-x where X = 10 or 6.

First, am I thinking about the problem correctly? If so, how do I get the probability of selecting a particular code word?

## input – Unreal C ++ Detecting a new key down during current key retention

I am currently working on a combat system and I wanted to be able to have combinations of keys to execute combat movements and so on, and I am also detecting the type of key input, for example, if the key is touched or pressed for a long time.

I use this line below to record the moment at which a key is pressed and the moment at which the same key is released, to be able to differentiate whether the key is touched quickly or held down.

FPlatformTime :: Seconds ();

and when the game detects a key press, it will then execute the function, using a timer and stop when released.

``````//Long Press
void ABasePlayerController::StartRepeat(UFunction* FunctionNamesToCall, FKey KeyInput)
{
//Execute if Timer is still active
if (IsKeyDown != false && GetWorld()->GetTimerManager().IsTimerActive(RepeatTimerHandle) && WasInputKeyJustPressed(KeyInput))
{
}
}
``````

The problem is when I wanted to make a key combination, and I stopped this function, every time a new key is pressed, the new key will be considered as Long pressed as well. My current codes can only register entry types after the key is released, and I also wanted to be able to do a loading combo.

For example when I hold a Tongue and I play a new different key, both keys will be considered as Long pressed, while the expected result is supposed to be Long pressed Tongue key, and the new key pressed is a simple quick tap.

Any ideas? Thank you!

## java – Continue executing the cycle after detecting an exception in the try / catch block

How to continue the iteration cycle if an exception occurs in while (iterator.hasNext ())?

Then I want to do something like below.

``````            try {
loop: while (iterator.hasNext())  // as excetion is on this line excetion will be catch by catch_2
{
try {
Result res = (Result) iterator.next();
} catch (Exception e) {                    // catch_1
e.printStackTrace();
}
}
} catch (Exception e) {                            // catch_2
// goto start of the loop
continue loop;
}
``````

## Spells: How is the imbalance changing the objective of Detecting thoughts only to the dead and dying?

One of my players is playing a Lashunta envoy with the theme touched by death. As such, they have access to "Detect thoughts" once a day.

To give a little flavor to your subject, I decided to let them use thoughts to detect only the dead and dying, instead of being with someone alive. In the case of the dead, the thoughts would reflect their last moments, and they must have died last week.

How unbalanced is this? What should I worry about? If it is important, we are running the Dead Suns campaign.

## Scent allows you to detect enemies that try to sneak up on you in more cases than you would hear.

Because most creatures have hearing (Pathfinder seems to assume that all creatures do so unless they say otherwise) many creatures will attempt to move silently using Stealth.

Scent avoids these stealth attempts (which allows you to be aware of them) unless they have taken steps to prevent your Scent from working. A creature that knows you (form r) has a smell can do it, but many other creatures will not know or simply do not have the means to mask its smell.

Notably, the smell is typically a meaning of vague sense

In the best case, a vague sense can be used to detect the presence of an inadvertent creature, so it is not detected.

While updating this to inaccurate allows

Usually, you can feel a creature automatically with an imprecise sense, but it has the hidden condition instead of the observed condition. That could not be detected …

Mechanically, this ignores Not detected; Inadvertent is the most extreme version of Undetected that would allow creatures to really take advantage of you (potentially as dangerous assassination attempts with future content releases), while Undetected is almost as bad.

Unnoticed
If a creature does not notice it, that creature has no idea that you are present. When you go unnoticed, the creature does not detect you either. This condition is important for skills that can be used only against targets that completely ignore your presence.

Not detected
When you are not detected by a creature, that creature cannot see you at all, has no idea what space you occupy and cannot attack you, although you may still be affected by
skills that point to an area …

Hidden
While you are hiding from a creature, that creature knows the space you are in but cannot say precisely where you are … A creature you are hiding from is flat, and must succeed at a time DC 11 flat check when you attack with an attack,
the spell or other effect or failure affects you.

Notably, any ally that reduces an enemy to Hidden allows everyone to treat them as Hidden because you effectively know what space the target occupies. Being the one with the scent gives you the advantage to allow your group to counter an ambush.

A note on how to hide from Scent.

It seems that there is margin in the sidebar on p465, which implies that you can usually try to hide from the senses, including Scent, with the proper narration (maybe cover yourself with mud, etc.); however, the Foil Sense skill ability allows creatures to defeat Scent without preparing specifically for it. Fortunately, it requires Master in Stealth, so few creatures will run with that ability.

The Stealth skill is designed to use Hide to avoid visual detection and Avoid warning and sneak in to avoid being seen and heard. For many special senses, a player can describe how they are avoiding being detected by that special sense and use the most applicable stealth action. For example, a creature that treads lightly to avoid being detected by Tremorsense would be using Sneak.

Based on this, some GM (including myself) would instead ask for a costume or a survival roll, if the task in question was to cover themselves with mud to overcome their smell.

## penetration test: the antivirus and its function in detecting the execution of the payload?

I recently started learning about ethical piracy and penetration testing. Along the way, I am sure that many people learn about these issues in which I have encountered some obstacles. I will not write an essay about my daily life and study schedule because I know that I will simply be super famous and I will not be able to get peace. Or, I'll take everyone to death. So I'm going to cut to the right …

My first question is this:
1) Antivirus software works by means of signature-based detection. Signature-based detection evaluates the elements (perhaps not the correct word?) Based on a large database of known threats. The software carries with it its own digital signature. If this signature for a particular item matches a known signature in the database, it is marked as malicious and the necessary steps are taken.

• Do AVs depend solely on this method?
• Let's say, for example, that the malware passes the AV (because its signature is new), is the malware at home and is it dry?
• Or do things such as behavioral analysis still prevail? Let's say the malware executes known commands or uses known components; Metasploit framework, Empire, etc. The malware has already exceeded the AV in terms of signature-based detection, provided that the malware is clean. Are there other possibilities that other defenses can detect malicious activity?
• How long does the AV "hang" from a particular executable? Let's say you start scanning it the moment it hits the disk. Okay, it's clean (according to AV), will it approve the executable, decrease its vigilance, increase, put on the white list or ignore?

– I see many articles about known threats, particularly in the past, where the malicious load was not simply downloaded in executable format and then executed. A payload can, for example, be hidden in a PDF, a Word document and even then, the payload has not yet been executed and is simply downloaded by a Powershell command
– At what moment are binary executable payloads in .exe format useful in a possible attack, in any case? It's obvious to me that AV vendors today dissect and tear many .exe payloads, and rightly so. It is, by far, what I have learned, the most common vector of attack (if it is the correct way to explain it?) And also the oldest and well used. A person downloads a file that he thinks is legitimate, he is not, he sets up a reverse shell, ready. Or, a person downloads a file, believes it is legitimate, is a keylogger, is ready, or a RAT.

I still feel that there is more behind the scenes. The more I have gotten myself into the task of exploiting a Windows-based system (in my own lab environment), the harder and sometimes more messy it can be to simply put the thing on the computer in the first place. I have used hexadecimal editors, UPX, useless dlls aggregates and resources to confuse detection analysis, signed false executables, modified exe templates and yet … I feel something is missing …

Hmmm …
Thank you!

## 2d – Unity Colliders – How do I detect nearby objects without my detection ranges detecting each other?

How can I get the types of both colliders in an activation overlap message as `OnTriggerExit2D (Collider2D other)`?

Example:

• `Objects A and B` both have a `BoxCollider2D` Y `CircleCollider2D` components

• So, `object A` enters one of the trigger colliders `object B`.

• I can get `object B`type of collider with the `is` operator.

How can I get the type of A collider?

The reason I want this is that I only want collisions where `object A`is `CircleCollider2D` touches `object B`is `BoxCollider2D`.

``````void OnTriggerExit2D (Collider2D other)
{
yes (other is BoxCollider2D)
// make code
}
``````

Here is a table of what I want: I just want to record the trigger overlays of `CircleCollider2D to BoxCollider2D`. With the `is` operator, I can safely eliminate all collisions at `CircleCollider2D` but collisions between two `BoxCollider2D` Stay, what I do not want.

``````+ ------------------ + --------------- + -------------- ---- +
| Row to column | BoxCollider2D | CircleCollider2D |
+ ------------------ + --------------- + -------------- ---- +
| BoxCollider2D | No | No |
| CircleCollider2D | Yes | No |
+ ------------------ + --------------- + -------------- ---- +
``````

Edit
The real questions were to detect nearby objects without the detection range detecting each other.

## Detecting changes in focus – Photo stack exchange

If you use a non-autofocus mode of the camera (or, better yet, a lens without autofocus, with the lens cylinder pasted to the correct point) and you do not use the fully open lens, then, realistically, the focus of the camera will change in a negligible way over time, unless it does horrible things (huge thermal cycles, vibrations, mechanical shocks, etc. would not be good).

In particular, you can calculate the depth of field at a given aperture that will tell you how much the focus has to deviate for things to matter significantly.

So my temptation would be not to worry too much, unless, for some reason, knowing that the thing was absolutely focused is completely critical.

## Unreal 4: Error when detecting a collision with another instance of the same actor?

I have a project where, after a certain interval of time, 2 NPCs are generated in different locations on the map.

Each of them collides with a collision box that defines its "class" (red or blue):

When 2 NPCs collided, a condition was verified (if the "class" of those involved is different) and from there both are destroyed, but nothing happens:

I put an impression right after the Cast To NPC To see if it was happening and when they are generated, the print appears four times.

Blueprint:

Result in the game:

I would like to know how to establish a distribution only between two instances of the same actor.

Image that shows that nothing happens when (two instances of the same actor) collide:

I did the test with both codes (printing and destroying both).

EDIT 1 (it was being redundant)

In the destruction code, I can simply say that it destroys itself, because as it will be executed in both cases, the two will destroy themselves:

I would still like to know how to correctly detect the collision between two instances of the same actor, but now I know that the code will be executed twice, once in instance A and again in instance B.