EDIT2: ended up improving the script, edited comments/code below

I believe I’ve resolved this problem. My solution is approximate, but that’s good enough for my purposes, and I’m only using walls that are longer on the y axis than they are on the x axis (a tall rectangle rotated about the center such that the x axis is width, is another way to put it). So, future people reading this, keep this in mind, this code is sort of particular if you’re not using sprite like I am.

Code below is a script I attached onto each slanted wall, explanation follows.

```
public class SlantedWalls : MonoBehaviour {
public float minX;
public float maxX;
public float minY;
public float maxY;
public float yForMinX;
public float yForMaxX;
public float xForMinY;
public float xForMaxY;
void Start () {
minX = GetComponent<SpriteRenderer>().bounds.min.x;
maxX = GetComponent<SpriteRenderer>().bounds.max.x;
minY = GetComponent<SpriteRenderer>().bounds.min.y;
maxY = GetComponent<SpriteRenderer>().bounds.max.y;
float decisionAngle = transform.rotation.eulerAngles.z % 180;
//Debug.Log(string.Format("I am {0}, my angle is {1}", this, decisionAngle));
if (decisionAngle < 90)
{
float xOffset = transform.localScale.x * (1 - ((transform.rotation.eulerAngles.z % 90) / 90));
float yOffset = transform.localScale.x * ((transform.rotation.eulerAngles.z % 90) / 90);
yForMinX = maxY - yOffset;
yForMaxX = minY + yOffset;
xForMinY = maxX - xOffset;
xForMaxY = minX + xOffset;
//Debug.Log(string.Format("maxY: {0}, rotation%90: {1}, rotation%90/90: {2}, thus yOffset: {3}, and so yForMinX: {4}", maxY, transform.rotation.eulerAngles.z % 90, ((transform.rotation.eulerAngles.z % 90) / 90), yOffset, yForMinX));
}
else
{
float xOffset = transform.localScale.x * ((transform.rotation.eulerAngles.z % 90) / 90);
float yOffset = transform.localScale.x * (1 - ((transform.rotation.eulerAngles.z % 90) / 90));
yForMinX = minY + yOffset;
yForMaxX = maxY - yOffset;
xForMinY = minX + xOffset;
xForMaxY = maxX - xOffset;
//Debug.Log(string.Format("minY: {0}, rotation%90: {1}, 1 - rotation%90/90: {2}, thus yOffset: {3}, and so yForMinX: {4}", minY, transform.rotation.eulerAngles.z%90, 1 - ((transform.rotation.eulerAngles.z % 90) / 90), yOffset, yForMinX));
}
//Debug.Log(string.Format("LMP: {0}, {1}", minX, yForMinX));
//Debug.Log(string.Format("TMP: {0}, {1}", xForMaxY, maxY));
//Debug.Log(string.Format("BMP: {0}, {1}", xForMinY, minY));
//Debug.Log(string.Format("RMP: {0}, {1}", maxX, yForMaxX));
}
}
```

Basically, I noticed that depending on the kind of angle used, the missing pieces were relatively close to other existing pieces, so I could use some inferring to figure the missing pieces out.

For example, if the slanted wall is mostly straight up and down, then the missing y values are close enough to the known y values, so the difference between the y values is small, about (transform.rotation.eulerAngles.z % 90) (example: 10 degrees / 90 = .11. With a width of 1, the missing y value from the left most point is .11 below max y, which is close to max y itself)

Alternatively, the missing x values are close to one width away from known x values, so a difference is used that is close to the width, or 1 - ((transform.rotation.eulerAngles.z % 90) / 90) (example: 10 degrees / 90 = .11, 1 - .11 = .89. with a width of 1, the missing x value from the top most point is .89 to the right of min x, which is close to one widths away from min x).

Whether the offset was added or removed depends which value is being inferred from which point. No magic here, I just looked at rotated rectangles and saw what needed to happen based on if the angle was > or < 90.

You could figure out which axis is longer instead of assuming y like I do, and make this script even more generic. Also you could fine tune the number for further accuracy, at the moment the resulting values look like they’re anywhere between 0 or .2 off.

Finally, I found that I only needed to solve for 180 degrees. Because I’m using the bounds, rotating past 180 degrees of rotation makes, say, min.x, equivalent to what it was at a small angle. This is why I created decisionAngle, and why it’s a mod 180 from the euler angles.