Endogine sprite engine

5:46 9 Jul '08

I like Endogine but i have one question: how to clear screen? (delete all sprites, texts, etc)
Sign In·View Thread·PermaLink

7:28 9 Jul '08

If you have references to all the Sprite-derived instances, just Dispose() them, otherwise you can iterate through the root sprite's (normally Stage.DefaultParent) children and Dispose() those, and they will dispose all their children recursively.

If you're going to use the engine seriously, I can provide a link to the latest version. There have been massive additions (and some breaking changes) to it since the last update here, but I haven't had time to rewrite the article or create tutorials for it.

8:29 9 Jul '08

will be very good if you will give me link to latest version
Sign In·View Thread·PermaLink

Re: How to clear screen? [modified]

13:00 9 Jul '08

It's available now at
http://flowlabs.net/Download/Endogine080709.rar

I've had to remove some resources and projects because of copyright issues (eg BASS libraries), so you might get a few error messages when opening the solution, but you should be able to just ignore them.

Unfortunately, I won't have time to give any support ATM, so I'm afraid you're on your own - don't throw away your old projects just yet Wink

5.00/5 (1 vote)

0:08 10 Jul '08

thanks ps yeah, there some errors with the vectronica and vectronicaapp (not found) and tao, bass, irrlicht... which versions of irrlicht and tao i should use? modified on Thursday, July 10, 2008 6:28 AM
Sign In·View Thread·PermaLink

Re: How to clear screen? [modified]

2:42 10 Jul '08

The OpenGL renderer is experimental, you should exclude that projects from the solution. The Irrlicht renderer, which provides DX/OGL/Software modes, actually works pretty OK, but I had to add some features to the Irrlicht engine so it's not one of the standard dlls (and there's still work to do on it). You can download my Irrlicht dlls here: http://flowlabs.net/Download/Irrlicht.rar
Sign In·View Thread·PermaLink

Displaying JPG image bytes on the form using Direct X

3:20 10 Jul '08

thanks for the help it's hard to find engine like this (usualy they all commercial) modified on Thursday, July 10, 2008 8:27 AM
Sign In·View Thread·PermaLink

sraddhan

20:32 28 Feb '08

Hi Jonas,

I am developing a project, where in I am suppose to display jpeg images from MJPEG stream recieved from IP camera.

Current Status:
Out of that continuous JPEG stream JPEG images are extracted successfully. Right now the JPEG images are being displayed on the picture box. e.g. pictureBox1.Image = image.

Problem:
But CPU utilization is quite high. [for 5+ mega pixel image CPU utilization is 65%]

Hopeful way:
Using Direct X, I think CPU utilization can be reduced upto 5%.

Question:
Is there any way I can use Direct X which takes jpeg bytes and then renders them on the control.

Any help would be appreciated.

Thanks,
Sraddhan

PS: Anybody reading this thread is also welcomed to answer.

Re: Displaying JPG image bytes on the form using Direct X

Re: Where is the project at?

4:40 29 Feb '08

Hi, using DirectX to show the decoded images will probably help a little bit, but you won't get nowhere near 5%, as the decoding process is probably what takes most of the CPU cycles. It might be possible to use some of the later GPUs with video decoding support to decrease CPU workload, but I haven't studied the issue myself so I can't really say. HTH, Jonas
Sign In·View Thread·PermaLink

AStar Path Finding

PBirch

22:55 17 Sep '07

I wanted to send a thanks for your contribution. I used your AStar routine as the basis of a rewrite to encapsulate the implementation a bit more. It's about 90% as far as features (needs some more events defined) but from testing so far functionally it appears pretty clean. I'd love to hear your thoughts.

Below is:
AStarSearcher
AStarNode
AStarSearchResult

and an Init routine for the search nodes

/******************************
AStarSearcher
******************************/

public class AStarSearcher
  {
    private Vector3 _minBoundary;
    private Vector3 _maxBoundary;

    private bool _paused = false;
    private bool _sorted = false;

    private List _nodeList = new List();
    private List _tempNodes = new List();

    public event EventHandler OnNodeAdded;
    public event EventHandler OnNodeRemoved;

    public AStarSearcher(Vector3 MinBoundary, Vector3 MaxBoundary)
    {
      _minBoundary = MinBoundary;
      _maxBoundary = MaxBoundary;
      InitializeNodes();
    }

    // Need to be able to add and remove nodes from the nodeList

    public void InitializeNodes()
    {
      _nodeList = new List();
      InitializeTempNodes();
    }

    public void InitializeTempNodes()
    {
      // Detatch from all relations
      for (int i = 0; i < _tempNodes.Count; i++)
      {
        RemoveTempNode(_tempNodes[0]);
      }
      // Don't need to reset to new node list since it's now empty
      // but for good measure...
      _tempNodes = new List();
    }

    public void AddNode(Vector3 Position)
    {
      AStarNode node = new AStarNode(this, Position);
      AddNode(node);
    }

    public void AddNode(AStarNode Node)
    {
      if(!IsInBounds(Node.Position))
      {
        throw new Exception("Node out of bounds");
      }
      _nodeList.Add(Node);
      _sorted = false;
      NodeAdded(Node);
    }

    public void AddTempNode(AStarNode Node)
    {
      if (!IsInBounds(Node.Position))
      {
        throw new Exception("Temp node out of bounds");
      }
      _tempNodes.Add(Node);
      NodeAdded(Node);
      // Look into setting the temp nodes availability to
      // that of the closest real node
    }

    public void RemoveNode(AStarNode Node)
    {
      if (!_nodeList.Contains(Node))
      {
        return;
      }
      _nodeList.Remove(Node);
      NodeRemoved(Node);
    }

    public void RemoveTempNode(AStarNode Node)
    {
      if (!_tempNodes.Contains(Node))
      {
        return;
      }
      _tempNodes.Remove(Node);
      NodeRemoved(Node);
    }
    
    public List GetSearchNodes()
    {
      // Search scope is the list of nodes and temp nodes together
      List result = new List();
      result.AddRange(_nodeList);
      result.AddRange(_tempNodes);
      return result;
    }

    public void SortNodes()
    {
      if (!_sorted)
      {
        _nodeList.Sort(AStarNode.ByPosition);
        _sorted = true;
      }
    }

    public void UpdateCost(AStarNode Node, List Goals)
    {
      // Manhattan might be faster but the results get skewed for
      // diagonal results so no good
      double costToStart = 0;
      if (Node.Parent != null)
      {
        // Put an emphasis on the cost to move so best path is followed
        // With the right node layout this can encourage a better overall path
        // But there may be some pitfalls with irregularly spaced nodes
        double distance = Node.Position.Distance(Node.Parent.Position);
        costToStart = Node.Parent.CostToStart + Node.Parent.Cost + (distance * distance);
      }
      Node.CostToStart = costToStart;
      // Get the average distance of all goals
      // Might be a better way to calc this and/or allow weighting for goal priorities
      Node.CostToGoal = GetAverageDistance(Node, Goals);
      Node.TotalCost = Node.CostToStart + Node.CostToGoal + Node.Cost;
    }

    public double GetAverageDistance(AStarNode Node, List Available)
    {
      if (Available.Count == 0)
      {
        return 0;
      }
      double result = 0;
      foreach (AStarNode node in Available)
      {
        result += Node.Position.Distance(node.Position);
      }
      return result / Available.Count;
    }

    public AStarNode FindClosestNode(AStarNode Node, List Available)
    {
      if (Available.Count == 0)
      {
        return Node;
      }
      double min = Node.Position.Distance(Available[0].Position);
      int index = 0;
      for (int i = 1; i < Available.Count; i++)
      {
        double d = Node.Position.Distance(Available[i].Position);
        if (d < min)
        {
          min = d;
          index = i;
        }
      }
      return Available[index];
    }

    /// 
    /// Tries to find the best path to the destination or goal location
    /// 

    /// The end point of the path
    /// The result of the search and, if successful, the path
    public AStarSearchResult FindShortestPath(Vector3 Start, Vector3 Goal)
    {
      List goals = new List();
      goals.Add(Goal);
      return FindShortestPath(Start, goals);
    }

    /// 
    /// Tries to find the shortest path to the nearest destination or goal location
    /// 

    /// Available end points to choose from
    /// The result of the search and, if successful, the path
    public AStarSearchResult FindShortestPath(Vector3 Start, List Goals)
    {
      // Must have at least one goal to choose from
      if(Goals.Count == 0)
      {
        return new AStarSearchResult();
      }
      // Clear any temp nodes
      InitializeTempNodes();
      // Housekeeping lists
      List openNodes = new List();
      List closedNodes = new List();
      // Create the path container
      List solution = new List();
      // Get the list of goal nodes to check against for success
      List goalNodes = ConvertGoalsToNodes(Goals);
      // Get the starting node
      AStarNode startNode = ConvertToStartNode(Start);
      // Add the start node to the open list
      openNodes.Add(startNode);
      // Set startNode as the current to begin with
      AStarNode current = startNode;

      UpdateCost(startNode, goalNodes);
      // Keep searching until all possibilities are exhausted (no path avail)
      // Could be tweaked to provide best attempt if goal can't be reached
      while (openNodes.Count > 0)
      {
        // Find the cheapest node in the open list
        current = RemoveCheapestNode(openNodes);
        // No nodes found in the open list
        if (current == null)
        {
          return new AStarSearchResult();
        }
        // Have we found a goal node yet?
        if (goalNodes.Contains(current))
        {
          // Walk up the parent chain to build the path
          while (current != null)
          {
            solution.Insert(0, current.Position);
            current = current.Parent;
          }
          AStarSearchResult result = new AStarSearchResult(solution);
          return result;
        }
        // Haven't found it yet
        // Get all related nodes... from current
        List relatedNodes = current.RelatedNodes;
        foreach (AStarNode relatedNode in relatedNodes)
        {
          // Check if the related node can be traversed
          if (!relatedNode.Available)
          {
            continue;
          }
          // Make sure the node hasn't already been queued
          if (openNodes.Contains(relatedNode) || closedNodes.Contains(relatedNode))
          {
            continue;
          }
          // Create the relationship to the current node
          relatedNode.Parent = current;
          // Update the cost of the related node to reflect the parent cost
          UpdateCost(relatedNode, goalNodes);
          // Add the new node to the list to be searched
          openNodes.Add(relatedNode);
        }
        closedNodes.Add(current);
      }
      // Search failed with no results
      return new AStarSearchResult();
    }

    public AStarNode GetClosestNode(AStarNode Node)
    {
      SortNodes();
      // this should work if the node list is sorted by position
      foreach (AStarNode node in _nodeList)
      {
        if (Node.Position.X < node.Position.X && Node.Position.Y < node.Position.Y)
        {
          return node;
        }
      }
      // No nodes were smaller in x and y so take the greatest x, y node
      return _nodeList[_nodeList.Count - 1];
    }

    public void BindToClosestNode(AStarNode Node)
    {
      // Get the closest node from the perm list
      AStarNode closest = GetClosestNode(Node);
      // Add it as a relation
      Node.AddRelatedNode(closest);
      // Bind to the three closest to surround the new node as tight as possible
      // Sort the potential related nodes by distance
      Comparison byDistance = delegate(AStarNode One, AStarNode Two)
      {
        double distOne = Node.Position.Distance(One.Position);
        double distTwo = Node.Position.Distance(Two.Position);
        return distOne.CompareTo(distTwo);
      };
      closest.RelatedNodes.Sort(byDistance);
      // Borrow it's two closest relationships
      Node.AddRelatedNode(closest.RelatedNodes[0]);
      Node.AddRelatedNode(closest.RelatedNodes[1]);
    }

    // Can change ConvertToStartNode and ConvertGoalsToNodes to find
    // the closest node instead of exact matches to simulate 'snap-to'
    // like searching
    public AStarNode ConvertToStartNode(Vector3 Start)
    {
      // Look for the start in the current search nodes
      foreach (AStarNode node in GetSearchNodes())
      {
        if (node.Position == Start)
        {
          return node;
        }
      }
      // Create a temp node for the start
      AStarNode startNode = new AStarNode(this, Start);
      BindToClosestNode(startNode);
      // Add it to the temp nodes to put it in the search scope
      AddTempNode(startNode);
      return startNode;
    }

    public List ConvertGoalsToNodes(List Goals)
    {
      List goalNodes = new List();
      foreach (Vector3 goal in Goals)
      {
        bool found = false;
        // Look at all current search nodes for a match
        foreach (AStarNode node in GetSearchNodes())
        {
          // The goal is already a node
          if (node.Position == goal)
          {
            goalNodes.Add(node);
            found = true;
            break;
          }
        }
        if (!found)
        {
          // Create a temp node for the goal
          AStarNode goalNode = new AStarNode(this, goal);
          BindToClosestNode(goalNode);
          // Add it to the result list
          goalNodes.Add(goalNode);
          // Add it to the temp nodes to allow it to be searched for
          AddTempNode(goalNode);
        }
      }
      return goalNodes;
    }

    public AStarNode RemoveCheapestNode(List Nodes)
    {
      if (Nodes.Count == 0)
      {
        return null;
      }
      double min = Nodes[0].TotalCost;
      int index = 0;
      for (int i = 1; i < Nodes.Count; i++)
      {
        if (Nodes[i].TotalCost < min)
        {
          min = Nodes[i].TotalCost;
          index = i;
        }
      }
      AStarNode result = Nodes[index];
      Nodes.RemoveAt(index);
      return result;
    }

    public bool IsAvailable(AStarNode Node)
    {
      if (!IsInBounds(Node.Position))
      {
        return false;
      }
      if (!Node.Available)
      {
        return false;
      }
      return true;
    }

    public bool IsInBounds(Vector3 Position)
    {
      return
        Position.X > _minBoundary.X &&
        Position.Y > _minBoundary.Y &&
        Position.X < _maxBoundary.X &&
        Position.Y < _maxBoundary.Y;
    }

    private void NodeAdded(AStarNode Node)
    {
      if (OnNodeAdded != null)
      {
        AStarNodeEventArgs args = new AStarNodeEventArgs(Node);
        OnNodeAdded(this, args);
      }
    }

    private void NodeRemoved(AStarNode Node)
    {
      if (OnNodeRemoved != null)
      {
        AStarNodeEventArgs args = new AStarNodeEventArgs(Node);
        OnNodeRemoved(this, args);
      }
    }
  }

/*****************************************
AStar Node
*****************************************/

public class AStarNode : IComparable
  {
    // Provide a mechanism for an outside party to provide the node's cost
    private AStarSearcher _owner = null;
    private AStarNode _parent = null;
    private List _relatedNodes = new List();
    private Vector3 _position;
    private bool _available = true;
    private double _cost = 0;
    private double _totalCost = 0;
    private double _costToStart = 0;
    private double _costToGoal = 0;

    public event EventHandler OnParentChanged;
    public event EventHandler OnPositionChanged;
    public event EventHandler OnAvailableChanged;
    public event EventHandler OnCostChanged;
    public event EventHandler OnTotalCostChanged;
    public event EventHandler OnCostToStartChanged;
    public event EventHandler OnCostToGoalChanged;
    public event EventHandler OnRelated;
    public event EventHandler OnUnRelated;

    public AStarNode(AStarSearcher Owner)
    {
      Initialize(Owner, new Vector3(0, 0, 0));
    }

    public AStarNode(AStarSearcher Owner, Vector3 Position)
    {
      Initialize(Owner, Position);
    }

    private void Initialize(AStarSearcher Owner, Vector3 Position)
    {
      _owner = Owner;
      _position = Position;
      _owner.OnNodeRemoved += new EventHandler(_owner_OnNodeRemoved);
    }

    void _owner_OnNodeRemoved(object sender, AStarNodeEventArgs e)
    {
      if (!_relatedNodes.Contains(e.Node))
      {
        return;
      }
      _relatedNodes.Remove(e.Node);
    }

    public void Dispose()
    {
      _parent = null;
    }

    public AStarNode Parent
    {
      get
      {
        return _parent;
      }
      set
      {
        if (_parent == value)
        {
          return;
        }
        _parent = value;
        if (_parent == null)
        {
          CostToStart = 0;
          return;
        }
        ParentChanged();
      }
    }

    public List RelatedNodes
    {
      get
      {
        return _relatedNodes;
      }
    }

    public Vector3 Position
    {
      get
      {
        return _position;
      }
      set
      {
        if(_position == value)
        {
          return;
        }
        _position = value;
        PositionChanged();
      }
    }

    public bool Available
    {
      get
      {
        return _available;
      }
      set
      {
        if (_available == value)
        {
          return;
        }
        _available = value;
        AvailableChanged();
      }
    }

    public double Cost
    {
      get
      {
        return _cost;
      }
      set
      {
        if (_cost == value)
        {
          return;
        }
        _cost = value;
        CostChanged();
      }
    }

    public double TotalCost
    {
      get
      {
        return _totalCost;
      }
      set
      {
        if (_totalCost == value)
        {
          return;
        }
        _totalCost = value;
        TotalCostChanged();
      }
    }

    public double CostToStart
    {
      get
      {
        return _costToStart;
      }
      set
      {
        if (_costToStart == value)
        {
          return;
        }
        _costToStart = value;
        CostToStartChanged();
      }
    }

    public double CostToGoal
    {
      get
      {
        return _costToGoal;
      }
      set
      {
        if (_costToGoal == value)
        {
          return;
        }
        _costToGoal = value;
        CostToGoalChanged();
      }
    }

    public void Reset()
    {
      Cost = 1;
      TotalCost = 0;
      CostToStart = 0;
      CostToGoal = 0;
      Parent = null;
    }

    private void ParentChanged()
    {
      if (OnParentChanged != null)
      {
        AStarNodeEventArgs args = new AStarNodeEventArgs(this);
        OnParentChanged(this, args);
      }
    }

    private void PositionChanged()
    {
      if (OnPositionChanged != null)
      {
        AStarNodeEventArgs args = new AStarNodeEventArgs(this);
        OnPositionChanged(this, args);
      }
    }

    private void AvailableChanged()
    {
      if (OnAvailableChanged != null)
      {
        AStarNodeEventArgs args = new AStarNodeEventArgs(this);
        OnAvailableChanged(this, args);
      }
    }

    private void CostChanged()
    {
      if (OnCostChanged != null)
      {
        AStarNodeEventArgs args = new AStarNodeEventArgs(this);
        OnCostChanged(this, args);
      }
    }

    private void TotalCostChanged()
    {
      if (OnTotalCostChanged != null)
      {
        AStarNodeEventArgs args = new AStarNodeEventArgs(this);
        OnTotalCostChanged(this, args);
      }
    }

    private void CostToStartChanged()
    {
      if (OnCostToStartChanged != null)
      {
        AStarNodeEventArgs args = new AStarNodeEventArgs(this);
        OnCostToStartChanged(this, args);
      }
    }

    private void CostToGoalChanged()
    {
      if (OnCostToGoalChanged != null)
      {
        AStarNodeEventArgs args = new AStarNodeEventArgs(this);
        OnCostToGoalChanged(this, args);
      }
    }
    private void Related(AStarNode Other)
    {
      if (OnRelated != null)
      {
        AStarRelatedNodesEventArgs args = new AStarRelatedNodesEventArgs(true, this, Other);
        OnRelated(this, args);
      }
    }

    private void UnRelated(AStarNode Other)
    {
      if (OnUnRelated != null)
      {
        AStarRelatedNodesEventArgs args = new AStarRelatedNodesEventArgs(false, this, Other);
        OnUnRelated(this, args);
      }
    }

    /// 
    /// Add this node to the target node and create the opposite relation as well
    /// 

    /// The other node to create the relation to
    public void AddRelatedNode(AStarNode RelatedNode)
    {
      if (RelatedNode == this)
      {
        return;
      }
      if (_relatedNodes.Contains(RelatedNode))
      {
        return;
      }
      _relatedNodes.Add(RelatedNode);
      // Could avoid possible repeat calls on add but related node list should
      // be short enough that it would only be a marginal savings
      RelatedNode.AddRelatedNode(this);
      Related(RelatedNode);
    }

    public void RemoveRelatedNode(AStarNode RelatedNode)
    {
      if (!_relatedNodes.Contains(RelatedNode))
      {
        return;
      }
      _relatedNodes.Remove(RelatedNode);
      RelatedNode.RemoveRelatedNode(RelatedNode);
      UnRelated(RelatedNode);
    }

    public static Comparison ByTotalCost
    {
      get
      {
        return delegate(AStarNode one, AStarNode two)
        {
          return one.TotalCost.CompareTo(two.TotalCost);
        };
      }
    }

    public static Comparison ByPosition
    {
      get
      {
        return delegate(AStarNode one, AStarNode two)
        {
          // sort primarily by x
          int x = one.Position.X.CompareTo(two.Position.X);
          if (x != 0)
          {
            return x;
          }
          // if x is the same then sort by y
          return one.Position.Y.CompareTo(two.Position.Y);

        };
      }
    }

    #region IComparable Members

    public int CompareTo(AStarNode other)
    {
      return this.Position.CompareTo(other.Position);
    }

    #endregion
  }

/***********************************
AStar Search Results
***********************************/

public class AStarSearchResult
  {
    private List _solution;
    private bool _foundSolution;

    public AStarSearchResult()
    {
      _foundSolution = false;
      _solution = new List();
    }

    public AStarSearchResult(List Solution)
    {
      if (Solution.Count == 0)
      {
        _foundSolution = false;
        return;
      }
      _foundSolution = true;
      _solution = Solution;
    }

    public bool FoundSolution
    {
      get
      {
        return _foundSolution;
      }
    }

    public List Solution
    {
      get
      {
        return _solution;
      }
    }
  }

/***************************************
AStart Provider initialization routine
This routine is for square tiles but the nature of the
searcher is such that is can support other board
types
Also, if the state of the nodes can be linked to the
state of the board via events or an observer etc
you should only need to init once so subsequent searches
benefit from the one time cost to build
***************************************/

public void InitAStarSearcher(AStarSearcher PathProvider, GameBoard GameBoard)
    {
      PathProvider.InitializeNodes();
      AStarNode[,] primaryNodes = new AStarNode[GameBoard.TilesAcross, GameBoard.TilesDown];
      AStarNode[,] secondaryNodes = new AStarNode[GameBoard.TilesAcross - 1, GameBoard.TilesDown - 1];
      // Add all the tile nodes
      for (int x = 0; x < GameBoard.TilesAcross; x++)
      {
        for (int y = 0; y < GameBoard.TilesDown; y++)
        {
          // Get top left position for the tile 
          // offset by half for the center points
          double left = GameBoard.Tiles[x, y].Left + (_width / 2);
          double top = GameBoard.Tiles[x, y].Top + (_height / 2);
          AStarNode primaryNode = new AStarNode(PathProvider, new Vector3(left, top, 0));
          // Need to link the tile to the node somehow (observer)
          // Node is available if the tile is available
          primaryNode.Available = GameBoard.Tiles[x, y].Terrain.LandPassable;
          primaryNodes[x, y] = primaryNode;
          PathProvider.AddNode(primaryNode);
          // Get top left starting from second row & col
          // This give the cross point for each tile
          if (x > 0 && y > 0)
          {
            AStarNode secondaryNode = new AStarNode(PathProvider, new Vector3(GameBoard.Tiles[x, y].Left, GameBoard.Tiles[x, y].Top, 0));
            // Node is available if all surrounding nodes are available
            // This avoids the issue in a square map where corners have to
            // be cut to make optimal paths but cannot pass through the corner
            // of an impassable tile
            secondaryNode.Available =
              GameBoard.Tiles[x, y].Terrain.LandPassable &&
              GameBoard.Tiles[x - 1, y].Terrain.LandPassable &&
              GameBoard.Tiles[x - 1, y - 1].Terrain.LandPassable &&
              GameBoard.Tiles[x, y - 1].Terrain.LandPassable;
            secondaryNodes[x - 1, y - 1] = secondaryNode;
            PathProvider.AddNode(secondaryNode);

            // Build related node lists
            // lines with -> means that the bi-directionality of related nodes makes this redundant
            // For the current primary node add the nodes above and to the left
            primaryNodes[x, y].AddRelatedNode(primaryNodes[x, y - 1]);
            primaryNodes[x, y].AddRelatedNode(primaryNodes[x - 1, y]);
            // Also add the corner, secondary node to it's upper left
            // -> primaryNodes[x, y].AddRelatedNode(secondaryNode[x - 1, y - 1]);
            // For node up and left add nodes to it's right and it's bottom
            primaryNodes[x - 1, y - 1].AddRelatedNode(primaryNodes[x - 1, y]);
            primaryNodes[x - 1, y - 1].AddRelatedNode(primaryNodes[x, y - 1]);
            // Also add the corner, secondary node to it's lower right
            // -> primaryNodes[x - 1, y - 1].AddRelatedNode(secondaryNode[x - 1, y - 1]);
            // For node above add the node to it's left and the current node
            primaryNodes[x, y - 1].AddRelatedNode(primaryNodes[x - 1, y - 1]);
            // -> primaryNodes[x, y - 1].AddRelatedNode(primaryNodes[x, y]);
            // Also add the corner, secondary node to it's lower left
            // -> primaryNodes[x, y - 1].AddRelatedNode(secondaryNode[x - 1, y - 1]);
            // For node to the left add the node above it and the current node
            primaryNodes[x - 1, y].AddRelatedNode(primaryNodes[x - 1, y - 1]);
            // -> primaryNodes[x - 1, y].AddRelatedNode(primaryNodes[x, y]);
            // Also add the corner, secondary node to it's upper right
            // -> primaryNodes[x - 1, y].AddRelatedNode(secondaryNode[x - 1, y - 1]);
            // For the secondary node add all four corner nodes
            secondaryNodes[x - 1, y - 1].AddRelatedNode(primaryNodes[x, y]);
            secondaryNodes[x - 1, y - 1].AddRelatedNode(primaryNodes[x - 1, y]);
            secondaryNodes[x - 1, y - 1].AddRelatedNode(primaryNodes[x - 1, y - 1]);
            secondaryNodes[x - 1, y - 1].AddRelatedNode(primaryNodes[x, y - 1]);

            if(x > 1)
            {
              // For the secondary node add the secondary node to it's left
              secondaryNodes[x - 1, y - 1].AddRelatedNode(secondaryNodes[x - 2, y - 1]);
            }
            if(y > 1)
            {
              // For the secondary node add the secondary node above it
              secondaryNodes[x - 1, y - 1].AddRelatedNode(secondaryNodes[x - 1, y - 2]);
            }
          }
        }
      }
    }

/******************************************
Example of search request
******************************************/

Point start = new Point(50, 50);
        Point goal1 = new Point(405, 400);
        Point goal2 = new Point(300, 400);
        List goals = new List();
        goals.Add(new Vector3(goal1.X, goal1.Y, 0));
        goals.Add(new Vector3(goal2.X, goal2.Y, 0));

        AStarSearchResult result = _pathProvider.FindShortestPath(
          new Vector3(start.X, start.Y, 0),
          goals);

Where is the project at?

Charles Parcell

8:03 29 Aug '07

Been a while since I stopped in here to check on things. I see you had expected to have something out early '07 and here it is late '07. Still keeping the project alive here?
Sign In·View Thread·PermaLink