Need help improving my Flow Field and Unit Avoidance code so that the units can properly surround a unit instead of getting stuck

My setup is like this. Every update my movement system moves all of the units on the field. They use some Boid logic to avoid eachother, and a flow field that directs them towards each other. This is the result. https://imgur.com/a/CaUpfT7

My general setup is to calculate 2 flow fields, one for each player. From every field on the map (32×32 fields) I calculate the vector that points towards the closest enemy. Now this is a fine approach but I’d like to somehow take into consideration obstacles somehow (without another round of for loops)? Or should I handle that in my movement system avoidance? I was maybe thinking of doing A* once a unit is close enough to the enemy but all of these systems together seem rather hacky and overkill.

There are no obstacles currently, maybe a spell will generate it in the future. For now there are only units on the battleground without terrain or obstacles (besides units fighting eachother)

Here is some code. Firstly how I create the flowfields (kinda costly, will look into a way to optimize it further, don’t really need every single tile, can probably merge 2 or 3 together)

func (g *Grid) Update() {     g.entityPositions[0] = g.entityPositions[0][:0]     g.entityPositions[1] = g.entityPositions[1][:0]     entities := g.world.GetEntityManager().GetEntities()     posComps := g.world.GetObjectPool().Components["PositionComponent"]      for _, ent := range entities {         g.entityPositions[ent.PlayerTag] = append(g.entityPositions[ent.PlayerTag], posComps[ent.Index].(components.PositionComponent).Position)     }      for x := 0; x <= g.MaxWidth/FlowTileSize; x++ {         for y := 0; y <= g.MaxHeight/FlowTileSize; y++ {              curPosVector := engine.Vector{X: float32(x * 32), Y: float32(y * 32)}             // find closest tile to this one for both players             minDist := float32(100000.0)             minIndx := -1             for indx, pos := range g.entityPositions[0] {                 d := engine.GetDistanceIncludingDiagonal(pos, curPosVector)                 if d < minDist {                     minIndx = indx                     minDist = d                 }             }              //  fmt.Printf("CurPos : %v, enemyPos : %v,  direction %v \n", curPosVector, g.entityPositions[0][minIndx], g.entityPositions[0][minIndx].Subtract(curPosVector).Normalize())             g.flowTiles[1][x][y].Direction = g.entityPositions[0][minIndx].Subtract(curPosVector).Normalize()              minDist1 := float32(100000.0)             minIndx1 := -1             for indx, pos := range g.entityPositions[1] {                 d := engine.GetDistanceIncludingDiagonal(pos, curPosVector)                 if d < minDist1 {                     minIndx1 = indx                     minDist1 = d                 }             }              g.flowTiles[0][x][y].Direction = g.entityPositions[1][minIndx1].Subtract(curPosVector).Normalize()         }     } }  

And my movement code. A lot of code but just basic allignnment cohesion/ separation. With added 2 look ahead vectors to steer away from the collision.

        desiredDirection := world.Grid.GetDesiredDirectionAt(positionComp.Position, tag)         direction := movementComp.Direction         maxSpeed = movementComp.MovementSpeed          //Avoidance         nearbyEntities := helper.GetNearbyEntities(100, world, index)          avoidance := engine.Zero()         avoidance = avoidance.Add(alignment(world, nearbyEntities, direction).MultiplyScalar(alignmentCoef))         avoidance = avoidance.Add(cohesion(world, nearbyEntities, direction, positionComp.Position).MultiplyScalar(cohesionCoef))         avoidance = avoidance.Add(separation(world, nearbyEntities, direction, positionComp.Position).MultiplyScalar(separationCoef))           //Checking ahead of us whether or not we'll encounter something         lookAheadVectorLong := direction.Add(desiredDirection).MultiplyScalar(maxSpeed * 2.5)         lookAheadVectorShort := direction.Add(desiredDirection).MultiplyScalar(maxSpeed)         maxAvoidanceForce := float32(1.0)          checkPosShort := positionComp.Position.Add(lookAheadVectorShort)         checkPosLong := positionComp.Position.Add(lookAheadVectorLong)          collidedIndexShort := world.Grid.IsPositionFree(index, checkPosShort, positionComp.BoundingBox)         collidedIndexLong := world.Grid.IsPositionFree(index, checkPosLong, positionComp.BoundingBox)          if collidedIndexShort != -1 {             direction = engine.Zero()             avoidance = checkPosShort.Subtract(world.ObjectPool.Components["PositionComponent"][collidedIndexShort].(components.PositionComponent).Position).Normalize()             avoidance = avoidance.MultiplyScalar(maxAvoidanceForce * 1.5)         } else if collidedIndexLong != -1 {             direction = direction.MultiplyScalar(breakingForce)             avoidance = checkPosShort.Subtract(world.ObjectPool.Components["PositionComponent"][collidedIndexLong].(components.PositionComponent).Position).Normalize()             avoidance = avoidance.MultiplyScalar(maxAvoidanceForce * 1.2)         }          direction = desiredDirection         direction = direction.Add(avoidance).Normalize()          positionComp.Position = positionComp.Position.Add(direction.MultiplyScalar(maxSpeed))          positionComp.Position.X = engine.Constraint(positionComp.Position.X, 0, 799)         positionComp.Position.Y = engine.Constraint(positionComp.Position.Y, 0, 511)          movementComp.Direction = direction.Normalize()          world.ObjectPool.Components["PositionComponent"][index] = positionComp         world.ObjectPool.Components["MovementComponent"][index] = movementComp          fmt.Printf("I %d am at %v\n", index, positionComp.Position)     }  }  func limit(p engine.Vector, lim float32) engine.Vector {     if p.X > lim {         p.X = lim     } else if p.X < -lim {         p.X = -lim     }     if p.Y > lim {         p.Y = lim     } else if p.Y < -lim {         p.Y = -lim     }     return p } func alignment(world *game.World, siblings []int, velocity engine.Vector) engine.Vector {     avg := engine.Vector{X: 0, Y: 0}     total := float32(0.0)      for _, siblingIndex := range siblings {         avg = avg.Add(world.ObjectPool.Components["MovementComponent"][siblingIndex].(components.MovementComponent).Direction)         total++     }     if total > 0 {         avg = avg.DivideScalar(total)         avg = avg.Normalize().MultiplyScalar(maxSpeed)         avg = avg.Subtract(velocity)         avg = limit(avg, maxForce)         return avg     }     return engine.Vector{X: 0.0, Y: 0.0}  }  func cohesion(world *game.World, siblings []int, velocity engine.Vector, position engine.Vector) engine.Vector {     avg := engine.Vector{X: 0, Y: 0}     total := float32(0)      for _, siblingindex := range siblings {          avg = avg.Add(world.ObjectPool.Components["PositionComponent"][siblingIndex].(components.PositionComponent).Position)         total++      }     if total > 0 {         avg = avg.MultiplyScalar(1.0 / total * cohesionCoef)         avg = avg.Subtract(position)         avg = avg.Normalize().MultiplyScalar(maxSpeed)         avg = avg.Subtract(velocity)         avg = limit(avg, maxForce)         return avg     }     return engine.Vector{X: 0.0, Y: 0.0} }  func separation(world *game.World, siblings []int, velocity engine.Vector, position engine.Vector) engine.Vector {     avg := engine.Vector{X: 0, Y: 0}     total := float32(0)      for _, siblingIndex := range siblings {         siblingPos := world.ObjectPool.Components["PositionComponent"][siblingIndex].(components.PositionComponent).Position         d := position.Distance(siblingPos)         if d < desiredSeperation {             diff := position.Subtract(siblingPos)             diff = diff.Normalize()             diff = diff.DivideScalar(d)             avg = avg.Add(diff)             total++         }     }     if total > 0 {         avg.DivideScalar(total)     }      if total > 0 {         avg = avg.MultiplyScalar(1.0 / total * separationCoef)         avg = avg.Normalize().MultiplyScalar(maxSpeed)         avg = avg.Subtract(velocity)         avg = limit(avg, maxForce)     }     return avg } 

What I am trying to achieve is:

Units not mashing into each other and just positioning themselves in a free spot around their target.

What are my problems :

  1. Make the flow field direct them away from collision rather than just towards closest unit.
  2. Make it work with the current system without adding too many nested loops and awful checks.
  3. I am doing the avoidance correctly? I have a desired direction that I get from the flow field (that directs me towards closest enemy), then I add avoidance to it to avoid any other units in the area.

My units move really well up untill the point of collision/ going to a spot next to a target. I am not sure how to implemenent that behaviour yet.

(This is my forth iteration of the movement system. I went from pure boid, to grid based, to A*, to this. So I tried a lot of variations and this going surrounding behaviour has been bugging me every time.)

Custom engine (server) written in Golang and then dispatched to Godot for the visuals. Performance is not my concern, but this is a server, so I am more mindful of that, I could probably brute force it but I’d rather hear some better take on it.

Any suggestion/article/ video is greatly appreciated !!

Edit: Thinking about it, flow field is currently useless. I can basically just have a vector pointing to the closest enemy for each unit… Would be less costly as well. But the problem of them clumping and not knowing how to surround still stands.

Adsense Reporting – Finding Earning not Attributed to an Ad Unit

I’ve been a publisher using Adsense since 2006.

Up until sometime in 2020, I was pretty good with having all ad placements allocated to (or "tied to") Ad Units.

Recently though, as much as half of my actual earnings don’t show up in the Ad Units report. e.g. If my overall earnings on a given day was $ 60, only $ 30 of that shows up in the Ad Units report.

Clearly I must have an ad (or multiple ads) running that don’t have an Ad Unit?

How would I go about troubleshooting that?

It’s all on the same site/domain so hopefully it won’t be too hard to track down.

A 32 – bit wide main memory unit with a capacity of 1 GB is built using 256M X 4-bit DRAM chips

A 32 – bit wide main memory unit with a capacity of 1 GB is built using 256M X 4-bit DRAM chips. The number of rows of memory cells in the DRAM chip is 2^14. The time taken to perform one refresh operation is 50 nanoseconds. The refresh period is 2 milliseconds. The percentage (rounded to the closet integer) of the time available for performing the memory read/write operations in the main memory unit is _______ .

I calculated that the no of DRAM chips needed is 32. Now each DRAM have rows = 2^14
and columns 2^16 also as we can refresh the rows in parallel and since for one memory cell the time is 50 nanoseconds so for 2^16 columns we will need 2^16 * 50 nano sec ?…Is my approach right

or if i consider that 50 nanoseconds is the time for refresh of a complete row then also it would need a total of 50 nanosec to refresh all in parallel

Maximal subsets of a point set which fit in a unit disk

Suppose that there are a set $ P$ of $ n$ points on the plane, and let $ P_1, \dots, P_k$ be not necessarily disjoint subsets of $ P$ such that every point in $ P_i|\ 1 \leq i \leq k$ fits inside a unit disk $ D_i$ .

Moreover, each $ P_i$ is maximal. This means that if the corresponding unit disk $ D_i$ moves to cover another point, then one point which was inside the disk will be uncovered.

Here is an example: enter image description here

In the above figure, there are three maximal subsets.

I don’t know whether this problem has a name or was studied before, but my question is:

  1. Can $ k$ be $ O(1)^n$ ?
  2. If not, then can we find those subsets in polynomial time w.r.t. $ n$ ?

Is realization of unit disk graphs hard?

It is known that recognizing a unit disk graph is NP-hard [1].

However, the paper does not mention how hard is the realization problem.

I have looked up several references [2][3][4]. None of the papers answer whether the following problem is NP-hard:

Given a unit disk graph $ G = (V,E)$ , find a configuration of a set $ \mathcal{D}$ of disks, such that the intersection graph $ G(\mathcal{D})$ of $ \mathcal{D}$ is isomorphic to $ G$ .

The difference between this problem and the recognition problem is that the input of this problem is guaranteed to be a unit disk.

Is there any study that shows the complexity of the above problem? I expect it to be NP-hard, but I am yet to find a full proof.

Doubts on the behavior of Unit Type in a type system

I have a doubt about the Unit Type in the context of Type Theory and its use in different case scenarios.

To start with, a Unit Type can be seen as a nullary Product Type, namely Unit, with one only value term which is the empty tuple, (). Also, there exist a unique map from any type to the Unit.

Now, it happens that the use of the Unit Type goes beyond such trivial definition, and is in fact used in the definition of Algebraic Data Types, which are Sums of Product Types. Specifically, it is possible to represent the concept of an Enumerated Type using a Sum of Unit Types, e.g. in StandardML we might have:

datatype suit = HEARTS | CLUBS | DIAMONDS | SPADES 

where HEARTS, CLUBS, DIAMONDS and SPADES are nullary Product Types and therefore all isomorphic to the Unit.

My doubt is the following: if there exist only one element of Unit, how can the type system distinguish between the four distinct instances used in the Sum Type above (five instances if we also consider the empty tuple…)? I understand that they can be considered all equal to each other up to isomorphism, but they are extensionally different and in fact, even by considering only the suit we are supposed to pattern-match on them…

Convex Hull of Unit Circles

(Posted this also on Math StackExchange but I’m not sure if it belong there or here).

I know that if we’re trying to get the convex hull of unit circles, we can simply shrink the circles down to their centers and consider the convex hull of their centers, but I’m trying to prove some intermediate steps towards that.

a) Show that boundary of the convex hull consists of only straight line segments and parts of circles.

b) Show that each circle an appear at most once in the boundary of the convex hull.

(This is from de Berg’s Computational Geometry book.)

I sort of have an intuition of why these are true, but my problem is that whenever I try to come up with a solution, I end up considering lots of cases, and I feel like it’s not rigorous or elegant enough because of so many cases. Is there a neat way to prove these?

(Note: I know that this has been posted before in https://math.stackexchange.com/questions/122867/convex-hull-algorithms, but I’m not satisfied with the answers there, and I’m trying to go for something more rigorous.)

How can I reference classes from my scripts in my unit tests?

Bit of a noob question, but I’m having trouble getting unit testing working in Unity. I created a PlayMode test assembly, I toggled “Enable playmode tests for all assemblies” as directed in the manual, but when I try to edit the test script, Visual Studio still isn’t recognizing references to the classes I’ve written. There’s also no option to manually add a reference within Visual Studio. Am I doing something wrong, or is this some kind of bug? It’s hard to imagine what kind of unit testing you could even do without references to your main project.

Show, if possible, small isolated “islands” in the unit cube using RegionPlot3D

I have a certain three-dimensional constraint

-(1/3) < t3 < 1/3 && -(1/3) < t2 < 1/3 && 9 t1^2 < (1 - 3 t3)^2 && 9 t1^2 < (1 + 3 t3)^2 && t1^2 t2^2 t3^2 > 1/23328  . 

If I perform an integration over the unit cube $ [-1,1]^3$ , I obtain (using the GenericCylindricalDecomposition and FullSimplify command) the result

(1/(54 Sqrt[2]))(8 Sqrt[2 - Sqrt[2]] - ArcTanh[Sqrt[1 - 1/Sqrt[2]]] (8 + Log[128]) + Log[2 - Sqrt[4 - 2 Sqrt[2]]]^2 - Log[2 + Sqrt[4 - 2 Sqrt[2]]]^2 - 4 PolyLog[2, 1/4 (2 - Sqrt[4 - 2 Sqrt[2]])] + 4 PolyLog[2, 1/4 (2 + Sqrt[4 - 2 Sqrt[2]])] 

which evaluates to approximately 0.00221357, while, of course, the unit cube has a much larger volume, that is, $ 2^3=8$ .

I believe–on the basis of prior (“bound-entanglement” probability) considerations, that the regions in which the constraint is satisfied are disjointed and form an “archipelago” of islands.

However, my limited attempts (using various ranges of coordinates for the variables $ t1, t2, t3$ ) to show these presumed regions using RegionPlot3D just return vacuous plots.