Lifebuoy created on brick transform after a small delay.

Conflicts:
	include/Game/BallSystem.h
	include/Game/ProjectileSystem.h
	src/game/Game/BallSystem.cpp
	src/game/Game/ProjectileSystem.cpp
	src/game/Rendering/AnimationSystem.cpp

CMakeLists.txt

@@ -31,6 +31,7 @@ if(BUILD_RENDERER_OPENGL)
 endif()
 # Compiling for DirectX target
 if(BUILD_RENDERER_DIRECTX)
+    add_definitions(-DBUILD_RENDERER_DIRECTX)
     include_directories(${PROJECT_SOURCE_DIR}/include/Rendering/DirectX)
 endif()
 

assets/DefaultConfig.ini

@@ -1,6 +1,7 @@
 [Debug]
-SkipStory=false
 LogLevel=1
+SkipPreload=false
+SkipMenu=false
 
 [Audio]
 SFXVolume=0.5
@@ -9,4 +10,10 @@ BGMVolume=0.5
 [Video]
 Fullscreen=false
 Width=675
-Height=1080[Water]Radius=0.3[Cheat]GodMode=false
+Height=1080
+
+[Water]
+Radius=0.3
+
+[Cheat]
+GodMode=false

assets/Models/Brick/InkBrick.mtl

@@ -0,0 +1,12 @@
+# Blender MTL File: 'Bricks.blend'
+# Material Count: 1
+
+newmtl Material.004
+Ns 96.078431
+Ka 0.000000 0.000000 0.000000
+Kd 0.640000 0.640000 0.640000
+Ks 0.500000 0.500000 0.500000
+Ni 1.000000
+d 1.000000
+illum 2
+map_Kd InkBrickTexture.png

assets/Models/Brick/InkBrick.obj

@@ -0,0 +1,513 @@
+# Blender v2.75 (sub 0) OBJ File: 'Bricks.blend'
+# www.blender.org
+mtllib InkBrick.mtl
+o OriginalBrick.015_Cube.028
+v 0.416882 0.151013 0.189181
+v 0.383459 0.157800 0.197587
+v 0.427922 0.161606 0.161784
+v 0.383459 0.180000 0.161784
+v 0.432779 0.125616 0.202365
+v 0.383459 0.126000 0.215784
+v 0.450000 0.126000 0.161784
+v -0.416882 0.151013 0.189181
+v 0.000000 0.157800 0.197587
+v -0.383459 0.157800 0.197587
+v -0.427922 0.161606 0.161784
+v 0.000000 0.180000 0.161784
+v -0.383459 0.180000 0.161784
+v -0.432779 0.125616 0.202365
+v 0.000000 0.126000 0.215784
+v -0.383459 0.126000 0.215784
+v -0.450000 0.126000 0.161784
+v 0.427922 0.161606 0.000000
+v 0.416882 0.151013 -0.189181
+v 0.383459 0.180000 0.000000
+v 0.383459 0.157800 -0.197587
+v 0.427922 0.161606 -0.161784
+v 0.383459 0.180000 -0.161784
+v 0.450000 0.126000 0.000000
+v 0.432779 0.125616 -0.202365
+v 0.383459 0.126000 -0.215784
+v 0.450000 0.126000 -0.161784
+v 0.000000 0.180000 0.000000
+v -0.427922 0.161606 0.000000
+v -0.416882 0.151013 -0.189181
+v 0.000000 0.157800 -0.197587
+v -0.383459 0.180000 0.000000
+v -0.383459 0.157800 -0.197587
+v -0.427922 0.161606 -0.161784
+v 0.000000 0.180000 -0.161784
+v -0.383459 0.180000 -0.161784
+v -0.450000 0.126000 0.000000
+v -0.432779 0.125616 -0.202365
+v 0.000000 0.126000 -0.215784
+v -0.383459 0.126000 -0.215784
+v -0.450000 0.126000 -0.161784
+v 0.416882 -0.151013 0.189181
+v 0.383459 -0.157800 0.197587
+v 0.427922 -0.161606 0.161784
+v 0.383459 -0.180000 0.161784
+v 0.432779 -0.125616 0.202365
+v 0.383459 -0.126000 0.215784
+v 0.450000 -0.126000 0.161784
+v 0.432723 0.000000 0.202132
+v 0.383459 0.000000 0.215784
+v 0.450000 0.000000 0.161784
+v -0.416882 -0.151013 0.189181
+v 0.000000 -0.157800 0.197587
+v -0.383459 -0.157800 0.197587
+v -0.427922 -0.161606 0.161784
+v 0.000000 -0.180000 0.161784
+v -0.383459 -0.180000 0.161784
+v -0.432779 -0.125616 0.202365
+v 0.000000 -0.126000 0.215784
+v -0.383459 -0.126000 0.215784
+v -0.450000 -0.126000 0.161784
+v -0.432723 0.000000 0.202132
+v 0.000000 0.000000 0.215784
+v -0.383459 0.000000 0.215784
+v -0.450000 0.000000 0.161784
+v 0.427922 -0.161606 0.000000
+v 0.416882 -0.151013 -0.189181
+v 0.383459 -0.180000 0.000000
+v 0.383459 -0.157800 -0.197587
+v 0.427922 -0.161606 -0.161784
+v 0.383459 -0.180000 -0.161784
+v 0.450000 -0.126000 0.000000
+v 0.432779 -0.125616 -0.202365
+v 0.383459 -0.126000 -0.215784
+v 0.450000 -0.126000 -0.161784
+v 0.450000 0.000000 0.000000
+v 0.432723 0.000000 -0.202132
+v 0.383459 0.000000 -0.215784
+v 0.450000 0.000000 -0.161784
+v 0.000000 -0.180000 0.000000
+v -0.427922 -0.161606 0.000000
+v -0.416882 -0.151013 -0.189181
+v 0.000000 -0.157800 -0.197587
+v -0.383459 -0.180000 0.000000
+v -0.383459 -0.157800 -0.197587
+v -0.427922 -0.161606 -0.161784
+v 0.000000 -0.180000 -0.161784
+v -0.383459 -0.180000 -0.161784
+v -0.450000 -0.126000 0.000000
+v -0.432779 -0.125616 -0.202365
+v 0.000000 -0.126000 -0.215784
+v -0.383459 -0.126000 -0.215784
+v -0.450000 -0.126000 -0.161784
+v -0.450000 0.000000 0.000000
+v -0.432723 0.000000 -0.202132
+v 0.000000 0.000000 -0.215784
+v -0.383459 0.000000 -0.215784
+v -0.450000 0.000000 -0.161784
+vt 0.736296 0.734058
+vt 0.500643 0.743520
+vt 0.500362 0.637947
+vt 0.837408 0.612007
+vt 0.834584 0.645864
+vt 0.730556 0.620368
+vt 0.734629 0.582637
+vt 0.749262 0.590630
+vt 0.500288 0.610193
+vt 0.755018 0.568012
+vt 0.839541 0.583855
+vt 0.717484 0.591376
+vt 0.712524 0.570102
+vt 0.500224 0.586196
+vt 0.735447 0.565260
+vt 0.734762 0.501989
+vt 0.756709 0.501913
+vt 0.500002 0.502775
+vt 0.708830 0.502077
+vt 0.842604 0.501613
+vt 0.264945 0.735621
+vt 0.270081 0.621896
+vt 0.166203 0.648090
+vt 0.163195 0.614255
+vt 0.265807 0.584195
+vt 0.282998 0.592819
+vt 0.160910 0.586119
+vt 0.245341 0.569708
+vt 0.251218 0.592286
+vt 0.264896 0.566824
+vt 0.287844 0.571513
+vt 0.243294 0.503622
+vt 0.265242 0.503551
+vt 0.291174 0.503466
+vt 0.157399 0.503902
+vt 0.500934 0.853308
+vt 0.941713 0.642142
+vt 0.951578 0.604167
+vt 0.968122 0.623010
+vt 0.501012 0.882459
+vt 0.738745 0.848046
+vt 0.931097 0.581575
+vt 0.932938 0.607778
+vt 0.955207 0.583085
+vt 0.985107 0.598851
+vt 0.739681 0.902895
+vt 0.501079 0.907860
+vt 0.935388 0.501282
+vt 0.963040 0.501182
+vt 0.741078 0.990924
+vt 0.501311 0.995378
+vt 0.999949 0.501047
+vt 0.059065 0.645100
+vt 0.048991 0.607196
+vt 0.067650 0.610678
+vt 0.263101 0.849623
+vt 0.069348 0.584464
+vt 0.032552 0.626152
+vt 0.015434 0.602112
+vt 0.262456 0.904477
+vt 0.045246 0.586140
+vt 0.036960 0.504291
+vt 0.064611 0.504202
+vt 0.261526 0.992513
+vt 0.000049 0.504410
+vt 0.499642 0.367606
+vt 0.499361 0.262038
+vt 0.735045 0.269934
+vt 0.729910 0.383652
+vt 0.833769 0.357438
+vt 0.836784 0.391268
+vt 0.734188 0.421348
+vt 0.716998 0.412727
+vt 0.499716 0.395359
+vt 0.839075 0.419400
+vt 0.754653 0.435831
+vt 0.748775 0.413256
+vt 0.735100 0.438717
+vt 0.712155 0.434032
+vt 0.499780 0.419355
+vt 0.263722 0.271498
+vt 0.162621 0.393515
+vt 0.165454 0.359662
+vt 0.269461 0.385180
+vt 0.265384 0.422906
+vt 0.250754 0.414912
+vt 0.244996 0.437526
+vt 0.160482 0.421664
+vt 0.282529 0.414171
+vt 0.287486 0.435443
+vt 0.264565 0.440282
+vt 0.499070 0.152257
+vt 0.940896 0.360393
+vt 0.950979 0.398289
+vt 0.932321 0.394814
+vt 0.736888 0.155940
+vt 0.498993 0.123107
+vt 0.930630 0.421027
+vt 0.967411 0.379329
+vt 0.984535 0.403359
+vt 0.498925 0.097707
+vt 0.737533 0.101089
+vt 0.954730 0.419342
+vt 0.498693 0.010195
+vt 0.738463 0.013059
+vt 0.058336 0.363344
+vt 0.048459 0.401312
+vt 0.031922 0.382463
+vt 0.261274 0.157517
+vt 0.068933 0.423912
+vt 0.067099 0.397709
+vt 0.044823 0.422391
+vt 0.014928 0.406612
+vt 0.260338 0.102671
+vt 0.258941 0.014648
+vt 0.739249 0.877387
+vt 0.262753 0.878967
+vt 0.737237 0.126597
+vt 0.260770 0.128177
+vn 0.194900 0.980800 0.000000
+vn 0.000000 1.000000 0.000000
+vn 0.000000 0.961700 0.273900
+vn 0.647300 0.762200 0.000000
+vn 0.178700 0.949500 0.257800
+vn 0.457300 0.661600 0.594300
+vn 0.631200 0.737600 0.239800
+vn 0.000000 0.694500 0.719500
+vn 0.939500 0.276000 0.202600
+vn 0.961700 0.274000 0.000000
+vn 0.151600 0.685100 0.712500
+vn 0.135500 0.258500 0.956400
+vn 0.000000 0.256900 0.966400
+vn 0.632300 0.305000 0.712100
+vn 0.658300 0.000000 0.752800
+vn 0.979700 0.000000 0.200600
+vn 0.000000 0.000000 1.000000
+vn 0.134200 0.000000 0.990900
+vn 1.000000 0.000000 0.000000
+vn -0.194900 0.980800 0.000000
+vn -0.178700 0.949500 0.257800
+vn -0.647300 0.762200 0.000000
+vn -0.457300 0.661600 0.594300
+vn -0.151600 0.685100 0.712500
+vn -0.961700 0.274000 0.000000
+vn -0.939500 0.276000 0.202600
+vn -0.631200 0.737600 0.239800
+vn -0.632300 0.305000 0.712100
+vn -0.135500 0.258500 0.956400
+vn -0.979700 0.000000 0.200600
+vn -0.658300 0.000000 0.752800
+vn -0.134200 0.000000 0.990900
+vn -1.000000 0.000000 0.000000
+vn 0.000000 0.961700 -0.273900
+vn 0.178700 0.949500 -0.257800
+vn 0.457300 0.661600 -0.594300
+vn 0.151600 0.685100 -0.712500
+vn 0.000000 0.694500 -0.719500
+vn 0.939500 0.276000 -0.202600
+vn 0.631200 0.737600 -0.239800
+vn 0.632300 0.305000 -0.712100
+vn 0.135500 0.258500 -0.956400
+vn 0.000000 0.256900 -0.966400
+vn 0.979700 0.000000 -0.200600
+vn 0.658300 0.000000 -0.752800
+vn 0.134200 0.000000 -0.990900
+vn 0.000000 0.000000 -1.000000
+vn -0.178700 0.949500 -0.257800
+vn -0.457300 0.661600 -0.594300
+vn -0.631200 0.737600 -0.239800
+vn -0.939500 0.276000 -0.202600
+vn -0.151600 0.685100 -0.712500
+vn -0.135500 0.258500 -0.956400
+vn -0.632300 0.305000 -0.712100
+vn -0.658300 0.000000 -0.752800
+vn -0.979700 0.000000 -0.200600
+vn -0.134200 0.000000 -0.990900
+vn 0.000000 -0.961700 0.273900
+vn 0.000000 -1.000000 0.000000
+vn 0.194900 -0.980800 0.000000
+vn 0.178700 -0.949500 0.257800
+vn 0.647300 -0.762200 0.000000
+vn 0.457300 -0.661600 0.594300
+vn 0.151600 -0.685100 0.712500
+vn 0.000000 -0.694500 0.719500
+vn 0.961700 -0.274000 0.000000
+vn 0.939500 -0.276000 0.202600
+vn 0.631200 -0.737600 0.239800
+vn 0.632300 -0.305000 0.712100
+vn 0.135500 -0.258500 0.956400
+vn 0.000000 -0.256900 0.966400
+vn -0.194900 -0.980800 0.000000
+vn -0.647300 -0.762200 0.000000
+vn -0.178700 -0.949500 0.257800
+vn -0.457300 -0.661600 0.594300
+vn -0.631200 -0.737600 0.239800
+vn -0.939500 -0.276000 0.202600
+vn -0.961700 -0.274000 0.000000
+vn -0.151600 -0.685100 0.712500
+vn -0.135500 -0.258500 0.956400
+vn -0.632300 -0.305000 0.712100
+vn 0.000000 -0.961700 -0.273900
+vn 0.178700 -0.949500 -0.257800
+vn 0.457300 -0.661600 -0.594300
+vn 0.631200 -0.737600 -0.239800
+vn 0.000000 -0.694500 -0.719500
+vn 0.939500 -0.276000 -0.202600
+vn 0.151600 -0.685100 -0.712500
+vn 0.135500 -0.258500 -0.956400
+vn 0.000000 -0.256900 -0.966400
+vn 0.632300 -0.305000 -0.712100
+vn -0.178700 -0.949500 -0.257800
+vn -0.457300 -0.661600 -0.594300
+vn -0.151600 -0.685100 -0.712500
+vn -0.939500 -0.276000 -0.202600
+vn -0.631200 -0.737600 -0.239800
+vn -0.632300 -0.305000 -0.712100
+vn -0.135500 -0.258500 -0.956400
+usemtl Material.004
+s 1
+f 20/1/1 28/2/2 12/3/3
+f 18/4/4 20/5/1 4/6/5
+f 1/7/6 3/8/7 4/6/5
+f 4/6/5 12/3/3 9/9/8
+f 3/8/7 7/10/9 24/11/10
+f 1/7/6 2/12/11 6/13/12
+f 9/9/8 15/14/13 6/13/12
+f 1/7/6 5/15/14 7/10/9
+f 5/15/14 49/16/15 51/17/16
+f 15/14/13 63/18/17 50/19/18
+f 5/15/14 6/13/12 50/19/18
+f 7/10/9 51/17/16 76/20/19
+f 12/3/3 28/2/2 32/21/20
+f 13/22/21 32/23/20 29/24/22
+f 8/25/23 10/26/24 13/22/21
+f 9/9/8 12/3/3 13/22/21
+f 37/27/25 17/28/26 11/29/27
+f 8/25/23 14/30/28 16/31/29
+f 16/31/29 15/14/13 9/9/8
+f 17/28/26 14/30/28 8/25/23
+f 65/32/30 62/33/31 14/30/28
+f 64/34/32 63/18/17 15/14/13
+f 14/30/28 62/33/31 64/34/32
+f 94/35/33 65/32/30 17/28/26
+f 35/36/34 28/2/2 20/1/1
+f 23/37/35 20/5/1 18/4/4
+f 19/38/36 21/39/37 23/37/35
+f 31/40/38 35/36/34 23/41/35
+f 24/11/10 27/42/39 22/43/40
+f 19/38/36 25/44/41 26/45/42
+f 26/46/42 39/47/43 31/40/38
+f 27/42/39 25/44/41 19/38/36
+f 79/48/44 77/49/45 25/44/41
+f 78/50/46 96/51/47 39/47/43
+f 25/44/41 77/49/45 78/52/46
+f 76/20/19 79/48/44 27/42/39
+f 32/21/20 28/2/2 35/36/34
+f 29/24/22 32/23/20 36/53/48
+f 30/54/49 34/55/50 36/53/48
+f 36/56/48 35/36/34 31/40/38
+f 34/55/50 41/57/51 37/27/25
+f 30/54/49 33/58/52 40/59/53
+f 31/40/38 39/47/43 40/60/53
+f 30/54/49 38/61/54 41/57/51
+f 38/61/54 95/62/55 98/63/56
+f 39/47/43 96/51/47 97/64/57
+f 38/61/54 40/59/53 97/65/57
+f 41/57/51 98/63/56 94/35/33
+f 56/66/58 80/67/59 68/68/60
+f 45/69/61 68/70/60 66/71/62
+f 42/72/63 43/73/64 45/69/61
+f 53/74/65 56/66/58 45/69/61
+f 72/75/66 48/76/67 44/77/68
+f 42/72/63 46/78/69 47/79/70
+f 47/79/70 59/80/71 53/74/65
+f 48/76/67 46/78/69 42/72/63
+f 51/17/16 49/16/15 46/78/69
+f 50/19/18 63/18/17 59/80/71
+f 46/78/69 49/16/15 50/19/18
+f 76/20/19 51/17/16 48/76/67
+f 84/81/72 80/67/59 56/66/58
+f 81/82/73 84/83/72 57/84/74
+f 52/85/75 55/86/76 57/84/74
+f 57/84/74 56/66/58 53/74/65
+f 55/86/76 61/87/77 89/88/78
+f 52/85/75 54/89/79 60/90/80
+f 53/74/65 59/80/71 60/90/80
+f 52/85/75 58/91/81 61/87/77
+f 58/91/81 62/33/31 65/32/30
+f 59/80/71 63/18/17 64/34/32
+f 58/91/81 60/90/80 64/34/32
+f 61/87/77 65/32/30 94/35/33
+f 68/68/60 80/67/59 87/92/82
+f 66/71/62 68/70/60 71/93/83
+f 67/94/84 70/95/85 71/93/83
+f 71/96/83 87/92/82 83/97/86
+f 70/95/85 75/98/87 72/75/66
+f 67/94/84 69/99/88 74/100/89
+f 83/97/86 91/101/90 74/102/89
+f 67/94/84 73/103/91 75/98/87
+f 73/103/91 77/49/45 79/48/44
+f 91/101/90 96/104/47 78/105/46
+f 73/103/91 74/100/89 78/52/46
+f 75/98/87 79/48/44 76/20/19
+f 87/92/82 80/67/59 84/81/72
+f 88/106/92 84/83/72 81/82/73
+f 82/107/93 85/108/94 88/106/92
+f 83/97/86 87/92/82 88/109/92
+f 89/88/78 93/110/95 86/111/96
+f 82/107/93 90/112/97 92/113/98
+f 92/114/98 91/101/90 83/97/86
+f 93/110/95 90/112/97 82/107/93
+f 98/63/56 95/62/55 90/112/97
+f 97/115/57 96/104/47 91/101/90
+f 90/112/97 95/62/55 97/65/57
+f 94/35/33 98/63/56 93/110/95
+f 4/6/5 20/1/1 12/3/3
+f 3/8/7 18/4/4 4/6/5
+f 2/12/11 1/7/6 4/6/5
+f 2/12/11 4/6/5 9/9/8
+f 18/4/4 3/8/7 24/11/10
+f 5/15/14 1/7/6 6/13/12
+f 2/12/11 9/9/8 6/13/12
+f 3/8/7 1/7/6 7/10/9
+f 7/10/9 5/15/14 51/17/16
+f 6/13/12 15/14/13 50/19/18
+f 49/16/15 5/15/14 50/19/18
+f 24/11/10 7/10/9 76/20/19
+f 13/22/21 12/3/3 32/21/20
+f 11/29/27 13/22/21 29/24/22
+f 11/29/27 8/25/23 13/22/21
+f 10/26/24 9/9/8 13/22/21
+f 29/24/22 37/27/25 11/29/27
+f 10/26/24 8/25/23 16/31/29
+f 10/26/24 16/31/29 9/9/8
+f 11/29/27 17/28/26 8/25/23
+f 17/28/26 65/32/30 14/30/28
+f 16/31/29 64/34/32 15/14/13
+f 16/31/29 14/30/28 64/34/32
+f 37/27/25 94/35/33 17/28/26
+f 23/41/35 35/36/34 20/1/1
+f 22/43/40 23/37/35 18/4/4
+f 22/43/40 19/38/36 23/37/35
+f 21/116/37 31/40/38 23/41/35
+f 18/4/4 24/11/10 22/43/40
+f 21/39/37 19/38/36 26/45/42
+f 21/116/37 26/46/42 31/40/38
+f 22/43/40 27/42/39 19/38/36
+f 27/42/39 79/48/44 25/44/41
+f 26/46/42 78/50/46 39/47/43
+f 26/45/42 25/44/41 78/52/46
+f 24/11/10 76/20/19 27/42/39
+f 36/56/48 32/21/20 35/36/34
+f 34/55/50 29/24/22 36/53/48
+f 33/58/52 30/54/49 36/53/48
+f 33/117/52 36/56/48 31/40/38
+f 29/24/22 34/55/50 37/27/25
+f 38/61/54 30/54/49 40/59/53
+f 33/117/52 31/40/38 40/60/53
+f 34/55/50 30/54/49 41/57/51
+f 41/57/51 38/61/54 98/63/56
+f 40/60/53 39/47/43 97/64/57
+f 95/62/55 38/61/54 97/65/57
+f 37/27/25 41/57/51 94/35/33
+f 45/69/61 56/66/58 68/68/60
+f 44/77/68 45/69/61 66/71/62
+f 44/77/68 42/72/63 45/69/61
+f 43/73/64 53/74/65 45/69/61
+f 66/71/62 72/75/66 44/77/68
+f 43/73/64 42/72/63 47/79/70
+f 43/73/64 47/79/70 53/74/65
+f 44/77/68 48/76/67 42/72/63
+f 48/76/67 51/17/16 46/78/69
+f 47/79/70 50/19/18 59/80/71
+f 47/79/70 46/78/69 50/19/18
+f 72/75/66 76/20/19 48/76/67
+f 57/84/74 84/81/72 56/66/58
+f 55/86/76 81/82/73 57/84/74
+f 54/89/79 52/85/75 57/84/74
+f 54/89/79 57/84/74 53/74/65
+f 81/82/73 55/86/76 89/88/78
+f 58/91/81 52/85/75 60/90/80
+f 54/89/79 53/74/65 60/90/80
+f 55/86/76 52/85/75 61/87/77
+f 61/87/77 58/91/81 65/32/30
+f 60/90/80 59/80/71 64/34/32
+f 62/33/31 58/91/81 64/34/32
+f 89/88/78 61/87/77 94/35/33
+f 71/96/83 68/68/60 87/92/82
+f 70/95/85 66/71/62 71/93/83
+f 69/99/88 67/94/84 71/93/83
+f 69/118/88 71/96/83 83/97/86
+f 66/71/62 70/95/85 72/75/66
+f 73/103/91 67/94/84 74/100/89
+f 69/118/88 83/97/86 74/102/89
+f 70/95/85 67/94/84 75/98/87
+f 75/98/87 73/103/91 79/48/44
+f 74/102/89 91/101/90 78/105/46
+f 77/49/45 73/103/91 78/52/46
+f 72/75/66 75/98/87 76/20/19
+f 88/109/92 87/92/82 84/81/72
+f 86/111/96 88/106/92 81/82/73
+f 86/111/96 82/107/93 88/106/92
+f 85/119/94 83/97/86 88/109/92
+f 81/82/73 89/88/78 86/111/96
+f 85/108/94 82/107/93 92/113/98
+f 85/119/94 92/114/98 83/97/86
+f 86/111/96 93/110/95 82/107/93
+f 93/110/95 98/63/56 90/112/97
+f 92/114/98 97/115/57 91/101/90
+f 92/113/98 90/112/97 97/65/57
+f 89/88/78 94/35/33 93/110/95

assets/Models/Brick/KrakenBrick.mtl

@@ -0,0 +1,22 @@
+# Blender MTL File: 'Bricks.blend'
+# Material Count: 2
+
+newmtl Arm
+Ns 96.078431
+Ka 0.000000 0.000000 0.000000
+Kd 0.640000 0.640000 0.640000
+Ks 0.250000 0.250000 0.250000
+Ni 1.000000
+d 1.000000
+illum 2
+map_Kd texture.png
+
+newmtl Brick
+Ns 96.078431
+Ka 0.000000 0.000000 0.000000
+Kd 0.640000 0.640000 0.640000
+Ks 0.500000 0.500000 0.500000
+Ni 1.000000
+d 1.000000
+illum 2
+map_Kd White.png

assets/Models/Halfpipe.mtl

@@ -1,14 +1,14 @@
-# Blender MTL File: 'None'
+# Blender MTL File: 'Background.blend'
 # Material Count: 1
 
 newmtl Material.001
-Ns 96.078431
+Ns 92.156863
 Ka 0.000000 0.000000 0.000000
-Kd 0.640000 0.640000 0.640000
+Kd 0.512000 0.512000 0.512000
 Ks 0.500000 0.500000 0.500000
 Ni 1.000000
 d 1.000000
 illum 2
-map_Kd Test/Brick_Diffuse.png
-map_Bump Test/Brick_Normal.png
-map_Ks Test/Brick_Specular.png
+map_Kd Brunn_Diffuse.png
+map_Bump Brunn_Normals.png
+map_Ks Brunn_Specular.png

assets/Models/Halfpipe.obj

@@ -1,11 +1,10 @@
-# Blender v2.75 (sub 0) OBJ File: ''
+# Blender v2.75 (sub 0) OBJ File: 'Background.blend'
 # www.blender.org
 mtllib Halfpipe.mtl
 o Cylinder
-v 0.000000 -2.908792 -1.000000
-v 0.000000 2.908792 -1.000000
 v 0.195090 -2.908792 -0.980785
 v 0.195090 2.908792 -0.980785
+v 0.000000 2.908792 -1.000000
 v 0.382683 -2.908792 -0.923880
 v 0.382683 2.908792 -0.923880
 v 0.555570 -2.908792 -0.831470
@@ -19,11 +18,10 @@ v 0.923880 2.908792 -0.382683
 v 0.980785 -2.908792 -0.195090
 v 0.980785 2.908792 -0.195090
 v 1.000000 -2.908792 -0.000000
-v 1.000000 2.908792 -0.000000
-v -1.000000 -2.908792 -0.000001
-v -1.000000 2.908792 -0.000001
+v 1.000000 2.908792 0.000000
 v -0.980785 -2.908792 -0.195091
 v -0.980785 2.908792 -0.195091
+v -1.000000 2.908792 -0.000001
 v -0.923879 -2.908792 -0.382684
 v -0.923879 2.908792 -0.382684
 v -0.831469 -2.908792 -0.555571
@@ -34,91 +32,91 @@ v -0.555569 -2.908792 -0.831470
 v -0.555569 2.908792 -0.831470
 v -0.382682 -2.908792 -0.923880
 v -0.382682 2.908792 -0.923880
-v -0.195089 -2.908792 -0.980786
+v 0.000000 -2.908792 -1.000000
 v -0.195089 2.908792 -0.980786
-vt -1.156714 -1.419990
-vt -1.158346 2.336063
-vt -1.031779 2.336118
-vt -1.283288 -1.420045
-vt -1.284913 2.336008
-vt -1.409862 -1.420100
-vt -1.411480 2.335954
-vt -1.536436 -1.420155
-vt -1.538048 2.335899
-vt 2.387354 -1.418355
-vt 2.385534 2.337692
-vt 2.512101 2.337753
-vt 2.260782 -1.418416
-vt 2.258967 2.337631
-vt 2.134208 -1.418478
-vt 2.132400 2.337570
-vt 2.007634 -1.418538
-vt 2.005832 2.337510
-vt -0.144122 -1.419541
-vt -0.145809 2.336510
-vt -0.019241 2.336567
-vt -0.270696 -1.419598
-vt -0.272376 2.336454
-vt -0.397270 -1.419654
-vt -0.398943 2.336397
-vt -0.523844 -1.419711
-vt -0.525511 2.336341
-vt -0.650418 -1.419767
-vt -0.652078 2.336285
-vt -0.776992 -1.419823
-vt -0.778645 2.336229
-vt -1.030140 -1.419935
-vt -0.905212 2.336174
-vt -0.903566 -1.419879
-vt 2.513929 -1.418293
-vt -0.017548 -1.419484
-vn -0.098000 0.000000 0.995200
-vn -0.290300 0.000000 0.956900
-vn -0.471400 0.000000 0.881900
-vn -0.634400 0.000000 0.773000
-vn -0.773000 0.000000 0.634400
-vn -0.881900 0.000000 0.471400
-vn -0.956900 0.000000 0.290300
-vn -0.995200 0.000000 0.098000
-vn 0.995200 0.000000 0.098000
-vn 0.956900 0.000000 0.290300
-vn 0.881900 0.000000 0.471400
-vn 0.773000 0.000000 0.634400
-vn 0.634400 0.000000 0.773000
-vn 0.471400 0.000000 0.881900
-vn 0.098000 0.000000 0.995200
-vn 0.290300 0.000000 0.956900
+v -0.195089 -2.908792 -0.980787
+v -1.000000 -2.908792 -0.000001
+vt 0.572383 0.000045
+vt 0.572387 1.000008
+vt 0.515062 1.000008
+vt 0.629704 0.000045
+vt 0.629712 1.000008
+vt 0.687026 0.000045
+vt 0.687036 1.000008
+vt 0.744348 0.000044
+vt 0.744361 1.000008
+vt 0.801670 0.000044
+vt 0.801686 1.000007
+vt 0.858992 0.000044
+vt 0.859011 1.000007
+vt 0.916314 0.000043
+vt 0.916335 1.000006
+vt 0.973636 0.000043
+vt 0.973661 1.000006
+vt 0.113808 0.000043
+vt 0.113788 1.000007
+vt 0.056463 1.000007
+vt 0.171130 0.000044
+vt 0.171113 1.000008
+vt 0.228452 0.000044
+vt 0.228437 1.000008
+vt 0.285774 0.000044
+vt 0.285762 1.000008
+vt 0.343096 0.000045
+vt 0.343087 1.000008
+vt 0.400418 0.000045
+vt 0.400412 1.000008
+vt 0.515061 0.000045
+vt 0.457737 1.000008
+vt 0.457739 0.000045
+vt 0.056486 0.000043
+vn -0.098000 -0.000000 0.995200
+vn -0.290300 -0.000000 0.956900
+vn -0.471400 -0.000000 0.881900
+vn -0.634400 -0.000000 0.773000
+vn -0.773000 -0.000000 0.634400
+vn -0.881900 -0.000000 0.471400
+vn -0.956900 -0.000000 0.290300
+vn -0.995200 -0.000000 0.098000
+vn 0.995200 -0.000000 0.098000
+vn 0.956900 -0.000000 0.290300
+vn 0.881900 -0.000000 0.471400
+vn 0.773000 -0.000000 0.634400
+vn 0.634400 -0.000000 0.773000
+vn 0.471400 -0.000000 0.881900
+vn 0.098000 -0.000000 0.995200
+vn 0.290300 -0.000000 0.956900
 usemtl Material.001
-s off
-f 3/1/1 4/2/1 2/3/1
-f 5/4/2 6/5/2 4/2/2
-f 7/6/3 8/7/3 6/5/3
-f 9/8/4 10/9/4 8/7/4
-f 11/10/5 12/11/5 10/12/5
-f 13/13/6 14/14/6 12/11/6
-f 15/15/7 16/16/7 14/14/7
-f 17/17/8 18/18/8 16/16/8
-f 21/19/9 22/20/9 20/21/9
-f 23/22/10 24/23/10 22/20/10
-f 25/24/11 26/25/11 24/23/11
-f 27/26/12 28/27/12 26/25/12
-f 29/28/13 30/29/13 28/27/13
-f 31/30/14 32/31/14 30/29/14
-f 1/32/15 2/3/15 34/33/15
-f 33/34/16 34/33/16 32/31/16
-f 1/32/1 3/1/1 2/3/1
-f 3/1/2 5/4/2 4/2/2
-f 5/4/3 7/6/3 6/5/3
-f 7/6/4 9/8/4 8/7/4
-f 9/35/5 11/10/5 10/12/5
-f 11/10/6 13/13/6 12/11/6
-f 13/13/7 15/15/7 14/14/7
-f 15/15/8 17/17/8 16/16/8
-f 19/36/9 21/19/9 20/21/9
-f 21/19/10 23/22/10 22/20/10
-f 23/22/11 25/24/11 24/23/11
-f 25/24/12 27/26/12 26/25/12
-f 27/26/13 29/28/13 28/27/13
-f 29/28/14 31/30/14 30/29/14
-f 33/34/15 1/32/15 34/33/15
-f 31/30/16 33/34/16 32/31/16
+s 1
+f 1/1/1 2/2/1 3/3/1
+f 4/4/2 5/5/2 2/2/2
+f 6/6/3 7/7/3 5/5/3
+f 8/8/4 9/9/4 7/7/4
+f 10/10/5 11/11/5 9/9/5
+f 12/12/6 13/13/6 11/11/6
+f 14/14/7 15/15/7 13/13/7
+f 16/16/8 17/17/8 15/15/8
+f 18/18/9 19/19/9 20/20/9
+f 21/21/10 22/22/10 19/19/10
+f 23/23/11 24/24/11 22/22/11
+f 25/25/12 26/26/12 24/24/12
+f 27/27/13 28/28/13 26/26/13
+f 29/29/14 30/30/14 28/28/14
+f 31/31/15 3/3/15 32/32/15
+f 33/33/16 32/32/16 30/30/16
+f 31/31/1 1/1/1 3/3/1
+f 1/1/2 4/4/2 2/2/2
+f 4/4/3 6/6/3 5/5/3
+f 6/6/4 8/8/4 7/7/4
+f 8/8/5 10/10/5 9/9/5
+f 10/10/6 12/12/6 11/11/6
+f 12/12/7 14/14/7 13/13/7
+f 14/14/8 16/16/8 15/15/8
+f 34/34/9 18/18/9 20/20/9
+f 18/18/10 21/21/10 19/19/10
+f 21/21/11 23/23/11 22/22/11
+f 23/23/12 25/25/12 24/24/12
+f 25/25/13 27/27/13 26/26/13
+f 27/27/14 29/29/14 28/28/14
+f 33/33/15 31/31/15 32/32/15
+f 29/29/16 33/33/16 30/30/16

assets/Models/Kraken/Body.mtl

@@ -0,0 +1,12 @@
+# Blender MTL File: 'Sid.blend'
+# Material Count: 1
+
+newmtl Derp
+Ns 96.078431
+Ka 0.000000 0.000000 0.000000
+Kd 0.800000 0.800000 0.800000
+Ks 0.500000 0.500000 0.500000
+Ni 1.000000
+d 1.000000
+illum 2
+map_Kd SquidTexture.png

include/Core/Engine.h

@@ -37,6 +37,7 @@
 #include "Rendering/CModel.h"
 #include "Rendering/CSprite.h"
 #include "Rendering/CPointLight.h"
+#include "Rendering/CCamera.h"
 #include "Transform/TransformSystem.h"
 #include "Sound/SoundSystem.h"
 #include "Sound/CCollisionSound.h"
@@ -48,12 +49,15 @@
 #include "Game/CLifebuoy.h"
 #include "Game/CProjectile.h"
 #include "Game/CBrick.h"
+#include "Game/CBrickPart.h"
 #include "Game/CWall.h"
 #include "Game/CKraken.h"
+#include "Game/CNewWaterVolume.h"
 #include "Game/CBackground.h"
 #include "Game/CTravels.h"
 #include "Game/CStickyAim.h"
 #include "Game/BallSystem.h"
+#include "Game/LifeSystem.h"
 #include "Game/HitLagSystem.h"
 #include "Game/TravellingSystem.h"
 #include "Game/LifebuoySystem.h"
@@ -64,6 +68,7 @@
 
 #include "Game/BrickComponents.h"
 
+#include "Game/ScreenShakeSystem.h"
 #include "Game/EScreenShake.h"
 
 #include "Physics/PhysicsSystem.h"
@@ -83,6 +88,8 @@
 #include "GUI/Button.h"
 #include "Game/GUI/MainMenu.h"
 #include "Game/GUI/HUD.h"
+#include "Game/GUI/ELoadingFrameComplete.h"
+#include "Game/GUI/LoadingFrame.h"
 
 namespace dd
 {
@@ -91,9 +98,15 @@ class Engine
 {
 
 public:
-	Engine(int argc, char* argv[]) {
-		auto config = ResourceManager::Load<ConfigFile>("Config.ini");
+	Engine(int argc, char* argv[]) 
+	{
+		ResourceManager::RegisterType<Texture>("Texture");
+		ResourceManager::RegisterType<Model>("Model");
+		ResourceManager::RegisterType<Sound>("Sound");
+		ResourceManager::RegisterType<ConfigFile>("ConfigFile");
+		ResourceManager::LoadPreloadsFromFile();
 
+		auto config = ResourceManager::Load<ConfigFile>("Config.ini");
 		LOG_LEVEL = static_cast<_LOG_LEVEL>(config->GetValue<int>("Debug.LogLevel", 1));
 
 		m_EventBroker = std::make_shared<EventBroker>();
@@ -111,15 +124,11 @@ public:
 		m_FrameStack = new GUI::Frame(m_EventBroker.get());
 		m_FrameStack->Width = 675;
 		m_FrameStack->Height = 1080;
-
-		if (config->GetValue<bool>("Debug.SkipStory", false)) {
-			Events::GameStart e;
-			m_EventBroker->Publish(e);
-			auto hud = new GUI::HUD(m_FrameStack, "HUD");
-		}
-		else {
-			auto menu = new GUI::MainMenu(m_FrameStack, "MainMenu");
-		}
+		m_MainMenu = new GUI::MainMenu(m_FrameStack, "MainMenu");
+		m_MainMenu->Hide();
+		m_LoadingFrame = new GUI::LoadingFrame(m_FrameStack, "Loading");
+		m_LoadingFrame->SetTexture("Textures/GUI/Loading.png");
+		PreloadAllTheShit();
 
 		m_InputManager = std::make_shared<InputManager>(m_Renderer->Window(), m_EventBroker);
 
@@ -140,12 +149,15 @@ public:
 
 		m_World->ComponentFactory.Register<Components::Sprite>();
 
+		m_World->ComponentFactory.Register<Components::Camera>();
 		m_World->ComponentFactory.Register<Components::RectangleShape>();
 		m_World->ComponentFactory.Register<Components::Physics>();
 		m_World->ComponentFactory.Register<Components::Ball>();
 		m_World->ComponentFactory.Register<Components::Brick>();
+		m_World->ComponentFactory.Register<Components::BrickPart>();
 		m_World->ComponentFactory.Register<Components::Pad>();
 		m_World->ComponentFactory.Register<Components::Wall>();
+		m_World->ComponentFactory.Register<Components::NewWaterVolume>();
 		m_World->ComponentFactory.Register<Components::Background>();
 		m_World->ComponentFactory.Register<Components::Life>();
 		m_World->ComponentFactory.Register<Components::Lifebuoy>();
@@ -197,6 +209,12 @@ public:
 		m_World->SystemFactory.Register<Systems::WaterSystem>(
 			[this]() { return new Systems::WaterSystem(m_World.get(), m_EventBroker); });
 		m_World->AddSystem<Systems::WaterSystem>();
+		m_World->SystemFactory.Register<Systems::LifeSystem>(
+			[this]() { return new Systems::LifeSystem(m_World.get(), m_EventBroker); });
+		m_World->AddSystem<Systems::LifeSystem>();
+		m_World->SystemFactory.Register<Systems::ScreenShakeSystem>(
+			[this]() { return new Systems::ScreenShakeSystem(m_World.get(), m_EventBroker); });
+		m_World->AddSystem<Systems::ScreenShakeSystem>();
 
 		m_World->ComponentFactory.Register<Components::Model>();
 		m_World->ComponentFactory.Register<Components::Template>();
@@ -207,13 +225,29 @@ public:
 		m_World->Initialize();
 
 		//auto particleEmitter= m_World->AddComponent<Components::Emitter>(Pe);
-		//EVENT_SUBSCRIBE_MEMBER(m_EGameStart, &Engine::OnGameStart);
+
 		m_EGameStart = decltype(m_EGameStart)(std::bind(&Engine::OnGameStart, this, std::placeholders::_1));
 		m_EventBroker->Subscribe(m_EGameStart);
+		m_ELoadingFrameComplete = decltype(m_ELoadingFrameComplete)(std::bind(&Engine::OnLoadingFrameComplete, this, std::placeholders::_1));
+		m_EventBroker->Subscribe(m_ELoadingFrameComplete);
 
 		m_LastTime = glfwGetTime();
 	}
 
+	void PreloadAllTheShit()
+	{
+		if (ResourceManager::Load<ConfigFile>("Config.ini")->GetValue<bool>("Debug.SkipPreload", false)) {
+			m_LoadingFrame->Hide();
+			m_MainMenu->Show();
+			return;
+		}
+
+		for (auto& pair : ResourceManager::GetPreloads()) {
+			m_LoadingFrame->AddResource(pair.first, pair.second);
+		}
+		m_LoadingFrame->Preload();
+	}
+
 	bool Running() const { return !glfwWindowShouldClose(m_Renderer->Window()); }
 
 	void Tick()
@@ -243,8 +277,6 @@ public:
 			TEMPAddToRenderQueue();
 		}
 
-		std::unique_ptr<dd::Camera> defaultCamera = nullptr;
-
 		// Render scene
 		//TODO send renderqueue to draw.
 		m_Renderer->Draw(m_RendererQueue);
@@ -264,6 +296,20 @@ public:
 	{
 		if (!m_TransformSystem)
 			m_TransformSystem = m_World->GetSystem<Systems::TransformSystem>();
+		
+		// HACK: How do we handle multiple cameras? Maybe view and projection matrices in render queue...
+		auto cameras = m_World->GetComponentsOfType<Components::Camera>();
+		if (cameras != nullptr) {
+			for (auto& component : *cameras) {
+				auto camera = static_cast<Components::Camera*>(component.get());
+				auto transform = m_World->GetComponent<Components::Transform>(camera->Entity);
+				m_Renderer->Camera()->SetPosition(transform->Position);
+				m_Renderer->Camera()->SetOrientation(transform->Orientation);
+				m_Renderer->Camera()->SetFOV(camera->FOV);
+				m_Renderer->Camera()->SetNearClip(camera->NearClip);
+				m_Renderer->Camera()->SetFarClip(camera->FarClip);
+			}
+		}
 
 		for (auto &pair : *m_World->GetEntities())
 		{
@@ -361,13 +407,11 @@ public:
 			job.ModelMatrix = modelMatrix * model->m_Matrix;
 			job.Color = modelComponent->Color;
 			
-			if (model->m_Skeleton != nullptr) {
+			if (model->m_Skeleton != nullptr && animationComponent != nullptr) {
 				job.Skeleton = model->m_Skeleton;
-				if (animationComponent != nullptr) {
-					job.AnimationName = animationComponent->Name;
-					job.AnimationTime = animationComponent->Time;
-					job.NoRootMotion = animationComponent->NoRootMotion;
-				}
+				job.AnimationName = animationComponent->Name;
+				job.AnimationTime = animationComponent->Time;
+				job.NoRootMotion = animationComponent->NoRootMotion;
 			}
 
 			m_RendererQueue.Deferred.Add(job);
@@ -415,6 +459,8 @@ public:
 private:
 	std::shared_ptr<EventBroker> m_EventBroker;
 	GUI::Frame* m_FrameStack = nullptr;
+	GUI::MainMenu* m_MainMenu = nullptr;
+	GUI::LoadingFrame* m_LoadingFrame = nullptr;
 	std::shared_ptr<Renderer> m_Renderer;
 	RenderQueueCollection m_RendererQueue;
 	std::shared_ptr<InputManager> m_InputManager;
@@ -444,6 +490,17 @@ private:
 
 		return true;
 	};
+
+	EventRelay<Engine, Events::LoadingFrameComplete> m_ELoadingFrameComplete;
+	bool OnLoadingFrameComplete(const Events::LoadingFrameComplete& event)
+	{
+		if (event.FrameName == "Loading") {
+			event.Frame->Hide();
+			m_MainMenu->Show();
+		}
+		return true;
+	}
+
 	double m_LastTime;
 };
 

include/Core/Engine.h.orig

@@ -0,0 +1,649 @@
+/*
+	This file is part of Daydream Engine.
+	Copyright 2014 Adam Byléhn, Tobias Dahl, Simon Holmberg, Viktor Ljung
+	
+	Daydream Engine is free software: you can redistribute it and/or modify
+	it under the terms of the GNU Lesser General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+	
+	Daydream Engine is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU Lesser General Public License for more details.
+	
+	You should have received a copy of the GNU Lesser General Public License
+	along with Daydream Engine.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include <string>
+#include <sstream>
+#include <Sound/CCollisionSound.h>
+
+#include "ResourceManager.h"
+#include "OBJ.h"
+#include "Model.h"
+#include "Texture.h"
+#include "EventBroker.h"
+#include "RenderQueue.h"
+#include "Renderer.h"
+#include "InputManager.h"
+//TODO: Remove includes that are only here for the temporary draw solution.
+#include "World.h"
+#include "CTransform.h"
+#include "CTemplate.h"
+#include "Core/ConfigFile.h"
+#include "Core/EventBroker.h"
+#include "Rendering/CModel.h"
+#include "Rendering/CSprite.h"
+#include "Rendering/CPointLight.h"
+#include "Transform/TransformSystem.h"
+#include "Sound/SoundSystem.h"
+#include "Sound/CCollisionSound.h"
+
+#include "Game/LevelSystem.h"
+#include "Game/PadSystem.h"
+#include "Game/CBall.h"
+#include "Game/CPad.h"
+#include "Game/CLifebuoy.h"
+#include "Game/CProjectile.h"
+#include "Game/CBrick.h"
+#include "Game/CWall.h"
+#include "Game/CKraken.h"
+#include "Game/CBackground.h"
+#include "Game/CTravels.h"
+#include "Game/CStickyAim.h"
+#include "Game/BallSystem.h"
+#include "Game/HitLagSystem.h"
+#include "Game/TravellingSystem.h"
+#include "Game/LifebuoySystem.h"
+#include "Game/ProjectileSystem.h"
+#include "Game/KrakenSystem.h"
+#include "Game/Bricks/CPowerUpBrick.h"
+
+#include "Game/BrickComponents.h"
+
+#include "Game/EScreenShake.h"
+
+#include "Physics/PhysicsSystem.h"
+#include "Physics/CPhysics.h"
+#include "Physics/CRectangleShape.h"
+#include "Physics/ESetImpulse.h"
+#include "Physics/CWaterVolume.h"
+#include "Physics/CParticle.h"
+#include "Physics/CParticleEmitter.h"
+
+#include "Rendering/AnimationSystem.h"
+
+#include "Game/EGameStart.h"
+#include "Sound/EPlaySound.h"
+
+#include "GUI/Frame.h"
+#include "GUI/Button.h"
+#include "Game/GUI/MainMenu.h"
+#include "Game/GUI/HUD.h"
+
+namespace dd
+{
+
+class Engine
+{
+
+public:
+	Engine(int argc, char* argv[]) {
+		auto config = ResourceManager::Load<ConfigFile>("Config.ini");
+
+		LOG_LEVEL = static_cast<_LOG_LEVEL>(config->GetValue<int>("Debug.LogLevel", 1));
+
+		m_EventBroker = std::make_shared<EventBroker>();
+
+		m_Renderer = std::make_shared<Renderer>();
+		m_Renderer->SetFullscreen(config->GetValue<bool>("Video.Fullscreen", false));
+		m_Renderer->SetResolution(Rectangle(
+			0, 
+			0, 
+			config->GetValue<int>("Video.Width", 675), 
+			config->GetValue<int>("Video.Height", 1080)
+		));
+		m_Renderer->Initialize();
+
+		m_FrameStack = new GUI::Frame(m_EventBroker.get());
+		m_FrameStack->Width = 675;
+		m_FrameStack->Height = 1080;
+
+		if (config->GetValue<bool>("Debug.SkipStory", false)) {
+			Events::GameStart e;
+			m_EventBroker->Publish(e);
+			auto hud = new GUI::HUD(m_FrameStack, "HUD");
+		}
+		else {
+			auto menu = new GUI::MainMenu(m_FrameStack, "MainMenu");
+		}
+
+		m_InputManager = std::make_shared<InputManager>(m_Renderer->Window(), m_EventBroker);
+
+		m_World = std::make_shared<World>(m_EventBroker);
+
+		//TODO: Move this out of engine.h
+		m_World->ComponentFactory.Register<Components::Transform>();
+		m_World->SystemFactory.Register<Systems::TransformSystem>(
+				[this]() { return new Systems::TransformSystem(m_World.get(), m_EventBroker); });
+		m_World->AddSystem<Systems::TransformSystem>();
+		m_World->ComponentFactory.Register<Components::Model>();
+		m_World->ComponentFactory.Register<Components::Template>();
+
+		m_World->ComponentFactory.Register<Components::CollisionSound>();
+		m_World->SystemFactory.Register<Systems::SoundSystem>(
+				[this]() { return new Systems::SoundSystem(m_World.get(), m_EventBroker); });
+		m_World->AddSystem<Systems::SoundSystem>();
+
+		m_World->ComponentFactory.Register<Components::Sprite>();
+
+		m_World->ComponentFactory.Register<Components::RectangleShape>();
+		m_World->ComponentFactory.Register<Components::Physics>();
+		m_World->ComponentFactory.Register<Components::Ball>();
+		m_World->ComponentFactory.Register<Components::Brick>();
+		m_World->ComponentFactory.Register<Components::Pad>();
+		m_World->ComponentFactory.Register<Components::Wall>();
+		m_World->ComponentFactory.Register<Components::Background>();
+		m_World->ComponentFactory.Register<Components::Life>();
+		m_World->ComponentFactory.Register<Components::Lifebuoy>();
+		m_World->ComponentFactory.Register<Components::Projectile>();
+		m_World->ComponentFactory.Register<Components::Kraken>();
+		m_World->ComponentFactory.Register<Components::StickyAim>();
+		m_World->ComponentFactory.Register<Components::Travels>();
+
+		m_World->ComponentFactory.Register<Components::PowerUp>();
+		m_World->ComponentFactory.Register<Components::PowerUpBrick>();
+
+		m_World->ComponentFactory.Register<Components::StandardBrick>();
+		m_World->ComponentFactory.Register<Components::MultiBallBrick>();
+		m_World->ComponentFactory.Register<Components::LifebuoyBrick>();
+		m_World->ComponentFactory.Register<Components::StickyBrick>();
+		m_World->ComponentFactory.Register<Components::InkBlasterBrick>();
+		m_World->ComponentFactory.Register<Components::KrakenAttackBrick>();
+
+		m_World->SystemFactory.Register<Systems::LevelSystem>(
+				[this]() { return new Systems::LevelSystem(m_World.get(), m_EventBroker); });
+		m_World->AddSystem<Systems::LevelSystem>();
+		m_World->SystemFactory.Register<Systems::PadSystem>(
+				[this]() { return new Systems::PadSystem(m_World.get(), m_EventBroker); });
+		m_World->AddSystem<Systems::PadSystem>();
+		m_World->SystemFactory.Register<Systems::BallSystem>(
+				[this]() { return new Systems::BallSystem(m_World.get(), m_EventBroker); });
+		m_World->AddSystem<Systems::BallSystem>();
+		m_World->SystemFactory.Register<Systems::HitLagSystem>(
+				[this]() { return new Systems::HitLagSystem(m_World.get(), m_EventBroker); });
+		m_World->AddSystem<Systems::HitLagSystem>();
+		m_World->SystemFactory.Register<Systems::LifebuoySystem>(
+			[this]() { return new Systems::LifebuoySystem(m_World.get(), m_EventBroker); });
+		m_World->AddSystem<Systems::LifebuoySystem>();
+		m_World->SystemFactory.Register<Systems::ProjectileSystem>(
+			[this]() { return new Systems::ProjectileSystem(m_World.get(), m_EventBroker); });
+		m_World->AddSystem<Systems::ProjectileSystem>();
+		m_World->SystemFactory.Register<Systems::PhysicsSystem>(
+				[this]() { return new Systems::PhysicsSystem(m_World.get(), m_EventBroker); });
+		m_World->AddSystem<Systems::PhysicsSystem>();
+		m_World->SystemFactory.Register<Systems::AnimationSystem>(
+				[this]() { return new Systems::AnimationSystem(m_World.get(), m_EventBroker); });
+		m_World->AddSystem<Systems::AnimationSystem>();
+		m_World->SystemFactory.Register<Systems::TravellingSystem>(
+			[this]() { return new Systems::TravellingSystem(m_World.get(), m_EventBroker); });
+		m_World->AddSystem<Systems::TravellingSystem>();
+		m_World->SystemFactory.Register<Systems::KrakenSystem>(
+			[this]() { return new Systems::KrakenSystem(m_World.get(), m_EventBroker); });
+		m_World->AddSystem<Systems::KrakenSystem>();
+
+		m_World->ComponentFactory.Register<Components::Model>();
+		m_World->ComponentFactory.Register<Components::Template>();
+		m_World->ComponentFactory.Register<Components::PointLight>();
+		m_World->ComponentFactory.Register<Components::WaterVolume>();
+		m_World->ComponentFactory.Register<Components::Particle>();
+		m_World->ComponentFactory.Register<Components::ParticleEmitter>();
+		m_World->Initialize();
+
+<<<<<<< HEAD
+		//PointLightTest
+		{
+			auto t_Light = m_World->CreateEntity();
+			auto transform = m_World->AddComponent<Components::Transform>(t_Light);
+			transform->Position = glm::vec3(-3.f, 6.f, -5.f);
+			transform->Sticky = true;
+			auto pl = m_World->AddComponent<Components::PointLight>(t_Light);
+			pl->Radius = 20.f;
+			pl->Diffuse = glm::vec3(0.8f, 0.7f, 0.05f);
+			auto model = m_World->AddComponent<Components::Model>(t_Light);
+			model->ModelFile = "Models/Core/UnitSphere.obj";
+			m_World->CommitEntity(t_Light);
+		}
+		{
+			auto t_Light = m_World->CreateEntity();
+			auto transform = m_World->AddComponent<Components::Transform>(t_Light);
+			transform->Position = glm::vec3(3.f, -5.f, -5.f);
+			transform->Sticky = true;
+			auto pl = m_World->AddComponent<Components::PointLight>(t_Light);
+			pl->Radius = 15.f;
+			pl->Diffuse = glm::vec3(0.1f, 0.5f, 0.8f);
+			auto model = m_World->AddComponent<Components::Model>(t_Light);
+			model->ModelFile = "Models/Core/UnitSphere.obj";
+			m_World->CommitEntity(t_Light);
+		}
+
+		//Halfpipe background test model.
+		{
+			auto t_halfPipe = m_World->CreateEntity();
+			auto transform = m_World->AddComponent<Components::Transform>(t_halfPipe);
+			transform->Position = glm::vec3(0.f, 0.f, -15.f);
+			transform->Scale = glm::vec3(6.f, 6.f, 10.f);
+			transform->Sticky = false;
+			auto model = m_World->AddComponent<Components::Model>(t_halfPipe);
+			model->ModelFile = "Models/Test/halfpipe/Halfpipe.obj";
+			model->Color = glm::vec4(0.8f, 0.8f, 0.8f, 0.3f);
+			m_World->CommitEntity(t_halfPipe);
+		}
+		{
+			auto t_halfPipe = m_World->CreateEntity();
+			auto transform = m_World->AddComponent<Components::Transform>(t_halfPipe);
+			transform->Position = glm::vec3(0.f, 34.6f, -15.f);
+			transform->Scale = glm::vec3(6.f, 6.f, 10.f);
+			transform->Sticky = false;
+			auto model = m_World->AddComponent<Components::Model>(t_halfPipe);
+			model->ModelFile = "Models/Test/halfpipe/Halfpipe.obj";
+			model->Color = glm::vec4(0.8f, 0.8f, 0.8f, 0.3f);
+			m_World->CommitEntity(t_halfPipe);
+		}
+
+		//Background
+		
+		{
+			auto background = m_World->CreateEntity();
+			auto transform = m_World->AddComponent<Components::Transform>(background);
+			transform->Position = glm::vec3(0.f, 0.f, -30.f);
+			transform->Scale = glm::vec3(2681.f / 50.f, 1080.f / 50.f, 1.f);
+			auto sprite = m_World->AddComponent<Components::Sprite>(background);
+			sprite->SpriteFile = "Textures/Background.png";
+			m_World->CommitEntity(background);
+		}
+
+		//			auto particleEmitter= m_World->AddComponent<Components::Emitter>(Pe);
+		//Water test
+		{
+			auto t_waterBody = m_World->CreateEntity();
+			auto transform = m_World->AddComponent<Components::Transform>(t_waterBody);
+			transform->Position = glm::vec3(0.f, -3.5f, -10.f);
+			transform->Scale = glm::vec3(7.0f, 1.5f, 1.f);
+			transform->Sticky = true;
+			auto water = m_World->AddComponent<Components::WaterVolume>(t_waterBody);
+			auto body = m_World->AddComponent<Components::RectangleShape>(t_waterBody);
+			m_World->CommitEntity(t_waterBody);
+		}
+
+
+		
+
+		//ParticleTest
+
+
+		/*{
+			auto Pe = m_World->CreateEntity();
+			auto transform = m_World->AddComponent<Components::Transform>(Pe);
+			auto particleEmitter= m_World->AddComponent<Components::ParticleEmitter>(Pe);
+			auto emitteSprite = m_World->AddComponent<Components::Sprite>(Pe);
+
+			transform->Position = glm::vec3(0.f, 0.f, -10.f);
+			emitteSprite->SpriteFile = "Textures/Test/Brick_Normal.png";
+			particleEmitter->GravityScale = 0.0f;
+			particleEmitter->SpawnRate = 1.f;
+			particleEmitter->NumberOfTicks = 2;
+			particleEmitter->Speed = 1.f;
+			particleEmitter->ParticlesPerTick = 5;
+			particleEmitter->Spread = glm::pi<float>()*2;
+			particleEmitter->EmittingAngle = glm::pi<float>();
+			particleEmitter->LifeTime = 50;
+
+			{
+				auto Pt = m_World->CreateEntity(Pe);
+				auto PtTransform = m_World->AddComponent<Components::Transform>(Pt);
+				auto PtSprite = m_World->AddComponent<Components::Sprite>(Pt);
+				auto PtParticle = m_World->AddComponent<Components::Particle>(Pt);
+				auto PtTemplate = m_World->AddComponent<Components::Template>(Pt);
+
+				//PtTransform->Velocity = glm::vec3(1.0f, 0.f, 0.f);
+				PtTransform->Position = transform->Position;
+				PtSprite->SpriteFile = "Textures/Background.png";
+				PtParticle->LifeTime = 3.f;
+				PtParticle->Flags = static_cast<ParticleFlags::Type>(ParticleFlags::Type::Powder | ParticleFlags::Type::ParticleContactFilter | ParticleFlags::Type::FixtureContactFilter);
+			}
+			m_World->CommitEntity(Pe);
+		}*/
+
+		//TODO: Why does the ball not collide with these bricks?
+		//BottomBox
+		{
+			auto BottomWall = m_World->CreateEntity();
+			auto transform = m_World->AddComponent<Components::Transform>(BottomWall);
+			transform->Position = glm::vec3(0.f, -6.f, -10.f);
+			transform->Scale = glm::vec3(20.f, 0.5f, 1.f);
+			//std::shared_ptr<Components::Sprite> sprite = m_World->AddComponent<Components::Sprite>(BottomWall);
+			//sprite->SpriteFile = "Textures/Core/ErrorTexture.png";
+			std::shared_ptr<Components::RectangleShape> rectangleShape = m_World->AddComponent<Components::RectangleShape>(BottomWall);
+			rectangleShape->Dimensions = glm::vec2(20.f, 0.5f);
+			std::shared_ptr<Components::Physics> physics = m_World->AddComponent<Components::Physics>(BottomWall);
+			physics->CollisionType = CollisionType::Type::Static;
+			physics->Category = CollisionLayer::Wall;
+			physics->Mask = static_cast<CollisionLayer::Type>(CollisionLayer::LifeBuoy);
+			transform->Sticky = true;
+			m_World->CommitEntity(BottomWall);
+		}
+
+		{
+			auto topWall = m_World->CreateEntity();
+			std::shared_ptr<Components::Transform> transform = m_World->AddComponent<Components::Transform>(topWall);
+			transform->Position = glm::vec3(0.f, 6.f, -10.f);
+			transform->Scale = glm::vec3(20.f, 0.5f, 1.f);
+
+			//std::shared_ptr<Components::Sprite> sprite = m_World->AddComponent<Components::Sprite>(topWall);
+			//sprite->SpriteFile = "Textures/Core/ErrorTexture.png";
+
+			std::shared_ptr<Components::RectangleShape> rectangleShape = m_World->AddComponent<Components::RectangleShape>(topWall);
+			rectangleShape->Dimensions = glm::vec2(20.f, 0.5f);
+
+			std::shared_ptr<Components::Physics> physics = m_World->AddComponent<Components::Physics>(topWall);
+			physics->CollisionType = CollisionType::Type::Static;
+			physics->Category = CollisionLayer::Wall;
+			physics->Mask = static_cast<CollisionLayer::Type>(CollisionLayer::Ball | CollisionLayer::Brick);
+			transform->Sticky = true;
+
+			m_World->CommitEntity(topWall);
+		}
+
+		{
+			auto leftWall = m_World->CreateEntity();
+			std::shared_ptr<Components::Transform> transform = m_World->AddComponent<Components::Transform>(
+					leftWall);
+			transform->Position = glm::vec3(-4.f, 1.f, -10.f);
+			transform->Scale = glm::vec3(0.5f, 20.f, 1.f);
+
+			//std::shared_ptr<Components::Sprite> sprite = m_World->AddComponent<Components::Sprite>(leftWall);
+			//sprite->SpriteFile = "Textures/Core/ErrorTexture.png";
+
+			std::shared_ptr<Components::RectangleShape> rectangleShape = m_World->AddComponent<Components::RectangleShape>(leftWall);
+			rectangleShape->Dimensions = glm::vec2(0.5f, 20.f);
+
+			std::shared_ptr<Components::Physics> physics = m_World->AddComponent<Components::Physics>(leftWall);
+			physics->CollisionType = CollisionType::Type::Static;
+			physics->Category = CollisionLayer::Wall;
+			physics->Mask = static_cast<CollisionLayer::Type>(CollisionLayer::Ball | CollisionLayer::Brick);
+			transform->Sticky = true;
+
+			m_World->CommitEntity(leftWall);
+		}
+
+		{
+			auto rightWall = m_World->CreateEntity();
+			std::shared_ptr<Components::Transform> transform = m_World->AddComponent<Components::Transform>(
+					rightWall);
+			transform->Position = glm::vec3(4.f, 1.f, -10.f);
+			transform->Scale = glm::vec3(0.5f, 20.f, 1.f);
+
+			//std::shared_ptr<Components::Sprite> sprite = m_World->AddComponent<Components::Sprite>(rightWall);
+			//sprite->SpriteFile = "Textures/Core/ErrorTexture.png";
+
+			std::shared_ptr<Components::RectangleShape> rectangleShape = m_World->AddComponent<Components::RectangleShape>(rightWall);
+			rectangleShape->Dimensions = glm::vec2(0.5f, 20.f);
+
+			std::shared_ptr<Components::Physics> physics = m_World->AddComponent<Components::Physics>(rightWall);
+			physics->CollisionType = CollisionType::Type::Static;
+			physics->Category = CollisionLayer::Wall;
+			physics->Mask = static_cast<CollisionLayer::Type>(CollisionLayer::Ball | CollisionLayer::Brick);
+			transform->Sticky = true;
+
+			m_World->CommitEntity(rightWall);
+		}
+
+=======
+		//auto particleEmitter= m_World->AddComponent<Components::Emitter>(Pe);
+>>>>>>> origin/master
+		//EVENT_SUBSCRIBE_MEMBER(m_EGameStart, &Engine::OnGameStart);
+		m_EGameStart = decltype(m_EGameStart)(std::bind(&Engine::OnGameStart, this, std::placeholders::_1));
+		m_EventBroker->Subscribe(m_EGameStart);
+
+		m_LastTime = glfwGetTime();
+	}
+
+	bool Running() const { return !glfwWindowShouldClose(m_Renderer->Window()); }
+
+	void Tick()
+	{
+		double currentTime = glfwGetTime();
+		double dt = currentTime - m_LastTime;
+		m_LastTime = currentTime;
+
+		// Update input
+		m_InputManager->Update(dt);
+		// Swap event queues to get fresh input data in the read queue
+		//m_EventBroker->Swap();
+
+		//ResourceManager::Update();
+		if (m_GameIsRunning) {
+			m_World->Update(dt);
+		} else {
+			m_EventBroker->Process<Systems::SoundSystem>();
+		}
+		m_EventBroker->Process<GUI::Frame>();
+		m_FrameStack->UpdateLayered(dt);
+
+		m_RendererQueue.Clear();
+		m_FrameStack->DrawLayered(m_RendererQueue);
+		//TODO Fill up the renderQueue with models (Temp fix)
+		if (m_GameIsRunning) {
+			TEMPAddToRenderQueue();
+		}
+
+		std::unique_ptr<dd::Camera> defaultCamera = nullptr;
+
+		// Render scene
+		//TODO send renderqueue to draw.
+		m_Renderer->Draw(m_RendererQueue);
+
+		m_EventBroker->Process<Engine>();
+		// Swap event queues
+		m_EventBroker->Swap();
+
+		glfwPollEvents();
+	}
+
+	std::shared_ptr<Systems::TransformSystem> m_TransformSystem;
+	std::shared_ptr<Systems::LevelSystem> m_LevelSystem;
+
+	//TODO: Get this out of engine.h
+	void TEMPAddToRenderQueue()
+	{
+		if (!m_TransformSystem)
+			m_TransformSystem = m_World->GetSystem<Systems::TransformSystem>();
+
+		for (auto &pair : *m_World->GetEntities())
+		{
+			EntityID entity = pair.first;
+
+			auto templateComponent = m_World->GetComponent<Components::Template>(entity);
+			if (templateComponent)
+				continue;
+
+			auto transform = m_World->GetComponent<Components::Transform>(entity);
+			if (!transform)
+				continue;
+
+			auto modelComponent = m_World->GetComponent<Components::Model>(entity);
+			if (modelComponent)
+			{
+				Model* modelAsset = nullptr;
+				modelAsset = ResourceManager::Load<Model>(modelComponent->ModelFile);
+
+				if (modelAsset)
+				{
+					Components::Transform absoluteTransform = m_TransformSystem->AbsoluteTransform(entity);
+					glm::mat4 modelMatrix = glm::translate(glm::mat4(), absoluteTransform.Position)
+						* glm::toMat4(absoluteTransform.Orientation)
+						* glm::scale(absoluteTransform.Scale);
+					Components::Animation* animationComponent = m_World->GetComponent<Components::Animation>(entity);
+					EnqueueModel(modelAsset, modelMatrix, modelComponent, animationComponent);
+				}
+			}
+
+			auto pointLightComponent = m_World->GetComponent<Components::PointLight>(entity);
+			if (pointLightComponent)
+			{
+				Components::Transform absoluteTransform = m_TransformSystem->AbsoluteTransform(entity);
+				EnqueuePointLight(absoluteTransform.Position,
+								  pointLightComponent->Diffuse,
+								  pointLightComponent->Specular,
+								  pointLightComponent->Radius);
+			}
+
+			auto parent = m_World->GetEntityParent(entity);
+			if(parent != 0) {
+				auto waterParticleComponent = m_World->GetComponent<Components::WaterVolume>(parent);
+				if (waterParticleComponent) {
+					//TODO: Remove hardcoded color.
+					//TODO: Do i even need modelMatrix?
+					Components::Transform absoluteTransform = m_TransformSystem->AbsoluteTransform(entity);
+					glm::mat4 modelMatrix = glm::translate(absoluteTransform.Position)
+											* glm::scale(absoluteTransform.Scale);
+					EnqueueWaterParticles(absoluteTransform.Position, glm::vec4(1.f, 1.f, 1.f, 1.f), modelMatrix, absoluteTransform.Position.z);
+				}
+			}
+
+
+			auto spriteComponent = m_World->GetComponent<Components::Sprite>(entity);
+			if (spriteComponent)
+			{
+				std::string normal = spriteComponent->NormalTexture;
+				std::string spec = spriteComponent->SpecularTexture;
+
+				if (normal.empty()) {
+					normal = "Textures/Core/NeutralNormalMap.png";
+				}
+				if (spec.empty()) {
+					spec = "Textures/Core/NeutralSpecularMap.png";
+				}
+				auto texturediff = ResourceManager::Load<Texture>(spriteComponent->SpriteFile);
+				auto texturenorm = ResourceManager::Load<Texture>(normal);
+				auto texturespec = ResourceManager::Load<Texture>(spec);
+
+
+				Components::Transform absoluteTransform = m_TransformSystem->AbsoluteTransform(entity);
+				glm::quat orientation2D = glm::angleAxis(glm::eulerAngles(absoluteTransform.Orientation).z, glm::vec3(0, 0, -1));
+				glm::mat4 modelMatrix = glm::translate(absoluteTransform.Position)
+					* glm::toMat4(orientation2D)
+					* glm::scale(absoluteTransform.Scale);
+				EnqueueSprite(texturediff, texturenorm, texturespec, modelMatrix, spriteComponent->Color, absoluteTransform.Position.z);
+			}
+		}
+	}
+
+	//TODO: Get this out of engine.h
+	void EnqueueModel(Model* model, glm::mat4 modelMatrix, const Components::Model* modelComponent, const Components::Animation* animationComponent)
+	{
+		for (auto texGroup : model->TextureGroups)
+		{
+			ModelJob job;
+			job.TextureID = (texGroup.Texture) ? texGroup.Texture->ResourceID : 0;
+			job.DiffuseTexture = (texGroup.Texture) ? *texGroup.Texture : 0;
+			job.NormalTexture = (texGroup.NormalMap) ? *texGroup.NormalMap : 0;
+			job.SpecularTexture = (texGroup.SpecularMap) ? *texGroup.SpecularMap : 0;
+			job.VAO = model->VAO;
+			job.ElementBuffer = model->ElementBuffer;
+			job.StartIndex = texGroup.StartIndex;
+			job.EndIndex = texGroup.EndIndex;
+			job.ModelMatrix = modelMatrix * model->m_Matrix;
+			job.Color = modelComponent->Color;
+			
+			if (model->m_Skeleton != nullptr) {
+				job.Skeleton = model->m_Skeleton;
+				if (animationComponent != nullptr) {
+					job.AnimationName = animationComponent->Name;
+					job.AnimationTime = animationComponent->Time;
+					job.NoRootMotion = animationComponent->NoRootMotion;
+				}
+			}
+
+			m_RendererQueue.Deferred.Add(job);
+		}
+	}
+
+	// TODO: Get this out of engine.h
+	void EnqueueSprite(Texture* texture, Texture* normalTexture, Texture* specularTexture, glm::mat4 modelMatrix, glm::vec4 color, float depth)
+	{
+		SpriteJob job;
+		job.TextureID = texture->ResourceID;
+		job.DiffuseTexture = *texture;
+		job.NormalTexture = *normalTexture;
+		job.SpecularTexture = *specularTexture;
+		job.ModelMatrix = modelMatrix;
+		job.Color = color;
+		job.Depth = depth;
+
+
+		m_RendererQueue.Forward.Add(job);
+	}
+
+	void EnqueuePointLight(glm::vec3 position, glm::vec3 diffuseColor, glm::vec3 specularColor, float radius)
+	{
+		PointLightJob job;
+		job.Position = position;
+		job.DiffuseColor = diffuseColor;
+		job.SpecularColor = specularColor;
+		job.Radius = radius;
+
+		m_RendererQueue.Lights.Add(job);
+
+	}
+
+	void EnqueueWaterParticles(glm::vec3 position, glm::vec4 color, glm::mat4 modelMatrix, float depth)
+	{
+		WaterParticleJob job;
+		job.Position = position;
+		job.Color = color;
+		job.ModelMatrix = modelMatrix;
+		job.Depth = depth;
+
+		m_RendererQueue.Forward.Add(job);
+	}
+
+private:
+	std::shared_ptr<EventBroker> m_EventBroker;
+	GUI::Frame* m_FrameStack = nullptr;
+	std::shared_ptr<Renderer> m_Renderer;
+	RenderQueueCollection m_RendererQueue;
+	std::shared_ptr<InputManager> m_InputManager;
+	std::shared_ptr<World> m_World;
+	glm::vec3 m_CameraPosition = glm::vec3(0.f, 0.f, 0.f);
+
+	//TODO: Redo
+	bool m_GameIsRunning = false;
+	dd::EventRelay<Engine, dd::Events::GameStart> m_EGameStart;
+	bool OnGameStart(const dd::Events::GameStart &event)
+	{
+		m_GameIsRunning = true;
+		//Todo: Move this
+		{
+// 			dd::Events::PlaySound e;
+// 			e.FilePath = "Sounds/BGM/under-the-sea-instrumental.wav";
+// 			e.IsAmbient = true;
+// 			m_EventBroker->Publish(e);
+		}
+		{
+// 			dd::Events::PlaySound e;
+// 			e.FilePath = "Sounds/BGM/water-flowing.wav";
+// 			e.Gain = 0.3f;
+// 			e.IsAmbient = true;
+// 			m_EventBroker->Publish(e);
+		}
+
+		return true;
+	};
+	double m_LastTime;
+};
+
+}

include/Core/ResourceManager.h

@@ -22,7 +22,9 @@
 #include <string>
 #include <functional>
 #include <vector>
+#include <set>
 #include <unordered_map>
+#include <fstream>
 
 #include "Util/UnorderedMapPair.h"
 #include "Util/Factory.h"
@@ -70,13 +72,8 @@ public:
 	return s;
 	}*/
 
-	/** Registers the factory function of a resource type
-
-		@tparam T Resource type.
-		@param factoryFunction Lambda function that creates a new instance of the resource.
-	*/
 	template <typename T>
-	static void RegisterType(std::function<Resource*(std::string)> factoryFunction);
+	static void RegisterType(std::string typeName);
 
 	/** Preloads a resource and caches it for future use
 
@@ -85,6 +82,7 @@ public:
 	*/
 	template <typename T>
 	static void Preload(std::string resourceName);
+	static void Preload(std::string resourceType, std::string resourceName);
 
 	/** Checks if a resource is in cache
 
@@ -101,14 +99,7 @@ public:
 	*/
 	template <typename T>
 	static T* Load(std::string resourceName, Resource* parent = nullptr);
-
-	/** Fetches a loaded resource
-
-		@tparam T Resource type.
-		@param resourceName Fully qualified name of the resource to fetch.
-	*/
-	template <typename T>
-	static T* Fetch(std::string resourceName);
+	static Resource* Load(std::string resourceType, std::string resourceName, Resource* parent = nullptr);
 
 	/** Reloads an already loaded resource, keeping its resource ID intact.
 
@@ -116,14 +107,19 @@ public:
 	 	@param resourceName Fully qualified name of the resource to reload.
 	*/
     static void Reload(std::string resourceName);
+	
+	static void LoadPreloadsFromFile();
+	static const std::set<std::pair<std::string, std::string>>& GetPreloads() { return m_Preloads; }
 
 	static void Update();
 
 private:
+	static std::unordered_map<std::string, std::string> m_CompilerTypenameToResourceType;
     static std::unordered_map<std::string, std::function<Resource*(std::string)>> m_FactoryFunctions; // type -> factory function
 	static std::unordered_map<std::pair<std::string, std::string>, Resource*> m_ResourceCache; // (type, name) -> resource
 	static std::unordered_map<std::string, Resource*> m_ResourceFromName; // name -> resource
 	static std::unordered_map<Resource*, Resource*> m_ResourceParents; // resource -> parent resource
+	static std::set<std::pair<std::string, std::string>> m_Preloads; // (type, name)
 
 	// TODO: Getters for IDs
 	static unsigned int m_CurrentResourceTypeID;
@@ -140,93 +136,40 @@ private:
 	static unsigned int GetNewResourceID(unsigned int typeID);
 
 	// Internal: Create a resource and cache it
-	template <typename T>
-	static T* CreateResource(std::string resourceName, Resource* parent);
+	static Resource* CreateResource(std::string resourceType, std::string resourceName, Resource* parent);
 };
 
 template <typename T>
 T* ResourceManager::Load(std::string resourceName, Resource* parent /* = nullptr */)
 {
-	auto resourceType = typeid(T).name();
-	auto it = m_ResourceCache.find(std::make_pair(resourceType, resourceName));
-	if (it != m_ResourceCache.end())
-		return static_cast<T*>(it->second);
-
-	if (m_Preloading) {
-		LOG_INFO("Preloading resource \"%s\"", resourceName.c_str());
-	} else {
-		LOG_WARNING("Hot-loading resource \"%s\"", resourceName.c_str());
-	}
-
-	return CreateResource<T>(resourceName, parent);
-}
-
-template <typename T>
-T* ResourceManager::Fetch(std::string resourceName)
-{
-	auto resourceType = typeid(T).name();
-	auto it = m_ResourceCache.find(std::make_pair(resourceType, resourceName));
-	if (it == m_ResourceCache.end())
-	{
-		LOG_ERROR("Failed to fetch resource \"%s\": Resource not loaded!", resourceName.c_str());
+	auto resourceTypename = typeid(T).name();
+	auto it = m_CompilerTypenameToResourceType.find(resourceTypename);
+	if (it == m_CompilerTypenameToResourceType.end()) {
+		LOG_ERROR("Failed to load resource \"%s\" of type \"%s\": type not registered", resourceName.c_str(), resourceTypename);
 		return nullptr;
-	} else
-	{
-		return static_cast<T*>(it->second);
 	}
+
+	return static_cast<T*>(Load(it->second, resourceName, parent));
 }
 
 template <typename T>
-void ResourceManager::RegisterType(std::function<Resource*(std::string)> factoryFunction)
+void ResourceManager::RegisterType(std::string typeName)
 {
-	m_FactoryFunctions[typeid(T).name()] = factoryFunction;
+	m_CompilerTypenameToResourceType[typeid(T).name()] = typeName;
+	m_FactoryFunctions[typeName] = [](std::string resourceName) { return new T(resourceName); };
 }
 
 template <typename T>
 void ResourceManager::Preload(std::string resourceName)
 {
-	auto resourceType = typeid(T).name();
-	if (IsResourceLoaded(resourceType, resourceName))
-	{
-		LOG_WARNING("Attempted to preload resource \"%s\" multiple times!", resourceName.c_str());
+	auto resourceTypename = typeid(T).name();
+	auto it = m_CompilerTypenameToResourceType.find(resourceTypename);
+	if (it == m_CompilerTypenameToResourceType.end()) {
+		LOG_ERROR("Failed to load resource \"%s\" of type \"%s\": type not registered", resourceName.c_str(), resourceTypename);
 		return;
 	}
 
-	m_Preloading = true;
-	LOG_INFO("Preloading resource \"%s\"", resourceName.c_str());
-	CreateResource<T>(resourceName, nullptr);
-	m_Preloading = false;
-}
-
-template <typename T>
-T* ResourceManager::CreateResource(std::string resourceName, Resource* parent)
-{
-	const char* resourceType = typeid(T).name();
-	/*auto facIt = m_FactoryFunctions.find(resourceType);
-	if (facIt == m_FactoryFunctions.end())
-	{
-	LOG_ERROR("Failed to load resource \"%s\" of type \"%s\": Type not registered", resourceName.c_str(), resourceType);
-	return nullptr;
-	}*/
-
-	// Call the factory function
-	T* resource = new T(resourceName);
-	// Store IDs
-	resource->TypeID = GetTypeID(resourceType);
-	resource->ResourceID = GetNewResourceID(resource->TypeID);
-	// Cache
-	m_ResourceCache[std::make_pair(resourceType, resourceName)] = resource;
-	m_ResourceFromName[resourceName] = resource;
-	if (parent != nullptr)
-	{
-		m_ResourceParents[resource] = parent;
-	}
-	if (!boost::filesystem::is_directory(resourceName))
-	{
-		LOG_DEBUG("Adding watch for %s", resourceName.c_str());
-		m_FileWatcher.AddWatch(resourceName, fileWatcherCallback);
-	}
-	return resource;
+	Preload(it->second, resourceName);
 }
 
 }

include/Game/BallSystem.h

@@ -1,6 +1,8 @@
 #ifndef DAYDREAM_BALLSYSTEM_H
 #define DAYDREAM_BALLSYSTEM_H
 
+#include <random>
+
 #include "Core/System.h"
 #include "Core/World.h"
 #include "Core/EventBroker.h"
@@ -8,14 +10,17 @@
 #include "Core/CTemplate.h"
 #include "Core/ResourceManager.h"
 #include "Core/ConfigFile.h"
+
 #include "Physics/CPhysics.h"
 #include "Physics/CCircleShape.h"
 #include "Physics/CRectangleShape.h"
 #include "Physics/EContact.h"
+
 #include "Rendering/CModel.h"
 #include "Rendering/CSprite.h"
 #include "Rendering/CPointLight.h"
 #include "Rendering/CAnimation.h"
+
 #include "Game/CBall.h"
 #include "Game/CPowerUp.h"
 #include "Game/CLife.h"
@@ -30,6 +35,8 @@
 #include "Game/EStickyAttachedToPad.h"
 #include "Game/EInkBlaster.h"
 #include "Game/EInkBlasterOver.h"
+#include "Game/EKrakenAttack.h"
+#include "Game/EKrakenAttackEnd.h"
 #include "Game/EStageCleared.h"
 #include "Game/EArrivedAtNewStage.h"
 #include "Game/EGameOver.h"
@@ -39,7 +46,11 @@
 #include "Game/EHitLag.h"
 #include "Game/EActionButton.h"
 #include "Game/ELifebuoyHit.h"
+
 #include "Physics/ECreateParticleSequence.h"
+#include "Sound/CCollisionSound.h"
+#include "Sound/EPlaySound.h"
+#include "Rendering/EAnimationComplete.h"
 
 namespace dd
 {
@@ -74,7 +85,6 @@ public:
     void OnEntityRemoved(EntityID entity) override;
 
     EntityID CreateBall();
-    void CreateLife(int);
     EntityID Ball() { return m_Ball; };
     void SetBall(const EntityID& ball) { m_Ball = ball; }
 
@@ -86,22 +96,18 @@ public:
     void SetEdgeY(const float& edgeY) { m_EdgeY = edgeY; }
     int& MultiBalls() { return m_MultiBalls; }
     void SetMultiBalls(const int& multiBalls) { m_MultiBalls = multiBalls; }
-    int& Lives() { return m_Lives; }
-    void SetLives(const int& lives) { m_Lives = lives; }
-    int& PastLives() { return m_PastLives; }
-    void SetPastLives(const int& pastLives) { m_PastLives = pastLives; }
     bool ReplaceBall() const { return m_ReplaceBall; }
     void SetReplaceBall(const bool& replaceBall) { m_ReplaceBall = replaceBall; }
     bool IsPaused() const { return m_Pause; }
     void SetPause(const bool& pause) { m_Pause = pause; }
 
 private:
+	std::mt19937 m_RandomGenerator;
+
     float m_XMovementMultiplier = 2.f;
     float m_EdgeX = 3.4f; //Actually 3.2, but anyways.
     float m_EdgeY = 5.2f;
     int m_MultiBalls = 0;
-    int m_Lives = 3;
-    int m_PastLives = 3;
     bool m_ReplaceBall = false;
     bool m_Pause = false;
     bool m_Waiting = true;
@@ -109,9 +115,12 @@ private:
 	bool m_InkBlaster = false;
 	bool m_InkAttached = false;
 	bool m_InkBlockedWaiting = false;
+	bool m_KrakenAttack = false;
+	double m_KrakenCharge = 0;
 	bool m_Restarting = false;
 	int m_StickyCounter = 3;
-	bool m_GodMode = false;
+
+	bool m_First = true;
 
 	bool m_StageBlockedWaiting = false;
 
@@ -123,33 +132,37 @@ private:
     std::unordered_map<EntityID, std::list<glm::vec2>> m_Contacts;
     void ResolveContacts();
 
-    dd::EventRelay<BallSystem, dd::Events::LifeLost> m_ELifeLost;
     dd::EventRelay<BallSystem, dd::Events::MultiBallLost> m_EMultiBallLost;
     dd::EventRelay<BallSystem, dd::Events::ResetBall> m_EResetBall;
     dd::EventRelay<BallSystem, dd::Events::MultiBall> m_EMultiBall;
 	dd::EventRelay<BallSystem, dd::Events::StickyPad> m_EStickyPad;
 	dd::EventRelay<BallSystem, dd::Events::InkBlaster> m_EInkBlaster;
 	dd::EventRelay<BallSystem, dd::Events::InkBlasterOver> m_EInkBlasterOver;
+	dd::EventRelay<BallSystem, dd::Events::KrakenAttack> m_EKrakenAttack;
+	dd::EventRelay<BallSystem, dd::Events::KrakenAttackEnd> m_EKrakenAttackEnd;
     dd::EventRelay<BallSystem, dd::Events::Pause> m_EPause;
 	dd::EventRelay<BallSystem, dd::Events::Resume> m_EResume;
     dd::EventRelay<BallSystem, dd::Events::Contact> m_Contact;
     dd::EventRelay<BallSystem, dd::Events::ActionButton> m_EActionButton;
 	dd::EventRelay<BallSystem, dd::Events::StageCleared> m_EStageCleared;
 	dd::EventRelay<BallSystem, dd::Events::ArrivedAtNewStage> m_EArrivedAtNewStage;
+	dd::EventRelay<BallSystem, dd::Events::AnimationComplete> m_EAnimationComplete;
 
     bool Contact(const Events::Contact &event);
-    bool OnLifeLost(const dd::Events::LifeLost &event);
     bool OnMultiBallLost(const dd::Events::MultiBallLost &event);
     bool OnResetBall(const dd::Events::ResetBall &event);
     bool OnMultiBall(const dd::Events::MultiBall &event);
 	bool OnStickyPad(const dd::Events::StickyPad &event);
 	bool OnInkBlaster(const dd::Events::InkBlaster &event);
 	bool OnInkBlasterOver(const dd::Events::InkBlasterOver &event);
+	bool OnKrakenAttack(const dd::Events::KrakenAttack &event);
+	bool OnKrakenAttackEnd(const dd::Events::KrakenAttackEnd &event);
     bool OnPause(const dd::Events::Pause &event);
 	bool OnResume(const dd::Events::Resume &event);
     bool OnActionButton(const dd::Events::ActionButton &event);
 	bool OnStageCleared(const dd::Events::StageCleared &event);
 	bool OnArrivedToNewStage(const dd::Events::ArrivedAtNewStage &event);
+	bool OnAnimationComplete(const dd::Events::AnimationComplete &event);
 };
 
 }

include/Game/CBall.h

@@ -22,8 +22,11 @@ struct Ball : Component
     bool Waiting = true;
 	bool InkBlaster = false;
 	bool Sticky = false;
+	bool Loaded = false;
 	glm::vec3 StickyPlacement = glm::vec3(0, 0, 0);
-    glm::vec3 SavedSpeed = glm::vec3(0, 0, 0);
+    glm::vec3 SavedSpeed = glm::vec3(0, 1, 0);
+
+	int PosterBoy = 0;
 };
 
 }

include/Game/CBrick.h

@@ -19,7 +19,9 @@ struct Brick : Component
 	//0 = empty, 1 = normal, 2 = multi-brick, 3 = lifebuoy, 4 = sticky, 5 = blaster, 6 = kraken
     int Type = 0;
     bool Removed = false;
-	int Number = 0; // For the Kraken to keep track of which bricks needs replacing.
+	int Number = 100; // For the Kraken to keep track of which bricks needs replacing.
+	bool BeingGenerated = false;
+	glm::vec3 GenerationGoal;
 
 	//What number of types each is.
 	const int EmptyBrickSpace = 0;

include/Game/CBrickPart.h

@@ -0,0 +1,26 @@
+//
+// Created by Adniklastrator on 2015-10-21.
+//
+
+#ifndef DAYDREAM_CBRICKPART_H
+#define DAYDREAM_CBRICKPART_H
+
+#include "Core/Component.h"
+
+namespace dd
+{
+
+namespace Components
+{
+
+struct BrickPart : Component
+{
+	bool Submerged = false;
+	int NumberOfPartsInBrick;
+};
+
+}
+
+}
+
+#endif //DAYDREAM_CBRICKPART_H

include/Game/CKraken.h

@@ -15,14 +15,16 @@ namespace Components
 
 struct Kraken : Component {
 
-    int Health = 10;
-	int CurrentAction = 1;
+    int MaxHealth = 18;
+	int Health = MaxHealth;
+	int CurrentAction = 3;
+	float RetreatSpeed = 0.2;
 	
 	const int Idle = 1;
 	const int Grabbing = 2;
-	const int Taunting = 3;
-	const int Moving = 4;
-	const int BrickGenerating = 5;
+	const int BrickGenerating = 3;
+	const int BrickGenerating2 = 4;
+	const int Waiting = 5;
 	// Idle. Generating bricks. Taunting. No idea.
 };
 

include/Game/CLife.h

@@ -13,10 +13,15 @@ namespace dd
 namespace Components
 {
 
-struct Life : Component {
-
+struct Life : Component 
+{
     int Number = 0;
-
+	float SinusAltitude = 0;
+	float Amplitude = 1;
+	float Frequency = 1;
+	float SinusSpeed = 1;
+	bool Left = false;
+	bool Dead = false;
 };
 
 }

include/Game/CNewWaterVolume.h

@@ -0,0 +1,25 @@
+//
+// Created by Adniklastrator on 2015-10-22.
+//
+
+#ifndef CNEWWATERVOLUME_H
+#define CNEWWATERVOLUME_H
+
+#include "Core/Component.h"
+
+namespace dd
+{
+
+namespace Components
+{
+
+struct NewWaterVolume : public Component
+{
+    
+};
+
+}
+
+}
+
+#endif //DAYDREAM_NEWWATERVOLUME_H

include/Game/EBreakAllBricks.h

@@ -0,0 +1,25 @@
+//
+// Created by Adniklastrator on 2015-10-23.
+//
+
+#ifndef DAYDREAM_EBREAKALLBRICKS_H
+#define DAYDREAM_EBREAKALLBRICKS_H
+
+#include "Core/EventBroker.h"
+
+namespace dd
+{
+
+namespace Events
+{
+
+struct BreakAllBricks : Event
+{
+	
+};
+
+}
+
+}
+
+#endif //DAYDREAM_EBREAKALLBRICKS_H

include/Game/EBrickGenerating.h

@@ -15,9 +15,12 @@ namespace Events
 
 struct BrickGenerating : Event
 {
-	glm::vec3 Origin;
+	glm::vec3 Origin1;
+	glm::vec3 Origin2;
 	int TargetLine;
 	int Set;
+	int SetCluster;
+	int Speed = 6;
 };
 
 }

include/Game/EKrakenAttackEnd.h

@@ -0,0 +1,25 @@
+//
+// Created by Adniklastrator on 2015-10-21.
+//
+
+#ifndef DAYDREAM_EKRAKENATTACKEND_H
+#define DAYDREAM_EKRAKENATTACKEND_H
+
+#include "Core/EventBroker.h"
+
+namespace dd
+{
+
+namespace Events
+{
+
+struct KrakenAttackEnd : Event
+{
+	
+};
+
+}
+
+}
+
+#endif //DAYDREAM_EKRAKENATTACKEND_H

include/Game/EKrakenHit.h

@@ -17,6 +17,9 @@ struct KrakenHit : Event
 {
 	EntityID Kraken;
 	EntityID Hitter;
+	int MaxHealth;
+	int CurrentHealth;
+	int NewHealth;
 };
 
 }

include/Game/EScreenShake.h

@@ -15,9 +15,9 @@ namespace Events
 
 struct ScreenShake : Event
 {
-    float Time;
-	int Intensity;
-	float TimeTakenToCoolDown;
+    float Time = 1.f;
+	float Intensity = 1.f;
+	float TimeTakenToCoolDown = 1.f;
 };
 
 }

include/Game/GUI/HUD.h

@@ -51,6 +51,7 @@ public:
 		EVENT_SUBSCRIBE_MEMBER(m_EGameOver, &HUD::OnGameOver);
 		EVENT_SUBSCRIBE_MEMBER(m_ClusterClear, &HUD::OnClusterClear);
 		EVENT_SUBSCRIBE_MEMBER(m_KrakenAttack, &HUD::OnKrakenAttack);
+		EVENT_SUBSCRIBE_MEMBER(m_KrakenAttackEnd, &HUD::OnKrakenAttackEnd);
 
 		updateScore();
 	}
@@ -71,22 +72,23 @@ private:
 	EventRelay<Frame, Events::GameOver> m_EGameOver;
 	EventRelay<Frame, Events::ClusterClear> m_ClusterClear;
 	EventRelay<Frame, Events::KrakenAttack> m_KrakenAttack;
+	EventRelay<Frame, Events::KrakenAttackEnd> m_KrakenAttackEnd;
 
 	void updateScore()
 	{
 		m_ScoreNumberFrame->SetLeft(Width / 2.f - m_ScoreNumberFrame->Width / 2.f);
 
-		m_ScoreBackMid->SetLeft(m_ScoreNumberFrame->Left());
 		m_ScoreBackMid->Width = m_ScoreNumberFrame->Width;
 		m_ScoreBackMid->Height = m_ScoreNumberFrame->Height + 35;
+		m_ScoreBackMid->SetLeft(m_ScoreNumberFrame->Left() + 4);
 
-		m_ScoreBackLeft->SetRight(m_ScoreBackMid->Left());
-		m_ScoreBackLeft->Width = 40;
+		//m_ScoreBackLeft->Width = 40;
 		m_ScoreBackLeft->Height = m_ScoreBackMid->Height;
+		m_ScoreBackLeft->SetRight(m_ScoreBackMid->Left());
 
-		m_ScoreBackRight->SetLeft(m_ScoreBackMid->Right());
-		m_ScoreBackRight->Width = 40;
+		//m_ScoreBackRight->Width = 40;
 		m_ScoreBackRight->Height = m_ScoreBackMid->Height;
+		m_ScoreBackRight->SetLeft(m_ScoreBackMid->Right());
 	}
 
 	bool OnScore(const Events::ScoreEvent& event)
@@ -122,6 +124,13 @@ private:
 		
 		return true;
 	}
+
+	bool OnKrakenAttackEnd(const Events::KrakenAttackEnd& event)
+	{
+		m_KrakenAttackSlider->Hide();
+
+		return true;
+	}
 };
 
 }

include/Game/GUI/LoadingFrame.h

@@ -28,9 +28,9 @@ public:
 		m_Slider->X = Width / 2.f - m_Slider->Width / 2.f;
 	}
 
-	void AddTexturePreload(std::string resourceName)
+	void AddResource(std::string resourceType, std::string resourceName)
 	{
-		m_Items.push_back(resourceName);
+		m_Preload.push_back(std::make_pair(resourceType, resourceName));
 	}
 
 	void Preload()
@@ -47,10 +47,10 @@ public:
 	void Update(double dt) override
 	{
 		if (m_Preloading) {
-			ResourceManager::Preload<dd::Texture>(m_Items[m_CurrentItem]);
-			m_Slider->SetPercentage((m_CurrentItem + 1) / (float)m_Items.size());
+			ResourceManager::Preload(m_Preload[m_CurrentItem].first, m_Preload[m_CurrentItem].second);
+			m_Slider->SetPercentage((m_CurrentItem + 1) / (float)m_Preload.size());
 			m_CurrentItem++;
-			if (m_CurrentItem >= m_Items.size()) {
+			if (m_CurrentItem >= m_Preload.size()) {
 				m_Preloading = false;
 				dd::Events::LoadingFrameComplete e;
 				e.FrameName = Name();
@@ -63,7 +63,7 @@ public:
 private:
 	bool m_Preloading = false;
 	int m_CurrentItem = 0;
-	std::vector<std::string> m_Items;
+	std::vector<std::pair<std::string, std::string>> m_Preload;
 	GUI::Slider* m_Slider = nullptr;
 };
 

include/Game/GUI/MainMenu.h

@@ -2,9 +2,11 @@
 #define GUI_MAINMENU_H__
 
 #include "GUI/TextureFrame.h"
+#include "Game/GUI/LoadingFrame.h"
 #include "Game/GUI/MainMenuMain.h"
 #include "Game/GUI/MainMenuOptions.h"
 #include "Core/EKeyUp.h"
+#include "Game/EGameStart.h"
 
 namespace dd
 {
@@ -37,6 +39,18 @@ public:
 		//EVENT_SUBSCRIBE_MEMBER(m_EKeyUp, &MainMenu::OnKeyUp);
 	}
 
+	void Show() override
+	{
+		if (ResourceManager::Load<ConfigFile>("Config.ini")->GetValue<bool>("Debug.SkipMenu", false)) {
+			Events::GameStart e;
+			EventBroker->Publish(e);
+			Hide();
+			auto hud = new GUI::HUD(BaseFrame, "HUD");
+		} else {
+			TextureFrame::Show();
+		}
+	}
+
 private:
 	TextureFrame* m_LeftBanner;
 	MainMenuMain* m_MainMenuMain;

include/Game/GUI/MainMenuMain.h

@@ -58,6 +58,7 @@ private:
 		if (event.Button == m_SquidoutButton) {
 			m_Parent->Hide();
 			auto story = new GUI::Story1(BaseFrame, "Story1");
+			story->Play();
 		}
 
 		return true;

include/Game/GUI/Story1.h

@@ -3,11 +3,11 @@
 
 #include "Core/ResourceManager.h"
 #include "Game/GUI/StoryboardFrame.h"
-#include "Game/GUI/ELoadingFrameComplete.h"
-#include "Game/GUI/LoadingFrame.h"
 #include "Game/EGameStart.h"
 #include "Core/EKeyDown.h"
 #include "Game/GUI/HUD.h"
+#include "Sound/EPlaySound.h"
+#include "Sound/EStopSound.h"
 
 namespace dd
 {
@@ -20,37 +20,8 @@ public:
 	Story1(Frame* parent, std::string name)
 		: StoryboardFrame(parent, name) 
 	{
-		EVENT_SUBSCRIBE_MEMBER(m_ELoadingFrameComplete, &Story1::OnLoadingFrameComplete);
 		EVENT_SUBSCRIBE_MEMBER(m_EKeyDown, &Story1::OnKeyDown);
 
-		m_LoadingFrame = new GUI::LoadingFrame(this, "Story1LoadingFrame");
-		m_LoadingFrame->SetTexture("Textures/GUI/Loading.png");
-		m_LoadingFrame->AddTexturePreload("Textures/Story/Brunn1.png");
-		m_LoadingFrame->AddTexturePreload("Textures/Story/Brunn2.png");
-		m_LoadingFrame->AddTexturePreload("Textures/Story/Brunn3.png");
-		m_LoadingFrame->AddTexturePreload("Textures/Story/Brunn4.png");
-		m_LoadingFrame->AddTexturePreload("Textures/Story/Brunn5.png");
-		m_LoadingFrame->AddTexturePreload("Textures/Story/SubScene1.png");
-		m_LoadingFrame->AddTexturePreload("Textures/Story/SubScene2.png");
-		m_LoadingFrame->AddTexturePreload("Textures/Story/SubScene3.png");
-		m_LoadingFrame->AddTexturePreload("Textures/Story/SubScene4.png");
-		m_LoadingFrame->AddTexturePreload("Textures/Story/SubScene5.png");
-		m_LoadingFrame->AddTexturePreload("Textures/Story/SubScene6.png");
-		m_LoadingFrame->AddTexturePreload("Textures/Story/SubScene7.png");
-		m_LoadingFrame->AddTexturePreload("Textures/Story/SubScene8.png");
-		m_LoadingFrame->AddTexturePreload("Textures/Story/SubScene9.png");
-		m_LoadingFrame->AddTexturePreload("Textures/Story/SubScene10.png");
-		m_LoadingFrame->AddTexturePreload("Textures/Story/SubScene11.png");
-		m_LoadingFrame->AddTexturePreload("Textures/Story/SubScene12.png");
-		m_LoadingFrame->AddTexturePreload("Textures/Story/SubScene13.png");
-		m_LoadingFrame->AddTexturePreload("Textures/Story/SubScene14.png");
-		m_LoadingFrame->AddTexturePreload("Textures/Story/SubScene15.png");
-		m_LoadingFrame->AddTexturePreload("Textures/Story/SubScene16.png");
-		m_LoadingFrame->AddTexturePreload("Textures/Story/SubScene17.png");
-		m_LoadingFrame->AddTexturePreload("Textures/Story/SubScene18.png");
-		m_LoadingFrame->AddTexturePreload("Textures/Story/SubScene19.png");
-		m_LoadingFrame->Preload();
-
 		m_Spacebar = new TextureFrame(this, "ZZZSpacebar");
 		m_Spacebar->SetTexture("Textures/GUI/SpacebarSkip.png");
 		m_Spacebar->SetRight(Right() - 10);
@@ -196,6 +167,14 @@ public:
 		AddTransition(t);
 	}
 
+	virtual void Play() override
+	{
+		StoryboardFrame::Play();
+		Events::PlaySound se;
+		se.FilePath = "Sounds/jap-story.wav";
+		EventBroker->Publish(se);
+	}
+
 	void Update(double dt) override
 	{
 		StoryboardFrame::Update(dt);
@@ -209,7 +188,6 @@ public:
 	}
 
 private:
-	GUI::LoadingFrame* m_LoadingFrame = nullptr;
 	TextureFrame* m_Spacebar = nullptr;
 
 	EventRelay<Frame, Events::KeyDown> m_EKeyDown;
@@ -220,25 +198,17 @@ private:
 		}
 
 		if (event.KeyCode == GLFW_KEY_SPACE) {
-			m_LoadingFrame->CancelPreload();
 			Events::GameStart e;
 			EventBroker->Publish(e);
+			Events::StopSound se;
+			se.FilePath = "Sounds/jap-story.wav";
+			EventBroker->Publish(se);
 			Hide();
 			auto hud = new GUI::HUD(BaseFrame, "HUD");
 		}
 		return true;
 	}
 
-	EventRelay<Frame, Events::LoadingFrameComplete> m_ELoadingFrameComplete;
-	bool OnLoadingFrameComplete(const Events::LoadingFrameComplete& event)
-	{
-		if (event.FrameName == "Story1LoadingFrame") {
-			event.Frame->Hide();
-			m_Spacebar->Hide();
-			Play();
-		}
-		return true;
-	}
 };
 
 }

include/Game/GUI/StoryboardFrame.h

@@ -33,12 +33,12 @@ public:
 		m_Timeline.push_back(transition);
 	}
 
-	void Play()
+	virtual void Play()
 	{
 		m_Playing = true;
 	}
 
-	void Skip()
+	virtual void Skip()
 	{
 		m_Playing = false;
 		OnComplete();

include/Game/KrakenSystem.h

@@ -21,15 +21,22 @@
 #include "Physics/ECreateParticleSequence.h"
 #include "Game/EPause.h"
 #include "Game/EResume.h"
+#include "Game/EComboEvent.h"
+#include "Game/EScoreEvent.h"
 #include "Game/EKrakenAppear.h"
 #include "Game/EKrakenAttack.h"
 #include "Game/EKrakenHit.h"
 #include "Game/EKrakenDefeated.h"
 #include "Game/EBrickGenerating.h"
+#include "Game/EArrivedAtNewStage.h"
 #include "Game/CTravels.h"
 #include "Game/CKraken.h"
 #include "Game/CBall.h"
+#include "Game/CProjectile.h"
+#include "Game/EScreenShake.h"
 #include "Sound/CCollisionSound.h"
+#include "Rendering/CAnimation.h"
+#include "Rendering/CSprite.h"
 //#include "Core/Camera.h" Camera Component
 
 
@@ -59,15 +66,23 @@ private:
 
 	bool m_Pause = false;
 	bool m_KrakenBattle = false;
+	bool m_KrakenHasArrived = false;
 	bool m_ReturnToIdle = false;
+	bool m_RandomKraken = false;
 	EntityID m_KrakenTemplate;
 	std::string m_Action = "Idle";
+	int m_NumberOfActions;
 	float m_KrakenTimer = 0;
-	float m_KrakenSecondsToAction = 1;
+	float m_KrakenMaxSecondsToAction = 10;
+	float m_KrakenMinSecondsToAction = 10;
+	float m_KrakenCurrentSecondsToAction = 15;
 	const int Idle = 1;
 
-	std::array<int, 14> m_Bricks;
-	std::array<int, 14> m_Colors;
+	int m_Set = 0;
+	int m_SetCluster = 0;
+
+	std::array<int, 42> m_Bricks;
+	std::array<int, 42> m_Colors;
 
     dd::EventRelay<KrakenSystem, dd::Events::Pause> m_EPause;
 	dd::EventRelay<KrakenSystem, dd::Events::Resume> m_EResume;
@@ -77,6 +92,7 @@ private:
 	dd::EventRelay<KrakenSystem, dd::Events::KrakenHit> m_EKrakenHit;
 	dd::EventRelay<KrakenSystem, dd::Events::KrakenDefeated> m_EKrakenDefeated;
 	dd::EventRelay<KrakenSystem, dd::Events::BrickGenerating> m_EBrickGenerating;
+	dd::EventRelay<KrakenSystem, dd::Events::ArrivedAtNewStage> m_EArrivedAtNewStage;
     bool OnPause(const dd::Events::Pause &event);
 	bool OnResume(const dd::Events::Resume &event);
 	bool OnContact(const dd::Events::Contact &event);
@@ -85,6 +101,7 @@ private:
 	bool OnKrakenHit(const dd::Events::KrakenHit &event);
 	bool OnKrakenDefeated(const dd::Events::KrakenDefeated &event);
 	bool OnBrickGenerating(const dd::Events::BrickGenerating &event);
+	bool OnArrivedAtNewStage(const dd::Events::ArrivedAtNewStage &event);
 	void GetBrickSet();
 };
 

include/Game/LevelSystem.h

@@ -19,10 +19,12 @@
 #include "Rendering/CSprite.h"
 #include "Rendering/CModel.h"
 #include "Rendering/CPointLight.h"
+#include "Rendering/CCamera.h"
 
 #include "Transform/EMove.h"
 
 #include "Game/CBrick.h"
+#include "Game/CBrickPart.h"
 #include "Game/CBall.h"
 #include "Game/CLife.h"
 #include "Game/CWall.h"
@@ -58,6 +60,7 @@
 #include "Game/EKrakenAppear.h"
 #include "Game/EKrakenDefeated.h"
 #include "Game/EBrickGenerating.h"
+#include "Game/EBreakAllBricks.h"
 
 #include "Physics/CPhysics.h"
 #include "Physics/CCircleShape.h"
@@ -100,7 +103,7 @@ public:
     void CreateBasicLevel(int, int, glm::vec2, float);
     void CreateLevel(int);
     EntityID CreateBrick(int, int, glm::vec2, float, int, int, int, glm::vec4);
-	void BrickHit(EntityID, EntityID, int);
+	void BrickHit(EntityID, EntityID, int, bool);
 
     void OnEntityRemoved(EntityID entity);
 
@@ -172,8 +175,15 @@ private:
     std::array<int, 42> m_Bricks;
 	std::array<glm::vec4, 42> m_Colors;
 
-	std::array<int, 14> m_BrickSet;
-	std::array<glm::vec4, 14> m_ColorSet;
+	std::array<int, 42> m_BrickSet;
+	std::array<glm::vec4, 42> m_ColorSet;
+	std::array<bool, 42> m_KrakenBricks;
+
+	bool m_BrickGenerating = false;
+	dd::Events::BrickGenerating m_BrickGeneratingEvent;
+
+	bool m_KrakenBattle = false;
+	bool m_BreakAllBricks = false;
 
     dd::EventRelay<LevelSystem, dd::Events::Contact> m_EContact;
     dd::EventRelay<LevelSystem, dd::Events::ScoreEvent> m_EScoreEvent;
@@ -187,6 +197,7 @@ private:
 	dd::EventRelay<LevelSystem, dd::Events::Resume> m_EResume;
     dd::EventRelay<LevelSystem, dd::Events::HitPad> m_EHitPad;
 	dd::EventRelay<LevelSystem, dd::Events::BrickGenerating> m_EBrickGenerating;
+	dd::EventRelay<LevelSystem, dd::Events::BreakAllBricks> m_EBreakAllBricks;
 	dd::EventRelay<LevelSystem, dd::Events::KrakenDefeated> m_EKrakenDefeated;
 
     bool OnContact(const dd::Events::Contact &event);
@@ -201,12 +212,14 @@ private:
 	bool OnResume(const dd::Events::Resume &event);
     bool OnHitPad(const dd::Events::HitPad &event);
 	bool OnBrickGenerating(const dd::Events::BrickGenerating &event);
-	void GetBrickSet(int Set);
+	bool BrickGenerating(const dd::Events::BrickGenerating &event);
+	bool OnBreakAllBricks(const dd::Events::BreakAllBricks &event);
+	void GetBrickSet(int Set, int SetCluster);
 	bool OnKrakenDefeated(const dd::Events::KrakenDefeated &event);
 
     void GetNextLevel();
 	void SetBrokenModel(EntityID entity);
-	void CreateBrokenModelPart(EntityID Parent, std::string ModelPath, glm::vec3 RelativePosition, glm::vec2 Hitbox);
+	void CreateBrokenModelPart(EntityID Parent, std::string ModelPath, glm::vec3 RelativePosition, glm::vec2 Hitbox, int NumberOfParts);
 };
 
 }

include/Game/LifeSystem.h

@@ -0,0 +1,80 @@
+//
+// Created by Adniklastrator on 2015-10-22.
+//
+
+#ifndef DAYDREAM_LIFESYSTEM_H
+#define DAYDREAM_LIFESYSTEM_H
+
+
+#include "Core/System.h"
+#include "Core/CTransform.h"
+#include "Core/CTemplate.h"
+#include "Core/EventBroker.h"
+#include "Core/World.h"
+
+#include "Core/ConfigFile.h"
+
+#include "Transform/EMove.h"
+#include "Rendering/CModel.h"
+
+#include "Game/CLife.h"
+#include "Game/EPause.h"
+#include "Game/EResume.h"
+#include "Game/ELifeLost.h"
+#include "Game/EGameOver.h"
+#include "Game/EKrakenAttackEnd.h"
+
+#include "Rendering/CAnimation.h"
+#include "Physics/CParticleEmitter.h"
+#include "Physics/ECreateParticleSequence.h"
+
+
+namespace dd
+{
+
+namespace Systems
+{
+
+class LifeSystem : public System
+{
+public:
+    LifeSystem(World* world, std::shared_ptr<dd::EventBroker> eventBroker)
+    : System(world, eventBroker)
+    { }
+
+    
+	void Initialize() override;
+	void Update(double dt) override;
+	void UpdateEntity(double dt, EntityID entity, EntityID parent) override;
+
+	bool IsPaused() const { return m_Pause; }
+	void SetPause(const bool& pause) { m_Pause = pause; }
+	int& Lives() { return m_Lives; }
+	void SetLives(const int& lives) { m_Lives = lives; }
+	int& PastLives() { return m_PastLives; }
+	void SetPastLives(const int& pastLives) { m_PastLives = pastLives; }
+
+private:
+	bool m_Pause = false;
+	int m_Lives = 3;
+	int m_PastLives = 3;
+	float m_LifeSpeed = 0.8;
+
+	bool m_GodMode = false;
+
+	void CreateLife(int);
+
+    dd::EventRelay<LifeSystem, dd::Events::Pause> m_EPause;
+	dd::EventRelay<LifeSystem, dd::Events::Resume> m_EResume;
+	dd::EventRelay<LifeSystem, dd::Events::LifeLost> m_ELifeLost;
+
+    bool OnPause(const dd::Events::Pause &event);
+	bool OnResume(const dd::Events::Resume &event);
+	bool OnLifeLost(const dd::Events::LifeLost &event);
+};
+
+}
+
+}
+
+#endif //DAYDREAM_LIFESYSTEM_H

include/Game/LifebuoySystem.h

@@ -47,6 +47,10 @@ public:
 private:
 	bool m_Pause = false;
 	EntityID m_Template;
+	Events::Lifebuoy m_SavedEvent;
+	bool m_Lifebuoy = false;
+	float m_Timer;
+	float m_WaitingTime = 0.4;
 
 	dd::EventRelay<LifebuoySystem, dd::Events::Contact> m_EContact;
 	dd::EventRelay<LifebuoySystem, dd::Events::Pause> m_EPause;
@@ -58,6 +62,7 @@ private:
 	bool OnPause(const dd::Events::Pause &event);
 	bool OnResume(const dd::Events::Resume &event);
 	bool OnLifebuoy(const dd::Events::Lifebuoy &event);
+	bool Lifebuoy(const dd::Events::Lifebuoy &event);
 	bool OnLifebuoyHit(const dd::Events::LifebuoyHit &event);
 
 	struct LifebuoyInfo

include/Game/PadSystem.h

@@ -43,6 +43,7 @@
 #include "Game/EStickyAttachedToPad.h"
 #include "Game/EInkBlaster.h"
 #include "Game/EKrakenAttack.h"
+#include "Game/EKrakenAttackEnd.h"
 #include "Game/EPowerUpTaken.h"
 #include "Game/EStageCleared.h"
 #include "Game/EPause.h"
@@ -50,8 +51,10 @@
 #include "Game/EHitLag.h"
 #include "Game/EScreenShake.h"
 #include "Game/EActionButton.h"
+#include "Rendering/CAnimation.h"
 
 #include "Game/EBrickGenerating.h"
+#include "Game/EBreakAllBricks.h"
 
 
 namespace dd
@@ -70,29 +73,12 @@ public:
     void Update(double dt) override;
     void UpdateEntity(double dt, EntityID entity, EntityID parent) override;
 
-    EntityID& Entity() { return m_Entity; }
-    void SetEntity(const EntityID& ent) { m_Entity = ent; }
-    glm::vec3 Acceleration() const { return m_Acceleration; }
-    void SetAcceleration(const glm::vec3& acceleration) { m_Acceleration = acceleration; }
-
-    bool Left() const { return m_Left; }
-    void SetLeft(const bool& left) { m_Left = left; }
-    bool Right() const { return m_Right; }
-    void SetRight(const bool& right) { m_Right = right; }
-    float Edge() const { return m_Edge; }
-    void SetEdge(const float& edge) { m_Edge = edge; }
-
-    Components::Transform* Transform() const { return m_Transform; }
-    void SetTransform(Components::Transform* transform) { m_Transform = transform; }
-    Components::Pad* Pad() const { return m_Pad; }
-    void SetPad(Components::Pad* pad) { m_Pad = pad; }
-
     bool IsPaused() const { return m_Pause; }
     void SetPause(const bool& pause) { m_Pause = pause; }
 
 private:
-    EntityID m_Entity = 0;
-    glm::vec3 m_Acceleration = glm::vec3(0.f, 0.f, 0.f);
+    EntityID m_PadEntity = 0;
+    glm::vec3 m_PadAcceleration = glm::vec3(0.f, 0.f, 0.f);
     bool m_Left = false;
     bool m_Right = false;
     bool m_ReplaceBall = false;
@@ -103,8 +89,13 @@ private:
 	double m_KrakenStrength = 0;
 	double m_PlayerStrength = 0;
     float m_Edge = 2.8f;
-    Components::Transform* m_Transform = nullptr;
-    Components::Pad* m_Pad = nullptr;
+	float m_PadOriginalHeight = -4.8;
+	float m_PadHeight = m_PadOriginalHeight;
+	EntityID m_KrakenArm = 0;
+	EntityID m_KrakenArmHitbox = 0;
+	float m_PadRiseSpeed = 0.2;
+    Components::Transform* m_PadTransform = nullptr;
+    Components::Pad* m_PadComponent = nullptr;
 	std::shared_ptr<Components::Transform> m_StickTransform;
 	std::shared_ptr<Components::StickyAim> m_StickyAim;
 
@@ -123,6 +114,7 @@ private:
     dd::EventRelay<PadSystem, dd::Events::Pause> m_EPause;
 	dd::EventRelay<PadSystem, dd::Events::Resume> m_EResume;
 	dd::EventRelay<PadSystem, dd::Events::KrakenAttack> m_EKrakenAttack;
+	dd::EventRelay<PadSystem, dd::Events::KrakenAttackEnd> m_EKrakenAttackEnd;
 	dd::EventRelay<PadSystem, dd::Events::StickyPad> m_EStickyPad;
 	dd::EventRelay<PadSystem, dd::Events::StickyAttachedToPad> m_EStickyAttachedToPad;
 	dd::EventRelay<PadSystem, dd::Events::ActionButton> m_EActionButton;
@@ -140,6 +132,7 @@ private:
     bool OnPause(const dd::Events::Pause &event);
 	bool OnResume(const dd::Events::Resume &event);
 	bool OnKrakenAttack(const dd::Events::KrakenAttack &event);
+	bool OnKrakenAttackEnd(const dd::Events::KrakenAttackEnd &event);
 	bool OnStickyPad(const dd::Events::StickyPad &event);
 	bool OnStickyAttachedToPad(const dd::Events::StickyAttachedToPad &event);
 	bool OnActionButton(const dd::Events::ActionButton &event);

include/Game/ProjectileSystem.h

@@ -5,6 +5,10 @@
 #ifndef DAYDREAM_PROJECTILESYSTEM_H
 #define DAYDREAM_PROJECTILESYSTEM_H
 
+
+#include <fstream>
+#include <iostream>
+
 #include "Core/System.h"
 #include "Core/CTransform.h"
 #include "Core/CTemplate.h"
@@ -19,13 +23,14 @@
 #include "Game/EResume.h"
 #include "Game/EInkBlaster.h"
 #include "Game/EInkBlasterOver.h"
+#include "Game/EKrakenAttack.h"
+#include "Game/EKrakenAttackEnd.h"
 #include "Game/EActionButton.h"
 #include "Game/EHitPad.h"
 #include "Game/CProjectile.h"
 #include "Game/CBall.h"
 #include "Rendering/CSprite.h"
-#include <fstream>
-#include <iostream>
+#include "Rendering/CAnimation.h"
 
 namespace dd
 {
@@ -52,6 +57,7 @@ private:
 	bool m_Pause = false;
 	bool m_InkBlaster = false;
 	bool m_SquidLoaded = false;
+	bool m_KrakenAttack = false;
 	int m_Shots = 0;
 	float m_InkBlasterSpeed = 5;
 	EntityID m_InkBlastTemplate;
@@ -61,6 +67,8 @@ private:
 	dd::EventRelay<ProjectileSystem, dd::Events::Pause> m_EPause;
 	dd::EventRelay<ProjectileSystem, dd::Events::Resume> m_EResume;
 	dd::EventRelay<ProjectileSystem, dd::Events::InkBlaster> m_EInkBlaster;
+	dd::EventRelay<ProjectileSystem, dd::Events::KrakenAttack> m_EKrakenAttack;
+	dd::EventRelay<ProjectileSystem, dd::Events::KrakenAttackEnd> m_EKrakenAttackEnd;
 	dd::EventRelay<ProjectileSystem, dd::Events::HitPad> m_EHitPad;
 	dd::EventRelay<ProjectileSystem, dd::Events::ActionButton> m_EActionButton;
 
@@ -68,6 +76,8 @@ private:
 	bool OnPause(const dd::Events::Pause &event);
 	bool OnResume(const dd::Events::Resume &event);
 	bool OnInkBlaster(const dd::Events::InkBlaster &event);
+	bool OnKrakenAttack(const dd::Events::KrakenAttack &event);
+	bool OnKrakenAttackEnd(const dd::Events::KrakenAttackEnd &event);
 	bool OnHitPad(const dd::Events::HitPad &event);
 	bool OnActionButton(const dd::Events::ActionButton &event);
 };

include/Game/ScreenShakeSystem.h

@@ -12,6 +12,7 @@
 #include "Core/CTemplate.h"
 #include "Core/EventBroker.h"
 #include "Core/World.h"
+#include "Rendering/CCamera.h"
 #include "Game/EPause.h"
 #include "Game/EResume.h"
 #include "Game/EScreenShake.h"

include/Game/TravellingSystem.h

@@ -18,6 +18,7 @@
 #include "Game/EStageCleared.h"
 #include "Game/CTravels.h"
 #include "Game/CBackground.h"
+#include "Game/CNewWaterVolume.h"
 
 
 namespace dd

include/Game/WaterSystem.h

@@ -11,9 +11,13 @@
 #include "Core/CTemplate.h"
 #include "Core/EventBroker.h"
 #include "Core/World.h"
+#include "Core/ConfigFile.h"
 #include "Transform/EMove.h"
+#include "Physics/CPhysics.h"
 #include "Physics/CWaterVolume.h"
 #include "Physics/CRectangleShape.h"
+#include "Game/CBrickPart.h"
+#include "Game/CNewWaterVolume.h"
 #include "Game/EPause.h"
 #include "Game/EResume.h"
 #include "Game/ERelevantObjectCreated.h"
@@ -47,6 +51,13 @@ public:
 private:
 	bool m_Pause = false;
 	EntityID m_BottomWall = 0;
+	float m_SubmergedOriginalHeight = -4.5;
+	float m_SubmergedHeight = m_SubmergedOriginalHeight;
+
+	bool m_RaiseWater = false;
+	bool m_RemoveWater = false;
+
+	std::array<int, 10> m_BrickPartCounters;
 
     dd::EventRelay<WaterSystem, dd::Events::Pause> m_EPause;
 	dd::EventRelay<WaterSystem, dd::Events::Resume> m_EResume;

include/Physics/CParticleEmitter.h

@@ -22,7 +22,7 @@ struct ParticleEmitter : public Component
     float Speed = 2.f;
     double LifeTime = 100;
 	float RadiusDistribution = 0;
-
+	bool DefaultScale = false;
 	//values to interpolate between.
 	std::vector<glm::vec3> ScaleValues;
 	std::vector<float> AlphaValues;

include/Physics/ECreateParticleSequence.h

@@ -26,6 +26,7 @@ struct CreateParticleSequence : public Event
 	glm::vec4 Color = glm::vec4(0);
 	EntityID parent = 0;
 	// values to interpolate between.
+	bool DefaultScale = false;
 	std::vector<glm::vec3> ScaleValues;
 	std::vector<float> AlphaValues;
 

include/Physics/PhysicsSystem.h

@@ -14,6 +14,7 @@
 #include "Core/CTemplate.h"
 #include "Core/CTransform.h"
 #include "Core/CTemplate.h"
+#include "Rendering/Texture.h"
 
 #include "Physics/EContact.h"
 #include "Physics/ESetImpulse.h"
@@ -42,6 +43,8 @@
 #include "Rendering/CSprite.h"
 #include "Rendering/CModel.h"
 
+#include "Sound/EPlaySound.h"
+
 
 namespace dd
 {

include/PrecompiledHeader.h

@@ -29,9 +29,11 @@
 #define GLFW_INCLUDE_GLU
 #define NOMINMAX
 #include <GLFW/glfw3.h>
-#define GLFW_EXPOSE_NATIVE_WIN32
-#define GLFW_EXPOSE_NATIVE_WGL
-#include <GLFW/glfw3native.h>
+#ifdef BUILD_RENDERER_DIRECTX
+	#define GLFW_EXPOSE_NATIVE_WIN32
+	#define GLFW_EXPOSE_NATIVE_WGL
+	#include <GLFW/glfw3native.h>
+#endif
 #include <glext.h>
 #include "Core/Util/GLError.h"
 

include/Rendering/AnimationSystem.h

@@ -4,6 +4,9 @@
 #include "Core/System.h"
 #include "Core/World.h"
 #include "Rendering/CAnimation.h"
+#include "Rendering/EAnimationComplete.h"
+#include "Rendering/CModel.h"
+#include "Rendering/Model.h"
 #include "Game/EPause.h"
 #include "Game/EResume.h"
 

include/Rendering/BaseRenderer.h

@@ -37,8 +37,8 @@ public:
 	void SetFullscreen(bool fullscreen) { m_Fullscreen = fullscreen; }
 	bool VSYNC() const { return m_VSYNC; }
 	void SetVSYNC(bool vsync) { m_VSYNC = vsync; }
-	const dd::Camera* Camera() const { return m_Camera; }
-	void SetCamera(const dd::Camera* camera)
+	dd::Camera* Camera() const { return m_Camera; }
+	void SetCamera(dd::Camera* camera)
 	{
 		if (camera == nullptr) {
 			m_Camera = m_DefaultCamera.get();
@@ -55,7 +55,7 @@ protected:
 	bool m_Fullscreen = false;
 	bool m_VSYNC = false;
 	std::unique_ptr<dd::Camera> m_DefaultCamera = nullptr;
-	const dd::Camera* m_Camera = nullptr;
+	dd::Camera* m_Camera = nullptr;
 	GLFWwindow* m_Window = nullptr;
 };
 

include/Rendering/CAnimation.h

@@ -13,6 +13,7 @@ struct Animation : Component
 	std::string Name;
 	double Time = 0.0;
 	double Speed = 0.0;
+	bool Loop = true;
 	bool NoRootMotion = true;
 };
 

include/Rendering/CCamera.h

@@ -30,14 +30,9 @@ namespace Components
 
 struct Camera : Component
 {
-	Camera() 
-	: FOV(glm::radians(45.f))
-	, NearClip(0.1f)
-	, FarClip(100.f) { }
-
-	float FOV;
-	float NearClip;
-	float FarClip;
+	float FOV = glm::radians(45.f);
+	float NearClip = 0.01f;
+	float FarClip = 100.f;
 };
 
 }

include/Rendering/EAnimationComplete.h

@@ -0,0 +1,21 @@
+#ifndef RENDERING_EANIMATIONCOMPLETE_H__
+#define RENDERING_EANIMATIONCOMPLETE_H__
+
+#include "Core/Entity.h"
+#include "Core/EventBroker.h"
+
+namespace dd
+{
+namespace Events
+{
+
+struct AnimationComplete : Event
+{
+	EntityID Entity;
+	std::string Animation;
+};
+
+}
+}
+
+#endif

include/Rendering/OpenGL/Rendering/Renderer.h

@@ -43,7 +43,6 @@ class Renderer : public BaseRenderer
 public:
 	void Initialize() override;
 	void Draw(RenderQueueCollection& rq) override;
-	void PlaceCamera(glm::vec3 position);
 
 private:
 	int m_GLVersion[2];
@@ -97,12 +96,6 @@ private:
 	void DrawWater(RenderQueue &objects);
 	void DrawGUI(RenderQueue& rq);
 	void DebugKeys();
-
-	dd::EventRelay<Renderer, dd::Events::ScreenShake> m_EScreenShake;
-	bool OnScreenShake(dd::Events::ScreenShake &event);
-	bool m_ScreenShake = false;
-	float m_ShakeIntensity = 0;
-	float m_ShakeTimer = 0;
 };
 
 }

include/Sound/SoundSystem.h

@@ -20,6 +20,7 @@
 #include "Physics/ECreateParticleSequence.h"
 #include "Physics/EContact.h"
 #include "Game/EGameStart.h"
+#include "Game/EKrakenAppear.h"
 
 
 namespace dd
@@ -41,6 +42,8 @@ private:
 	const std::string MENU_BGM = "Sounds/BGM/eastern-music.wav";
 	const std::string GAME_BGM = "Sounds/BGM/under-the-sea-n.wav";
 	const std::string WATER_BGM = "Sounds/BGM/water-flowing.wav";
+	const std::string STORY_VOICE = "Sounds/jap-story.wav";
+	const std::string BOSS_BGM = "Sounds/BGM/boss-fight.wav";
 
     float m_BGMMasterVolume = 1.f;
     float m_SFXMasterVolume = 1.f;
@@ -61,6 +64,8 @@ private:
     bool OnMasterVolume(const dd::Events::MasterVolume &event);
 	dd::EventRelay<SoundSystem, dd::Events::GameStart> m_EGameStart;
 	bool OnGameStart(const dd::Events::GameStart &event);
+	dd::EventRelay <SoundSystem, dd::Events::KrakenAppear> m_EKrakenAppear;
+	bool OnKrakenAppear(const dd::Events::KrakenAppear &event);
 	
 
     ALuint CreateSource();

src/game/CMakeLists.txt

@@ -112,6 +112,17 @@ set(SOURCE_FILES
     ${SOURCE_FILES_GUI}
 )
 
+set(LIBRARIES
+    ${OPENGL_LIBRARIES}
+    ${GLEW_LIBRARIES}
+    ${GLFW_LIBRARIES}
+    ${Boost_LIBRARIES}
+    ${assimp_LIBRARIES}
+    ${PNG_LIBRARIES}
+    ${X11_LIBRARIES}
+    ${OPENAL_LIBRARY}
+    ${liquidfun_LIBRARIES}
+)
     
 if(BUILD_RENDERER_OPENGL)
     set(SOURCE_FILES ${SOURCE_FILES}
@@ -123,6 +134,9 @@ if(BUILD_RENDERER_DIRECTX)
     set(SOURCE_FILES ${SOURCE_FILES}
         ${SOURCE_FILES_Rendering_DirectX}
     )
+    set(LIBRARIES ${LIBRARIES}
+        ${CMAKE_LIBRARY_PATH}/DirectXTK.lib
+    )
 endif()
 
 if(CMAKE_COMPILER_IS_GNUCXX)
@@ -133,16 +147,7 @@ endif()
 
 add_library(game ${SOURCE_FILES})
 target_link_libraries(game
-    ${OPENGL_LIBRARIES}
-    ${GLEW_LIBRARIES}
-    ${GLFW_LIBRARIES}
-    ${Boost_LIBRARIES}
-    ${assimp_LIBRARIES}
-    ${PNG_LIBRARIES}
-    ${X11_LIBRARIES}
-    ${OPENAL_LIBRARY}
-	${liquidfun_LIBRARIES}
-    ${CMAKE_LIBRARY_PATH}/DirectXTK.lib
+    ${LIBRARIES}
 )
 
 add_executable(breakout 
@@ -150,15 +155,6 @@ add_executable(breakout
 )
 target_link_libraries(breakout
 	game
-    ${OPENGL_LIBRARIES}
-    ${GLEW_LIBRARIES}
-    ${GLFW_LIBRARIES}
-    ${Boost_LIBRARIES}
-    ${assimp_LIBRARIES}
-    ${PNG_LIBRARIES}
-	${X11_LIBRARIES}
-    ${OPENAL_LIBRARY}
-    ${liquidfun_LIBRARIES}
-    ${CMAKE_LIBRARY_PATH}/DirectXTK.lib
+    ${LIBRARIES}
 )
 

src/game/Core/ResourceManager.cpp

@@ -19,10 +19,12 @@
 #include "PrecompiledHeader.h"
 #include "Core/ResourceManager.h"
 
+std::unordered_map<std::string, std::string> dd::ResourceManager::m_CompilerTypenameToResourceType;
 std::unordered_map<std::string, std::function<dd::Resource*(std::string)>> dd::ResourceManager::m_FactoryFunctions;
 std::unordered_map<std::pair<std::string, std::string>, dd::Resource*> dd::ResourceManager::m_ResourceCache;
 std::unordered_map<std::string, dd::Resource*> dd::ResourceManager::m_ResourceFromName;
 std::unordered_map<dd::Resource*, dd::Resource*> dd::ResourceManager::m_ResourceParents;
+std::set<std::pair<std::string, std::string>> dd::ResourceManager::m_Preloads; // (type, name)
 unsigned int dd::ResourceManager::m_CurrentResourceTypeID = 0;
 std::unordered_map<std::string, unsigned int> dd::ResourceManager::m_ResourceTypeIDs;
 std::unordered_map<unsigned int, unsigned int> dd::ResourceManager::m_ResourceCount;
@@ -82,4 +84,86 @@ void dd::ResourceManager::fileWatcherCallback(std::string path, FileWatcher::Fil
 void dd::ResourceManager::Update()
 {
 	m_FileWatcher.Check();
+}
+
+void dd::ResourceManager::LoadPreloadsFromFile()
+{
+	std::ifstream f("PreloadResources");
+	while (f.good()) {
+		std::string resourceType;
+		std::string resourceName;
+		f >> resourceType >> resourceName;
+		if (!resourceType.empty() && !resourceType.empty()) {
+			m_Preloads.insert(std::make_pair(resourceType, resourceName));
+		}
+	}
+	f.close();
+}
+
+void dd::ResourceManager::Preload(std::string resourceType, std::string resourceName)
+{
+	if (IsResourceLoaded(resourceType, resourceName))
+	{
+		//LOG_WARNING("Attempted to preload resource \"%s\" multiple times!", resourceName.c_str());
+		return;
+	}
+
+	m_Preloading = true;
+	LOG_INFO("Preloading resource \"%s\"", resourceName.c_str());
+	CreateResource(resourceType, resourceName, nullptr);
+	m_Preloading = false;
+}
+
+dd::Resource* dd::ResourceManager::Load(std::string resourceType, std::string resourceName, dd::Resource* parent /*= nullptr*/)
+{
+	auto it = m_ResourceCache.find(std::make_pair(resourceType, resourceName));
+	if (it != m_ResourceCache.end())
+		return it->second;
+
+	if (m_Preloading) {
+		LOG_INFO("Preloading resource \"%s\"", resourceName.c_str());
+	} else {
+		LOG_WARNING("Hot-loading resource \"%s\"", resourceName.c_str());
+
+		if (!resourceType.empty() && !resourceName.empty()) {
+			std::replace(resourceName.begin(), resourceName.end(), '\\', '/');
+			if (m_Preloads.find(std::make_pair(resourceType, resourceName)) == m_Preloads.end()) {
+				std::ofstream f("PreloadResources", std::ofstream::app);
+				f << resourceType << " " << resourceName << std::endl;
+				f.close();
+				m_Preloads.insert(std::make_pair(resourceType, resourceName));
+			}
+		}
+	}
+
+	return CreateResource(resourceType, resourceName, parent);
+}
+
+dd::Resource* dd::ResourceManager::CreateResource(std::string resourceType, std::string resourceName, dd::Resource* parent)
+{
+	auto facIt = m_FactoryFunctions.find(resourceType);
+	if (facIt == m_FactoryFunctions.end())
+	{
+		LOG_ERROR("Failed to load resource \"%s\" of type \"%s\": type not registered", resourceName.c_str(), resourceType.c_str());
+		return nullptr;
+	}
+
+	// Call the factory function
+	Resource* resource = facIt->second(resourceName);
+	// Store IDs
+	resource->TypeID = GetTypeID(resourceType);
+	resource->ResourceID = GetNewResourceID(resource->TypeID);
+	// Cache
+	m_ResourceCache[std::make_pair(resourceType, resourceName)] = resource;
+	m_ResourceFromName[resourceName] = resource;
+	if (parent != nullptr)
+	{
+		m_ResourceParents[resource] = parent;
+	}
+	if (!boost::filesystem::is_directory(resourceName))
+	{
+		LOG_DEBUG("Adding watch for %s", resourceName.c_str());
+		m_FileWatcher.AddWatch(resourceName, fileWatcherCallback);
+	}
+	return resource;
 }

src/game/Game/KrakenSystem.cpp

@@ -17,34 +17,40 @@ void dd::Systems::KrakenSystem::Initialize()
 	EVENT_SUBSCRIBE_MEMBER(m_EKrakenHit, &KrakenSystem::OnKrakenHit);
 	EVENT_SUBSCRIBE_MEMBER(m_EKrakenDefeated, &KrakenSystem::OnKrakenDefeated);
 	EVENT_SUBSCRIBE_MEMBER(m_EBrickGenerating, &KrakenSystem::OnBrickGenerating);
+	EVENT_SUBSCRIBE_MEMBER(m_EArrivedAtNewStage, &KrakenSystem::OnArrivedAtNewStage);
 
 	EntityID ent = m_World->CreateEntity();
 	auto transform = m_World->AddComponent<Components::Transform>(ent);
+	transform->Position = glm::vec3(50, 50, -10);
 	auto model = m_World->AddComponent<Components::Model>(ent);
+	model->ModelFile = "Models/Kraken/Body.dae";
+	auto animationComponent = m_World->AddComponent<Components::Animation>(ent);
+	animationComponent->Speed = 0.6f;
+
 	auto kraken = m_World->AddComponent<Components::Kraken>(ent);
-	std::shared_ptr<Components::RectangleShape> cCircle = m_World->AddComponent<Components::RectangleShape>(ent);
-	cCircle->Dimensions = glm::vec2(2, 4);
+
+	std::shared_ptr<Components::RectangleShape> cRect = m_World->AddComponent<Components::RectangleShape>(ent);
+	cRect->Dimensions = glm::vec2(10.f, 4.f);
+
 	//cCircle->Radius = 2;
 	std::shared_ptr<Components::Physics> cPhys = m_World->AddComponent<Components::Physics>(ent);
-	std::shared_ptr<Components::Template> cTemplate = m_World->AddComponent<Components::Template>(ent);
-
-	auto travels = m_World->AddComponent<Components::Travels>(ent);
-	travels->CurrentlyTraveling = false;
-
 	cPhys->CollisionType = CollisionType::Type::Static;
 	cPhys->GravityScale = 0.f;
 	cPhys->Category = CollisionLayer::Type::Brick;
 	cPhys->Mask = static_cast<CollisionLayer::Type>(CollisionLayer::Type::Ball | CollisionLayer::Type::Projectile | CollisionLayer::Type::Wall | CollisionLayer::LifeBuoy);
 
-	model->ModelFile = "Models/Test/Ball/Sid.obj";
-	transform->Position = glm::vec3(50, 50, -10);
+	std::shared_ptr<Components::Template> cTemplate = m_World->AddComponent<Components::Template>(ent);
+
+	auto travels = m_World->AddComponent<Components::Travels>(ent);
+	travels->CurrentlyTraveling = false;
+
+	
 	//sound
 	auto collisionSound = m_World->AddComponent<Components::CollisionSound>(ent);
-	collisionSound->FilePath = "Sounds/Brick/LTTP_Boss_Hit.wav";
+	collisionSound->FilePath = "Sounds/Boss/boss-hit.wav";
 	m_World->CommitEntity(ent);
 
 	m_KrakenTemplate = ent;
-
 	InitializeObjects();
 }
 
@@ -62,6 +68,16 @@ void dd::Systems::KrakenSystem::Update(double dt)
 
 void dd::Systems::KrakenSystem::UpdateEntity(double dt, EntityID entity, EntityID parent)
 {
+	auto kraken = m_World->GetComponent<Components::Kraken>(entity);
+	if (kraken != nullptr) {
+		if (kraken->Health < 0) {
+			auto transform = m_World->GetComponent<Components::Transform>(entity);
+			transform->Position.y += kraken->RetreatSpeed * dt;
+			kraken->RetreatSpeed += 0.05;
+			return;
+		}
+	}
+
     if (IsPaused() || !m_KrakenBattle) {
         return;
     }
@@ -69,7 +85,7 @@ void dd::Systems::KrakenSystem::UpdateEntity(double dt, EntityID entity, EntityI
 	auto templateCheck = m_World->GetComponent<Components::Template>(entity);
 	if (templateCheck != nullptr){ return; }
 
-	auto kraken = m_World->GetComponent<Components::Kraken>(entity);
+	
 	if (kraken != nullptr) {
 		auto transform = m_World->GetComponent<Components::Transform>(entity);
 		if (transform->Position.y < -10) {
@@ -77,30 +93,98 @@ void dd::Systems::KrakenSystem::UpdateEntity(double dt, EntityID entity, EntityI
 			return;
 		}
 		Events::KrakenAttack krakenAttack;
-		switch (kraken->CurrentAction)
-		{
+		switch (kraken->CurrentAction) {
 		case 1: // Idle
-			//m_KrakenTimer += dt;
-			if (m_KrakenTimer > m_KrakenSecondsToAction) {
+			if (m_RandomKraken) {
+				m_KrakenTimer += dt;
+			}
+			if (m_KrakenTimer > m_KrakenCurrentSecondsToAction) {
 				m_KrakenTimer = 0;
-				std::uniform_real_distribution<float> dist(1, 2.999f);
-				float random = dist(m_RandomGenerator);
-				//std::cout << random << std::endl;
-				kraken->CurrentAction = random;
-				//std::cout << kraken->CurrentAction << std::endl;
+				kraken->CurrentAction = 3;
+				if (m_NumberOfActions == 0) {
+					kraken->CurrentAction = 3;
+				} else {
+					std::uniform_real_distribution<float> dist(1, 4.999f);
+					float random = dist(m_RandomGenerator);
+					//std::cout << random << std::endl;
+					kraken->CurrentAction = random;
+					//std::cout << kraken->CurrentAction << std::endl;
+				}
 			}
 			break;
 		case 2: // Grabbing
-			kraken->CurrentAction = 5;
-			krakenAttack.ChargeUpdate = 0;
+			m_NumberOfActions++;
+			kraken->CurrentAction = 3;
+			/*krakenAttack.ChargeUpdate = 0;
 			krakenAttack.KrakenStrength = 0.1;
 			krakenAttack.PlayerStrength = 0.05;
-			EventBroker->Publish(krakenAttack);
+			EventBroker->Publish(krakenAttack);*/
+			
 			break;
 		case 3: // Brick Generating
-			break;
-		case 4: // Moving
-			break;
+			{
+				m_NumberOfActions++;
+				kraken->CurrentAction = 1;
+				Events::BrickGenerating e;
+				e.Origin1 = glm::vec3(-5, 7, -10);
+				e.Origin2 = glm::vec3(5, 7, -10);
+				e.Speed = 10;
+				if (m_RandomKraken) {
+					if (kraken->Health > 20) {
+					e.SetCluster = 0;
+					} else if (kraken->Health > 10) {
+					e.SetCluster = 1;
+					} else {
+					e.SetCluster = 2;
+					}
+					std::uniform_real_distribution<float> dist(1, 6.999f);
+					float random = dist(m_RandomGenerator);
+					e.Set = random;
+				} else {
+					e.Set = m_Set;
+					e.SetCluster = m_SetCluster;
+					m_Set++;
+					if (m_Set > 6) {
+						m_SetCluster++;
+						m_Set = 1;
+					}
+				}
+
+				EventBroker->Publish(e);
+				break;
+			}
+		case 4: // Brick Generating second case
+			{
+				m_NumberOfActions++;
+				kraken->CurrentAction = 1;
+				Events::BrickGenerating e;
+				e.Origin1 = glm::vec3(-5, 7, -10);
+				e.Origin2 = glm::vec3(5, 7, -10);
+				e.Speed = 10;
+				if (m_RandomKraken) {
+					if (kraken->Health > 20) {
+						e.SetCluster = 0;
+					} else if (kraken->Health > 10) {
+						e.SetCluster = 1;
+					} else {
+						e.SetCluster = 2;
+					}
+					std::uniform_real_distribution<float> dist(1, 6.999f);
+					float random = dist(m_RandomGenerator);
+					e.Set = random;
+				} else {
+					e.Set = m_Set;
+					e.SetCluster = m_SetCluster;
+					m_Set++;
+					if (m_Set > 6) {
+					m_SetCluster++;
+					m_Set = 1;
+					}
+				}
+
+				EventBroker->Publish(e);
+				break;
+			}
 		case 5: // Taunting
 			if (m_ReturnToIdle) {
 				m_ReturnToIdle = false;
@@ -161,13 +245,40 @@ bool dd::Systems::KrakenSystem::OnContact(const dd::Events::Contact &event)
 		return false;
 	}
 	
-	auto ball = m_World->GetComponent<Components::Ball>(otherEntitiy);
-	if (ball != nullptr) {
+	auto projectile = m_World->GetComponent<Components::Projectile>(otherEntitiy);
+	if (projectile != nullptr) {
+		Events::ScoreEvent es;
+		es.Score = 23;
+		EventBroker->Publish(es);
 		Events::KrakenHit e;
 		e.Kraken = krakenEntity;
 		e.Hitter = otherEntitiy;
+		e.MaxHealth = kraken->MaxHealth;
+		e.CurrentHealth = kraken->Health;
+		e.NewHealth = kraken->Health - 1;
+		EventBroker->Publish(e);
+		m_World->RemoveEntity(otherEntitiy);
+		return true;
+	}
+	auto ball = m_World->GetComponent<Components::Ball>(otherEntitiy);
+	if (ball != nullptr) {
+		ball->Combo += 1;
+		Events::ComboEvent ec;
+		ec.Combo = ball->Combo;
+		ec.Ball = otherEntitiy;
+		EventBroker->Publish(ec);
+		Events::ScoreEvent es;
+		es.Score = ball->Combo * 23;
+		EventBroker->Publish(es);
+		Events::KrakenHit e;
+		e.Kraken = krakenEntity;
+		e.Hitter = otherEntitiy;
+		e.MaxHealth = kraken->MaxHealth;
+		e.CurrentHealth = kraken->Health;
+		e.NewHealth = kraken->Health - 1;
 		EventBroker->Publish(e);
 	}
+	return true;
 }
 
 bool dd::Systems::KrakenSystem::OnKrakenAppear(const dd::Events::KrakenAppear &event)
@@ -176,7 +287,15 @@ bool dd::Systems::KrakenSystem::OnKrakenAppear(const dd::Events::KrakenAppear &e
 	m_World->RemoveComponent<Components::Template>(ent);
 	auto transform = m_World->GetComponent<Components::Transform>(ent);
 	transform->Position = event.Position;
+	transform->Position.y += 3.f;
 	m_KrakenBattle = true;
+
+	Events::ScreenShake e;
+	e.Intensity = 10;
+	e.Time = 2;
+	e.TimeTakenToCoolDown = 6;
+	EventBroker->Publish(e);
+
 	return true;
 }
 
@@ -185,34 +304,108 @@ bool dd::Systems::KrakenSystem::OnKrakenAttack(const dd::Events::KrakenAttack &e
 	if (event.ChargeUpdate >= 1) {
 		m_ReturnToIdle = true;
 	}
+
+	Events::ScreenShake e;
+	e.Intensity = 2;
+	e.Time = 0.5f;
+	e.TimeTakenToCoolDown = 3.f;
+	EventBroker->Publish(e);
+
 	return true;
 }
 
 bool dd::Systems::KrakenSystem::OnKrakenHit(const dd::Events::KrakenHit &event)
 {
 	auto kraken = m_World->GetComponent<Components::Kraken>(event.Kraken);
-	//kraken->Health--;
+	auto transform = m_World->GetComponent<Components::Transform>(event.Hitter);
+	kraken->Health--;
+	kraken->CurrentAction = 3;
+	//kraken->Health -= 15;
+	//kraken->Health = -1; //To defeat the kraken instantly.
+
+	auto model = m_World->GetComponent<Components::Model>(event.Kraken);
+	float modifier = ((float)kraken->MaxHealth - (float)kraken->Health) / (float)kraken->MaxHealth; // 1 is almost no life left, 0 is max life left.
+	//std::cout << modifier << std::endl;
+	model->Color = glm::vec4(1, 1 - modifier, 1 - modifier, 1);
+
+	int timeDifferenceBetweenMaxAndMin = m_KrakenMaxSecondsToAction - m_KrakenMinSecondsToAction;
+	m_KrakenCurrentSecondsToAction = m_KrakenMaxSecondsToAction - (modifier * timeDifferenceBetweenMaxAndMin);
+	// If modifier is 1, MaxSeconds is 15, MinSeconds is 5, then... 15 - (1 * 10), meaning 5.
+
+	auto ball = m_World->GetComponent<Components::Transform>(event.Hitter);
+	if (ball != nullptr) {
+		//Particle trail
+		Events::CreateParticleSequence trail;
+		trail.parent = event.Hitter;
+		trail.AlphaValues.push_back(1.f);
+		trail.AlphaValues.push_back(0.f);
+		trail.ScaleValues.push_back(glm::vec3(0.08f));
+		trail.ScaleValues.push_back(glm::vec3(0.f));
+		trail.RadiusDistribution = 2;
+		trail.EmitterLifeTime = 1.f;
+		trail.ParticleLifeTime = 1.f;
+		trail.ParticlesPerTick = 1;
+		trail.SpawnRate = 0.5f;
+		trail.Speed = 10.f;
+		trail.EmittingAngle = glm::half_pi<float>();
+		trail.SpriteFile = "Textures/Particles/FadeBall.png";
+		trail.Color = glm::vec4(1, 0, 0, 1);
+		//p.Spread = ...
+		EventBroker->Publish(trail);
+	}
+
+	//ParticlePoof
+	Events::CreateParticleSequence poof;
+	poof.EmitterLifeTime = 4;
+	poof.EmittingAngle = glm::half_pi<float>();
+	poof.Spread = 0.5f;
+	poof.NumberOfTicks = 1;
+	poof.ParticleLifeTime = 1.5f;
+	poof.ParticlesPerTick = 2;
+	poof.Position = transform->Position;
+	poof.ScaleValues.clear();
+	poof.ScaleValues.push_back(glm::vec3(0.5f));
+	poof.ScaleValues.push_back(glm::vec3(2.f, 2.f, 0.2f));
+	poof.SpriteFile = "Textures/Particles/Cloud_Particle.png";
+	poof.Color = glm::vec4(1, 0, 0, 1);
+	poof.AlphaValues.clear();
+	poof.AlphaValues.push_back(1.f);
+	poof.AlphaValues.push_back(0.f);
+	poof.Speed = 20;
+	EventBroker->Publish(poof);
+
 	//std::cout << kraken->Health << std::endl;
-	kraken->Health = -1;
+	//kraken->Health = -1;
 	if (kraken->Health < 0) {
 		Events::KrakenDefeated e;
 		e.Kraken = event.Kraken;
 		e.Hitter = event.Hitter;
 		EventBroker->Publish(e);
 	}
+
+	Events::ScreenShake e;
+	e.Intensity = 2;
+	e.Time = 0.2f;
+	e.TimeTakenToCoolDown = 1.5f;
+	EventBroker->Publish(e);
+
 	return false;
 }
 
 bool dd::Systems::KrakenSystem::OnKrakenDefeated(const dd::Events::KrakenDefeated &event)
 {
 	m_KrakenBattle = false;
+	m_Set = 0;
+	m_SetCluster = 0;
 
 	auto kraken = m_World->GetComponent<Components::Kraken>(event.Kraken);
 	auto physicsComponent = m_World->GetComponent<Components::Physics>(event.Kraken);
+
+	m_World->RemoveComponent<Components::Travels>(event.Kraken);
 	/*physicsComponent->CollisionType = CollisionType::Type::Dynamic;
-	physicsComponent->GravityScale = 1.f;
+	physicsComponent->GravityScale = 1.f;*/
 	physicsComponent->Mask = static_cast<CollisionLayer::Type>(CollisionLayer::Water | CollisionLayer::Wall);
-	physicsComponent->Calculate = false;*/
+	/*physicsComponent->Calculate = false;*/
 
 	auto transformComponentBrick = m_World->GetComponent<Components::Transform>(event.Kraken);
 	auto transformComponentHitter = m_World->GetComponent<Components::Transform>(event.Hitter);
@@ -235,8 +428,8 @@ bool dd::Systems::KrakenSystem::OnKrakenDefeated(const dd::Events::KrakenDefeate
 	EventBroker->Publish(i);*/
 
 	auto cModel = m_World->GetComponent<Components::Model>(event.Kraken);
-	cModel->Color = brickModel->Color;
-	cModel->Color *= 0.5f;
+	cModel->Color = glm::vec4(1, 1, 1, 1);
+	cModel->Color *= 0.3f;
 
 	/*m_World->RemoveComponent<Components::Template>(event.Kraken);
 	m_World->SetEntityParent(event.Kraken, 0);
@@ -288,4 +481,12 @@ bool dd::Systems::KrakenSystem::OnKrakenDefeated(const dd::Events::KrakenDefeate
 bool dd::Systems::KrakenSystem::OnBrickGenerating(const dd::Events::BrickGenerating &event)
 {
 	return true;
+}
+
+bool dd::Systems::KrakenSystem::OnArrivedAtNewStage(const dd::Events::ArrivedAtNewStage &event)
+{
+	if (m_KrakenBattle) {
+		m_KrakenHasArrived = true;
+	}
+	return true;
 }

src/game/Game/LevelSystem.cpp

@@ -23,9 +23,19 @@ void dd::Systems::LevelSystem::Initialize()
 	EVENT_SUBSCRIBE_MEMBER(m_EResume, &LevelSystem::OnResume);
 	EVENT_SUBSCRIBE_MEMBER(m_EHitPad, &LevelSystem::OnHitPad);
 	EVENT_SUBSCRIBE_MEMBER(m_EBrickGenerating, &LevelSystem::OnBrickGenerating);
+	EVENT_SUBSCRIBE_MEMBER(m_EBreakAllBricks, &LevelSystem::OnBreakAllBricks);
 	EVENT_SUBSCRIBE_MEMBER(m_EKrakenDefeated, &LevelSystem::OnKrakenDefeated);
 
-	m_GodMode = ResourceManager::Load<ConfigFile>("Config.ini")->GetValue("Cheat.GodMode", false);
+	m_GodMode = ResourceManager::Load<ConfigFile>("Config.ini")->GetValue<bool>("Cheat.GodMode", false);
+
+	// Camera
+	{
+		auto ent = m_World->CreateEntity();
+		auto transform = m_World->AddComponent<Components::Transform>(ent);
+		auto camera = m_World->AddComponent<Components::Camera>(ent);
+		camera->FOV = glm::radians(58.31f);
+		m_World->CommitEntity(ent);
+	}
 
 	//PointLightTest
 	{
@@ -61,15 +71,27 @@ void dd::Systems::LevelSystem::Initialize()
 		auto travels = m_World->AddComponent<Components::Travels>(t_halfPipe);
 		travels->CurrentlyTraveling = false;
 		auto model = m_World->AddComponent<Components::Model>(t_halfPipe);
-		model->ModelFile = "Models/Test/halfpipe/Halfpipe.obj";
-		model->Color = glm::vec4(0.8f, 0.8f, 0.8f, 1.f);
+		model->ModelFile = "Models/Halfpipe.obj";
+		//model->Color = glm::vec4(0.8f, 0.8f, 0.8f, 1.f);
 		m_World->CommitEntity(t_halfPipe);
 
 		auto t_halfPipe2 = m_World->CloneEntity(t_halfPipe);
 		auto transform2 = m_World->GetComponent<Components::Transform>(t_halfPipe);
 		transform2->Position = glm::vec3(0.f, 34.6f, -15.f); //Halfpipe Value
+
+		// Added to prevent white borders around screen shake
+		{
+			auto halfPipeBackground = m_World->CreateEntity();
+			auto transform = m_World->AddComponent<Components::Transform>(halfPipeBackground);
+			transform->Position = glm::vec3(0.f, 0.f, -15.f);
+			transform->Scale = glm::vec3(6.f, 6.f, 10.f) * 2.f;
+			auto model = m_World->AddComponent<Components::Model>(halfPipeBackground);
+			model->ModelFile = "Models/Halfpipe.obj";
+			m_World->CommitEntity(halfPipeBackground);
+		}
 	}
 
+
 	//Background
 
 	/*{
@@ -132,8 +154,8 @@ void dd::Systems::LevelSystem::Initialize()
 		auto wall = m_World->AddComponent<Components::Wall>(BottomWall);
 		transform->Position = glm::vec3(0.f, -6.f, -10.f);
 		transform->Scale = glm::vec3(20.f, 0.5f, 1.f);
-		std::shared_ptr<Components::Sprite> sprite = m_World->AddComponent<Components::Sprite>(BottomWall);
-		sprite->SpriteFile = "Textures/Core/ErrorTexture.png";
+		//std::shared_ptr<Components::Sprite> sprite = m_World->AddComponent<Components::Sprite>(BottomWall);
+		//sprite->SpriteFile = "Textures/Core/ErrorTexture.png";
 		std::shared_ptr<Components::RectangleShape> rectangleShape = m_World->AddComponent<Components::RectangleShape>(BottomWall);
 		rectangleShape->Dimensions = glm::vec2(20.f, 0.5f);
 		std::shared_ptr<Components::Physics> physics = m_World->AddComponent<Components::Physics>(BottomWall);
@@ -238,8 +260,9 @@ void dd::Systems::LevelSystem::Initialize()
 	transform->Position = glm::vec3(50, 50, -10);
 	//sound
 	auto collisionSound = m_World->AddComponent<Components::CollisionSound>(m_BrickTemplate);
-	collisionSound->FilePath = "Sounds/Brick/shortbrickbreak.wav";
+	collisionSound->FilePath = "Sounds/Brick/brick-hit.wav";
 	m_World->CommitEntity(m_BrickTemplate);
+
     return;
 }
 
@@ -248,6 +271,9 @@ void dd::Systems::LevelSystem::Update(double dt)
     if (!m_Initialized) {
         GetNextLevel();
         CreateLevel(0);
+		for (int i = 0; i < m_KrakenBricks.size(); i++) {
+			m_KrakenBricks[i] = false;
+		}
         m_Initialized = true;
     }
 }
@@ -275,9 +301,33 @@ void dd::Systems::LevelSystem::UpdateEntity(double dt, EntityID entity, EntityID
 		}
 	}
 
+	if (m_BreakAllBricks) {
+		if (m_LooseBricks == 1 && m_KrakenBattle) {
+			m_BreakAllBricks = false;
+		}
+	}
+
     auto brick = m_World->GetComponent<Components::Brick>(entity);
     if (brick != nullptr) {
-        auto transform = m_World->GetComponent<Components::Transform>(entity);
+		if (m_BreakAllBricks) {
+			if (!brick->Removed) {
+				brick->Removed = true;
+				BrickHit(entity, entity, 0, false);
+			}
+		}
+
+		auto transform = m_World->GetComponent<Components::Transform>(entity);
+		if (brick->BeingGenerated) {
+			if (transform->Position == brick->GenerationGoal) {
+				brick->BeingGenerated = false;
+				auto cPhys = m_World->AddComponent<Components::Physics>(entity);
+				cPhys->CollisionType = CollisionType::Type::Static;
+				cPhys->GravityScale = 0.f;
+				cPhys->Category = CollisionLayer::Type::Brick;
+				cPhys->Mask = static_cast<CollisionLayer::Type>(CollisionLayer::Type::Ball | CollisionLayer::Type::Projectile | CollisionLayer::Type::Wall | CollisionLayer::LifeBuoy);
+			}
+		}
+        
         //Removes bricks that falls out of the stage.
 		if (transform->Position.y < -10) {
 			if (brick->Type == StandardBrick) {
@@ -307,12 +357,23 @@ void dd::Systems::LevelSystem::UpdateEntity(double dt, EntityID entity, EntityID
 			}
 			m_LooseBricks--;
 			m_World->RemoveEntity(entity);
+			return;
         }
     }
 
     auto ball = m_World->GetComponent<Components::Ball>(entity);
 
-    if (NumberOfBricks() <= 0 && m_LooseBricks <= 0 && !Restarting()) {
+	if (ball != nullptr) {
+		if (m_BrickGenerating && !m_BreakAllBricks) {
+			auto transform = m_World->GetComponent<Components::Transform>(entity);
+			if (transform->Position.y < 0 && transform->Velocity.y < 0) {
+				m_BrickGenerating = false;
+				BrickGenerating(m_BrickGeneratingEvent);
+			}
+		}
+	}
+
+    if (NumberOfBricks() <= 0 && m_LooseBricks <= 0 && !Restarting() && !m_Cleared) {
         if (MultiBalls() <= 0 && PowerUps() <= 0) {
             Events::StageCleared ec;
             ec.ClearedStage = m_CurrentLevel;
@@ -434,14 +495,17 @@ EntityID dd::Systems::LevelSystem::CreateBrick(int row, int line, glm::vec2 spac
 		auto type = m_World->AddComponent<Components::StickyBrick>(brick);
 		model->ModelFile = "Models/Brick/StickyBrick.obj";
 	} else if (typeInt == InkBlasterBrick) {
-		cBrick->Type = InkBlasterBrick;
+		cBrick->Type = InkBlasterBrick; 
 		auto type = m_World->AddComponent<Components::InkBlasterBrick>(brick);
-		model->Color = glm::vec4(0.1f, 0.1f, 0.1f, 1.0f);
+		model->ModelFile = "Models/Brick/InkBrick.obj";
+		model->Color = glm::vec4(0.7f, 0.7f, 0.7f, 1.f);
 	} else if (typeInt == KrakenAttackBrick) {
 		cBrick->Type = KrakenAttackBrick;
 		auto type = m_World->AddComponent<Components::KrakenAttackBrick>(brick);
-		model->Color = glm::vec4(0.f, 0.5f, 1.0f, 1.0f);
+		model->ModelFile = "Models/Brick/KrakenBrick.obj";
+
 	} else if (typeInt == Kraken) {
+		m_KrakenBattle = true;
 		Events::KrakenAppear e;
 		e.Position = transform->Position;
 		e.Health = 10;
@@ -456,26 +520,45 @@ EntityID dd::Systems::LevelSystem::CreateBrick(int row, int line, glm::vec2 spac
 
 bool dd::Systems::LevelSystem::OnBrickGenerating(const dd::Events::BrickGenerating &event)
 {
-	GetBrickSet(event.Set);
-	LOG_DEBUG("This is happening.");
+	m_BreakAllBricks = true;
+	m_BrickGenerating = true;
+	m_BrickGeneratingEvent = event;
+	return true;
+}
 
-	int rows = 2;
+bool dd::Systems::LevelSystem::BrickGenerating(const dd::Events::BrickGenerating &event)
+{
+	GetBrickSet(event.Set, event.SetCluster);
+
+	int rows = 6;
 	int lines = 7;
 	int getter = 0;
 	for (int i = 0; i < rows; i++) {
 		for (int j = 0; j < lines; j++) {
-			auto ent = CreateBrick(i, j, SpaceBetweenBricks(), SpaceToEdge(), -4, 1, m_BrickSet[getter], m_ColorSet[getter]);
-			if (ent != NULL) {
-				auto transform = m_World->GetComponent<Components::Transform>(ent);
-				Events::Move e;
-				e.GoalPosition = transform->Position;
-				transform->Position = event.Origin;
-				e.Entity = ent;
-				e.Speed = 6;
-				e.Queue = false;
-				EventBroker->Publish(e);
-				m_LooseBricks++;
-				SetNumberOfBricks(NumberOfBricks() + 1);
+			if (!m_KrakenBricks[getter]) {
+				auto ent = CreateBrick(i, j, SpaceBetweenBricks(), SpaceToEdge(), -3.2, 1, m_BrickSet[getter], m_ColorSet[getter]);
+				if (ent != NULL) {
+					auto brick = m_World->GetComponent<Components::Brick>(ent);
+					brick->BeingGenerated = true;
+					m_World->RemoveComponent<Components::Physics>(ent);
+					brick->Number = getter;
+					m_KrakenBricks[getter] = true;
+					auto transform = m_World->GetComponent<Components::Transform>(ent);
+					Events::Move e;
+					e.GoalPosition = transform->Position;
+					if (j < 4) {
+						transform->Position = event.Origin1;
+					} else {
+						transform->Position = event.Origin2;
+					}
+					brick->GenerationGoal = e.GoalPosition;
+					e.Entity = ent;
+					e.Speed = event.Speed;
+					e.Queue = false;
+					EventBroker->Publish(e);
+					m_LooseBricks++;
+					SetNumberOfBricks(NumberOfBricks() + 1);
+				}
 			}
 			getter++;
 		}
@@ -483,10 +566,16 @@ bool dd::Systems::LevelSystem::OnBrickGenerating(const dd::Events::BrickGenerati
 	return true;
 }
 
-void dd::Systems::LevelSystem::GetBrickSet(int set)
+bool dd::Systems::LevelSystem::OnBreakAllBricks(const dd::Events::BreakAllBricks &event)
 {
-	std::array<int, 14> level;
-	std::array<glm::vec4, 14> color;
+	m_BreakAllBricks = true;
+	return true;
+}
+
+void dd::Systems::LevelSystem::GetBrickSet(int set, int setCluster) // These are sets the Kraken gets!
+{
+	std::array<int, 42> level;
+	std::array<glm::vec4, 42> color;
 	// Level array indicates type of brick.
 	// 0 is empty space.
 	// 1 is standard brick.
@@ -515,53 +604,282 @@ void dd::Systems::LevelSystem::GetBrickSet(int set)
 	glm::vec4 m = glm::vec4(1, 0, 1, 1);
 	glm::vec4 d = glm::vec4(0, 0, 0, 1);
 
-	if (set == 1) {
-		level =
-		{1, 1, 1, 1, 1, 1, 1,
-		 1, 1, 1, 1, 1, 1, 1 };
-		color =
-		{r, r, r, r, r, r, r,
-		 r, r, r, r, r, r, r };
-	}
-	else if (set == 2) {
-		level =
-		{2, 2, 2, 2, 2, 2, 2,
-		 2, 2, 2, 2, 2, 2, 2 };
-		color =
-		{w, w, w, w, w, w, w,
-		 w, w, w, w, w, w, w };
-	}
-	else if (set == 3) {
-		level =
-		{0, 0, 0, 0, 0, 0, 0,
-		 0, 0, 0, 0, 0, 0, 0 };
-		color =
-		{w, w, w, w, w, w, w,
-		 w, w, w, w, w, w, w };
-	}
-	else if (set == 4) {
-		level =
-		{0, 0, 0, 0, 0, 0, 0,
-		 0, 0, 0, 0, 0, 0, 0 };
-		color =
-		{w, w, w, w, w, w, w,
-		 w, w, w, w, w, w, w };
-	}
-	else if (set == 5) {
-		level =
-		{0, 0, 0, 0, 0, 0, 0,
-		 0, 0, 0, 0, 0, 0, 0 };
-		color =
-		{w, w, w, w, w, w, w,
-		 w, w, w, w, w, w, w };
-	}
-	else if (set == 6) {
-		level =
-		{0, 0, 0, 1, 0, 0, 0,
-		 0, 0, 0, 0, 0, 0, 0 };
-		color =
-		{w, w, w, w, w, w, w,
-		 w, w, w, w, w, w, w };
+	if (setCluster == 0) {
+		if (set == 1) {
+			level = // The Charge
+			{1, 0, 0, 0, 0, 0, 1,
+			 0, 1, 0, 0, 0, 1, 0,
+			 0, 0, 1, 0, 1, 0, 0,
+			 0, 0, 0, 1, 0, 0, 0,
+			 0, 0, 0, 0, 0, 0, 0,
+			 0, 0, 0, 0, 0, 0, 0 };
+			color =
+			{r, r, r, r, r, r, r,
+			 r, r, r, r, r, r, r,
+			 r, r, r, r, r, r, r,
+			 r, r, r, r, r, r, r,
+			 r, r, r, r, r, r, r,
+			 r, r, r, r, r, r, r };
+		} else if (set == 2) {
+			level = // The Audience
+			{0, 0, 0, 0, 0, 0, 0,
+			 4, 0, 0, 0, 0, 0, 1,
+			 1, 0, 0, 0, 0, 0, 1,
+			 1, 0, 0, 0, 0, 0, 1,
+			 1, 0, 0, 0, 0, 0, 6,
+			 0, 0, 0, 0, 0, 0, 0 };
+			color =
+			{y, y, y, y, y, y, y,
+			 y, y, y, y, y, y, y,
+			 y, y, y, y, y, y, y,
+			 y, y, y, y, y, y, y,
+			 y, y, y, y, y, y, y,
+			 y, y, y, y, y, y, y };
+		} else if (set == 3) {
+			level = // The Alien Defense
+			{0, 0, 0, 0, 0, 0, 0,
+			 0, 0, 0, 0, 0, 0, 0,
+			 0, 0, 0, 0, 0, 0, 0,
+			 0, 3, 0, 0, 0, 1, 0,
+			 1, 1, 6, 0, 1, 1, 1,
+			 0, 0, 0, 0, 0, 0, 0 };
+			color =
+			{b, b, b, b, b, b, b,
+			 b, b, b, b, b, b, b,
+			 b, b, b, b, b, b, b,
+			 b, b, b, b, b, b, b,
+			 b, b, b, b, b, b, b,
+			 b, b, b, b, b, b, b };
+		} else if (set == 4) {
+			level = // The Scales (right)
+			{1, 1, 1, 0, 0, 0, 0,
+			 1, 1, 6, 0, 0, 0, 0,
+			 0, 0, 0, 0, 0, 0, 0,
+			 0, 0, 0, 0, 0, 0, 0,
+			 0, 0, 0, 0, 1, 1, 1,
+			 0, 0, 0, 0, 1, 4, 1 };
+			color =
+			{m, m, m, m, m, m, m,
+			 m, m, m, m, m, m, m,
+			 m, m, m, m, m, m, m,
+			 m, m, m, m, m, m, m,
+			 m, m, m, m, m, m, m,
+			 m, m, m, m, m, m, m };
+		} else if (set == 5) {
+			level = // The Scales (left)
+			{0, 0, 0, 0, 1, 1, 1,
+			 0, 0, 0, 0, 1, 3, 1,
+			 0, 0, 0, 0, 0, 0, 0,
+			 0, 0, 0, 0, 0, 0, 0,
+			 1, 1, 1, 0, 0, 0, 0,
+			 1, 6, 1, 0, 0, 0, 0 };
+			color =
+			{g, g, g, g, g, g, g,
+			 g, g, g, g, g, g, g,
+			 g, g, g, g, g, g, g,
+			 g, g, g, g, g, g, g,
+			 g, g, g, g, g, g, g,
+			 g, g, g, g, g, g, g };
+		} else if (set == 6) {
+			level = // The Sword
+			{0, 0, 0, 1, 0, 0, 0,
+			 0, 0, 6, 2, 6, 0, 0,
+			 0, 0, 0, 1, 0, 0, 0,
+			 0, 0, 0, 1, 0, 0, 0,
+			 0, 0, 0, 1, 0, 0, 0,
+			 0, 0, 0, 1, 0, 0, 0 };
+			color =
+			{c, c, c, c, c, c, c,
+			 c, c, c, c, c, c, c,
+			 c, c, c, c, c, c, c,
+			 c, c, c, c, c, c, c,
+			 c, c, c, c, c, c, c,
+			 c, c, c, c, c, c, c };
+		}
+	} else if (setCluster == 1) {
+		if (set == 1) {
+			level = // The Wall
+			{1, 0, 0, 0, 0, 0, 1,
+			 1, 0, 0, 0, 0, 0, 1,
+			 6, 0, 0, 0, 0, 0, 6,
+			 1, 1, 1, 1, 1, 1, 1,
+			 1, 1, 1, 1, 1, 1, 1,
+			 0, 0, 0, 0, 0, 0, 0 };
+			color =
+			{r, r, r, r, r, r, r,
+			 r, r, r, r, r, r, r,
+			 r, r, r, r, r, r, r,
+			 r, r, r, r, r, r, r,
+			 r, r, r, r, r, r, r,
+			 r, r, r, r, r, r, r };
+		} else if (set == 2) {
+			level = // The Checkerboard
+			{0, 0, 0, 0, 0, 0, 0,
+			 0, 0, 0, 0, 0, 0, 0,
+			 3, 0, 1, 0, 6, 0, 1,
+			 0, 1, 0, 1, 0, 1, 0,
+			 1, 0, 1, 0, 1, 0, 1,
+			 0, 0, 0, 0, 0, 0, 0 };
+			color =
+			{y, y, y, y, y, y, y,
+			 y, y, y, y, y, y, y,
+			 y, y, y, y, y, y, y,
+			 y, y, y, y, y, y, y,
+			 y, y, y, y, y, y, y,
+			 y, y, y, y, y, y, y };
+		} else if (set == 3) {
+			level = // The Fighter Jet
+			{0, 0, 0, 0, 0, 0, 0,
+			 0, 0, 0, 0, 0, 0, 0,
+			 6, 0, 1, 0, 1, 0, 6,
+			 0, 1, 1, 1, 1, 1, 0,
+			 0, 0, 4, 1, 1, 0, 0,
+			 0, 0, 0, 1, 0, 0, 0 };
+			color =
+			{b, b, b, b, b, b, b,
+			 b, b, b, b, b, b, b,
+			 b, b, b, b, b, b, b,
+			 b, b, b, b, b, b, b,
+			 b, b, b, b, b, b, b,
+			 b, b, b, b, b, b, b };
+		} else if (set == 4) {
+			level = // The Formation
+			{0, 0, 0, 0, 0, 0, 0,
+			 1, 1, 4, 1, 1, 3, 1,
+			 0, 0, 0, 0, 0, 0, 0,
+			 1, 1, 6, 1, 1, 1, 1,
+			 0, 0, 0, 0, 0, 0, 0,
+			 0, 0, 0, 0, 0, 0, 0 };
+			color = 
+			{m, m, m, m, m, m, m,
+			 m, m, m, m, m, m, m,
+			 m, m, m, m, m, m, m,
+			 m, m, m, m, m, m, m,
+			 m, m, m, m, m, m, m,
+			 m, m, m, m, m, m, m };
+		} else if (set == 5) {
+			level = // The Pillars
+			{0, 0, 0, 0, 0, 0, 0,
+			 0, 1, 1, 0, 1, 1, 0,
+			 0, 6, 1, 0, 1, 6, 0,
+			 0, 1, 1, 0, 1, 1, 0,
+			 0, 1, 3, 0, 3, 1, 0,
+			 0, 0, 0, 0, 0, 0, 0 };
+			color =
+			{g, g, g, g, g, g, g,
+			 g, g, g, g, g, g, g,
+			 g, g, g, g, g, g, g,
+			 g, g, g, g, g, g, g,
+			 g, g, g, g, g, g, g,
+			 g, g, g, g, g, g, g };
+		} else if (set == 6) {
+			level = // The Treasure Chest
+			{0, 0, 0, 1, 0, 0, 0,
+			 0, 0, 1, 1, 1, 0, 0,
+			 0, 1, 1, 2, 1, 1, 0,
+			 0, 0, 1, 6, 1, 0, 0,
+			 0, 0, 0, 1, 0, 0, 0,
+			 0, 0, 0, 0, 0, 0, 0 };
+			color =
+			{c, c, c, c, c, c, c,
+			 c, c, c, c, c, c, c,
+			 c, c, c, c, c, c, c,
+			 c, c, c, c, c, c, c,
+			 c, c, c, c, c, c, c,
+			 c, c, c, c, c, c, c };
+		}
+	} else if (setCluster == 2) {
+		if (set == 1) {
+			level = // The Butterfly
+			{4, 0, 0, 1, 0, 0, 1,
+			 1, 6, 0, 1, 0, 1, 1,
+			 1, 1, 1, 6, 1, 1, 1,
+			 1, 1, 0, 1, 0, 1, 1, 
+			 1, 0, 0, 1, 0, 0, 1,
+			 1, 0, 0, 1, 0, 0, 3 };
+			color =
+			{r, r, r, r, r, r, r,
+			 r, r, r, r, r, r, r,
+			 r, r, r, r, r, r, r,
+			 r, r, r, r, r, r, r,
+			 r, r, r, r, r, r, r,
+			 r, r, r, r, r, r, r };
+		} else if (set == 2) {
+			level = // The Cross
+			{1, 1, 0, 0, 0, 1, 1,
+			 0, 4, 1, 0, 1, 6, 0,
+			 0, 0, 1, 1, 1, 0, 0,
+			 0, 0, 1, 3, 1, 0, 0,
+			 0, 1, 1, 0, 1, 1, 0,
+			 1, 1, 0, 0, 0, 1, 1 };
+			color =
+			{y, y, y, y, y, y, y,
+			 y, y, y, y, y, y, y,
+			 y, y, y, y, y, y, y,
+			 y, y, y, y, y, y, y,
+			 y, y, y, y, y, y, y,
+			 y, y, y, y, y, y, y };
+		} else if (set == 3) {
+			level = // The Inverted Cross
+			{0, 0, 1, 1, 1, 0, 0,
+			 1, 0, 0, 6, 0, 0, 1,
+			 4, 1, 0, 0, 0, 1, 3,
+			 1, 1, 0, 0, 0, 1, 1,
+			 1, 0, 0, 6, 0, 0, 1,
+			 0, 0, 1, 1, 1, 0, 0 };
+			color =
+			{b, b, b, b, b, b, b,
+			 b, b, b, b, b, b, b,
+			 b, b, b, b, b, b, b,
+			 b, b, b, b, b, b, b,
+			 b, b, b, b, b, b, b,
+			 b, b, b, b, b, b, b };
+		} else if (set == 4) {
+			level = // The Great Wall
+			{1, 1, 1, 1, 1, 1, 1,
+			 1, 1, 6, 1, 1, 1, 1,
+			 0, 0, 0, 0, 0, 0, 0,
+			 1, 6, 1, 1, 1, 1, 1,
+			 0, 0, 0, 0, 0, 0, 0,
+			 1, 3, 1, 1, 1, 1, 1 };
+			color =
+			{m, m, m, m, m, m, m,
+			 m, m, m, m, m, m, m,
+			 m, m, m, m, m, m, m,
+			 m, m, m, m, m, m, m,
+			 m, m, m, m, m, m, m,
+			 m, m, m, m, m, m, m };
+		} else if (set == 5) {
+			level = // The Champion
+			{0, 0, 1, 1, 1, 0, 0,
+			 0, 0, 1, 1, 1, 0, 0,
+			 0, 0, 1, 1, 1, 0, 0,
+			 1, 1, 1, 0, 1, 1, 1,
+			 3, 6, 1, 0, 1, 6, 1,
+			 1, 1, 1, 0, 1, 1, 1 };
+			color =
+			{g, g, g, g, g, g, g,
+			 g, g, g, g, g, g, g,
+			 g, g, g, g, g, g, g,
+			 g, g, g, g, g, g, g,
+			 g, g, g, g, g, g, g,
+			 g, g, g, g, g, g, g };
+		} else if (set == 6) {
+			level = // The Dog. What, you can't see it? XD
+			{0, 1, 1, 6, 1, 1, 0,
+			 1, 1, 4, 5, 4, 1, 1,
+			 1, 1, 1, 1, 1, 1, 1,
+			 6, 0, 1, 1, 1, 0, 6,
+			 1, 0, 1, 1, 1, 0, 1,
+			 0, 0, 0, 3, 0, 0, 0 };
+			color =
+			{c, c, c, c, c, c, c,
+			 c, c, c, c, c, c, c,
+			 c, c, c, c, c, c, c,
+			 c, c, c, c, c, c, c,
+			 c, c, c, c, c, c, c,
+			 c, c, c, c, c, c, c };
+		}
 	}
 
 	std::copy(std::begin(level), std::end(level), std::begin(m_BrickSet));
@@ -576,6 +894,11 @@ void dd::Systems::LevelSystem::OnEntityRemoved(EntityID entity)
 
 bool dd::Systems::LevelSystem::OnContact(const dd::Events::Contact &event)
 {
+	auto templateCheck = m_World->GetComponent<Components::Template>(event.Entity1);
+	if (templateCheck != nullptr){ return false; }
+	templateCheck = m_World->GetComponent<Components::Template>(event.Entity2);
+	if (templateCheck != nullptr){ return false; }
+
     EntityID entityBrick;
     EntityID entityBall;
 	EntityID entityShot = 0;
@@ -615,13 +938,17 @@ bool dd::Systems::LevelSystem::OnContact(const dd::Events::Contact &event)
     brick = m_World->GetComponent<Components::Brick>(entityBrick);
     if (brick == nullptr) {
         return false;
-    }
+	}
+
+	if (brick->BeingGenerated) {
+		return false;
+	}
 
 	if (entityShot != 0) {
 		// For when a brick gets shot.
 		brick->Removed = true;
 		m_World->RemoveEntity(entityShot);
-		BrickHit(entityShot, entityBrick, 1);
+		BrickHit(entityShot, entityBrick, 1, true);
 		//ep.Radius = 0.05;
 
 		return true;
@@ -637,13 +964,13 @@ bool dd::Systems::LevelSystem::OnContact(const dd::Events::Contact &event)
 		ec.Ball = entityBall;
 		EventBroker->Publish(ec);
 
-		BrickHit(entityBall, entityBrick, ball->Combo);
+		BrickHit(entityBall, entityBrick, ball->Combo, true);
     }
 
     return true;
 }
 
-void dd::Systems::LevelSystem::BrickHit(EntityID entityHitter, EntityID entityBrick, int combo)
+void dd::Systems::LevelSystem::BrickHit(EntityID entityHitter, EntityID entityBrick, int combo, bool activatePowerUps)
 {
 	auto brick = m_World->GetComponent<Components::Brick>(entityBrick);
 	auto physicsComponent = m_World->GetComponent<Components::Physics>(entityBrick);
@@ -653,52 +980,56 @@ void dd::Systems::LevelSystem::BrickHit(EntityID entityHitter, EntityID entityBr
 
 	auto transformComponentBrick = m_World->GetComponent<Components::Transform>(entityBrick);
 	auto transformComponentHitter = m_World->GetComponent<Components::Transform>(entityHitter);
-		
-
 	auto brickModel = m_World->GetComponent<Components::Model>(entityBrick);
 
-	// Check if the brick is any kind of special.
-	auto multi = m_World->GetComponent<Components::MultiBallBrick>(entityBrick);
-	if (multi != nullptr) {
-		Events::MultiBall e;
-		e.padTransform = transformComponentBrick;
-		EventBroker->Publish(e);
+	if (brick->Number < 50) {
+		m_KrakenBricks[brick->Number] = false;
 	}
-	else {
-		auto buoy = m_World->GetComponent<Components::LifebuoyBrick>(entityBrick);
-		if (buoy != nullptr) {
-			Events::Lifebuoy e;
-			e.Transform = transformComponentBrick;
+
+	// Check if the brick is any kind of special.
+	if (activatePowerUps) {
+		auto multi = m_World->GetComponent<Components::MultiBallBrick>(entityBrick);
+		if (multi != nullptr) {
+			Events::MultiBall e;
+			e.padTransform = transformComponentBrick;
 			EventBroker->Publish(e);
 		}
 		else {
-			auto sticky = m_World->GetComponent<Components::StickyBrick>(entityBrick);
-			if (sticky != nullptr) {
-				Events::StickyPad e;
+			auto buoy = m_World->GetComponent<Components::LifebuoyBrick>(entityBrick);
+			if (buoy != nullptr) {
+				Events::Lifebuoy e;
 				e.Transform = transformComponentBrick;
-				e.Times = 3;
 				EventBroker->Publish(e);
 			}
 			else {
-				auto ink = m_World->GetComponent<Components::InkBlasterBrick>(entityBrick);
-				if (ink != nullptr) {
-					Events::InkBlaster e;
+				auto sticky = m_World->GetComponent<Components::StickyBrick>(entityBrick);
+				if (sticky != nullptr) {
+					Events::StickyPad e;
 					e.Transform = transformComponentBrick;
-					e.Shots = 5;
-					e.Speed = 7;
+					e.Times = 3;
 					EventBroker->Publish(e);
 				}
 				else {
-					auto kraken = m_World->GetComponent<Components::KrakenAttackBrick>(entityBrick);
-					if (kraken != nullptr) {
-						Events::KrakenAttack e;
-						e.ChargeUpdate = 0;
-						e.KrakenStrength = 0.1;
-						e.PlayerStrength = 0.05;
+					auto ink = m_World->GetComponent<Components::InkBlasterBrick>(entityBrick);
+					if (ink != nullptr) {
+						Events::InkBlaster e;
+						e.Transform = transformComponentBrick;
+						e.Shots = 5;
+						e.Speed = 7;
 						EventBroker->Publish(e);
 					}
 					else {
+						auto kraken = m_World->GetComponent<Components::KrakenAttackBrick>(entityBrick);
+						if (kraken != nullptr) {
+							Events::KrakenAttack e;
+							e.ChargeUpdate = 0;
+							e.KrakenStrength = 0.1;
+							e.PlayerStrength = 0.05;
+							EventBroker->Publish(e);
+						}
+						else {
 
+						}
 					}
 				}
 			}
@@ -835,10 +1166,17 @@ bool dd::Systems::LevelSystem::OnPowerUpTaken(const dd::Events::PowerUpTaken &ev
 
 bool dd::Systems::LevelSystem::OnKrakenDefeated(const dd::Events::KrakenDefeated &event)
 {
+	m_KrakenBattle = false;
+	m_BrickGenerating = false;
+	m_BreakAllBricks = true;
 	SetNumberOfBricks(NumberOfBricks() - 1);
 	m_LooseBricks--;
 
-	std::cout << m_LooseBricks << std::endl;
+	Events::ScoreEvent e;
+	e.Score = 1000;
+	EventBroker->Publish(e);
+
+	//std::cout << m_LooseBricks << std::endl;
 
 	return true;
 }
@@ -846,6 +1184,7 @@ bool dd::Systems::LevelSystem::OnKrakenDefeated(const dd::Events::KrakenDefeated
 bool dd::Systems::LevelSystem::OnStageCleared(const dd::Events::StageCleared &event)
 {
     if (!m_Cleared) {
+		m_BreakAllBricks = false;
         m_Cleared = true;
         SetRestarting(true);
         Events::ResetBall e;
@@ -924,7 +1263,6 @@ void dd::Systems::LevelSystem::GetNextLevel()
 	glm::vec4 p3 = glm::vec4(189.f / 255.f, 0.f / 255.f, 187.f / 255.f, 1.f);
 	glm::vec4 p4 = glm::vec4(125.f / 255.f, 0.f / 255.f, 147.f / 255.f, 1.f);
 
-
     if (m_CurrentCluster == 0) {
         if (m_CurrentLevel == 1) {
             level =
@@ -945,10 +1283,10 @@ void dd::Systems::LevelSystem::GetNextLevel()
             level =
                     {0, 0, 0, 0, 0, 0, 0,
                      0, 0, 0, 0, 0, 0, 0,
-                     0, 0, 0, 100, 0, 0, 0,
                      0, 0, 0, 0, 0, 0, 0,
                      0, 0, 0, 0, 0, 0, 0,
-                     0, 0, 0, 0, 0, 0, 0};
+                     0, 0, 0, 0, 0, 0, 0,
+                     0, 0, 0, 100, 0, 0, 0};
 			color = 
 					{w, w, w, w, w, w, w,
 					 w, w, w, w, w, w, w,
@@ -1097,11 +1435,11 @@ void dd::Systems::LevelSystem::GetNextLevel()
 		else if (m_CurrentLevel == 6) {
 					level =
 					{0, 0, 0, 0, 0, 0, 0,
-					 0, 0, 0, 100, 0, 0, 0,
 					 0, 0, 0, 0, 0, 0, 0,
 					 0, 0, 0, 0, 0, 0, 0,
 					 0, 0, 0, 0, 0, 0, 0,
-					 0, 0, 0, 0, 0, 0, 0};
+					 0, 0, 0, 0, 0, 0, 0,
+					 0, 0, 0, 100, 0, 0, 0 };
 					color =
 					{w, w, w, w, w, w, w,
 					 w, w, w, w, w, w, w,
@@ -1129,39 +1467,45 @@ void dd::Systems::LevelSystem::SetBrokenModel(EntityID entity)
 	std::uniform_int_distribution<int> dist(0, 2);
 	int index = dist(m_RandomGenerator);
 
+	int parts = 0;
+
 	switch (index)
 	{
 	case 0:
-		CreateBrokenModelPart(entity, "Models/Brick/BrickBreak/1/WhiteBrickBreak1.obj", glm::vec3(-0.29912f, 0.0082f, 0.f), glm::vec2(0.281f, 0.351f));
-		CreateBrokenModelPart(entity, "Models/Brick/BrickBreak/1/WhiteBrickBreak2.obj", glm::vec3(0.07597f, -0.02899f, 0.f), glm::vec2(0.559f, 0.351f));
-		CreateBrokenModelPart(entity, "Models/Brick/BrickBreak/1/WhiteBrickBreak3.obj", glm::vec3(0.3227f, 0.05632, 0.f), glm::vec2(0.25f, 0.25f));
+		CreateBrokenModelPart(entity, "Models/Brick/BrickBreak/1/WhiteBrickBreak1.obj", glm::vec3(-0.29912f, 0.0082f, 0.f), glm::vec2(0.281f, 0.351f), 3);
+		CreateBrokenModelPart(entity, "Models/Brick/BrickBreak/1/WhiteBrickBreak2.obj", glm::vec3(0.07597f, -0.02899f, 0.f), glm::vec2(0.559f, 0.351f), 3);
+		CreateBrokenModelPart(entity, "Models/Brick/BrickBreak/1/WhiteBrickBreak3.obj", glm::vec3(0.3227f, 0.05632, 0.f), glm::vec2(0.25f, 0.25f), 3);
 		break;
 
 	case 1:
-		CreateBrokenModelPart(entity, "Models/Brick/BrickBreak/2/WhiteBrickBreak1.obj", glm::vec3(-0.3236f, 0.0159f, 0.f), glm::vec2(0.237f, 0.327f));
-		CreateBrokenModelPart(entity, "Models/Brick/BrickBreak/2/WhiteBrickBreak2.obj", glm::vec3(0.07645f, 0.03131f, 0.f), glm::vec2(0.594f, 0.211f));
-		CreateBrokenModelPart(entity, "Models/Brick/BrickBreak/2/WhiteBrickBreak3.obj", glm::vec3(0.09468f, -0.11792f, 0.f), glm::vec2(0.692f, 0.112f));
-		CreateBrokenModelPart(entity, "Models/Brick/BrickBreak/2/WhiteBrickBreak4.obj", glm::vec3(0.33957f, 0.13079f, 0.f), glm::vec2(0.208f, 0.085f));
+		CreateBrokenModelPart(entity, "Models/Brick/BrickBreak/2/WhiteBrickBreak1.obj", glm::vec3(-0.3236f, 0.0159f, 0.f), glm::vec2(0.237f, 0.327f), 4);
+		CreateBrokenModelPart(entity, "Models/Brick/BrickBreak/2/WhiteBrickBreak2.obj", glm::vec3(0.07645f, 0.03131f, 0.f), glm::vec2(0.594f, 0.211f), 4);
+		CreateBrokenModelPart(entity, "Models/Brick/BrickBreak/2/WhiteBrickBreak3.obj", glm::vec3(0.09468f, -0.11792f, 0.f), glm::vec2(0.692f, 0.112f), 4);
+		CreateBrokenModelPart(entity, "Models/Brick/BrickBreak/2/WhiteBrickBreak4.obj", glm::vec3(0.33957f, 0.13079f, 0.f), glm::vec2(0.208f, 0.085f), 4);
 		break;
 
 	case 2:
-		CreateBrokenModelPart(entity, "Models/Brick/BrickBreak/3/WhiteBrickBreak1.obj", glm::vec3(-0.34882f, 0.0564f, 0.f), glm::vec2(0.175f, 0.228f));
-		CreateBrokenModelPart(entity, "Models/Brick/BrickBreak/3/WhiteBrickBreak2.obj", glm::vec3(0.0678f, 0.07679f, 0.f), glm::vec2(0.699f, 0.183f));
-		CreateBrokenModelPart(entity, "Models/Brick/BrickBreak/3/WhiteBrickBreak3.obj", glm::vec3(-0.11862f, -0.10342, 0.f), glm::vec2(0.563f, 0.164f));
-		CreateBrokenModelPart(entity, "Models/Brick/BrickBreak/3/WhiteBrickBreak4.obj", glm::vec3(0.31479f, -0.06351f, 0.f), glm::vec2(0.261f, 0.21f));
+		CreateBrokenModelPart(entity, "Models/Brick/BrickBreak/3/WhiteBrickBreak1.obj", glm::vec3(-0.34882f, 0.0564f, 0.f), glm::vec2(0.175f, 0.228f), 4);
+		CreateBrokenModelPart(entity, "Models/Brick/BrickBreak/3/WhiteBrickBreak2.obj", glm::vec3(0.0678f, 0.07679f, 0.f), glm::vec2(0.699f, 0.183f), 4);
+		CreateBrokenModelPart(entity, "Models/Brick/BrickBreak/3/WhiteBrickBreak3.obj", glm::vec3(-0.11862f, -0.10342, 0.f), glm::vec2(0.563f, 0.164f), 4);
+		CreateBrokenModelPart(entity, "Models/Brick/BrickBreak/3/WhiteBrickBreak4.obj", glm::vec3(0.31479f, -0.06351f, 0.f), glm::vec2(0.261f, 0.21f), 4);
 		break;
 
 	default:
 		LOG_INFO("Something went wrong with the random generator in SetBrokenModel");
 		break;
 	}
+
+	return;
 }
 
-void dd::Systems::LevelSystem::CreateBrokenModelPart(EntityID Parent, std::string ModelPath, glm::vec3 RelativePosition, glm::vec2 Hitbox)
+void dd::Systems::LevelSystem::CreateBrokenModelPart(EntityID Parent, std::string ModelPath, glm::vec3 RelativePosition, glm::vec2 Hitbox, int NumberOfParts)
 {
 	auto ent = m_World->CreateEntity(Parent);
 	auto cTemplate = m_World->AddComponent<Components::Template>(ent);
 	auto cTransform = m_World->AddComponent<Components::Transform>(ent);
+	auto cBrickPart = m_World->AddComponent<Components::BrickPart>(ent);
+	cBrickPart->NumberOfPartsInBrick = NumberOfParts;
 
 	cTransform->Position = RelativePosition;
 
@@ -1174,6 +1518,7 @@ void dd::Systems::LevelSystem::CreateBrokenModelPart(EntityID Parent, std::strin
 	auto cPhys = m_World->AddComponent<Components::Physics>(ent);
 	cPhys->CollisionType = CollisionType::Type::Dynamic;
 	cPhys->GravityScale = 1.f;
+	cPhys->Density = 30;
 	cPhys->Category = CollisionLayer::Type::Brick;
 	cPhys->Mask = static_cast<CollisionLayer::Type>(CollisionLayer::Type::Wall);
 }

src/game/Game/LifeSystem.cpp

@@ -0,0 +1,192 @@
+//
+// Created by Adniklastrator on 2015-10-13.
+//
+
+#include "PrecompiledHeader.h"
+#include "Game/LifeSystem.h"
+
+void dd::Systems::LifeSystem::Initialize()
+{
+	EVENT_SUBSCRIBE_MEMBER(m_EPause, &LifeSystem::OnPause);
+	EVENT_SUBSCRIBE_MEMBER(m_EResume, &LifeSystem::OnResume);
+	EVENT_SUBSCRIBE_MEMBER(m_ELifeLost, &LifeSystem::OnLifeLost);
+
+	for (int i = 0; i < Lives(); i++) {
+		CreateLife(i);
+	}
+
+	m_GodMode = ResourceManager::Load<ConfigFile>("Config.ini")->GetValue<bool>("Cheat.GodMode", false);
+}
+
+void dd::Systems::LifeSystem::Update(double dt)
+{
+	if (m_Pause) {
+		return;
+	}
+	if (Lives() < 0) {
+		Events::KrakenAttackEnd ek;
+		EventBroker->Publish(ek);
+
+		Events::GameOver e;
+		EventBroker->Publish(e);
+
+		Events::Pause p;
+		p.Type = "All";
+		EventBroker->Publish(p);
+
+		//TODO: Make this not so ugly
+		SetLives(3);
+	}
+}
+
+void dd::Systems::LifeSystem::UpdateEntity(double dt, EntityID entity, EntityID parent)
+{
+	if (m_Pause) {
+		return;
+	}
+
+	auto templateCheck = m_World->GetComponent<Components::Template>(entity);
+	if (templateCheck != nullptr){ return; }
+	auto life = m_World->GetComponent<Components::Life>(entity);
+
+	
+	if (life != nullptr) {
+		auto transform = m_World->GetComponent<Components::Transform>(entity);
+		if (transform->Position.y < -8) {
+			m_World->RemoveEntity(entity);
+			return;
+		}
+
+		transform->Position.x += transform->Velocity.x * dt;
+		transform->Position.y += transform->Velocity.y * dt;
+		
+		glm::vec2 dir = glm::normalize(glm::vec2(transform->Velocity.x, transform->Velocity.y));
+		glm::vec2 up = glm::vec2(0.f, 1.f);
+		float angle = glm::acos(glm::dot<float>(dir, up)) * glm::sign(dir.x);
+		transform->Orientation = glm::rotate(glm::quat(), angle, glm::vec3(0.f, 0.f, -1.f));
+
+		if (!life->Dead) {
+			if (life->Left) {
+				if (transform->Position.x < -3.8) {
+					life->Left = false;
+					transform->Velocity.x = m_LifeSpeed;
+				}
+			}
+			else {
+				if (transform->Position.x > 3.8) {
+					life->Left = true;
+					transform->Velocity.x = -m_LifeSpeed;
+				}
+			}
+
+			float sin = life->SinusAltitude;
+			life->SinusAltitude += life->SinusSpeed * dt;
+			float y = glm::sin((sin)* glm::half_pi<float>() * life->Frequency) * life->Amplitude;
+			transform->Velocity.y = y;
+
+			if (Lives() != PastLives()) {
+				if (life->Number + 1 == PastLives()) {
+					life->Dead = true;
+					auto model = m_World->GetComponent<Components::Model>(entity);
+					model->Color *= 0.3;
+
+					//Particle trail
+					Events::CreateParticleSequence trail;
+					trail.parent = entity;
+					trail.AlphaValues.push_back(1.f);
+					trail.AlphaValues.push_back(0.f);
+					trail.ScaleValues.push_back(glm::vec3(0.08f));
+					trail.ScaleValues.push_back(glm::vec3(0.f));
+					trail.RadiusDistribution = 1;
+					trail.EmitterLifeTime = 2.f;
+					trail.ParticleLifeTime = 1.f;
+					trail.ParticlesPerTick = 1;
+					trail.SpawnRate = 0.1f;
+					trail.Speed = 10.f;
+					trail.EmittingAngle = glm::half_pi<float>();
+					trail.SpriteFile = "Textures/Particles/FadeBall.png";
+					trail.Color = model->Color;
+					//p.Spread = ...
+					EventBroker->Publish(trail);
+
+					//ParticlePoof
+					Events::CreateParticleSequence poof;
+					poof.EmitterLifeTime = 4;
+					poof.EmittingAngle = glm::half_pi<float>();
+					poof.Spread = 0.5f;
+					poof.NumberOfTicks = 1;
+					poof.ParticleLifeTime = 1.5f;
+					poof.ParticlesPerTick = 1;
+					poof.Position = transform->Position;
+					poof.ScaleValues.clear();
+					poof.ScaleValues.push_back(glm::vec3(0.5f));
+					poof.ScaleValues.push_back(glm::vec3(2.f, 2.f, 0.2f));
+					poof.SpriteFile = "Textures/Particles/Cloud_Particle.png";
+					poof.Color = model->Color;
+					poof.AlphaValues.clear();
+					poof.AlphaValues.push_back(1.f);
+					poof.AlphaValues.push_back(0.f);
+					poof.Speed = 10;
+					EventBroker->Publish(poof);
+
+					//m_World->RemoveEntity(entity);
+					SetPastLives(Lives());
+				}
+			}
+		} else {
+			transform->Velocity.y -= 0.5 * dt;
+		}
+	}
+}
+
+void dd::Systems::LifeSystem::CreateLife(int number)
+{
+	auto life = m_World->CreateEntity();
+	std::shared_ptr<Components::Transform> transform = m_World->AddComponent<Components::Transform>(life);
+	//transform->Position = glm::vec3(-1.5f + number * 0.15f, -2.f, -5.f);
+	transform->Position = glm::vec3(-3.8f + number * 3.7f, -5.2f, -10.f);
+	//transform->Scale = glm::vec3(0.1f, 0.1f, 0.1f);
+	transform->Scale = glm::vec3(0.2f, 0.2f, 0.2f);
+	transform->Velocity.x = m_LifeSpeed;
+
+	std::shared_ptr<Components::Life> cLife = m_World->AddComponent<Components::Life>(life);
+	cLife->Number = number;
+	cLife->SinusAltitude = glm::half_pi<float>() * number;
+	cLife->Amplitude = 0.2;
+	cLife->Frequency = 1;
+	cLife->SinusSpeed = 1;
+
+	auto model = m_World->AddComponent<Components::Model>(life);
+	model->ModelFile = "Models/Sid/Sid.dae";
+
+	auto anim = m_World->AddComponent<Components::Animation>(life);
+	anim->Speed = 0.5f;
+
+	m_World->CommitEntity(life);
+}
+
+bool dd::Systems::LifeSystem::OnLifeLost(const dd::Events::LifeLost &event)
+{
+	if (!m_GodMode){
+		SetLives(Lives() - 1);
+		return true;
+	}
+	return true;
+}
+
+bool dd::Systems::LifeSystem::OnPause(const dd::Events::Pause &event)
+{
+	/*if (event.Type != "LifeSystem" && event.Type != "All") {
+		return false;
+	}*/
+	m_Pause = true;
+    return true;
+}
+bool dd::Systems::LifeSystem::OnResume(const dd::Events::Resume &event)
+{
+	/*if (event.Type != "LifeSystem" && event.Type != "All") {
+	return false;
+	}*/
+	m_Pause = false;
+	return true;
+}

src/game/Game/LifebuoySystem.cpp

@@ -76,6 +76,19 @@ void dd::Systems::LifebuoySystem::Update(double dt)
 			++it;
 		}
 	}
+
+	if (IsPaused()) {
+		return;
+	}
+	
+	if (m_Lifebuoy) {
+		m_Timer += dt;
+		if (m_Timer > m_WaitingTime) {
+			m_Timer = 0;
+			m_Lifebuoy = false;
+			Lifebuoy(m_SavedEvent);
+		}
+	}
 }
 
 void dd::Systems::LifebuoySystem::UpdateEntity(double dt, EntityID entity, EntityID parent)
@@ -113,7 +126,14 @@ bool dd::Systems::LifebuoySystem::OnContact(const dd::Events::Contact &event)
     return true;
 }
 
-bool dd::Systems::LifebuoySystem::OnLifebuoy(const dd::Events::Lifebuoy &event) 
+bool dd::Systems::LifebuoySystem::OnLifebuoy(const dd::Events::Lifebuoy &event)
+{
+	m_Lifebuoy = true;
+	m_SavedEvent = event;
+	return true;
+}
+
+bool dd::Systems::LifebuoySystem::Lifebuoy(const dd::Events::Lifebuoy &event) 
 {
 	auto ent = m_World->CloneEntity(m_Template);
 	m_World->SetProperty(ent, "Name", "Lifebuoy");
@@ -121,7 +141,8 @@ bool dd::Systems::LifebuoySystem::OnLifebuoy(const dd::Events::Lifebuoy &event)
 	auto transform = m_World->GetComponent<Components::Transform>(ent);
 	auto physics = m_World->GetComponent<Components::Physics>(ent);
 	physics->CollisionType = CollisionType::Type::Dynamic;
-	transform->Position = glm::vec3(0.f, 0.f, -10.f);
+	//transform->Position = glm::vec3(0.f, 0.f, -10.f);
+	transform->Position = event.Transform->Position;
 	transform->Velocity = glm::vec3(20.f, 3.f, 0.f);
 	LifebuoyInfo info;
 	info.Entity = ent;
@@ -143,7 +164,7 @@ bool dd::Systems::LifebuoySystem::OnLifebuoyHit(const dd::Events::LifebuoyHit &e
 	e.EmittingAngle = glm::half_pi<float>();
 	e.Spread = 0.5f;
 	e.NumberOfTicks = 1;
-	e.ParticleLifeTime = 1.f;
+	e.ParticleLifeTime = 2.f;
 	e.ParticlesPerTick = 1;
 	e.Position = transformComponent->Position;
 	e.ScaleValues.clear();

src/game/Game/PadSystem.cpp

@@ -34,6 +34,7 @@ void dd::Systems::PadSystem::Initialize()
     EVENT_SUBSCRIBE_MEMBER(m_EPause, &PadSystem::OnPause);
 	EVENT_SUBSCRIBE_MEMBER(m_EResume, &PadSystem::OnResume);
 	EVENT_SUBSCRIBE_MEMBER(m_EKrakenAttack, &PadSystem::OnKrakenAttack);
+	EVENT_SUBSCRIBE_MEMBER(m_EKrakenAttackEnd, &PadSystem::OnKrakenAttackEnd);
 	EVENT_SUBSCRIBE_MEMBER(m_EStickyPad, &PadSystem::OnStickyPad);
 	EVENT_SUBSCRIBE_MEMBER(m_EStickyAttachedToPad, &PadSystem::OnStickyAttachedToPad);
 	EVENT_SUBSCRIBE_MEMBER(m_EActionButton, &PadSystem::OnActionButton);
@@ -43,7 +44,7 @@ void dd::Systems::PadSystem::Initialize()
         auto ent = m_World->CreateEntity();
         m_World->SetProperty(ent, "Name", "Pad");
         auto ctransform = m_World->AddComponent<Components::Transform>(ent);
-        ctransform->Position = glm::vec3(0.f, -4.8f, -10.f);
+        ctransform->Position = glm::vec3(0.f, m_PadHeight, -10.f);
         auto rectangleShape = m_World->AddComponent<Components::RectangleShape>(ent);
         rectangleShape->Dimensions = glm::vec2(1.f, 0.1f);
         auto physics = m_World->AddComponent<Components::Physics>(ent);
@@ -57,7 +58,11 @@ void dd::Systems::PadSystem::Initialize()
         auto pad = m_World->AddComponent<Components::Pad>(ent);
         m_World->CommitEntity(ent);
 
-        SetEdge(3.2 - (ctransform->Scale.x / 2));
+        m_Edge = 3.2 - (ctransform->Scale.x / 2);
+		
+		m_PadEntity = ent;
+		m_PadTransform = ctransform.get();
+		m_PadComponent = pad.get();
     }
 
 	//Stick
@@ -76,18 +81,31 @@ void dd::Systems::PadSystem::Initialize()
 		m_StickTransform = transform;
 		m_StickyAim = sticky;
 
-		/*{
-			auto entChild = m_World->CreateEntity(ent);
-			std::shared_ptr<Components::Transform> transform = m_World->AddComponent<Components::Transform>(entChild);
-			transform->Position = glm::vec3(0.f, 12.5f, 0.f);
+			/*{
+		auto entChild = m_World->CreateEntity(ent);
+		std::shared_ptr<Components::Transform> transform = m_World->AddComponent<Components::Transform>(entChild);
+		transform->Position = glm::vec3(0.f, 12.5f, 0.f);
 
-			transform->Scale = glm::vec3(0.1f, 25.f, 0.1f);
-			std::shared_ptr<Components::Sprite> sprite = m_World->AddComponent<Components::Sprite>(entChild);
-			sprite->SpriteFile = "Models/Brick/White.png";
-			sprite->Color = glm::vec4(0.f, 0.5f, 0.f, 0.5f);
+		transform->Scale = glm::vec3(0.1f, 25.f, 0.1f);
+		std::shared_ptr<Components::Sprite> sprite = m_World->AddComponent<Components::Sprite>(entChild);
+		sprite->SpriteFile = "Models/Brick/White.png";
+		sprite->Color = glm::vec4(0.f, 0.5f, 0.f, 0.5f);
 		}*/
 	}
 
+	// Kraken arm
+	{
+		m_KrakenArm = m_World->CreateEntity(m_PadEntity);
+		auto transform = m_World->AddComponent<Components::Transform>(m_KrakenArm);
+		transform->Position = glm::vec3(1.f, -3.0f, 0.f);
+		auto model = m_World->AddComponent<Components::Model>(m_KrakenArm);
+		model->ModelFile = "Models/Kraken/Arm.dae";
+		auto animation = m_World->AddComponent<Components::Animation>(m_KrakenArm);
+		animation->Speed = 0.0f;
+		animation->Loop = false;
+		m_World->CommitEntity(m_KrakenArm);
+	}
+
 	m_ResetBall = true;
 }
 
@@ -109,16 +127,21 @@ void dd::Systems::PadSystem::UpdateEntity(double dt, EntityID entity, EntityID p
 				m_ResetBall = false;
 			}
 			auto ballTransform = m_World->GetComponent<Components::Transform>(entity);
-			ballTransform->Position = Transform()->Position;
+			ballTransform->Position = m_PadTransform->Position;
 			ballTransform->Position += ball->StickyPlacement;
-			glm::vec2 dir = glm::normalize(glm::vec2(ball->SavedSpeed.x, ball->SavedSpeed.y));
-			glm::vec2 up = glm::vec2(0.f, 1.f);
-			float angle = glm::acos(glm::dot<float>(dir, up)) * glm::sign(dir.x);
-			ballTransform->Orientation = glm::rotate(glm::quat(), angle, glm::vec3(0.f, 0.f, -1.f));
-			if (ball->Sticky) {
-				m_StickTransform->Orientation = glm::rotate(glm::quat(), angle, glm::vec3(0.f, 0.f, 1.f));
-				m_StickTransform->Position = ballTransform->Position;
+			if (ball->Loaded) {
+				ballTransform->Orientation = glm::quat();
+			} else {
+				glm::vec2 dir = glm::normalize(glm::vec2(ball->SavedSpeed.x, ball->SavedSpeed.y));
+				glm::vec2 up = glm::vec2(0.f, 1.f);
+				float angle = glm::acos(glm::dot<float>(dir, up)) * glm::sign(dir.x);
+				ballTransform->Orientation = glm::rotate(glm::quat(), angle, glm::vec3(0.f, 0.f, -1.f));
+				if (ball->Sticky) {
+					m_StickTransform->Orientation = glm::rotate(glm::quat(), angle, glm::vec3(0.f, 0.f, 1.f));
+					m_StickTransform->Position = ballTransform->Position;
+				}
 			}
+			
 		}
 		if (!m_StickyAim->Aiming) {
 			m_StickTransform->Position = glm::vec3(30.f, 0.f, 0.f);
@@ -132,17 +155,6 @@ void dd::Systems::PadSystem::Update(double dt)
         return;
     }
 
-    if (Entity() == 0) {
-        for (auto it = m_World->GetEntities()->begin(); it != m_World->GetEntities()->end(); it++) {
-            if (m_World->GetProperty<std::string>(it->first, "Name") == "Pad") {
-                SetEntity(it->first);
-                SetTransform(m_World->GetComponent<Components::Transform>(Entity()));
-                SetPad(m_World->GetComponent<Components::Pad>(Entity()));
-                break;
-            }
-        }
-    }
-
 	if (m_KrakenAttack) {
 		m_KrakenCharge -= m_KrakenStrength * dt;
 		if (m_KrakenCharge < 0) {
@@ -151,14 +163,20 @@ void dd::Systems::PadSystem::Update(double dt)
 		Events::KrakenAttack e;
 		e.ChargeUpdate = m_KrakenCharge;
 		EventBroker->Publish(e);
-		//std::cout << "Charge: " << m_KrakenCharge << std::endl;
 		return;
 	}
 
-	auto transform = Transform();
-	auto pad = Pad();
-	auto acceleration = Acceleration();
+	auto transform = m_PadTransform;
+	auto pad = m_PadComponent;
+	auto acceleration = m_PadAcceleration;
 
+	if (glm::abs(transform->Position.y - m_PadHeight) > m_PadRiseSpeed) {
+		if (transform->Position.y < m_PadHeight) {
+			transform->Position.y += m_PadRiseSpeed * (float)dt;
+		} else if (transform->Position.y > m_PadHeight) {
+			transform->Position.y -= m_PadRiseSpeed * 5 * (float)dt;
+		}
+	}
     if (transform->Velocity.x < -pad->MaxSpeed) {
         transform->Velocity.x = -pad->MaxSpeed;
     }
@@ -166,27 +184,27 @@ void dd::Systems::PadSystem::Update(double dt)
         transform->Velocity.x = pad->MaxSpeed;
     }
     transform->Position += transform->Velocity * (float)dt;
-    if (transform->Position.x > Edge()) {
-        transform->Position.x = Edge();
-    } else if (transform->Position.x < -Edge()) {
-        transform->Position.x = -Edge();
+    if (transform->Position.x > m_Edge) {
+        transform->Position.x = m_Edge;
+    } else if (transform->Position.x < -m_Edge) {
+        transform->Position.x = -m_Edge;
     }
-    transform->Velocity += acceleration  * (float)dt;
-    if (glm::abs(transform->Velocity.x) > 1 || (!Left() && !Right())) {
+    transform->Velocity += acceleration * (float)dt;
+    if (glm::abs(transform->Velocity.x) > 1 || (!m_Left && !m_Right)) {
         transform->Velocity -= transform->Velocity * pad->SlowdownModifier * (float) dt;
     }
 
-    if (Left()) {
+    if (m_Left) {
         acceleration.x = -pad->AccelerationSpeed;
-    } else if (Right()) {
+    } else if (m_Right) {
         acceleration.x = pad->AccelerationSpeed;
     } else {
         acceleration.x = 0.f;
     }
 
-    SetTransform(transform);
-    SetPad(pad);
-    SetAcceleration(acceleration);
+    m_PadTransform = transform;
+    m_PadComponent = pad;
+    m_PadAcceleration = acceleration;
 
     return;
 }
@@ -220,11 +238,11 @@ bool dd::Systems::PadSystem::OnKeyDown(const dd::Events::KeyDown &event) {
     } else if (val == GLFW_KEY_LEFT) {
         //std::cout << "Left!" << std::endl;
         //acceleration.x = -0.01f;
-        SetLeft(true);
+        m_Left = true;
     } else if (val == GLFW_KEY_RIGHT) {
         //std::cout << "Right!" << std::endl;
         //acceleration.x = 0.01f;
-        SetRight(true);
+        m_Right = true;
     } else if (val == GLFW_KEY_R) {
         Events::ResetBall e;
         EventBroker->Publish(e);
@@ -243,7 +261,7 @@ bool dd::Systems::PadSystem::OnKeyDown(const dd::Events::KeyDown &event) {
 		EventBroker->Publish(e);
 	} else if (val == GLFW_KEY_M) {
         Events::MultiBall e;
-        e.padTransform = Transform();
+        e.padTransform = m_PadTransform;
         EventBroker->Publish(e);
     } else if (val == GLFW_KEY_P) {
 		if (IsPaused()) {
@@ -271,12 +289,17 @@ bool dd::Systems::PadSystem::OnKeyDown(const dd::Events::KeyDown &event) {
 		EventBroker->Publish(e);
 	} else if (val == GLFW_KEY_G) {
 		Events::BrickGenerating e;
-		e.Origin = glm::vec3(-5, 7, -10);
+		e.Origin1 = glm::vec3(-5, 7, -10);
+		e.Origin2 = glm::vec3(5, 7, -10);
 		e.Set = 1;
+		e.SetCluster = 1;
+		EventBroker->Publish(e);
+	} else if (val == GLFW_KEY_C) {
+		Events::BreakAllBricks e;
 		EventBroker->Publish(e);
 	} else if (val == GLFW_KEY_L) {
 		Events::Lifebuoy e;
-		e.Transform = Transform();
+		e.Transform = m_PadTransform;
 		EventBroker->Publish(e);
 	} else if (val == GLFW_KEY_Y) {
 		Events::StickyPad e;
@@ -295,14 +318,14 @@ bool dd::Systems::PadSystem::OnKeyDown(const dd::Events::KeyDown &event) {
 		EventBroker->Publish(e);
 	} else if (val == GLFW_KEY_Q) {
 		Events::Move e;
-		e.Entity = Entity();
-		e.GoalPosition = glm::vec3(0, 0, -10);
+		e.Entity = m_PadEntity;
+		e.GoalPosition = glm::vec3(0, 0, -10); 
 		e.Speed = 5;
 		e.Queue = false;
 		EventBroker->Publish(e);
 	} else if (val == GLFW_KEY_SPACE) {
         Events::ActionButton e;
-		e.Position = Transform()->Position;
+		e.Position = m_PadTransform->Position;
         EventBroker->Publish(e);
     } else if (val == GLFW_KEY_D) {
         return false;
@@ -318,9 +341,9 @@ bool dd::Systems::PadSystem::OnKeyUp(const dd::Events::KeyUp &event)
     } else if (val == GLFW_KEY_DOWN) {
 
     } else if (val == GLFW_KEY_LEFT) {
-        SetLeft(false);
+        m_Left = false;
     } else if (val == GLFW_KEY_RIGHT) {
-        SetRight(false);
+        m_Right = false;
     }
     return true;
 }
@@ -419,6 +442,7 @@ bool dd::Systems::PadSystem::OnStageCleared(const dd::Events::StageCleared &even
 {
     //auto entity = CreateBall();
 	m_StickyAim->Aiming = false;
+	m_PadHeight = m_PadOriginalHeight;
     return true;
 }
 
@@ -450,14 +474,8 @@ bool dd::Systems::PadSystem::OnRaiseWaterWall(const dd::Events::RaiseWaterWall &
 
 bool dd::Systems::PadSystem::RaisePad(float amount, float speed)
 {
-	auto transform = Transform();
-	glm::vec3 raise = glm::vec3(0, amount, 0);
-	Events::Move e;
-	e.Entity = m_Entity;
-	e.GoalPosition = transform->Position + raise;
-	e.Speed = speed;
-	e.Queue = true;
-	EventBroker->Publish(e);
+	m_PadHeight += amount;
+	m_PadRiseSpeed = speed;
 	return true;
 }
 
@@ -468,23 +486,64 @@ bool dd::Systems::PadSystem::OnKrakenAttack(const dd::Events::KrakenAttack &even
 		m_PlayerStrength = event.PlayerStrength;
 		m_KrakenCharge = event.ChargeUpdate;
 		m_KrakenAttack = true;
-		auto transform = Transform();
-		auto acceleration = Acceleration();
+		auto transform = m_PadTransform;
+		auto acceleration = m_PadAcceleration;
 
 		transform->Velocity = glm::vec3(0, 0, 0);
 		acceleration = glm::vec3(0, 0, 0);
+		if (m_KrakenArmHitbox == 0) {
+			auto animation = m_World->GetComponent<Components::Animation>(m_KrakenArm);
+			animation->Time = 0.0;
+			animation->Speed = 1.0;
 
-		SetTransform(transform);
-		SetAcceleration(acceleration);
+			m_KrakenArmHitbox = m_World->CreateEntity();
+			auto hb_transform = m_World->AddComponent<Components::Transform>(m_KrakenArmHitbox);
+			hb_transform->Position = transform->Position + glm::vec3(-1.f, -5.0f, -10.f);
+			//hb_transform->Position = glm::vec3(-2.f, -8.0f, -10.f);
+			hb_transform->Scale = glm::vec3(2.5f, 2.5f, 1.f);
+			hb_transform->Velocity = glm::vec3(0.f, 10.f, 0.f);
+			//auto hb_sprite = m_World->AddComponent<Components::Sprite>(m_KrakenArmHitbox);
+			//hb_sprite->SpriteFile = "Textures/Core/ErrorTexture.png";
+			auto hb_physics = m_World->AddComponent<Components::Physics>(m_KrakenArmHitbox);
+			hb_physics->Calculate = true;
+			hb_physics->CollisionType = CollisionType::Type::Static;
+			hb_physics->Category = CollisionLayer::Type::Other;
+			hb_physics->Mask = CollisionLayer::Type::Water;
+			hb_physics->GravityScale = 0.f;
+			auto hb_HitBox = m_World->AddComponent<Components::CircleShape>(m_KrakenArmHitbox);
+			hb_HitBox->Radius = 1.25f;
+			m_World->CommitEntity(m_KrakenArmHitbox);
+		}
+
+		m_PadTransform = transform;
+		m_PadAcceleration = acceleration;
 	} else if (m_KrakenCharge >= 1) {
 		m_KrakenAttack = false;
-		m_KrakenCharge = 0;
-		m_KrakenStrength = 0;
-		m_PlayerStrength = 0;
+		Events::KrakenAttackEnd e;
+		EventBroker->Publish(e);
 	}
 	return true;
 }
 
+bool dd::Systems::PadSystem::OnKrakenAttackEnd(const dd::Events::KrakenAttackEnd &event)
+{
+	m_KrakenAttack = false;
+	m_KrakenCharge = 0;
+	m_KrakenStrength = 0;
+	m_PlayerStrength = 0;
+
+		//m_World->RemoveEntity(m_KrakenArm);
+
+	auto animation = m_World->GetComponent<Components::Animation>(m_KrakenArm);
+	animation->Time = 0.0;
+	animation->Speed = -1.5;
+	m_World->RemoveEntity(m_KrakenArmHitbox);
+	//m_KrakenArm = NULL;
+	m_KrakenArmHitbox = 0;
+		
+	return true;
+}
+
 bool dd::Systems::PadSystem::OnStickyPad(const dd::Events::StickyPad &event)
 {
 	return true;

src/game/Game/ProjectileSystem.cpp

@@ -13,6 +13,8 @@ void dd::Systems::ProjectileSystem::Initialize()
 	EVENT_SUBSCRIBE_MEMBER(m_EPause, &ProjectileSystem::OnPause);
 	EVENT_SUBSCRIBE_MEMBER(m_EResume, &ProjectileSystem::OnResume);
 	EVENT_SUBSCRIBE_MEMBER(m_EInkBlaster, &ProjectileSystem::OnInkBlaster);
+	EVENT_SUBSCRIBE_MEMBER(m_EKrakenAttack, &ProjectileSystem::OnKrakenAttack);
+	EVENT_SUBSCRIBE_MEMBER(m_EKrakenAttackEnd, &ProjectileSystem::OnKrakenAttackEnd);
 	EVENT_SUBSCRIBE_MEMBER(m_EHitPad, &ProjectileSystem::OnHitPad);
 	EVENT_SUBSCRIBE_MEMBER(m_EActionButton, &ProjectileSystem::OnActionButton);
 
@@ -107,40 +109,77 @@ bool dd::Systems::ProjectileSystem::OnInkBlaster(const dd::Events::InkBlaster &e
 bool dd::Systems::ProjectileSystem::OnHitPad(const dd::Events::HitPad &event)
 {
 	if (m_InkBlaster) {
+		auto ball = m_World->GetComponent<Components::Ball>(event.Ball);
+		ball->Loaded = true;
 		m_SquidLoaded = true;
 		m_AttachedSquid = event.Ball;
+
+		auto model = m_World->GetComponent<Components::Model>(m_AttachedSquid);
+		model->ModelFile = "Models/Sid/Sid_Shoot.dae";
+		
+		auto anim = m_World->GetComponent<Components::Animation>(m_AttachedSquid);
+		anim->Loop = false;
+		anim->Speed = 0.f;
 	}
 	return true;
 }
 
+bool dd::Systems::ProjectileSystem::OnKrakenAttack(const dd::Events::KrakenAttack &event)
+{
+	m_KrakenAttack = true;
+	return true;
+}
+
+bool dd::Systems::ProjectileSystem::OnKrakenAttackEnd(const dd::Events::KrakenAttackEnd &event)
+{
+	m_KrakenAttack = false;
+	return true;
+}
+
 bool dd::Systems::ProjectileSystem::OnActionButton(const dd::Events::ActionButton &event)
 {
-	if (m_InkBlaster && m_SquidLoaded) {
-		auto ent = m_World->CloneEntity(m_InkBlastTemplate);
-		m_World->RemoveComponent<Components::Template>(ent);
-		auto projectile = m_World->GetComponent<Components::Projectile>(ent);
-		projectile->Speed = m_InkBlasterSpeed;
-		auto transform = m_World->GetComponent<Components::Transform>(ent);
-		transform->Position = event.Position;
-		transform->Velocity = glm::vec3(0, projectile->Speed, 0);
-		m_Shots--;
-		if (m_Shots <= 0) {
-			auto ball = m_World->GetComponent<Components::Ball>(m_AttachedSquid);
-			m_InkBlaster = false;
-			m_SquidLoaded = false;
-			ball->InkBlaster = false;
-			ball->Sticky = false;
-			ball->Waiting = true;
-			
-			{
-				Events::InkBlasterOver e;
-				e.Ball = m_AttachedSquid;
-				EventBroker->Publish(e);
-			}
+	if (!m_KrakenAttack) {
+		if (m_InkBlaster && m_SquidLoaded) {
+			auto ent = m_World->CloneEntity(m_InkBlastTemplate);
+			m_World->RemoveComponent<Components::Template>(ent);
+			auto projectile = m_World->GetComponent<Components::Projectile>(ent);
+			projectile->Speed = m_InkBlasterSpeed;
+			auto transform = m_World->GetComponent<Components::Transform>(ent);
+			transform->Position = event.Position;
+			transform->Velocity = glm::vec3(0, projectile->Speed, 0);
+			m_Shots--;
+
+			auto anim = m_World->GetComponent<Components::Animation>(m_AttachedSquid);
+			anim->Loop = false;
+			anim->Speed = 1.f;
+			anim->Time = 0.f;
+
+			if (m_Shots <= 0) {
+				auto ball = m_World->GetComponent<Components::Ball>(m_AttachedSquid);
+				m_InkBlaster = false;
+				m_SquidLoaded = false;
+				ball->InkBlaster = false;
+				ball->Sticky = false;
+				ball->Loaded = false;
+				ball->Waiting = true;
+
+				{
+					Events::InkBlasterOver e;
+					e.Ball = m_AttachedSquid;
+					EventBroker->Publish(e);
+
+					auto model = m_World->GetComponent<Components::Model>(m_AttachedSquid);
+					model->ModelFile = "Models/Sid/Sid_Flying.dae";
+
+					auto anim = m_World->GetComponent<Components::Animation>(m_AttachedSquid);
+					anim->Loop = true;
+					anim->Speed = 1.f;
+				}
 			{
 				Events::ActionButton e;
 				EventBroker->Publish(e);
 			}
+			}
 		}
 	}
 	return true;

src/game/Game/ProjectileSystem.cpp.orig

@@ -1,151 +0,0 @@
-//
-// Created by Adniklastrator on 2015-10-08.
-//
-
-
-#include "PrecompiledHeader.h"
-#include "Game/ProjectileSystem.h"
-
-
-void dd::Systems::ProjectileSystem::Initialize()
-{
-	EVENT_SUBSCRIBE_MEMBER(m_EContact, &ProjectileSystem::OnContact);
-	EVENT_SUBSCRIBE_MEMBER(m_EPause, &ProjectileSystem::OnPause);
-	EVENT_SUBSCRIBE_MEMBER(m_EResume, &ProjectileSystem::OnResume);
-	EVENT_SUBSCRIBE_MEMBER(m_EInkBlaster, &ProjectileSystem::OnInkBlaster);
-	EVENT_SUBSCRIBE_MEMBER(m_EHitPad, &ProjectileSystem::OnHitPad);
-	EVENT_SUBSCRIBE_MEMBER(m_EActionButton, &ProjectileSystem::OnActionButton);
-
-	//Ink Blast
-	{
-		auto ent = m_World->CreateEntity();
-		m_World->SetProperty(ent, "Name", "Projectile");
-		std::shared_ptr<Components::Transform> ctransform = m_World->AddComponent<Components::Transform>(ent);
-		
-		auto circleShape = m_World->AddComponent<Components::CircleShape>(ent);
-		auto inkBlastTemplate = m_World->AddComponent<Components::Template>(ent);
-		circleShape->Radius = 0.1f;
-		auto physics = m_World->AddComponent<Components::Physics>(ent);
-		physics->CollisionType = CollisionType::Type::Dynamic;
-		physics->Category = CollisionLayer::Type::Projectile;
-		physics->Mask = static_cast<CollisionLayer::Type>(CollisionLayer::Type::Pad | CollisionLayer::Type::Brick | CollisionLayer::Type::Wall);
-		physics->Calculate = true;
-		ctransform->Position = glm::vec3(0.f, 0.f, -10.f);
-		ctransform->Scale = glm::vec3(0.6f, 0.6f, 0.6f);
-// 		auto cModel = m_World->AddComponent<Components::Model>(ent);
-// 		cModel->ModelFile = "Models/Test/Ball/Sid.obj";
-		auto cSprite = m_World->AddComponent<Components::Sprite>(ent);
-		cSprite->SpriteFile = "Textures/Particles/OilShot.png";
-		auto projectile = m_World->AddComponent<Components::Projectile>(ent);
-
-		m_World->CommitEntity(ent);
-
-		m_InkBlastTemplate = ent;
-	}
-
-    return;
-}
-
-void dd::Systems::ProjectileSystem::Update(double dt)
-{
-	if (m_Pause) {
-		return;
-	}
-}
-
-void dd::Systems::ProjectileSystem::UpdateEntity(double dt, EntityID entity, EntityID parent)
-{
-    if (IsPaused()) {
-        return;
-    }
-    auto templateCheck = m_World->GetComponent<Components::Template>(entity);
-    if (templateCheck != nullptr){ return; }
-
-	auto shot = m_World->GetComponent<Components::Projectile>(entity);
-	if (shot != nullptr) {
-		auto transform = m_World->GetComponent<Components::Transform>(entity);
-		if (transform->Position.y > 8) {
-			m_World->RemoveEntity(entity);
-		}
-	}
-}
-
-bool dd::Systems::ProjectileSystem::OnPause(const dd::Events::Pause &event)
-{
-    /*if (event.Type != "ProjectileSystem" && event.Type != "All") {
-        return false;
-    }*/
-    
-    m_Pause = true;
-
-    return true;
-}
-
-bool dd::Systems::ProjectileSystem::OnResume(const dd::Events::Resume &event)
-{
-	/*if (event.Type != "ProjectileSystem" && event.Type != "All") {
-	return false;
-	}*/
-	m_Pause = false;
-	return true;
-}
-
-bool dd::Systems::ProjectileSystem::OnContact(const dd::Events::Contact &event)
-{
-    
-    return true;
-}
-
-bool dd::Systems::ProjectileSystem::OnInkBlaster(const dd::Events::InkBlaster &event)
-{
-	m_InkBlaster = true;
-	m_Shots = event.Shots;
-	m_InkBlasterSpeed = event.Speed;
-	return true;
-}
-
-bool dd::Systems::ProjectileSystem::OnHitPad(const dd::Events::HitPad &event)
-{
-	if (m_InkBlaster) {
-		m_SquidLoaded = true;
-		m_AttachedSquid = event.Ball;
-	}
-	return true;
-}
-
-bool dd::Systems::ProjectileSystem::OnActionButton(const dd::Events::ActionButton &event)
-{
-	if (m_InkBlaster && m_SquidLoaded) {
-		auto ent = m_World->CloneEntity(m_InkBlastTemplate);
-		m_World->RemoveComponent<Components::Template>(ent);
-		auto projectile = m_World->GetComponent<Components::Projectile>(ent);
-		projectile->Speed = m_InkBlasterSpeed;
-		auto transform = m_World->GetComponent<Components::Transform>(ent);
-		transform->Position = event.Position;
-<<<<<<< HEAD
-		transform->Velocity = glm::vec3(0, projectile->Speed, 0);
-=======
-		transform->Velocity = glm::vec3(0, 7, 0);
->>>>>>> origin/master
-		m_Shots--;
-		if (m_Shots <= 0) {
-			auto ball = m_World->GetComponent<Components::Ball>(m_AttachedSquid);
-			m_InkBlaster = false;
-			m_SquidLoaded = false;
-			ball->InkBlaster = false;
-			ball->Sticky = false;
-			ball->Waiting = true;
-			
-			{
-				Events::InkBlasterOver e;
-				e.Ball = m_AttachedSquid;
-				EventBroker->Publish(e);
-			}
-			{
-				Events::ActionButton e;
-				EventBroker->Publish(e);
-			}
-		}
-	}
-	return true;
-}

src/game/Game/ScreenShakeSystem.cpp

@@ -5,6 +5,7 @@
 #include "PrecompiledHeader.h"
 #include "Game/ScreenShakeSystem.h"
 
+
 void dd::Systems::ScreenShakeSystem::Initialize()
 {
 	std::random_device rd;
@@ -36,7 +37,7 @@ void dd::Systems::ScreenShakeSystem::UpdateEntity(double dt, EntityID entity, En
         return;
     }
 
-	/*auto camera = m_World->GetComponent<Components::Camera>(entity);
+	auto camera = m_World->GetComponent<Components::Camera>(entity);
 	
 	if (camera != nullptr) {
 		auto transform = m_World->GetComponent<Components::Transform>(entity);
@@ -73,7 +74,7 @@ void dd::Systems::ScreenShakeSystem::UpdateEntity(double dt, EntityID entity, En
 		} else {
 			m_CameraPosition = transform->Position;
 		}
-	}*/
+	}
 }
 
 bool dd::Systems::ScreenShakeSystem::OnPause(const dd::Events::Pause &event)

src/game/Game/WaterSystem.cpp

@@ -14,6 +14,8 @@ void dd::Systems::WaterSystem::Initialize()
 	EVENT_SUBSCRIBE_MEMBER(m_ERaiseWater, &WaterSystem::OnRaiseWater);
 	EVENT_SUBSCRIBE_MEMBER(m_ERaiseWaterWall, &WaterSystem::OnRaiseWaterWall);
 
+	m_RaiseWater = ResourceManager::Load<ConfigFile>("Config.ini")->GetValue<bool>("Debug.RaiseWater", false);
+
 	//Water test
 	{
 		auto t_waterBody = m_World->CreateEntity();
@@ -24,6 +26,10 @@ void dd::Systems::WaterSystem::Initialize()
 		auto body = m_World->AddComponent<Components::RectangleShape>(t_waterBody);
 		m_World->CommitEntity(t_waterBody);
 	}
+
+	m_BrickPartCounters =
+	{0, 0, 0, 0, 0,
+	 0, 0, 0, 0, 0 };
 }
 
 void dd::Systems::WaterSystem::Update(double dt)
@@ -43,6 +49,31 @@ void dd::Systems::WaterSystem::UpdateEntity(double dt, EntityID entity, EntityID
 	auto templateCheck = m_World->GetComponent<Components::Template>(entity);
 	if (templateCheck != nullptr){ return; }
 
+	auto brickPart = m_World->GetComponent<Components::BrickPart>(entity);
+	if (brickPart != nullptr) {
+		auto transform = m_World->GetComponent<Components::Transform>(entity);
+		if (m_RaiseWater) {
+			if (!brickPart->Submerged) {
+				if (transform->Position.y < m_SubmergedHeight) {
+					brickPart->Submerged = true;
+					m_BrickPartCounters[brickPart->NumberOfPartsInBrick]++;
+					//std::cout << "Parts: " << m_BrickPartCounters[brickPart->NumberOfPartsInBrick] << " of " << brickPart->NumberOfPartsInBrick << std::endl;
+					if (m_BrickPartCounters[brickPart->NumberOfPartsInBrick] >= brickPart->NumberOfPartsInBrick) {
+						m_BrickPartCounters[brickPart->NumberOfPartsInBrick] = 0;
+						Events::RaiseWater e;
+						e.Amount = 0.2;
+						e.Speed = 0.2;
+						EventBroker->Publish(e);
+					}
+				}
+			}
+		}
+		if (transform->Position.y < -10) {
+			m_World->RemoveEntity(entity);
+			return;
+		}
+	}
+
 	if (m_BottomWall == 0) {
 		for (auto it = m_World->GetEntities()->begin(); it != m_World->GetEntities()->end(); it++) {
 			if (m_World->GetProperty<std::string>(it->first, "Name") == "BottomWall") {
@@ -51,6 +82,21 @@ void dd::Systems::WaterSystem::UpdateEntity(double dt, EntityID entity, EntityID
 			}
 		}
 	}
+
+	auto newWater = m_World->GetComponent<Components::NewWaterVolume>(entity);
+	if (newWater != nullptr) {
+		if (m_RemoveWater) {
+			//m_World->RemoveComponent<Components::WaterVolume>(entity);
+			//m_World->RemoveComponent<Components::RectangleShape>(entity);
+			//m_World->RemoveComponent<Components::WaterVolume>(entity);
+			//m_World->RemoveEntity(entity);
+			//m_World->RemoveComponent<Components::>();
+		}
+		/*auto transform = m_World->AddComponent<Components::Transform>(entity);
+		if (transform->Position.y < -10) {
+			m_World->RemoveEntity(entity);
+		}*/
+	}
 }
 
 bool dd::Systems::WaterSystem::OnPause(const dd::Events::Pause &event)
@@ -80,13 +126,14 @@ bool dd::Systems::WaterSystem::OnRelevantObjectCreated(const dd::Events::Relevan
 
 bool dd::Systems::WaterSystem::OnStageCleared(const dd::Events::StageCleared &event)
 {
-	
+	m_SubmergedHeight = m_SubmergedOriginalHeight;
+	m_RemoveWater = true;
 	return true;
 }
 
 bool dd::Systems::WaterSystem::OnArrivedAtNewStage(const dd::Events::ArrivedAtNewStage &event)
 {
-	
+	m_RemoveWater = false;
 	return true;
 }
 
@@ -95,13 +142,16 @@ bool dd::Systems::WaterSystem::OnRaiseWater(const dd::Events::RaiseWater &event)
 	{
 		auto t_waterBody = m_World->CreateEntity();
 		auto transform = m_World->AddComponent<Components::Transform>(t_waterBody);
-		transform->Position = glm::vec3(0.f, -3.5f, -10.f);
-		transform->Scale = glm::vec3(7.0f, event.Amount * 1.6f, 1.f);
+		transform->Position = glm::vec3(0.f, m_SubmergedHeight, -10.f);
+		transform->Scale = glm::vec3(7.0f, event.Amount * 1.4f, 1.f);
 		auto water = m_World->AddComponent<Components::WaterVolume>(t_waterBody);
+		auto newWater = m_World->AddComponent<Components::NewWaterVolume>(t_waterBody); //Meaning it isn't the original water we had.
 		auto body = m_World->AddComponent<Components::RectangleShape>(t_waterBody);
 		m_World->CommitEntity(t_waterBody);
 	}
 
+	m_SubmergedHeight += event.Amount;
+
 	return true;
 }
 

src/game/Physics/PhysicsSystem.cpp

@@ -37,6 +37,7 @@ void dd::Systems::PhysicsSystem::InitializeWater()
     m_ParticleSystemDef.radius = radius;
     m_ParticleSystemDef.gravityScale = gravityScale;
 	m_ParticleSystemDef.density = 4.f;
+	m_ParticleSystemDef.surfaceTensionNormalStrength = 0.07;
 
     m_WaterParticleSystem = m_PhysicsWorld->CreateParticleSystem(&m_ParticleSystemDef);
 }
@@ -235,7 +236,12 @@ void dd::Systems::PhysicsSystem::Update(double dt)
 				auto particle = m_World->GetComponent<Components::Particle>(entity);
 
                 transform->Position = glm::vec3(position.x, position.y, transform->Position.z);
-				transform->Scale = particle->Scale;//glm::vec3(particle->Radius * 2.f, particle->Radius * 2.f, 1);
+				EntityID emitter = m_ParticleEmitters.ParticleEmitter[e];
+				auto cEmitter = m_World->GetComponent<Components::ParticleEmitter>(emitter);
+				if (!cEmitter->DefaultScale)
+				{
+					transform->Scale = particle->Scale;
+				}
             }
         }
 
@@ -271,7 +277,7 @@ void dd::Systems::PhysicsSystem::UpdateEntity(double dt, EntityID entity, Entity
                 m_World->RemoveEntity(entity);
             }
         }
-		//Update alpha
+		//Update alpha & scale
 		auto sprite = m_World->GetComponent<Components::Sprite>(entity);
 		float timeProgress = particle->TimeLived / (particle->LifeTime - 0.1);
 		if (timeProgress > 1) {
@@ -280,7 +286,9 @@ void dd::Systems::PhysicsSystem::UpdateEntity(double dt, EntityID entity, Entity
 		auto emitter = m_World->GetComponent<Components::ParticleEmitter>(particle->ParticleSystem);
 		if (emitter) {
 			sprite->Color.w = ScalarInterpolation(timeProgress, emitter->AlphaValues);
-			particle->Scale = VectorInterpolation(timeProgress, emitter->ScaleValues);
+			if (!emitter->DefaultScale) {
+				particle->Scale = VectorInterpolation(timeProgress, emitter->ScaleValues);
+			}
 			
 		}
     }
@@ -719,8 +727,9 @@ bool dd::Systems::PhysicsSystem::CreateParticleSequence(const Events::CreatePart
     particleEmitter->EmittingAngle = event.EmittingAngle;
     particleEmitter->LifeTime = event.EmitterLifeTime;
 	particleEmitter->AlphaValues = event.AlphaValues;
-	particleEmitter->ScaleValues = event.ScaleValues;
 	particleEmitter->RadiusDistribution = event.RadiusDistribution;
+	particleEmitter->DefaultScale = event.DefaultScale;
+	particleEmitter->ScaleValues = event.ScaleValues;
 	{
 		//Creating Particle Template
 		auto particle = m_World->CreateEntity(emitter);
@@ -730,10 +739,17 @@ bool dd::Systems::PhysicsSystem::CreateParticleSequence(const Events::CreatePart
 		m_World->AddComponent<Components::Template>(particle);
 		particleTransform->Position = emitterTransform->Position;
 		sprite->SpriteFile = event.SpriteFile;
+		if (particleEmitter->DefaultScale == true)
+		{
+			Texture* texture = ResourceManager::Load<Texture>(event.SpriteFile);
+			particleEmitter->ScaleValues.clear();
+			particleEmitter->ScaleValues.push_back(glm::vec3(texture->Width / 100, texture->Height / 100, 1));
+			
+		} 
 		sprite->Color = event.Color;
 		particleComponent->LifeTime = event.ParticleLifeTime;
 		particleComponent->Flags = event.Flags;
-		particleComponent->Scale = event.ScaleValues[0];
+		particleComponent->Scale = particleEmitter->ScaleValues[0];
 		particleComponent->ParticleSystem = emitter;
     }
     m_World->CommitEntity(emitter);
@@ -820,8 +836,9 @@ bool dd::Systems::PhysicsSystem::OnContact(const dd::Events::Contact &event)
 
 		model = m_World->GetComponent<Components::Model>(event.Entity1);
 	}
+	Events::PlaySound se;
 
-	//Spawn a particle when a brick collides with somthing
+	//Spawn a particle when a brick collides with something
 	Events::CreateParticleSequence e;
 	e.EmitterLifeTime = 3;
 	e.EmittingAngle = glm::half_pi<float>();
@@ -833,8 +850,9 @@ bool dd::Systems::PhysicsSystem::OnContact(const dd::Events::Contact &event)
 	e.Color = glm::vec4(1.f);
 	e.AlphaValues.push_back(1.f);
 	e.AlphaValues.push_back(0.f);
-	e.ScaleValues.push_back(glm::vec3(1.f));
+	e.ScaleValues.push_back(glm::vec3(4));
 	e.Speed = 0;
+	e.DefaultScale = true;
 
 	auto PowerFriend = m_World->GetComponent<Components::MultiBallBrick>(entity);
 	auto PowerSaviour = m_World->GetComponent<Components::LifebuoyBrick>(entity);
@@ -843,17 +861,28 @@ bool dd::Systems::PhysicsSystem::OnContact(const dd::Events::Contact &event)
 	auto PowerKraken = m_World->GetComponent<Components::KrakenAttackBrick>(entity);
 
 	if (PowerFriend) {
+		se.FilePath = "Sounds/jap-awesome.wav";
+		EventBroker->Publish(se);
 		e.SpriteFile = "Textures/PowerUps/Friends.png";
 	} else if (PowerSaviour) {
+		se.FilePath = "Sounds/jap-awesome.wav";
+		EventBroker->Publish(se);
 		e.SpriteFile = "Textures/PowerUps/Saviour.png";
 	} else if (PowerSticky) {
+		se.FilePath = "Sounds/jap-awesome.wav";
+		EventBroker->Publish(se);
 		e.SpriteFile = "Textures/PowerUps/Sticky.png";
 	} else if (PowerInkBlaster){
+		se.FilePath = "Sounds/jap-awesome.wav";
+		EventBroker->Publish(se);
 		e.SpriteFile = "Textures/PowerUps/InkBlaster.png";
 	} else if (PowerKraken) { 
+		se.FilePath = "Sounds/jap-huh.wav";
+		EventBroker->Publish(se);
 		e.SpriteFile = "Textures/PowerUps/RealeaseTheKraken.png";
 	}
 	else {
+		e.DefaultScale = false;
 		e.EmitterLifeTime = 4;
 		e.EmittingAngle = glm::half_pi<float>();
 		e.Spread = 0.5f;

src/game/Rendering/AnimationSystem.cpp

@@ -24,8 +24,29 @@ void dd::Systems::AnimationSystem::Update(double dt)
 	}
 
 	for (auto& component : *animations) {
-		auto animation = static_cast<Components::Animation*>(component.get());
-		animation->Time += animation->Speed * dt;
+		EntityID ent = component->Entity;
+		auto animationComponent = static_cast<Components::Animation*>(component.get());
+
+		// Get animation information
+		auto modelComponent = m_World->GetComponent<Components::Model>(ent);
+		auto model = ResourceManager::Load<Model>(modelComponent->ModelFile);
+		auto skeleton = model->m_Skeleton;
+		auto animation = skeleton->GetAnimation(animationComponent->Name);
+
+		if (animationComponent->Speed != 0.0) {
+			double nextTime = animationComponent->Time + animationComponent->Speed * dt;
+			if (!animationComponent->Loop && glm::abs(nextTime) > animation->Duration) {
+				animationComponent->Time = glm::sign(nextTime) * animation->Duration;
+				animationComponent->Speed = 0.0;
+				LOG_DEBUG("Animation \"%s\" on Entity %i finished.", animationComponent->Name.c_str(), ent);
+				Events::AnimationComplete e;
+				e.Entity = ent;
+				e.Animation = animationComponent->Name;
+					EventBroker->Publish(e);
+			} else {
+				animationComponent->Time = nextTime;
+			}
+		}
 	}
 }
 

src/game/Rendering/OpenGL/Renderer.cpp

@@ -21,6 +21,10 @@
 
 void dd::Renderer::Initialize()
 {
+	ResourceManager::RegisterType<ShaderProgram>("ShaderProgram");
+	ResourceManager::RegisterType<VertexShader>("VertexShader");
+	ResourceManager::RegisterType<FragmentShader>("FragmentShader");
+
 	// Initialize GLFW
 	if (!glfwInit()) {
 		LOG_ERROR("GLFW: Initialization failed");
@@ -59,7 +63,7 @@ void dd::Renderer::Initialize()
 	}
 
 	// Create default camera
-	m_DefaultCamera = std::unique_ptr<dd::Camera>(new dd::Camera((float)m_Resolution.Width / m_Resolution.Height, 45.f, 0.01f, 5000.f));
+	m_DefaultCamera = std::unique_ptr<dd::Camera>(new dd::Camera((float)m_Resolution.Width / m_Resolution.Height, glm::radians(45.f), 0.01f, 5000.f));
 	m_DefaultCamera->SetPosition(glm::vec3(0, 0, 0));
 	if (m_Camera == nullptr) {
 		m_Camera = m_DefaultCamera.get();
@@ -387,11 +391,6 @@ void dd::Renderer::DrawForward(RenderQueue &objects, RenderQueue &lights)
 	DrawWater(objects);
 }
 
-void dd::Renderer::PlaceCamera(glm::vec3 position)
-{
-	m_DefaultCamera->SetPosition(position);
-}
-
 void dd::Renderer::DrawScene(RenderQueue &objects, ShaderProgram &program)
 {
 	GLuint shaderProgramHandle = program;

src/game/Rendering/RawModel.cpp

@@ -293,6 +293,10 @@ dd::RawModel::RawModel(std::string fileName)
 			Skeleton::Animation::Keyframe animationFrame;
 			animationFrame.Index = keyframe;
 			animationFrame.Time = frameTimes[keyframe] / animation->mTicksPerSecond;
+			// HACK: For some reason Blender likes to create a first frame that doesn't start at time 0
+			if (keyframe == 0) {
+				animationFrame.Time = 0;
+			}
 			for (auto &kv2 : kv.second) {
 				int boneID = kv2.first;
 				auto &property = kv2.second;

src/game/Rendering/Skeleton.cpp

@@ -69,7 +69,7 @@ std::vector<glm::mat4> dd::Skeleton::GetFrameBones(const Animation& animation, d
 	int currentKeyframeIndex = GetKeyframe(animation, time);
 
 	const Animation::Keyframe& currentFrame = animation.Keyframes[currentKeyframeIndex];
-	const Animation::Keyframe& nextFrame = animation.Keyframes[currentKeyframeIndex + 1];
+	const Animation::Keyframe&	nextFrame = animation.Keyframes[(currentKeyframeIndex + 1) % animation.Keyframes.size()];
 	float alpha = (time - currentFrame.Time) / (nextFrame.Time - currentFrame.Time);
 
 	//auto animationFrame = Animations[""].Keyframes[frame];
@@ -149,12 +149,12 @@ int dd::Skeleton::GetKeyframe(const Animation& animation, double time)
 {
 	if (time < 0)
 		time = 0;
-	if (time > animation.Duration)
+	if (time >= animation.Duration)
 		return animation.Keyframes.size() - 1;
 
 	for (int keyframe = 0; keyframe < animation.Keyframes.size(); ++keyframe) {
 		if (animation.Keyframes[keyframe].Time > time)
-			return glm::max(0, keyframe - 1); // HACK: If the time is less than the first keyframe, don
+			return (keyframe - 1) % animation.Keyframes.size();
 	}
 
 	return 0;

src/game/Sound/SoundSystem.cpp

@@ -40,6 +40,7 @@ void dd::Systems::SoundSystem::Initialize()
     EVENT_SUBSCRIBE_MEMBER(m_EStopSound, &SoundSystem::OnStopSound);
     EVENT_SUBSCRIBE_MEMBER(m_EMasterVolume, &SoundSystem::OnMasterVolume);
 	EVENT_SUBSCRIBE_MEMBER(m_EGameStart, &SoundSystem::OnGameStart);
+	EVENT_SUBSCRIBE_MEMBER(m_EKrakenAppear, &SoundSystem::OnKrakenAppear);
 
 	m_SFXMasterVolume = ResourceManager::Load<ConfigFile>("Config.ini")->GetValue<float>("Audio.SFXVolume", 1.f);
 	m_BGMMasterVolume = ResourceManager::Load<ConfigFile>("Config.ini")->GetValue<float>("Audio.BGMVolume", 1.f);
@@ -188,6 +189,11 @@ bool dd::Systems::SoundSystem::OnContact(const dd::Events::Contact &event)
 
 bool dd::Systems::SoundSystem::OnGameStart(const dd::Events::GameStart &event)
 {
+	{
+		dd::Events::StopSound e;
+		e.FilePath = STORY_VOICE;
+		EventBroker->Publish(e);
+	}
 	{
 		dd::Events::StopSound e;
 		e.FilePath = MENU_BGM;
@@ -209,5 +215,32 @@ bool dd::Systems::SoundSystem::OnGameStart(const dd::Events::GameStart &event)
 	return true;
 }
 
+bool dd::Systems::SoundSystem::OnKrakenAppear(const dd::Events::KrakenAppear &event)
+{
+	{
+		dd::Events::StopSound e;
+		e.FilePath = GAME_BGM;
+		EventBroker->Publish(e);
+	}
+	{
+		dd::Events::StopSound e;
+		e.FilePath = WATER_BGM;
+		EventBroker->Publish(e);
+	}
+	{
+		dd::Events::PlaySound e;
+		e.FilePath = BOSS_BGM;
+		e.IsAmbient = true;
+		e.Gain = 0.4f;
+		EventBroker->Publish(e);
+	}
+	{
+		dd::Events::PlaySound e;
+		e.FilePath = "Sounds/Boss/boss-roar.wav";
+		EventBroker->Publish(e);
+	}
+	return true;
+}
+