Jump to content
OGXbox.com

Meerjel01

Members
  • Posts

    209
  • Joined

  • Last visited

  • Days Won

    7

Posts posted by Meerjel01

  1. On 5/2/2024 at 4:54 PM, Meerjel01 said:

    Bump*

    I haven't tested it yet on my engine but I believe it'll be more working using this method than a bunch of for-loops.

    #include <iostream>
    
    using namespace std;
    
    class CObject
    {
    public:
    	void ExecuteDeb(int num)
    	{
    		printf("Printing! %i ", num);
    	}
    };
    
    class CObjectLinker
    {
    public:
    	CObject* objs;
    	int numObjs;
    	
    	CObjectLinker(int num)
    	{
    		numObjs = num;
    		objs = new CObject[numObjs];
    	}
    	
    	void StartExecute()
    	{
    		int number = numObjs;
    		
    		keepExecuting(number);
    	}
    	
    	void keepExecuting(int& curNum)
    	{
    		objs[curNum].ExecuteDeb(curNum);
    		curNum--;
    		
    		if(curNum < 0)
    			return;
    		keepExecuting(curNum);
    	}
    };
    
    int main(int argc, char *argv[]) {
    	CObjectLinker linker(4);
    	
    	linker.StartExecute();
    }

    This was a test to see if I can execute multiple objects with a countdown method instead of the usual. If And For/While takes some speed away when used a lot so I was experimenting and came up with this. Any thoughts?

    This code ain't good apparently. It looks decent but apparently it's no good for the engine to have this in it. Guess for loops aren't too bad after all?

    • Like 1
  2. Bump*

    I haven't tested it yet on my engine but I believe it'll be more working using this method than a bunch of for-loops.

    #include <iostream>
    
    using namespace std;
    
    class CObject
    {
    public:
    	void ExecuteDeb(int num)
    	{
    		printf("Printing! %i ", num);
    	}
    };
    
    class CObjectLinker
    {
    public:
    	CObject* objs;
    	int numObjs;
    	
    	CObjectLinker(int num)
    	{
    		numObjs = num;
    		objs = new CObject[numObjs];
    	}
    	
    	void StartExecute()
    	{
    		int number = numObjs;
    		
    		keepExecuting(number);
    	}
    	
    	void keepExecuting(int& curNum)
    	{
    		objs[curNum].ExecuteDeb(curNum);
    		curNum--;
    		
    		if(curNum < 0)
    			return;
    		keepExecuting(curNum);
    	}
    };
    
    int main(int argc, char *argv[]) {
    	CObjectLinker linker(4);
    	
    	linker.StartExecute();
    }

    This was a test to see if I can execute multiple objects with a countdown method instead of the usual. If And For/While takes some speed away when used a lot so I was experimenting and came up with this. Any thoughts?

    • Like 1
  3. I'm on a Mac so I can't do a lot with the assets for now but I got the resources out from the archive. The models seems to be mdl files but I'm not sure which structure they're built from.

    I got the .ipa file from here btw. Gonna have to play the game myself to get the game's feel correct.

  4. When I was interested in a full 3D game engine for the OG Xbox, I wanted to do a simple technique that Conker Live and Reloaded did with facial expressions. The mouths where 3D, but the eyes where 2D textures with 2 stages. It's not shape group based (I think) but uses bones for the mouths and textures for eyes like the outside and the inside of them.

    There might be an 8 for this. When I finish my own skinned mesh renderer and animator then I will do this. Seems to be the best looking way to me.

     

     

    • Like 2
  5. I did some changing to the code and it seems to work a bit better now. But it's not predictable enough and it might be the node grid that I made that is not set up correctly. Gonna make a new graph and changing to other parts of the engine's code to make it easier to work with.

    • Like 1
  6. On 1/25/2024 at 2:35 PM, corona2222 said:

    maybe, (when i find a moment) wheres the latest code?

    Here.

    // Init the grid then Get A Path	
    bool GetPath(D3DXVECTOR3 start, D3DXVECTOR3 end, st_path& finalPath, float maxStartLimit, float maxEndLimit)
    	{
    		CAStarNode* startNode = &GetNearestNode(start);
    		if(Distance(startNode->position, start) > maxStartLimit)
    			return false;
    		
    		CAStarNode* endNode = &GetNearestNode(end);
    		if(Distance(endNode->position, end) > maxEndLimit)
    			return false;
    
    	
    
    		CAStarNode* openList = new CAStarNode[numNodes];
    		CAStarNode* closedList = new CAStarNode[numNodes];
    		
    
    		int currentOpenAmount = 0;
    		int currentClosedAmount = 0;
    
    
    		openList[0] = *startNode;
    		currentOpenAmount++;
    
    		while (currentOpenAmount > 0)
    		{
    
    			if(currentOpenAmount <= 0)
    				break;
    
    			CAStarNode* currentNode = &openList[currentOpenAmount - 1];
    			
    			int neighCount = currentNode->numNeighbours;
    			
    			for(int i=0; i < neighCount; i++)
    			{
    				currentNode->neighbours[i].parent = currentNode;
    				currentNode->neighbours[i].gCost = Distance(currentNode->position, currentNode->neighbours[i].position);
    				currentNode->neighbours[i].hCost = Distance(currentNode->position, endNode->position);
    				currentNode->neighbours[i].fCost = currentNode->neighbours[i].gCost + currentNode->neighbours[i].hCost;
    			}
    					
    			
    			
    			// CAStarNode* neigh = currentNode->neighbours;
    			
    			
    			
    			int ending = 0;
    			if(currentNode->id == endNode->id)
    			{
    				
    				CAStarNode* nods = new CAStarNode[numNodes];
    				int curNods = 0;
    				
    				CAStarNode* curNod = currentNode;
    				
    				bool creating = true;
    				while(creating)
    				{
    					nods[curNods] = *curNod;
    					curNods++;
    					
    					if(curNod->id != startNode->id)
    						curNod = curNod->parent;
    					else
    						creating = false;
    				}
    
    				if(curNods <= 0)
    					return false;
    				
    				st_path result;
    				result.numCorners = curNods;
    				result.corners = new D3DXVECTOR3[curNods];
    				for(int n=0; n < curNods; n++)
    				{
    					result.corners[n] = nods[n].position;
    				}
    				// finalPath = CreatePath(startNode, endNode);
    				finalPath = result;
    				
    				
    				
    				
    				return true;
    			}
    			
    			
    			
    			bool picked = false;
    			for(int i=0; i < neighCount; i++)
    			{
    				
    				int sel = 0;
    				
    				
    				for(int x=0; x < neighCount; x++)
    				{
    					
    					if(currentNode->neighbours[x].fCost < currentNode->neighbours[sel].fCost)
    					{
    						sel = x;
    					}
    				}
    				
    				if(CheckInClosedList(closedList, currentClosedAmount, currentNode->neighbours[sel]))
    				{
    					int lar = 0;
    					for(int x=0; x < neighCount; x++)
    					{
    							
    						if(currentNode->neighbours[x].fCost > currentNode->neighbours[lar].fCost)
    						{
    							lar = x;
    						}
    					}
    					
    					currentNode->neighbours[sel].fCost = currentNode->neighbours[lar].fCost + 1;
    					
    					continue;
    					/*
    					currentNode->neighbours[i].gCost = currentNode->gCost + Distance(currentNode->position, currentNode->neighbours[i].position);
    					currentNode->neighbours[i].hCost = Distance(currentNode->neighbours[i].position, endNode->position);
    					
    					
    					currentNode->neighbours[i].fCost = currentNode->neighbours[i].gCost + currentNode->neighbours[i].hCost;
    					
    					currentNode->neighbours[i].parent = currentNode;
    					
    					openList[currentOpenAmount] = currentNode->neighbours[i];
    					currentOpenAmount++;
    					*/
    				}
    				else
    				{
    					openList[currentOpenAmount] = currentNode->neighbours[sel];
    					currentOpenAmount++;
    					picked = true;
    					break;
    				}
    			}
    			
    			if(picked == false)
    			{
    				currentOpenAmount--;
    			}
    			
    			closedList[currentClosedAmount] = *currentNode;
    			currentClosedAmount++;
    			
    		}
    
    
    		
    		
    		
    		return false;
    	}
    	
    	CAStarNode GetNearestNode(D3DXVECTOR3 position)
    	{
    		CAStarNode result;
    		float dist = 1000;
    		for(int n=0; n < numNodes; n++)
    		{
    			float d = Distance(position, nodes[n].position);
    			
    			if(d < dist)
    			{
    				result = nodes[n];
    				
    				dist = d;
    			}
    		}
    		
    		return result;
    	}

    I've just come back to this.

Board Life Status


Board startup date: April 23, 2017 12:45:48
×
×
  • Create New...

Important Information

By using this site, you agree to our Terms of Use.