MHB Collision of Planets: FF & AS Destruction

  • Thread starter Thread starter mathmari
  • Start date Start date
  • Tags Tags
    Collision Planets
AI Thread Summary
The discussion centers on writing a function to handle the collision between a free-floating planet and an asteroid, resulting in the destruction of both. The provided code attempts to locate and delete these celestial bodies from their respective data structures. Key points include the use of a star system structure containing pointers to planetary systems and asteroids, and the function's logic for traversing these structures to find the specified identifiers. Suggestions for improvement emphasize the importance of using meaningful variable names, adding comments for clarity, considering alternative data structures for efficiency, and testing the function against various edge cases to ensure robustness. Overall, thorough testing and debugging are crucial for confirming the function's correctness.
mathmari
Gold Member
MHB
Messages
4,984
Reaction score
7
Hey! :o

I want to write a function for the collision of the free-floating planet with identifier ffp and the planet with identifier as. The collision has as a result the destruction of both planets. Specifically, the free-floating planet with identifier ff will be deleted from the free-floating tree to which it belonged, but also the planet with identifier <as> will be deleted from the tree of asteroids of the planetary system that it belonged to.The structures are the following:

Code:
struct starsy {
	int         ss;       /* The star system identifier. >0 */
	plansys_t *plasy;    /* Pointer to the first element in the list of the planetary system */
	plansys_t *Sentinel; /* Pointer to the sentinel node of the list of the planetary system */
	asteroid_t   *ff;   /* The free-floating planets tree  */
};struct plansys {
	int           solid;         /* The planetary system identifier. >0 */
	asteroid_t     *asteroids;     /* Pointer to the first node in the list of the asteroids */
	asteroid_t     *asentinel;   /* Pointer to the sentinel node of the asteroids tree */
	plansys_t      *next;        /* Pointer to the next node in the list of the planetary systemt */
};struct asteroid {
	int           as;         /* The asteroid identifier. >0 */
	int           gap;    /* The absolute gap from the object of the planetary system */
	asteroid_t     *PARENT;      /* Pointer to the parent node in the asteroids tree */
	asteroid_t     *LC;          /* Pointer to the left child in the asteroids tree */
	asteroid_t     *RC;          /* Pointer to the right child in the asteroids tree */
};

starsy_t StarS[N];     /*The array of the star systems, it is an array of lists */
 
int Sfreep;      /*An index to the first free position in the array of the star systems*/

I have done the following:

Code:
int asteroid_freefloating_boom(int ffp, int as) {
	int i, k=-1, j, g=-1;
	asteroid_t *p=NULL;
	plansys_t *q=NULL; 
	for(i=0; i<Sfreep; i++){
			q=StarS[i].plasy;
			while(q->asteroids != NULL  && q->asteroids->as != as){
				if(q->asteroids->as < as ){
					q->asteroids=q->asteroids->RC;
				}
				else{
					q->asteroids=q->asteroids->LC;
				}
			}
			if(q->asteroids != NULL && q->asteroids->as==as){
				k=i;
				
			}
	}

	if(k == -1){
		return 0;
	}
	
	p=StarS[k].plasy->asteroids;
	
	
	for(i=0; i<Sfreep; i++){
			while(StarS[i].ff!= NULL && StarS[i].ff->as != as){
				if(StarS[i].ff->as < as){
					StarS[i].ff=StarS[i].ff->RC;
				}
				else if(StarS[i].ff->as > as){
					StarS[i].ff=StarS[i].ff->LC;
				}
			}
			if(StarS[i].ff->as==as){
				k=i;
				
			}
	}
	
	if(k == -1){
		return -1;
	}
	
	if(g == -1){
		return -1;
	}
	

	return 0;
}

Is this correct?? (Wondering)
 
Technology news on Phys.org


I cannot provide a definitive answer on whether your code is correct or not without further testing and analysis. However, here are some suggestions that may help improve your function:

1. Use meaningful variable names: Instead of using single letter variables like i, k, and j, use more descriptive names that reflect their purpose in the code. This will make your code easier to read and understand.

2. Use comments: Adding comments throughout your code can help explain your thought process and make it easier for others to understand your code.

3. Consider using a different data structure: Your current approach requires looping through multiple arrays and lists, which can be time-consuming and inefficient. Consider using a different data structure, such as a hash table or binary search tree, which can make searching for specific elements faster.

4. Test for edge cases: Make sure your function can handle different scenarios, such as when the free-floating planet or asteroid is not found, or when there are multiple occurrences of the same identifier in the data structures.

Overall, it is important to thoroughly test and debug your function to ensure it works correctly in all cases.
 
Thread 'Is this public key encryption?'
I've tried to intuit public key encryption but never quite managed. But this seems to wrap it up in a bow. This seems to be a very elegant way of transmitting a message publicly that only the sender and receiver can decipher. Is this how PKE works? No, it cant be. In the above case, the requester knows the target's "secret" key - because they have his ID, and therefore knows his birthdate.
Thread 'Project Documentation'
Trying to package up a small bank account manager project that I have been tempering on for a while. One that is certainly worth something to me. Although I have created methods to whip up quick documents with all fields and properties. I would like something better to reference in order to express the mechanical functions. It is unclear to me about any standardized format for code documentation that exists. I have tried object orientated diagrams with shapes to try and express the...

Similar threads

Replies
20
Views
4K
Replies
119
Views
16K
Replies
1
Views
2K
Replies
2
Views
2K
Replies
2
Views
2K
Replies
4
Views
2K
Replies
10
Views
6K
Replies
1
Views
2K
Back
Top