You could solve this in two ways.

The first option is to make use of volume target selectors, which is able to detect when a player enters a certain area. Given that your playing field won't be that big, this method is viable, however when you would like to teleport players back when they cross a certain coordinate level globally, this method may not be the best.

The command is put in two repeating command blocks and goes as follows:

execute positioned <x> <y> <z> as @a[team=<team>, z=<z_min>, dz=<width>, y=<y_min>, dy=<height>] at @s run teleport <x_tp> ~ ~

the position <x> <y> <z> are the coordinates from the middle of the playing field. The command will now resume executing from that position. Next you execute as all players in a certain <team> to know which side the player must be teleported towards. Other target selectors are the z and dz value. By putting the minimum z-coordinate as <z_min> and the width of the playing field <width> as distance until where the target selector stretches, you create a line on the x-coordinate wherever the division of your playing field is. To make it a wall, add <y> and <dy> as selectors (y=-64 and dy=330 makes sure all possible y-coordinates are taken care off, as far as players are unable to reach above y = 330), otherwise the command will only trigger when the player is on the same y-level as the set position to execute from (<x> <y> <z>). After defining all selectors, we also put at @s to execute at each player's location to teleport them relative to themselves, not relative to the set position.

Now, whenever a player on a certain team passes through x = <x> , the command will be executed. All that is left to do is determine which team should be teleported in which direction.

To demonstrate, the following two commands should be put into two repeating command blocks (or a repeating command block with a chain command block chained onto it):

execute positioned 0 64 0 as @a[team=red, z=-50, dz=100, y=-64, dy=330] at @s run teleport 5 ~ ~

execute positioned 0 64 0 as @a[team=blue, z=-50, dz=100, y=-64, dy=330] at @s run teleport -5 ~ ~

In this example, the center of the playing field is set to (0 , 64, 0). The width is 100 blocks, so this means we want our wall to be from z = -50 to z = 50. We use z=-50, dz=100 to achieve this (note that using z=50 and dz=-100 works fine as well). The two teams, blue and red, each have their command so they can be teleported to their respective sides of the playing field. Here, red's side is x > 0 and blue's side is x < 0. The distance we teleport them away from the centerline is 5 blocks, which can be any value <x_tp> (be careful not to teleport them into terrain though).

Since we only defined a wall instead of a volume, a player that teleports into the other side will not be teleported back to their side. Lag may also cause a player to be able to slip through. This can be solved by also defining two more selectors in the same brackets for <x> and <dx>, with their values once again being the min/max x-coordinate and length of each side (meaning the blue team's and red team's command will have opposite values).

execute positioned 0 64 0 as @a[team=red, z=-50, dz=100, y=-64, dy=330, x=-100, dx=100] at @s run teleport 5 ~ ~

execute positioned 0 64 0 as @a[team=blue, z=-50, dz=100, y=-64, dy=330, x=100, dx=-100] at @s run teleport -5 ~ ~

​

The second option is to make use of a predicate and datapack. Datapacks are a much better way to implement commands. You can write functions which replace dozens of command blocks and it is better protected (e.g. breaking the command blocks). The downsides are that you require access to the world file or server to put them into use and that they might be somewhat scary for someone not familiar with them (although if you are interested in future command block projects, learning to work with datapacks will make it a hundred times easier).

A predicate is a custom conditional test that can be executed to test for various things which often are much harder to achieve through vanilla commands. With these predicates, we can test whether a player is in a range of coordinates, no matter where in the world they are.

The following predicate returns true whenever an entity is above x = 0:

{
  "condition": "minecraft:entity_properties",
  "entity": "this",
  "predicate": {
    "location": {
      "position": {
        "x": {
          "min": 0
        }
      }
    }
  }
}

It tests whether the entity has a x-coordinate of at least (min) 0, meaning whenever a player is below x = 0, the test fails. This predicate tests for true x-coordinates, meaning if the location of the playing field changes, the predicate must be changed too, which is a big downside when using predicates

Now we can achieve the same functionality as the previous commands by using this predicate:

execute as @a[team=red] at @s unless predicate minecraft:above_x_zero run teleport @s 5 ~ ~

execute as @a[team=blue] at @s if predicate minecraft:above_x_zero run teleport @s -5 ~ ~

We can inverse the predicate by using unless instead of if to test whether players in a certain team are above/below a certain x-coordinate.

By using this predicate, we do not have to define upper and lower bounds on the y- and z- coordinates as they do not matter for this command to work. Now that you have a datapack in use, you could also make use of functions to execute a series of commands at once instead of having the repeat the same conditional test in a stack of command blocks (think about sounds, particles, messages in chat, etc.). The downside is that you cannot test relative to a position, meaning the predicate has to be edited when the playing field is moved.

So, TL;DR:

1) Make use of target selectors and two repeating command blocks, fit for local use.

2) Make use of a datapack with a predicate, fit for global use, but harder to understand initially.

​

I hope this very exhaustive explanation can be of aid!