This we can put in the Scneario class like the other rendering options

Ok :)

We can remove the origin as this will always be the physical origin in 0,0

Ok :)

Did you test what np.infty plots? does it work? Maybe there is a way to plot an infinite long line in pyglet, we should check, otherwise we can choose a very high value

Unfortunately, I haven't been able to test it yet, which is why I was hoping to get your feedback. :) In other instances, it seems to work fine.

Using np.infty doesn't seem like the best approach. I couldn't find any guidance on how to implement an infinite line or one that progressively extends. For now, the simplest option seems to be setting infinite_value to a very large number (perhaps 10^9?). What do you think?

Yeah that might be best

To test it just run a scenario of your choice and play with the args:

• one boundary only, both, none
• also play with the rendering settings in the Scenario base class to check that they do not affect the rendering of the boundaries

Ok, I have just tried this in navigation, it should works fine.

Let me resume what I have done in order to assess if it is ok:

• in use_vmas_env.py, I have just setted scenario_name="navigation" and enforce_bounds=True;
• in navigation.py, I have modified this if statement (just for this assessment)

  VectorizedMultiAgentSimulator/vmas/scenarios/navigation.py

  Line 56 in 26ceb42

  if self.enforce_bounds:

  in this

        if self.enforce_bounds:
            self.x_semidim = None # self.world_spawning_x
            self.y_semidim = self.world_spawning_y
        else:
            self.x_semidim = None
            self.y_semidim = None

• I have run the simulation and this is the rendering result:
  

If I try with y_semidim, the result is analogous.
It should be okay, what do you think?

looks very good

also try changing these settings from the make_world in navigation to check they interact well with the feature

Ops, yeah it should works well, I didn't say you previously :)

I have set:

• self.viewer_size = (640, 540)
• self.viewer_zoom = 0.6
• self.render_origin = (-2, 1)

Here the result:

Very cool! ok push and i ll review

In the case of only one boundary set we need just 2 lines not 4

In the case of only one boundary set we need just 2 lines not 4

Sorry, are you sure?

Eventhough are just two lines, in my opinion, we should specify 4 points. Anyway, I agree that the previous implementation drew a square/rectangle.

I think the point regards the for-loop for drawing lines, for this reason I suggest this new implementation. But I'm not understanding why it draws nothing in the case of just "two parallel lines".

if x_semi is not None and y_semi is not None: # drawing square/rectangle

    boundary_edges = [
        (-x_semi, y_semi),  # top_left
        (x_semi, y_semi),  # top_right
        (x_semi, -y_semi),  # bottom_right
        (-x_semi, -y_semi)  # bottom_left
    ]

    # Create lines to form the boundary by connecting each corner to the next
    for i in range(len(boundary_edges)):
        start = boundary_edges[i]  # Current corner point
        end = boundary_edges[
            (i + 1) % len(boundary_edges)]  # Next corner point, wrap around to the first point
        print(start, end)
        line = Line(start, end, width=0.7)  # Create a line between two corners
        line.set_color(*color)  # Set the line color
        self.viewer.add_onetime(line)  # Add the line to the viewer for rendering

else: # drawing two parallel lines

    # if only x_semi is provided, draw horizontal lines
    if x_semi is not None:
        boundary_edges = [
            (-x_semi, infinite_value),  # upper_left
            (x_semi, infinite_value),  # upper_right
            (-x_semi, -infinite_value),  # lower_left
            (x_semi, -infinite_value)  # lower_right
        ]

    # if only y_semi is provided, draw vertical lines
    elif y_semi is not None:
        boundary_edges = [
            (infinite_value, y_semi),  # right_top
            (infinite_value, -y_semi),  # right_bottom
            (-infinite_value, y_semi),  # left_top
            (-infinite_value, -y_semi)  # left_bottom
        ]

    else:
        boundary_edges = []

    # create the two parallel lines by connecting the points
    for i in range(0, len(boundary_edges), 2):
        start = boundary_edges[i]
        end = boundary_edges[i + 1]
        print(start, end)
        line = Line(start, end, width=0.7)
        line.set_color(*color)
        self.viewer.add_onetime(line)

What do you think?

I was wrong in labelling boundary_edges, the correct name should be boundary_points or something like this.

yes what you did is what i was thinking, still 4 points, but only draw 2 lines when only one semidim is available.

I do think we can write it a little more compactly tho:

• define the 4 points like before
• write only once the line creation loop making it work for 2 or 4 lines

if it is too difficult also as is it works, but more compact would look better

what we want to avoid is drawing 4 lines when only one semidim is available

this looks the same as the first part of the if

I have just fixed

• i think it was y not x
• always use is not None as it might trigger or not when it is 0 or not (imagine the nightmare)

Ok, thanks for this; should we add "is not None" also in the other parts?

oh i think all of this got a bit messed up, i'll let you test it and then i ll do the last test

Apologies for the caos :(

I wanted to ask if I should include 'is not None' in other if-statements like:

• x_semi = self.world.x_semidim if self.world.x_semidim else infinite_value --> x_semi = self.world.x_semidim if self.world.x_semidim is not None else infinite_value (and similarly for y_semi)
• 1 if (self.world.x_semidim and self.world.y_semidim) else 2 --> 1 if (self.world.x_semidim is not None and self.world.y_semidim is not None) else 2

I've tested all the scenarios with and without 'is not None,' and they worked fine.

But just to be on the safe side, as you suggested, I'll add 'is not None' wherever possible. Does that sound good?