Yes, your idea makes sense and sounds like a fun and engaging project! You want to create a simple solar system simulation with some interesting features, including relative motion perspectives. Here's a brief outline of how you might go about implementing this in Python:

### Basic Structure

1. **Setup**: 
   - Use a library like `matplotlib` for plotting or `pygame` for more interactive graphics.
   - Define the Sun and planets with attributes such as distance from the Sun, orbital period (in years), and direction of orbit.

2. **User Input**:
   - Allow the user to input the number of planets (up to 5), their distances from the Sun, orbital periods, and the direction of orbit.
   - Additionally, let the user choose the reference frame (either the Sun or any of the planets).

3. **Animation**:
   - Simulate the motion of planets around the Sun by updating their positions over time.
   - For perspective shifts, apply transformations to show what the motion looks like from the chosen planet's perspective.

4. **Relativity Effect**:
   - When changing the perspective to another planet, calculate the apparent motion of the Sun and other planets. This involves shifting the origin of your coordinate system to the chosen planet and recalculating positions.

### Implementation Details

Here's a high-level overview of how you can implement this:

1. **Data Structures**:
   - Use classes to define celestial objects:
     ```python
     class CelestialBody:
         def __init__(self, name, distance, period, direction, color):
             self.name = name
             self.distance = distance
             self.period = period
             self.direction = direction
             self.color = color
             self.angle = 0.0

         def update_position(self, time_step):
             # Update the angle based on the period and direction
             self.angle += self.direction * (360 / self.period) * time_step
     ```

2. **Simulation Loop**:
   - Use `matplotlib.animation` or a game loop in `pygame` to update positions and redraw the scene.
   - Compute the position of each planet based on its angle and distance from the Sun or chosen central body.

3. **Perspective Transformation**:
   - If the user selects a planet's perspective, adjust the positions of all other bodies relative to this central planet:
     ```python
     def transform_to_perspective(reference_body, bodies):
         transformed_positions = []
         for body in bodies:
             if body != reference_body:
                 # Calculate relative position
                 relative_x = body.distance * cos(radians(body.angle)) - reference_body.distance * cos(radians(reference_body.angle))
                 relative_y = body.distance * sin(radians(body.angle)) - reference_body.distance * sin(radians(reference_body.angle))
                 transformed_positions.append((relative_x, relative_y, body.color))
         return transformed_positions
     ```

4. **Visualization**:
   - Use the plotting library to draw circles representing the Sun and planets.
   - Trace paths by storing previous positions and drawing lines.

5. **User Interface**:
   - Simple command-line prompts or a GUI for input parameters.
   - Buttons or keys to switch perspectives.

### Tools and Libraries

- **Matplotlib**: Great for static and animated plots.
- **Pygame**: Good for real-time graphics and interaction.
- **Numpy**: Useful for mathematical calculations.

### Additional Features

- Add a speed control to fast-forward the simulation.
- Display information like current date in the simulation or orbital speed.
- Introduce eccentric orbits by varying the distance dynamically.

This project will not only be a fun visual demonstration but also a great exercise in programming and understanding orbital mechanics. If you have further questions or need help with specifics, feel free to ask!