hexagonal | Toy implementation instance | Architecture library

I am following this link for understanding hexagonal architecture with spring boot. The infrastructure section contains the configuration for the service bean and the repository is passed as a parameter as a below method.

Configuration

This code works for changing the value of href, which I can confirm because the alert alternates confirmation as expected. However, the is unchanging. What is the problem?

I'm testing a TOF camera from Broadcom. It has hexagonal pixels.

I wish to represent the histogram in 3D as in the utility of the constructor.

I tested the vedo library. But I can’t give the values in Z and reorder the cells and trace to the ground

I am trying to draw a hexagonal grid in a certain orientation. I had used a function which was provided in this answer, so i got something like this:

Now, i would like to have a hexagon grid which is not oriented in this way, but that one of the edges is on top, like this:

Here is the code used to plot the first graph:

I'm trying to draw a hexagonal grid with love2d using love.graphics.line but after drawing around 15000 lines the program crashes with only one message abort (core dumped).

I want to instantiate GameObjects(specifically hexagonal tiles) at the hexagonalCoodinates(hexcoordinates). For this I wrote a custom coordinate system. But I found out that unity doesn't accept anything other than Vector3 or transform. How do I make it do that? Or is there a easier way to do this?

This is the method to generate the gameObjects

I am confused about where to handle domain events in an application that is based on the hexagonal architecture. I am talking about the bounded-context-internal domain events, and not about inter-context integration/application/public events.

Background

As far as I understand, application logic (i.e. use case logic, workflow logic, interaction with infrastructure etc.) is where command handlers belong, because they are specific to a certain application design and/or UI design. Command handlers then call into the domain layer, where all the domain logic resides (domain services, aggregates, domain events). The domain layer should be independent of specific application workflows and/or UI design.

In many resources (blogs, books) I find that people implement domain event handlers in the application layer, similar to command handlers. This is because the handling of a domain event should be done in its own transaction. And since it could influence other aggregates, these aggregates must be loaded via infrastructure first. The key point however, is this: The domain event is torn apart and turned into a series of method calls to aggregates. This important translation resides in the application layer only.

Question

I consider the knowledge about what domain events cause what effects on other aggregates as an integral part of the domain knowledge itself. If I were to delete everything except my domain layer, shouldn't that knowledge be retained somewhere? In my view, we should place domain event handlers directly in the domain layer itself:

• They could be domain services which receive both a domain event and an aggregate that might be affected by it, and transform the domain event into one or many method calls.

• They could be methods on aggregates themselves which directly consume the entire domain event (i.e. the signature contains the domain event type) and do whatever they want with it.

Of course, in order to load the affected aggregate, we still need a corresponding handler in the application layer. This handler only starts a new transaction, loads the interested aggregate and calls into the domain layer.

Since I have never seen this mentioned anywhere, I wonder if I got something wrong about DDD, domain events or the difference between application layer and domain layer.

EDIT: Examples

Let's start with this commonly used approach:

I am developing a card game in HTML that shows real-time perspectives and card movements to all players.

All players are connected via socket.io.

BACKGROUND:

If there are 4 players, table is square and table HTML body is rotated based on player position on their screen.

The structure is like this:

I'm creating a tile-based game in Unity (C#) with a hexagonal grid. I am making hills and mountains in my game, and to optimize, I only activate the top layer of tiles and leave the rest of them inactive. I render each tile with a noise-based height map (please note the colors on the grid itself such as brown, green, and grey do not correspond to height).

However, I encounter issues when the hills become high and a vertical gap between one tile and the next reveals a hole in the map due to height disparities.

To fix this, I am making a retroactive function which cycles through each pixel on the noise map and if it detects a disparity between one pixel and another which borders it, then it will activate the tile below the higher tile in the disparity. The blue tiles below represent the tiles that it detected as being in a disparity, and the red ones are the tiles activated as a result of their higher counterparts being detected as such.

Most the time, however, the disparities are not recognized in the right positions. You can see in the image above that the brown tile which should be considered as having a disparity (since it's leaving a gap) has a gaping hole and no red tile beneath it, while others which have no gaps are considered as having disparities and are thus blue. Here is a representation of how there's little correlation between the height map and the disparities detected:

You can see above that the white on the height map, representing high areas, does not correspond with the blue on the grid, which should correspond with disparities (and thus mainly correspond with where the white and the black converge on the noise map, outlining the location between high and low areas).

Here is my code to detect disparities: