Simulasi Burung (2) - Latihan Strategi Algoritmik dan Pemrograman Lintas Bidang

Introduction

This tutorial guides you through simulating the flight of a bird launched from a slingshot using algorithmic strategies and programming. The tutorial is particularly relevant for students in Informatics, as it demonstrates concepts of motion in physics, specifically uniformly accelerated motion. By the end of this guide, you will be able to calculate the time it takes for a bird to reach its maximum horizontal distance.

Step 1: Understanding the Motion Concept

• Familiarize yourself with the principle of uniformly accelerated motion (Gerak Lurus Berubah Beraturan, GLBB).
• Key characteristics to note:
  • The object (in this case, the bird) experiences constant acceleration.
  • The initial velocity and the acceleration will determine how far the bird travels horizontally.

Step 2: Setting Up the Simulation Environment

• Choose a programming language that supports simulation and graphical output (for example, Python or Java).
• Install any necessary libraries or frameworks:
  • For Python, consider using libraries like Pygame for graphics or NumPy for calculations.
• Create a new project and set up the main script.

Step 3: Defining Variables

• Define the key variables required for the simulation:
  • initial_velocity: The speed at which the bird is launched.
  • angle: The angle of launch, which affects the trajectory.
  • gravity: The acceleration due to gravity (approximately 9.81 m/s²).

initial_velocity = 20  # example value in m/s
angle = 45  # launch angle in degrees
gravity = 9.81  # gravitational acceleration in m/s²

Step 4: Calculating Horizontal Distance

• Use the following formulas to calculate the time of flight and horizontal distance:
  • Time of flight can be calculated as:
    • ( t = \frac{2 \times \text{initial_velocity} \times \sin(\text{angle})}{\text{gravity}} )
  • Horizontal distance can be calculated as:
    • ( d = \text{initial_velocity} \times \cos(\text{angle}) \times t )

import math

# Convert angle to radians
angle_rad = math.radians(angle)

# Calculate time of flight
time_of_flight = (2 * initial_velocity * math.sin(angle_rad)) / gravity

# Calculate horizontal distance
horizontal_distance = initial_velocity * math.cos(angle_rad) * time_of_flight

Step 5: Implementing the Simulation

• Create a function to simulate the movement:
  • Update the position of the bird based on the calculated distance over time intervals.
  • Use a loop to represent the flight of the bird, updating its position and displaying it on the screen.

def simulate_bird_flight():
    for t in range(int(time_of_flight * 100)):  # simulate in 0.01 increments
        x_position = initial_velocity * math.cos(angle_rad) * (t / 100)
        y_position = (initial_velocity * math.sin(angle_rad) * (t / 100)) - (0.5 * gravity * (t / 100) ** 2)
        # Update graphical display with (x_position, y_position)

Step 6: Visualizing the Results

• Implement a method to visualize the bird's path:
  • Use graphical functions to draw the trajectory on the screen.
  • Ensure to plot the maximum height and the point of landing.

Conclusion

In this tutorial, you learned how to simulate the flight of a bird launched from a slingshot using principles of physics and programming. Key steps included understanding motion concepts, setting up your programming environment, defining essential variables, calculating distances, and visualizing the results. You can expand this simulation by experimenting with different initial velocities and angles to see how they affect the bird's flight.