├── 18 onedirection.py
├── 3D love animation.zip
├── Apocalypse.py
├── Cinta Lama Bersemi Kembali.py
├── DJ garam dan madu.py
├── Doin' Time.py
├── Tante Culik Aku Dong.py
├── You'll Be in My Heart.py
├── about you.py
├── aku dah lupa.py
├── all to well.py
├── baby.py
├── birds of a feather.py
├── blue yung kai.py
├── cheerleader.py
├── confess2
    ├── assets
    │   └── blue.mp3
    ├── index.html
    ├── love.html
    ├── script
    │   ├── love.js
    │   └── main.js
    └── styles
    │   ├── love.css
    │   └── main.css
├── flower 2
    ├── index.html
    └── style.css
├── flower
    ├── flower 1.py
    ├── flower 10.py
    ├── flower 2.py
    ├── flower 7.py
    └── flower 9.py
├── forever young.py
├── ga romantis.py
├── happy birthday python
    ├── happy birthday 5.py
    ├── happy birthday.py
    └── happy birthday_2.py
├── heart.py
├── heart_14.py
├── heart_2.py
├── heart_8.py
├── heart_9.py
├── i like you the most.py
├── i love you text animation.py
├── i love you.zip
├── jangan hilangkan dia.py
├── kalkulator 2
    ├── index.html
    ├── script.js
    └── styles.css
├── kamu cantik kamu baik.py
├── kasih aba aba.py
├── koiiro kobo
    ├── background.jpg
    └── koiiro.html
├── lirik end of begining.py
├── love love love
    ├── index.html
    ├── script.js
    └── style.css
├── love10
    ├── index.html
    ├── script.js
    └── style.css
├── love12
    ├── index.html
    ├── script.js
    └── styles.css
├── love13
    ├── index.html
    └── script.js
├── love14
    └── index.html
├── love15
    ├── index.html
    └── styles.css
├── love16
    ├── index.html
    ├── script.js
    └── style.css
├── love18
    ├── index.html
    ├── script.js
    └── styles.css
├── love21
    ├── index.html
    ├── script.js
    └── styles.css
├── love23
    ├── css
    │   └── style.css
    ├── index.html
    └── js
    │   ├── MeshSurfaceSampler.js
    │   ├── OBJLoader.js
    │   ├── TrackballControls.js
    │   ├── gsap.min.js
    │   ├── script.js
    │   ├── simplex-noise.js
    │   └── three.min.js
├── love26
    ├── index.html
    ├── script.js
    └── style.css
├── love28
    ├── index.html
    ├── script.js
    └── style.css
├── love3
    ├── index.html
    ├── script.js
    └── style.css
├── love4
    ├── index.html
    ├── script.js
    └── style.css
├── love5
    ├── index.html
    ├── script.js
    └── styles.css
├── love7
    ├── index.html
    ├── script.js
    └── style.css
├── mangu.py
├── masa depanmu.py
├── masa lalumu.py
├── multo.py
├── nan ko paham.py
├── perfect onedireection.py
├── right now.py
├── seandainya.py
├── sempurna.py
├── sign of times.py
├── somebody pleasure V2.py
├── somebody pleasure.py
├── somebody to you.py
├── steal my girl.py
├── stecu stecu.py
├── strong.py
├── superficial love.py
├── to the bone.py
├── tresno tekane mati .py
├── valentine
    ├── css
    │   ├── style.css
    │   └── style2.css
    ├── index.html
    ├── index2.html
    └── js
    │   ├── script.js
    │   └── script2.js
├── watch.py
├── we can't be friends.py
├── where we are.py
├── wide awake.py
├── wish you were here.py
└── ya maulana.py


/18 onedirection.py:
--------------------------------------------------------------------------------
 1 | import time
 2 | from threading import Thread, Lock
 3 | import sys
 4 | 
 5 | lock = Lock()
 6 | 
 7 | def animate_text(text, delay=0.1):
 8 |     with lock:
 9 |         for char in text:
10 |             sys.stdout.write(char)
11 |             sys.stdout.flush()
12 |             time.sleep(delay)
13 |         print()
14 | 
15 | def sing_lyric(lyric, delay, speed):
16 |     time.sleep(delay)
17 |     animate_text(lyric, speed)
18 | 
19 | def sing_song():
20 |     lyrics = [
21 |         ("I have loved you since we were 18", 0.08),
22 |         ("Long before we both thought the same thing", 0.07),
23 |         ("To be loved and to be in love", 0.07),
24 |         ("And all I could do is say that these arms were made for holding you oh oh oh whoa", 0.07),
25 |         ("I wanna love like you made me feel", 0.09),
26 |         ("When we were 18", 0.1)
27 |     ]
28 |     delays = [0.3, 6.9, 11.0, 14.0, 20.8, 24.8]
29 |     
30 |     threads = []
31 |     for i in range(len(lyrics)):
32 |         lyric, speed = lyrics[i]
33 |         t = Thread(target=sing_lyric, args=(lyric, delays[i], speed))
34 |         threads.append(t)
35 |         t.start()
36 |     for thread in threads:
37 |         thread.join()
38 | if __name__ == "__main__":
39 |     sing_song()
40 | 


--------------------------------------------------------------------------------
/3D love animation.zip:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/lukman467/coding/d3b3dde560a9e5eec25263a0e7b0da8a8bbd2e42/3D love animation.zip


--------------------------------------------------------------------------------
/Apocalypse.py:
--------------------------------------------------------------------------------
 1 | import time
 2 | from threading import Thread, Lock
 3 | import sys
 4 | 
 5 | lock = Lock()
 6 | 
 7 | def animate_text(text, delay=0.1):
 8 |     with lock:
 9 |         for char in text:
10 |             sys.stdout.write(char)
11 |             sys.stdout.flush()
12 |             time.sleep(delay)
13 |         print()
14 | 
15 | def sing_lyric(lyric, delay, speed):
16 |     time.sleep(delay)
17 |     animate_text(lyric, speed)
18 | 
19 | def sing_song():
20 |     lyrics = [
21 |         ("\n""Got the music in you, baby", 0.09),
22 |         ("Tell me why", 0.06),
23 |         ("Got the music in you, baby", 0.09),
24 |         ("Tell me why", 0.06),
25 |         ("You've been locked in here forever", 0.07),
26 |         ("And you just can't say goodbye", 0.09),
27 |     ]
28 |     delays = [0.3, 2.9, 5.5, 7.6, 10.5, 12.4]
29 |     
30 |     threads = []
31 |     for i in range(len(lyrics)):
32 |         lyric, speed = lyrics[i]
33 |         t = Thread(target=sing_lyric, args=(lyric, delays[i], speed))
34 |         threads.append(t)
35 |         t.start()
36 |     
37 |     for thread in threads:
38 |         thread.join()
39 | 
40 | if __name__ == "__main__":
41 |     sing_song()


--------------------------------------------------------------------------------
/Cinta Lama Bersemi Kembali.py:
--------------------------------------------------------------------------------
 1 | import time
 2 | from threading import Thread, Lock
 3 | import sys
 4 | 
 5 | lock = Lock()
 6 | 
 7 | def animate_text(text, delay=0.1):
 8 |     with lock:
 9 |         for char in text:
10 |             sys.stdout.write(char)
11 |             sys.stdout.flush()
12 |             time.sleep(delay)
13 |         print()
14 | 
15 | def sing_lyric(lyric, delay, speed):
16 |     time.sleep(delay)
17 |     animate_text(lyric, speed)
18 | 
19 | def sing_song():
20 |     lyrics = [
21 |         ("\nMau tak mau ku harus menolakmu", 0.06),
22 |         ("Karna ku sudah ada pengganti dirimu", 0.06),
23 |         ("Aku yang sekarang bukanlah yang dulu", 0.06),
24 |         ("Maafkan mantan aku tak mau\n", 0.09),
25 |         ("Cintaku padamu bersemi kembali", 0.11),
26 |         ("Maukah kau menjadi pacarku lagi", 0.11),
27 |     ]
28 |     delays = [0.3, 2.4, 4.7, 6.6, 10.6, 15.2]
29 |     
30 |     threads = []
31 |     for i in range(len(lyrics)):
32 |         lyric, speed = lyrics[i]
33 |         t = Thread(target=sing_lyric, args=(lyric, delays[i], speed))
34 |         threads.append(t)
35 |         t.start()
36 |     
37 |     for thread in threads:
38 |         thread.join()
39 | 
40 | if __name__ == "__main__":
41 |     sing_song()
42 | 


--------------------------------------------------------------------------------
/DJ garam dan madu.py:
--------------------------------------------------------------------------------
 1 | import time
 2 | from threading import Thread, Lock
 3 | import sys
 4 | 
 5 | lock = Lock()
 6 | 
 7 | def animate_text(text, delay=0.1):
 8 |     with lock:
 9 |         for char in text:
10 |             sys.stdout.write(char)
11 |             sys.stdout.flush() 
12 |             time.sleep(delay)
13 |         print()
14 | 
15 | def sing_lyric(lyric, delay, speed):
16 |     time.sleep(delay)
17 |     animate_text(lyric, speed)
18 | 
19 | def sing_song():
20 |     lyrics = [
21 |         ("\nHold my hands, dont-dont tell your friends", 0.06),
22 |         ("Cerita kemaren, ku ingat permanen", 0.08),
23 |         ("Manis mu kaya permen, I hope this never end", 0.08),
24 |         ("Oh can you be my Gwen? and ill be the Spiderman", 0.06),
25 |         ("\nSakit dadaku, ku mulai merindu", 0.09),
26 |         ("Ku bayangkan jika kamu tidur di sampingku", 0.07),
27 |         ("Di malam yang semu", 0.08),
28 |         ("Pejamkan mataku", 0.07),
29 |         ("Ku bayangkan tubuhmu jika di pelukanku", 0.07)
30 |     ]
31 |     delays = [0.3, 3.0, 6.3, 10.0, 13.0, 16.5, 19.9, 21.7, 23.3]
32 |     
33 |     threads = []
34 |     for i in range(len(lyrics)):
35 |         lyric, speed = lyrics[i]
36 |         t = Thread(target=sing_lyric, args=(lyric, delays[i], speed))
37 |         threads.append(t)
38 |         t.start()
39 |     for thread in threads:
40 |         thread.join()
41 | 
42 | if __name__ == "__main__":
43 |     sing_song()
44 | 


--------------------------------------------------------------------------------
/Doin' Time.py:
--------------------------------------------------------------------------------
 1 | import time
 2 | from threading import Thread, Lock
 3 | import sys
 4 | 
 5 | lock = Lock()
 6 | 
 7 | def animate_text(text, delay=0.1):
 8 |     with lock:
 9 |         for char in text:
10 |             sys.stdout.write(char)
11 |             sys.stdout.flush()
12 |             time.sleep(delay)
13 |         print()
14 | 
15 | def sing_lyric(lyric, delay, speed):
16 |     time.sleep(delay)
17 |     animate_text(lyric, speed)
18 | 
19 | def sing_song():
20 |     lyrics = [
21 |         ("\n""Bradley's on the microphone with Ras MG", 0.06),
22 |         ("All the people in the dance will agree", 0.07),
23 |         ("That we're well-qualified to represent the L.B.C", 0.08),
24 |         ("Me, me and Louie, we gonna run to the party", 0.08),
25 |         ("And dance to the rhythm, it gets harder""\n", 0.07)
26 |     ]
27 |     delays = [0.3, 3.3, 5.8, 10.2, 14.0]
28 |     
29 |     threads = []
30 |     for i in range(len(lyrics)):
31 |         lyric, speed = lyrics[i]
32 |         t = Thread(target=sing_lyric, args=(lyric, delays[i], speed))
33 |         threads.append(t)
34 |         t.start()
35 |     for thread in threads:
36 |         thread.join()
37 | 
38 | if __name__ == "__main__":
39 |     sing_song()
40 | 


--------------------------------------------------------------------------------
/Tante Culik Aku Dong.py:
--------------------------------------------------------------------------------
 1 | import time
 2 | from threading import Thread, Lock
 3 | import sys
 4 | 
 5 | lock = Lock()
 6 | 
 7 | def animate_text(text, delay=0.1):
 8 |     with lock:
 9 |         for char in text:
10 |             sys.stdout.write(char)
11 |             sys.stdout.flush()
12 |             time.sleep(delay)
13 |         print()
14 | 
15 | def sing_lyric(lyric, delay, speed):
16 |     time.sleep(delay)
17 |     animate_text(lyric, speed)
18 | 
19 | def sing_song():
20 |     lyrics = [
21 |         ("\nsudah terbiasa terjadi tante", 0.10),
22 |         ("teman datang ketika lagi butuh saja", 0.09),
23 |         ("coba kalo lagi susah", 0.08),
24 |         ("mereka semua menghilang...", 0.09),
25 |         ("tante\n", 0.07),
26 |     ]
27 |     
28 |     delays = [0.3, 3.9, 8.1, 11.0, 16.8]  
29 |     
30 |     threads = []
31 |     for i in range(len(lyrics)):
32 |         lyric, speed = lyrics[i]
33 |         t = Thread(target=sing_lyric, args=(lyric, delays[i], speed))
34 |         threads.append(t)
35 |         t.start()
36 |     
37 |     for thread in threads:
38 |         thread.join()
39 | 
40 | if __name__ == "__main__":
41 |     sing_song()


--------------------------------------------------------------------------------
/You'll Be in My Heart.py:
--------------------------------------------------------------------------------
 1 | import time
 2 | from threading import Thread, Lock
 3 | import sys
 4 | 
 5 | lock = Lock()
 6 | 
 7 | def animate_text(text, delay=0.1):
 8 |     with lock:
 9 |         for char in text:
10 |             sys.stdout.write(char)
11 |             sys.stdout.flush()
12 |             time.sleep(delay)
13 |         print()
14 | 
15 | def sing_lyric(lyric, delay, speed):
16 |     time.sleep(delay)
17 |     animate_text(lyric, speed)
18 | 
19 | def sing_song():
20 |     lyrics = [
21 |         ("\nDon't listen to them", 0.07),
22 |         ("Cause what do they know", 0.05),
23 |         ("We need each other", 0.07),
24 |         ("to have, to hold", 0.07),
25 |         ("They'll see in time", 0.08),
26 |         ("I know\n", 0.07),
27 |         ("When destiny calls you", 0.07),
28 |         ("you must be strong", 0.07),
29 |         ("I may not be with you", 0.07),
30 |         ("But you've got to hold on", 0.07),
31 |         ("They'll see in time", 0.08),
32 |         ("I know", 0.07),
33 |     ]
34 |     delays = [0.3, 3.2, 5.8, 8.3, 10.6, 15.5, 20.8, 23.4, 26.0, 28.5, 31.2, 36.0]
35 |     
36 |     threads = []
37 |     for i in range(len(lyrics)):
38 |         lyric, speed = lyrics[i]
39 |         t = Thread(target=sing_lyric, args=(lyric, delays[i], speed))
40 |         threads.append(t)
41 |         t.start()
42 |     
43 |     for thread in threads:
44 |         thread.join()
45 | 
46 | if __name__ == "__main__":
47 |     sing_song()


--------------------------------------------------------------------------------
/about you.py:
--------------------------------------------------------------------------------
 1 | import time
 2 | from threading import Thread, Lock
 3 | import sys
 4 | 
 5 | lock = Lock()
 6 | 
 7 | def animate_text(text, delay=0.1):
 8 |     with lock:
 9 |         for char in text:
10 |             sys.stdout.write(char)
11 |             sys.stdout.flush()
12 |             time.sleep(delay)
13 |         print()
14 | 
15 | def sing_lyric(lyric, delay, speed):
16 |     time.sleep(delay)
17 |     animate_text(lyric, speed)
18 | 
19 | def sing_song():
20 |     lyrics = [
21 |         ("Do you think I have forgotten?", 0.1),
22 |         ("Do you think I have forgotten?", 0.1),
23 |         ("Do you think I have forgotten", 0.1),
24 |         ("about you?", 0.2),
25 |         ("There was something bout you that now I cant remember", 0.08),
26 |         ("Its the same damn thing that made my heart surrender", 0.1),
27 |         ("And I miss you on a train, I miss you in the morning", 0.1),
28 |         ("I never know what to think about", 0.1),
29 |         ("I think about youuuuuuuuuuuuuuuuuuuuuuuuuuu", 0.1)
30 |     ]
31 |     delays = [0.3, 5.0, 10.0, 15.0, 20.3, 25.0, 27.0, 30.2, 33.3]
32 |     
33 |     threads = []
34 |     for i in range(len(lyrics)):
35 |         lyric, speed = lyrics[i]
36 |         t = Thread(target=sing_lyric, args=(lyric, delays[i], speed))
37 |         threads.append(t)
38 |         t.start()
39 |     
40 |     for thread in threads:
41 |         thread.join()
42 | 
43 | if __name__ == "__main__":
44 |     sing_song()


--------------------------------------------------------------------------------
/aku dah lupa.py:
--------------------------------------------------------------------------------
 1 | import time
 2 | from threading import Thread, Lock
 3 | import sys
 4 | 
 5 | lock = Lock()
 6 | 
 7 | def animate_text(text, delay=0.1):
 8 |     with lock:
 9 |         for char in text:
10 |             sys.stdout.write(char)
11 |             sys.stdout.flush()
12 |             time.sleep(delay)
13 |         print()
14 | 
15 | def sing_lyric(lyric, delay, speed):
16 |     time.sleep(delay)
17 |     animate_text(lyric, speed)
18 | 
19 | def sing_song():
20 |     lyrics = [
21 |         ("\nAku dah lupa tak ingat lagi", 0.07),
22 |         ("Nama kau pun hilang dari hati", 0.05),
23 |         ("Aku move on hidup sendiri", 0.06),
24 |         ("Tak perlu kau, aku happy\n", 0.06),
25 |         ("Aku dah lupa tak ingat lagi", 0.06),
26 |         ("Nama kau pun hilang dari hati", 0.05),
27 |         ("Aku move on hidup sendiri", 0.06),
28 |         ("Tak perlu kau, aku happy\n", 0.06),
29 |     ]
30 |     delays = [0.3, 2.8, 4.2, 6.6, 8.1, 10.2, 11.2, 13.7]
31 |     
32 |     threads = []
33 |     for i in range(len(lyrics)):
34 |         lyric, speed = lyrics[i]
35 |         t = Thread(target=sing_lyric, args=(lyric, delays[i], speed))
36 |         threads.append(t)
37 |         t.start()
38 |     
39 |     for thread in threads:
40 |         thread.join()
41 | 
42 | if __name__ == "__main__":
43 |     sing_song()


--------------------------------------------------------------------------------
/all to well.py:
--------------------------------------------------------------------------------
 1 | import time
 2 | from threading import Thread, Lock
 3 | import sys
 4 | 
 5 | lock = Lock()
 6 | 
 7 | def animate_text(text, delay=0.1):
 8 |     with lock:
 9 |         for char in text:
10 |             sys.stdout.write(char)
11 |             sys.stdout.flush()
12 |             time.sleep(delay)
13 |         print()
14 | 
15 | def sing_lyric(lyric, delay, speed):
16 |     time.sleep(delay)
17 |     animate_text(lyric, speed)
18 | 
19 | def sing_song():
20 |     lyrics = [
21 |         ("Just between us, I remember it, all too well", 0.11),
22 |         ("Wind in my hair, I was there, I was there", 0.08),
23 |         ("Down the stairs, I was there, I was there", 0.08),
24 |         ("Sacred prayer, I was there, I was there", 0.09),
25 |         ("It was rare, you remember it all too well", 0.10),
26 |     ]
27 |     delays = [0.3, 6.4, 11.5, 16.5, 21.5]
28 |     
29 |     threads = []
30 |     for i in range(len(lyrics)):
31 |         lyric, speed = lyrics[i]
32 |         t = Thread(target=sing_lyric, args=(lyric, delays[i], speed))
33 |         threads.append(t)
34 |         t.start()
35 |     
36 |     for thread in threads:
37 |         thread.join()
38 | 
39 | if __name__ == "__main__":
40 |     sing_song()


--------------------------------------------------------------------------------
/baby.py:
--------------------------------------------------------------------------------
 1 | import time
 2 | from threading import Thread, Lock
 3 | import sys
 4 | 
 5 | lock = Lock()
 6 | 
 7 | def animate_text(text, delay=0.1):
 8 |     with lock:
 9 |         for char in text:
10 |             sys.stdout.write(char)
11 |             sys.stdout.flush()
12 |             time.sleep(delay)
13 |         print()
14 | 
15 | def sing_lyric(lyric, delay, speed):
16 |     time.sleep(delay)
17 |     animate_text(lyric, speed)
18 | 
19 | def sing_song():
20 |     lyrics = [
21 |         ("\n""Oh, for you, I would have done whatever", 0.08),
22 |         ("And I just can't believe we ain't together", 0.07),
23 |         ("And I wanna play it cool, but I'm losing you", 0.07),
24 |         ("I'll buy you anything, I'll buy you any ring", 0.08),
25 |         ("And I'm in pieces, baby fix me", 0.09),
26 |         ("And just shake me 'til you wake me from this bad dream""\n", 0.06),
27 |     ]
28 |     
29 |     delays = [0.3, 4.1, 7.9, 11.5, 14.1, 19.0]
30 |     
31 |     threads = []
32 |     for i in range(len(lyrics)):
33 |         lyric, speed = lyrics[i]
34 |         t = Thread(target=sing_lyric, args=(lyric, delays[i], speed))
35 |         threads.append(t)
36 |         t.start()
37 |     
38 |     for thread in threads:
39 |         thread.join()
40 | 
41 | if __name__ == "__main__":
42 |     sing_song()


--------------------------------------------------------------------------------
/birds of a feather.py:
--------------------------------------------------------------------------------
 1 | import time
 2 | from threading import Thread, Lock
 3 | import sys
 4 | 
 5 | lock = Lock()
 6 | 
 7 | def animate_text(text, delay=0.1):
 8 |     with lock:
 9 |         for char in text:
10 |             sys.stdout.write(char)
11 |             sys.stdout.flush()
12 |             time.sleep(delay)
13 |         print()
14 | 
15 | def sing_lyric(lyric, delay, speed):
16 |     time.sleep(delay)
17 |     animate_text(lyric, speed)
18 | 
19 | def sing_song():
20 |     lyrics = [
21 |         ("\n""And I don't know what I'm crying for", 0.11),
22 |         ("I don't think I could love you more", 0.11),
23 |         ("It might not be long, but baby, I", 0.11),
24 |         ("I'll love you 'til the day that I die", 0.08),
25 |         ("Til the day that I die", 0.08),
26 |         ("Til the light leaves my eyes", 0.08),
27 |         ("Til the day that I die""\n", 0.08)
28 |     ]
29 |     delays = [0.3, 5.0, 9.6, 15.6, 21.3, 25.6, 30.6]
30 |     
31 |     threads = []
32 |     for i in range(len(lyrics)):
33 |         lyric, speed = lyrics[i]
34 |         t = Thread(target=sing_lyric, args=(lyric, delays[i], speed))
35 |         threads.append(t)
36 |         t.start()
37 |     
38 |     for thread in threads:
39 |         thread.join()
40 | 
41 | if __name__ == "__main__":
42 |     sing_song()


--------------------------------------------------------------------------------
/blue yung kai.py:
--------------------------------------------------------------------------------
 1 | import time
 2 | from threading import Thread, Lock
 3 | import sys
 4 | 
 5 | lock = Lock()
 6 | 
 7 | def animate_text(text, delay=0.1):
 8 |     with lock:
 9 |         for char in text:
10 |             sys.stdout.write(char)
11 |             sys.stdout.flush()
12 |             time.sleep(delay)
13 |         print()
14 | 
15 | def sing_lyric(lyric, delay, speed):
16 |     time.sleep(delay)
17 |     animate_text(lyric, speed)
18 | 
19 | def sing_song():
20 |     lyrics = [
21 |         ("\n""You'd be mineeeeee", 0.08),
22 |         ("would you mind if I took your hand tonight?", 0.10),
23 |         ("Know you're all that I want this life", 0.10),
24 |         ("\n""I'll imagine we fell in love", 0.07),
25 |         ("I'll nap under moonlight skies with you", 0.07),
26 |         ("I think I'll picture us, you with the waves", 0.07),
27 |         ("The ocean's colors on your face", 0.08),
28 |         ("I'll leave my heart with your air", 0.08),
29 |         ("So let me fly with you", 0.08),
30 |         ("Will you be forever with me?", 0.11),
31 |     ]
32 | 
33 |     delays = [0.2, 2.4, 8.0, 15.7, 18.6, 22.4, 26.0, 29.8, 34.1, 37.3]
34 | 
35 |     threads = []
36 |     for i in range(len(lyrics)):
37 |         lyric, speed = lyrics[i]
38 |         t = Thread(target=sing_lyric, args=(lyric, delays[i], speed))
39 |         threads.append(t)
40 |         t.start()
41 | 
42 |     for thread in threads:
43 |         thread.join()
44 | 
45 | if __name__ == "__main__":
46 |     sing_song()


--------------------------------------------------------------------------------
/cheerleader.py:
--------------------------------------------------------------------------------
 1 | import time
 2 | from threading import Thread, Lock
 3 | import sys
 4 | 
 5 | lock = Lock()
 6 | 
 7 | def animate_text(text, delay=0.1):
 8 |     with lock:
 9 |         for char in text:
10 |             sys.stdout.write(char)
11 |             sys.stdout.flush()
12 |             time.sleep(delay)
13 |         print()
14 | 
15 | def sing_lyric(lyric, delay, speed):
16 |     time.sleep(delay)
17 |     animate_text(lyric, speed)
18 | 
19 | def sing_song():
20 |     lyrics = [
21 |         ("\n""Hmm, she gives me love and affection", 0.08),
22 |         ("Baby, did I mention?", 0.09),
23 |         ("You're the only girl for me", 0.08),
24 |         ("No, I don't need the next one", 0.08),
25 |         ("Mama loves you too", 0.08),
26 |         ("She thinks I made the right selection", 0.09),
27 |         ("Now all that's left to do", 0.09),
28 |         ("Is just for me to pop the question""\n", 0.07)
29 |     ]
30 |     delays = [0.3, 3.5, 5.8, 8.0, 10.4, 12.0, 15.0, 16.0]
31 |     
32 |     threads = []
33 |     for i in range(len(lyrics)):
34 |         lyric, speed = lyrics[i]
35 |         t = Thread(target=sing_lyric, args=(lyric, delays[i], speed))
36 |         threads.append(t)
37 |         t.start()
38 |     for thread in threads:
39 |         thread.join()
40 |         
41 | if __name__ == "__main__":
42 |     sing_song()
43 | 


--------------------------------------------------------------------------------
/confess2/assets/blue.mp3:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/lukman467/coding/d3b3dde560a9e5eec25263a0e7b0da8a8bbd2e42/confess2/assets/blue.mp3


--------------------------------------------------------------------------------
/confess2/index.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html lang="en">
 3 | <head>
 4 |     <meta charset="UTF-8">
 5 |     <meta name="viewport" content="width=device-width, initial-scale=1.0">
 6 |     <title>❤️</title>
 7 |     <link rel="stylesheet" href="styles/main.css">
 8 | <div class="wallpaper"></div>
 9 |     <div class="content">
10 |     </div>
11 | </head>
12 | <body>
13 |     <div class="bg_heart">
14 |         <div class="message"></div>
15 |         <a href="love.html" class="next-button">pencet aku</a>
16 |     </div>
17 | 
18 |     <script src="https://code.jquery.com/jquery-3.6.0.min.js"></script>
19 |     <script src="script/main.js"></script>
20 | <script>
21 |     function setupMusic() {
22 |         const music = document.getElementById('backgroundMusic');
23 |         
24 |         const isMusicPlaying = localStorage.getItem('musicPlaying') === 'true';
25 |         const musicCurrentTime = localStorage.getItem('musicCurrentTime') || 0;
26 | 
27 |         if (isMusicPlaying) {
28 |             music.currentTime = parseFloat(musicCurrentTime);
29 |         }
30 | 
31 |         music.addEventListener('play', () => {
32 |             localStorage.setItem('musicPlaying', 'true');
33 |         });
34 | 
35 |         music.addEventListener('pause', () => {
36 |             localStorage.setItem('musicPlaying', 'false');
37 |         });
38 | 
39 |         setInterval(() => {
40 |             localStorage.setItem('musicCurrentTime', music.currentTime);
41 |         }, 1000);
42 | 
43 |         document.addEventListener('click', function startMusic() {
44 |             music.play().catch(error => {
45 |                 console.log('Autoplay prevented', error);
46 |             });
47 |             document.removeEventListener('click', startMusic);
48 |         });
49 |     }
50 | 
51 |         document.addEventListener('DOMContentLoaded', setupMusic);
52 | </script>
53 | 
54 | <audio id="backgroundMusic" loop>
55 |     <source src="assets/blue.mp3" type="audio/mpeg">
56 |     Your browser does not support the audio element.
57 | </script>
58 | </body>
59 | </html>


--------------------------------------------------------------------------------
/confess2/love.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html lang="en">
 3 | <head>
 4 |   <meta charset="UTF-8">
 5 |   <meta http-equiv="X-UA-Compatible" content="IE=edge">
 6 |   <meta name="viewport" content="width=device-width, initial-scale=1.0">
 7 |   <title>❤️</title>
 8 |   <link rel="stylesheet" href="styles/love.css">
 9 | </head>
10 | <body>
11 |   <canvas id="heart"></canvas>
12 |   <audio id="backgroundMusic" loop>
13 |     <source src="assets/blue.mp3" type="audio/mpeg">
14 |     Your browser does not support the audio element.
15 |   </audio>
16 |   <script src="script/love.js"></script>
17 | </body>
18 | </html>
19 | 


--------------------------------------------------------------------------------
/confess2/script/love.js:
--------------------------------------------------------------------------------
  1 | window.requestAnimationFrame =
  2 |   window.__requestAnimationFrame ||
  3 |   window.requestAnimationFrame ||
  4 |   window.webkitRequestAnimationFrame ||
  5 |   window.mozRequestAnimationFrame ||
  6 |   window.oRequestAnimationFrame ||
  7 |   window.msRequestAnimationFrame ||
  8 |   (function () {
  9 |     return function (callback, element) {
 10 |       var lastTime = element.__lastTime || 0;
 11 |       var currTime = Date.now();
 12 |       var timeToCall = Math.max(1, 33 - (currTime - lastTime));
 13 |       window.setTimeout(callback, timeToCall);
 14 |       element.__lastTime = currTime + timeToCall;
 15 |     };
 16 |   })();
 17 | 
 18 | window.isDevice = /android|webos|iphone|ipad|ipod|blackberry|iemobile|opera mini/i.test(
 19 |   (navigator.userAgent || navigator.vendor || window.opera).toLowerCase()
 20 | );
 21 | 
 22 | var loaded = false;
 23 | 
 24 | function init() {
 25 |   if (loaded) return;
 26 |   loaded = true;
 27 |   var mobile = window.isDevice;
 28 |   var koef = mobile ? 0.5 : 1;
 29 |   var canvas = document.getElementById("heart");
 30 |   var ctx = canvas.getContext("2d");
 31 |   var width = (canvas.width = koef * innerWidth);
 32 |   var height = (canvas.height = koef * innerHeight);
 33 |   var rand = Math.random;
 34 | 
 35 |   ctx.fillStyle = "rgba(0,0,0,1)";
 36 |   ctx.fillRect(0, 0, width, height);
 37 | 
 38 |   function drawText() {
 39 |     ctx.font = "60px Arial";
 40 |     ctx.fillStyle = "lightblue";
 41 |     ctx.textAlign = "center";
 42 |     ctx.fillText("I love you sayang", width / 2, height / 2.2 + 400);
 43 |   }
 44 | 
 45 |   function heartPosition(rad) {
 46 |     return [
 47 |       Math.pow(Math.sin(rad), 3),
 48 |       -(
 49 |         15 * Math.cos(rad) -
 50 |         5 * Math.cos(2 * rad) -
 51 |         2 * Math.cos(3 * rad) -
 52 |         Math.cos(4 * rad)
 53 |       ),
 54 |     ];
 55 |   }
 56 | 
 57 |   function scaleAndTranslate(pos, sx, sy, dx, dy) {
 58 |     return [dx + pos[0] * sx, dy + pos[1] * sy];
 59 |   }
 60 | 
 61 |   window.addEventListener("resize", function () {
 62 |     width = canvas.width = koef * innerWidth;
 63 |     height = canvas.height = koef * innerHeight;
 64 |     ctx.fillStyle = "rgba(0,0,0,1)";
 65 |     ctx.fillRect(0, 0, width, height);
 66 |   });
 67 | 
 68 |   var traceCount = mobile ? 20 : 50;
 69 |   var pointsOrigin = [];
 70 |   var dr = mobile ? 0.3 : 0.1;
 71 |   for (var i = 0; i < Math.PI * 2; i += dr)
 72 |     pointsOrigin.push(scaleAndTranslate(heartPosition(i), 310, 19, 0, 0));
 73 |   for (var i = 0; i < Math.PI * 2; i += dr)
 74 |     pointsOrigin.push(scaleAndTranslate(heartPosition(i), 250, 15, 0, 0));
 75 |   for (var i = 0; i < Math.PI * 2; i += dr)
 76 |     pointsOrigin.push(scaleAndTranslate(heartPosition(i), 190, 11, 0, 0));
 77 | 
 78 |   var heartPointsCount = pointsOrigin.length;
 79 |   var targetPoints = [];
 80 | 
 81 |   function pulse(kx, ky) {
 82 |     for (var i = 0; i < pointsOrigin.length; i++) {
 83 |       targetPoints[i] = [
 84 |         kx * pointsOrigin[i][0] + width / 2,
 85 |         ky * pointsOrigin[i][1] + height / 2.2,
 86 |       ];
 87 |     }
 88 |   }
 89 | 
 90 |   var e = [];
 91 |   for (var i = 0; i < heartPointsCount; i++) {
 92 |     var x = rand() * width;
 93 |     var y = rand() * height;
 94 |     e[i] = {
 95 |       vx: 0,
 96 |       vy: 0,
 97 |       R: 2,
 98 |       speed: rand() + 5,
 99 |       q: ~~(rand() * heartPointsCount),
100 |       D: 2 * (i % 2) - 1,
101 |       force: 0.2 * rand() + 0.7,
102 |       f: "rgba(51, 204, 255, 0.7)",
103 |       trace: Array.from({ length: traceCount }, () => ({ x, y })),
104 |     };
105 |   }
106 | 
107 |   var config = { traceK: 0.4, timeDelta: 0.6 };
108 |   var time = 0;
109 | 
110 |   function loop() {
111 |     var n = -Math.cos(time);
112 |     pulse((1 + n) * 0.5, (1 + n) * 0.5);
113 |     time += (Math.sin(time) < 0 ? 9 : n > 0.8 ? 0.2 : 1) * config.timeDelta;
114 | 
115 |     ctx.fillStyle = "rgba(0,0,0,.1)";
116 |     ctx.fillRect(0, 0, width, height);
117 | 
118 |     for (var i = e.length; i--; ) {
119 |       var u = e[i];
120 |       var q = targetPoints[u.q];
121 |       var dx = u.trace[0].x - q[0];
122 |       var dy = u.trace[0].y - q[1];
123 |       var length = Math.sqrt(dx * dx + dy * dy);
124 | 
125 |       if (length < 10) {
126 |         if (rand() > 0.95) {
127 |           u.q = ~~(rand() * heartPointsCount);
128 |         } else {
129 |           if (rand() > 0.99) u.D *= -1;
130 |           u.q = (u.q + u.D) % heartPointsCount;
131 |           if (u.q < 0) u.q += heartPointsCount;
132 |         }
133 |       }
134 | 
135 |       u.vx += (-dx / length) * u.speed;
136 |       u.vy += (-dy / length) * u.speed;
137 |       u.trace[0].x += u.vx;
138 |       u.trace[0].y += u.vy;
139 |       u.vx *= u.force;
140 |       u.vy *= u.force;
141 | 
142 |       for (var k = 0; k < u.trace.length - 1; k++) {
143 |         var T = u.trace[k];
144 |         var N = u.trace[k + 1];
145 |         N.x -= config.traceK * (N.x - T.x);
146 |         N.y -= config.traceK * (N.y - T.y);
147 |       }
148 | 
149 |       ctx.fillStyle = u.f;
150 |       u.trace.forEach((t) => ctx.fillRect(t.x, t.y, 1, 1));
151 |     }
152 | 
153 |     drawText();
154 |     window.requestAnimationFrame(loop, canvas);
155 |   }
156 | 
157 |   loop();
158 | }
159 | 
160 | function continueMusic() {
161 |   const music = document.getElementById("backgroundMusic");
162 | 
163 |   const isMusicPlaying = localStorage.getItem("musicPlaying") === "true";
164 |   const musicCurrentTime = localStorage.getItem("musicCurrentTime") || 0;
165 | 
166 |   if (music) {
167 |     if (isMusicPlaying) {
168 |       music.currentTime = parseFloat(musicCurrentTime);
169 |       music.play().catch((error) =>
170 |         console.log("Music playback failed", error)
171 |       );
172 |     }
173 |   }
174 | 
175 |   document.addEventListener("click", function startMusic() {
176 |     if (music && !isMusicPlaying) {
177 |       music.play().catch((error) => console.log("Autoplay prevented", error));
178 |       document.removeEventListener("click", startMusic);
179 |     }
180 |   });
181 | }
182 | 
183 | document.addEventListener("DOMContentLoaded", function () {
184 |   init();
185 |   continueMusic();
186 | });
187 | 


--------------------------------------------------------------------------------
/confess2/script/main.js:
--------------------------------------------------------------------------------
  1 | document.addEventListener('contextmenu', function(e) {
  2 |     e.preventDefault();
  3 | });
  4 | 
  5 | document.addEventListener('keydown', function(e) {
  6 |     if ((e.ctrlKey || e.metaKey) && (e.key === 'c' || e.key === 'C')) {
  7 |         e.preventDefault();
  8 |     }
  9 | });
 10 | 
 11 | const messages = [
 12 |     "Tap dimana aja yaaa",
 13 |     "hey kamu ❤️",
 14 |     "aku mau ngomong sesuatu nih",
 15 |     "coba pencet",
 16 |     "pencet lagi",
 17 |     "ayo semangat mencetnya",
 18 |     "janji ini terakhir",
 19 |     "serius",
 20 |     "ini",
 21 |     "terakhir",
 22 |     "tapi bohong hehe yahaha hayyuk",
 23 |     "aku tau pasti kamu kesal",
 24 |     "hmm",
 25 |     "yaudah deh",
 26 |     "padahal",
 27 |     "aku cuma mau bilang",
 28 |     "kepasar beli terasi pulangnya makan kadal",
 29 |     "i love you❤️",
 30 |     "bjiirlah",
 31 |     "coba pencet tombol dibawah ini 💝"
 32 | ];
 33 | 
 34 | let currentPage = 0;
 35 | let isLastPage = false;
 36 | 
 37 | function showMessage() {
 38 |     $('.message').text(messages[currentPage]);
 39 |     
 40 |     isLastPage = currentPage === messages.length - 1;
 41 |     
 42 |     if (isLastPage) {
 43 |         $('.next-button').show();
 44 |         $('.bg_heart').css('cursor', 'default');
 45 |     } else {
 46 |         $('.next-button').hide();
 47 |         $('.bg_heart').css('cursor', 'pointer');
 48 |     }
 49 | }
 50 | 
 51 | $('.bg_heart').on('click', function() {
 52 |     if (!isLastPage) {
 53 |         currentPage++;
 54 |         showMessage();
 55 |     }
 56 | });
 57 | 
 58 | var love = setInterval(function() {
 59 |     var r_num = Math.floor(Math.random() * 40) + 1;
 60 |     var r_size = Math.floor(Math.random() * 65) + 10;
 61 |     var r_left = Math.floor(Math.random() * 100) + 1;
 62 |     var r_bg = Math.floor(Math.random() * 25) + 100;
 63 |     var r_time = Math.floor(Math.random() * 5) + 5;
 64 |     
 65 |     $('.bg_heart').append("<div class='heart' style='width:" + r_size + "px;height:" + r_size + "px;left:" + r_left + "%;background:rgba(255," + (r_bg - 25) + "," + r_bg + ",1);animation:love " + r_time + "s ease'></div>");
 66 |     
 67 |     $('.bg_heart').append("<div class='heart' style='width:" + (r_size - 10) + "px;height:" + (r_size - 10) + "px;left:" + (r_left + r_num) + "%;background:rgba(255," + (r_bg - 25) + "," + (r_bg + 25) + ",1);animation:love " + (r_time + 5) + "s ease'></div>");
 68 |     
 69 |     $('.heart').each(function() {
 70 |         var top = parseFloat($(this).css("top"));
 71 |         var width = parseFloat($(this).css("width"));
 72 |         if (top <= -100 || width >= 150) {
 73 |             $(this).remove();
 74 |         }
 75 |     });
 76 | }, 500);
 77 | 
 78 | showMessage();
 79 | 
 80 | function clearMusicState() {
 81 |     localStorage.removeItem('musicPlaying');
 82 |     localStorage.removeItem('musicCurrentTime');
 83 | }
 84 | 
 85 | window.onload = function() {
 86 |     clearMusicState(); 
 87 | }
 88 | 
 89 | function setupMusic() {
 90 |     const music = document.getElementById('backgroundMusic');
 91 |     
 92 |     if (!localStorage.getItem('initialLoad')) {
 93 |         clearMusicState();
 94 |         localStorage.setItem('initialLoad', 'true');
 95 |         music.currentTime = 0;
 96 |     }
 97 | 
 98 |     const isMusicPlaying = localStorage.getItem('musicPlaying') === 'true';
 99 |     const musicCurrentTime = localStorage.getItem('musicCurrentTime') || 0;
100 | 
101 |     if (isMusicPlaying) {
102 |         music.currentTime = parseFloat(musicCurrentTime);
103 |         music.play().catch(error => console.log('Playback failed', error));
104 |     }
105 | 
106 |     music.addEventListener('play', () => {
107 |         localStorage.setItem('musicPlaying', 'true');
108 |     });
109 | 
110 |     music.addEventListener('pause', () => {
111 |         localStorage.setItem('musicPlaying', 'false');
112 |     });
113 | 
114 |     setInterval(() => {
115 |         localStorage.setItem('musicCurrentTime', music.currentTime);
116 |     }, 1000);
117 | 
118 |     document.addEventListener('click', function startMusic() {
119 |         music.play().catch(error => {
120 |             console.log('Autoplay prevented', error);
121 |         });
122 |         document.removeEventListener('click', startMusic);
123 |     });
124 | }
125 | 
126 | document.addEventListener('DOMContentLoaded', setupMusic);


--------------------------------------------------------------------------------
/confess2/styles/love.css:
--------------------------------------------------------------------------------
1 | canvas {
2 |     position: absolute;
3 |     left: 0;
4 |     top: 0;
5 |     width: 100%;
6 |     height: 100%;
7 |     background-color: rgba(0, 0, 0, 0.2);
8 |   }
9 |   


--------------------------------------------------------------------------------
/confess2/styles/main.css:
--------------------------------------------------------------------------------
  1 | html, body {
  2 |   height: 100%;
  3 |   margin: 0;
  4 |   font-family: 'Arial', sans-serif;
  5 |   -webkit-user-select: none;
  6 |   -ms-user-select: none;
  7 |   user-select: none;
  8 | }
  9 | 
 10 | .bg_heart {
 11 |   position: relative;
 12 |   top: 0;
 13 |   left: 0;
 14 |   width: 100%;
 15 |   height: 100%;
 16 |   overflow: hidden;
 17 |   cursor: pointer;
 18 | }
 19 | 
 20 | .heart {
 21 |   position: absolute;
 22 |   top: -50%;
 23 |   transform: rotate(-45deg);
 24 | }
 25 | 
 26 | .heart:before,
 27 | .heart:after {
 28 |   position: absolute;
 29 |   display: block;
 30 |   content: "";
 31 |   width: 100%;
 32 |   height: 100%;
 33 |   background: inherit;
 34 |   border-radius: 100%;
 35 | }
 36 | 
 37 | .heart:before {
 38 |   top: -50%;
 39 |   left: 0;
 40 | }
 41 | 
 42 | .heart:after {
 43 |   top: 0;
 44 |   right: -50%;
 45 | }
 46 | 
 47 | @keyframes love {
 48 |   0% {
 49 |       top: 110%;
 50 |   }
 51 | }
 52 | 
 53 | .message {
 54 |   position: fixed;
 55 |   top: 50%;
 56 |   left: 50%;
 57 |   transform: translate(-50%, -50%);
 58 |   color: #ff4d6d;
 59 |   font-size: 2em;
 60 |   text-align: center;
 61 |   text-shadow: 2px 2px 4px rgba(0, 0, 0, 0.2);
 62 |   z-index: 1000;
 63 |   width: 80%;
 64 |   padding: 20px;
 65 |   background-color: rgba(255, 255, 255, 0);
 66 |   border-radius: 15px;
 67 |   pointer-events: none;
 68 | }
 69 | 
 70 | .next-button {
 71 |   display: none;
 72 |   position: fixed;
 73 |   bottom: 50px;
 74 |   left: 50%;
 75 |   transform: translateX(-50%);
 76 |   padding: 15px 30px;
 77 |   background-color: #ff4d6d;
 78 |   color: white;
 79 |   border: none;
 80 |   border-radius: 25px;
 81 |   font-size: 1.2em;
 82 |   cursor: pointer;
 83 |   z-index: 1000;
 84 |   transition: all 0.3s ease;
 85 |   box-shadow: 0 4px 15px rgba(0,0,0,0.2);
 86 | }
 87 | 
 88 | .next-button:hover {
 89 |   background-color: #ff3357;
 90 |   transform: translateX(-50%) scale(1.05);
 91 | }
 92 | 
 93 | @media (max-width: 600px) {
 94 |   .message {
 95 |     font-size: 1.5em; 
 96 |     padding: 10px; 
 97 |   }
 98 | 
 99 |   .next-button {
100 |     padding: 10px 20px; 
101 |     font-size: 1em; 
102 |   }
103 | }
104 | 
105 | @media (min-width: 601px) and (max-width: 1024px) {
106 |   .message {
107 |     font-size: 2.0em;
108 |     padding: 15px;
109 |   }
110 | 
111 |   .next-button {
112 |     padding: 12px 25px; 
113 |     font-size: 1.1em; 
114 |   }
115 | }
116 | 
117 | @media (min-width: 1025px) {
118 |   .message {
119 |     font-size: 3em; 
120 |     padding: 20px; 
121 |   }
122 | 
123 |   .next-button {
124 |     padding: 15px 30px; 
125 |     font-size: 1.2em; 
126 |   }
127 | }


--------------------------------------------------------------------------------
/flower 2/index.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html lang="en">
 3 | <head>
 4 |     <meta charset="UTF-8">
 5 |     <meta name="viewport" content="width=device-width, initial-scale=1.0">
 6 |     <link rel="stylesheet" href="style.css">
 7 |     <title>Flower</title>
 8 | </head>
 9 | <body>
10 |     <div class="container">
11 |         <svg viewBox="0 0 800 600" class="main-svg">
12 |           <rect width="100%" height="100%" class="boundary"></rect>
13 |           
14 |           <linearGradient id="gradient-black-white">
15 |               <stop stop-color="black" offset="0"/>
16 |               <stop stop-color="white" offset="100%"/>
17 |           </linearGradient>
18 |           
19 |           <mask id="petal-mask" maskunits="objectBoundingBox" maskcontentunits="objectBoundingBox">
20 |               <rect y="0" width="1" height="1" fill="url(#gradient-black-white)"/>
21 |           </mask>
22 |           
23 |           <symbol id="petal-shape">
24 |               <path d="M60,400 C60,400 120,298.319352 120,200 C120,89.54305 60,0 60,0 C60,0 0,89.54305 0,200 C0,310.45695 60,400 60,400 Z" class="petal-element"></path>
25 |           </symbol>
26 |       
27 |           <svg viewBox="0 10 120 800">
28 |             <rect width="100%" height="100%" class="boundary"></rect>
29 |             <g class="petals-group">
30 |               <g class="petal-group">
31 |                 <use xlink:href="#petal-shape"/>
32 |               </g>
33 |               <g class="petal-group">
34 |                 <use xlink:href="#petal-shape"/>
35 |               </g>
36 |               <g class="petal-group">
37 |                 <use xlink:href="#petal-shape"/>
38 |               </g>
39 |               <g class="petal-group">
40 |                 <use xlink:href="#petal-shape"/>
41 |               </g>
42 |               <g class="petal-group">
43 |                 <use xlink:href="#petal-shape"/>
44 |               </g>
45 |               <g class="petal-group">
46 |                 <use xlink:href="#petal-shape"/>
47 |               </g>
48 |               <g class="petal-group">
49 |                 <use xlink:href="#petal-shape"/>
50 |               </g>
51 |               <g class="petal-group">
52 |                 <use xlink:href="#petal-shape"/>
53 |               </g>
54 |               <g class="petal-group">
55 |                 <use xlink:href="#petal-shape"/>
56 |               </g>
57 |               <g class="petal-group">
58 |                 <use xlink:href="#petal-shape"/>
59 |               </g>
60 |               <g class="petal-group">
61 |                 <use xlink:href="#petal-shape"/>
62 |               </g>
63 |               <g class="petal-group">
64 |                 <use xlink:href="#petal-shape"/>
65 |               </g>
66 |               <g class="petal-group">
67 |                 <use xlink:href="#petal-shape"/>
68 |               </g>
69 |               <g class="petal-group">
70 |                 <use xlink:href="#petal-shape"/>
71 |               </g>
72 |               <g class="petal-group">
73 |                 <use xlink:href="#petal-shape"/>
74 |               </g>
75 |             </g>
76 |           </svg>
77 |         </svg>
78 |       </div>
79 | </body>
80 | </html>


--------------------------------------------------------------------------------
/flower 2/style.css:
--------------------------------------------------------------------------------
  1 | body {
  2 |   background: #FFF;
  3 | }
  4 | 
  5 | svg {
  6 |   overflow: visible;
  7 | }
  8 | 
  9 | .main-svg {
 10 |   width: 100%;
 11 |   height: 95%;
 12 | }
 13 | 
 14 | .container {
 15 |   position: absolute;
 16 |   top: 0;
 17 |   right: 0;
 18 |   bottom: 0;
 19 |   left: 0;
 20 | }
 21 | 
 22 | .boundary {
 23 |   fill: none;
 24 | }
 25 | 
 26 | .petals-group {
 27 |   transform-origin: 60px 400px;
 28 |   animation: spin-full 20s infinite;
 29 | }
 30 | 
 31 | .petal-group {
 32 |   transform-origin: 60px 415px;
 33 | }
 34 | .petal-group:nth-of-type(15n+1) {
 35 |   transform: rotate(24deg);
 36 |   color: hsl(76.8, 95%, 60%);
 37 | }
 38 | .petal-group:nth-of-type(15n+2) {
 39 |   transform: rotate(48deg);
 40 |   color: hsl(153.6, 95%, 60%);
 41 | }
 42 | .petal-group:nth-of-type(15n+3) {
 43 |   transform: rotate(72deg);
 44 |   color: hsl(230.4, 95%, 60%);
 45 | }
 46 | .petal-group:nth-of-type(15n+4) {
 47 |   transform: rotate(96deg);
 48 |   color: hsl(307.2, 95%, 60%);
 49 | }
 50 | .petal-group:nth-of-type(15n+5) {
 51 |   transform: rotate(120deg);
 52 |   color: hsl(24, 95%, 60%);
 53 | }
 54 | .petal-group:nth-of-type(15n+6) {
 55 |   transform: rotate(144deg);
 56 |   color: hsl(100.8, 95%, 60%);
 57 | }
 58 | .petal-group:nth-of-type(15n+7) {
 59 |   transform: rotate(168deg);
 60 |   color: hsl(177.6, 95%, 60%);
 61 | }
 62 | .petal-group:nth-of-type(15n+8) {
 63 |   transform: rotate(192deg);
 64 |   color: hsl(254.4, 95%, 60%);
 65 | }
 66 | .petal-group:nth-of-type(15n+9) {
 67 |   transform: rotate(216deg);
 68 |   color: hsl(331.2, 95%, 60%);
 69 | }
 70 | .petal-group:nth-of-type(15n+10) {
 71 |   transform: rotate(240deg);
 72 |   color: hsl(48, 95%, 60%);
 73 | }
 74 | .petal-group:nth-of-type(15n+11) {
 75 |   transform: rotate(264deg);
 76 |   color: hsl(124.8, 95%, 60%);
 77 | }
 78 | .petal-group:nth-of-type(15n+12) {
 79 |   transform: rotate(288deg);
 80 |   color: hsl(201.6, 95%, 60%);
 81 | }
 82 | .petal-group:nth-of-type(15n+13) {
 83 |   transform: rotate(312deg);
 84 |   color: hsl(278.4, 95%, 60%);
 85 | }
 86 | .petal-group:nth-of-type(15n+14) {
 87 |   transform: rotate(336deg);
 88 |   color: hsl(355.2, 95%, 60%);
 89 | }
 90 | .petal-group:nth-of-type(15n+15) {
 91 |   transform: rotate(360deg);
 92 |   color: hsl(72, 95%, 60%);
 93 | }
 94 | 
 95 | .petal-group use {
 96 |   fill: currentColor;
 97 |   transform-origin: 60px 250px;
 98 |   -webkit-mask: url(#petal-mask);
 99 |           mask: url(#petal-mask);
100 |   animation: spin-full 5s infinite;
101 | }
102 | 
103 | @keyframes spin-full {
104 |   100% {
105 |     transform: rotate(360deg);
106 |   }
107 | }


--------------------------------------------------------------------------------
/flower/flower 1.py:
--------------------------------------------------------------------------------
 1 | import turtle as tr
 2 | 
 3 | layar = tr.Screen()
 4 | 
 5 | tr.setup(800, 800)
 6 | layar.bgcolor('#262626')
 7 | tr.pencolor('#540d6e')
 8 | tr.speed(0)
 9 | tr.tracer(100)
10 | tr.pensize(1)
11 | 
12 | warna_bunga = ('#FF78C4', '#97DBAE', '#C1EFFF', '#F0B86E')
13 | 
14 | for i in range(3):
15 |     for n in range(400):
16 |         tr.color(warna_bunga[n % 4])
17 |         tr.circle(190 - n / 2, 90)
18 |         tr.left(90)
19 |         tr.circle(190 - n / 2, 90)
20 |         tr.color(warna_bunga[n % 4])
21 |         
22 |     tr.left(30)
23 | 
24 | layar.exitonclick()
25 | 


--------------------------------------------------------------------------------
/flower/flower 10.py:
--------------------------------------------------------------------------------
 1 | import turtle
 2 | 
 3 | screen = turtle.Screen()
 4 | screen.bgcolor("black")
 5 | 
 6 | t = turtle.Turtle()
 7 | t.speed(0)
 8 | t.hideturtle()
 9 | 
10 | palette = ["yellow", "red", "yellow", "red"]
11 | 
12 | iterations = 120
13 | for step in range(iterations):
14 |     radius = 200 - step
15 |     for shade in palette:
16 |         t.color(shade)
17 |         t.circle(radius, 100)
18 |         t.left(90)
19 |         t.circle(radius, 100)
20 |         t.right(60)
21 |         t.end_fill()
22 | 
23 | screen.mainloop()
24 | 


--------------------------------------------------------------------------------
/flower/flower 2.py:
--------------------------------------------------------------------------------
 1 | import turtle
 2 | 
 3 | t = turtle.Turtle()
 4 | t.speed(2) 
 5 | t.pensize(2)
 6 | 
 7 | t.penup()
 8 | t.left(90)
 9 | t.forward(200)
10 | t.pendown()
11 | t.right(90)
12 | 
13 | t.fillcolor("red")
14 | t.begin_fill()
15 | t.circle(10, 180)
16 | t.circle(25, 110)
17 | t.left(50)
18 | t.circle(60, 45)
19 | t.circle(20, 170)
20 | t.right(24)
21 | t.forward(30)
22 | t.left(10)
23 | t.circle(30, 110)
24 | t.forward(20)
25 | t.left(40)
26 | t.circle(90, 70)
27 | t.circle(30, 150)
28 | t.right(30)
29 | t.forward(15)
30 | t.circle(80, 90)
31 | t.left(15)
32 | t.forward(45)
33 | t.right(165)
34 | t.forward(20)
35 | t.left(155)
36 | t.circle(150, 80)
37 | t.left(50)
38 | t.circle(150, 90)
39 | t.end_fill()
40 | 
41 | t.left(150)
42 | t.circle(-90, 70)
43 | t.left(20)
44 | t.circle(75, 105)
45 | t.setheading(60)
46 | t.circle(80, 98)
47 | t.circle(-90, 40)
48 | t.left(180)
49 | t.circle(90, 40)
50 | t.circle(-80, 98)
51 | t.setheading(-83)
52 | 
53 | t.forward(30)
54 | t.left(90)
55 | t.forward(25)
56 | t.left(45)
57 | t.fillcolor("green")
58 | t.begin_fill()
59 | t.circle(-80, 90)
60 | t.right(90)
61 | t.circle(-80, 90)
62 | t.end_fill()
63 | 
64 | t.right(135)
65 | t.forward(60)
66 | t.left(180)
67 | t.forward(85)
68 | t.left(90)
69 | t.forward(80)
70 | t.right(90)
71 | t.right(45)
72 | 
73 | t.fillcolor("green")
74 | t.begin_fill()
75 | t.circle(80, 90)
76 | t.left(90)
77 | t.circle(80, 90)
78 | t.end_fill()
79 | 
80 | t.left(135)
81 | t.forward(60)
82 | t.left(180)
83 | t.forward(60)
84 | t.right(90)
85 | t.circle(200, 60)
86 | 
87 | turtle.done()
88 | 


--------------------------------------------------------------------------------
/flower/flower 7.py:
--------------------------------------------------------------------------------
 1 | import turtle
 2 | 
 3 | t = turtle.Turtle()
 4 | s = turtle.Screen()
 5 | 
 6 | s.bgcolor('#262626')
 7 | t.pencolor('magenta')
 8 | t.speed(100)
 9 | 
10 | col = ('cyan', 'yellow', 'red', 'light green')
11 | 
12 | for n in range(10):
13 |     for x in range(8):
14 |         t.speed(x+10)
15 |         for i in range(2):
16 |             t.pensize(2)
17 |             t.circle(80+n*20, 90)
18 |             t.lt(90)
19 |         t.lt(45)
20 |     t.pencolor(col[n%4])
21 | s.exitonclick()
22 | turtle.done()
23 | 


--------------------------------------------------------------------------------
/flower/flower 9.py:
--------------------------------------------------------------------------------
 1 | from turtle import *
 2 | import colorsys
 3 | 
 4 | pensize(2)
 5 | speed(0)
 6 | Screen().bgcolor('black')
 7 | penup()
 8 | setpos(0, -50) 
 9 | pendown()
10 | 
11 | start_shade = 0.5
12 | color_variation = 0.3
13 | 
14 | for shape in range(16):
15 |     for layer in range(15):
16 |         color_value = start_shade + (shape/5) * color_variation
17 |         color_value = color_value % 1.0
18 |         
19 |         rgb = colorsys.hsv_to_rgb(color_value, 0.8 + layer/75, 1)
20 |         color(rgb)
21 |         
22 |         right(90)
23 |         circle(200 - layer * 6, 90)
24 |         left(90)
25 |         circle(200 - layer * 6, 90)
26 |         right(180)
27 |     
28 |     circle(60, 24)
29 | 
30 | exitonclick()
31 | 


--------------------------------------------------------------------------------
/forever young.py:
--------------------------------------------------------------------------------
 1 | import time
 2 | from threading import Thread, Lock
 3 | import sys
 4 | 
 5 | lock = Lock()
 6 | 
 7 | def animate_text(text, delay=0.1):
 8 |     with lock:
 9 |         for char in text:
10 |             sys.stdout.write(char)
11 |             sys.stdout.flush()
12 |             time.sleep(delay)
13 |         print()
14 | 
15 | def sing_lyric(lyric, delay, speed):
16 |     time.sleep(delay)
17 |     animate_text(lyric, speed)
18 | 
19 | def sing_song():
20 |     lyrics = [
21 |         ("\n""Forever young", 0.09),
22 |         ("I want to be forever young", 0.09),
23 |         ("Do you really want to live forever?", 0.08),
24 |         ("Forever, and ever", 0.14),
25 |         ("Forever young", 0.09),
26 |         ("I want to be forever young", 0.1),
27 |         ("Do you really want to live forever?", 0.08),
28 |         ("Forever, and ever", 0.14)
29 |     ]
30 |     delays = [0.3, 2.8, 7.5, 10.9, 14.5, 16.9, 21.6, 24.9]
31 |     
32 |     threads = []
33 |     for i in range(len(lyrics)):
34 |         lyric, speed = lyrics[i]
35 |         t = Thread(target=sing_lyric, args=(lyric, delays[i], speed))
36 |         threads.append(t)
37 |         t.start()
38 |     for thread in threads:
39 |         thread.join()
40 | 
41 | if __name__ == "__main__":
42 |     sing_song()


--------------------------------------------------------------------------------
/ga romantis.py:
--------------------------------------------------------------------------------
 1 | import time
 2 | from threading import Thread, Lock
 3 | import sys
 4 | 
 5 | lock = Lock()
 6 | 
 7 | def animate_text(text, delay=0.1):
 8 |     with lock:
 9 |         for char in text:
10 |             sys.stdout.write(char)
11 |             sys.stdout.flush()
12 |             time.sleep(delay)
13 |         print()
14 | 
15 | def sing_lyric(lyric, delay, speed):
16 |     time.sleep(delay)
17 |     animate_text(lyric, speed)
18 | 
19 | def sing_song():
20 |     lyrics = [
21 |         ("\nAku ga mau jadi mataharimu", 0.08),
22 |         ("Karena itu akan membuatku jauh", 0.08),
23 |         ("Aku ga mau jadi bintang-bintangmu", 0.08),
24 |         ("Walau indah itu juga 'kan jauh", 0.08),
25 |         ("Yang aku mau menjadi udaramu", 0.09),
26 |         ("Selalu setia tiap hela nafasmu\n", 0.1),
27 |         ("Aku ga romantis", 0.08),
28 |         ("Maaf, aku ga romantis", 0.08),
29 |         ("Maaf, aku ga romantis", 0.08),
30 |         ("Maaf, aku ga romantis\n", 0.08)
31 |     ]
32 |     delays = [0.3, 4.0, 7.8, 11.5, 14.9, 18.3, 22.0, 23.7, 25.3, 26.8]
33 |     
34 |     threads = []
35 |     for i in range(len(lyrics)):
36 |         lyric, speed = lyrics[i]
37 |         t = Thread(target=sing_lyric, args=(lyric, delays[i], speed))
38 |         threads.append(t)
39 |         t.start()
40 |     for thread in threads:
41 |         thread.join()
42 | 
43 | if __name__ == "__main__":
44 |     sing_song()
45 | 


--------------------------------------------------------------------------------
/happy birthday python/happy birthday 5.py:
--------------------------------------------------------------------------------
  1 | import turtle as trtl
  2 | import math
  3 | import random
  4 | 
  5 | def ellipse_x(width, angle_deg):
  6 |     angle_rad = math.radians(angle_deg)
  7 |     return width * math.cos(angle_rad)
  8 | 
  9 | def ellipse_y(height, angle_deg):
 10 |     angle_rad = math.radians(angle_deg)
 11 |     return height * math.sin(angle_rad)
 12 | 
 13 | screen = trtl.Screen()
 14 | screen.bgcolor("#d3dae8")
 15 | screen.setup(900, 800)
 16 | screen.title("Happy Birthday Furina")
 17 | 
 18 | pen = trtl.Turtle()
 19 | pen.pensize(3)
 20 | pen.speed(0)
 21 | pen.hideturtle()
 22 | 
 23 | screen.tracer(1)
 24 | screen.delay(1)
 25 | color_palette = {
 26 |     "light_green": "#c5e8c8",
 27 |     "medium_green": "#a3d2a7",
 28 |     "light_yellow": "#f7e8aa",
 29 |     "cream": "#fffceb",
 30 |     "off_white": "#fffdf4",
 31 |     "brown": "#8b5a2b",
 32 |     "dark_brown": "#5e4425",
 33 |     "orange": "#ffa500",
 34 |     "golden_yellow": "#ffb732",
 35 |     "teal": "#66cccc",
 36 |     "flame_orange": "#ff6600",
 37 |     "sky_blue": "#87ceeb",
 38 |     "light_steel": "#b0c4de",
 39 |     "confetti_colors": ["#4CAF50", "#FFC107", "#2196F3", "#FF5722", "#9C27B0", "#3F51B5", "#00BCD4", "#009688"]
 40 | }
 41 | 
 42 | def draw_ellipse(t, width, height, color, fill_color, y_offset=0):
 43 |     t.penup()
 44 |     t.goto(width, y_offset)
 45 |     t.pendown()
 46 |     t.pencolor(color)
 47 |     t.begin_fill()
 48 |     for deg in range(360):
 49 |         x = ellipse_x(width, deg)
 50 |         y = ellipse_y(height, deg) + y_offset
 51 |         t.goto(x, y)
 52 |     t.fillcolor(fill_color)
 53 |     t.end_fill()
 54 | 
 55 | def draw_cake_layer(t, width, height, outline_color, fill_color, y_offset):
 56 |     draw_ellipse(t, width, height, outline_color, fill_color, y_offset)
 57 | 
 58 | def draw_candle(t, x_pos, y_base, height):
 59 |     t.penup()
 60 |     t.goto(x_pos + 4, y_base)
 61 |     t.pendown()
 62 |     t.pencolor(color_palette["teal"])
 63 |     t.begin_fill()
 64 |     for deg in range(360):
 65 |         x = ellipse_x(4, deg) + x_pos
 66 |         y = ellipse_y(1, deg) + y_base
 67 |         t.goto(x, y)
 68 |     t.goto(x_pos + 4, y_base + height)
 69 |     for deg in range(540):
 70 |         x = ellipse_x(4, deg) + x_pos
 71 |         y = ellipse_y(1, deg) + y_base + height
 72 |         t.goto(x, y)
 73 |     t.goto(x_pos - 4, y_base)
 74 |     t.fillcolor(color_palette["teal"])
 75 |     t.end_fill()
 76 |     
 77 |     t.pencolor("white")
 78 |     t.pensize(4)
 79 |     for i in range(1, 6):
 80 |         t.goto(x_pos + 4, y_base + 10 * i)
 81 |         t.penup()
 82 |         t.goto(x_pos - 4, y_base + 10 * i)
 83 |         t.pendown()
 84 |     t.penup()
 85 |     t.goto(x_pos, y_base + height)
 86 |     t.pendown()
 87 |     t.goto(x_pos, y_base + height + 10)
 88 |     t.pensize(3)
 89 |     
 90 |     t.penup()
 91 |     t.goto(x_pos + 4, y_base + height + 20)
 92 |     t.pendown()
 93 |     t.pencolor(color_palette["flame_orange"])
 94 |     t.begin_fill()
 95 |     for deg in range(360):
 96 |         x = ellipse_x(4, deg) + x_pos
 97 |         y = ellipse_y(10, deg) + y_base + height + 20
 98 |         t.goto(x, y)
 99 |     t.fillcolor(color_palette["flame_orange"])
100 |     t.end_fill()
101 | 
102 | def add_dots(t, count, x_min, x_max, y_min, y_max, size_min, size_max):
103 |     colors = color_palette["confetti_colors"]
104 |     
105 |     for _ in range(count):
106 |         t.penup()
107 |         x = random.randint(x_min, x_max)
108 |         y = random.randint(y_min, y_max)
109 |         t.goto(x, y)
110 |         t.pendown()
111 |         t.dot(random.randint(size_min, size_max), random.choice(colors))
112 | 
113 | draw_cake_layer(pen, 150, 60, "white", color_palette["light_green"], 0)
114 | 
115 | pen.penup()
116 | pen.pensize(4)
117 | pen.goto(150, 0)
118 | pen.pendown()
119 | pen.begin_fill()
120 | for deg in range(180):
121 |     x = ellipse_x(150, -deg)
122 |     y = ellipse_y(70, -deg)
123 |     pen.goto(x, y)
124 | for deg in range(180, 360):
125 |     x = ellipse_x(150, deg)
126 |     y = ellipse_y(60, deg)
127 |     pen.goto(x, y)
128 | pen.fillcolor(color_palette["medium_green"])
129 | pen.end_fill()
130 | 
131 | draw_cake_layer(pen, 120, 48, "white", color_palette["light_yellow"], 0)
132 | 
133 | pen.begin_fill()
134 | pen.pensize(4)
135 | pen.pencolor(color_palette["light_steel"])
136 | for deg in range(540):
137 |     x = ellipse_x(120, deg)
138 |     y = ellipse_y(48, deg) + 70
139 |     pen.goto(x, y)
140 | pen.goto(-120, 0)
141 | pen.fillcolor(color_palette["light_yellow"])
142 | pen.end_fill()
143 | 
144 | draw_cake_layer(pen, 120, 48, color_palette["light_yellow"], color_palette["light_yellow"], 70)
145 | draw_cake_layer(pen, 110, 44, color_palette["cream"], color_palette["cream"], 70)
146 | 
147 | pen.penup()
148 | pen.pensize(4)
149 | pen.goto(120, 0)
150 | pen.pendown()
151 | pen.begin_fill()
152 | pen.pencolor(color_palette["sky_blue"])
153 | for deg in range(180):
154 |     x = ellipse_x(120, -deg)
155 |     y = ellipse_y(48, -deg) + 10
156 |     pen.goto(x, y)
157 | pen.goto(-120, 0)
158 | for deg in range(180, 360):
159 |     x = ellipse_x(120, deg)
160 |     y = ellipse_y(48, deg)
161 |     pen.goto(x, y)
162 | pen.fillcolor(color_palette["sky_blue"])
163 | pen.end_fill()
164 | 
165 | pen.penup()
166 | pen.pensize(4)
167 | pen.goto(120, 70)
168 | pen.pendown()
169 | pen.begin_fill()
170 | pen.pensize(4)
171 | pen.pencolor(color_palette["light_steel"])
172 | for i in range(1800):
173 |     x = ellipse_x(120, 0.1 * i)
174 |     y = ellipse_y(-18, i) + 10
175 |     pen.goto(x, y)
176 | pen.goto(-120, 70)
177 | pen.pensize(1)
178 | for deg in range(180, 360):
179 |     x = ellipse_x(120, deg)
180 |     y = ellipse_y(48, deg) + 70
181 |     pen.goto(x, y)
182 | pen.fillcolor(color_palette["light_steel"])
183 | pen.end_fill()
184 | 
185 | pen.penup()
186 | pen.pensize(4)
187 | pen.goto(80, 70)
188 | pen.pendown()
189 | pen.begin_fill()
190 | pen.pencolor(color_palette["brown"])
191 | pen.goto(80, 120)
192 | for deg in range(180):
193 |     x = ellipse_x(80, deg)
194 |     y = ellipse_y(32, deg) + 120
195 |     pen.goto(x, y)
196 | pen.goto(-80, 70)
197 | for deg in range(180, 360):
198 |     x = ellipse_x(80, deg)
199 |     y = ellipse_y(32, deg) + 70
200 |     pen.goto(x, y)
201 | pen.fillcolor(color_palette["brown"])
202 | pen.end_fill()
203 | 
204 | draw_cake_layer(pen, 80, 32, color_palette["dark_brown"], color_palette["dark_brown"], 120)
205 | draw_cake_layer(pen, 70, 28, color_palette["orange"], color_palette["orange"], 120)
206 | 
207 | pen.penup()
208 | pen.pensize(4)
209 | pen.goto(80, 120)
210 | pen.pendown()
211 | pen.begin_fill()
212 | pen.pencolor(color_palette["dark_brown"])
213 | for i in range(1800):
214 |     x = ellipse_x(80, 0.1 * i)
215 |     y = ellipse_y(-12, i) + 80
216 |     pen.goto(x, y)
217 | pen.goto(-80, 120)
218 | pen.pensize(1)
219 | for deg in range(180, 360):
220 |     x = ellipse_x(80, deg)
221 |     y = ellipse_y(32, deg) + 120
222 |     pen.goto(x, y)
223 | pen.fillcolor(color_palette["dark_brown"])
224 | pen.end_fill()
225 | 
226 | candle_positions = [
227 |     (60, 120, 50), 
228 |     (-60, 120, 50),
229 |     (0, 130, 50),
230 |     (30, 110, 50),
231 |     (-30, 110, 50)
232 | ]
233 | 
234 | for pos in candle_positions:
235 |     draw_candle(pen, pos[0], pos[1], pos[2])
236 | 
237 | dot_regions = [
238 |     (80, -120, 120, -25, 30, 2, 5),
239 |     (40, -90, 90, -35, 10, 2, 5),
240 |     (40, -80, 80, 60, 90, 2, 5),
241 |     (30, -50, 50, 45, 70, 2, 5),
242 |     (50, -500, 500, 120, 300, 3, 5)
243 | ]
244 | 
245 | for region in dot_regions:
246 |     add_dots(pen, *region)
247 | 
248 | pen.seth(90)
249 | pen.penup()
250 | pen.goto(0, 0)
251 | pen.forward(210)
252 | pen.left(90)
253 | pen.forward(170)
254 | pen.pendown()
255 | pen.write("Happy Birthday", font=("Curlz MT", 50 , 'bold'))
256 | 
257 | screen.update()
258 | trtl.done()


--------------------------------------------------------------------------------
/happy birthday python/happy birthday.py:
--------------------------------------------------------------------------------
  1 | import turtle
  2 | 
  3 | my_turtle_cursor = turtle.Turtle()
  4 | my_turtle_screen = turtle.Screen()
  5 | y_coordinate = -125
  6 | 
  7 | def draw_circle_on_top_of_stick(fill_color, border_color, x, y, radius):
  8 |     my_turtle_cursor.penup()
  9 |     my_turtle_cursor.pensize(3)
 10 |     my_turtle_cursor.color(fill_color)
 11 |     my_turtle_cursor.fillcolor(border_color)
 12 |     my_turtle_cursor.goto(x, y)
 13 |     my_turtle_cursor.pendown()
 14 |     my_turtle_cursor.begin_fill()
 15 |     my_turtle_cursor.circle(radius)
 16 |     my_turtle_cursor.end_fill()
 17 |     my_turtle_cursor.getscreen().update()
 18 | 
 19 | def draw_candle_for_cake(fill_color, border_color, x, y):
 20 |     my_turtle_cursor.penup()
 21 |     my_turtle_cursor.color(border_color)
 22 |     my_turtle_cursor.fillcolor(fill_color)
 23 |     my_turtle_cursor.goto(x, y)
 24 |     my_turtle_cursor.pendown()
 25 |     my_turtle_cursor.begin_fill()
 26 |     my_turtle_cursor.forward(25)
 27 |     my_turtle_cursor.left(90)
 28 |     my_turtle_cursor.forward(60)
 29 |     my_turtle_cursor.left(90)
 30 |     my_turtle_cursor.forward(25)
 31 |     my_turtle_cursor.left(90)
 32 |     my_turtle_cursor.forward(60)
 33 |     my_turtle_cursor.left(90)
 34 |     my_turtle_cursor.end_fill()
 35 |     my_turtle_cursor.getscreen().update()
 36 | 
 37 | def draw_stick_on_candle(fill_color, x, y, cursor_size):
 38 |     my_turtle_cursor.penup()
 39 |     my_turtle_cursor.color(fill_color)
 40 |     my_turtle_cursor.fillcolor(fill_color)
 41 |     my_turtle_cursor.goto(x, y)
 42 |     my_turtle_cursor.pensize(cursor_size)
 43 |     my_turtle_cursor.begin_fill()
 44 |     my_turtle_cursor.pendown()
 45 |     my_turtle_cursor.right(90)
 46 |     my_turtle_cursor.forward(12)
 47 |     my_turtle_cursor.end_fill()
 48 |     my_turtle_cursor.getscreen().update()
 49 | 
 50 | def write_happy_inside_circle(text_color, x, y):
 51 |     my_turtle_cursor.penup()
 52 |     my_turtle_cursor.color(text_color)
 53 |     my_turtle_cursor.goto(x, y)
 54 |     my_turtle_cursor.begin_fill()
 55 |     my_turtle_cursor.pendown()
 56 |     my_turtle_cursor.write("Happy", font=("sans-serif", 26, "bold"))
 57 |     my_turtle_cursor.getscreen().update()
 58 | 
 59 | def write_birthday_inside_circle(text_color, x, y):
 60 |     my_turtle_cursor.penup()
 61 |     my_turtle_cursor.color(text_color)
 62 |     my_turtle_cursor.goto(x, y)
 63 |     my_turtle_cursor.begin_fill()
 64 |     my_turtle_cursor.pendown()
 65 |     my_turtle_cursor.write("Birthday", font=("sans-serif", 26, "bold"))
 66 |     my_turtle_cursor.getscreen().update()
 67 | 
 68 | def draw_stick(fill_color, border_color, x, y):
 69 |     my_turtle_cursor.penup()
 70 |     my_turtle_cursor.pensize(3)
 71 |     my_turtle_cursor.color(border_color)
 72 |     my_turtle_cursor.fillcolor(fill_color)
 73 |     my_turtle_cursor.goto(x, y)
 74 |     my_turtle_cursor.begin_fill()
 75 |     my_turtle_cursor.pendown()
 76 |     my_turtle_cursor.left(180)
 77 |     my_turtle_cursor.forward(200)
 78 |     my_turtle_cursor.end_fill()
 79 | 
 80 | def draw_toppings_on_cake(fill_color, border_color, x, y, radius):
 81 |     my_turtle_cursor.penup()
 82 |     my_turtle_cursor.color(border_color)
 83 |     my_turtle_cursor.fillcolor(fill_color)
 84 |     my_turtle_cursor.goto(x, y)
 85 |     my_turtle_cursor.pendown()
 86 |     my_turtle_cursor.begin_fill()
 87 |     my_turtle_cursor.forward(10)
 88 |     my_turtle_cursor.left(90)
 89 |     my_turtle_cursor.circle(radius, extent = 180)
 90 |     my_turtle_cursor.left(90)
 91 |     my_turtle_cursor.forward(10)
 92 |     my_turtle_cursor.end_fill()
 93 |     my_turtle_cursor.getscreen().update()
 94 | 
 95 | def draw_layer_of_the_cake(fill_color, border_color, cursor_size, x, y, width, height):
 96 |     my_turtle_cursor.hideturtle()
 97 |     my_turtle_cursor.penup()
 98 |     my_turtle_cursor.pensize(cursor_size)
 99 |     my_turtle_cursor.color(border_color)
100 |     my_turtle_cursor.fillcolor(fill_color)
101 |     my_turtle_cursor.goto(x, y)
102 |     my_turtle_cursor.pendown()
103 |     my_turtle_cursor.begin_fill()
104 | 
105 |     for i in range(2):
106 |         my_turtle_cursor.forward(width)
107 |         my_turtle_cursor.left(90)
108 |         my_turtle_cursor.forward(height)
109 |         my_turtle_cursor.left(90)
110 | 
111 |     my_turtle_cursor.end_fill()
112 |     my_turtle_cursor.setheading(0)
113 |     my_turtle_cursor.getscreen().update()
114 | 
115 | my_turtle_screen.bgcolor("#FFFDD0")
116 | 
117 | parts_of_cake = []
118 | parts_of_cake.append(["#A020F0", "#000000", 3, 30])
119 | parts_of_cake.append(["#55FF55", "#000000", 3, 20])
120 | parts_of_cake.append(["#B87333", "#000000", 3, 60])
121 | 
122 | draw_layer_of_the_cake("#FFC0CB", "#000000", 3, -220, y_coordinate - 70, 400, 10)
123 | 
124 | for parts in parts_of_cake:
125 |     draw_layer_of_the_cake(parts[0], parts[1], parts[2], -135, y_coordinate - 60, 240, parts[3])
126 |     y_coordinate += parts[3]
127 | 
128 | draw_toppings_on_cake("#C20067", "#000000", -120, y_coordinate - 60, 10)
129 | draw_toppings_on_cake("#FFFF00", "#000000", -80, y_coordinate - 60, 10)
130 | draw_toppings_on_cake("#FF0000", "#000000", 25, y_coordinate - 60, 10)
131 | draw_toppings_on_cake("#0000FF", "#000000", 59, y_coordinate - 60, 10)
132 | draw_toppings_on_cake("#FFA500", "#000000", -135, y_coordinate - 80, 10)
133 | draw_toppings_on_cake("#E4E6EB", "#000000", -135, y_coordinate - 100, 10)
134 | draw_toppings_on_cake("#FFA500", "#000000", -135, y_coordinate - 120, 10)
135 | draw_toppings_on_cake("#181A18", "#000000", -80, y_coordinate - 80, 10)
136 | draw_toppings_on_cake("#0000FF", "#000000", -65, y_coordinate - 110, 10)
137 | draw_toppings_on_cake("#FFD700", "#000000", -95, y_coordinate - 140, 10)
138 | draw_toppings_on_cake("#181A18", "#000000", 10, y_coordinate - 80, 10)
139 | draw_toppings_on_cake("#E4E6EB", "#000000", -20, y_coordinate - 110, 10)
140 | draw_toppings_on_cake("#181418", "#000000", 35, y_coordinate - 140, 10)
141 | draw_toppings_on_cake("#FFA500", "#000000", 75, y_coordinate - 80, 10)
142 | draw_toppings_on_cake("#E4E6EB", "#000000", 75, y_coordinate - 110, 10)
143 | draw_toppings_on_cake("#FFD700", "#000000", 75, y_coordinate - 140, 10)
144 | draw_candle_for_cake("#FFF44F", "#000000", -40, y_coordinate - 60)
145 | draw_stick_on_candle("#181A18", -26, y_coordinate + 15, 7)
146 | draw_stick("#181A18", "#181A18", 0, y_coordinate - 60)
147 | draw_circle_on_top_of_stick("#181A18", "#FFFDD0", 100, y_coordinate + 235, 100)
148 | write_happy_inside_circle("#000000", -70, y_coordinate + 240)
149 | write_birthday_inside_circle("#000000", -80, y_coordinate + 190)
150 | 
151 | turtle.done()
152 | 


--------------------------------------------------------------------------------
/happy birthday python/happy birthday_2.py:
--------------------------------------------------------------------------------
 1 | import turtle
 2 | 
 3 | bg = turtle.Screen()
 4 | bg.bgcolor("black")
 5 | 
 6 | turtle.pensize(3)
 7 | 
 8 | turtle.hideturtle()
 9 | turtle.penup()
10 | turtle.goto(-165, -180) 
11 | turtle.color("white")
12 | turtle.pendown()
13 | turtle.forward(330)
14 | 
15 | turtle.penup()
16 | turtle.goto(-155, -150) 
17 | turtle.color("white")
18 | turtle.pendown()
19 | turtle.forward(305)
20 | 
21 | turtle.penup()
22 | turtle.goto(-145, -120)
23 | turtle.color("white")
24 | turtle.pendown()
25 | turtle.forward(280)
26 | 
27 | turtle.penup()
28 | turtle.goto(-95, -100)
29 | turtle.color("pink")
30 | turtle.begin_fill()
31 | turtle.pendown()
32 | turtle.forward(190)
33 | turtle.left(90)
34 | turtle.forward(95)
35 | turtle.left(90)
36 | turtle.forward(190)
37 | turtle.left(90)
38 | turtle.forward(95)
39 | turtle.end_fill()
40 | 
41 | positions = [-75, -25, 25, 75]
42 | colors = ["red", "blue", "yellow", "green"]
43 | 
44 | for i, pos in enumerate(positions):
45 |     turtle.penup()
46 |     turtle.goto(pos, 20)
47 |     turtle.color(colors[i])
48 |     turtle.pendown()
49 |     turtle.forward(20)
50 | 
51 | for pos in positions:
52 |     turtle.penup()
53 |     turtle.goto(pos, 30)
54 |     turtle.color("red")
55 |     turtle.pendown()
56 |     turtle.forward(3)
57 | 
58 | turtle.penup()
59 | turtle.goto(10, -60)
60 | turtle.pendown()
61 | 
62 | circle_colors = ["red", "orange", "brown", "green", "blue", "purple", "grey"]
63 | for each_color in circle_colors:
64 |     angle = 360 / len(circle_colors)
65 |     turtle.color(each_color)
66 |     turtle.circle(10)
67 |     turtle.right(angle)
68 |     turtle.forward(10)
69 | 
70 | turtle.penup()
71 | turtle.goto(-160, 50)
72 | turtle.color("white")
73 | turtle.pendown()
74 | turtle.write("happy birthday to you<3", font=("Poppins", 25, "normal"))
75 | turtle.color("lightblue")
76 | 
77 | turtle.done()
78 | 


--------------------------------------------------------------------------------
/heart.py:
--------------------------------------------------------------------------------
 1 | import math
 2 | from turtle import *
 3 | 
 4 | def hearta(k):
 5 |     return 15*math.sin(k)**3
 6 | 
 7 | def heartb(k):
 8 |     return 12*math.cos(k)-5*\
 9 |     math.cos(2*k)-2*\
10 |     math.cos(3*k)-\
11 |     math.cos(4*k)
12 |     
13 | speed(9000)
14 | bgcolor("black")
15 | 
16 | for i in range(6000):
17 |     goto(hearta(i)*20,heartb(i)*20)
18 |     for j in range(5):
19 |         color("red")
20 |     goto(0,0)
21 | done()


--------------------------------------------------------------------------------
/heart_14.py:
--------------------------------------------------------------------------------
 1 | import turtle
 2 | import math
 3 | 
 4 | t = turtle.Turtle()
 5 | t.speed(0)
 6 | t.color("red")
 7 | turtle.bgcolor("black")
 8 | 
 9 | def corazon(n):
10 |     x = 16 * math.sin(n) ** 3
11 |     y = 13 * math.cos(n) - 5 * \
12 |         math.cos(2*n) - 2*math.cos(3*n) - \
13 |         math.cos(4*n)
14 |     return x, y
15 | 
16 | t.penup()
17 | for i in range(30):
18 |     t.goto(0, 0)
19 |     t.pendown()
20 |     for n in range(0, 100, 2):
21 |         x, y = corazon(n/10)
22 |         t.goto(x*i, y*i)
23 |     t.penup()
24 | 
25 | t.hideturtle()
26 | turtle.done()
27 | 


--------------------------------------------------------------------------------
/heart_2.py:
--------------------------------------------------------------------------------
 1 | import turtle
 2 | import time
 3 | 
 4 | screen = turtle.Screen()
 5 | screen.setup(800, 800)
 6 | screen.bgcolor("pink")
 7 | 
 8 | t = turtle.Turtle()
 9 | t.hideturtle()
10 | t.speed(3)
11 | 
12 | def draw_heart(x, y, size, color, thickness):
13 |     t.penup()
14 |     t.goto(x, y)
15 |     t.color(color)
16 |     t.pensize(thickness)
17 |     t.pendown()
18 |     t.begin_fill()
19 |     t.left(140)
20 |     t.forward(size)
21 |     
22 |     for _ in range(200):
23 |         t.right(1)
24 |         t.forward(size * 0.009)
25 |     
26 |     t.left(120)
27 |     
28 |     for _ in range(200):
29 |         t.right(1)
30 |         t.forward(size * 0.009)
31 |     
32 |     t.forward(size)
33 |     t.end_fill()
34 |     t.setheading(0)
35 | 
36 | hearts = [
37 |     (0, -150, 300, "#FF9999", 5),
38 |     (0, -135, 270, "#FFCCCC", 5),
39 |     (0, -120, 240, "#FFE6E6", 5),
40 |     (0, -105, 210, "#FFCCCC", 5),
41 |     (0, -90, 180, "#FF99CC", 5),
42 |     (0, -75, 150, "#FFCCFF", 5),
43 |     (0, -50, 100, "#FF6666", 5)
44 | ]
45 | 
46 | for heart in hearts:
47 |     draw_heart(*heart)
48 |     time.sleep(0.5)
49 | 
50 | screen.mainloop()
51 | 


--------------------------------------------------------------------------------
/heart_8.py:
--------------------------------------------------------------------------------
 1 | import math
 2 | import turtle
 3 | 
 4 | def heart_x(t):
 5 |     return 16 * math.sin(t)**3
 6 | 
 7 | def heart_y(t):
 8 |     return 13 * math.cos(t) - 5 * math.cos(2*t) - 2 * math.cos(3*t) - math.cos(4*t)
 9 | 
10 | screen = turtle.Screen()
11 | screen.bgcolor("black")
12 | screen.title("Red Heart")
13 | 
14 | t = turtle.Turtle()
15 | t.speed(5)  
16 | t.width(2)  
17 | t.pencolor("red")  
18 | 
19 | scale_factor = 18
20 | 
21 | for i in range(300):
22 |     t.goto(heart_x(i) * scale_factor, heart_y(i) * scale_factor)
23 | 
24 | turtle.done()
25 | 


--------------------------------------------------------------------------------
/heart_9.py:
--------------------------------------------------------------------------------
 1 | import math
 2 | from turtle import *
 3 | 
 4 | def hearta(k):
 5 |     return 15 * math.sin(k) ** 3
 6 | 
 7 | def heartb(k):
 8 |     return 11.8*math.cos(k) - 5 * math.cos(2*k) - 2*math.cos(3*k) - math.cos(4*k)
 9 | 
10 | speed(0)
11 | bgcolor("black")
12 | 
13 | for i in range(10000):
14 |     x = hearta(i) * 20
15 |     y = heartb(i) * 20
16 |     goto(x, y)
17 |     for j in range(3):
18 |         goto(x, 0)
19 |         color("red")
20 | 
21 | done()


--------------------------------------------------------------------------------
/i like you the most.py:
--------------------------------------------------------------------------------
 1 | import time
 2 | from threading import Thread, Lock
 3 | import sys
 4 | 
 5 | lock = Lock()
 6 | 
 7 | def animate_text(text, delay=0.1):
 8 |     with lock:
 9 |         for char in text:
10 |             sys.stdout.write(char)
11 |             sys.stdout.flush()
12 |             time.sleep(delay)
13 |         print()
14 | 
15 | def sing_lyric(lyric, delay, speed):
16 |     time.sleep(delay)
17 |     animate_text(lyric, speed)
18 | 
19 | def sing_song():
20 |     lyrics = [
21 |         ("\nCause you're the one that I like", 0.06),
22 |         ("I cant deny", 0.08),
23 |         ("Every night you're on my mind", 0.08),
24 |         ("So if I call you tonight", 0.08),
25 |         ("Will you pick up and give me your time?", 0.08),
26 |         ("Miss you every night", 0.08),
27 |         ("Miss you all the time", 0.07),
28 |         ("No, I don't even know", 0.08),
29 |         ("Where to start", 0.08)
30 |     ]
31 |     delays = [0.3, 2.1, 4.0, 6.0, 8.5, 12.3, 14.5, 16.4, 18.0]
32 |     
33 |     threads = []
34 |     for i in range(len(lyrics)):
35 |         lyric, speed = lyrics[i]
36 |         t = Thread(target=sing_lyric, args=(lyric, delays[i], speed))
37 |         threads.append(t)
38 |         t.start()
39 |     
40 |     for thread in threads:
41 |         thread.join()
42 | 
43 | if __name__ == "__main__":
44 |     sing_song()


--------------------------------------------------------------------------------
/i love you text animation.py:
--------------------------------------------------------------------------------
  1 | from turtle import color, back, left, forward, pensize, right, exitonclick , done 
  2 | import turtle
  3 | t = turtle.Turtle()
  4 | pensize(5)
  5 | 
  6 | color("white")
  7 | back(450)
  8 | color("black")
  9 | 
 10 | left(90)
 11 | forward(100)
 12 | back(100)
 13 | right(90)
 14 | color("white")
 15 | forward(100)
 16 | left(90)
 17 | color("black")
 18 | forward(100)
 19 | back(100)
 20 | right(90)
 21 | color("black")
 22 | forward(50)
 23 | color("white")
 24 | forward(50)
 25 | color("black")
 26 | forward(50)
 27 | back(50)
 28 | left(90)
 29 | forward(100)
 30 | right(90)
 31 | forward(50)
 32 | right(90)
 33 | forward(100)
 34 | left(90)
 35 | color("white")
 36 | forward(100)
 37 | color("black")
 38 | left(120)
 39 | forward(110)
 40 | back(110)
 41 | right(60)
 42 | forward(110)
 43 | back(110)
 44 | right(60)
 45 | color("white")
 46 | forward(100)
 47 | color("black")
 48 | forward(50)
 49 | back(50)
 50 | left(90)
 51 | forward(100)
 52 | right(90)
 53 | forward(50)
 54 | back(50)
 55 | right(90)
 56 | forward(50)
 57 | left(90)
 58 | forward(50)
 59 | back(50)
 60 | right(90)
 61 | forward(50)
 62 | left(90)
 63 | forward(50)
 64 | color("white")
 65 | forward(150)
 66 | color("black")
 67 | left(90)
 68 | forward(50)
 69 | left(45)
 70 | forward(75)
 71 | back(75)
 72 | right(90)
 73 | forward(75)
 74 | back(75)
 75 | left(45)
 76 | back(50)
 77 | right(90)
 78 | color("white")
 79 | forward(100)
 80 | color("black")
 81 | forward(50)
 82 | back(50)
 83 | left(90)
 84 | forward(100)
 85 | right(90)
 86 | forward(50)
 87 | right(90)
 88 | forward(100)
 89 | left(90)
 90 | color("white")
 91 | forward(100)
 92 | color("black")
 93 | back(50)
 94 | left(90)
 95 | forward(100)
 96 | back(100)
 97 | right(90)
 98 | forward(50)
 99 | left(90)
100 | forward(107)
101 | color("white")
102 | done()


--------------------------------------------------------------------------------
/i love you.zip:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/lukman467/coding/d3b3dde560a9e5eec25263a0e7b0da8a8bbd2e42/i love you.zip


--------------------------------------------------------------------------------
/jangan hilangkan dia.py:
--------------------------------------------------------------------------------
 1 | import time
 2 | from threading import Thread, Lock
 3 | import sys
 4 | 
 5 | lock = Lock()
 6 | 
 7 | def animate_text(text, delay=0.1):
 8 |     with lock:
 9 |         for char in text:
10 |             sys.stdout.write(char)
11 |             sys.stdout.flush()
12 |             time.sleep(delay)
13 |         print()
14 | 
15 | def sing_lyric(lyric, delay, speed):
16 |     time.sleep(delay)
17 |     animate_text(lyric, speed)
18 | 
19 | def sing_song():
20 |     lyrics = [
21 |         ("\n""Sungguh sungguh aku tak ingin", 0.14),
22 |         ("Hatiku jadi milik yang lainnya", 0.14),
23 |         ("Ku bersumpah kau sosok yang tak mungkin", 0.14),
24 |         ("Kutemukan lagi""\n", 0.14),
25 |     ]
26 |     
27 |     delays = [0.3, 6.8, 14.7, 21.9]
28 |     
29 |     threads = []
30 |     for i in range(len(lyrics)):
31 |         lyric, speed = lyrics[i]
32 |         t = Thread(target=sing_lyric, args=(lyric, delays[i], speed))
33 |         threads.append(t)
34 |         t.start()
35 |     
36 |     for thread in threads:
37 |         thread.join()
38 | 
39 | if __name__ == "__main__":
40 |     sing_song()


--------------------------------------------------------------------------------
/kalkulator 2/index.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html lang="en">
 3 | <head>
 4 |     <meta charset="UTF-8">
 5 |     <meta name="viewport" content="width=device-width, initial-scale=1.0">
 6 |     <title>Calculator</title>
 7 |     <link rel="stylesheet" href="styles.css">
 8 | </head>
 9 | <body>
10 |     <div class="calculator">
11 |         <input type="text" id="display" disabled>
12 |         <div class="buttons">
13 |             <button onclick="appendToDisplay('7')">7</button>
14 |             <button onclick="appendToDisplay('8')">8</button>
15 |             <button onclick="appendToDisplay('9')">9</button>
16 |             <button onclick="appendToDisplay('+')">+</button>
17 |             <button onclick="appendToDisplay('4')">4</button>
18 |             <button onclick="appendToDisplay('5')">5</button>
19 |             <button onclick="appendToDisplay('6')">6</button>
20 |             <button onclick="appendToDisplay('-')">-</button>
21 |             <button onclick="appendToDisplay('1')">1</button>
22 |             <button onclick="appendToDisplay('2')">2</button>
23 |             <button onclick="appendToDisplay('3')">3</button>
24 |             <button onclick="calculate()">=</button>
25 |             <button onclick="clearDisplay()">C</button>
26 |             <button onclick="appendToDisplay('0')">0</button>
27 |         </div>
28 |     </div>
29 |     <script src="script.js"></script>
30 | </body>
31 | </html>
32 | 


--------------------------------------------------------------------------------
/kalkulator 2/script.js:
--------------------------------------------------------------------------------
 1 | function appendToDisplay(value) {
 2 |     const display = document.getElementById('display');
 3 |     display.value += value;
 4 | }
 5 | 
 6 | function calculate() {
 7 |     const display = document.getElementById('display');
 8 |     const expression = display.value;
 9 |     
10 |     // This will replace the result of any mathematical operation with "I love you"
11 |     if (expression.match(/[0-9]+[+\-*/][0-9]+/)) {
12 |         display.value = 'I love you';
13 |     } else {
14 |         try {
15 |             display.value = eval(expression);
16 |         } catch {
17 |             display.value = 'Error';
18 |         }
19 |     }
20 | }
21 | 
22 | function clearDisplay() {
23 |     const display = document.getElementById('display');
24 |     display.value = '';
25 | }
26 | 


--------------------------------------------------------------------------------
/kalkulator 2/styles.css:
--------------------------------------------------------------------------------
 1 | body {
 2 |     display: flex;
 3 |     justify-content: center;
 4 |     align-items: center;
 5 |     height: 100vh;
 6 |     background-color: #f0f0f0;
 7 |     margin: 0;
 8 | }
 9 | 
10 | .calculator {
11 |     background-color: white;
12 |     padding: 20px;
13 |     border-radius: 10px;
14 |     box-shadow: 0 0 10px rgba(0, 0, 0, 0.1);
15 | }
16 | 
17 | #display {
18 |     width: 100%;
19 |     height: 40px;
20 |     margin-bottom: 10px;
21 |     text-align: right;
22 |     font-size: 24px;
23 |     padding: 10px;
24 |     box-sizing: border-box;
25 | }
26 | 
27 | .buttons {
28 |     display: grid;
29 |     grid-template-columns: repeat(4, 1fr);
30 |     gap: 10px;
31 | }
32 | 
33 | button {
34 |     height: 50px;
35 |     font-size: 18px;
36 |     background-color: #e0e0e0;
37 |     border: none;
38 |     border-radius: 5px;
39 |     cursor: pointer;
40 | }
41 | 
42 | button:active {
43 |     background-color: #d0d0d0;
44 | }
45 | 


--------------------------------------------------------------------------------
/kamu cantik kamu baik.py:
--------------------------------------------------------------------------------
 1 | import time
 2 | from threading import Thread, Lock
 3 | import sys
 4 | 
 5 | lock = Lock()
 6 | 
 7 | def animate_text(text, delay=0.1):
 8 |     with lock:
 9 |         for char in text:
10 |             sys.stdout.write(char)
11 |             sys.stdout.flush()
12 |             time.sleep(delay)
13 |         print()
14 | 
15 | def sing_lyric(lyric, delay, speed):
16 |     time.sleep(delay)
17 |     animate_text(lyric, speed)
18 | 
19 | def sing_song():
20 |     lyrics = [
21 |         ("\nKarna kamu cantik", 0.09),
22 |         ("Kan kuberi segalanya apa yang kupunya", 0.09),
23 |         ("Dan hatimu baik", 0.10),
24 |         ("Sempurnalah duniaku saat kau di sisiku\n", 0.10),
25 |         ("Bukan karna make up di wajahmu", 0.09),
26 |         ("Atau lipstik merah itu", 0.09),
27 |         ("Lembut hati tutur kata", 0.08),
28 |         ("Terciptalah cinta yang kupuja\n", 0.10),
29 |     ]
30 |     
31 |     delays = [0.3, 3.4, 7.4, 10.5, 14.5, 18.0, 21.9, 24.4]
32 |     
33 |     threads = []
34 |     for i in range(len(lyrics)):
35 |         lyric, speed = lyrics[i]
36 |         t = Thread(target=sing_lyric, args=(lyric, delays[i], speed))
37 |         threads.append(t)
38 |         t.start()
39 |     
40 |     for thread in threads:
41 |         thread.join()
42 | 
43 | if __name__ == "__main__":
44 |     sing_song()
45 | 


--------------------------------------------------------------------------------
/kasih aba aba.py:
--------------------------------------------------------------------------------
 1 | import time
 2 | from threading import Thread, Lock
 3 | import sys
 4 | 
 5 | lock = Lock()
 6 | 
 7 | def animate_text(text, delay=0.1):
 8 |     with lock:
 9 |         for char in text:
10 |             sys.stdout.write(char)
11 |             sys.stdout.flush()
12 |             time.sleep(delay)
13 |         print()
14 | 
15 | def sing_lyric(lyric, delay, speed):
16 |     time.sleep(delay)
17 |     animate_text(lyric, speed)
18 | 
19 | 
20 | def sing_lyric_part(lyric_part, delay, speed, add_newline=False):
21 |     time.sleep(delay)
22 |     with lock:
23 |         for char in lyric_part:
24 |             sys.stdout.write(char)
25 |             sys.stdout.flush()
26 |             time.sleep(speed)
27 |         if add_newline:
28 |             print()  
29 | 
30 | def sing_song():
31 |     lyrics = [
32 |         ("\nKu merasakan apa yang kau rasakan", 0.10),
33 |         ("Tanpa ragu ku bilang kamu yang paling paham aku", 0.07),
34 |         # ("Dua jadi satu, belah hati aku", 0.10),
35 |         ("Aku mau maju tapi tinggal tunggu waktu", 0.08)
36 |     ]
37 |     delays = [0.3, 4.3, 12.1]
38 | 
39 |     threads = []
40 |     for i in range(0):
41 |         lyric, speed = lyrics[i]
42 |         t = Thread(target=sing_lyric, args=(lyric, delays[i], speed))
43 |         threads.append(t)
44 |         t.start()
45 | 
46 |     t_0 = Thread(target=sing_lyric_part, args=("Dua jadi satu ", 8.4, 0.09, False))
47 |     t_1 = Thread(target=sing_lyric_part, args=("belah hati aku", 10.2, 0.10, True))
48 |     threads.extend([t_0, t_1])
49 |     t_0.start()
50 |     t_1.start()
51 |     
52 |     for i in range(len(lyrics)):
53 |         lyric, speed = lyrics[i]
54 |         t = Thread(target=sing_lyric, args=(lyric, delays[i], speed))
55 |         threads.append(t)
56 |         t.start()
57 |     
58 |     for thread in threads:
59 |         thread.join()
60 | 
61 | if __name__ == "__main__":
62 |     sing_song()
63 |     


--------------------------------------------------------------------------------
/koiiro kobo/background.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/lukman467/coding/d3b3dde560a9e5eec25263a0e7b0da8a8bbd2e42/koiiro kobo/background.jpg


--------------------------------------------------------------------------------
/koiiro kobo/koiiro.html:
--------------------------------------------------------------------------------
  1 | <!DOCTYPE html>
  2 | <html lang="en">
  3 | <head>
  4 |     <meta charset="UTF-8">
  5 |     <meta name="viewport" content="width=device-width, initial-scale=1.0">
  6 |     <title>Animasi Lirik Lagu</title>
  7 |     <link rel="stylesheet" href="https://fonts.googleapis.com/css2?family=Poppins:wght@400;600&display=swap">
  8 |     <style>
  9 |         body {
 10 |             display: flex;
 11 |             justify-content: center;
 12 |             align-items: center;
 13 |             height: 100vh;
 14 |             margin: 0;
 15 |             font-family: 'Poppins', sans-serif;
 16 |             position: relative;
 17 |             color: white;
 18 |         }
 19 | 
 20 |         body::before {
 21 |             content: "";
 22 |             position: absolute;
 23 |             top: 0;
 24 |             left: 0;
 25 |             width: 100%;
 26 |             height: 100%;
 27 |             background-image: url('background.jpg');
 28 |             background-size: cover;
 29 |             background-position: center;
 30 |             z-index: -2;
 31 |         }
 32 | 
 33 |         body::after {
 34 |             content: "";
 35 |             position: absolute;
 36 |             top: 0;
 37 |             left: 0;
 38 |             width: 100%;
 39 |             height: 100%;
 40 |             background-color: rgba(0, 0, 0, 0.1);
 41 |             z-index: -1;
 42 |         }
 43 | 
 44 |         .lyrics-container {
 45 |             text-align: center;
 46 |             white-space: pre;
 47 |             padding: 20px;
 48 |             font-size: 24px;
 49 |             text-shadow: 2px 2px 4px rgba(0, 0, 0, 0.8);
 50 |             z-index: 1;
 51 |         }
 52 | 
 53 |         .line {
 54 |             display: block;
 55 |             margin-bottom: 5px;
 56 |         }
 57 |     </style>
 58 | </head>
 59 | <body>
 60 |     <div class="lyrics-container" id="lyricsContainer">
 61 |     </div>
 62 |     <script>
 63 |         const lyrics = [
 64 |             "suki yo",
 65 |             "ima anata ni omoi nosete",
 66 |             "hora sunao ni naru no watashi",
 67 |             "kono saki motto soba ni ite mo ii ka na?",
 68 |             "koi to koi ga kasanatte",
 69 |             "suki yo"
 70 |         ];
 71 | 
 72 |         const delays = [0.5, 0.1, 0.6, 0.6, 0.6, 0.6];
 73 |         const speeds = [0.10, 0.13, 0.13, 0.11, 0.12, 0.08];
 74 | 
 75 |         function animateText(text, container, speed) {
 76 |             return new Promise((resolve) => {
 77 |                 let i = 0;
 78 |                 function typeChar() {
 79 |                     if (i < text.length) {
 80 |                         container.innerHTML += text.charAt(i);
 81 |                         i++;
 82 |                         setTimeout(typeChar, speed * 1000);
 83 |                     } else {
 84 |                         resolve();
 85 |                     }
 86 |                 }
 87 |                 typeChar();
 88 |             });
 89 |         }
 90 | 
 91 |         async function singSong() {
 92 |             const lyricsContainer = document.getElementById('lyricsContainer');
 93 |             for (let i = 0; i < lyrics.length; i++) {
 94 |                 await new Promise(resolve => setTimeout(resolve, delays[i] * 1000));
 95 |                 const lineContainer = document.createElement('span');
 96 |                 lineContainer.classList.add('line');
 97 |                 lyricsContainer.appendChild(lineContainer);
 98 |                 await animateText(lyrics[i], lineContainer, speeds[i]);
 99 |             }
100 |         }
101 | 
102 |         singSong();
103 |     </script>
104 | </body>
105 | </html>
106 | 


--------------------------------------------------------------------------------
/lirik end of begining.py:
--------------------------------------------------------------------------------
 1 | import time
 2 | from threading import Thread
 3 | import sys
 4 | 
 5 | lyrics = [
 6 |     ("Just trust me, you'll be fine", 0.09),
 7 |     ("And when I'm back in Chicago, I feel it", 0.09),
 8 |     ("Another version of me, I was in it", 0.09),
 9 |     ("I wave goodbye to the end of beginning", 0.08),
10 |     ("Goodbye, goodbye, goodbye, goodbye", 0.1)
11 | ]
12 | delays = [0, 5.0, 11.0, 17.0, 20.8]
13 | 
14 | def animate_text(text, delay=0.1):
15 |     for char in text:
16 |         sys.stdout.write(char)
17 |         sys.stdout.flush()
18 |         time.sleep(delay)
19 |     print()
20 | 
21 | def sing_lyric(lyric, delay, speed):
22 |     time.sleep(delay)
23 |     animate_text(lyric, speed)
24 | 
25 | def sing_song():
26 |     threads = []
27 |     for i in range(len(lyrics)):
28 |         lyric, speed = lyrics[i]
29 |         t = Thread(target=sing_lyric, args=(lyric, delays[i], speed))
30 |         threads.append(t)
31 |         t.start()
32 |     for thread in threads:
33 |         thread.join()
34 | 
35 | if __name__ == "__main__":
36 |     sing_song()


--------------------------------------------------------------------------------
/love love love/script.js:
--------------------------------------------------------------------------------
  1 | 
  2 | "use strict";
  3 | 
  4 | !(function () {
  5 |   function t() {
  6 |     !(function () {
  7 |       var t, g;
  8 |       if (
  9 |         ((o = l / 2),
 10 |         (a = s / 2),
 11 |         (n = c.create()),
 12 |         (e = n.world),
 13 |         (r = d.create({
 14 |           element: document.body,
 15 |           engine: n,
 16 |           options: {
 17 |             width: l,
 18 |             height: s,
 19 |             wireframes: !1,
 20 |             background: "transparent",
 21 |             pixelRatio: 1
 22 |           }
 23 |         })),
 24 |         (i = u.create()),
 25 |         u.run(i, n),
 26 |         (n.gravity.scale = 0),
 27 |         (n.gravity.x = 0),
 28 |         (n.gravity.y = 0),
 29 |         "undefined" != typeof fetch)
 30 |       ) {
 31 |         (t = function (t, e) {
 32 |           return Array.prototype.slice.call(t.querySelectorAll(e));
 33 |         }),
 34 |           (g = function (t) {
 35 |             return fetch(t)
 36 |               .then(function (t) {
 37 |                 return t.text();
 38 |               })
 39 |               .then(function (t) {
 40 |                 return new window.DOMParser().parseFromString(
 41 |                   t,
 42 |                   "image/svg+xml"
 43 |                 );
 44 |               });
 45 |           })(svg_terrain).then(function (n) {
 46 |             var r = t(n, "path"),
 47 |               i = r.map(function (t) {
 48 |                 return v.pathToVertices(t, 30);
 49 |               }),
 50 |               l = y.fromVertices(
 51 |                 256,
 52 |                 200,
 53 |                 i,
 54 |                 {
 55 |                   isStatic: !0,
 56 |                   render: {
 57 |                     fillStyle: "transparent",
 58 |                     strokeStyle: "transparent",
 59 |                     lineWidth: 1
 60 |                   }
 61 |                 },
 62 |                 !0
 63 |               );
 64 |             h.add(e, l), (o = l.position.x), (a = l.position.y);
 65 |           });
 66 |         let n = null,
 67 |           r = null;
 68 |         g(svg_heart).then(function (e) {
 69 |           n ||
 70 |             ((r = t(e, "path").map(function (t) {
 71 |               return v.pathToVertices(t, 50);
 72 |             })),
 73 |             (n = y.fromVertices(
 74 |               o,
 75 |               1.5 * a,
 76 |               r,
 77 |               {
 78 |                 restitution: 0,
 79 |                 friction: 0,
 80 |                 frictionStatic: 0,
 81 |                 frictionAir: 0,
 82 |                 mass: 20,
 83 |                 render: {
 84 |                   lineWidth: 2
 85 |                 }
 86 |               },
 87 |               !0
 88 |             )),
 89 |             M.scale(n, 0.2, 0.2));
 90 |         });
 91 |         let i = function () {
 92 |           let t = structuredClone(n);
 93 |           (t.id = f.nextId()),
 94 |             (t.position.x = o),
 95 |             (t.position.y = 1.5 * a),
 96 |             S.push(S.shift());
 97 |           let r = S[0];
 98 |           (t.render.fillStyle = r),
 99 |             (t.render.strokeStyle = r),
100 |             t.parts.forEach(function (e, n) {
101 |               (t.parts[n].render.fillStyle = r),
102 |                 (t.parts[n].render.strokeStyle = r);
103 |             }),
104 |             M.setAngle(t, Math.round(360 * Math.random()), !1),
105 |             M.setVelocity(t, {
106 |               x: f.random(-5, 5),
107 |               y: f.random(-5, -1)
108 |             }),
109 |             h.add(e, t);
110 |         };
111 |         setTimeout(function () {
112 |           let t = 0,
113 |             e = setInterval(() => {
114 |               i(), 2 == t && (clearInterval(e), (n = null), (r = null)), t++;
115 |             }, 780);
116 |         }, 220);
117 |       } else f.warn("Fetch is not available. Could not load SVG.");
118 |       let k = m.create(r.canvas),
119 |         x = p.create(n, {
120 |           mouse: k,
121 |           constraint: {
122 |             stiffness: 0.2,
123 |             render: {
124 |               visible: !1
125 |             }
126 |           }
127 |         });
128 |       h.add(e, x),
129 |         (r.mouse = k),
130 |         d.lookAt(r, {
131 |           min: {
132 |             x: 0,
133 |             y: 0
134 |           },
135 |           max: {
136 |             x: l,
137 |             y: s
138 |           }
139 |         }),
140 |         d.run(r);
141 |     })();
142 |   }
143 |   let e,
144 |     n,
145 |     r,
146 |     i,
147 |     o,
148 |     a,
149 |     l = 512,
150 |     s = 512,
151 |     c = (Matter.World, Matter.Engine),
152 |     d = Matter.Render,
153 |     u = Matter.Runner,
154 |     f = (Matter.Composites, Matter.Common),
155 |     p = Matter.MouseConstraint,
156 |     m = Matter.Mouse,
157 |     h = Matter.Composite,
158 |     y = (Matter.Vertices, Matter.Bodies),
159 |     M = Matter.Body,
160 |     v = (Matter.Events, Matter.Query, Matter.Svg),
161 |     g = [
162 |       "pink",
163 |       "deeppink",
164 |       "deeppink",
165 |       "hotpink",
166 |       "hotpink",
167 |       "lightpink",
168 |       "magenta",
169 |       "orchid"
170 |     ],
171 |     S = ["mediumvioletred", "crimson", "salmon"];
172 |   (window.onload = () => {
173 |     t();
174 |   }),
175 |     setTimeout(function () {
176 |       let t = 0,
177 |         n = setInterval(() => {
178 |           !(function () {
179 |             let t = f.choose(g);
180 |             const n = y.circle(o, a, 25, {
181 |               restitution: 0,
182 |               friction: 0,
183 |               frictionStatic: 0,
184 |               frictionAir: 0,
185 |               mass: 10,
186 |               render: {
187 |                 fillStyle: t,
188 |                 strokeStyle: t,
189 |                 lineWidth: 0
190 |               }
191 |             });
192 |             M.setVelocity(n, {
193 |               x: f.random(-1, 1),
194 |               y: f.random(-1, 1)
195 |             }),
196 |               h.add(e, n);
197 |           })(),
198 |             60 == t && clearInterval(n),
199 |             t++;
200 |         }, 100);
201 |     }, 2e3);
202 | })();


--------------------------------------------------------------------------------
/love10/index.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html lang="en">
 3 | <head>
 4 |     <meta charset="UTF-8">
 5 |     <meta name="viewport" content="width=device-width, initial-scale=1.0">
 6 |     <title>heart</title>
 7 |     <link rel="stylesheet" href="style.css">
 8 | </head>
 9 | <body>
10 |     <canvas id="alx"></canvas>
11 |     <script src="script.js"></script>
12 | </body>
13 | </html>
14 | 


--------------------------------------------------------------------------------
/love10/script.js:
--------------------------------------------------------------------------------
 1 | var c = document.getElementById('alx');
 2 | 
 3 |   var b = document.body;
 4 |   var a = c.getContext('2d');
 5 | 
 6 | 
 7 |   e = [];
 8 |   h = [];
 9 |   WIDTH = c.width = innerWidth;
10 |   HEIGHT = c.height = innerHeight;
11 |   v = 32 + 16 + 8;
12 |   R = Math.random;
13 |   C = Math.cos;
14 |   Y = 6.3;
15 | 
16 |   for (i = 0; i < Y ; i += 0.2) 
17 |     h.push([WIDTH / 2  + 210 * Math.pow(Math.sin(i), 3), 
18 |       HEIGHT / 2  + 13 * -(15 * C(i) - 5 * C(2 * i) - 2 * C(3 * i) - C(4 * i))]);
19 | 
20 |   for (i = 0; i < Y  ; i += 0.4) 
21 |     h.push([WIDTH / 2  + 150 * Math.pow(Math.sin(i), 3), 
22 |       HEIGHT / 2  + 9 * -(15 * C(i) - 5 * C(2 * i) - 2 * C(3 * i) - C(4 * i))]);
23 | 
24 |   for (i = 0; i < Y  ; i += 0.8) 
25 |     h.push([WIDTH / 2  + 90 * Math.pow(Math.sin(i), 3), 
26 |       HEIGHT / 2  + 5 * -(15 * C(i) - 5 * C(2 * i) - 2 * C(3 * i) - C(4 * i))]);
27 | 
28 |   for (i = 0; i < v;) {
29 |       x = R() * WIDTH;
30 |       y = R() * HEIGHT;
31 |       H = 80 * (i / v) + Math.random * 100;
32 |       S = 40 * R() + 60;
33 |       B = 60 * R() + 20;
34 |       f = [];
35 |       for (k = 0; k < v;) f[k++] = {
36 |           x: x,
37 |           y: y,
38 |           X: 0,
39 |           Y: 0,
40 |           R: 1 - k / v + 1,
41 |           S: R() + 1,
42 |           q: ~~(R() * v),
43 |           D: 2 * (i % 2) - 1,
44 |           F: 0.2 * R() + 0.7,
45 |           f: "hsla(" + ~~H + "," + ~~S + "%," + ~~B + "%,.1)"
46 |       };
47 |       e[i++] = f
48 |   }
49 | 
50 |   function path(d) {
51 |       a.fillStyle = d.f;
52 |       a.beginPath();
53 |       a.arc(d.x, d.y, d.R, 0, Y, 1);
54 |       a.closePath();
55 |       a.fill()
56 |   }
57 |   setInterval(function () {
58 |       a.fillStyle = "rgba(0,0,0,.2)";
59 |       a.fillRect(0, 0, WIDTH, HEIGHT);
60 |       for (i = v; i--;) {
61 |           f = e[i];
62 |           u = f[0];
63 |           q = h[u.q];
64 |           D = u.x - q[0];
65 |           E = u.y - q[1];
66 |           G = Math.sqrt(D * D + E * E);
67 |           10 > G && (0.95 < R() ? u.q = ~~ (R() * v) : (0.99 < R() && (u.D *= -1), u.q += u.D, u.q %= v, 0 > u.q && (u.q += v)));
68 |           u.X += -D / G * u.S;
69 |           u.Y += -E / G * u.S;
70 |           u.x += u.X;
71 |           u.y += u.Y;
72 |           path(u);
73 |           u.X *= u.F;
74 |           u.Y *= u.F;
75 |           for (k = 0; k < v - 1;) T = f[k], N = f[++k], N.x -= 0.7 * (N.x - T.x), N.y -= 0.7 * (N.y - T.y), path(N)
76 |       }
77 |   }, 25);


--------------------------------------------------------------------------------
/love10/style.css:
--------------------------------------------------------------------------------
1 | body
2 | { 
3 |   padding: 0;
4 |   margin: 0;
5 | }
6 | 


--------------------------------------------------------------------------------
/love12/index.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html lang="en">
 3 |   <head>
 4 |     <meta charset="UTF-8" />
 5 |     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
 6 |     <title>i love you</title>
 7 |     <link rel="stylesheet" href="styles.css" />
 8 |   </head>
 9 |   <body>
10 |     <div class="heart h0"></div>
11 |     <div class="heart h1"></div>
12 |     <div class="heart h2"></div>
13 |     <div class="heart h3"></div>
14 |     <div class="heart h4"></div>
15 |     <div class="heart h5"></div>
16 |     <div class="heart h6"></div>
17 |   </body>
18 | </html>
19 | 


--------------------------------------------------------------------------------
/love12/script.js:
--------------------------------------------------------------------------------
  1 | 'use strict';
  2 | 
  3 | const maxScale         = 3;
  4 | const scaleStep        = .001;
  5 | const width            = 400;
  6 | const height           = 400;
  7 | const heartsCount      = 20;
  8 | const newHeartInterval = 250;
  9 | const colourList       = [
 10 |   "#9925fb",
 11 |   "#cb27fc",
 12 |   "#fd28fc",
 13 |   "#22cccb",
 14 |   "#1aa5cb",
 15 |   "#137dca"
 16 | ];
 17 | 
 18 | function drawHeart(ctx, fromx, fromy,lw,hlen,color) {
 19 |   var x = fromx;
 20 |   var y = fromy;
 21 |   var width = lw ;
 22 |   var height = hlen;
 23 | 
 24 |   ctx.save();
 25 |   ctx.beginPath();
 26 |   var topCurveHeight = height * 0.3;
 27 |   ctx.moveTo(x, y + topCurveHeight);
 28 |   ctx.bezierCurveTo(
 29 |     x, y, 
 30 |     x - width / 2, y, 
 31 |     x - width / 2, y + topCurveHeight
 32 |   );
 33 | 
 34 |   ctx.bezierCurveTo(
 35 |     x - width / 2, y + (height + topCurveHeight) / 2, 
 36 |     x, y + (height + topCurveHeight) / 2, 
 37 |     x, y + height
 38 |   );
 39 | 
 40 |   ctx.bezierCurveTo(
 41 |     x, y + (height + topCurveHeight) / 2, 
 42 |     x + width / 2, y + (height + topCurveHeight) / 2, 
 43 |     x + width / 2, y + topCurveHeight
 44 |   );
 45 | 
 46 |   ctx.bezierCurveTo(
 47 |     x + width / 2, y, 
 48 |     x, y, 
 49 |     x, y + topCurveHeight
 50 |   );
 51 | 
 52 |   ctx.closePath();
 53 |   ctx.fillStyle = color;
 54 |   ctx.fill();
 55 |   ctx.restore();
 56 | }
 57 | 
 58 | class Heart {
 59 |   constructor(scale = 0, colour = 'red') {
 60 |     this.s = scale;
 61 |     this.c = colour;
 62 |     this.x = width/2;
 63 |     this.h = height * scale; 
 64 |     this.y = height/2 - (this.h !== 0 ? this.h / 2 : 0);
 65 |     this.i = scaleStep;
 66 |   }
 67 |   
 68 |   step() {
 69 |     this.s += this.i;  
 70 |     this.i += 0.00005; 
 71 |     this.h = height * this.s; 
 72 |     this.y = height / 2 - (this.h !== 0 ? this.h / 2 : 0); 
 73 |   }
 74 |   
 75 |   draw(context) {
 76 |     if (this.s === 0)
 77 |       return;
 78 |     drawHeart(context, this.x, this.y, this.h, this.h, this.c);
 79 |   }
 80 | }
 81 | 
 82 | class ColourWheel {
 83 |   constructor(colors) {
 84 |     this.i = 0;
 85 |     this.c = colors;
 86 |   }
 87 |   
 88 |   next() {
 89 |     let c = this.c[this.i++];
 90 |     this.i %= this.c.length;
 91 |     return c;
 92 |   }
 93 | }
 94 | 
 95 | window.addEventListener('load', function() {
 96 |   var canvas  = document.getElementById("animation"),
 97 |       context = canvas.getContext("2d"),
 98 |       colours = new ColourWheel(colourList),
 99 |       hearts  = [];
100 |   
101 |   context.fillStyle = 'rgba(38, 38, 38, 1)';
102 |   context.fillRect(0, 0, width, height);
103 |   
104 |   let lastTime = 0;
105 |   +(function animation(time) {
106 |     requestAnimationFrame(animation);
107 |     
108 |     for (let h of hearts) h.step();
109 |     
110 |     hearts = hearts.filter(h => h.s <= maxScale * 1.5);
111 |     
112 |     if (time - lastTime >= newHeartInterval) {
113 |       lastTime = time;
114 |       hearts.push(new Heart(0, colours.next()));
115 |     }
116 |     
117 |     hearts.sort((a, b) => b.s - a.s);
118 |     
119 |     for (let h of hearts) h.draw(context);
120 |   }());
121 | });


--------------------------------------------------------------------------------
/love12/styles.css:
--------------------------------------------------------------------------------
  1 | body {background: rgb(237, 151, 104);}
  2 | 
  3 | .heart {
  4 |   position: absolute;
  5 |   left: 50%;
  6 |   top: 50%;
  7 |   width: 24px;
  8 | 	height: 24px;
  9 |   clip-path: path("M12 4.248c-3.148-5.402-12-3.825-12 2.944 0 4.661 5.571 9.427 12 15.808 6.43-6.381 12-11.147 12-15.808 0-6.792-8.875-8.306-12-2.944z");
 10 | }
 11 | 
 12 | .h0 {
 13 |   background: #ffcccc;
 14 | 	transform: scale(150);
 15 |   animation: move0 linear 2s 0s infinite;
 16 | }
 17 | 
 18 | .h1 {
 19 |   background: #ff6666;
 20 | 	transform: scale(90);
 21 |   animation: move1 linear 2s 0s infinite;
 22 | }
 23 | 
 24 | .h2 {
 25 |   background: #cc0000;
 26 | 	transform: scale(60);
 27 |   animation: move2 linear 2s 0s infinite;
 28 | }
 29 | 
 30 | .h3 {
 31 | 	background: #ffcccc;
 32 | 	transform: scale(40);
 33 |   animation: move3 linear 2s 0s infinite;
 34 | }
 35 | 
 36 | .h4 {
 37 |   background: #ff6666;
 38 | 	transform: scale(20);
 39 |   animation: move4 linear 2s 0s infinite;
 40 | }
 41 | 
 42 | .h5 {
 43 |   background: #cc0000;
 44 | 	transform: scale(5);
 45 |   animation: move5 linear 2s 0s infinite;
 46 | }
 47 | 
 48 | .h6 {
 49 | 	background: #ffcccc;
 50 | 	transform: scale(.1);
 51 |   animation: move6 linear 2s 0s infinite;
 52 | }
 53 | 
 54 | @keyframes move0 {
 55 |   to {
 56 |     transform: scale(180);
 57 |     background: #cc0000;
 58 |   }
 59 | }
 60 | 
 61 | @keyframes move1 {
 62 |   to {
 63 |     transform: scale(150);
 64 |     background: #ffcccc;
 65 |   }
 66 | }
 67 | 
 68 | @keyframes move2 {
 69 |   to {
 70 |     transform: scale(90);
 71 |     background: #ff6666;
 72 |   }
 73 | }
 74 | 
 75 | @keyframes move3 {
 76 |   to {
 77 |     transform: scale(60);
 78 |     background: #cc0000;
 79 |   }
 80 | }
 81 | 
 82 | @keyframes move4 {
 83 |   to {
 84 |     transform: scale(40);
 85 |     background: #ffcccc;
 86 |   }
 87 | }
 88 | 
 89 | @keyframes move5 {
 90 |   to {
 91 |     transform: scale(20);
 92 |     background: #ff6666;
 93 |   }
 94 | }
 95 | 
 96 | @keyframes move6 {
 97 |   to {
 98 |     transform: scale(5);
 99 |     background: #cc0000;
100 |   }
101 | }
102 | 


--------------------------------------------------------------------------------
/love13/index.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html lang="en">
 3 | <head>
 4 |     <meta charset="UTF-8">
 5 |     <meta name="viewport" content="width=device-width, initial-scale=1.0">
 6 |     <title>rawr</title>
 7 |     <style>
 8 |         body {
 9 |             margin: 0;
10 |             overflow: hidden;
11 |         }
12 |         canvas {
13 |             display: block;
14 |         }
15 |     </style>
16 | </head>
17 | <body>
18 |     <script src="script.js"></script>
19 | </body>
20 | </html>
21 | 


--------------------------------------------------------------------------------
/love13/script.js:
--------------------------------------------------------------------------------
  1 | "use strict";
  2 | 
  3 | var pulseDirection = 1;
  4 | var pulseSpeed = 0.02;
  5 | const body = document.getElementsByTagName("body").item(0);
  6 | body.style.background = "#000";
  7 | 
  8 | const TP = 2 * Math.PI;
  9 | const CSIZE = 400;
 10 | 
 11 | const ctx = (() => {
 12 |     let d = document.createElement("div");
 13 |     d.style.textAlign = "center";
 14 |     body.append(d);
 15 |     let c = document.createElement("canvas");
 16 |     c.width = 2 * CSIZE;
 17 |     c.height = 2 * CSIZE;
 18 |     d.append(c);
 19 |     return c.getContext("2d");
 20 | })();
 21 | ctx.translate(CSIZE, CSIZE);
 22 | ctx.lineCap = "round";
 23 | 
 24 | onresize = () => {
 25 |     let D = Math.min(window.innerWidth, window.innerHeight) - 40;
 26 |     ctx.canvas.style.width = D + "px";
 27 |     ctx.canvas.style.height = D + "px";
 28 | };
 29 | 
 30 | const getRandomInt = (min, max, low) => {
 31 |     if (low) return Math.floor(Math.random() * Math.random() * (max - min)) + min;
 32 |     else return Math.floor(Math.random() * (max - min)) + min;
 33 | };
 34 | 
 35 | var Circle = function (x, y, xp, yp, radius, pc) {
 36 |     this.x = x;
 37 |     this.y = y;
 38 |     this.xp = xp;
 39 |     this.yp = yp;
 40 |     this.radius = radius;
 41 |     this.originalRadius = radius;
 42 |     this.pc = pc;
 43 |     this.c = [];
 44 |     this.fullyGrown = false;
 45 |     this.pulseDirection = 1;
 46 | };
 47 | 
 48 | Circle.prototype.pulsate = function() {
 49 |     this.radius += this.radius * this.pulseDirection * pulseSpeed;
 50 |     if (this.radius >= this.originalRadius * 1.5) {
 51 |         this.pulseDirection = -1;
 52 |     } else if (this.radius <= this.originalRadius) {
 53 |         this.pulseDirection = 1;
 54 |     }
 55 | };
 56 | 
 57 | Circle.prototype.drawCircle = function(rf) {
 58 |     if (this.fullyGrown) {
 59 |         this.pulsate();
 60 |     }
 61 |     drawHeart(this.x, this.y, this.radius * rf * 1.5, "hsl(" + (hue + 5 * this.radius) + ",90%,50%)");
 62 | };
 63 | 
 64 | function drawHeart(x, y, size, color) {
 65 |     ctx.shadowColor = color;
 66 |     ctx.shadowBlur = 10;
 67 |     ctx.shadowOffsetX = 0;
 68 |     ctx.shadowOffsetY = 0;
 69 | 
 70 |     var d = size;
 71 |     var k = x - d / 2;
 72 |     var l = y - d / 2;
 73 | 
 74 |     ctx.beginPath();
 75 |     ctx.moveTo(k, l + d / 4);
 76 |     ctx.quadraticCurveTo(k, l, k + d / 4, l);
 77 |     ctx.quadraticCurveTo(k + d / 2, l, k + d / 2, l + d / 4);
 78 |     ctx.quadraticCurveTo(k + d / 2, l, k + d * 3/4, l);
 79 |     ctx.quadraticCurveTo(k + d, l, k + d, l + d / 4);
 80 |     ctx.quadraticCurveTo(k + d, l + d / 2, k + d * 3/4, l + d * 3/4);
 81 |     ctx.lineTo(k + d / 2, l + d);
 82 |     ctx.lineTo(k + d / 4, l + d * 3/4);
 83 |     ctx.quadraticCurveTo(k, l + d / 2, k, l + d / 4);
 84 |     ctx.fillStyle = color;
 85 |     ctx.fill();
 86 |     ctx.closePath();
 87 |     ctx.shadowBlur = 0;
 88 | }
 89 | 
 90 | var Curve = function () {
 91 |     this.car = [];
 92 |     this.to = -getRandomInt(0, 400);
 93 |     this.addCurveCircle = (cir) => {
 94 |         if (cir.pc) {
 95 |             this.car.unshift(cir.pc);
 96 |             this.addCurveCircle(cir.pc);
 97 |         }
 98 |     }
 99 |     this.setPath = () => {
100 |         this.len = 0;
101 |         this.path = new Path2D();
102 |         this.path.moveTo(0, 0);
103 |         this.path.lineTo(this.car[1].xp, this.car[1].yp);
104 |         this.len += this.car[0].radius;
105 |         for (let i = 1; i < this.car.length - 1; i++) {
106 |             this.path.bezierCurveTo(this.car[i].x, this.car[i].y, this.car[i].x, this.car[i].y, this.car[i + 1].xp, this.car[i + 1].yp);
107 |             this.len += 2 * this.car[i].radius;
108 |         }
109 |         this.path.lineTo(this.car[this.car.length - 1].x, this.car[this.car.length - 1].y);
110 |         this.len += this.car[this.car.length - 1].radius;
111 |     }
112 |     this.drawCurve = () => {
113 |         let tt = this.to + t;
114 |         ctx.setLineDash([Math.max(1, tt), 4000]);
115 |         ctx.stroke(this.path);
116 |     if (tt > this.len + 40) {
117 |         this.car[this.car.length - 1].fullyGrown = true;
118 |         this.car[this.car.length - 1].drawCircle(0.8);
119 |         if (tt > this.len + 120) return false;
120 |         else return true;
121 |     } else if (tt > this.len) {
122 |         let raf = 0.8 * (tt - this.len) / 40;
123 |         this.car[this.car.length - 1].drawCircle(raf);
124 |         return true;
125 |     } else {
126 |         return true;
127 |     }
128 | }
129 | };
130 | 
131 | var cval = (x, y, rad) => {
132 |     if (Math.pow(x * x + y * y, 0.5) > CSIZE - rad) return false;
133 |     for (let i = 0; i < ca.length; i++) {
134 |         let rt = rad + ca[i].radius;
135 |         let xd = ca[i].x - x;
136 |         let yd = ca[i].y - y;
137 |         if (Math.abs(xd) > rt) continue;
138 |         if (Math.abs(yd) > rt) continue;
139 |         if (Math.pow(xd * xd + yd * yd, 0.5) + 1 < rt) {
140 |             return false;
141 |         }
142 |     }
143 |     return true;
144 | }
145 | 
146 | var eg = Math.random() < 0.3;
147 | 
148 | var grow = (rad) => {
149 |     let c = eg
150 |         ? ca[ca.length - 1 - getRandomInt(0, ca.length, true)]
151 |         : ca[getRandomInt(0, ca.length)];
152 |     let a = TP * Math.random();
153 |     let x = c.x + (c.radius + rad) * Math.cos(a);
154 |     let y = c.y + (c.radius + rad) * Math.sin(a);
155 |     if (cval(x, y, rad)) {
156 |         let xp = c.x + c.radius * Math.cos(a);
157 |         let yp = c.y + c.radius * Math.sin(a);
158 |         let circle = new Circle(x, y, xp, yp, rad, c);
159 |         c.c.push(circle);
160 |         ca.push(circle);
161 |         return true;
162 |     }
163 |     return false;
164 | }
165 | 
166 | ctx.fillStyle = "green";
167 | ctx.lineWidth = 5;
168 | 
169 | var draw = () => {
170 |     ctx.clearRect(-CSIZE, -CSIZE, 2 * CSIZE, 2 * CSIZE);
171 |     let grown = 0;
172 |     for (let i = 0; i < curves.length; i++) {
173 |         if (curves[i].drawCurve()) grown++;
174 |     }
175 |     if (grown === curves.length) {
176 |         fullyGrownFlag = true;
177 |     }
178 |     return grown;
179 | }
180 | 
181 | var stopped = true;
182 | var start = () => {
183 |     if (stopped) {
184 |         stopped = false;
185 |         requestAnimationFrame(animate);
186 |     } else stopped = true;
187 | }
188 | body.addEventListener("click", start, false);
189 | 
190 | var t = 0;
191 | var inc = 3;
192 | var fullyGrownFlag = false;
193 | var animate = () => {
194 |     if (stopped) return;
195 |     t += inc;
196 | 
197 |     let grown = draw();
198 |     if (!grown && !fullyGrownFlag) {
199 |         ctx.strokeStyle = "hsla(" + getRandomInt(0, 360) + ",90%,60%,0.6)";
200 |         setCircles();
201 |     }
202 |     if (fullyGrownFlag && grown === 0 && t <= -2000) { 
203 |         resetPattern();
204 |     }
205 |     requestAnimationFrame(animate);
206 | };
207 | 
208 | function resetPattern() {
209 |     eg = Math.random() < 0.3;
210 |     hue = getRandomInt(0, 360);
211 |     fullyGrownFlag = false;
212 |     t = 0;
213 |     setCircles();
214 |     start();
215 | }
216 | 
217 | ctx.canvas.onmouseover = () => {
218 |     inc = -8;
219 | };
220 | 
221 | ctx.canvas.onmouseout = () => {
222 |     if (t <= -2000) {
223 |         resetPattern();
224 |     }
225 |     inc = 3;
226 | };
227 | 
228 | var hue = getRandomInt(0, 360);
229 | var ca = [new Circle(0, 0, 0, 0, 50, 0, 0)];
230 | 
231 | var curves = [];
232 | 
233 | var setCircles = () => {
234 |     eg = Math.random() < 0.3;
235 |     ca = [new Circle(0, 0, 0, 0, 50, 0, 0)];
236 |     for (let i = 0; i < 2000; i++) {
237 |         let r = 10;
238 |         if (i < 20) r = 42;
239 |         else if (i < 100) r = 34;
240 |         else if (i < 300) r = 26;
241 |         else if (i < 1000) r = 18;
242 |         grow(r);
243 |     }
244 |     curves = [];
245 |     for (let i = 0; i < ca.length; i++) {
246 |         if (ca[i].c.length == 0) {
247 |             var nc = new Curve();
248 |             nc.car = [ca[i]];
249 |             nc.addCurveCircle(ca[i]);
250 |             nc.setPath();
251 |             curves.push(nc);
252 |         }
253 |     }
254 | }
255 | 
256 | onresize();
257 | setCircles();
258 | ctx.strokeStyle = "hsla(" + getRandomInt(0, 360) + ",90%,60%,0.6)";
259 | start();
260 | 


--------------------------------------------------------------------------------
/love14/index.html:
--------------------------------------------------------------------------------
  1 | <!DOCTYPE html>
  2 | <html lang="en">
  3 | <head>
  4 |   <meta charset="UTF-8">
  5 |   <meta http-equiv="X-UA-Compatible" content="IE=edge">
  6 |   <meta name="viewport" content="width=device-width, initial-scale=1.0">
  7 |   <title>❤️</title>
  8 |   <style>
  9 |     canvas {
 10 |       position: absolute;
 11 |       left: 0;
 12 |       top: 0;
 13 |       width: 100%;
 14 |       height: 100%;
 15 |       background-color: rgba(0, 0, 0, 0.2);
 16 |     }
 17 |   </style>
 18 | </head>
 19 | <body>
 20 |   <canvas id="heart"></canvas>
 21 |   <script>
 22 |     window.requestAnimationFrame =
 23 |       window.__requestAnimationFrame ||
 24 |       window.requestAnimationFrame ||
 25 |       window.webkitRequestAnimationFrame ||
 26 |       window.mozRequestAnimationFrame ||
 27 |       window.oRequestAnimationFrame ||
 28 |       window.msRequestAnimationFrame ||
 29 |       (function () {
 30 |         return function (callback, element) {
 31 |           var lastTime = element.__lastTime || 0;
 32 |           var currTime = Date.now();
 33 |           var timeToCall = Math.max(1, 33 - (currTime - lastTime));
 34 |           window.setTimeout(callback, timeToCall);
 35 |           element.__lastTime = currTime + timeToCall;
 36 |         };
 37 |       })();
 38 | 
 39 |     window.isDevice = /android|webos|iphone|ipad|ipod|blackberry|iemobile|opera mini/i.test(
 40 |       (navigator.userAgent || navigator.vendor || window.opera).toLowerCase()
 41 |     );
 42 | 
 43 |     var loaded = false;
 44 | 
 45 |     var init = function () {
 46 |       if (loaded) return;
 47 |       loaded = true;
 48 |       var mobile = window.isDevice;
 49 |       var koef = mobile ? 0.5 : 1;
 50 |       var canvas = document.getElementById("heart");
 51 |       var ctx = canvas.getContext("2d");
 52 |       var width = (canvas.width = koef * innerWidth);
 53 |       var height = (canvas.height = koef * innerHeight);
 54 |       var rand = Math.random;
 55 | 
 56 |       ctx.fillStyle = "rgba(0,0,0,1)";
 57 |       ctx.fillRect(0, 0, width, height);
 58 | 
 59 |       var drawText = function () {
 60 |         ctx.font = "60px Arial"; 
 61 |         ctx.fillStyle = "lightblue";
 62 |         ctx.textAlign = "center";
 63 |         ctx.fillText("", width / 2, height / 2.2 + 400); 
 64 |       };
 65 | 
 66 |       var heartPosition = function (rad) {
 67 |         return [
 68 |           Math.pow(Math.sin(rad), 3),
 69 |           -(
 70 |             15 * Math.cos(rad) -
 71 |             5 * Math.cos(2 * rad) -
 72 |             2 * Math.cos(3 * rad) -
 73 |             Math.cos(4 * rad)
 74 |           ),
 75 |         ];
 76 |       };
 77 | 
 78 |       var scaleAndTranslate = function (pos, sx, sy, dx, dy) {
 79 |         return [dx + pos[0] * sx, dy + pos[1] * sy];
 80 |       };
 81 | 
 82 |       window.addEventListener("resize", function () {
 83 |         width = canvas.width = koef * innerWidth;
 84 |         height = canvas.height = koef * innerHeight;
 85 |         ctx.fillStyle = "rgba(0,0,0,1)";
 86 |         ctx.fillRect(0, 0, width, height);
 87 |       });
 88 | 
 89 |       var traceCount = mobile ? 20 : 50;
 90 |       var pointsOrigin = [];
 91 |       var dr = mobile ? 0.3 : 0.1;
 92 |       for (var i = 0; i < Math.PI * 2; i += dr)
 93 |         pointsOrigin.push(scaleAndTranslate(heartPosition(i), 310, 19, 0, 0)); 
 94 |       for (var i = 0; i < Math.PI * 2; i += dr)
 95 |         pointsOrigin.push(scaleAndTranslate(heartPosition(i), 250, 15, 0, 0)); 
 96 |       for (var i = 0; i < Math.PI * 2; i += dr)
 97 |         pointsOrigin.push(scaleAndTranslate(heartPosition(i), 190, 11, 0, 0)); 
 98 | 
 99 |       var heartPointsCount = pointsOrigin.length;
100 |       var targetPoints = [];
101 | 
102 |       var pulse = function (kx, ky) {
103 |         for (var i = 0; i < pointsOrigin.length; i++) {
104 |           targetPoints[i] = [
105 |             kx * pointsOrigin[i][0] + width / 2,
106 |             ky * pointsOrigin[i][1] + height / 2.2,
107 |           ];
108 |         }
109 |       };
110 | 
111 |       var e = [];
112 |       for (var i = 0; i < heartPointsCount; i++) {
113 |         var x = rand() * width;
114 |         var y = rand() * height;
115 |         e[i] = {
116 |           vx: 0,
117 |           vy: 0,
118 |           R: 2,
119 |           speed: rand() + 5,
120 |           q: ~~(rand() * heartPointsCount),
121 |           D: 2 * (i % 2) - 1,
122 |           force: 0.2 * rand() + 0.7,
123 |           f: "rgba(51, 204, 255, 0.7)",
124 |           trace: Array.from({ length: traceCount }, () => ({ x, y })),
125 |         };
126 |       }
127 | 
128 |       var config = { traceK: 0.4, timeDelta: 0.6 };
129 |       var time = 0;
130 | 
131 |       var loop = function () {
132 |         var n = -Math.cos(time);
133 |         pulse((1 + n) * 0.5, (1 + n) * 0.5);
134 |         time += (Math.sin(time) < 0 ? 9 : n > 0.8 ? 0.2 : 1) * config.timeDelta;
135 | 
136 |         ctx.fillStyle = "rgba(0,0,0,.1)";
137 |         ctx.fillRect(0, 0, width, height);
138 | 
139 |         for (var i = e.length; i--; ) {
140 |           var u = e[i];
141 |           var q = targetPoints[u.q];
142 |           var dx = u.trace[0].x - q[0];
143 |           var dy = u.trace[0].y - q[1];
144 |           var length = Math.sqrt(dx * dx + dy * dy);
145 | 
146 |           if (length < 10) {
147 |             if (rand() > 0.95) {
148 |               u.q = ~~(rand() * heartPointsCount);
149 |             } else {
150 |               if (rand() > 0.99) u.D *= -1;
151 |               u.q = (u.q + u.D) % heartPointsCount;
152 |               if (u.q < 0) u.q += heartPointsCount;
153 |             }
154 |           }
155 | 
156 |           u.vx += (-dx / length) * u.speed;
157 |           u.vy += (-dy / length) * u.speed;
158 |           u.trace[0].x += u.vx;
159 |           u.trace[0].y += u.vy;
160 |           u.vx *= u.force;
161 |           u.vy *= u.force;
162 | 
163 |           for (var k = 0; k < u.trace.length - 1; k++) {
164 |             var T = u.trace[k];
165 |             var N = u.trace[k + 1];
166 |             N.x -= config.traceK * (N.x - T.x);
167 |             N.y -= config.traceK * (N.y - T.y);
168 |           }
169 | 
170 |           ctx.fillStyle = u.f;
171 |           u.trace.forEach((t) => ctx.fillRect(t.x, t.y, 1, 1));
172 |         }
173 | 
174 |         drawText();
175 |         window.requestAnimationFrame(loop, canvas);
176 |       };
177 | 
178 |       loop();
179 |     };
180 | 
181 |     var s = document.readyState;
182 |     if (s === "complete" || s === "loaded" || s === "interactive") init();
183 |     else document.addEventListener("DOMContentLoaded", init);
184 |   </script>
185 | </body>
186 | </html>


--------------------------------------------------------------------------------
/love16/index.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html lang="en">
 3 | <head>
 4 |   <meta charset="UTF-8">
 5 |   <meta name="viewport" content="width=device-width, initial-scale=1.0">
 6 |   <style link rel="stylesheet" href="style.css"></style>
 7 |   <title>lope lope</title>
 8 | </head>
 9 | <body>
10 |   <canvas id="heart" width="1920" height="947"></canvas>
11 |   <script src="script.js"></script>
12 | </body>
13 | </html>


--------------------------------------------------------------------------------
/love16/script.js:
--------------------------------------------------------------------------------
  1 | window.requestAnimationFrame =
  2 |   window.__requestAnimationFrame ||
  3 |   window.requestAnimationFrame ||
  4 |   window.webkitRequestAnimationFrame ||7
  5 |   window.mozRequestAnimationFrame ||
  6 |   window.oRequestAnimationFrame ||
  7 |   window.msRequestAnimationFrame ||
  8 |   (function () {
  9 |     return function (callback, element) {
 10 |       var lastTime = element.__lastTime;
 11 |       if (lastTime === undefined) {
 12 |         lastTime = 0;
 13 |       }
 14 |       var currTime = Date.now();
 15 |       var timeToCall = Math.max(1, 33 - (currTime - lastTime));
 16 |       window.setTimeout(callback, timeToCall);
 17 |       element.__lastTime = currTime + timeToCall;
 18 |     };
 19 |   })();
 20 | 
 21 | window.isDevice = (/android|webos|iphone|ipad|ipod|blackberry|iemobile|opera mini/i.test(((navigator.userAgent || navigator.vendor || window.opera)).toLowerCase()));
 22 | 
 23 | var loaded = false;
 24 | var init = function () {
 25 |   if (loaded) return;
 26 |   loaded = true;
 27 |   var mobile = window.isDevice;
 28 |   var koef = mobile ? 0.5 : 1;
 29 |   var canvas = document.getElementById('heart');
 30 |   var ctx = canvas.getContext('2d');
 31 |   var width = canvas.width = koef * innerWidth;
 32 |   var height = canvas.height = koef * innerHeight;
 33 |   var rand = Math.random;
 34 |   ctx.fillStyle = "rgba(0,0,0,1)";
 35 |   ctx.fillRect(0, 0, width, height);
 36 | 
 37 |   var heartPosition = function (rad) {
 38 |     return [Math.pow(Math.sin(rad), 3), -(15 * Math.cos(rad) - 5 * Math.cos(2 * rad) - 2 * Math.cos(3 * rad) - Math.cos(4 * rad))];
 39 |   };
 40 | 
 41 |   var scaleAndTranslate = function (pos, sx, sy, dx, dy) {
 42 |     return [dx + pos[0] * sx, dy + pos[1] * sy];
 43 |   };
 44 | 
 45 |   window.addEventListener('resize', function () {
 46 |     width = canvas.width = koef * innerWidth;
 47 |     height = canvas.height = koef * innerHeight;
 48 |     ctx.fillStyle = "rgba(0,0,0,1)";
 49 |     ctx.fillRect(0, 0, width, height);
 50 |   });
 51 | 
 52 |   var traceCount = mobile ? 20 : 50;
 53 |   var pointsOrigin = [];
 54 |   var i;
 55 |   var dr = mobile ? 0.3 : 0.1;
 56 |   for (i = 0; i < Math.PI * 2; i += dr) pointsOrigin.push(scaleAndTranslate(heartPosition(i), 210, 13, 0, 0));
 57 |   for (i = 0; i < Math.PI * 2; i += dr) pointsOrigin.push(scaleAndTranslate(heartPosition(i), 150, 9, 0, 0));
 58 |   for (i = 0; i < Math.PI * 2; i += dr) pointsOrigin.push(scaleAndTranslate(heartPosition(i), 90, 5, 0, 0));
 59 |   var heartPointsCount = pointsOrigin.length;
 60 | 
 61 |   var targetPoints = [];
 62 |   var pulse = function (kx, ky) {
 63 |     for (i = 0; i < pointsOrigin.length; i++) {
 64 |       targetPoints[i] = [];
 65 |       targetPoints[i][0] = kx * pointsOrigin[i][0] + width / 2;
 66 |       targetPoints[i][1] = ky * pointsOrigin[i][1] + height / 2;
 67 |     }
 68 |   };
 69 | 
 70 |   var e = [];
 71 |   for (i = 0; i < heartPointsCount; i++) {
 72 |     var x = rand() * width;
 73 |     var y = rand() * height;
 74 |     e[i] = {
 75 |       vx: 0,
 76 |       vy: 0,
 77 |       R: 2,
 78 |       speed: rand() + 5,
 79 |       q: ~~(rand() * heartPointsCount),
 80 |       D: 2 * (i % 2) - 1,
 81 |       force: 0.2 * rand() + 0.7,
 82 |       f: "hsla(0," + ~~(40 * rand() + 60) + "%," + ~~(60 * rand() + 20) + "%,.3)",
 83 |       trace: []
 84 |     };
 85 |     for (var k = 0; k < traceCount; k++) e[i].trace[k] = { x: x, y: y };
 86 |   }
 87 | 
 88 |   var config = {
 89 |     traceK: 0.4,
 90 |     timeDelta: 0.01
 91 |   };
 92 | 
 93 |   var time = 0;
 94 |   var loop = function () {
 95 |     var n = -Math.cos(time);
 96 |     pulse((1 + n) * .5, (1 + n) * .5);
 97 |     time += ((Math.sin(time)) < 0 ? 9 : (n > 0.8) ? .2 : 1) * config.timeDelta;
 98 |     ctx.fillStyle = "rgba(0,0,0,.1)";
 99 |     ctx.fillRect(0, 0, width, height);
100 |     for (i = e.length; i--;) {
101 |       var u = e[i];
102 |       var q = targetPoints[u.q];
103 |       var dx = u.trace[0].x - q[0];
104 |       var dy = u.trace[0].y - q[1];
105 |       var length = Math.sqrt(dx * dx + dy * dy);
106 |       if (10 > length) {
107 |         if (0.95 < rand()) {
108 |           u.q = ~~(rand() * heartPointsCount);
109 |         } else {
110 |           if (0.99 < rand()) {
111 |             u.D *= -1;
112 |           }
113 |           u.q += u.D;
114 |           u.q %= heartPointsCount;
115 |           if (0 > u.q) {
116 |             u.q += heartPointsCount;
117 |           }
118 |         }
119 |       }
120 |       u.vx += -dx / length * u.speed;
121 |       u.vy += -dy / length * u.speed;
122 |       u.trace[0].x += u.vx;
123 |       u.trace[0].y += u.vy;
124 |       u.vx *= u.force;
125 |       u.vy *= u.force;
126 |       for (k = 0; k < u.trace.length - 1;) {
127 |         var T = u.trace[k];
128 |         var N = u.trace[++k];
129 |         N.x -= config.traceK * (N.x - T.x);
130 |         N.y -= config.traceK * (N.y - T.y);
131 |       }
132 |       ctx.fillStyle = u.f;
133 |       for (k = 0; k < u.trace.length; k++) {
134 |         ctx.fillRect(u.trace[k].x, u.trace[k].y, 1, 1);
135 |       }
136 |     }
137 |     ctx.fillStyle = "rgba(255,255,255,1)";
138 |     for (i = u.trace.length + 13; i--;) ctx.fillRect(targetPoints[i][0], targetPoints[i][1], 2, 2);
139 | 
140 |     window.requestAnimationFrame(loop, canvas);
141 |   };
142 |   loop();
143 | };
144 | 
145 | var s = document.readyState;
146 | if (s === 'complete' || s === 'loaded' || s === 'interactive') init();
147 | else document.addEventListener('DOMContentLoaded', init, false);


--------------------------------------------------------------------------------
/love16/style.css:
--------------------------------------------------------------------------------
1 | canvas {
2 |     position: absolute;
3 |     left: 0;
4 |     top: 0;
5 |     width: 100%;
6 |     height: 100%;
7 |     background-color: rgba(0, 0, 0, .2);
8 |   }


--------------------------------------------------------------------------------
/love18/index.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html lang="en">
 3 | <head>
 4 |     <meta charset="UTF-8">
 5 |     <title>💕</title>
 6 |     <link rel="stylesheet" href="styles.css">
 7 | </head>
 8 | <body>
 9 |     <script src="script.js"></script>
10 | </body>
11 | </html>
12 | 


--------------------------------------------------------------------------------
/love18/script.js:
--------------------------------------------------------------------------------
  1 | class Tool {
  2 |     static randomNumber(min, max) {
  3 |         return Math.floor(Math.random() * (max - min + 1) + min);
  4 |     }
  5 | 
  6 |     static randomColorRGB() {
  7 |         return `rgb(${this.randomNumber(0, 255)}, ${this.randomNumber(0, 255)}, ${this.randomNumber(0, 255)})`;
  8 |     }
  9 | 
 10 |     static randomColorHSL(hue, saturation, lightness) {
 11 |         return `hsl(${hue}, ${saturation}%, ${lightness}%)`;
 12 |     }
 13 | 
 14 |     static gradientColor(ctx, cr, cg, cb, ca, x, y, r) {
 15 |         const col = `${cr},${cg},${cb}`;
 16 |         const g = ctx.createRadialGradient(x, y, 0, x, y, r);
 17 |         g.addColorStop(0, `rgba(${col}, ${ca * 1})`);
 18 |         g.addColorStop(0.5, `rgba(${col}, ${ca * 0.5})`);
 19 |         g.addColorStop(1, `rgba(${col}, ${ca * 0})`);
 20 |         return g;
 21 |     }
 22 | }
 23 | 
 24 | class Angle {
 25 |     constructor(a) {
 26 |         this.a = a;
 27 |         this.rad = (this.a * Math.PI) / 180;
 28 |     }
 29 | 
 30 |     incDec(num) {
 31 |         this.a += num;
 32 |         this.rad = (this.a * Math.PI) / 180;
 33 |     }
 34 | }
 35 | 
 36 | let canvas;
 37 | let offCanvas;
 38 | 
 39 | class Canvas {
 40 |     constructor(bool) {
 41 |         this.canvas = document.createElement("canvas");
 42 |         if (bool === true) {
 43 |             this.canvas.style.position = "relative";
 44 |             this.canvas.style.display = "block";
 45 |             this.canvas.style.top = 0;
 46 |             this.canvas.style.left = 0;
 47 |             document.body.appendChild(this.canvas);
 48 |         }
 49 |         this.ctx = this.canvas.getContext("2d");
 50 |         this.width = this.canvas.width = window.innerWidth;
 51 |         this.height = this.canvas.height = window.innerHeight;
 52 |         this.width < 768 ? (this.heartSize = 180) : (this.heartSize = 250);
 53 |         this.mouseX = null;
 54 |         this.mouseY = null;
 55 |         this.hearts = [];
 56 |         this.offHeartNum = 1;
 57 |         this.offHearts = [];
 58 |         this.data = null;
 59 |     }
 60 | 
 61 |     onInit() {
 62 |         let index = 0;
 63 |         for (let i = 0; i < this.height; i += 12) {
 64 |             for (let j = 0; j < this.width; j += 12) {
 65 |                 let oI = (j + i * this.width) * 4 + 3;
 66 |                 if (this.data[oI] > 0) {
 67 |                     index++;
 68 |                     const h = new Heart(canvas.ctx, j + Tool.randomNumber(-3, 3), i + Tool.randomNumber(-3, 3), Tool.randomNumber(6, 12), index);
 69 |                     canvas.hearts.push(h);
 70 |                 }
 71 |             }
 72 |         }
 73 |     }
 74 | 
 75 |     offInit() {
 76 |         for (let i = 0; i < this.offHeartNum; i++) {
 77 |             const s = new Heart(this.ctx, this.width / 2, this.height / 2.3, this.heartSize);
 78 |             this.offHearts.push(s);
 79 |         }
 80 |         for (let i = 0; i < this.offHearts.length; i++) {
 81 |             this.offHearts[i].offRender(i);
 82 |         }
 83 |         this.data = this.ctx.getImageData(0, 0, this.width, this.height).data;
 84 |         this.onInit();
 85 |     }
 86 | 
 87 |     render() {
 88 |         this.ctx.clearRect(0, 0, this.width, this.height);
 89 |         for (let i = 0; i < this.hearts.length; i++) {
 90 |             this.hearts[i].render(i);
 91 |         }
 92 |     }
 93 | 
 94 |     resize() {
 95 |         this.offHearts = [];
 96 |         this.hearts = [];
 97 |         this.width = this.canvas.width = window.innerWidth;
 98 |         this.height = this.canvas.height = window.innerHeight;
 99 |         this.width < 768 ? (this.heartSize = 180) : (this.heartSize = 250);
100 |     }
101 | }
102 | 
103 | class Heart {
104 |     constructor(ctx, x, y, r, i) {
105 |         this.ctx = ctx;
106 |         this.init(x, y, r, i);
107 |     }
108 | 
109 |     init(x, y, r, i) {
110 |         this.x = x;
111 |         this.xi = x;
112 |         this.y = y;
113 |         this.yi = y;
114 |         this.r = r;
115 |         this.i = i * 0.5 + 200;
116 |         this.l = this.i;
117 |         this.c = Tool.randomColorHSL(Tool.randomNumber(-5, 5), 80, 60);
118 |         this.a = new Angle(Tool.randomNumber(0, 360));
119 |         this.v = {
120 |             x: Math.random(),
121 |             y: -Math.random(),
122 |         };
123 |         this.ga = Math.random();
124 |     }
125 | 
126 |     draw() {
127 |         const ctx = this.ctx;
128 |         ctx.save();
129 |         ctx.globalCompositeOperation = "lighter";
130 |         ctx.globalAlpha = this.ga;
131 |         ctx.beginPath();
132 |         ctx.fillStyle = this.c;
133 |         ctx.moveTo(this.x, this.y + this.r);
134 |         ctx.bezierCurveTo(
135 |             this.x - this.r - this.r / 5,
136 |             this.y + this.r / 1.5,
137 |             this.x - this.r,
138 |             this.y - this.r,
139 |             this.x,
140 |             this.y - this.r / 5
141 |         );
142 |         ctx.bezierCurveTo(
143 |             this.x + this.r,
144 |             this.y - this.r,
145 |             this.x + this.r + this.r / 5,
146 |             this.y + this.r / 1.5,
147 |             this.x,
148 |             this.y + this.r
149 |         );
150 |         ctx.closePath();
151 |         ctx.fill();
152 |         ctx.restore();
153 |     }
154 | 
155 |     updateParams() {
156 |         this.a.incDec(1);
157 |         Math.sin(this.a.rad) < 0 ? (this.r = -Math.sin(this.a.rad) * 20) : (this.r = Math.sin(this.a.rad) * 20);
158 |     }
159 | 
160 |     updatePosition() {
161 |         this.l -= 1;
162 |         if (this.l < 0) {
163 |             this.v.y -= 0.01;
164 |             this.v.x += 0.02;
165 |             this.y += this.v.y;
166 |             this.x += this.v.x;
167 |         }
168 |     }
169 | 
170 |     wrapPosition() {
171 |         if (this.x > canvas.width * 1.5) {
172 |             this.init(this.xi, this.yi, Tool.randomNumber(6, 12), this.i);
173 |         }
174 |     }
175 | 
176 |     render() {
177 |         this.wrapPosition();
178 |         this.updateParams();
179 |         this.updatePosition();
180 |         this.draw();
181 |     }
182 | 
183 |     offRender(i) {
184 |         this.draw();
185 |     }
186 | }
187 | 
188 | (function () {
189 |     "use strict";
190 |     window.addEventListener("load", function () {
191 |         offCanvas = new Canvas(false);
192 |         canvas = new Canvas(true);
193 | 
194 |         offCanvas.offInit();
195 | 
196 |         function render() {
197 |             window.requestAnimationFrame(function () {
198 |                 canvas.render();
199 |                 render();
200 |             });
201 |         }
202 | 
203 |         render();
204 | 
205 |         window.addEventListener(
206 |             "resize",
207 |             function () {
208 |                 canvas.resize();
209 |                 offCanvas.resize();
210 |                 offCanvas.offInit();
211 |             },
212 |             false
213 |         );
214 |     });
215 | })();
216 | 


--------------------------------------------------------------------------------
/love18/styles.css:
--------------------------------------------------------------------------------
 1 | * {
 2 |     margin: 0;
 3 |     padding: 0;
 4 | }
 5 | 
 6 | html, body {
 7 |     overflow: hidden;
 8 | }
 9 | 
10 | body {
11 |     position: relative;
12 |     background: #000;
13 | }
14 | 


--------------------------------------------------------------------------------
/love21/index.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html lang="en">
 3 | <head>
 4 |     <meta charset="UTF-8">
 5 |     <meta http-equiv="X-UA-Compatible" content="IE=edge">
 6 |     <link rel="stylesheet" href="styles.css">
 7 |     <title>❤️</title>
 8 | </head>
 9 | <body>
10 |     <div class="box"></div>
11 |     <canvas id="heart"></canvas>
12 |     <script src="script.js"></script>
13 | </body>
14 | </html>


--------------------------------------------------------------------------------
/love21/script.js:
--------------------------------------------------------------------------------
  1 | var canvas = document.getElementById("heart");
  2 | canvas.width = 600;
  3 | canvas.height = 600;
  4 | canvas.style.width = canvas.width + "px";
  5 | canvas.style.height = canvas.height + "px";
  6 | 
  7 | var context = canvas.getContext("2d");
  8 | context.translate(canvas.width / 2, canvas.height / 2);
  9 | context.scale(1, -1);
 10 | context.moveTo(0, 0);
 11 | 
 12 | context.fillStyle = '#ea80b0';
 13 | 
 14 | function xin(t, r, j, ws) {
 15 |     this.trans = t;
 16 |     this.rs = r;
 17 |     this.ws = ws;
 18 |     this.index = j;
 19 |     this.x = this.trans * this.ws * Math.sin(this.index) * Math.sin(this.index) * Math.sin(this.index);
 20 |     this.y = this.trans * (16 * Math.cos(this.index) - 5 * Math.cos(2 * this.index) - 2 * Math.cos(3 * this.index) - Math.cos(4 * this.index));
 21 | }
 22 | 
 23 | let ws = 18;
 24 | let hs = 16;
 25 | let wsSpeed = 0.15;
 26 | let hsSpeed = 0.15;
 27 | let speed = 0.2;
 28 | 
 29 | let wqs = [];
 30 | let nqs = [];
 31 | let hxz = [];
 32 | let hxz2 = [];
 33 | let dc = [];
 34 | 
 35 | sdata();
 36 | 
 37 | function sdata() {
 38 |     for (let j = 0; j < 500; j += speed) {
 39 |         let trans = 9 + Math.random() * 2.5;
 40 |         let size = Math.random() * 2;
 41 |         let xins = new xin(trans, size, j, ws);
 42 |         wqs.push(xins);
 43 |     }
 44 | 
 45 |     for (let j = 0; j < 300; j += speed) {
 46 |         let trans = 7 + Math.random() * 5;
 47 |         let size = Math.random() * 2.5;
 48 |         let xins = new xin(trans, size, j, ws);
 49 |         nqs.push(xins);
 50 |     }
 51 | 
 52 |     for (let j = 0; j < 600; j += speed) {
 53 |         let trans = 11 + Math.random() * 2;
 54 |         let size = Math.random() * 3.5;
 55 |         let xins = new xin(trans, size, j, ws);
 56 |         hxz.push(xins);
 57 |     }
 58 | 
 59 |     for (let j = 0; j < 500; j += speed) {
 60 |         let trans = 0 + Math.random() * 2.7;
 61 |         let size = Math.random() * 2.5;
 62 |         let xins = new xin(trans, size, j, ws);
 63 |         hxz2.push(xins);
 64 |     }
 65 | 
 66 |     function animate() {
 67 |         context.clearRect(-canvas.width / 2, -canvas.height / 2, canvas.width, canvas.height);
 68 |         ws += wsSpeed;
 69 |         if (ws < 16) {
 70 |             wsSpeed *= -1;
 71 |         } else if (ws > 18) {
 72 |             wsSpeed *= -1;
 73 |         }
 74 |         hs += hsSpeed;
 75 |         if (hs < 14) {
 76 |             hsSpeed *= -1;
 77 |         } else if (hs > 16) {
 78 |             hsSpeed *= -1;
 79 |         }
 80 | 
 81 |         [hxz, hxz2, nqs, wqs].forEach(collection => {
 82 |             collection.forEach(v => {
 83 |                 context.beginPath();
 84 |                 context.arc(
 85 |                     v.trans * ws * Math.sin(v.index) * Math.sin(v.index) * Math.sin(v.index), 
 86 |                     v.trans * (hs * Math.cos(v.index) - 5 * Math.cos(2 * v.index) - 2 * Math.cos(3 * v.index) - Math.cos(4 * v.index)), 
 87 |                     v.rs, 0, Math.PI * 2
 88 |                 );
 89 |                 context.fill();
 90 |                 context.stroke();
 91 |                 context.closePath();
 92 |             });
 93 |         });
 94 | 
 95 |         dc = [];
 96 |         for (let j = 0; j < 300; j += speed) {
 97 |             let trans = 1 + Math.random() * 20;
 98 |             let size = Math.random() * 2;
 99 |             let xins = new xin(trans, size, j, ws);
100 |             dc.push(xins);
101 |         }
102 | 
103 |         dc.forEach(v => {
104 |             context.beginPath();
105 |             context.arc(v.x, v.y, v.rs, 0, Math.PI * 2);
106 |             context.fill();
107 |             context.stroke();
108 |             context.closePath();
109 |         });
110 | 
111 |         requestAnimationFrame(animate);
112 |     }
113 | 
114 |     animate();
115 | }


--------------------------------------------------------------------------------
/love21/styles.css:
--------------------------------------------------------------------------------
 1 | body {
 2 |     filter: blur(0.5px);
 3 |     background: #000;
 4 |     display: flex;
 5 |     justify-content: center;
 6 |     align-items: center;
 7 |     height: 100vh;
 8 |     margin: 0;
 9 |     overflow: hidden;
10 | }
11 | .box {
12 |     position: absolute;
13 |     top: 50%;
14 |     left: 50%;
15 |     transform: translate(-50%, -50%);
16 |     width: 500px;
17 |     height: 500px;
18 |     background: rgba(255,0, 10, .2);
19 |     border-radius: 50%;
20 |     mix-blend-mode: screen;
21 |     filter: blur(100px);
22 | }
23 | canvas {
24 |     display: block;
25 | }


--------------------------------------------------------------------------------
/love23/css/style.css:
--------------------------------------------------------------------------------
1 | body {
2 |   background-color: #000;
3 |   overflow: hidden;
4 |   margin: 0;
5 | }


--------------------------------------------------------------------------------
/love23/index.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html lang="zh">
 3 |   <head>
 4 |     <meta charset="UTF-8" />
 5 |     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
 6 |     <title>Heart</title>
 7 |     <link rel="stylesheet" href="css/style.css" />
 8 |   </head>
 9 |   <body>
10 |     <script src="js/three.min.js"></script>
11 |     <script src="js/MeshSurfaceSampler.js"></script>
12 |     <script src="js/TrackballControls.js"></script>
13 |     <script src="js/simplex-noise.js"></script>
14 |     <script src="js/OBJLoader.js"></script>
15 |     <script src="js/gsap.min.js"></script>
16 |     <script src="js/script.js"></script>
17 |   </body>
18 | </html>
19 | 


--------------------------------------------------------------------------------
/love23/js/MeshSurfaceSampler.js:
--------------------------------------------------------------------------------
  1 | (function () {
  2 |     const _face = new THREE.Triangle();
  3 |     const _color = new THREE.Vector3();
  4 | 
  5 |     class MeshSurfaceSampler {
  6 |         constructor(mesh) {
  7 |             let geometry = mesh.geometry;
  8 | 
  9 |             if (!geometry.isBufferGeometry || geometry.attributes.position.itemSize !== 3) {
 10 |                 throw new Error('THREE.MeshSurfaceSampler: Requires BufferGeometry triangle mesh.');
 11 |             }
 12 | 
 13 |             if (geometry.index) {
 14 |                 console.warn('THREE.MeshSurfaceSampler: Converting geometry to non-indexed BufferGeometry.');
 15 |                 geometry = geometry.toNonIndexed();
 16 |             }
 17 | 
 18 |             this.geometry = geometry;
 19 |             this.randomFunction = Math.random;
 20 |             this.positionAttribute = this.geometry.getAttribute('position');
 21 |             this.colorAttribute = this.geometry.getAttribute('color');
 22 |             this.weightAttribute = null;
 23 |             this.distribution = null;
 24 |         }
 25 | 
 26 |         setWeightAttribute(name) {
 27 |             this.weightAttribute = name ? this.geometry.getAttribute(name) : null;
 28 |             return this;
 29 |         }
 30 | 
 31 |         build() {
 32 |             const positionAttribute = this.positionAttribute;
 33 |             const weightAttribute = this.weightAttribute;
 34 |             const faceWeights = new Float32Array(positionAttribute.count / 3);
 35 | 
 36 |             for (let i = 0; i < positionAttribute.count; i += 3) {
 37 |                 let faceWeight = 1;
 38 | 
 39 |                 if (weightAttribute) {
 40 |                     faceWeight = weightAttribute.getX(i) + weightAttribute.getX(i + 1) + weightAttribute.getX(i + 2);
 41 |                 }
 42 | 
 43 |                 _face.a.fromBufferAttribute(positionAttribute, i);
 44 |                 _face.b.fromBufferAttribute(positionAttribute, i + 1);
 45 |                 _face.c.fromBufferAttribute(positionAttribute, i + 2);
 46 | 
 47 |                 faceWeight *= _face.getArea();
 48 |                 faceWeights[i / 3] = faceWeight;
 49 |             }
 50 | 
 51 |             this.distribution = new Float32Array(positionAttribute.count / 3);
 52 |             let cumulativeTotal = 0;
 53 | 
 54 |             for (let i = 0; i < faceWeights.length; i++) {
 55 |                 cumulativeTotal += faceWeights[i];
 56 |                 this.distribution[i] = cumulativeTotal;
 57 |             }
 58 | 
 59 |             return this;
 60 |         }
 61 | 
 62 |         setRandomGenerator(randomFunction) {
 63 |             this.randomFunction = randomFunction;
 64 |             return this;
 65 |         }
 66 | 
 67 |         sample(targetPosition, targetNormal, targetColor) {
 68 |             const cumulativeTotal = this.distribution[this.distribution.length - 1];
 69 |             const faceIndex = this.binarySearch(this.randomFunction() * cumulativeTotal);
 70 |             return this.sampleFace(faceIndex, targetPosition, targetNormal, targetColor);
 71 |         }
 72 | 
 73 |         binarySearch(x) {
 74 |             const dist = this.distribution;
 75 |             let start = 0;
 76 |             let end = dist.length - 1;
 77 |             let index = -1;
 78 | 
 79 |             while (start <= end) {
 80 |                 const mid = Math.ceil((start + end) / 2);
 81 | 
 82 |                 if (mid === 0 || dist[mid - 1] <= x && dist[mid] > x) {
 83 |                     index = mid;
 84 |                     break;
 85 |                 } else if (x < dist[mid]) {
 86 |                     end = mid - 1;
 87 |                 } else {
 88 |                     start = mid + 1;
 89 |                 }
 90 |             }
 91 | 
 92 |             return index;
 93 |         }
 94 | 
 95 |         sampleFace(faceIndex, targetPosition, targetNormal, targetColor) {
 96 |             let u = this.randomFunction();
 97 |             let v = this.randomFunction();
 98 | 
 99 |             if (u + v > 1) {
100 |                 u = 1 - u;
101 |                 v = 1 - v;
102 |             }
103 | 
104 |             _face.a.fromBufferAttribute(this.positionAttribute, faceIndex * 3);
105 |             _face.b.fromBufferAttribute(this.positionAttribute, faceIndex * 3 + 1);
106 |             _face.c.fromBufferAttribute(this.positionAttribute, faceIndex * 3 + 2);
107 | 
108 |             targetPosition.set(0, 0, 0).addScaledVector(_face.a, u).addScaledVector(_face.b, v).addScaledVector(_face.c, 1 - (u + v));
109 | 
110 |             if (targetNormal !== undefined) {
111 |                 _face.getNormal(targetNormal);
112 |             }
113 | 
114 |             if (targetColor !== undefined && this.colorAttribute !== undefined) {
115 |                 _face.a.fromBufferAttribute(this.colorAttribute, faceIndex * 3);
116 |                 _face.b.fromBufferAttribute(this.colorAttribute, faceIndex * 3 + 1);
117 |                 _face.c.fromBufferAttribute(this.colorAttribute, faceIndex * 3 + 2);
118 | 
119 |                 _color.set(0, 0, 0).addScaledVector(_face.a, u).addScaledVector(_face.b, v).addScaledVector(_face.c, 1 - (u + v));
120 | 
121 |                 targetColor.r = _color.x;
122 |                 targetColor.g = _color.y;
123 |                 targetColor.b = _color.z;
124 |             }
125 | 
126 |             return this;
127 |         }
128 |     }
129 | 
130 |     THREE.MeshSurfaceSampler = MeshSurfaceSampler;
131 | })();


--------------------------------------------------------------------------------
/love23/js/script.js:
--------------------------------------------------------------------------------
  1 | console.clear();
  2 | 
  3 | const scene = new THREE.Scene();
  4 | const camera = new THREE.PerspectiveCamera(75, window.innerWidth / window.innerHeight, 0.1, 1000);
  5 | const renderer = new THREE.WebGLRenderer({ antialias: true });
  6 | 
  7 | renderer.setClearColor(new THREE.Color("rgb(0,0,0)"));
  8 | renderer.setSize(window.innerWidth, window.innerHeight);
  9 | document.body.appendChild(renderer.domElement);
 10 | 
 11 | camera.position.z = 1.8;
 12 | 
 13 | const controls = new THREE.TrackballControls(camera, renderer.domElement);
 14 | controls.noPan = true;
 15 | controls.maxDistance = 3;
 16 | controls.minDistance = 0.7;
 17 | 
 18 | const group = new THREE.Group();
 19 | scene.add(group);
 20 | 
 21 | let heart = null;
 22 | let sampler = null;
 23 | let originHeart = null;
 24 | 
 25 | new THREE.OBJLoader().load("https://assets.codepen.io/127738/heart_2.obj", (obj) => {
 26 |     heart = obj.children[0];
 27 |     heart.geometry.rotateX(-Math.PI * 0.5);
 28 |     heart.geometry.scale(0.04, 0.04, 0.04);
 29 |     heart.geometry.translate(0, -0.4, 0);
 30 |     group.add(heart);
 31 | 
 32 |     heart.material = new THREE.MeshBasicMaterial({ color: new THREE.Color("rgb(0,0,0)") });
 33 |     originHeart = Array.from(heart.geometry.attributes.position.array);
 34 |     sampler = new THREE.MeshSurfaceSampler(heart).build();
 35 |     init();
 36 |     renderer.setAnimationLoop(render);
 37 | });
 38 | 
 39 | let positions = [];
 40 | let colors = [];
 41 | const geometry = new THREE.BufferGeometry();
 42 | const material = new THREE.PointsMaterial({ vertexColors: true, size: 0.009 });
 43 | const particles = new THREE.Points(geometry, material);
 44 | group.add(particles);
 45 | 
 46 | const simplex = new SimplexNoise();
 47 | const pos = new THREE.Vector3();
 48 | const palette = [
 49 |     new THREE.Color("#ffd4ee"),
 50 |     new THREE.Color("#ff77fc"),
 51 |     new THREE.Color("#ff77ae"),
 52 |     new THREE.Color("#ff1775"),
 53 | ];
 54 | 
 55 | class SparkPoint {
 56 |     constructor() {
 57 |         sampler.sample(pos);
 58 |         this.color = palette[Math.floor(Math.random() * palette.length)];
 59 |         this.rand = Math.random() * 0.03;
 60 |         this.pos = pos.clone();
 61 |         this.one = null;
 62 |         this.two = null;
 63 |     }
 64 | 
 65 |     update(a) {
 66 |         const noise = simplex.noise4D(this.pos.x * 1, this.pos.y * 1, this.pos.z * 1, 0.1) + 1.5;
 67 |         const noise2 = simplex.noise4D(this.pos.x * 500, this.pos.y * 500, this.pos.z * 500, 1) + 1;
 68 |         this.one = this.pos.clone().multiplyScalar(1.01 + noise * 0.15 * beat.a);
 69 |         this.two = this.pos.clone().multiplyScalar(1 + noise2 * 1 * (beat.a + 0.3) - beat.a * 1.2);
 70 |     }
 71 | }
 72 | 
 73 | let spikes = [];
 74 | 
 75 | function init() {
 76 |     positions = [];
 77 |     colors = [];
 78 |     for (let i = 0; i < 10000; i++) {
 79 |         const g = new SparkPoint();
 80 |         spikes.push(g);
 81 |     }
 82 | }
 83 | 
 84 | const beat = { a: 0 };
 85 | gsap.timeline({ repeat: -1, repeatDelay: 0.3 })
 86 |     .to(beat, { a: 0.5, duration: 0.6, ease: "power2.in" })
 87 |     .to(beat, { a: 0.0, duration: 0.6, ease: "power3.out" });
 88 | 
 89 | const maxZ = 0.23;
 90 | const rateZ = 0.5;
 91 | 
 92 | function render(a) {
 93 |     positions = [];
 94 |     colors = [];
 95 |     spikes.forEach((g, i) => {
 96 |         g.update(a);
 97 |         const rand = g.rand;
 98 |         const color = g.color;
 99 |         if (maxZ * rateZ + rand > g.one.z && g.one.z > -maxZ * rateZ - rand) {
100 |             positions.push(g.one.x, g.one.y, g.one.z);
101 |             colors.push(color.r, color.g, color.b);
102 |         }
103 |         if (maxZ * rateZ + rand * 2 > g.one.z && g.one.z > -maxZ * rateZ - rand * 2) {
104 |             positions.push(g.two.x, g.two.y, g.two.z);
105 |             colors.push(color.r, color.g, color.b);
106 |         }
107 |     });
108 | 
109 |     geometry.setAttribute("position", new THREE.BufferAttribute(new Float32Array(positions), 3));
110 |     geometry.setAttribute("color", new THREE.BufferAttribute(new Float32Array(colors), 3));
111 | 
112 |     const vs = heart.geometry.attributes.position.array;
113 |     for (let i = 0; i < vs.length; i += 3) {
114 |         const v = new THREE.Vector3(originHeart[i], originHeart[i + 1], originHeart[i + 2]);
115 |         const noise = simplex.noise4D(originHeart[i] * 1.5, originHeart[i + 1] * 1.5, originHeart[i + 2] * 1.5, a * 0.0005) + 1;
116 |         v.multiplyScalar(0 + noise * 0.15 * beat.a);
117 |         vs[i] = v.x;
118 |         vs[i + 1] = v.y;
119 |         vs[i + 2] = v.z;
120 |     }
121 |     heart.geometry.attributes.position.needsUpdate = true;
122 | 
123 |     controls.update();
124 |     renderer.render(scene, camera);
125 | }
126 | 
127 | window.addEventListener("resize", onWindowResize, false);
128 | 
129 | function onWindowResize() {
130 |     camera.aspect = window.innerWidth / window.innerHeight;
131 |     camera.updateProjectionMatrix();
132 |     renderer.setSize(window.innerWidth, window.innerHeight);
133 | }


--------------------------------------------------------------------------------
/love26/index.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html lang="en">
 3 | <head>
 4 |     <meta charset="UTF-8">
 5 |     <meta name="viewport" content="width=device-width, initial-scale=1.0">
 6 |     <link rel="stylesheet" href="style.css">
 7 |     <title>love</title>
 8 | </head>
 9 | <body>
10 |     <canvas id="c"></canvas>
11 |     <script src="script.js"></script>
12 | </body>
13 | </html>
14 | 


--------------------------------------------------------------------------------
/love26/script.js:
--------------------------------------------------------------------------------
  1 | const bodyElement = document.body;
  2 | const canvasElement = document.getElementsByTagName('canvas')[0];
  3 | const ctx = canvasElement.getContext('2d');
  4 | 
  5 | window.requestAnimFrame = (function() {
  6 |     return window.requestAnimationFrame ||
  7 |            window.webkitRequestAnimationFrame ||
  8 |            function(callback) {
  9 |                window.setTimeout(callback, 1000 / 60);
 10 |            };
 11 | })();
 12 | 
 13 | let mouseX = 0;
 14 | let mouseY = 0;
 15 | 
 16 | bodyElement.addEventListener('mousemove', function(event) {
 17 |     mouseX = event.pageX;
 18 |     mouseY = event.pageY;
 19 | });
 20 | 
 21 | bodyElement.addEventListener('click', function(event) {
 22 |     particles.forEach(particle => {
 23 |         particle.x = mouseX;
 24 |         particle.y = mouseY;
 25 |     });
 26 | });
 27 | 
 28 | const canvasWidth = window.innerWidth;
 29 | const canvasHeight = window.innerHeight;
 30 | const particleSizeFactor = Math.floor((canvasWidth * canvasHeight) / 29000);
 31 | const numParticles = 900;
 32 | const particles = [];
 33 | 
 34 | canvasElement.width = canvasWidth;
 35 | canvasElement.height = canvasHeight;
 36 | 
 37 | function initializeParticles() {
 38 |     for (let i = 0; i < numParticles; i++) {
 39 |         const particle = {
 40 |             x: canvasWidth / 2,
 41 |             y: canvasHeight / 2,
 42 |             angleControlA: Math.random() * 100000,
 43 |             angleControlB: 0,
 44 |             previousHeartState: 0,
 45 |             opacity: 0.1,
 46 |         };
 47 |         particle.angleControlB = particle.angleControlA;
 48 |         particles.push(particle);
 49 |     }
 50 | }
 51 | 
 52 | let heartPixelData = null;
 53 | 
 54 | function captureHeartShape() {
 55 |     ctx.fillStyle = "rgba(0, 0, 0, 1)";
 56 |     ctx.font = (canvasWidth * 0.8) + "px sans-serif";
 57 |     ctx.textAlign = "center";
 58 |     ctx.textBaseline = "middle";
 59 |     ctx.fillText('♥', canvasWidth / 2, canvasHeight / 2);
 60 | 
 61 |     try {
 62 |         heartPixelData = ctx.getImageData(0, 0, canvasWidth, canvasHeight).data;
 63 |     } catch (e) {
 64 |         console.error("Could not get image data:", e);
 65 |         return;
 66 |     }
 67 | 
 68 |     ctx.fillStyle = "rgba(0, 0, 0, 1)";
 69 |     ctx.fillRect(0, 0, canvasWidth, canvasHeight);
 70 | }
 71 | 
 72 | function render() {
 73 |     if (!heartPixelData) return;
 74 | 
 75 |     ctx.fillStyle = "rgba(0, 0, 0, 0.01)";
 76 |     ctx.fillRect(0, 0, canvasWidth, canvasHeight);
 77 | 
 78 |     particles.forEach(particle => {
 79 |         particle.angleControlA += Math.random() > 0.5 ? -1 : 1;
 80 |         particle.angleControlB -= (particle.angleControlB - particle.angleControlA) * 0.05;
 81 | 
 82 |         const angle = particle.angleControlB * 8;
 83 |         const radianAngle = angle * Math.PI / 180;
 84 |         particle.x += Math.cos(radianAngle);
 85 |         particle.y += Math.sin(radianAngle);
 86 | 
 87 |         const px = Math.floor(particle.x);
 88 |         const py = Math.floor(particle.y);
 89 | 
 90 |         let currentHeartValue = 0;
 91 |         if (px >= 0 && px < canvasWidth && py >= 0 && py < canvasHeight) {
 92 |             const pixelIndex = (px + (py * canvasWidth)) * 4;
 93 |             currentHeartValue = heartPixelData[pixelIndex + 3];
 94 |         }
 95 | 
 96 |         const isInHeart = currentHeartValue > 0;
 97 | 
 98 |         if ((isInHeart && !particle.previousHeartState) || (!isInHeart && particle.previousHeartState)) {
 99 |             particle.opacity = 0.05;
100 |         }
101 | 
102 |         particle.previousHeartState = isInHeart;
103 | 
104 |         if (isInHeart) {
105 |             particle.opacity += particle.opacity < 0.8 ? 0.03 : 0;
106 |             ctx.fillStyle = `rgba(255, 0, 0, ${particle.opacity})`;
107 |         } else {
108 |             particle.opacity += particle.opacity < 0.3 ? 0.01 : 0;
109 |             ctx.fillStyle = `rgba(255, 255, 255, ${particle.opacity})`;
110 |         }
111 | 
112 |         const wrapBuffer = particleSizeFactor;
113 |         if (particle.x > canvasWidth + wrapBuffer) particle.x = -wrapBuffer;
114 |         if (particle.x < -wrapBuffer) particle.x = canvasWidth + wrapBuffer;
115 |         if (particle.y > canvasHeight + wrapBuffer) particle.y = -wrapBuffer;
116 |         if (particle.y < -wrapBuffer) particle.y = canvasHeight + wrapBuffer;
117 | 
118 |         const deltaX = particle.x - canvasWidth / 2;
119 |         const deltaY = particle.y - canvasHeight / 2;
120 |         const distance = Math.sqrt(deltaX * deltaX + deltaY * deltaY);
121 |         const fontSizeBase = particleSizeFactor;
122 |         const dynamicFontSize = (distance < fontSizeBase * (fontSizeBase / 4) ? Math.floor(distance / (fontSizeBase / 4)) || 1 : fontSizeBase);
123 |         const finalFontSize = Math.max(1, dynamicFontSize);
124 |         ctx.font = finalFontSize + 'px Arial';
125 | 
126 |         ctx.fillText('❤', Math.floor(particle.x), Math.floor(particle.y));
127 |     });
128 | }
129 | 
130 | (function animationLoop() {
131 |     requestAnimFrame(animationLoop);
132 |     render();
133 | })();
134 | 
135 | initializeParticles();
136 | captureHeartShape();


--------------------------------------------------------------------------------
/love26/style.css:
--------------------------------------------------------------------------------
 1 | * {
 2 |     padding: 0;
 3 |     margin: 0;
 4 | }
 5 | #c {
 6 |     width: 100%;
 7 |     height: 100%;
 8 |     display: block;
 9 | 
10 | }


--------------------------------------------------------------------------------
/love28/index.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html lang="en">
 3 |   <head>
 4 |     <meta charset="UTF-8" />
 5 |     <title>Heart Animation</title> 
 6 |     <link rel="stylesheet" href="style.css" />
 7 |   </head>
 8 |   <body>
 9 |     <canvas id="c"></canvas>
10 |     <script src="script.js"></script>
11 |   </body>
12 | </html>


--------------------------------------------------------------------------------
/love28/script.js:
--------------------------------------------------------------------------------
  1 | (function() {
  2 | 
  3 |   const canvasElement = document.getElementById("c");
  4 |   const ctx = canvasElement.getContext("2d");
  5 | 
  6 |   const canvasWidth = canvasElement.width = 500;
  7 |   const canvasHeight = canvasElement.height = 500;
  8 |   const centerX = canvasWidth / 2;
  9 |   const centerY = canvasHeight / 2;
 10 | 
 11 |   const degreesToRadians = Math.PI / 180;
 12 |   const particleCount = 500;
 13 | 
 14 |   const particleInstances = [];
 15 | 
 16 |   const colorPalette = ["217,65,65", "240,223,223", "255,161,161", "237,126,126", "240,96,137"];
 17 | 
 18 |   ctx.strokeStyle = "white";
 19 |   ctx.globalAlpha = 0.7;
 20 | 
 21 |   function getRandomInteger(min, max) {
 22 |     return Math.floor(Math.random() * (max - min + 1)) + min;
 23 |   }
 24 | 
 25 |   class SparkleParticle {
 26 |     constructor() {
 27 |       this.radius = getRandomInteger(2, 12);
 28 | 
 29 |       const initialDist = Math.random() * 130 + 1;
 30 |       const initialAngle = Math.random() * 360;
 31 |       const angleInRadians = initialAngle * degreesToRadians;
 32 | 
 33 |       this.x = centerX + initialDist * Math.cos(angleInRadians);
 34 |       this.y = centerY + 25 + initialDist * Math.sin(angleInRadians);
 35 | 
 36 |       const speedFactor = Math.random();
 37 |       this.velocityX = speedFactor * (Math.random() < 0.5 ? -1 : 1);
 38 |       this.velocityY = speedFactor * (Math.random() < 0.5 ? -1 : 1);
 39 | 
 40 |       this.alpha = Math.random() * 0.8 + 0.1;
 41 |       const colorIndex = Math.floor(Math.random() * colorPalette.length);
 42 |       this.colorString = `rgba(${colorPalette[colorIndex]}, ${this.alpha})`;
 43 |     }
 44 | 
 45 |     move() {
 46 |         this.x += this.velocityX;
 47 |         this.y += this.velocityY;
 48 |     }
 49 | 
 50 |     reverseDirection() {
 51 |         this.velocityX *= -1;
 52 |         this.velocityY *= -1;
 53 |     }
 54 | 
 55 |     draw(context) {
 56 |         context.beginPath();
 57 |         context.arc(this.x, this.y, this.radius, 0, 2 * Math.PI);
 58 |         context.fillStyle = this.colorString;
 59 |         context.fill();
 60 |     }
 61 |   }
 62 | 
 63 |   for (let i = 0; i < particleCount; i++) {
 64 |     particleInstances.push(new SparkleParticle());
 65 |   }
 66 | 
 67 |   function defineHeartShape(particleRadius) {
 68 |     const heartSize = 100;
 69 |     const buffer = particleRadius;
 70 |     const effectiveRadius = heartSize - buffer;
 71 |     const safeRadius = Math.max(effectiveRadius, 1);
 72 | 
 73 |     const topCurveY = 200;
 74 |     const bottomPointY = 450;
 75 |     const leftCurveX = centerX - heartSize;
 76 |     const rightCurveX = centerX + heartSize;
 77 | 
 78 |     ctx.beginPath();
 79 |     ctx.moveTo(centerX, topCurveY);
 80 |     ctx.arc(rightCurveX, topCurveY, safeRadius, Math.PI, Math.PI * 0.23, false);
 81 |     ctx.lineTo(centerX, bottomPointY);
 82 |     ctx.arc(leftCurveX, topCurveY, safeRadius, Math.PI * 0.77, 0, false);
 83 |     ctx.closePath();
 84 |   }
 85 | 
 86 | 
 87 |   function renderAnimation() {
 88 |     ctx.fillStyle = "rgba(0, 0, 0, 0.1)";
 89 |     ctx.fillRect(0, 0, canvasWidth, canvasHeight);
 90 | 
 91 |     for (let i = 0; i < particleInstances.length; i++) {
 92 |       const particle = particleInstances[i];
 93 | 
 94 |       defineHeartShape(particle.radius);
 95 | 
 96 |       if (ctx.isPointInPath(particle.x, particle.y)) {
 97 |         particle.move();
 98 |         particle.draw(ctx);
 99 |       } else {
100 |         particle.reverseDirection();
101 |         particle.move();
102 |       }
103 |     }
104 | 
105 |     window.requestAnimationFrame(renderAnimation);
106 |   }
107 | 
108 |   window.requestAnimationFrame(renderAnimation);
109 | 
110 | })();


--------------------------------------------------------------------------------
/love28/style.css:
--------------------------------------------------------------------------------
 1 | * {
 2 |   margin: 0;
 3 |   padding: 0;
 4 |   overflow: hidden;
 5 |   background-color: #000;
 6 | }
 7 | 
 8 | #c {
 9 |   display: block;
10 |   margin: calc(50vh - 250px) auto; 
11 | }


--------------------------------------------------------------------------------
/love3/index.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html lang="en">
 3 | <head>
 4 |     <link rel="stylesheet" href="./style.css">
 5 | </head>
 6 | <body>
 7 |     <canvas id="cvs"></canvas>
 8 |     <script src="./script.js"></script>
 9 | </body>
10 | </html>
11 | 


--------------------------------------------------------------------------------
/love3/script.js:
--------------------------------------------------------------------------------
  1 | "use strict";
  2 | 
  3 | let W, H, ctx, ropes,stat,turn;
  4 | 
  5 | let mouse, touch;
  6 | let move = false;
  7 | 
  8 | const u = {
  9 |     drawC(x, y, r, c) {
 10 |         ctx.beginPath();
 11 |         ctx.fillStyle = c;
 12 |         ctx.arc(x, y, r, 0, 2*Math.PI);
 13 |         ctx.fill();
 14 |         ctx.closePath();
 15 |     },
 16 |     
 17 |     drawL(x0,y0,x, y, r, c) {
 18 |         ctx.beginPath();
 19 |         ctx.moveTo(x0,y0);
 20 |         ctx.lineWidth = r;
 21 |         ctx.strokeStyle = c;
 22 |         ctx.lineTo(x,y);
 23 |         
 24 |         ctx.stroke();
 25 |         ctx.closePath();
 26 |     },
 27 |     
 28 |     pick(max=1, min=0){
 29 |         return Math.random() * (max - min) + min;
 30 |     },
 31 |     
 32 |     ipick(max=1, min=0){
 33 |         return Math.round(Math.random() * (max - min) + min);
 34 |     },
 35 |     writeT(text,x,y){
 36 |         ctx.beginPath();
 37 | // The size is set with the font
 38 |         ctx.font = '25px serif';
 39 | // align position
 40 |         ctx.fillStyle = "yellow";
 41 |         ctx.textAlign = "center"; 
 42 |         ctx.textBaseline = "middle"; 
 43 | // draw text
 44 |         ctx.fillText(text,x,y);
 45 |         ctx.fill();
 46 |         ctx.closePath();}
 47 | };
 48 | 
 49 | class Rope{
 50 |     constructor(x,y,r,c,z){
 51 |         this.ref = {x:x, y:y};
 52 |         this.si=Math.min(0.05*this.ref.x,0.05*(W-this.ref.x),0.05*this.ref.y,0.05*(H-this.ref.y));
 53 |         this.d ={x:1, y:-1.3};
 54 |         this.z =z;
 55 |         this.r =r;
 56 |         this.c =c;
 57 |         this.ar =0;
 58 |         this.f=1;
 59 |         this.n=[];
 60 |         this.n.push(new Node(this.ref.x, this.ref.y,this.r,this.c));
 61 |         this.createCords();
 62 |     }
 63 |     createCords(){
 64 |     let a, b;
 65 |         for(let i=0;i<20;i++){
 66 |             a=this.n[0].x+5*(i+1);
 67 |             b=this.n[0].y+5*(i+1);
 68 |             let color=this.c;
 69 |             this.n.push(new Node(a,b,u.pick(),color));}
 70 |     }
 71 | // Controls movement
 72 |     update(idx) {
 73 |         for(let j=0;j<this.n.length;j++){
 74 | // parametric equations driven by increment in angle this.z for node 0
 75 |         if(!j){
 76 |         if(mouse.x&&(idx!=turn))continue;
 77 |         this.z+=0.01;
 78 |         let tx=Math.sin(this.z);
 79 |         this.n[j].x = mouse.x || this.ref.x+ (this.si*(16*tx*tx*tx));
 80 |         tx=this.z;
 81 |         this.n[j].y = mouse.y || this.ref.y-(this.si*(13*Math.cos(tx)-5*Math.cos(2*tx)- 2*Math.cos(3*tx) - Math.cos(4*tx)));
 82 | // reset position with touch
 83 |             if(mouse.x){this.ref.x=mouse.x;
 84 |                 if(mouse.y)this.ref.y=mouse.y;
 85 |                 this.ar=0; //not calculating
 86 |                 this.z%=6.3132;
 87 |                 turn++;
 88 |                 turn%=(ropes.length);
 89 |                 mouse.x=null;
 90 |                 mouse.y=null;
 91 |                 this.si=Math.min(0.05*this.ref.x,0.05*(W-this.ref.x),0.05*this.ref.y,0.05*(H-this.ref.y));
 92 |                 ctx.fillStyle = "rgba(24,0,151,0.95)";
 93 |                 ctx.fillRect(0, 0, W, H);}
 94 |         }
 95 |         else{
 96 |         this.n[j].x +=  (this.n[j-1].x-this.n[j].x) /(j+1) ;
 97 |         this.n[j].y +=  (this.n[j-1].y-this.n[j].y) /(j+1) ;
 98 |         }
 99 |     this.n[j].draw();
100 |     }
101 |     }
102 | }
103 | 
104 | class Node{
105 |     constructor(x,y,r,c){
106 |         this.x = x;
107 |         this.y = y;
108 |         this.r = r;
109 |         this.c = c;
110 |     }
111 |     draw() {
112 |         u.drawC(this.x, this.y, this.r, this.c);
113 |     }
114 |     check(ref,d,si,f){
115 |         //return(this.x>ref.x+(2*si)-1 || this.x<ref.x-(2*si)+1);
116 |         return(this.x>ref.x+(2*si) || this.x<ref.x-(2*si));
117 |     }
118 | }
119 | 
120 | const eventsListener = () => {
121 |     mouse = {
122 |         x: null,
123 |         y: null
124 |     };
125 |      touch = {
126 |         x: null,
127 |         y: null
128 |     };
129 | 
130 |     window.addEventListener("mousemove", function(event){
131 |         if(move){
132 |             mouse.x = event.clientX;
133 |             mouse.y = event.clientY;
134 |         }
135 |         else{
136 |             mouse.x = null;
137 |             mouse.y = null;
138 |         }
139 |     });
140 |     window.addEventListener("mousedown", function(event){
141 |         move=true;
142 |         mouse.x = event.clientX;
143 |         mouse.y = event.clientY;
144 |     });
145 |     window.addEventListener("mouseup", function(event){
146 |         move=false;
147 |     });
148 |     window.addEventListener("touchstart", function(event){
149 |         let touch = event.changedTouches[0];
150 |         let touchX = parseInt(touch.clientX);
151 |         let touchY = parseInt(touch.clientY);
152 |         mouse.x = touchX-cvs.offsetLeft;
153 |         mouse.y = touchY-cvs.offsetTop;
154 |         move=true;
155 |     });
156 |     
157 |     window.addEventListener("touchmove", function(event){
158 |         //event.preventDefault();
159 |         if(move){
160 |             let touch = event.changedTouches[0];
161 |             let touchX = parseInt(touch.clientX);
162 |             let touchY = parseInt(touch.clientY);
163 |             event.preventDefault();
164 |             mouse.x = touchX-cvs.offsetLeft;
165 |             mouse.y = touchY-cvs.offsetTop;
166 |         }
167 |     },{passive:false}); //*** thanks to SR
168 |     
169 |     window.addEventListener("touchend", function(event){
170 |         mouse.x = null;
171 |         mouse.y = null;
172 |         move=false;
173 |     });
174 | };
175 | 
176 | const animate = () => {
177 |     ctx.fillStyle = "rgba(24,0,151,0.015)";
178 |     ctx.fillRect(0, 0, W, H);
179 |     //ropes.forEach((x) => {x.update()});
180 |     ropes.forEach((x, idx) => {x.update(idx)});
181 |     if(stat){
182 |     u.writeT("x=16*sin**3(t); y=13*cos(t)-",0.5*W,0.85*H);
183 | u.writeT("5*cos(2t)- 2*cos(3t) - cos(4t)",0.5*W,0.9*H);
184 |     u.writeT("proves that love is irrational",0.5*W,0.95*H);}
185 |     requestAnimationFrame(animate);
186 | };
187 | 
188 | const init = () => {
189 |     ctx = document.querySelector("#cvs").getContext("2d");
190 |     W = ctx.canvas.width = innerWidth;
191 |     H = ctx.canvas.height = innerHeight;
192 |     turn=0;
193 |     stat=(window.confirm("Want to know the formula?"));
194 |     ropes=[];
195 |     ropes.push(new Rope(W*0.5, H*0.25,1,"hotpink",0.2));
196 |     //ropes.push(new Rope(W*0.25, H*0.25,5,"cyan"));
197 |     ropes.push(new Rope(W*0.5, H*0.25,2,"cyan",3.341));
198 |     //window.alert("Credit to Lolo for event handlers: touch or strife");
199 |     ctx.fillStyle = "rgba(24,0,151,0.99)";
200 |     ctx.fillRect(0, 0, W, H);
201 |     eventsListener();
202 |     requestAnimationFrame(animate);
203 | };
204 | 
205 | onload = init;
206 | 


--------------------------------------------------------------------------------
/love3/style.css:
--------------------------------------------------------------------------------
1 | body {
2 |     margin: 0;
3 |     height: 100vh;
4 |     user-select: none;
5 |     -webkit-user-select : none;
6 |     position: fixed;
7 | }


--------------------------------------------------------------------------------
/love4/index.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html lang="en">
 3 | <head>
 4 |     <meta charset="UTF-8">
 5 |     <meta name="viewport" content="width=device-width, initial-scale=1.0">
 6 |     <title>Heart Animation</title>
 7 |     <link rel="stylesheet" href="style.css">
 8 | </head>
 9 | <body>
10 |     <canvas id="pinkboard"></canvas>
11 |     <script src="script.js"></script>
12 | </body>
13 | </html>


--------------------------------------------------------------------------------
/love4/style.css:
--------------------------------------------------------------------------------
 1 | body, html {
 2 |     height: 100%;
 3 |     margin: 0;
 4 |     padding: 0;
 5 |     background: #000;
 6 |     display: flex;
 7 |     justify-content: center;
 8 |     align-items: center;
 9 |     overflow: hidden;
10 | }
11 | 
12 | #pinkboard {
13 |     position: absolute;
14 |     width: 100%;
15 |     height: 100%;
16 | }


--------------------------------------------------------------------------------
/love5/index.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html>
 3 |   <head>
 4 |     <title>heart aanimation</title>
 5 |     <meta name="Generator" content="EditPlus" />
 6 |     <meta name="Author" content="" />
 7 |     <meta name="Keywords" content="" />
 8 |     <meta name="Description" content="" />
 9 |     <link rel="stylesheet" href="styles.css" />
10 |   </head>
11 |   <body>
12 |     <div class="box">
13 |       <canvas id="pinkboard"></canvas> 
14 |     </div>
15 |     <script src="script.js"></script>
16 |   </body>
17 | </html>
18 | 


--------------------------------------------------------------------------------
/love5/script.js:
--------------------------------------------------------------------------------
  1 | var settings = {
  2 |   particles: {
  3 |     length: 10000,
  4 |     duration: 4,
  5 |     velocity: 80,
  6 |     effect: -1.3,
  7 |     size: 8,
  8 |   },
  9 | };
 10 | 
 11 | (function () {
 12 |   var b = 0;
 13 |   var c = ["ms", "moz", "webkit", "o"];
 14 |   for (var a = 0; a < c.length && !window.requestAnimationFrame; ++a) {
 15 |     window.requestAnimationFrame = window[c[a] + "RequestAnimationFrame"];
 16 |     window.cancelAnimationFrame =
 17 |       window[c[a] + "CancelAnimationFrame"] ||
 18 |       window[c[a] + "CancelRequestAnimationFrame"];
 19 |   }
 20 |   if (!window.requestAnimationFrame) {
 21 |     window.requestAnimationFrame = function (h, e) {
 22 |       var d = new Date().getTime();
 23 |       var f = Math.max(0, 16 - (d - b));
 24 |       var g = window.setTimeout(function () {
 25 |         h(d + f);
 26 |       }, f);
 27 |       b = d + f;
 28 |       return g;
 29 |     };
 30 |   }
 31 |   if (!window.cancelAnimationFrame) {
 32 |     window.cancelAnimationFrame = function (d) {
 33 |       clearTimeout(d);
 34 |     };
 35 |   }
 36 | })();
 37 | 
 38 | var Point = (function () {
 39 |   function Point(x, y) {
 40 |     this.x = typeof x !== "undefined" ? x : 0;
 41 |     this.y = typeof y !== "undefined" ? y : 0;
 42 |   }
 43 |   Point.prototype.clone = function () {
 44 |     return new Point(this.x, this.y);
 45 |   };
 46 |   Point.prototype.length = function (length) {
 47 |     if (typeof length == "undefined") {
 48 |       return Math.sqrt(this.x * this.x + this.y * this.y);
 49 |     }
 50 |     this.normalize();
 51 |     this.x *= length;
 52 |     this.y *= length;
 53 |     return this;
 54 |   };
 55 |   Point.prototype.normalize = function () {
 56 |     var length = this.length();
 57 |     this.x /= length;
 58 |     this.y /= length;
 59 |     return this;
 60 |   };
 61 |   return Point;
 62 | })();
 63 | 
 64 | var Particle = (function () {
 65 |   function Particle() {
 66 |     this.position = new Point();
 67 |     this.velocity = new Point();
 68 |     this.acceleration = new Point();
 69 |     this.age = 0;
 70 |   }
 71 |   Particle.prototype.initialize = function (x, y, dx, dy) {
 72 |     this.position.x = x;
 73 |     this.position.y = y;
 74 |     this.velocity.x = dx;
 75 |     this.velocity.y = dy;
 76 |     this.acceleration.x = dx * settings.particles.effect;
 77 |     this.acceleration.y = dy * settings.particles.effect;
 78 |     this.age = 0;
 79 |   };
 80 |   Particle.prototype.update = function (deltaTime) {
 81 |     this.position.x += this.velocity.x * deltaTime;
 82 |     this.position.y += this.velocity.y * deltaTime;
 83 |     this.velocity.x += this.acceleration.x * deltaTime;
 84 |     this.velocity.y += this.acceleration.y * deltaTime;
 85 |     this.age += deltaTime;
 86 |   };
 87 |   Particle.prototype.draw = function (context, image) {
 88 |     function ease(t) {
 89 |       return --t * t * t + 1;
 90 |     }
 91 |     var size = image.width * ease(this.age / settings.particles.duration);
 92 |     context.globalAlpha = 1 - this.age / settings.particles.duration;
 93 |     context.drawImage(
 94 |       image,
 95 |       this.position.x - size / 2,
 96 |       this.position.y - size / 2,
 97 |       size,
 98 |       size
 99 |     );
100 |   };
101 |   return Particle;
102 | })();
103 | 
104 | var ParticlePool = (function () {
105 |   var particles,
106 |     firstActive = 0,
107 |     firstFree = 0,
108 |     duration = settings.particles.duration;
109 | 
110 |   function ParticlePool(length) {
111 |     particles = new Array(length);
112 |     for (var i = 0; i < particles.length; i++) {
113 |       particles[i] = new Particle();
114 |     }
115 |   }
116 |   ParticlePool.prototype.add = function (x, y, dx, dy) {
117 |     particles[firstFree].initialize(x, y, dx, dy);
118 |     firstFree++;
119 |     if (firstFree == particles.length) firstFree = 0;
120 |     if (firstActive == firstFree) firstActive++;
121 |     if (firstActive == particles.length) firstActive = 0;
122 |   };
123 |   ParticlePool.prototype.update = function (deltaTime) {
124 |     var i;
125 |     if (firstActive < firstFree) {
126 |       for (i = firstActive; i < firstFree; i++) {
127 |         particles[i].update(deltaTime);
128 |       }
129 |     }
130 |     if (firstFree < firstActive) {
131 |       for (i = firstActive; i < particles.length; i++) {
132 |         particles[i].update(deltaTime);
133 |       }
134 |       for (i = 0; i < firstFree; i++) {
135 |         particles[i].update(deltaTime);
136 |       }
137 |     }
138 |     while (particles[firstActive].age >= duration && firstActive != firstFree) {
139 |       firstActive++;
140 |       if (firstActive == particles.length) firstActive = 0;
141 |     }
142 |   };
143 |   ParticlePool.prototype.draw = function (context, image) {
144 |     if (firstActive < firstFree) {
145 |       for (i = firstActive; i < firstFree; i++) {
146 |         particles[i].draw(context, image);
147 |       }
148 |     }
149 |     if (firstFree < firstActive) {
150 |       for (i = firstActive; i < particles.length; i++) {
151 |         particles[i].draw(context, image);
152 |       }
153 |       for (i = 0; i < firstFree; i++) {
154 |         particles[i].draw(context, image);
155 |       }
156 |     }
157 |   };
158 |   return ParticlePool;
159 | })();
160 | 
161 | (function (canvas) {
162 |   var context = canvas.getContext("2d"),
163 |     particles = new ParticlePool(settings.particles.length),
164 |     particleRate = settings.particles.length / settings.particles.duration,
165 |     time;
166 | 
167 |   function pointOnHeart(t) {
168 |     return new Point(
169 |       160 * Math.pow(Math.sin(t), 3),
170 |       130 * Math.cos(t) -
171 |         50 * Math.cos(2 * t) -
172 |         20 * Math.cos(3 * t) -
173 |         10 * Math.cos(4 * t) +
174 |         25
175 |     );
176 |   }
177 | 
178 |   var image = (function () {
179 |     var canvas = document.createElement("canvas"),
180 |       context = canvas.getContext("2d");
181 |     canvas.width = settings.particles.size;
182 |     canvas.height = settings.particles.size;
183 | 
184 |     function to(t) {
185 |       var point = pointOnHeart(t);
186 |       point.x =
187 |         settings.particles.size / 2 + (point.x * settings.particles.size) / 350;
188 |       point.y =
189 |         settings.particles.size / 2 - (point.y * settings.particles.size) / 350;
190 |       return point;
191 |     }
192 | 
193 |     context.beginPath();
194 |     var t = -Math.PI;
195 |     var point = to(t);
196 |     context.moveTo(point.x, point.y);
197 |     while (t < Math.PI) {
198 |       t += 0.01;
199 |       point = to(t);
200 |       context.lineTo(point.x, point.y);
201 |     }
202 |     context.closePath();
203 |     context.fillStyle = "#f50b02";
204 |     context.fill();
205 | 
206 |     var image = new Image();
207 |     image.src = canvas.toDataURL();
208 |     return image;
209 |   })();
210 | 
211 |   function render() {
212 |     requestAnimationFrame(render);
213 | 
214 |     var newTime = new Date().getTime() / 1000,
215 |       deltaTime = newTime - (time || newTime);
216 |     time = newTime;
217 | 
218 |     context.clearRect(0, 0, canvas.width, canvas.height);
219 | 
220 |     var amount = particleRate * deltaTime;
221 |     for (var i = 0; i < amount; i++) {
222 |       var pos = pointOnHeart(Math.PI - 2 * Math.PI * Math.random());
223 |       var dir = pos.clone().length(settings.particles.velocity);
224 |       particles.add(
225 |         canvas.width / 2 + pos.x,
226 |         canvas.height / 2 - pos.y,
227 |         dir.x,
228 |         -dir.y
229 |       );
230 |     }
231 | 
232 |     particles.update(deltaTime);
233 |     particles.draw(context, image);
234 |   }
235 | 
236 |   function onResize() {
237 |     canvas.width = canvas.clientWidth;
238 |     canvas.height = canvas.clientHeight;
239 |   }
240 |   window.onresize = onResize;
241 | 
242 |   setTimeout(function () {
243 |     onResize();
244 |     render();
245 |   }, 10);
246 | })(document.getElementById("pinkboard"));
247 | 


--------------------------------------------------------------------------------
/love5/styles.css:
--------------------------------------------------------------------------------
 1 | html,
 2 | body {
 3 |   height: 100%;
 4 |   padding: 0;
 5 |   margin: 0;
 6 |   background: rgba(0, 0, 0, 0.851);
 7 | }
 8 | canvas {
 9 |   position: absolute;
10 |   width: 100%;
11 |   height: 100%;
12 | }
13 | 


--------------------------------------------------------------------------------
/love7/index.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html lang="en">
 3 | 
 4 | <head>
 5 |   <meta charset="UTF-8">
 6 |   <meta name="viewport" content="width=device-width, initial-scale=1.0">
 7 |   <title>3D love</title>
 8 |   <link rel="stylesheet" href="style.css">
 9 | </head>
10 | 
11 | <body>
12 |   <main>
13 |     <section>
14 |       <div>
15 |         <canvas id="canvas"></canvas>
16 |         <h2>I love you</h2>
17 |       </div>
18 |     </section>
19 |   </main>
20 | 
21 |   <script async src="https://ga.jspm.io/npm:es-module-shims@1.6.3/dist/es-module-shims.js" crossorigin="anonymous"></script>
22 | 
23 |   <script type="importmap">
24 |     {
25 |       "imports": {
26 |         "three": "https://unpkg.com/three@0.154.0/build/three.module.js",
27 |         "three/addons/": "https://unpkg.com/three@0.154.0/examples/jsm/",
28 |         "three-mesh-bvh": "https://unpkg.com/three-mesh-bvh@0.6.0/build/index.module.js",
29 |         "three-bvh-csg": "https://unpkg.com/three-bvh-csg@0.0.7/build/index.module.js"
30 |       }
31 |     }
32 |   </script>
33 | 
34 |   <script type="module" src="script.js"></script>
35 | </body>
36 | 
37 | </html>
38 | 


--------------------------------------------------------------------------------
/love7/script.js:
--------------------------------------------------------------------------------
  1 | import * as THREE from "three";
  2 | import { OrbitControls as e } from "three/addons/controls/OrbitControls.js";
  3 | import * as BufferGeometryUtils from "three/addons/utils/BufferGeometryUtils.js";
  4 | import { SUBTRACTION as t, Brush as n, Evaluator as r } from "three-bvh-csg";
  5 | 
  6 | !(function () {
  7 |   "use strict";
  8 |   function a() {
  9 |     ((E = new THREE.Scene()).environment = w),
 10 |       (l = new THREE.WebGLRenderer({
 11 |         canvas: canvas,
 12 |         antialias: !0,
 13 |         alpha: !0
 14 |       })).setPixelRatio(window.devicePixelRatio),
 15 |       l.setSize(window.innerWidth, window.innerHeight),
 16 |       (l.useLegacyLights = !1),
 17 |       (s = new THREE.PerspectiveCamera(
 18 |         35,
 19 |         window.innerWidth / window.innerHeight,
 20 |         0.1,
 21 |         3 * H
 22 |       )).position.set(0, 0, H * Math.sqrt(2)),
 23 |       s.lookAt(0, 0, 0);
 24 |     const a = new THREE.AmbientLight(16777215, 0.3);
 25 |     E.add(a);
 26 |     const u = new THREE.DirectionalLight(16777215, 1);
 27 |     u.position.set(0, 2 * H, 0),
 28 |       E.add(u),
 29 |       (E.fog = new THREE.FogExp2(16101802, 0.005)),
 30 |       (m = new THREE.MeshStandardMaterial({
 31 |         metalness: 1,
 32 |         roughness: 0
 33 |       })),
 34 |       (p = []),
 35 |       (c = c = new THREE.CapsuleGeometry(3, 6, 5, 20)).rotateZ(-Math.PI / 3.78),
 36 |       c.translate(0, -1, 0),
 37 |       c.scale(1, 1, 0.85),
 38 |       c.scale(0.24, 0.24, 0.24),
 39 |       (c = (function (e) {
 40 |         let a,
 41 |           o,
 42 |           i,
 43 |           s,
 44 |           E = e.clone(),
 45 |           l = new THREE.MeshBasicMaterial({}),
 46 |           d = 2 * c.parameters.radius,
 47 |           m = 2 * c.parameters.height,
 48 |           h = new THREE.BoxGeometry(d, m, d);
 49 |         return (
 50 |           h.translate(-d / 2, 0, 0),
 51 |           (a = new r()),
 52 |           (o = new n(E, l)),
 53 |           (i = new n(h, l)),
 54 |           (a.useGroups = !0),
 55 |           (s = a.evaluate(o, i, t, s)).geometry
 56 |         );
 57 |       })(c)),
 58 |       p.push(c),
 59 |       (c = c.clone()).rotateY(Math.PI),
 60 |       p.push(c),
 61 |       (c = BufferGeometryUtils.mergeGeometries(p)),
 62 |       (c = BufferGeometryUtils.mergeVertices(c)).computeVertexNormals();
 63 |     const M = new THREE.Color(),
 64 |       T = new THREE.Matrix4();
 65 |     h = new THREE.InstancedMesh(c, m, R);
 66 |     for (let e = 0; e < R; e++)
 67 |       g(T),
 68 |         h.setMatrixAt(e, T),
 69 |         h.setColorAt(
 70 |           e,
 71 |           M.setHSL(
 72 |             Math.abs(THREE.MathUtils.randInt(9750, 1e4) / 1e4),
 73 |             1,
 74 |             THREE.MathUtils.randInt(450, 700) / 1e3
 75 |           )
 76 |         );
 77 |     E.add(h);
 78 |     (c = new THREE.SphereGeometry(0.3, 20, 10)),
 79 |       (m = m.clone()).color.set("deeppink"),
 80 |       (m.roughness = 0.3),
 81 |       (h = new THREE.InstancedMesh(c, m, 220));
 82 |     for (let e = 0; e < 220; e++) g(T), h.setMatrixAt(e, T);
 83 |     E.add(h),
 84 |       ((d = new e(s, l.domElement)).autoRotate = !0),
 85 |       (d.enableDamping = !0),
 86 |       (d.enablePan = !1),
 87 |       (d.minDistance = 0.1),
 88 |       (d.maxDistance = H * Math.sqrt(2)),
 89 |       (d.minPolarAngle = 0),
 90 |       (d.maxPolarAngle = Math.PI / 2),
 91 |       d.target.set(0, 0, 0),
 92 |       d.update(),
 93 |       window.addEventListener("resize", o),
 94 |       i();
 95 |   }
 96 |   function o() {
 97 |     (s.aspect = window.innerWidth / window.innerHeight),
 98 |       s.updateProjectionMatrix(),
 99 |       l.setSize(window.innerWidth, window.innerHeight);
100 |   }
101 |   function i() {
102 |     requestAnimationFrame(i), d.update(), l.render(E, s);
103 |   }
104 |   let s,
105 |     E,
106 |     l,
107 |     d,
108 |     c,
109 |     m,
110 |     h,
111 |     w,
112 |     u,
113 |     p = [];
114 |   const R = 700,
115 |     H = 50,
116 |     g = (function () {
117 |       const e = new THREE.Vector3(),
118 |         t = new THREE.Euler(),
119 |         n = new THREE.Quaternion(),
120 |         r = new THREE.Vector3();
121 |       return function (a) {
122 |         (e.x = (2 * Math.random() - 1) * H),
123 |           (e.y = (2 * Math.random() - 1) * H),
124 |           (e.z = (2 * Math.random() - 1) * H),
125 |           (t.x = 0),
126 |           (t.z = 2 * Math.random() * Math.PI),
127 |           (t.y = 2 * Math.random() * Math.PI),
128 |           n.setFromEuler(t),
129 |           r.set(1, 1, 1),
130 |           a.compose(e, n, r);
131 |       };
132 |     })();
133 |   (u = new THREE.TextureLoader()).setCrossOrigin(""),
134 |     u.load(
135 |       "https://happy358.github.io/Images/HDR/kloofendal_48d_partly_cloudy_puresky_2k.jpg",
136 |       function (e) {
137 |         (e.colorSpace = THREE.SRGBColorSpace),
138 |           (e.minFilter = THREE.NearestFilter),
139 |           (e.generateMipmaps = !1),
140 |           (e.mapping = THREE.EquirectangularReflectionMapping),
141 |           (w = e),
142 |           a();
143 |       }
144 |     );
145 | })();
146 | 


--------------------------------------------------------------------------------
/love7/style.css:
--------------------------------------------------------------------------------
 1 | @import url("https://fonts.googleapis.com/css2?family=Asap&display=swap");
 2 | * {
 3 |   margin: 0;
 4 |   padding: 0;
 5 |   box-sizing: border-box;
 6 | }
 7 | html,
 8 | body {
 9 |   background: pink;
10 |   overscroll-behavior-x: none;
11 |   overscroll-behavior-y: none;
12 | }
13 | body {
14 |   font-family: "Asap", sans-serif;
15 |   position: relative;
16 |   width: 100vw;
17 |   min-height: 100vh;
18 |   text-align: center;
19 |   overflow-x: hidden;
20 |   color: white;
21 |   font-size: 8.0rem;
22 | }
23 | 
24 | canvas {
25 |   -moz-user-select: none;
26 |   -webkit-user-select: none;
27 |   -ms-user-select: none;
28 |   user-select: none;
29 |   pointer-events: none;
30 |   position: fixed;
31 |   width: 100vw;
32 |   height: 100vh;
33 |   top: 0;
34 |   left: 0;
35 | 
36 | }
37 | h2 {
38 |   position: relative;
39 |   color: rgb(255, 253, 254);
40 | }
41 | section {
42 |   position: relative;
43 |   width: 100vw;
44 |   min-height: 100vh;
45 |   display: flex;
46 |   align-items: center;
47 |   justify-content: center;
48 | }
49 | #arrow {
50 |   position: absolute;
51 |   bottom: 2vh;
52 |   left: 0;
53 |   right: 0;
54 |   font-size: 30vmin;
55 |   transform-origin: center center;
56 |   transform: rotate(90deg);
57 |   animation: arrow 2s 0s ease infinite;
58 | }
59 | @keyframes arrow {
60 |   0% {
61 |     opacity: 1;
62 |   }
63 |   50% {
64 |     opacity: 0;
65 |   }
66 |   100% {
67 |     opacity: 1;
68 |   }
69 | }
70 | 


--------------------------------------------------------------------------------
/mangu.py:
--------------------------------------------------------------------------------
 1 | import time
 2 | from threading import Thread, Lock
 3 | import sys
 4 | 
 5 | lock = Lock()
 6 | 
 7 | def animate_text(text, delay=0.1):
 8 |     with lock:
 9 |         for char in text:
10 |             sys.stdout.write(char)
11 |             sys.stdout.flush()
12 |             time.sleep(delay)
13 |         print()
14 | 
15 | def sing_lyric(lyric, delay, speed):
16 |     time.sleep(delay)
17 |     animate_text(lyric, speed)
18 | 
19 | def sing_lyric_part(lyric_part, delay, speed, add_newline=False):
20 |     time.sleep(delay)
21 |     with lock:
22 |         for char in lyric_part:
23 |             sys.stdout.write(char)
24 |             sys.stdout.flush()
25 |             time.sleep(speed)
26 |         if add_newline:
27 |             print()  
28 | 
29 | def sing_song():
30 |     lyrics = [
31 |         # ("\nJangan salahkan faham ku kini tertuju oh", 0.10),
32 |         ("Siapa yang tau", 0.11),
33 |         ("Siapa yang mau", 0.11),
34 |         ("Kau di sana", 0.10),
35 |         ("Aku diseberangmu\n", 0.11),
36 |         # ("Cerita kita sulit dicerna", 0.10),
37 |         ("Tak lagi sama", 0.10),
38 |         ("Cara berdoa\n", 0.10),
39 |         # ("Cerita kita sulit diterka", 0.10),
40 |         ("Tak lagi sama", 0.10),
41 |         ("Arah kiblatnya", 0.10),
42 |     ]
43 |     
44 |     delays = [9.6, 12.3, 15.5, 17.0, 25.2, 28.0, 35.7, 38.2]
45 |     
46 |     threads = []
47 |     for i in range(0):
48 |         lyric, speed = lyrics[i]
49 |         t = Thread(target=sing_lyric, args=(lyric, delays[i], speed))
50 |         threads.append(t)
51 |         t.start()
52 |     
53 |     t_0 = Thread(target=sing_lyric_part, args=("\nJangan salahkan faham ku kini ", 0.3, 0.13, False))
54 |     t_1 = Thread(target=sing_lyric_part, args=("tertuju oh", 5.8, 0.13, True))
55 |     threads.extend([t_0, t_1])
56 |     t_0.start()
57 |     t_1.start()
58 | 
59 |     t_2 = Thread(target=sing_lyric_part, args=("Cerita kita ", 20.2, 0.13, False))
60 |     t_3 = Thread(target=sing_lyric_part, args=("sulit dicerna", 22.7, 0.13, True))
61 |     threads.extend([t_2, t_3])
62 |     t_2.start()
63 |     t_3.start()
64 | 
65 |     t_4 = Thread(target=sing_lyric_part, args=("Cerita kita ", 30.2, 0.13, False))
66 |     t_5 = Thread(target=sing_lyric_part, args=("sulit diterka", 32.7, 0.13, True))
67 |     threads.extend([t_4, t_5])
68 |     t_4.start()
69 |     t_5.start()
70 | 
71 |     for i in range(len(lyrics)):
72 |         lyric, speed = lyrics[i]
73 |         t = Thread(target=sing_lyric, args=(lyric, delays[i], speed))
74 |         threads.append(t)
75 |         t.start()
76 | 
77 |     
78 |     for thread in threads:
79 |         thread.join()
80 | 
81 | if __name__ == "__main__":
82 |     sing_song()
83 | 


--------------------------------------------------------------------------------
/masa depanmu.py:
--------------------------------------------------------------------------------
 1 | import time
 2 | from threading import Thread, Lock
 3 | import sys
 4 | 
 5 | lock = Lock()
 6 | RED = '\033[91m'
 7 | RESET = '\033[0m'
 8 | 
 9 | def animate_text(text, delay=0.1, color_info=None):
10 |     with lock:
11 |         use_red = True
12 |         for char in text:
13 |             if color_info and char == color_info:
14 |                 color = f"{RED}{char}{RESET}" if use_red else char
15 |                 sys.stdout.write(color)
16 |                 use_red = not use_red
17 |             else:
18 |                 sys.stdout.write(char)
19 |             sys.stdout.flush()
20 |             time.sleep(delay)
21 |         print()
22 | 
23 | def sing_lyric(lyric, delay, speed, color_char):
24 |     time.sleep(delay)
25 |     animate_text(lyric, speed, color_char)
26 | 
27 | def sing_song():
28 |     lyrics = [
29 |         ("\nA A A A A A A A A A Aku akan beritahu pada dunia", 0.08, 'A'),
30 |         ("kau begitu indah", 0.08, None),
31 |         ("yang pernah ku punya", 0.08, None),
32 |         ("A A A A Aku akan selalu menemani dirimu", 0.08, 'A'),
33 |         ("U U U U U U Ucap Terima kasih untuk dirimu", 0.09, 'U'),
34 |         ("kita membuat memori sampai ahkhir hayat nanti", 0.08, None),
35 |         ("cinta ku tak pernah mati jadi kau tak perlu worry", 0.07, None),
36 |         ("genggam tanganku tak perlu ragu", 0.08, None),
37 |         ("habiskan waktu hanya bersama dirimu", 0.08, None),
38 |     ]
39 |     
40 |     delays = [0.3, 5.0, 6.8, 8.0, 11.3, 15.3, 18.6, 22.7, 26.0]
41 |     
42 |     threads = []
43 |     for i in range(len(lyrics)):
44 |         lyric, speed, color_char = lyrics[i]
45 |         t = Thread(target=sing_lyric, args=(lyric, delays[i], speed, color_char))
46 |         threads.append(t)
47 |         t.start()
48 |     
49 |     for thread in threads:
50 |         thread.join()
51 | 
52 | if __name__ == "__main__":
53 |     sing_song()


--------------------------------------------------------------------------------
/masa lalumu.py:
--------------------------------------------------------------------------------
 1 | import time
 2 | from threading import Thread, Lock
 3 | import sys
 4 | 
 5 | lock = Lock()
 6 | 
 7 | def animate_text(text, delay=0.1):
 8 |     with lock:
 9 |         for char in text:
10 |             sys.stdout.write(char)
11 |             sys.stdout.flush()
12 |             time.sleep(delay)
13 |         print()
14 | 
15 | def sing_lyric(lyric, delay, speed):
16 |     time.sleep(delay)
17 |     animate_text(lyric, speed)
18 | 
19 | def sing_song():
20 |     lyrics = [
21 |         ("\nKAU KAU KAU tak pernah katakan", 0.08),
22 |         ("Apa kurangnya ku untukmu", 0.07),
23 |         ("Namun ku tak sebanding", 0.07),
24 |         ("Meskipun aku di sampingmu", 0.07),
25 |         ("Dan kau masih cinta yang lalu", 0.06),
26 |         ("Dia pergi, kau menunggu", 0.06),
27 |         ("Baik kau pergi berhenti bebani diriku", 0.08),
28 |     ]
29 |     delays = [0.3, 2.5, 4.7, 6.2, 8.1, 10.4, 12.2]
30 |     
31 |     threads = []
32 |     for i in range(len(lyrics)):
33 |         lyric, speed = lyrics[i]
34 |         t = Thread(target=sing_lyric, args=(lyric, delays[i], speed))
35 |         threads.append(t)
36 |         t.start()
37 |     
38 |     for thread in threads:
39 |         thread.join()
40 | 
41 | if __name__ == "__main__":
42 |     sing_song()


--------------------------------------------------------------------------------
/multo.py:
--------------------------------------------------------------------------------
 1 | import time
 2 | from threading import Thread, Lock
 3 | import sys
 4 | 
 5 | lock = Lock()
 6 | 
 7 | def animate_text(text, delay=0.1):
 8 |     with lock:
 9 |         for char in text:
10 |             sys.stdout.write(char)
11 |             sys.stdout.flush()
12 |             time.sleep(delay)
13 |         print()
14 | 
15 | def sing_lyric(lyric, delay, speed):
16 |     time.sleep(delay)
17 |     animate_text(lyric, speed)
18 | 
19 | def sing_song():
20 |     lyrics = [
21 |         ("\nDi mo ba ako lilisanin?", 0.13),
22 |         ("Hindi pa ba sapat pagpapahirap sa 'kin?", 0.10),
23 |         ("Hindi na ba ma-mamamayapa?", 0.12),
24 |         ("Hindi na ba ma-mamamayapa?", 0.12),
25 |         ("\nHindi na makalaya...", 0.13)
26 |     ]
27 |     delays = [0.3, 4.8, 9.5, 14.0, 17.3]
28 |     
29 |     threads = []
30 |     for i in range(len(lyrics)):
31 |         lyric, speed = lyrics[i]
32 |         t = Thread(target=sing_lyric, args=(lyric, delays[i], speed))
33 |         threads.append(t)
34 |         t.start()
35 |     
36 |     for thread in threads:
37 |         thread.join()
38 | 
39 | if __name__ == "__main__":
40 |     sing_song()
41 | 


--------------------------------------------------------------------------------
/nan ko paham.py:
--------------------------------------------------------------------------------
 1 | import time
 2 | from threading import Thread, Lock
 3 | import sys
 4 | 
 5 | lock = Lock()
 6 | 
 7 | def animate_text(text, delay=0.1):
 8 |     with lock:
 9 |         for char in text:
10 |             sys.stdout.write(char)
11 |             sys.stdout.flush()
12 |             time.sleep(delay)
13 |         print()  
14 | 
15 | def sing_lyric(lyric, delay, speed):
16 |     time.sleep(delay)
17 |     animate_text(lyric, speed)
18 |     
19 | def sing_lyric_part(lyric_part, delay, speed, add_newline=False):
20 |     time.sleep(delay)
21 |     with lock:
22 |         for char in lyric_part:
23 |             sys.stdout.write(char)
24 |             sys.stdout.flush()
25 |             time.sleep(speed)
26 |         if add_newline:
27 |             print()  
28 | 
29 | def sing_song():
30 |     lyrics = [
31 |         ("\nSu jauh sa tanam hati tapi tra hasil", 0.08),
32 |         ("Cobalah dewasa ko su bukan anak kecil", 0.09),
33 |         ("Sa coba imbangi namun hati tra kuat", 0.09),
34 |         ("Tersiksa makan hati dan itu sa su muak\n", 0.09),
35 |         # ("Nanti pasti ko mengerti", 0.13), 
36 |         ("Stelah sa hilang dan sa jauh untuk pergi", 0.12),
37 |         ("Ko akan tau bagaimana sa sayang ko tapi", 0.11),
38 |         ("Sa rasa percuma ko terus ungkit", 0.10),
39 |         # ("Ungkit luka lama yang buat sa trauma", 0.13),
40 |     ]
41 |     
42 |     delays = [0.3, 4.0, 7.7, 11.3, 14.6, 17.3, 21.9, 29.3, 34.7, 39.6, 42.9]
43 |     
44 |     threads = []
45 |     for i in range(4):
46 |         lyric, speed = lyrics[i]
47 |         t = Thread(target=sing_lyric, args=(lyric, delays[i], speed))
48 |         threads.append(t)
49 |         t.start()
50 |     
51 |     t_nanti = Thread(target=sing_lyric_part, args=("Nanti ", delays[4], 0.13, False))
52 |     threads.append(t_nanti)
53 |     t_nanti.start()
54 | 
55 |     t_pasti = Thread(target=sing_lyric_part, args=("pasti ko mengerti", delays[5], 0.13, True))
56 |     threads.append(t_pasti)
57 |     t_pasti.start()
58 | 
59 |     t_ungkit = Thread(target=sing_lyric_part, args=("Ungkit luka lama ", delays[9], 0.12, False))
60 |     threads.append(t_ungkit)
61 |     t_ungkit.start()
62 | 
63 |     t_trauma = Thread(target=sing_lyric_part, args=("yang buat sa trauma", delays[10], 0.12, True))
64 |     threads.append(t_trauma)
65 |     t_trauma.start()
66 |     
67 |     for i in range(4, len(lyrics)):
68 |         lyric, speed = lyrics[i]
69 |         t = Thread(target=sing_lyric, args=(lyric, delays[i+2], speed))
70 |         threads.append(t)
71 |         t.start()
72 |     
73 |     for thread in threads:
74 |         thread.join()
75 | 
76 | if __name__ == "__main__":
77 |     sing_song()


--------------------------------------------------------------------------------
/perfect onedireection.py:
--------------------------------------------------------------------------------
 1 | import time
 2 | from threading import Thread, Lock
 3 | import sys
 4 | 
 5 | lock = Lock()
 6 | 
 7 | def animate_text(text, delay=0.1):
 8 |     with lock:
 9 |         for char in text:
10 |             sys.stdout.write(char)
11 |             sys.stdout.flush()
12 |             time.sleep(delay)
13 |         print()
14 | 
15 | def sing_lyric(lyric, delay, speed):
16 |     time.sleep(delay)
17 |     animate_text(lyric, speed)
18 | 
19 | def sing_song():
20 |     lyrics = [
21 |         ("\n""And if you like midnight driving with the windows down", 0.08),
22 |         ("And if you like going places we can't even pronounce", 0.08),
23 |         ("If you like to do whatever you've been dreaming about", 0.08),
24 |         ("Then baby, you're perfect", 0.05),
25 |         ("Baby, you're perfect", 0.05),
26 |         ("So let's start right now""\n", 0.05),
27 |     ]
28 |     
29 |     delays = [0.3, 5.2, 10.0, 15.0, 17.5, 19.5]
30 |     
31 |     threads = []
32 |     for i in range(len(lyrics)):
33 |         lyric, speed = lyrics[i]
34 |         t = Thread(target=sing_lyric, args=(lyric, delays[i], speed))
35 |         threads.append(t)
36 |         t.start()
37 |     
38 |     for thread in threads:
39 |         thread.join()
40 | 
41 | if __name__ == "__main__":
42 |     sing_song()


--------------------------------------------------------------------------------
/right now.py:
--------------------------------------------------------------------------------
 1 | import time
 2 | from threading import Thread, Lock
 3 | import sys
 4 | 
 5 | lock = Lock()
 6 | 
 7 | def animate_text(text, delay=0.1):
 8 |     with lock:
 9 |         for char in text:
10 |             sys.stdout.write(char)
11 |             sys.stdout.flush()
12 |             time.sleep(delay)
13 |         print()
14 | 
15 | def sing_lyric(lyric, delay, speed):
16 |     time.sleep(delay)
17 |     animate_text(lyric, speed)
18 | 
19 | def sing_song():
20 |     lyrics = [
21 |         ("Right now", 0.11),
22 |         ("I wish you were here with me", 0.07),
23 |         ("Cause right now", 0.09),
24 |         ("Everything is new to me", 0.09),
25 |         ("You know I can't fight the feeling", 0.10),
26 |         ("And every night I feel it", 0.09),
27 |         ("Right now", 0.11),
28 |         ("I wish you were here with me", 0.07),
29 |     ]
30 |     delays = [0.3, 2.2, 7.5, 10.0, 16.2, 20.5, 24.0, 26.0]
31 |     
32 |     threads = []
33 |     for i in range(len(lyrics)):
34 |         lyric, speed = lyrics[i]
35 |         t = Thread(target=sing_lyric, args=(lyric, delays[i], speed))
36 |         threads.append(t)
37 |         t.start()
38 |     
39 |     for thread in threads:
40 |         thread.join()
41 | 
42 | if __name__ == "__main__":
43 |     sing_song()
44 | 


--------------------------------------------------------------------------------
/seandainya.py:
--------------------------------------------------------------------------------
 1 | import time
 2 | from threading import Thread, Lock
 3 | import sys
 4 | 
 5 | lock = Lock()
 6 | 
 7 | def animate_text(text, delay=0.1):
 8 |     with lock:
 9 |         for char in text:
10 |             sys.stdout.write(char)
11 |             sys.stdout.flush()
12 |             time.sleep(delay)
13 |         print()
14 | 
15 | def sing_lyric(lyric, delay, speed):
16 |     time.sleep(delay)
17 |     animate_text(lyric, speed)
18 | 
19 | def sing_song():
20 |     lyrics = [
21 |         ("Kelak kau kan menjalani hidupmu sendiri", 0.1),
22 |         ("Melukai kenangan yang telah kita lalui", 0.09),
23 |         ("Yang tersisa hanya aku sendiri di sini", 0.09),
24 |         ("Kau akan terbang jauh menembus awan", 0.09),
25 |         ("Memulai kisah baru tanpa diriku", 0.09),
26 |         ("\n""Seandainya kau tau ku tak ingin kau pergi", 0.10),
27 |         ("Meninggalkan ku sendiri bersama bayanganku", 0.10),
28 |         ("Seandainya kau tau aku kan selalu cinta", 0.10),
29 |         ("Jangan kau lupakan kenangan kita selama ini", 0.1)
30 |     ]
31 |     delays = [0.3, 7.0, 14.0, 20.7, 27.5, 35.3, 44.0, 49.0, 57.4]
32 |     
33 |     threads = []
34 |     for i in range(len(lyrics)):
35 |         lyric, speed = lyrics[i]
36 |         t = Thread(target=sing_lyric, args=(lyric, delays[i], speed))
37 |         threads.append(t)
38 |         t.start()
39 |     
40 |     for thread in threads:
41 |         thread.join()
42 | 
43 | if __name__ == "__main__":
44 |     sing_song()


--------------------------------------------------------------------------------
/sempurna.py:
--------------------------------------------------------------------------------
 1 | import time
 2 | from threading import Thread, Lock
 3 | import sys
 4 | 
 5 | lock = Lock()
 6 | 
 7 | def animate_text(text, delay=0.1):
 8 |     with lock:
 9 |         for char in text:
10 |             sys.stdout.write(char)
11 |             sys.stdout.flush()
12 |             time.sleep(delay)
13 |         print()
14 | 
15 | def sing_lyric(lyric, delay, speed):
16 |     time.sleep(delay)
17 |     animate_text(lyric, speed)
18 | 
19 | def sing_song():
20 |     lyrics = [
21 |         ("Janganlah kau tinggalkan diri ku", 0.1),
22 |         ("Tak kan mampu menghadapi semua", 0.12),
23 |         ("Hanya bersamamu ku akan bisa", 0.11),
24 |         ("Kau adalah darah ku", 0.10),
25 |         ("Kau adalah jantung ku", 0.10),
26 |         ("Kau adalah hidup ku lengkapi diri ku", 0.10),
27 |         ("Oh sayangku kau begitu", 0.1),
28 |         ("Sempurnaaaaaaaaaaaaaaaaa", 0.1)
29 |     ]
30 |     delays = [0.3, 4.5, 9.3, 14.1, 18.8, 23.0, 28.0, 34.5]
31 |     
32 |     threads = []
33 |     for i in range(len(lyrics)):
34 |         lyric, speed = lyrics[i]
35 |         t = Thread(target=sing_lyric, args=(lyric, delays[i], speed))
36 |         threads.append(t)
37 |         t.start()
38 |     
39 |     for thread in threads:
40 |         thread.join()
41 | 
42 | if __name__ == "__main__":
43 |     sing_song()
44 | 


--------------------------------------------------------------------------------
/sign of times.py:
--------------------------------------------------------------------------------
 1 | import time
 2 | from threading import Thread, Lock
 3 | import sys
 4 | 
 5 | lock = Lock()
 6 | 
 7 | def animate_text(text, delay=0.1):
 8 |     with lock:
 9 |         for char in text:
10 |             sys.stdout.write(char)
11 |             sys.stdout.flush()
12 |             time.sleep(delay)
13 |         print()
14 | 
15 | def sing_lyric(lyric, delay, speed):
16 |     time.sleep(delay)
17 |     animate_text(lyric, speed)
18 | 
19 | def sing_song():
20 |     lyrics = [
21 |         ("\n""We don't talk enough", 0.12),
22 |         ("We should open up", 0.14),
23 |         ("Before it's all too much", 0.12),
24 |         ("Will we ever learn?", 0.12),
25 |         ("We've been here before", 0.12),
26 |         ("It's just what we know", 0.12),
27 |         ("\n""Stop your crying, baby", 0.07),
28 |         ("It's a sign of the times", 0.06),
29 |         ("We gotta get away", 0.08),
30 |         ("We got to get away""\n", 0.08)
31 |     ]
32 |     
33 |     delays = [0, 4.0, 8.0, 16.0, 20.0, 24.0, 32.0, 34.0, 38.0, 42.5]
34 |     
35 |     threads = []
36 |     for i in range(len(lyrics)):
37 |         lyric, speed = lyrics[i]
38 |         t = Thread(target=sing_lyric, args=(lyric, delays[i], speed))
39 |         threads.append(t)
40 |         t.start()
41 |     for thread in threads:
42 |         thread.join()
43 | 
44 | if __name__ == "__main__":
45 |     sing_song()
46 | 


--------------------------------------------------------------------------------
/somebody pleasure V2.py:
--------------------------------------------------------------------------------
 1 | import time
 2 | from threading import Thread
 3 | import sys
 4 | 
 5 | def animate_text(text, delay):
 6 |     for char in text:
 7 |         sys.stdout.write(char)
 8 |         sys.stdout.flush()
 9 |         time.sleep(delay)
10 |     print()
11 | 
12 | def sing_lyric(lyric, delay, speed):
13 |     time.sleep(delay)
14 |     animate_text(lyric, speed)
15 | 
16 | def sing_song():
17 |     lyrics = [
18 |         ("\nI hold imagination", 0.5, 0.1),
19 |         ("Got full of love this sadness", 5.2, 0.09),
20 |         ("I don't feel something special", 9.8, 0.1),
21 |         ("Turn on the floor to get some special", 13.4, 0.08),
22 |         ("\nNever thought I'm leaving me", 17.4, 0.1),
23 |         ("Thought the truth that has been stolen", 21.5, 0.1),
24 |         ("It was in a blink of an eye", 26.5, 0.1),
25 |         ("Find a way how to say goodbye", 30.3, 0.1),
26 |         ("\nI've got to take me away from all sadness", 33.9, 0.13),
27 |         ("Stitch all my wounds, confess all the sins", 43.2, 0.09),
28 |         ("And took all my insecure", 47.0, 0.1)
29 |     ]
30 | 
31 |     threads = [Thread(target=sing_lyric, args=lyric) for lyric in lyrics]
32 |     for thread in threads: thread.start()
33 |     for thread in threads: thread.join()
34 | 
35 | if __name__ == "__main__":
36 |     sing_song()
37 | 


--------------------------------------------------------------------------------
/somebody pleasure.py:
--------------------------------------------------------------------------------
 1 | import time
 2 | from threading import Thread, Lock
 3 | import sys
 4 | 
 5 | lock = Lock()
 6 | 
 7 | def animate_text(text, delay=0.1):
 8 |     with lock:
 9 |         for char in text:
10 |             sys.stdout.write(char)
11 |             sys.stdout.flush()
12 |             time.sleep(delay)
13 |         print()
14 | 
15 | def sing_lyric(lyric, delay, speed):
16 |     time.sleep(delay)
17 |     animate_text(lyric, speed)
18 | 
19 | def sing_song():
20 |     lyrics = [
21 |         ("\n""Soul try to figure it out", 0.10),
22 |         ("From where I've been escapin", 0.10),
23 |         ("Running to end all the sin", 0.11),
24 |         ("Get away from the pressure", 0.10),
25 |         ("\n""Wondering to get a love that is so pure", 0.14),
26 |         ("Gotta have to always make sure", 0.10),
27 |         ("That I'm not just somebody's pleasure", 0.10)
28 |     ]
29 |     delays = [0.3, 4.6, 9.0, 13.4, 16.4, 25.5, 29.3]
30 |     
31 |     threads = []
32 |     for i in range(len(lyrics)):
33 |         lyric, speed = lyrics[i]
34 |         t = Thread(target=sing_lyric, args=(lyric, delays[i], speed))
35 |         threads.append(t)
36 |         t.start()
37 |     
38 |     for thread in threads:
39 |         thread.join()
40 | 
41 | if __name__ == "__main__":
42 |     sing_song()
43 | 


--------------------------------------------------------------------------------
/somebody to you.py:
--------------------------------------------------------------------------------
 1 | import time
 2 | from threading import Thread, Lock
 3 | import sys
 4 | 
 5 | lock = Lock()
 6 | 
 7 | def animate_text(text, delay=0.1):
 8 |     with lock:
 9 |         for char in text:
10 |             sys.stdout.write(char)
11 |             sys.stdout.flush()
12 |             time.sleep(delay)
13 |         print()
14 | 
15 | def sing_lyric(lyric, delay, speed):
16 |     time.sleep(delay)
17 |     animate_text(lyric, speed)
18 | 
19 | def sing_song():
20 |     lyrics = [
21 |         ("\nAll I wanna be, yeah, all I ever wanna be, yeah, yeah", 0.05),
22 |         ("Is somebody to you", 0.05),
23 |         ("All I wanna be, yeah, all I ever wanna be, yeah, yeah", 0.05),
24 |         ("Is somebody to you", 0.05),
25 |         ("Everybody's tryna be a billionaire", 0.06),
26 |         ("But every time I look at you, I just don't care", 0.05),
27 |         ("Cause all I wanna be, yeah, all I ever wanna be, yeah, yeah", 0.06),
28 |         ("Is somebody to youuuuu", 0.05)
29 |     ]
30 |     delays = [0.3, 3.5, 5.3, 8.5, 10.0, 12.5, 14.7, 18.5]
31 |     
32 |     threads = []
33 |     for i in range(len(lyrics)):
34 |         lyric, speed = lyrics[i]
35 |         t = Thread(target=sing_lyric, args=(lyric, delays[i], speed))
36 |         threads.append(t)
37 |         t.start()
38 |     
39 |     for thread in threads:
40 |         thread.join()
41 | 
42 | if __name__ == "__main__":
43 |     sing_song()
44 | 


--------------------------------------------------------------------------------
/steal my girl.py:
--------------------------------------------------------------------------------
 1 | import time
 2 | from threading import Thread, Lock
 3 | import sys
 4 | 
 5 | lock = Lock()
 6 | 
 7 | def animate_text(text, delay=0.1):
 8 |     with lock:
 9 |         for char in text:
10 |             sys.stdout.write(char)
11 |             sys.stdout.flush()
12 |             time.sleep(delay)
13 |         print()
14 | 
15 | def sing_lyric(lyric, delay, speed):
16 |     time.sleep(delay)
17 |     animate_text(lyric, speed)
18 | 
19 | def sing_song():
20 |     lyrics = [
21 |         ("\n""She's been my queen", 0.07),
22 |         ("Since we were sixteen", 0.07),
23 |         ("We want the same things", 0.07),
24 |         ("We dream the same dreams", 0.07),
25 |         ("Alright", 0.07),
26 |         ("Alright", 0.07),
27 |         ("\n""I got it all", 0.07),
28 |         ("Cause she is the one", 0.07),
29 |         ("Her mum calls me love", 0.07),
30 |         ("Her dad calls me son", 0.07),
31 |         ("Alright", 0.07),
32 |         ("Alright", 0.07),
33 |     ]
34 |     delays = [0.3, 1.7, 3.0, 4.5, 6.0, 9.5, 12.9, 13.9, 15.5, 17.0, 18.5, 22.0]
35 |     
36 |     threads = []
37 |     for i in range(len(lyrics)):
38 |         lyric, speed = lyrics[i]
39 |         t = Thread(target=sing_lyric, args=(lyric, delays[i], speed))
40 |         threads.append(t)
41 |         t.start()
42 |     
43 |     for thread in threads:
44 |         thread.join()
45 | 
46 | if __name__ == "__main__":
47 |     sing_song()
48 | 


--------------------------------------------------------------------------------
/stecu stecu.py:
--------------------------------------------------------------------------------
 1 | import time
 2 | from threading import Thread, Lock
 3 | import sys
 4 | 
 5 | lock = Lock()
 6 | 
 7 | def animate_text(text, delay=0.1):
 8 |     with lock:
 9 |         for char in text:
10 |             sys.stdout.write(char)
11 |             sys.stdout.flush()
12 |             time.sleep(delay)
13 |         print()
14 | 
15 | def sing_lyric(lyric, delay, speed):
16 |     time.sleep(delay)
17 |     animate_text(lyric, speed)
18 | 
19 | def sing_song():
20 |     lyrics = [
21 |         ("\nAduh, Abang bukan maksudku begitu", 0.07),
22 |         ("Masalah stecu bukan berarti tak mau", 0.07),
23 |         ("Jual mahal dikit kan bisa", 0.06),
24 |         ("Coba kase effort-nya saja", 0.06),
25 |         ("Kalo memang cocok bisa datang ke rumah\n", 0.06),
26 |         ("Stecu, stecu, stelan cuek baru malu", 0.09),
27 |         ("Aduh, Ade ini mau juga Abang yang rayu", 0.06),
28 |         ("Stecu, stecu, stelan cuek baru malu", 0.09),
29 |         ("Aduh, Ade ini mau juga abang yang maju", 0.06),
30 |     ]
31 |     
32 |     delays = [0.3, 3.7, 7.1, 8.7, 10.5, 13.7, 17.4, 20.4, 24.0]
33 |     
34 |     threads = []
35 |     for i in range(len(lyrics)):
36 |         lyric, speed = lyrics[i]
37 |         t = Thread(target=sing_lyric, args=(lyric, delays[i], speed))
38 |         threads.append(t)
39 |         t.start()
40 |     
41 |     for thread in threads:
42 |         thread.join()
43 | 
44 | if __name__ == "__main__":
45 |     sing_song()
46 | 


--------------------------------------------------------------------------------
/strong.py:
--------------------------------------------------------------------------------
 1 | import time
 2 | from threading import Thread, Lock
 3 | import sys
 4 | 
 5 | lock = Lock()
 6 | 
 7 | def animate_text(text, delay=0.1):
 8 |     with lock:
 9 |         for char in text:
10 |             sys.stdout.write(char)
11 |             sys.stdout.flush()
12 |             time.sleep(delay)
13 |         print()
14 | 
15 | def sing_lyric(lyric, delay, speed):
16 |     time.sleep(delay)
17 |     animate_text(lyric, speed)
18 | 
19 | def sing_song():
20 |     lyrics = [
21 |         ("I'm sorry if I say, I need you", 0.08),
22 |         ("But I don't care, I'm not scared of love", 0.06),
23 |         ("Cause when I'm not with you, I'm weaker", 0.07),
24 |         ("Is that so wrong? Is it so wrong", 0.08),
25 |         ("That you make me strong?", 0.06),
26 |     ]
27 |     delays = [0.3, 3.7, 7.4, 10.2, 13.7]
28 |     
29 |     threads = []
30 |     for i in range(len(lyrics)):
31 |         lyric, speed = lyrics[i]
32 |         t = Thread(target=sing_lyric, args=(lyric, delays[i], speed))
33 |         threads.append(t)
34 |         t.start()
35 |     
36 |     for thread in threads:
37 |         thread.join()
38 | 
39 | if __name__ == "__main__":
40 |     sing_song()
41 | 


--------------------------------------------------------------------------------
/superficial love.py:
--------------------------------------------------------------------------------
 1 | import time
 2 | from threading import Thread, Lock
 3 | import sys
 4 | 
 5 | lock = Lock()
 6 | 
 7 | def animate_text(text, delay=0.1):
 8 |     with lock:
 9 |         for char in text:
10 |             sys.stdout.write(char)
11 |             sys.stdout.flush()
12 |             time.sleep(delay)
13 |         print()
14 | 
15 | def sing_lyric(lyric, delay, speed):
16 |     time.sleep(delay)
17 |     animate_text(lyric, speed)
18 | 
19 | def sing_song():
20 |     lyrics = [
21 |         ("\nThis superficial love thing got me going crazy", 0.06),
22 |         ("Baby if you want me, then you better need me", 0.07),
23 |         ("Cause I'm so done, not being your number one", 0.08),
24 |         ("And if you wanna keep me, then you better treat me", 0.07),
25 |         ("Like a damn princess, make that an empress", 0.07),
26 |         ("Cause I'm so done, not being your number one", 0.08),
27 |         ("This superficial love", 0.06)
28 |     ]
29 |     delays = [0.3, 3.7, 6.8, 13.0, 16.5, 19.8, 26.0]
30 |     
31 |     threads = []
32 |     for i in range(len(lyrics)):
33 |         lyric, speed = lyrics[i]
34 |         t = Thread(target=sing_lyric, args=(lyric, delays[i], speed))
35 |         threads.append(t)
36 |         t.start()
37 |     for thread in threads:
38 |         thread.join()
39 | 
40 | if __name__ == "__main__":
41 |     sing_song()


--------------------------------------------------------------------------------
/to the bone.py:
--------------------------------------------------------------------------------
 1 | import time
 2 | from threading import Thread, Lock
 3 | import sys
 4 | 
 5 | lock = Lock()
 6 | 
 7 | def animate_text(text, delay=0.1):
 8 |     with lock:
 9 |         for char in text:
10 |             sys.stdout.write(char)
11 |             sys.stdout.flush()
12 |             time.sleep(delay)
13 |         print()
14 | 
15 | def sing_lyric(lyric, delay, speed):
16 |     time.sleep(delay)
17 |     animate_text(lyric, speed)
18 | 
19 | def sing_song():
20 |     lyrics = [
21 |         ("\n""Take me home, I'm fallin", 0.10),
22 |         ("Love me long, I'm rollin", 0.09),
23 |         ("Losing control, body and soul", 0.09),
24 |         ("Mind too for sure, I'm already yours", 0.10),
25 |         ("Walk you down, I'm all in", 0.10),
26 |         ("Hold you tight, you call and", 0.09),
27 |         ("I'll take control, your body and soul", 0.07),
28 |         ("Mind too for sure, I'm already yours", 0.09),
29 |     ]
30 |     delays = [0.3, 3.9, 7.0, 10.5, 15.0, 18.5, 21.5, 24.9]
31 |     
32 |     threads = []
33 |     for i in range(len(lyrics)):
34 |         lyric, speed = lyrics[i]
35 |         t = Thread(target=sing_lyric, args=(lyric, delays[i], speed))
36 |         threads.append(t)
37 |         t.start()
38 |     
39 |     for thread in threads:
40 |         thread.join()
41 | 
42 | if __name__ == "__main__":
43 |     sing_song()
44 | 


--------------------------------------------------------------------------------
/tresno tekane mati .py:
--------------------------------------------------------------------------------
 1 | import time
 2 | from threading import Thread, Lock
 3 | import sys
 4 | 
 5 | lock = Lock()
 6 | 
 7 | def animate_text(text, delay=0.1):
 8 |     with lock:
 9 |         for char in text:
10 |             sys.stdout.write(char)
11 |             sys.stdout.flush()
12 |             time.sleep(delay)
13 |         print()
14 | 
15 | def sing_lyric(lyric, delay, speed):
16 |     time.sleep(delay)
17 |     animate_text(lyric, speed)
18 | 
19 | def sing_song():
20 |     lyrics = [
21 |         ("\nNganti tok duake aku lilo", 0.11),
22 |         ("Wis kulino bab ngampet loro", 0.10),
23 |         ("Pokoke kowe liyane aku wegah", 0.11),
24 |         ("Raono kata pisah percoyo endinge indah\n", 0.09),
25 |         ("Kelangan kowe aku jelas ngamuk", 0.10),
26 |         ("Mlaku tanpo kowe ati remuk", 0.11),
27 |         ("Tak pasrahke gusti kabeh takdirku", 0.10),
28 |         ("Dongaku ora pedot yo mung dinggo sliramu\n", 0.08),
29 |     ]
30 |     
31 |     delays = [0.3, 4.3, 7.9, 11.6, 16.0, 19.3, 23.3, 27.0]
32 |     
33 |     threads = []
34 |     for i in range(len(lyrics)):
35 |         lyric, speed = lyrics[i]
36 |         t = Thread(target=sing_lyric, args=(lyric, delays[i], speed))
37 |         threads.append(t)
38 |         t.start()
39 |     
40 |     for thread in threads:
41 |         thread.join()
42 | 
43 | if __name__ == "__main__":
44 |     sing_song()
45 | 


--------------------------------------------------------------------------------
/valentine/css/style.css:
--------------------------------------------------------------------------------
 1 | body {
 2 |     display: flex;
 3 |     justify-content: center;
 4 |     align-items: center;
 5 |     height: 100vh;
 6 |     text-align: center;
 7 |     font-family: Arial, sans-serif;
 8 |     background-color: #fff;
 9 |     margin: 0;
10 |     overflow: hidden;
11 | }
12 | h1 {
13 |     color: #ff5555;
14 | }
15 | .container {
16 |     margin-top: 0px;
17 | }
18 | .gif-container {
19 |     margin-bottom: 20px;
20 | }
21 | .gif-container img {
22 |     max-width: 300px;
23 |     height: auto;
24 | }
25 | button {
26 |     font-size: 20px;
27 |     padding: 10px 20px;
28 |     margin: 10px;
29 |     border: none;
30 |     cursor: pointer;
31 | }
32 | .yes-btn {
33 |     background-color: #38b44d;
34 |     color: white;
35 | }
36 | .no-btn {
37 |     background-color: #e93d3d;
38 |     color: white;
39 |     position: absolute;
40 | }


--------------------------------------------------------------------------------
/valentine/css/style2.css:
--------------------------------------------------------------------------------
 1 | @import url("https://fonts.googleapis.com/css?family=Kaushan+Script");
 2 | 
 3 | html,
 4 | body,
 5 | .container {
 6 |     height: 100%;
 7 |     font-family: "Kaushan Script", "Sail", cursive;
 8 | }
 9 | 
10 | body {
11 |     display: flex;
12 |     justify-content: center;
13 |     align-items: center;
14 |     background: #ffffff;
15 |     margin: 0;
16 |     overflow: hidden;
17 | }
18 | canvas#c {
19 |     position: absolute;
20 |     top: 0;
21 |     left: 0;
22 | }
23 | 
24 | #balloon-container {
25 |     height: 100vh;
26 |     padding: 1em;
27 |     box-sizing: border-box;
28 |     display: flex;
29 |     flex-wrap: wrap;
30 |     overflow: hidden;
31 |     transition: opacity 500ms;
32 | }
33 | 
34 | .balloon {
35 |     height: 125px;
36 |     width: 105px;
37 |     border-radius: 75% 75% 70% 70%;
38 |     position: relative;
39 | }
40 | 
41 | .balloon:before {
42 |     content: "";
43 |     height: 75px;
44 |     width: 1px;
45 |     padding: 1px;
46 |     background-color: #FDFD96;
47 |     display: block;
48 |     position: absolute;
49 |     top: 125px;
50 |     left: 0;
51 |     right: 0;
52 |     margin: auto;
53 | }
54 | 
55 | .balloon:after {
56 |     content: "▲";
57 |     text-align: center;
58 |     display: block;
59 |     position: absolute;
60 |     color: inherit;
61 |     top: 120px;
62 |     left: 0;
63 |     right: 0;
64 |     margin: auto;
65 | }
66 | 
67 | @keyframes float {
68 |     from {
69 |         transform: translateY(100vh);
70 |         opacity: 1;
71 |     }
72 | 
73 |     to {
74 |         transform: translateY(-300vh);
75 |         opacity: 0;
76 |     }
77 | }


--------------------------------------------------------------------------------
/valentine/index.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html lang="en">
 3 | <head>
 4 |     <meta charset="UTF-8">
 5 |     <meta name="viewport" content="width=device-width, initial-scale=1.0">
 6 |     <link rel="stylesheet" href="css/style.css">
 7 |     <title>Be My Valentine?</title>
 8 | </head>
 9 | <body>
10 |     <div class="container">
11 |         <div class="gif-container">
12 |             <img src="https://i.postimg.cc/kR7z6fWr/ututu.gif" alt="Valentine GIF">
13 |         </div>
14 |         <h1>Will You Be My Valentine? ❤️</h1>
15 |         <button class="yes-btn" onclick="window.location.href='index2.html'">Yes</button>
16 |         <button class="no-btn" id="noBtn">No</button>
17 |     </div>
18 |     <script src="js/script.js"></script>
19 | </body>
20 | </html>


--------------------------------------------------------------------------------
/valentine/index2.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html lang="en">
 3 |     <head>
 4 |         <meta charset="UTF-8">
 5 |         <meta http-equiv="X-UA-Compatible" content="IE=edge">
 6 |         <meta name="viewport" content="width=device-width, initial-scale=1.0">
 7 |         <link rel="stylesheet" href="css/style2.css">
 8 |         <title>valentine</title>
 9 |     </head>
10 |     <body>
11 |         </div>
12 |             <canvas id="c"></canvas>
13 |             <div id="balloon-container">
14 |         </div>
15 |         <script src="js/script2.js"></script>
16 |     </body>
17 | </html>


--------------------------------------------------------------------------------
/valentine/js/script.js:
--------------------------------------------------------------------------------
1 | const noBtn = document.getElementById('noBtn');
2 | 
3 | noBtn.addEventListener('mouseover', () => {
4 |     const x = Math.random() * (window.innerWidth - 100);
5 |     const y = Math.random() * (window.innerHeight - 50);
6 |     noBtn.style.left = `${x}px`;
7 |     noBtn.style.top = `${y}px`;
8 | });


--------------------------------------------------------------------------------
/watch.py:
--------------------------------------------------------------------------------
 1 | import time
 2 | from threading import Thread, Lock
 3 | import sys
 4 | 
 5 | lock = Lock()
 6 | 
 7 | def animate_text(text, delay=0.1):
 8 |     with lock:
 9 |         for char in text:
10 |             sys.stdout.write(char)
11 |             sys.stdout.flush()
12 |             time.sleep(delay)
13 |         print()
14 | 
15 | def sing_lyric(lyric, delay, speed):
16 |     time.sleep(delay)
17 |     animate_text(lyric, speed)
18 | 
19 | def sing_song():
20 |     lyrics = [
21 |         ("\nWhen you call my name", 0.06),
22 |         ("Do you think I'll come running?", 0.06),
23 |         ("You never did the same", 0.06),
24 |         ("So good at givin' me nothing", 0.07),
25 |         ("When you close your eyes, do you picture me?", 0.07),
26 |         ("When you fantasize, am I your fantasy?", 0.07),
27 |         ("Now you know", 0.10),
28 |         ("Now I'm free", 0.1)
29 |     ]
30 |     delays = [0.3, 3.5, 6.4, 9.5, 12.8, 15.8, 19.6, 22.5]
31 |     
32 |     threads = []
33 |     for i in range(len(lyrics)):
34 |         lyric, speed = lyrics[i]
35 |         t = Thread(target=sing_lyric, args=(lyric, delays[i], speed))
36 |         threads.append(t)
37 |         t.start()
38 |     for thread in threads:
39 |         thread.join()
40 | 
41 | if __name__ == "__main__":
42 |     sing_song()


--------------------------------------------------------------------------------
/we can't be friends.py:
--------------------------------------------------------------------------------
 1 | import time
 2 | from threading import Thread, Lock
 3 | import sys
 4 | 
 5 | lock = Lock()
 6 | 
 7 | def animate_text(text, delay=0.1):
 8 |     with lock:
 9 |         for char in text:
10 |             sys.stdout.write(char)
11 |             sys.stdout.flush()
12 |             time.sleep(delay)
13 |         print()
14 | 
15 | def sing_lyric(lyric, delay, speed):
16 |     time.sleep(delay)
17 |     animate_text(lyric, speed)
18 | 
19 | def sing_song():
20 |     lyrics = [
21 |         ("\n""Know that you made me", 0.09),
22 |         ("I don't like how you paint me, yet I'm still here hanging", 0.07),
23 |         ("Not what you made me", 0.09),
24 |         ("It's something like a daydream", 0.08),
25 |         ("But I feel so seen in the night", 0.09),
26 |         ("So for now, it's only me", 0.08),
27 |         ("And maybe that's all I need""\n", 0.08)
28 |     ]
29 |     delays = [0, 4.0, 8.6, 12.6, 15.0, 19.2, 23.0]
30 |     
31 |     threads = []
32 |     for i in range(len(lyrics)):
33 |         lyric, speed = lyrics[i]
34 |         t = Thread(target=sing_lyric, args=(lyric, delays[i], speed))
35 |         threads.append(t)
36 |         t.start()
37 |     
38 |     for thread in threads:
39 |         thread.join()
40 | 
41 | if __name__ == "__main__":
42 |     sing_song()
43 | 


--------------------------------------------------------------------------------
/where we are.py:
--------------------------------------------------------------------------------
 1 | import time
 2 | from threading import Thread, Lock
 3 | import sys
 4 | 
 5 | lock = Lock()
 6 | 
 7 | def animate_text(text, delay=0.1):
 8 |     with lock:
 9 |         for char in text:
10 |             sys.stdout.write(char)
11 |             sys.stdout.flush()
12 |             time.sleep(delay)
13 |         print()
14 | 
15 | def sing_lyric(lyric, delay, speed):
16 |     time.sleep(delay)
17 |     animate_text(lyric, speed)
18 | 
19 | def sing_song():
20 |     lyrics = [
21 |         ("\nDid we ever know?", 0.07),
22 |         ("Did we ever know?", 0.07),
23 |         ("Did we ever know?", 0.12),
24 |         ("\nIs it all inside of my head?", 0.08),
25 |         ("Maybe you still think I don't care", 0.07),
26 |         ("But all I need is you", 0.08),
27 |         ("Yeah, you know it's true", 0.05),
28 |         ("yeah, you know it's true", 0.05),
29 |         ("\nForget about where we are and let go", 0.11),
30 |         ("We're so close\n", 0.09)
31 |     ]
32 |     delays = [0.3, 2.4, 4.1, 8.0, 11.9, 15.9, 18.5, 20.5, 22.7, 28.0]
33 |     
34 |     threads = []
35 |     for i in range(len(lyrics)):
36 |         lyric, speed = lyrics[i]
37 |         t = Thread(target=sing_lyric, args=(lyric, delays[i], speed))
38 |         threads.append(t)
39 |         t.start()
40 |     for thread in threads:
41 |         thread.join()
42 | 
43 | if __name__ == "__main__":
44 |     sing_song()
45 | 


--------------------------------------------------------------------------------
/wide awake.py:
--------------------------------------------------------------------------------
 1 | import time
 2 | from threading import Thread, Lock
 3 | import sys
 4 | 
 5 | lock = Lock()
 6 | 
 7 | def animate_text(text, delay=0.1):
 8 |     with lock:
 9 |         for char in text:
10 |             sys.stdout.write(char)
11 |             sys.stdout.flush()
12 |             time.sleep(delay)
13 |         print()
14 | 
15 | def sing_lyric(lyric, delay, speed):
16 |     time.sleep(delay)
17 |     animate_text(lyric, speed)
18 | 
19 | def sing_song():
20 |     lyrics = [
21 |         ("Falling from cloud nine", 0.12),
22 |         ("Crashing from the high", 0.11),
23 |         ("I'm letting go tonight", 0.11),
24 |         ("I'm Falling from cloud nine", 0.12),
25 |         ("Thunder rumbling", 0.10),
26 |         ("Castles crumbling", 0.10),
27 |         ("I am trying to hold on", 0.11)
28 |     ]
29 |     delays = [0.3, 5.7, 11.0, 16.2, 22.5, 25.2, 27.8]
30 |     
31 |     threads = []
32 |     for i in range(len(lyrics)):
33 |         lyric, speed = lyrics[i]
34 |         t = Thread(target=sing_lyric, args=(lyric, delays[i], speed))
35 |         threads.append(t)
36 |         t.start()
37 |     
38 |     for thread in threads:
39 |         thread.join()
40 | 
41 | if __name__ == "__main__":
42 |     sing_song()
43 | 


--------------------------------------------------------------------------------
/wish you were here.py:
--------------------------------------------------------------------------------
 1 | import time
 2 | from threading import Thread, Lock
 3 | import sys
 4 | 
 5 | lock = Lock()
 6 | 
 7 | def animate_text(text, delay=0.1):
 8 |     with lock:
 9 |         for char in text:
10 |             sys.stdout.write(char)
11 |             sys.stdout.flush()
12 |             time.sleep(delay)
13 |         print()
14 | 
15 | def sing_lyric(lyric, delay, speed):
16 |     time.sleep(delay)
17 |     animate_text(lyric, speed)
18 | 
19 | def sing_song():
20 |     lyrics = [
21 |         ("\n""If a picture is all that I have", 0.09),
22 |         ("I can picture the times that we won't get back", 0.08),
23 |         ("If I picture it now, it don't seem so bad", 0.09),
24 |         ("Either way, I still wish you were here", 0.08),
25 |         ("Don't say everything's meant to be", 0.09),
26 |         ("Cause you know it's not what I believe", 0.08),
27 |         ("Can't help but think that it should've been me", 0.08),
28 |         ("Either way, I still wish you were here", 0.08),
29 |     ]
30 |     delays = [0.3, 4.7, 9.2, 13.9, 18.3, 22.9, 26.9, 31.9]
31 | 
32 |     threads = []
33 |     for i in range(len(lyrics)):
34 |         lyric, speed = lyrics[i]
35 |         t = Thread(target=sing_lyric, args=(lyric, delays[i], speed))
36 |         threads.append(t)
37 |         t.start()
38 | 
39 |     for thread in threads:
40 |         thread.join()
41 | 
42 | if __name__ == "__main__":
43 |     sing_song()
44 | 


--------------------------------------------------------------------------------
/ya maulana.py:
--------------------------------------------------------------------------------
 1 | import time
 2 | from threading import Thread, Lock
 3 | import sys
 4 | 
 5 | Rawrr = Lock()
 6 | 
 7 | def animasi_teks(teks, jeda=0.1):
 8 |     with Rawrr:
 9 |         for karakter in teks:
10 |             sys.stdout.write(karakter)
11 |             sys.stdout.flush()
12 |             time.sleep(jeda)
13 |         print()
14 | 
15 | def nyanyikan_lirik(lirik, jeda, kecepatan):
16 |     time.sleep(jeda)
17 |     animasi_teks(lirik, kecepatan)
18 | 
19 | def nyanyikan_lagu():
20 |     lirik_lagu = [
21 |         ("\n""Segala duka hatiku hilang hilangkan", 0.06),
22 |         ("Semua salah dosaku mohon ampunkan", 0.06),
23 |         ("Airmata lukaku hapus hapuskan", 0.07),
24 |         ("Doa hari-hariku harap kabulkan\n", 0.07),
25 |         ("Maulana Maulanaa Yaa Sami' Du'anaa", 0.12),
26 |         ("Birahmatika Yaa Rabbi La Taqtho' Rojanaa", 0.11),
27 |         ("Maulana Maulanaa Yaa Sami' Du'anaa", 0.12),
28 |         ("Birahmatika Yaa Rabbi La Taqtho' Rojanaa""\n", 0.11),
29 |     ]
30 |     
31 |     jeda_lirik = [0.3, 2.7, 4.9, 7.0, 9.6, 14.0, 18.7, 23.3]
32 |     
33 |     threads = []
34 |     for i in range(len(lirik_lagu)):
35 |         lirik, kecepatan = lirik_lagu[i]
36 |         t = Thread(target=nyanyikan_lirik, args=(lirik, jeda_lirik[i], kecepatan))
37 |         threads.append(t)
38 |         t.start()
39 |     
40 |     for thread in threads:
41 |         thread.join()
42 | 
43 | if __name__ == "__main__":
44 |     nyanyikan_lagu()


--------------------------------------------------------------------------------