Add files via upload

Author: mvsg2

Square Wave.py

@@ -0,0 +1,15 @@
+import matplotlib.pyplot as plt
+import numpy as np
+from scipy.signal import square
+
+L=1
+
+x=np.arange(-L,L,0.001)
+
+y=square(2*np.pi*x)
+
+plt.plot(x,y,'r--')
+
+plt.title("fourier series for square wave ")
+
+plt.show()

Time Count.py

@@ -0,0 +1,5 @@
+import time
+for sec in range(30, 10, -1):
+    print(sec)
+    time.sleep(1)
+    

Water Waves.py

@@ -0,0 +1,254 @@
+import pygame
+from pygame.locals import *
+from threading import Thread
+import time
+
+
+"""
+Informations:
+    Simple script that shows how to make 2d waves with Pygame.
+    
+    I created this program with a good tutorial on this page:
+    --> https://gamedevelopment.tutsplus.com/tutorials/make-a-splash-with-dynamic-2d-water-effects--gamedev-236
+    This program use the Threads, with this module you can change the FPS constants destined to Pygame and consequently accelerate the program
+    but nothing changes because the Update() function is not connected with the Pygame's framerate.
+    There are other methods but i have chosen this one.
+    
+    This program is not very fast because too much springs are used, you can modify the script to optimize it.
+    You can release some springs and create a draw system with 2d polygons to make the script faster and more optimized.
+"""
+
+
+# Constants
+SCREEN_WIDTH = 400
+SCREEN_HEIGHT = 400
+CAPTION = "Waves Simulation with Pygame"
+FPS = 60
+BLUE = (0, 103, 247)
+WHITE = (255, 255, 255)
+
+
+class Main:
+    def __init__(self):
+        """Main class"""
+
+        self.screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
+        pygame.display.set_caption(CAPTION)
+
+        self.time = pygame.time.Clock()
+        
+        self.target_height = 200 ## Max wave height and stable point
+        self.tension = 0.025
+        self.dampening = 0.020
+        self.spread = 0.25
+        self.height_splash = 5 ## Number of loop round // Warnning with a too hight value on this variable, the script will be very slower
+        self.init_speed = 200 ## Initial speed
+        self.init_position_x = 0 ## first position
+        self.final_position_x = 400 ## second_position
+
+        self.springs = [] ## List of objects (here the objects are Springs)
+
+        self.number_rod = self.create_number_rod()
+        self.rod_width = self.create_rod_width()
+        self.init_index = int(self.number_rod / self.rod_width)
+        self.create_spring_list(self.rod_width)
+        self.start_water_waves(self.rod_width)
+        
+        self.done = False
+
+        self.run_game()
+
+
+    def run_game(self):
+        """Main loop"""
+        
+        while not self.done:
+            for event in pygame.event.get():
+                if event.type == QUIT:
+                    self.done = True
+                    pygame.quit()
+                    exit()
+                if event.type == MOUSEBUTTONUP:
+                    if self.counter.done == True:
+                        pos = pygame.mouse.get_pos()
+                        self.init_index = int(pos[0] / self.final_position_x * self.number_rod)
+                        self.start_water_waves(self.rod_width)
+
+            self.draw_level()
+            
+            for spring in self.springs:
+                spring.draw(self.screen)
+                
+            self.time.tick(FPS) ## Set a FPS constants but you can change it
+            pygame.display.flip()
+
+
+    def create_number_rod(self):
+        """Have half rod on all the water"""
+
+        return abs(int((self.init_position_x - self.final_position_x) / 2))
+
+
+    def create_rod_width(self):
+        """Make an size average thank to the number of rod"""
+
+        return int((self.init_position_x + self.final_position_x) / self.number_rod)
+            
+
+    def create_spring_list(self, rod_width):
+        """Create the spring list"""
+
+        for x in range(self.init_position_x, self.final_position_x, rod_width):
+            self.springs.append(Spring(x, self.target_height, rod_width))
+
+
+    def start_water_waves(self, rod_width):
+        """Start the waves motion at a given position"""
+
+        self.springs[self.init_index].speed = self.init_speed
+        self.counter = Counter_Waves_Motion(self)
+        self.counter.start()
+
+
+    def update(self):
+        """Update the waves"""
+
+        self.update_waves()
+        self.create_neighbour_list()
+        self.update_neighbour()
+        self.test_end_water_waves()
+
+
+    def test_end_water_waves(self):
+        """Check if the waves are still alive"""
+
+        count = 0
+
+        for i in range(len(self.springs)):
+            if not int(self.springs[i].speed) and not int(self.springs[i].y):
+                count += 1
+
+        if count == len(self.springs):
+            self.stop_water_motion()
+
+
+    def stop_water_motion(self):
+        """Stop the motion of the water"""
+  
+        for i in range(len(self.springs)):
+            self.springs[i].speed = 0
+            self.springs[i].height = self.target_height
+            self.springs[i].y = 0
+            
+   
+    def update_waves(self):
+        """Update the water waves
+        of all the rod in the springs list"""
+
+        for i in range(len(self.springs)):
+            self.springs[i].update(self.dampening, self.tension, self.target_height)
+
+
+    def create_neighbour_list(self):
+        """Create the lists of height
+        difference between the rods without reference"""
+
+        self.lDeltas = list(self.springs)
+        self.rDeltas = list(self.springs)
+
+
+    def update_neighbour(self):
+        """Update the rod beside another"""
+    
+        for j in range(self.height_splash):
+            for i in range(len(self.springs)):
+
+                if i > 0:
+                    self.lDeltas[i] = self.spread * (self.springs[i].height - self.springs[i - 1].height)
+                    self.springs[i - 1].speed += self.lDeltas[i]
+
+                if i < len(self.springs) - 1:
+                    self.rDeltas[i] = self.spread * (self.springs[i].height - self.springs[i + 1].height)
+                    self.springs[i + 1].speed += self.rDeltas[i]
+
+            self.termine_update_neighbour()
+
+
+    def termine_update_neighbour(self):
+        """Terminate the procedure"""
+
+        for i in range(len(self.springs)):
+            if i > 0:
+                self.springs[i - 1].height += self.lDeltas[i]
+            if i < len(self.springs) - 1:
+                self.springs[i + 1].height += self.rDeltas[i]
+
+
+    def draw_level(self):
+        """Draw the level background"""
+
+        self.screen.fill(WHITE)
+
+
+        
+class Spring:
+    def __init__(self, x, target_height, rod_width):
+        """Spring Creator, one spring by one"""
+
+        self.x = x
+        self.y = 0
+        self.speed = 0
+        self.height = target_height
+        self.bottom = 400
+        self.rod_width = rod_width
+
+
+    def update(self, dampening, tension, target_height):
+        """Update the springs, this is numerical integration
+        and called Euler Method, it is simple fast and usual"""
+        
+        self.y = target_height - self.height
+        self.speed += tension * self.y - self.speed * dampening
+        self.height += self.speed
+
+
+    def draw(self, screen):
+        """Draw the spring,
+        (Here this is a simple rod)"""
+
+        pygame.draw.line(screen, BLUE, (self.x, self.height), (self.x, self.bottom), self.rod_width)
+
+
+class Counter_Waves_Motion(Thread):
+    def __init__(self, main):
+        Thread.__init__(self)
+        """Thread init class, (counter class)"""
+
+        self.main = main
+
+        self.time = 0
+        self.max_time = 2
+        self.time_sleep = 0.01
+
+        self.done = False
+
+
+    def run(self):
+        """Run the Thread, (parallel programming)"""
+
+        while not self.done:
+            self.main.update()
+            
+            self.time += self.time_sleep
+
+            if self.time >= self.max_time:
+                self.done = True
+
+            time.sleep(self.time_sleep) 
+
+
+
+if __name__ == "__main__":
+    obj_main = Main()
+
+## In this program all is OOP