public void clearVision()
    {
            int countSize = visionField.Count;
            for (int i = 0; i < countSize; ++i)
            {
                if (visionField[i].gameObject != null)
                {
                    GameObject destroyme = visionField[i].gameObject;

                    GameObject.Destroy(destroyme);
                    visionField.Remove(visionField[i]);
                }
            }
        
    }

void Start () {
        
        if (Pathfinding.objectAtCoordsWithTag(mapX() + offsetX, mapY() + offsetY, "noLOS") == false)
        {
            newBlock(offsetX, offsetY, RayBeamBlock);
        }
        
        if(isRayStart)
        {
            if(offsetX != 0)
            {
                if (Pathfinding.objectAtCoordsWithTag(mapX() + offsetX, mapY() + 1, "LOSblock") == false && Pathfinding.objectAtCoordsWithTag(mapX() + offsetX, mapY() + 1, "noLOS") == false)
                {
                    newBlock(offsetX, 1, RayStartBlock);
                }

                if (Pathfinding.objectAtCoordsWithTag(mapX() + offsetX, mapY() - 1, "LOSblock") == false && Pathfinding.objectAtCoordsWithTag(mapX() + offsetX, mapY() - 1, "noLOS") == false)
                {
                    newBlock(offsetX, -1, RayStartBlock);
                }

            }
            if (offsetY != 0)
            {
                if (Pathfinding.objectAtCoordsWithTag(mapX() + 1, mapY() + offsetY, "LOSblock") == false && Pathfinding.objectAtCoordsWithTag(mapX() + 1, mapY() + offsetY, "noLOS") == false)
                {
                    newBlock(1, offsetY, RayStartBlock);
                }

                if (Pathfinding.objectAtCoordsWithTag(mapX() - 1, mapY() + offsetY, "LOSblock") == false && Pathfinding.objectAtCoordsWithTag(mapX() - 1, mapY() + offsetY, "noLOS") == false)
                {
                    newBlock(-1, offsetY, RayStartBlock);
                }

            }
        }
	}
	
	// Update is called once per frame
	void Update () {
	
	}

    private void newBlock (int offX, int offY, GameObject o)
    {
        GameObject newRay = (GameObject)Pathfinding.instantiateAtCoordinates(o, new MapXY(mapX() + offX, mapY() + offY));
        newRay.GetComponent<MapXY>().X = mapX() + offX;
        newRay.GetComponent<MapXY>().Y = mapY() + offY;
        newRay.GetComponent<LOSblock>().offsetX = offsetX;
        newRay.GetComponent<LOSblock>().offsetY = offsetY;
        newRay.GetComponent<LOSblock>().parent = parent;

        //Add the new LOSblock to the parent List of LOSblocks.
        parent.gameObject.GetComponent<LineOfSight>().visionField.Add(newRay.GetComponent<LOSblock>());
    }

public static bool objectAtCoordsWithTag(int x, int y, string tag)
    {
        Collider[] foundObjects = Physics.OverlapSphere(GameObject.Find("GameController").GetComponent<EncounterController>().LevelMap.contents[x, y].transform.position, 0.1F);

        for (int i = 0; i < foundObjects.Length; ++i)
        {
            if (foundObjects[i].GetComponent<HGtags>().hasTag(tag))
            {
                if(tag == "LOSblock")
                {
                    Debug.Log("PATHFINDING: LOSblock found at [" + x + "," + y + "]. Object is " + foundObjects[i].name);
                }
                return true;
            }
        }

        return false;
    }

public void clearVision()
    {
        int countSize = visionField.Count;
        for (int i = 0; i < countSize; ++i)
            {
            //if (visionField[i].gameObject != null)
            if (visionField[i] != null)
            {
                //GameObject destroyme = visionField[i].gameObject;
                GameObject destroyme = visionField[i];
                GameObject.Destroy(destroyme);
            }
        }

        visionField.Clear();
    }

DStecks fucked around with this message at 16:08 on Oct 8, 2015

Ranzear fucked around with this message at 09:10 on Oct 9, 2015

And now I've got an awesome new problem that fails for no good reason.

So, in my game, I'm using a class to hold tags for in-game objects (to specify if they're a map tile or if they block line of sight, for example). And my code that constructs an A* navigation map from the map tiles checks these tags when doing an OverlapSphere so that I don't get silliness going on. I'm now at the point in development where I need to move forward to a more advanced prototype, so I've created a new scene. The OverlapSphere is being created in the correct position, and is finding the tiles, but for some reason they don't have the assigned tags from the prefab, even though it shows that they do in the inspector:





"NOGOUpperFarLeft" is a tile I copied-and-pasted from the first, working, TEST scene. TestTileNOGOPrefab (50) is obviously created from a prefab. Notice their identical tags in the inspector.

DStecks fucked around with this message at 17:12 on Oct 9, 2015

Jewel fucked around with this message at 18:24 on Oct 9, 2015

Rocko Bonaparte fucked around with this message at 23:47 on Oct 9, 2015

MikeJF fucked around with this message at 06:22 on Oct 10, 2015

1. Do you want what is pretty much an evenly spaced grid of points, like this:
   
   
   
   except that instead of a precise coordinate for each point, the point lies in a random location in the black circles? If so, that's very easy, all you need to do is add a random number around zero to each point's x and y value.
   
   
2. Do you want a field of K random points within some space of dimensions MxN such that any regularly-spaced subspace of size LxL will have about K*L*L/(M*N) points per window? (e.g if you had a 100x100 space filled with 100 random points and looked at 20x20 windows, you'd want about 4 points per window) Then you want to use your regular squares idea, except there's no need to recompute the random seed for each cell. This kind of approach isnt considered inelegant at all. In fact, this class of algorithm has a formal name - a Monte Carlo method - and has been used to solved problems that people previously considered impossible to solve without it.
   
   In your case, first, break up your space into a grid, as you say. The important thing to think about here is how finely you want to space your grid. The more you want to overlap windows, the finer the grid needs to be spaced. For example, for a 100x100 grid and 20x20 windows with N points per window, if you want to ensure you have the same number of points for 20x20 windows starting at every 10 coordinates (e.g. windows starting at x:0/y:0, x:0/y:10, x:10/y:0, x:10/y:10, etc), then your grid spacing needs to be 10x10, not 20x20, and you'll subsequently look for N/4 points per 10 by 10 grid space instead of N points for every 20x20. (This is because of the Nyquist-Shannon sampling theorem, if you're interested). Likewise, if you want 20x20 windows starting every 5 coordinates, then you'll limit each 5x5 grid space to N/16 points.
   
   Anyways, now you have a grid, and so the next thing to do is start shoveling points into it. For now, think of each grid cell as a bucket. We want N points in each bucket, and there's a bunch of different ways to get that depending on what kind of spacing constraints you have. The most straight-forward is to just loop over each bucket and generate N random points (x from 0 to grid width, y from 0 to grid height) in each of them, adding the grid cell's starting x/y offset to each point. That's the simplest/fastest method by far. However, note that this method doesn't actually do anything about spacing; you could end up with two grid cells that have all their points along adjacent walls. What you can do about this is to use some kind of importance sampling, which means to reject a random point if it's within a certain distance to other already-generated points (note you need to check not only the current cell's points but also all adjacent cells' points). However, this can be really difficult or very time-consuming depending on your requirements. You can help the algorithm out by generating the random numbers in a more sophisticated way, but this can get fudgey. A more predictable way is to use "Poor Man's Importance Sampling," which means to just generate way more points than what you need, say, N*N points per cell (the more points you generate, the more even your spacing will be in the end, but the slower the algorithm will be), and then loop through the cells, chucking out the point that's closest to any other point on each pass. (again, remember that you need to check not only the current cell but all adjacent cells for this) Eventually, you get down to N random points in each cell, just like what you had previously, except now they should be spaced a lot more evenly.
   
   
3. Do you not actually want a regular grid filled with random points, but something that's kind of like a grid, but slightly random? That's called a random mesh. In that case, look into Voronoi diagrams that have had Lloyd relaxation applied to them. The more the diagram is relaxed, the more regular it will be; of course, the slower your code will be too. Something like this shows the idea, if you look at just the dots and not the shapes: http://www.raymondhill.net/voronoi/rhill-voronoi-demo5.html You could also use something like Lloyd's algorithm on the N-points-per-bucket method from above, although I'm not sure whether it'll actually be more computationally efficient than the N-squared-points-per-bucket method for a given variance of closest-point-distance because you'll need to compute extra stuff. It depends on how much you care about computational efficiency, I guess.
   

German Joey fucked around with this message at 14:04 on Oct 11, 2015

MikeJF fucked around with this message at 12:03 on Oct 11, 2015

Ranzear fucked around with this message at 10:33 on Oct 12, 2015

if(angle < 0)
      angle = angle + 360;
return angle % 360;

if(angle > 180)
     angle = angle - 360;
if (angle < -180)
     angle = angle + 360;
return angle % 360; 

emanresu tnuocca fucked around with this message at 18:49 on Oct 12, 2015

Sex Bumbo fucked around with this message at 19:05 on Oct 12, 2015