Merge branch 'Physics'

Conflicts:
	include/Core/Engine.h
	include/Physics/CPhysics.h
	include/Physics/PhysicsSystem.h
	src/game/Game/BallSystem.cpp
	src/game/Physics/PhysicsSystem.cpp

assets/Models/Brick/IceBrick.mtl

@@ -0,0 +1,12 @@
+# Blender MTL File: 'Bricks.blend'
+# Material Count: 1
+
+newmtl Material.002
+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 IceBrick_Diffuse.png

assets/Models/Brick/TurquoiseBrick.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 turquoise.png

assets/Models/Brick/TurquoiseBrick.obj

@@ -0,0 +1,513 @@
+# Blender v2.75 (sub 0) OBJ File: 'Bricks.blend'
+# www.blender.org
+mtllib TurquoiseBrick.mtl
+o OriginalBrick_Cube.002
+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.732824 0.651596
+vt 0.497063 0.656145
+vt 0.498352 0.561696
+vt 0.835737 0.544092
+vt 0.832410 0.574334
+vt 0.728776 0.549797
+vt 0.733409 0.516110
+vt 0.747921 0.523504
+vt 0.498691 0.536867
+vt 0.754013 0.503366
+vt 0.838288 0.518944
+vt 0.716137 0.523643
+vt 0.711494 0.504530
+vt 0.498984 0.515399
+vt 0.734485 0.500579
+vt 0.734742 0.443967
+vt 0.756687 0.444264
+vt 0.500002 0.440769
+vt 0.708811 0.443615
+vt 0.842574 0.445423
+vt 0.261516 0.645162
+vt 0.268342 0.543511
+vt 0.164088 0.565217
+vt 0.161584 0.534899
+vt 0.264629 0.509713
+vt 0.281689 0.517713
+vt 0.159717 0.509691
+vt 0.244381 0.496413
+vt 0.249922 0.516708
+vt 0.263977 0.494158
+vt 0.286851 0.498734
+vt 0.243317 0.437260
+vt 0.265263 0.437561
+vt 0.291193 0.437916
+vt 0.157430 0.436083
+vt 0.495722 0.754363
+vt 0.939579 0.572784
+vt 0.950008 0.538976
+vt 0.966270 0.556108
+vt 0.495366 0.780443
+vt 0.733578 0.753608
+vt 0.929866 0.518425
+vt 0.931317 0.541897
+vt 0.953950 0.520177
+vt 0.983612 0.534778
+vt 0.733699 0.802691
+vt 0.495056 0.803167
+vt 0.935351 0.446668
+vt 0.962999 0.447038
+vt 0.733787 0.881463
+vt 0.493987 0.881463
+vt 0.999906 0.447531
+vt 0.057009 0.560761
+vt 0.047501 0.526686
+vt 0.066106 0.530111
+vt 0.257977 0.747114
+vt 0.068193 0.506688
+vt 0.030782 0.543370
+vt 0.014024 0.521580
+vt 0.256516 0.796175
+vt 0.044070 0.507787
+vt 0.037002 0.434429
+vt 0.064650 0.434809
+vt 0.254277 0.874915
+vt 0.000094 0.433923
+vt 0.501652 0.319843
+vt 0.502941 0.225399
+vt 0.738475 0.236380
+vt 0.731650 0.338024
+vt 0.835884 0.316299
+vt 0.838396 0.346613
+vt 0.735366 0.371817
+vt 0.718307 0.363820
+vt 0.501313 0.344671
+vt 0.840268 0.371818
+vt 0.755614 0.385114
+vt 0.750071 0.364821
+vt 0.736021 0.387371
+vt 0.713148 0.382798
+vt 0.501020 0.366139
+vt 0.267194 0.229946
+vt 0.164293 0.337419
+vt 0.167628 0.307183
+vt 0.271241 0.331739
+vt 0.266605 0.365420
+vt 0.252095 0.358025
+vt 0.246001 0.378160
+vt 0.161736 0.362565
+vt 0.283877 0.357890
+vt 0.288517 0.377003
+vt 0.265527 0.380951
+vt 0.504282 0.127186
+vt 0.942953 0.320724
+vt 0.952471 0.354792
+vt 0.933866 0.351373
+vt 0.742013 0.134433
+vt 0.504638 0.101108
+vt 0.931787 0.374794
+vt 0.969182 0.338104
+vt 0.985946 0.359886
+vt 0.504948 0.078385
+vt 0.743473 0.085376
+vt 0.955907 0.373688
+vt 0.506017 0.000095
+vt 0.745712 0.006641
+vt 0.060470 0.308697
+vt 0.050030 0.342497
+vt 0.033776 0.325361
+vt 0.266441 0.127940
+vt 0.070165 0.363055
+vt 0.068721 0.339584
+vt 0.046081 0.361294
+vt 0.016425 0.346681
+vt 0.266320 0.078861
+vt 0.266232 0.000094
+vt 0.733646 0.779865
+vt 0.257192 0.773359
+vt 0.742798 0.108190
+vt 0.266373 0.101685
+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/Test/Ball/Sid.mtl

@@ -0,0 +1,21 @@
+# Blender MTL File: 'Sid.blend'
+# Material Count: 2
+
+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
+
+newmtl None
+Ns 0
+Ka 0.000000 0.000000 0.000000
+Kd 0.8 0.8 0.8
+Ks 0.8 0.8 0.8
+d 1
+illum 2
+map_Kd SquidTexture.png

include/Core/Engine.h

@@ -45,6 +45,7 @@
 #include "Game/CPad.h"
 #include "Game/CBrick.h"
 #include "Game/BallSystem.h"
+#include "Game/HitLagSystem.h"
 #include "Game/Bricks/CPowerUpBrick.h"
 
 #include "Physics/PhysicsSystem.h"
@@ -122,6 +123,9 @@ public:
 		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::PhysicsSystem>(
 				[this]() { return new Systems::PhysicsSystem(m_World.get(), m_EventBroker); });
 		m_World->AddSystem<Systems::PhysicsSystem>();
@@ -134,31 +138,6 @@ public:
 		m_World->ComponentFactory.Register<Components::ParticleEmitter>();
 		m_World->Initialize();
 
-
-		//OctoBall
-		{
-          	auto ent = m_World->CreateEntity();
-        	std::shared_ptr<Components::Transform> transform = m_World->AddComponent<Components::Transform>(ent);
-			transform->Position = glm::vec3(-0.f, 0.26f, -10.f);
-			transform->Scale = glm::vec3(0.5f, 0.5f, 0.5f);
-			transform->Velocity = glm::vec3(0.0f, -10.f, 0.f);
-          	auto model = m_World->AddComponent<Components::Model>(ent);
-			model->ModelFile = "Models/Test/Ball/Ballopus.obj";
-          	std::shared_ptr<Components::CircleShape> circleShape = m_World->AddComponent<Components::CircleShape>(ent);
-			std::shared_ptr<Components::Ball> ball = m_World->AddComponent<Components::Ball>(ent);
-			ball->Speed = 5.f;
-			std::shared_ptr<Components::Physics> physics = m_World->AddComponent<Components::Physics>(ent);
-			physics->Static = false;
-			physics->Category = CollisionLayer::Type::Ball;
-			physics->Mask = static_cast<CollisionLayer::Type>(CollisionLayer::Pad | CollisionLayer::Brick | CollisionLayer::Wall);
-			physics->Calculate = true;
-
-			//auto plight = m_World->AddComponent<Components::PointLight>(ent);
-			//plight->Radius = 2.f;
-
-			m_World->CommitEntity(ent);
-		}
-
 		//PointLightTest
 		{
 			auto t_Light = m_World->CreateEntity();
@@ -258,62 +237,33 @@ public:
 		//TODO: Why does the ball not collide with these bricks?
 		//BottomBox
 		{
-			auto topWall = m_World->CreateEntity();
+			auto BottomWall = m_World->CreateEntity();
-			auto transform = m_World->AddComponent<Components::Transform>(topWall);
+			auto transform = m_World->AddComponent<Components::Transform>(BottomWall);
-			transform->Position = glm::vec3(0.f, -6.f, -9.9f);
+			transform->Position = glm::vec3(0.f, -6.f, -10.f);
-			transform->Scale = glm::vec3(10.f, 0.5f, 1.f);
+			transform->Scale = glm::vec3(20.f, 0.5f, 1.f);
-			std::shared_ptr<Components::Sprite> sprite = m_World->AddComponent<Components::Sprite>(topWall);
+			std::shared_ptr<Components::Sprite> sprite = m_World->AddComponent<Components::Sprite>(BottomWall);
 			sprite->SpriteFile = "Textures/Core/ErrorTexture.png";
-			std::shared_ptr<Components::RectangleShape> boxShape = m_World->AddComponent<Components::RectangleShape>(
+			std::shared_ptr<Components::RectangleShape> rectangleShape = m_World->AddComponent<Components::RectangleShape>(BottomWall);
-					topWall);
+			rectangleShape->Dimensions = glm::vec2(20.f, 0.5f);
-			std::shared_ptr<Components::Physics> physics = m_World->AddComponent<Components::Physics>(topWall);
+			std::shared_ptr<Components::Physics> physics = m_World->AddComponent<Components::Physics>(BottomWall);
-			physics->Static = true;
+			physics->CollisionType = CollisionType::Type::Static;
-			m_World->CommitEntity(topWall);
+			m_World->CommitEntity(BottomWall);
 		}
-		//SideBox
-//		{
-//			auto topWall = m_World->CreateEntity();
-//			std::shared_ptr<Components::Transform> transform = m_World->AddComponent<Components::Transform>(topWall);
-//			transform->Position = glm::vec3(3.f, -3.0f, -9.9f);
-//			transform->Scale = glm::vec3(0.5f, 3.f, 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> boxShape = m_World->AddComponent<Components::RectangleShape>(
-//					topWall);
-//			std::shared_ptr<Components::Physics> physics = m_World->AddComponent<Components::Physics>(topWall);
-//			physics->Static = true;
-//			m_World->CommitEntity(topWall);
-//		}
-//		//OtherSideBox
-//		{
-//			auto topWall = m_World->CreateEntity();
-//			std::shared_ptr<Components::Transform> transform = m_World->AddComponent<Components::Transform>(topWall);
-//			transform->Position = glm::vec3(-4.f, -3.0f, -9.9f);
-//			transform->Scale = glm::vec3(0.5f, 3.0f, 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> boxShape = m_World->AddComponent<Components::RectangleShape>(
-//					topWall);
-//			std::shared_ptr<Components::Physics> physics = m_World->AddComponent<Components::Physics>(topWall);
-//			physics->Static = true;
-//			m_World->CommitEntity(topWall);
-//		}
 
 		{
 			auto topWall = m_World->CreateEntity();
-			std::shared_ptr<Components::Transform> transform = m_World->AddComponent<Components::Transform>(
+			std::shared_ptr<Components::Transform> transform = m_World->AddComponent<Components::Transform>(topWall);
-					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> boxShape = m_World->AddComponent<Components::RectangleShape>(
+			std::shared_ptr<Components::RectangleShape> rectangleShape = m_World->AddComponent<Components::RectangleShape>(topWall);
-					topWall);
+			rectangleShape->Dimensions = glm::vec2(20.f, 0.5f);
 
 			std::shared_ptr<Components::Physics> physics = m_World->AddComponent<Components::Physics>(topWall);
-			physics->Static = true;
+			physics->CollisionType = CollisionType::Type::Static;
 			physics->Category = CollisionLayer::Wall;
 			physics->Mask = static_cast<CollisionLayer::Type>(CollisionLayer::Ball | CollisionLayer::Brick);
 
@@ -330,11 +280,11 @@ public:
 			std::shared_ptr<Components::Sprite> sprite = m_World->AddComponent<Components::Sprite>(leftWall);
 			sprite->SpriteFile = "Textures/Core/ErrorTexture.png";
 
-			std::shared_ptr<Components::RectangleShape> boxShape = m_World->AddComponent<Components::RectangleShape>(
+			std::shared_ptr<Components::RectangleShape> rectangleShape = m_World->AddComponent<Components::RectangleShape>(leftWall);
-					leftWall);
+			rectangleShape->Dimensions = glm::vec2(0.5f, 20.f);
 
 			std::shared_ptr<Components::Physics> physics = m_World->AddComponent<Components::Physics>(leftWall);
-			physics->Static = true;
+			physics->CollisionType = CollisionType::Type::Static;
 			physics->Category = CollisionLayer::Wall;
 			physics->Mask = static_cast<CollisionLayer::Type>(CollisionLayer::Ball | CollisionLayer::Brick);
 
@@ -351,18 +301,18 @@ public:
 			std::shared_ptr<Components::Sprite> sprite = m_World->AddComponent<Components::Sprite>(rightWall);
 			sprite->SpriteFile = "Textures/Core/ErrorTexture.png";
 
-			std::shared_ptr<Components::RectangleShape> boxShape = m_World->AddComponent<Components::RectangleShape>(
+			std::shared_ptr<Components::RectangleShape> rectangleShape = m_World->AddComponent<Components::RectangleShape>(rightWall);
-					rightWall);
+			rectangleShape->Dimensions = glm::vec2(0.5f, 20.f);
 
 			std::shared_ptr<Components::Physics> physics = m_World->AddComponent<Components::Physics>(rightWall);
-			physics->Static = true;
+			physics->CollisionType = CollisionType::Type::Static;
 			physics->Category = CollisionLayer::Wall;
 			physics->Mask = static_cast<CollisionLayer::Type>(CollisionLayer::Ball | CollisionLayer::Brick);
-
 			m_World->CommitEntity(rightWall);
 		}
 
 
+
 		//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);

include/Game/BallSystem.h

@@ -8,18 +8,23 @@
 #include "Core/CTemplate.h"
 #include "Physics/CPhysics.h"
 #include "Physics/CCircleShape.h"
+#include "Physics/CRectangleShape.h"
 #include "Physics/EContact.h"
 #include "Rendering/CModel.h"
 #include "Rendering/CPointLight.h"
 #include "Game/CBall.h"
 #include "Game/CPowerUp.h"
 #include "Game/CLife.h"
+#include "Game/CBrick.h"
 #include "Game/ELifeLost.h"
 #include "Game/EComboEvent.h"
 #include "Game/EResetBall.h"
 #include "Game/EMultiBall.h"
 #include "Game/EMultiBallLost.h"
 #include "Game/EGameOver.h"
+#include "Game/EPause.h"
+#include "Game/EHitPad.h"
+#include "Game/EHitLag.h"
 
 namespace dd
 {
@@ -35,8 +40,7 @@ public:
 
     ~BallSystem();
 
-    EventRelay<BallSystem, Events::Contact> m_Contact;
+
-    bool Contact(const Events::Contact &event);
 
     void RegisterComponents(ComponentFactory *cf) override;
 
@@ -75,6 +79,8 @@ public:
     void SetReplaceBall(const bool& replaceBall) { m_ReplaceBall = replaceBall; }
     bool MultiBall() const { return m_MultiBall; }
     void SetMultiBall(const bool& multiBall) { m_MultiBall = multiBall; }
+    bool IsPaused() const { return m_Pause; }
+    void SetPause(const bool& pause) { m_Pause = pause; }
 
 private:
     float m_XMovementMultiplier = 2.f;
@@ -85,18 +91,30 @@ private:
     int m_PastLives = 3;
     bool m_ReplaceBall = false;
     bool m_MultiBall = false;
+    bool m_Pause = false;
+    EntityID m_LastCollision = 999999;
+
+    glm::vec3 m_SavedSpeed;
+    bool m_InitializePause = false;
 
     EntityID m_Ball;
 
+    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::Pause> m_EPause;
+    EventRelay<BallSystem, Events::Contact> m_Contact;
 
+    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 OnPause(const dd::Events::Pause &event);
 };
 
 }

include/Game/CBall.h

@@ -18,6 +18,8 @@ struct Ball : Component
     int Number = 0;
     float Speed = 5.f;
     int Combo = 0;
+    bool Paused = false;
+    glm::vec3 SavedSpeed = glm::vec3(0, 0, 0);
 };
 
 }

include/Game/CBrick.h

@@ -15,8 +15,6 @@ namespace Components
 
 struct Brick : Component
 {
-    int Points = 10;
-    int Hits = 1;
     int Score = 50;
     bool Removed = false;
 };

include/Game/CPad.h

@@ -17,9 +17,6 @@ namespace Components
 
 struct Pad : Component
 {
-    int Lives;
-    int Points;
-
     float SlowdownModifier = 5.f;
     float AccelerationSpeed = 40.f;
     float MaxSpeed = 5.f;

include/Game/EHitLag.h

@@ -0,0 +1,26 @@
+//
+// Created by Administrator on 2015-09-30.
+//
+
+#ifndef DAYDREAM_EHITLAG_H
+#define DAYDREAM_EHITLAG_H
+
+#include "Core/EventBroker.h"
+
+namespace dd
+{
+
+namespace Events
+{
+
+struct HitLag : Event
+{
+    float Time;
+    std::string Type;
+};
+
+}
+
+}
+
+#endif //DAYDREAM_EHITLAG_H

include/Game/EHitPad.h

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

include/Game/EPause.h

@@ -0,0 +1,25 @@
+//
+// Created by Adniklastrator on 2015-09-30.
+//
+
+#ifndef DAYDREAM_EPAUSE_H
+#define DAYDREAM_EPAUSE_H
+
+#include "Core/EventBroker.h"
+
+namespace dd
+{
+
+namespace Events
+{
+
+struct Pause : Event
+{
+    std::string Type;
+};
+
+}
+
+}
+
+#endif //DAYDREAM_EPAUSE_H

include/Game/HitLagSystem.h

@@ -0,0 +1,91 @@
+//
+// Created by Adniklastrator on 2015-09-30.
+//
+
+#ifndef DAYDREAM_HITLAGSYSTEM_H
+#define DAYDREAM_HITLAGSYSTEM_H
+
+
+#include "Core/System.h"
+#include "Core/CTransform.h"
+#include "Core/CTemplate.h"
+#include "Core/EventBroker.h"
+#include "Core/World.h"
+#include "Rendering/CSprite.h"
+#include "Rendering/CModel.h"
+#include "Game/CBrick.h"
+#include "Game/CBall.h"
+#include "Game/CLife.h"
+#include "Game/CPowerUp.h"
+#include "Game/EStageCleared.h"
+#include "Game/ELifeLost.h"
+#include "Game/EResetBall.h"
+#include "Game/EScoreEvent.h"
+#include "Game/EComboEvent.h"
+#include "Game/EMultiBall.h"
+#include "Game/EMultiBallLost.h"
+#include "Game/EPause.h"
+#include "Game/EHitLag.h"
+#include "Game/EGameOver.h"
+#include "Game/ECreatePowerUp.h"
+#include "Game/EPowerUpTaken.h"
+#include "Game/Bricks/CPowerUpBrick.h"
+#include "Physics/CPhysics.h"
+#include "Physics/CCircleShape.h"
+#include "Physics/CRectangleShape.h"
+#include "Physics/ESetImpulse.h"
+#include "Physics/EContact.h"
+#include "Sound/CCollisionSound.h"
+#include "Game/PadSystem.h"
+#include <fstream>
+#include <iostream>
+
+
+namespace dd
+{
+
+namespace Systems
+{
+
+class HitLagSystem : public System
+{
+public:
+    HitLagSystem(World* world, std::shared_ptr<dd::EventBroker> eventBroker)
+    : System(world, eventBroker)
+    { }
+
+    void Initialize() override;
+
+    void Update(double dt) override;
+    void FlipPause();
+
+    bool IsPaused() const { return m_Pause; }
+    void SetPause(const bool& pause) { m_Pause = pause; }
+    bool HitLag() const { return m_HitLag; }
+    void SetHitLag(const bool& hitLag) { m_HitLag = hitLag; }
+    float& HitLagDuration() { return m_HitLagDuration; }
+    void SetHitLagDuration(const float& hitLagDuration) { m_HitLagDuration = hitLagDuration; }
+    float& HitLagTimer() { return m_HitLagTimer; }
+    void SetHitLagTimer(const float& hitLagTimer) { m_HitLagTimer = hitLagTimer; }
+    std::string& CurrentType() { return m_CurrentType; }
+    void SetCurrentType(const std::string& currentType) { m_CurrentType = currentType; }
+private:
+    bool m_Pause;
+    bool m_HitLag;
+    float m_HitLagDuration;
+    float m_HitLagTimer;
+    std::string m_CurrentType;
+
+    dd::EventRelay<HitLagSystem, dd::Events::Pause> m_EPause;
+    dd::EventRelay<HitLagSystem, dd::Events::HitLag> m_EHitLag;
+
+    bool OnPause(const dd::Events::Pause &event);
+    bool OnHitLag(const dd::Events::HitLag &event);
+
+};
+
+}
+
+}
+
+#endif //DAYDREAM_HITLAGSYSTEM_H

include/Game/LevelSystem.h

@@ -21,8 +21,10 @@
 #include "Game/EResetBall.h"
 #include "Game/EScoreEvent.h"
 #include "Game/EComboEvent.h"
+#include "Game/EHitPad.h"
 #include "Game/EMultiBall.h"
 #include "Game/EMultiBallLost.h"
+#include "Game/EPause.h"
 #include "Game/EGameOver.h"
 #include "Game/ECreatePowerUp.h"
 #include "Game/EPowerUpTaken.h"
@@ -44,15 +46,15 @@ namespace Systems
 {
 
     // Me trying things out.
-class Level
+/*class Level
 {
 public:
-    int levelRows;
+    int levelRows = 6;
-    int levelLines;
+    int levelLines = 7;
-    int levelSpaceBetweenBricks;
+    glm::vec2 levelSpaceBetweenBricks = glm::vec2(1, 0.4);
-    int levelSpaceToEdge;
+    float levelSpaceToEdge = 0.25f;
-    int bricks[];
+    std::array<int, 42> bricks;
-};
+};*/
 
 class LevelSystem : public System
 {
@@ -64,10 +66,8 @@ public:
     void Initialize() override;
 
     void CreateBasicLevel(int, int, glm::vec2, float);
-    void SaveLevel(int, int, glm::vec2, int); // Shouldn't be here, but I'm experimenting.
+    void CreateLevel();
-    void LoadLevel(char[20]);
+    void CreateBrick(int, int, glm::vec2, float, int, int);
-    void CreateBrick(int, int, glm::vec2, float, int);
-    void ProcessCollision();
 
     void OnEntityRemoved(EntityID entity);
 
@@ -80,6 +80,8 @@ public:
     void SetRestarting(const bool& restarting) { m_Restarting = restarting; }
     bool Initialized() const { return m_Initialized; }
     void SetInitialized(const bool& initialized) { m_Initialized = initialized; }
+    bool IsPaused() const { return m_Pause; }
+    void SetPause(const bool& pause) { m_Pause = pause; }
     int& MultiBalls() { return m_MultiBalls; }
     void SetMultiBalls(const int& multiBalls) { m_MultiBalls = multiBalls; }
     int& PowerUps() { return m_PowerUps; }
@@ -101,8 +103,13 @@ public:
     void SetNotResettingTheStage(const float& notResettingTheStage) { m_NotResettingTheStage = notResettingTheStage; }
 
 private:
+    bool m_Cleared = false;
     bool m_Restarting = false;
     bool m_Initialized = false;
+    bool m_Pause = false;
+    int m_LooseBricks = 0;
+    int m_CurrentCluster = 2;
+    int m_CurrentLevel = 1;
     int m_MultiBalls = 0;
     int m_PowerUps = 0;
     int m_Score = 0;
@@ -113,6 +120,10 @@ private:
     glm::vec2 m_SpaceBetweenBricks = glm::vec2(1, 0.4);
     float m_NotResettingTheStage = 5.f;
 
+    EntityID m_BrickTemplate;
+
+    std::array<int, 42> m_Bricks;
+
     dd::EventRelay<LevelSystem, dd::Events::Contact> m_EContact;
     dd::EventRelay<LevelSystem, dd::Events::ScoreEvent> m_EScoreEvent;
     dd::EventRelay<LevelSystem, dd::Events::MultiBall> m_EMultiBall;
@@ -120,6 +131,8 @@ private:
     dd::EventRelay<LevelSystem, dd::Events::CreatePowerUp> m_ECreatePowerUp;
     dd::EventRelay<LevelSystem, dd::Events::PowerUpTaken> m_EPowerUpTaken;
     dd::EventRelay<LevelSystem, dd::Events::StageCleared> m_EStageCleared;
+    dd::EventRelay<LevelSystem, dd::Events::Pause> m_EPause;
+    dd::EventRelay<LevelSystem, dd::Events::HitPad> m_EHitPad;
 
     bool OnContact(const dd::Events::Contact &event);
     bool OnScoreEvent(const dd::Events::ScoreEvent &event);
@@ -128,6 +141,10 @@ private:
     bool OnCreatePowerUp(const dd::Events::CreatePowerUp &event);
     bool OnPowerUpTaken(const dd::Events::PowerUpTaken &event);
     bool OnStageCleared(const dd::Events::StageCleared &event);
+    bool OnPause(const dd::Events::Pause &event);
+    bool OnHitPad(const dd::Events::HitPad &event);
+
+    void GetNextLevel();
 };
 
 }

include/Game/PadSystem.h

@@ -28,6 +28,8 @@
 #include "Game/EMultiBall.h"
 #include "Game/EPowerUpTaken.h"
 #include "Game/EStageCleared.h"
+#include "Game/EPause.h"
+#include "Game/EHitLag.h"
 
 
 namespace dd
@@ -63,6 +65,9 @@ public:
     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);
@@ -74,18 +79,21 @@ private:
     Components::Transform* m_Transform = nullptr;
     Components::Pad* m_Pad = nullptr;
 
+    bool m_Pause = false;
+
     dd::EventRelay<PadSystem, dd::Events::KeyDown> m_EKeyDown;
     dd::EventRelay<PadSystem, dd::Events::KeyUp> m_EKeyUp;
     dd::EventRelay<PadSystem, dd::Events::Contact> m_EContact;
     dd::EventRelay<PadSystem, dd::Events::Contact> m_EContactPowerUp;
     dd::EventRelay<PadSystem, dd::Events::StageCleared> m_EStageCleared;
+    dd::EventRelay<PadSystem, dd::Events::Pause> m_EPause;
 
     bool OnKeyDown(const dd::Events::KeyDown &event);
     bool OnKeyUp(const dd::Events::KeyUp &event);
-
     bool OnContact(const dd::Events::Contact &event);
     bool OnContactPowerUp(const dd::Events::Contact &event);
     bool OnStageCleared(const dd::Events::StageCleared &event);
+    bool OnPause(const dd::Events::Pause &event);
 
     class PadSteeringInputController;
     std::array<std::shared_ptr<PadSteeringInputController>, 4> m_PadInputControllers;

include/Physics/CCircleShape.h

@@ -10,7 +10,7 @@ namespace Components
 
 struct CircleShape : public Component
 {
-    // Circles are circles
+    float Radius = 1.f;
 };
 
 }

include/Physics/CPhysics.h

@@ -18,15 +18,30 @@ enum Type
     Wall = 1 << 6
 };
 }
-namespace Components
-{
 
-struct Physics: public Component
+namespace CollisionType
 {
-    bool Static = true;
+enum Type
-    bool Calculate = false;
+{
-    float GravityScale = 0.f;
+    Static = 0,
-    CollisionLayer::Type Category = CollisionLayer::Type::Other;
+    Kinematic = 1,
+    Dynamic = 2,
+};
+}
+
+
+    namespace Components
+    {
+
+        struct Physics: public Component
+        {
+            CollisionType::Type CollisionType = CollisionType::Type::Static;
+
+            bool Calculate = false;
+            float GravityScale = 0.f;
+
+
+            CollisionLayer::Type Category = CollisionLayer::Type::Other;
 	CollisionLayer::Type Mask =	static_cast<CollisionLayer::Type>(
 		CollisionLayer::Pad
 		| CollisionLayer::Ball
@@ -36,7 +51,7 @@ struct Physics: public Component
 		| CollisionLayer::Wall
 		| CollisionLayer::Other
 	);
-};
+        };
 
 }
 }

include/Physics/CRectangleShape.h

@@ -10,7 +10,7 @@ namespace Components
 
 struct RectangleShape : public Component
 {
-
+    glm::vec2 Dimensions = glm::vec2(1.f, 1.f);
 };
 
 }

include/Physics/PhysicsSystem.h

@@ -3,159 +3,132 @@
 
 #include <unordered_map>
 
+#include <Box2D/Box2D.h>
+
 #include "Core/System.h"
 #include "Core/World.h"
-#include "CRectangleShape.h"
-#include "Physics/CPhysics.h"
-#include <Box2D/Box2D.h>
-#include "Core/CTransform.h"
-#include "Transform/TransformSystem.h"
-#include "Physics/EContact.h"
-#include "Physics/ESetImpulse.h"
-#include "Physics/CCircleShape.h"
 #include "Core/EventBroker.h"
-#include "Game/CPad.h"
-#include "Physics/CWaterVolume.h"
-#include "Game/CBall.h"
-#include "Rendering/CSprite.h"
-#include "Physics/CParticle.h"
-#include "Physics/CParticleEmitter.h"
 #include "Core/CTemplate.h"
 
+#include "Physics/CRectangleShape.h"
+#include "Physics/CCircleShape.h"
+#include "Physics/CPhysics.h"
+#include "Physics/CWaterVolume.h"
+#include "Core/CTransform.h"
+#include "Transform/TransformSystem.h"
+#include "CRectangleShape.h"
+#include "Physics/CPhysics.h"
+#include "Physics/EContact.h"
+#include "Physics/ESetImpulse.h"
+#include "Physics/CParticle.h"
+#include "Physics/CCircleShape.h"
+#include "Physics/CParticleEmitter.h"
+#include "Game/CPad.h"
+#include "Game/CPad.h"
+#include "Game/CBall.h"
+#include "Transform/TransformSystem.h"
+#include "Rendering/CSprite.h"
+#include "Core/CTemplate.h"
+#include "Game/EPause.h"
 
 namespace dd
 {
 
-namespace Systems
+    namespace Systems
-{
-
-
-class PhysicsSystem : public System
-{
-    friend class ContractListener;
-
-public:
-    PhysicsSystem(World* world, std::shared_ptr<dd::EventBroker> eventBroker)
-    : System(world, eventBroker) {}
-
-    ~PhysicsSystem();
-
-    EventRelay<PhysicsSystem, Events::SetImpulse> m_SetImpulse;
-    bool SetImpulse(const Events::SetImpulse &event);
-
-    void RegisterComponents(ComponentFactory* cf) override;
-    void Initialize() override;
-
-    // Called once per system every tick
-    void Update(double dt) override;
-    // Called once for every entity in the world every tick
-    void UpdateEntity(double dt, EntityID entity, EntityID parent) override;
-
-    // Called when components are committed to an entity
-    void OnEntityCommit(EntityID entity) override;
-
-    // Called when an entity is removed
-    void OnEntityRemoved(EntityID entity) override;
-
-private:
-    b2Vec2 m_Gravity;
-    b2World* m_PhysicsWorld;
-    double m_TimeStep;
-    double m_Accumulator;
-
-    int m_VelocityIterations, m_PositionIterations;
-
-    std::unordered_map<EntityID, b2Body*> m_EntitiesToBodies;
-    std::unordered_map<b2Body*, EntityID> m_BodiesToEntities;
-
-    void CreateBody(EntityID entity);
-
-    std::vector<b2ParticleSystem*> m_ParticleSystem;
-    std::vector<b2ParticleGroup*> t_ParticleGroup;
-
-    std::vector<std::unordered_map<EntityID, const b2ParticleHandle*>> m_EntitiesToParticleHandle;
-    std::vector<std::unordered_map<const b2ParticleHandle*, EntityID>> m_ParticleHandleToEntities;
-
-    b2ParticleSystem* CreateParticleSystem(float radius, float gravityScale);
-    void InitializeWater();
-    void CreateParticleGroup(EntityID entity);
-    void CreateParticleEmitter(EntityID entity);
-    void UpdateParticleEmitters(double dt); //TODO: Remove them and particles if needed.
-
-    //TODO: Fill struct with info needed.
-    struct ParticleEmitter
     {
-        std::vector<b2ParticleSystem*> ParticleSystem;
-        std::vector<EntityID> Emitter;
-        std::vector<EntityID> ParticleTemplate;
-    };
-    ParticleEmitter m_ParticleEmitters;
 
-    //TODO: Struct med listor är bättre än en lista med structs
+        class PhysicsSystem : public System
-    struct Impulse
-    {
-        b2Body* Body;
-        b2Vec2 Vector;
-        b2Vec2 Point;
-    };
-    std::list<Impulse> m_Impulses;
-
-
-
-    class ContactListener : public b2ContactListener
-    {
-    public:
-        ContactListener(PhysicsSystem* physicsSystem)
-                : m_PhysicsSystem(physicsSystem) { }
-
-        void BeginContact(b2Contact* contact)
         {
-            b2WorldManifold worldManifold;
+            friend class ContractListener;
 
-            contact->GetWorldManifold(&worldManifold);
+        public:
+            PhysicsSystem(World* world, std::shared_ptr<dd::EventBroker> eventBroker)
+                    : System(world, eventBroker) { }
 
-            Events::Contact e;
+            ~PhysicsSystem();
-            e.Entity1 = m_PhysicsSystem->m_BodiesToEntities[contact->GetFixtureA()->GetBody()];
-            e.Entity2 = m_PhysicsSystem->m_BodiesToEntities[contact->GetFixtureB()->GetBody()];
-            e.Normal = glm::normalize(glm::vec2(contact->GetManifold()->localNormal.x, contact->GetManifold()->localNormal.y));
-            e.SignificantNormal = glm::normalize((glm::abs(e.Normal.x) > glm::abs(e.Normal.y)) ? glm::vec2(e.Normal.x, 0) : glm::vec2(0, e.Normal.y));
 
-            m_PhysicsSystem->EventBroker->Publish(e);
+            void RegisterComponents(ComponentFactory* cf) override;
-        }
+            void Initialize() override;
-        void EndContact(b2Contact* contact)
+            void Update(double dt) override;
-        {
+            void UpdateEntity(double dt, EntityID entity, EntityID parent) override;
+            void OnEntityCommit(EntityID entity) override;
+            void OnEntityRemoved(EntityID entity) override;
 
-        }
+        private:
-        void PreSolve(b2Contact* contact, const b2Manifold* oldManifold)
+            struct Impulse
-        {
+            {
-            EntityID entityA = m_PhysicsSystem->m_BodiesToEntities[contact->GetFixtureA()->GetBody()];
+                b2Body* Body;
-            EntityID entityB = m_PhysicsSystem->m_BodiesToEntities[contact->GetFixtureB()->GetBody()];
+                b2Vec2 Impulse;
-
+                b2Vec2 Point;
-            auto physicsComponentA = m_PhysicsSystem->m_World->GetComponent<Components::Physics>(entityA);
+            };
-            auto physicsComponentB = m_PhysicsSystem->m_World->GetComponent<Components::Physics>(entityB);
+            bool m_Pause = false;
-
-            if (physicsComponentA != nullptr && physicsComponentB != nullptr) {
-                if (physicsComponentA->Calculate || physicsComponentB->Calculate) {
-                    // Turn of collisions
-                    contact->SetEnabled(false);
-                }
-            }
 
 
-        }
+            b2Vec2 m_Gravity = b2Vec2(0.f, -9.82f);
-        void PostSolve(b2Contact* contact, const b2ContactImpulse* impulse)
+            b2World* m_PhysicsWorld = nullptr;
-        {
+            float m_TimeStep = 1.f/60.f;
+            float m_Accumulator = 0.f;
+            int m_VelocityIterations = 6;
+            int m_PositionIterations = 2;
 
-        }
+            std::vector<b2ParticleSystem*> m_ParticleSystem;
+            std::vector<b2ParticleGroup*> t_ParticleGroup;
 
-    private:
+            std::vector<std::unordered_map<EntityID, const b2ParticleHandle*>> m_EntitiesToParticleHandle;
-        PhysicsSystem* m_PhysicsSystem;
+            std::vector<std::unordered_map<const b2ParticleHandle*, EntityID>> m_ParticleHandleToEntities;
-    };
+            std::unordered_map<EntityID, b2Body*> m_EntitiesToBodies;
+            std::unordered_map<b2Body*, EntityID> m_BodiesToEntities;
 
-    ContactListener* m_ContactListener;
-};
 
-}
+
+            void CreateBody(EntityID entity);
+            void SyncEntitiesWithBodies();
+            void SyncBodiesWithEntities();
+            void InitializeWater();
+            void CreateParticleGroup(EntityID entity);
+
+            b2ParticleSystem* CreateParticleSystem(float radius, float gravityScale);
+            void CreateParticleEmitter(EntityID entity);
+            void UpdateParticleEmitters(double dt); //TODO: Remove them and particles if needed.
+
+            EventRelay<PhysicsSystem, Events::SetImpulse> m_SetImpulse;
+            bool SetImpulse(const Events::SetImpulse &event);
+            dd::EventRelay<PhysicsSystem, dd::Events::Pause> m_EPause;
+            bool OnPause(const dd::Events::Pause &event);
+
+            //TODO: Fill struct with info needed.
+            struct ParticleEmitter
+            {
+                std::vector<b2ParticleSystem*> ParticleSystem;
+                std::vector<EntityID> ParticleEmitter;
+                std::vector<EntityID> ParticleTemplate;
+            };
+            ParticleEmitter m_ParticleEmitters;
+
+            std::list<Impulse> m_Impulses;
+
+
+
+            class ContactListener : public b2ContactListener
+            {
+            public:
+                ContactListener(PhysicsSystem* physicsSystem)
+                        : m_PhysicsSystem(physicsSystem) { }
+
+                void BeginContact(b2Contact* contact);
+                void EndContact(b2Contact* contact);
+                void PreSolve(b2Contact* contact, const b2Manifold* oldManifold);
+                void PostSolve(b2Contact* contact, const b2ContactImpulse* impulse);
+
+            private:
+                PhysicsSystem* m_PhysicsSystem;
+            };
+
+            ContactListener* m_ContactListener;
+        };
+
+    }
+
 }
 
-#endif //DAYDREAM_PHYSICSSYSTEM_H
+#endif

src/game/Game/BallSystem.cpp

@@ -18,26 +18,42 @@ void dd::Systems::BallSystem::Initialize()
     EVENT_SUBSCRIBE_MEMBER(m_EMultiBallLost, &BallSystem::OnMultiBallLost);
     EVENT_SUBSCRIBE_MEMBER(m_EResetBall, &BallSystem::OnResetBall);
     EVENT_SUBSCRIBE_MEMBER(m_EMultiBall, &BallSystem::OnMultiBall);
+    EVENT_SUBSCRIBE_MEMBER(m_EPause, &BallSystem::OnPause);
 
-    auto ent = m_World->CreateEntity();
+    //OctoBall
-    std::shared_ptr<Components::Transform> transform = m_World->AddComponent<Components::Transform>(ent);
+    {
-    transform->Position = glm::vec3(-0.f, 50.f, -10.f);
+        auto ent = m_World->CreateEntity();
-    transform->Scale = glm::vec3(0.5f, 0.5f, 0.5f);
+        std::shared_ptr<Components::Transform> transform = m_World->AddComponent<Components::Transform>(ent);
-    transform->Velocity = glm::vec3(0.0f, 0.f, 0.f);
+        transform->Position = glm::vec3(-0.f, 50.26f, -10.f);
-    auto model = m_World->AddComponent<Components::Model>(ent);
+        transform->Scale = glm::vec3(0.2f, 0.2f, 0.2f);
-    model->ModelFile = "Models/Test/Ball/Ballopus.obj";
+        transform->Velocity = glm::vec3(0.f, 0.f, 0.f);
-    std::shared_ptr<Components::CircleShape> circleShape = m_World->AddComponent<Components::CircleShape>(ent);
+        auto model = m_World->AddComponent<Components::Model>(ent);
-    std::shared_ptr<Components::Ball> ball = m_World->AddComponent<Components::Ball>(ent);
+        model->ModelFile = "Models/Test/Ball/Sid.obj";
-    ball->Speed = 5.f;
+        std::shared_ptr<Components::CircleShape> circleShape = m_World->AddComponent<Components::CircleShape>(ent);
-    std::shared_ptr<Components::Physics> physics = m_World->AddComponent<Components::Physics>(ent);
+        circleShape->Radius = 0.2f;
-    std::shared_ptr<Components::Template> ballTemplate = m_World->AddComponent<Components::Template>(ent);
+        std::shared_ptr<Components::Ball> ball = m_World->AddComponent<Components::Ball>(ent);
-    physics->Static = false;
+        ball->Speed = 5.f;
-    physics->Category = CollisionLayer::Type::Ball;
+        std::shared_ptr<Components::Physics> physics = m_World->AddComponent<Components::Physics>(ent);
-    physics->Mask = static_cast<CollisionLayer::Type>(CollisionLayer::Pad | CollisionLayer::Brick | CollisionLayer::Wall);
+        std::shared_ptr<Components::Template> ballTemplate = m_World->AddComponent<Components::Template>(ent);
-    physics->Calculate = true;
+    physics->CollisionType = CollisionType::Type::Dynamic;
-    m_World->CommitEntity(ent);
+        physics->Category = CollisionLayer::Type::Ball;
+        physics->Mask = static_cast<CollisionLayer::Type>(CollisionLayer::Type::Pad | CollisionLayer::Type::Brick | CollisionLayer::Type::Wall);
+        physics->Calculate = true;
 
-    SetBall(ent);
+        //auto plight = m_World->AddComponent<Components::PointLight>(ent);
+        //plight->Radius = 2.f;
+
+        m_World->CommitEntity(ent);
+
+        SetBall(ent);
+
+        auto ent2 = CreateBall();
+        auto transform2 = m_World->GetComponent<Components::Transform>(ent2);
+        transform2->Position = glm::vec3(-0.f, 0.26f, -10.f);
+        transform2->Velocity = glm::vec3(0.0f, -10.f, 0.f);
+
+        m_World->CommitEntity(ent2);
+    }
 
     for (int i = 0; i < Lives(); i++) {
         CreateLife(i);
@@ -52,15 +68,41 @@ void dd::Systems::BallSystem::Update(double dt)
         Events::GameOver e;
         EventBroker->Publish(e);
     }
+    ResolveContacts();
 }
 
 void dd::Systems::BallSystem::UpdateEntity(double dt, EntityID entity, EntityID parent)
 {
+    //TODO: When the ball collides with 2 bricks on the same frame it is reflected and then reflected again, make it reflect only once like a list or something?
+
+    auto ballComponent = m_World->GetComponent<Components::Ball>(entity);
+    if (IsPaused()) {
+        if (ballComponent != nullptr) {
+            auto transform = m_World->GetComponent<Components::Transform>(entity);
+
+            if (!ballComponent->Paused) {
+                ballComponent->Paused = true;
+                ballComponent->SavedSpeed = transform->Velocity;
+                transform->Velocity = glm::vec3(0, 0, 0);
+            }
+        }
+        return;
+    } else {
+        if (ballComponent != nullptr) {
+            auto transform = m_World->GetComponent<Components::Transform>(entity);
+
+            if (ballComponent->Paused) {
+                transform->Velocity = ballComponent->SavedSpeed;
+                ballComponent->Paused = false;
+            }
+        }
+    }
+
     auto templateCheck = m_World->GetComponent<Components::Template>(entity);
     if (templateCheck != nullptr){ return; }
-    auto ballComponent = m_World->GetComponent<Components::Ball>(entity);
+
     if (ballComponent != nullptr) {
-        if (ReplaceBall() == true) {
+        if (ReplaceBall()) {
             SetReplaceBall(false);
 
             auto transform = m_World->GetComponent<Components::Transform>(entity);
@@ -78,10 +120,6 @@ void dd::Systems::BallSystem::UpdateEntity(double dt, EntityID entity, EntityID
         }
         if (transformBall->Position.y < -EdgeY() - 4) {
             if (MultiBalls() != 0) {
-//                m_World->RemoveComponent<Components::Ball>(entity);
-//                m_World->RemoveComponent<Components::Transform>(entity);
-//                m_World->RemoveComponent<Components::CircleShape>(entity);
-//                m_World->RemoveComponent<Components::Physics>(entity);
                 m_World->RemoveEntity(entity);
                 Events::MultiBallLost e;
                 EventBroker->Publish(e);
@@ -93,7 +131,8 @@ void dd::Systems::BallSystem::UpdateEntity(double dt, EntityID entity, EntityID
                 EventBroker->Publish(e);
                 return;
             }
-        } else if (transformBall->Position.x > EdgeX()) {
+        } //Removing this made the wall collisions work again
+         /*else if (transformBall->Position.x > EdgeX()) {
             if (transformBall->Velocity.x > 0) {
                 glm::vec2 reflectedVelocity = glm::reflect(glm::vec2(transformBall->Velocity.x, transformBall->Velocity.y), glm::vec2(1, 0));
                 transformBall->Velocity = glm::vec3(reflectedVelocity, 0.f);
@@ -108,15 +147,13 @@ void dd::Systems::BallSystem::UpdateEntity(double dt, EntityID entity, EntityID
                 glm::vec2 reflectedVelocity = glm::reflect(glm::vec2(transformBall->Velocity.x, transformBall->Velocity.y), glm::vec2(0, 1));
                 transformBall->Velocity = glm::vec3(reflectedVelocity, 0.f);
             }
-        }
+        }*/
     }
 
     if (Lives() != PastLives()) {
         auto life = m_World->GetComponent<Components::Life>(entity);
         if (life != nullptr) {
             if (life->Number + 1 == PastLives()) {
-                m_World->RemoveComponent<Components::Life>(entity);
-                m_World->RemoveComponent<Components::Transform>(entity);
                 m_World->RemoveEntity(entity);
                 SetPastLives(Lives());
             }
@@ -132,6 +169,20 @@ void dd::Systems::BallSystem::UpdateEntity(double dt, EntityID entity, EntityID
     }
 }
 
+bool dd::Systems::BallSystem::OnPause(const dd::Events::Pause &event)
+{
+    if (event.Type != "BallSystem" && event.Type != "All") {
+        return false;
+    }
+
+    if (IsPaused()) {
+        SetPause(false);
+    } else {
+        SetPause(true);
+    }
+    return true;
+}
+
 void dd::Systems::BallSystem::OnEntityCommit(EntityID entity)
 {
 
@@ -178,12 +229,36 @@ bool dd::Systems::BallSystem::Contact(const Events::Contact &event)
         //TODO: Add support for power-up collisions
     }
 
+    auto brick = m_World->GetComponent<Components::Brick>(otherEntitiy);
+    if (brick != nullptr) {
+        auto transform = m_World->GetComponent<Components::Transform>(otherEntitiy);
+        auto physics = m_World->GetComponent<Components::Physics>(otherEntitiy);
+        auto rectangle = m_World->GetComponent<Components::RectangleShape>(otherEntitiy);
+        int hey = 5;
+    }
+
+    /*if (otherEntitiy == m_LastCollision) {
+
+        if (brick != nullptr) {
+            return false;
+        }
+    } else {
+        m_LastCollision = otherEntitiy;
+    }*/
+
     //if this is a brick thats dead do not collide :)
 
     auto ballTransform = m_World->GetComponent<Components::Transform>(ballEntity);
     glm::vec2 ballVelocity = glm::vec2(ballTransform->Velocity.x, ballTransform->Velocity.y);
 
     if (m_World->GetProperty<std::string>(otherEntitiy, "Name") == "Pad"){
+        Events::HitPad e;
+        EventBroker->Publish(e);
+       // Events::HitLag el;
+       // el.Time = 0.1f;
+        //el.Type = "All";
+       // EventBroker->Publish(el);
+
         auto padTransform = m_World->GetComponent<Components::Transform>(otherEntitiy);
         float x = (ballTransform->Position.x - padTransform->Position.x) * XMovementMultiplier();
 
@@ -198,39 +273,61 @@ bool dd::Systems::BallSystem::Contact(const Events::Contact &event)
         //std::cout << "Combo: " << ballComponent->Combo << std::endl;
     }
     else {
-        glm::vec2 reflectedVelocity = glm::reflect(ballVelocity, event.Normal);
+        auto it = m_Contacts.find(ballEntity);
-        ballTransform->Velocity = glm::vec3(reflectedVelocity, 0.f);
+        if (it == m_Contacts.end()) {
+            std::list<glm::vec2> normalList;
+            normalList.push_back(event.Normal);
+            m_Contacts[ballEntity] = normalList;
+        } else {
+            std::list<glm::vec2> normalList = it->second;
+            normalList.push_back(event.Normal);
+            m_Contacts[ballEntity] = normalList;
+        }
+
+        //glm::vec2 reflectedVelocity = glm::reflect(ballVelocity, event.Normal);
+        //ballTransform->Velocity = glm::vec3(reflectedVelocity, 0.f);
     }
 
     return true;
 }
 
+
+void dd::Systems::BallSystem::ResolveContacts()
+{
+
+    for (auto c : m_Contacts) {
+        int count = 0;
+        EntityID entity = c.first;
+        std::list<glm::vec2> contactNormals = c.second;
+        glm::vec2 finalNormal = glm::vec2(0.f);
+        for (auto it = contactNormals.begin(); it != contactNormals.end(); it++) {
+            finalNormal = finalNormal + (*it);
+            count++;
+        }
+        finalNormal = glm::normalize(finalNormal);
+
+        if (count > 1) {
+            LOG_INFO("MultiCollision %i", count);
+        }
+
+        auto transform = m_World->GetComponent<Components::Transform>(entity);
+        glm::vec2 velocity = glm::vec2(transform->Velocity.x, transform->Velocity.y);
+        glm::vec2 reflectedVelocity = glm::reflect(velocity, finalNormal);
+        transform->Velocity = glm::vec3(reflectedVelocity, 0.f);
+
+    }
+
+
+    m_Contacts.clear();
+}
+
 EntityID dd::Systems::BallSystem::CreateBall()
 {
     auto ent = m_World->CloneEntity(Ball());
 
     m_World->RemoveComponent<Components::Template>(ent);
 
-   /* auto ent = m_World->CreateEntity();
+    //m_World->CommitEntity(ent);
-    std::shared_ptr<Components::Transform> transform = m_World->AddComponent<Components::Transform>(ent);
-    transform->Position = glm::vec3(0.5f, 0.26f, -10.f);
-    transform->Scale = glm::vec3(0.5f, 0.5f, 0.5f);
-    auto model = m_World->AddComponent<Components::Model>(ent);
-    model->ModelFile = "Models/Test/Ball/Ballopus.obj";
-    //auto pointlight = m_World->AddComponent<Components::PointLight>(ent);
-    std::shared_ptr<Components::CircleShape> circleShape = m_World->AddComponent<Components::CircleShape>(ent);
-    std::shared_ptr<Components::Ball> cball = m_World->AddComponent<Components::Ball>(ent);
-    std::shared_ptr<Components::Physics> physics = m_World->AddComponent<Components::Physics>(ent);
-    physics->Static = false;
-    physics->Category = CollisionLayer::Type::Ball;
-    physics->Mask = CollisionLayer::Type::Pad | CollisionLayer::Type::Brick | CollisionLayer::Type::Wall;
-    physics->Calculate = true;
-    cball->Speed = 5.f;
-
-    auto plight = m_World->AddComponent<Components::PointLight>(ent);
-    plight->Radius = 2.f;*/
-
-    m_World->CommitEntity(ent);
 
     return ent;
 }
@@ -297,3 +394,4 @@ bool dd::Systems::BallSystem::OnMultiBall(const dd::Events::MultiBall &event)
 
     return true;
 }
+

src/game/Game/HitLagSystem.cpp

@@ -0,0 +1,57 @@
+//
+// Created by Adniklastrator on 2015-09-30.
+//
+
+#include "PrecompiledHeader.h"
+#include "Game/HitLagSystem.h"
+
+void dd::Systems::HitLagSystem::Initialize()
+{
+    EVENT_SUBSCRIBE_MEMBER(m_EPause, &HitLagSystem::OnPause);
+    EVENT_SUBSCRIBE_MEMBER(m_EHitLag, &HitLagSystem::OnHitLag);
+}
+
+void dd::Systems::HitLagSystem::Update(double dt)
+{
+    if (IsPaused()) {
+        if (HitLag()) {
+            SetHitLagTimer(HitLagTimer() += dt);
+            std::cout << HitLagTimer() << std::endl;
+            if (HitLagDuration() < HitLagTimer()) {
+                SetHitLagTimer(0);
+                SetHitLag(false);
+                FlipPause();
+            }
+        }
+        return;
+    }
+}
+
+void dd::Systems::HitLagSystem::FlipPause()
+{
+    Events::Pause e;
+    e.Type = CurrentType();
+    EventBroker->Publish(e);
+}
+
+bool dd::Systems::HitLagSystem::OnPause(const dd::Events::Pause &event)
+{
+    if (IsPaused()) {
+        SetPause(false);
+    } else {
+        SetPause(true);
+    }
+    return true;
+}
+
+bool dd::Systems::HitLagSystem::OnHitLag(const dd::Events::HitLag &event)
+{
+    if (HitLag()) {
+        FlipPause();
+    }
+    SetHitLag(true);
+    SetCurrentType(event.Type);
+    FlipPause();
+    SetHitLagDuration(event.Time);
+    return true;
+}

src/game/Game/LevelSystem.cpp

@@ -16,6 +16,30 @@ void dd::Systems::LevelSystem::Initialize()
     EVENT_SUBSCRIBE_MEMBER(m_EMultiBallLost, &LevelSystem::OnMultiBallLost);
     EVENT_SUBSCRIBE_MEMBER(m_EPowerUpTaken, &LevelSystem::OnPowerUpTaken);
     EVENT_SUBSCRIBE_MEMBER(m_EStageCleared, &LevelSystem::OnStageCleared);
+    EVENT_SUBSCRIBE_MEMBER(m_EPause, &LevelSystem::OnPause);
+    EVENT_SUBSCRIBE_MEMBER(m_EHitPad, &LevelSystem::OnHitPad);
+
+    m_BrickTemplate = m_World->CreateEntity();
+    std::shared_ptr<Components::Transform> transform = m_World->AddComponent<Components::Transform>(m_BrickTemplate);
+    auto model = m_World->AddComponent<Components::Model>(m_BrickTemplate);
+    std::shared_ptr<Components::Brick> cBrick = m_World->AddComponent<Components::Brick>(m_BrickTemplate);
+    std::shared_ptr<Components::RectangleShape> cRec = m_World->AddComponent<Components::RectangleShape>(m_BrickTemplate);
+    cRec->Dimensions = glm::vec2(0.9f, 0.35f);
+    std::shared_ptr<Components::Physics> cPhys = m_World->AddComponent<Components::Physics>(m_BrickTemplate);
+    std::shared_ptr<Components::Template> cTemplate = m_World->AddComponent<Components::Template>(m_BrickTemplate);
+    cPhys->CollisionType = CollisionType::Type::Dynamic;
+    cPhys->GravityScale = 0.f;
+    cPhys->Category = CollisionLayer::Type::Brick;
+    cPhys->Mask = CollisionLayer::Type::Ball;
+
+    model->ModelFile = "Models/Brick/TurquoiseBrick.obj";
+    transform->Position = glm::vec3(50, 50, -10);
+
+    //sound
+    auto collisionSound = m_World->AddComponent<Components::CollisionSound>(m_BrickTemplate);
+    collisionSound->FilePath = "Sounds/Brick/shortbrickbreak.wav";
+
+    m_World->CommitEntity(m_BrickTemplate);
 
     return;
 }
@@ -23,54 +47,74 @@ void dd::Systems::LevelSystem::Initialize()
 void dd::Systems::LevelSystem::Update(double dt)
 {
     if (!m_Initialized) {
-        CreateBasicLevel(Rows(), Lines(), SpaceBetweenBricks(), SpaceToEdge());
+        //CreateBasicLevel(Rows(), Lines(), SpaceBetweenBricks(), SpaceToEdge());
+        GetNextLevel();
+        CreateLevel();
         m_Initialized = true;
     }
 }
 
 void dd::Systems::LevelSystem::UpdateEntity(double dt, EntityID entity, EntityID parent)
 {
+    if (IsPaused()) {
+        return;
+    }
     auto templateCheck = m_World->GetComponent<Components::Template>(entity);
     if (templateCheck != nullptr){ return; }
 
-    auto ball = m_World->GetComponent<Components::Ball>(entity);
+    auto brick = m_World->GetComponent<Components::Brick>(entity);
-    SetNotResettingTheStage(NotResettingTheStage() + 0.01 * dt);
+    if (brick != nullptr) {
+        auto transform = m_World->GetComponent<Components::Transform>(entity);
+        //Removes bricks that falls out of the stage.
+        if (transform->Position.y < -10) {
+            m_LooseBricks--;
+            std::cout << m_LooseBricks << std::endl;
+            m_World->RemoveEntity(entity);
+        }
+    }
 
-    if (NumberOfBricks() <= 0 && Restarting() == false) {
+    auto ball = m_World->GetComponent<Components::Ball>(entity);
+
+    if (NumberOfBricks() <= 0 && m_LooseBricks <= 0 && !Restarting()) {
         if (MultiBalls() <= 0 && PowerUps() <= 0) {
-            if (NotResettingTheStage() > 5) {
+            Events::StageCleared ec;
-                SetRestarting(true);
+            EventBroker->Publish(ec);
-                Events::ResetBall e;
+            //CreateBasicLevel(Rows(), Lines(), SpaceBetweenBricks(), SpaceToEdge());
-                EventBroker->Publish(e);
-                Events::ScoreEvent es;
-                es.Score = 500;
-                EventBroker->Publish(es);
-                Events::StageCleared ec;
-                EventBroker->Publish(ec);
-                SetNotResettingTheStage(0);
-                //CreateBasicLevel(Rows(), Lines(), SpaceBetweenBricks(), SpaceToEdge());
-            }
         } else {
             if (ball != nullptr && MultiBalls() > 0) {
                 SetMultiBalls(MultiBalls()-1);
-                m_World->RemoveComponent<Components::Ball>(entity);
-                m_World->RemoveComponent<Components::Transform>(entity);
-                m_World->RemoveComponent<Components::CircleShape>(entity);
-                m_World->RemoveComponent<Components::Physics>(entity);
                 m_World->RemoveEntity(entity);
             } else {
                 auto powerUp = m_World->GetComponent<Components::PowerUp>(entity);
                 if (powerUp != nullptr) {
                     SetPowerUps(PowerUps() - 1);
-                    m_World->RemoveComponent<Components::PowerUp>(entity);
-                    m_World->RemoveComponent<Components::Transform>(entity);
                     m_World->RemoveEntity(entity);
+                } else {
+                    if (brick != nullptr) {
+                        m_LooseBricks--;
+                        std::cout << m_LooseBricks << std::endl;
+                        m_World->RemoveEntity(entity);
+                    }
                 }
             }
         }
     }
 }
 
+bool dd::Systems::LevelSystem::OnPause(const dd::Events::Pause &event)
+{
+    if (event.Type != "LevelSystem" && event.Type != "All") {
+        return false;
+    }
+
+    if (IsPaused()) {
+        SetPause(false);
+    } else {
+        SetPause(true);
+    }
+    return true;
+}
+
 void dd::Systems::LevelSystem::CreateBasicLevel(int rows, int lines, glm::vec2 spacesBetweenBricks, float spaceToEdge)
 {
     SetNumberOfBricks(rows * lines);
@@ -79,7 +123,7 @@ void dd::Systems::LevelSystem::CreateBasicLevel(int rows, int lines, glm::vec2 s
     for (int i = 0; i < rows; i++) {
         num--;
         for (int j = 0; j < Lines(); j++) {
-            CreateBrick(i, j, spacesBetweenBricks, spaceToEdge, num);
+            CreateBrick(i, j, spacesBetweenBricks, spaceToEdge, num, 1);
         }
         if (num == 1)
             num = Lines();
@@ -90,60 +134,55 @@ void dd::Systems::LevelSystem::CreateBasicLevel(int rows, int lines, glm::vec2 s
     return;
 }
 
-void dd::Systems::LevelSystem::CreateBrick(int row, int line, glm::vec2 spacesBetweenBricks, float spaceToEdge, int num)
+void dd::Systems::LevelSystem::CreateLevel()
 {
-    auto brick = m_World->CreateEntity();
+    std::cout << "Loading level: " << m_CurrentLevel << std::endl;
-    std::shared_ptr<Components::Transform> transform = m_World->AddComponent<Components::Transform>(brick);
+    SetNumberOfBricks(Rows() * Lines());
-    auto model = m_World->AddComponent<Components::Model>(brick);
+    int num = Lines();
-    std::shared_ptr<Components::Brick> cBrick = m_World->AddComponent<Components::Brick>(brick);
+    int getter = 0;
-    std::shared_ptr<Components::RectangleShape> cRec = m_World->AddComponent<Components::RectangleShape>(brick);
-    std::shared_ptr<Components::Physics> cPhys = m_World->AddComponent<Components::Physics>(brick);
-    cPhys->Static = false;
-    cPhys->GravityScale = 0.f;
-    cPhys->Category = CollisionLayer::Type::Brick;
-    cPhys->Mask = CollisionLayer::Type::Ball;
 
-    /*std::string fileName = "Textures/Bricks/";
+    for (int i = 0; i < Rows(); i++) {
-    fileName.append(std::to_string(num));
+        num--;
-    fileName.append(".png");*/
+        for (int j = 0; j < Lines(); j++) {
-    //sprite->SpriteFile =  fileName;
+            CreateBrick(i, j, SpaceBetweenBricks(), SpaceToEdge(), num, m_Bricks[getter]);
-    model->ModelFile = "Models/Test/Brick/Brick.obj";
+            getter++;
-    if ((line == 1 && row == 4) || (line == 3 && row == 2) || (line == 5 && row == 2)) {
+        }
+        if (num == 1)
+            num = Lines();
+    }
+    m_LooseBricks = NumberOfBricks();
+    SetRestarting(false);
+}
+
+void dd::Systems::LevelSystem::CreateBrick(int row, int line, glm::vec2 spacesBetweenBricks, float spaceToEdge, int num, int typeInt)
+{
+    if (typeInt == 0) {
+        SetNumberOfBricks(NumberOfBricks() - 1);
+        return;
+    }
+    auto brick = m_World->CloneEntity(m_BrickTemplate);
+    m_World->RemoveComponent<Components::Template>(brick);
+    auto transform = m_World->GetComponent<Components::Transform>(brick);
+    auto cBrick = m_World->GetComponent<Components::Brick>(brick);
+    auto cPhys = m_World->GetComponent<Components::Physics>(brick);
+
+    if (typeInt == 2) {
         std::shared_ptr<Components::PowerUpBrick> cPow = m_World->AddComponent<Components::PowerUpBrick>(brick);
+        auto model = m_World->GetComponent<Components::Model>(brick);
+        model->ModelFile = "Models/Brick/IceBrick.obj";
     }
     float x = line * spacesBetweenBricks.x;
     float y = row * spacesBetweenBricks.y;
-    transform->Scale = glm::vec3(0.8, 0.2, 0.2);
     transform->Position = glm::vec3(x - 3, 5 - spaceToEdge - y , -10.f);
     cBrick->Score = 10 * num;
 
-    //sound
-    auto collisionSound = m_World->AddComponent<Components::CollisionSound>(brick);
-    collisionSound->FilePath = "Sounds/Brick/shortbrickbreak.wav";
-
     m_World->CommitEntity(brick);
     return;
 }
 
-void dd::Systems::LevelSystem::ProcessCollision()
-{
-    // Like, go into brick component and check what it does upon collision. Maybe not done here?
-    return;
-}
-
 void dd::Systems::LevelSystem::OnEntityRemoved(EntityID entity)
 {
-    /*auto brick = m_World->GetComponent<Components::Brick>(entity);
+
-    if (brick != nullptr) {
-        SetNumberOfBricks(NumberOfBricks() - 1);
-        Events::ScoreEvent es;
-        es.Score = brick->Score;
-        EventBroker->Publish(es);
-        if (numberOfBricks < 1) {
-            EndLevel();
-        }
-    }
-    return;*/
 }
 
 bool dd::Systems::LevelSystem::OnContact(const dd::Events::Contact &event)
@@ -186,7 +225,9 @@ bool dd::Systems::LevelSystem::OnContact(const dd::Events::Contact &event)
         EventBroker->Publish(e);
     }
 
-    if (ball != nullptr && Restarting() == false) {
+    if (!Restarting() && !brick->Removed) {
+        brick->Removed = true;
+        // Hit brick with ball code.
         ball->Combo += 1;
         Events::ComboEvent ec;
         ec.Combo = ball->Combo;
@@ -195,12 +236,6 @@ bool dd::Systems::LevelSystem::OnContact(const dd::Events::Contact &event)
 
         auto ballTransform = m_World->GetComponent<Components::Transform>(entityBall);
 
-//        m_World->RemoveComponent<Components::Brick>(entityBrick);
-//        m_World->RemoveComponent<Components::Transform>(entityBrick);
-//        m_World->RemoveComponent<Components::RectangleShape>(entityBrick);
-//        m_World->RemoveComponent<Components::Physics>(entityBrick);
-//        m_World->RemoveEntity(entityBrick);
-
         auto physicsComponent = m_World->GetComponent<Components::Physics>(entityBrick);
         physicsComponent->GravityScale = 1.f;
         physicsComponent->Mask = static_cast<CollisionLayer::Type>(CollisionLayer::Water | CollisionLayer::Wall);
@@ -221,17 +256,14 @@ bool dd::Systems::LevelSystem::OnContact(const dd::Events::Contact &event)
 
 
         SetNumberOfBricks(NumberOfBricks() - 1);
-        if (NumberOfBricks() <= 0) {
-            //SetMultiBalls(MultiBalls() + 1);
-        }
         Events::ScoreEvent es;
         es.Score = brick->Score * ball->Combo;
         EventBroker->Publish(es);
 
-        std::cout << "Combo: " << ball->Combo << std::endl;
+        //std::cout << "Combo: " << ball->Combo << std::endl;
         //std::cout << NumberOfBricks() << std::endl;
         //std::cout << "Brick Score: " << brick->Score  << std::endl;
-        std::cout << "Score: " << Score() << std::endl;
+        //std::cout << "Score: " << Score() << std::endl;
     }
 
     return true;
@@ -247,14 +279,12 @@ bool dd::Systems::LevelSystem::OnScoreEvent(const dd::Events::ScoreEvent &event)
 bool dd::Systems::LevelSystem::OnMultiBall(const dd::Events::MultiBall &event)
 {
     SetMultiBalls(MultiBalls()+2);
-    std::cout << MultiBalls() << std::endl;
     return true;
 }
 
 bool dd::Systems::LevelSystem::OnMultiBallLost(const dd::Events::MultiBallLost &event)
 {
     SetMultiBalls(MultiBalls()-1);
-    std::cout << MultiBalls() << std::endl;
     return true;
 }
 
@@ -266,13 +296,12 @@ bool dd::Systems::LevelSystem::OnCreatePowerUp(const dd::Events::CreatePowerUp &
     auto model = m_World->AddComponent<Components::Model>(powerUp);
     std::shared_ptr<Components::CircleShape> cRec = m_World->AddComponent<Components::CircleShape>(powerUp);
     std::shared_ptr<Components::Physics> cPhys = m_World->AddComponent<Components::Physics>(powerUp);
-    cPhys->Static = false;
+    cPhys->CollisionType = CollisionType::Type::Dynamic;
     cPhys->Category = CollisionLayer::Type::PowerUp;
     cPhys->Mask = CollisionLayer::Type::Pad;
 
     std::shared_ptr<Components::PowerUp> cPow = m_World->AddComponent<Components::PowerUp>(powerUp);
 
-
     transform->Position = event.Position;
     transform->Scale = glm::vec3(0.2, 0.2, 0.2);
     transform->Velocity = glm::vec3(0, -4, 0);
@@ -292,13 +321,119 @@ bool dd::Systems::LevelSystem::OnPowerUpTaken(const dd::Events::PowerUpTaken &ev
 
 bool dd::Systems::LevelSystem::OnStageCleared(const dd::Events::StageCleared &event)
 {
+    if (!m_Cleared) {
+        m_Cleared = true;
+        SetRestarting(true);
+        Events::ResetBall e;
+        EventBroker->Publish(e);
+        Events::ScoreEvent es;
+        es.Score = 500;
+        EventBroker->Publish(es);
+        m_CurrentLevel++;
+        if (m_CurrentLevel < 6) {
+            GetNextLevel();
+            CreateLevel();
+        }
+    }
     return true;
 }
 
-void dd::Systems::LevelSystem::EndLevel()
+void dd::Systems::LevelSystem::GetNextLevel()
 {
-    Events::StageCleared e;
+    std::array<int, 42> level;
-    EventBroker->Publish(e);
+    if (m_CurrentCluster == 1) {
-    return;
+        if (m_CurrentLevel == 1) {
+            level =
+                    {0, 0, 0, 0, 0, 0, 0,
+                     0, 0, 0, 0, 0, 0, 0,
+                     0, 0, 0, 1, 0, 0, 0,
+                     0, 0, 0, 0, 0, 0, 0,
+                     0, 0, 0, 0, 0, 0, 0,
+                     0, 0, 0, 0, 0, 0, 0};
+        } else if (m_CurrentLevel == 2) {
+            level =
+                    {1, 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};
+        } else if (m_CurrentLevel == 3) {
+            level =
+                    {0, 0, 0, 0, 0, 0, 1,
+                     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};
+        } else if (m_CurrentLevel == 4) {
+            level =
+                    {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,
+                     1, 0, 0, 0, 0, 0, 0};
+        } else if (m_CurrentLevel == 5) {
+            level =
+                    {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, 1};
+        }
+    } else if (m_CurrentCluster == 2) {
+        if (m_CurrentLevel == 1) {
+            level =
+                    {1, 1, 0, 1, 0, 1, 1,
+                     1, 1, 1, 1, 1, 1, 1,
+                     1, 1, 1, 1, 1, 1, 1,
+                     1, 2, 1, 2, 1, 2, 1,
+                     1, 1, 0, 1, 0, 1, 1,
+                     1, 0, 0, 1, 0, 0, 1};
+        } else if (m_CurrentLevel == 2) {
+            level =
+                    {1, 0, 0, 0, 0, 0, 1,
+                     0, 1, 0, 0, 0, 1, 0,
+                     0, 0, 2, 2, 2, 0, 0,
+                     0, 0, 0, 1, 0, 0, 0,
+                     0, 0, 0, 0, 0, 0, 0,
+                     0, 0, 0, 0, 0, 0, 0};
+        } else if (m_CurrentLevel == 3) {
+            level =
+                    {2, 0, 0, 0, 0, 0, 2,
+                     0, 1, 0, 0, 0, 1, 0,
+                     1, 2, 1, 1, 1, 2, 1,
+                     1, 0, 1, 1, 1, 0, 1,
+                     1, 0, 1, 1, 1, 0, 1,
+                     1, 0, 1, 1, 1, 0, 1};
+        } else if (m_CurrentLevel == 4) {
+            level =
+                    {1, 2, 1, 1, 1, 2, 1,
+                     1, 0, 1, 1, 1, 0, 1,
+                     1, 2, 1, 1, 1, 2, 1,
+                     1, 0, 1, 1, 1, 0, 1,
+                     1, 0, 0, 0, 0, 0, 1,
+                     0, 1, 1, 0, 1, 1, 0};
+        } else if (m_CurrentLevel == 5) {
+            level =
+                    {1, 0, 1, 0, 1, 0, 1,
+                     0, 1, 0, 1, 0, 1, 0,
+                     2, 0, 1, 0, 1, 0, 2,
+                     0, 1, 0, 2, 0, 1, 0,
+                     1, 0, 1, 0, 1, 0, 1,
+                     0, 1, 0, 1, 0, 1, 0};
+        }
+    } else if (m_CurrentCluster == 3) {
+
+    }
+
+    std::copy(std::begin(level), std::end(level), std::begin(m_Bricks));
 }
 
+bool dd::Systems::LevelSystem::OnHitPad(const dd::Events::HitPad &event)
+{
+    m_Cleared = false;
+    return true;
+}

src/game/Game/PadSystem.cpp

@@ -27,16 +27,17 @@ void dd::Systems::PadSystem::Initialize()
     EVENT_SUBSCRIBE_MEMBER(m_EContact, &PadSystem::OnContact);
     EVENT_SUBSCRIBE_MEMBER(m_EContactPowerUp, &PadSystem::OnContactPowerUp);
     EVENT_SUBSCRIBE_MEMBER(m_EStageCleared, &PadSystem::OnStageCleared);
+    EVENT_SUBSCRIBE_MEMBER(m_EPause, &PadSystem::OnPause);
 
     {
         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, -3.5f, -10.f);
-        ctransform->Scale = glm::vec3(1.0f, 1.0f, 1.f);
+        auto rectangleShape = m_World->AddComponent<Components::RectangleShape>(ent);
-        auto rectangle = m_World->AddComponent<Components::RectangleShape>(ent);
+        rectangleShape->Dimensions = glm::vec2(1.f, 0.5f);
         auto physics = m_World->AddComponent<Components::Physics>(ent);
-        physics->Static = false;
+        physics->CollisionType = CollisionType::Type::Dynamic;
         physics->Category = CollisionLayer::Type::Pad;
 		physics->Mask = static_cast<CollisionLayer::Type>(CollisionLayer::Ball | CollisionLayer::PowerUp);
         physics->Calculate = true;
@@ -58,6 +59,9 @@ void dd::Systems::PadSystem::UpdateEntity(double dt, EntityID entity, EntityID p
 
 void dd::Systems::PadSystem::Update(double dt)
 {
+    if (IsPaused()) {
+        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") {
@@ -105,6 +109,20 @@ void dd::Systems::PadSystem::Update(double dt)
     return;
 }
 
+bool dd::Systems::PadSystem::OnPause(const dd::Events::Pause &event)
+{
+    if (event.Type != "PadSystem" && event.Type != "All") {
+        return false;
+    }
+
+    if (IsPaused()) {
+        SetPause(false);
+    } else {
+        SetPause(true);
+    }
+    return true;
+}
+
 bool dd::Systems::PadSystem::OnKeyDown(const dd::Events::KeyDown &event)
 {
     int val = event.KeyCode;
@@ -127,6 +145,15 @@ bool dd::Systems::PadSystem::OnKeyDown(const dd::Events::KeyDown &event)
         Events::MultiBall e;
         e.padTransform = Transform();
         EventBroker->Publish(e);
+    } else if (val == GLFW_KEY_P) {
+        Events::Pause e;
+        e.Type = "All";
+        EventBroker->Publish(e);
+    } else if (val == GLFW_KEY_H) {
+        Events::HitLag e;
+        e.Time = 0.2;
+        e.Type = "All";
+        EventBroker->Publish(e);
     } else if (val == GLFW_KEY_D) {
         return false;
     }
@@ -226,9 +253,6 @@ bool dd::Systems::PadSystem::OnContactPowerUp(const dd::Events::Contact &event)
         return false;
     }
 
-//    m_World->RemoveComponent<Components::PowerUp>(entityPower);
-//    m_World->RemoveComponent<Components::CircleShape>(entityPower);
-//    m_World->RemoveComponent<Components::Physics>(entityPower);
     m_World->RemoveEntity(entityPower);
     Events::PowerUpTaken ep;
     ep.Name = "Something";

src/game/Physics/ContactListener.cpp

@@ -0,0 +1,47 @@
+#include "PrecompiledHeader.h"
+#include "Physics/PhysicsSystem.h"
+
+void dd::Systems::PhysicsSystem::ContactListener::BeginContact(b2Contact* contact)
+{
+    b2WorldManifold worldManifold;
+
+    contact->GetWorldManifold(&worldManifold);
+
+    Events::Contact e;
+    e.Entity1 = m_PhysicsSystem->m_BodiesToEntities[contact->GetFixtureA()->GetBody()];
+    e.Entity2 = m_PhysicsSystem->m_BodiesToEntities[contact->GetFixtureB()->GetBody()];
+    e.Normal = glm::normalize(glm::vec2(contact->GetManifold()->localNormal.x, contact->GetManifold()->localNormal.y));
+    e.SignificantNormal = glm::normalize((glm::abs(e.Normal.x) > glm::abs(e.Normal.y)) ? glm::vec2(e.Normal.x, 0) : glm::vec2(0, e.Normal.y));
+
+    m_PhysicsSystem->EventBroker->Publish(e);
+}
+
+void dd::Systems::PhysicsSystem::ContactListener::EndContact(b2Contact* contact)
+{
+
+}
+
+void dd::Systems::PhysicsSystem::ContactListener::PreSolve(b2Contact* contact, const b2Manifold* oldManifold)
+{
+    EntityID entityA = m_PhysicsSystem->m_BodiesToEntities[contact->GetFixtureA()->GetBody()];
+    EntityID entityB = m_PhysicsSystem->m_BodiesToEntities[contact->GetFixtureB()->GetBody()];
+
+    auto physicsComponentA = m_PhysicsSystem->m_World->GetComponent<Components::Physics>(entityA);
+    auto physicsComponentB = m_PhysicsSystem->m_World->GetComponent<Components::Physics>(entityB);
+
+    if (physicsComponentA != nullptr && physicsComponentB != nullptr) {
+        if (physicsComponentA->Calculate || physicsComponentB->Calculate) {
+            // Turn of collisions
+            contact->SetEnabled(false);
+        }
+    }
+
+
+}
+
+void dd::Systems::PhysicsSystem::ContactListener::PostSolve(b2Contact* contact, const b2ContactImpulse* impulse)
+{
+
+}
+
+

src/game/Physics/PhysicsSystem.cpp

@@ -2,29 +2,20 @@
 #include "Physics/PhysicsSystem.h"
 
 
-
 void dd::Systems::PhysicsSystem::RegisterComponents(ComponentFactory* cf)
 {
     cf->Register<Components::CircleShape>();
+    //TODO: REGISTER PHYSICS COMPONENTS HERE
 }
 
 void dd::Systems::PhysicsSystem::Initialize()
 {
     m_ContactListener = new ContactListener(this);
-
-    m_Gravity = b2Vec2(0.f, -9.82f);
     m_PhysicsWorld = new b2World(m_Gravity);
-
-    m_TimeStep = 1.0/60.0;
-    m_VelocityIterations = 6;
-    m_PositionIterations = 2;
-    m_Accumulator = 0.0;
-
     m_PhysicsWorld->SetContactListener(m_ContactListener);
-
     InitializeWater();
-
+    EVENT_SUBSCRIBE_MEMBER(m_SetImpulse, PhysicsSystem::SetImpulse);
-    EVENT_SUBSCRIBE_MEMBER(m_SetImpulse, &PhysicsSystem::SetImpulse);
+    EVENT_SUBSCRIBE_MEMBER(m_EPause, &PhysicsSystem::OnPause);
 }
 
 void dd::Systems::PhysicsSystem::InitializeWater()
@@ -36,7 +27,11 @@ void dd::Systems::PhysicsSystem::InitializeWater()
 
 bool dd::Systems::PhysicsSystem::SetImpulse(const Events::SetImpulse &event)
 {
-    b2Body* body = m_EntitiesToBodies[event.Entity];
+    auto it = m_EntitiesToBodies.find(event.Entity);
+    if(it == m_EntitiesToBodies.end()) {
+        LOG_ERROR("Entity: %i, Tried to set an impulse on a body that does not exsist", event.Entity);
+        return false;
+    }
 
     b2Vec2 impulse;
     impulse.x = event.Impulse.x;
@@ -46,118 +41,143 @@ bool dd::Systems::PhysicsSystem::SetImpulse(const Events::SetImpulse &event)
     point.x = event.Point.x;
     point.y = event.Point.y;
 
-
     Impulse i;
-    i.Body = body;
+    i.Body = it->second;
-    i.Vector = impulse;
+    i.Impulse = impulse;
     i.Point = point;
 
     m_Impulses.push_back(i);
-
     return true;
 }
 
-void dd::Systems::PhysicsSystem::Update(double dt) {
+void dd::Systems::PhysicsSystem::SyncEntitiesWithBodies()
+{
 
-    m_Accumulator += dt;
+    for (auto i : m_EntitiesToBodies) {
-    while (m_Accumulator >= m_TimeStep) {
+        EntityID entity = i.first;
+        b2Body* body = i.second;
 
-        for (auto i : m_EntitiesToBodies) {
+        if (body == nullptr) {
-            EntityID entity = i.first;
+            LOG_ERROR("This body should not exist, please fix this");
-            b2Body *body = i.second;
+            continue;
-
-            auto transformComponent = m_World->GetComponent<Components::Transform>(entity);
-            if (!transformComponent) {
-                continue;
-                LOG_ERROR("RigidBody with no TransformComponent");
-            }
-            auto physicsComponent = m_World->GetComponent<Components::Physics>(entity);
-            if (!physicsComponent) {
-                continue;
-                LOG_ERROR("RigidBody with no PhysicsComponent");
-            }
-
-
-            if (body == nullptr) {
-                LOG_ERROR("This body should not exist");
-                continue;
-            }
-
-            if (m_World->GetEntityParent(entity) == 0) { //TODO: Make this work with childs too
-                b2Vec2 position;
-                position.x = transformComponent->Position.x;
-                position.y = transformComponent->Position.y;
-                float angle = glm::eulerAngles(transformComponent->Orientation).z;
-                body->SetTransform(position, angle);
-                body->SetLinearVelocity(b2Vec2(transformComponent->Velocity.x, transformComponent->Velocity.y));
-                body->SetGravityScale(physicsComponent->GravityScale);
-
-                b2Filter filter;
-                filter.categoryBits = physicsComponent->Category;
-                filter.maskBits = physicsComponent->Mask;
-                body->GetFixtureList()->SetFilterData(filter);
-            }
         }
 
-        UpdateParticleEmitters(dt);
+        auto transformComponent = m_World->GetComponent<Components::Transform>(entity);
+        if (! transformComponent) {
+            continue;
+            LOG_ERROR("RigidBody with no TransformComponent");
+        }
 
+        auto physicsComponent = m_World->GetComponent<Components::Physics>(entity);
+        if (! physicsComponent) {
+            continue;
+            LOG_ERROR("RigidBody with no PhysicsComponent");
+        }
+
+
+
+        if (m_World->GetEntityParent(entity) == 0) { //TODO: Make this work with childs too
+            b2Vec2 position;
+            position.x = transformComponent->Position.x;
+            position.y = transformComponent->Position.y;
+            float angle = glm::eulerAngles(transformComponent->Orientation).z;
+            body->SetTransform(position, angle);
+            body->SetLinearVelocity(b2Vec2(transformComponent->Velocity.x, transformComponent->Velocity.y));
+            body->SetGravityScale(physicsComponent->GravityScale);
+
+            b2Filter filter;
+            filter.categoryBits = physicsComponent->Category;
+            filter.maskBits = physicsComponent->Mask;
+            body->GetFixtureList()->SetFilterData(filter);
+        }
+    }
+}
+
+void dd::Systems::PhysicsSystem::SyncBodiesWithEntities()
+{
+    for (auto i : m_BodiesToEntities) {
+        b2Body* body = i.first;
+        EntityID entity = i.second;
+
+        if (body == nullptr) {
+            LOG_ERROR("This body should not exist, please fix this");
+            continue;
+        }
+
+        auto transformComponent = m_World->GetComponent<Components::Transform>(entity);
+        if (! transformComponent) {
+            continue;
+            LOG_ERROR("RigidBody with no TransformComponent");
+        }
+
+        auto physicsComponent = m_World->GetComponent<Components::Physics>(entity);
+        if (! physicsComponent) {
+            continue;
+            LOG_ERROR("RigidBody with no PhysicsComponent");
+        }
+
+        auto parent = m_World->GetEntityParent(entity);
+        if (parent == 0) {
+            auto physicsComponent = m_World->GetComponent<Components::Physics>(entity);
+
+            if (physicsComponent->Calculate) { //TODO: REPLACE THIS WITH PARTICLE COLLISION FILTERS
+                transformComponent->Position.x = transformComponent->Position.x + (transformComponent->Velocity.x * m_TimeStep);
+                transformComponent->Position.y = transformComponent->Position.y + (transformComponent->Velocity.y * m_TimeStep);
+            } else {
+                b2Vec2 position = body->GetPosition();
+                transformComponent->Position.x = position.x;
+                transformComponent->Position.y = position.y;
+
+                float angle = body->GetAngle();
+                transformComponent->Orientation =  glm::quat(glm::vec3(0, 0, angle));
+
+                b2Vec2 velocity = body->GetLinearVelocity();
+                transformComponent->Velocity.x = velocity.x;
+                transformComponent->Velocity.y = velocity.y;
+            }
+        }
+    }
+}
+
+void dd::Systems::PhysicsSystem::Update(double dt)
+{
+    if (m_Pause) {
+        return;
+    }
+
+    m_Accumulator += dt;
+
+    while(m_Accumulator >= m_TimeStep)
+    {
+
+        UpdateParticleEmitters(dt);
+        SyncEntitiesWithBodies();
+
+        //Apply Impulses Must be done after SyncEntitiesWithBodies
         for (auto i : m_Impulses) {
-            i.Body->ApplyLinearImpulse(i.Vector, i.Point, true);
+            i.Body->ApplyLinearImpulse(i.Impulse, i.Point, true);
         }
         m_Impulses.clear();
 
+
+        //Update the PhysicsWorld
         m_PhysicsWorld->Step(m_TimeStep, m_VelocityIterations, m_PositionIterations);
 
+        SyncBodiesWithEntities();
 
-        for (auto i : m_EntitiesToBodies) {
-            EntityID entity = i.first;
-            b2Body *body = i.second;
-
-            if (body == nullptr) {
-                LOG_ERROR("This body should not exist");
-                continue;
-            }
-
-            auto transformComponent = m_World->GetComponent<Components::Transform>(entity);
-            if (!transformComponent)
-                continue;
-            auto parent = m_World->GetEntityParent(entity);
-            if (parent == 0) {
-
-                auto physicsComponent = m_World->GetComponent<Components::Physics>(entity);
-                if (physicsComponent->Calculate) { //TODO: REPLACE THIS WITH PARTICLE COLLISION FILTERS
-                    transformComponent->Position.x =
-                            transformComponent->Position.x + (transformComponent->Velocity.x * m_TimeStep);
-                    transformComponent->Position.y =
-                            transformComponent->Position.y + (transformComponent->Velocity.y * m_TimeStep);
-                }
-                else {
-                    b2Vec2 position = body->GetPosition();
-                    transformComponent->Position.x = position.x;
-                    transformComponent->Position.y = position.y;
-
-                    float angle = body->GetAngle();
-                    transformComponent->Orientation = glm::quat(glm::vec3(0, 0, angle));
-
-                    b2Vec2 velocity = body->GetLinearVelocity();
-                    transformComponent->Velocity.x = velocity.x;
-                    transformComponent->Velocity.y = velocity.y;
-                }
-            }
-        }
 
         for ( int e = 0; e < m_EntitiesToParticleHandle.size(); e++) {
             b2Vec2 *positionBuffer = m_ParticleSystem[e]->GetPositionBuffer();
-            for (auto i : m_EntitiesToParticleHandle[e]){
+            for (auto i : m_EntitiesToParticleHandle[e]) {
                 EntityID entity = i.first;
-                const b2ParticleHandle *particleH = i.second;
+                b2ParticleHandle *particleH = i.second;
 
                 b2Vec2 positionB2 = positionBuffer[particleH->GetIndex()];
                 glm::vec2 position = glm::vec2(positionB2.x, positionB2.y);
 
                 EntityID entityParent = m_World->GetEntityParent(entity);
                 glm::vec3 parentTransform = glm::vec3(0.f);
-                if(entityParent) {
+                if (entityParent) {
                     auto tp = m_World->GetComponent<Components::Transform>(entityParent);
                     parentTransform = tp->Position;
                 }
@@ -172,12 +192,25 @@ void dd::Systems::PhysicsSystem::Update(double dt) {
     }
 }
 
-
 void dd::Systems::PhysicsSystem::UpdateEntity(double dt, EntityID entity, EntityID parent)
 {
 
 }
 
+bool dd::Systems::PhysicsSystem::OnPause(const dd::Events::Pause &event)
+{
+    if (event.Type != "PhysicsSystem" && event.Type != "All") {
+        return false;
+    }
+
+    if (m_Pause) {
+        m_Pause = false;
+    } else {
+        m_Pause = true;
+    }
+    return true;
+}
+
 void dd::Systems::PhysicsSystem::OnEntityCommit(EntityID entity)
 {
     auto physicsComponent = m_World->GetComponent<Components::Physics>(entity);
@@ -194,7 +227,12 @@ void dd::Systems::PhysicsSystem::OnEntityCommit(EntityID entity)
     }
 
     if (physicsComponent) {
-        CreateBody(entity);
+        auto it = m_EntitiesToBodies.find(entity);
+        if(it == m_EntitiesToBodies.end()) {
+            CreateBody(entity);
+        } else {
+            LOG_ERROR("Tried to commit a body that already exists");
+        }
     } else if (waterComponent) {
         CreateParticleGroup(entity);
     } else if (particleEmitterComponent) {
@@ -205,22 +243,25 @@ void dd::Systems::PhysicsSystem::OnEntityCommit(EntityID entity)
 
 void dd::Systems::PhysicsSystem::OnEntityRemoved(EntityID entity)
 {
-    auto physics = m_World->GetComponent<Components::Physics>(entity);
+   /* auto physics = m_World->GetComponent<Components::Physics>(entity);
     if (physics == nullptr) {
         return;
+    }*/
+
+    auto it = m_EntitiesToBodies.find(entity);
+    if(it == m_EntitiesToBodies.end()) {
+        LOG_ERROR("Trying to remove non-exsisting body, Entity: %i", entity);
+        return;
     }
 
-    b2Body* body = m_EntitiesToBodies[entity];
+    //LOG_INFO("Removing entity %i", entity);
-
+    it->second->GetWorld()->DestroyBody(it->second);
-    if (body != nullptr) {
+    m_BodiesToEntities.erase(it->second);
-        m_EntitiesToBodies.erase(entity);
+    m_EntitiesToBodies.erase(entity);
-        m_BodiesToEntities.erase(body);
+    //delete body;
-
-        m_PhysicsWorld->DestroyBody(body);
-    }
-
 }
 
+
 void dd::Systems::PhysicsSystem::CreateBody(EntityID entity)
 {
     auto physicsComponent = m_World->GetComponent<Components::Physics>(entity);
@@ -229,7 +270,6 @@ void dd::Systems::PhysicsSystem::CreateBody(EntityID entity)
         return;
     }
 
-
     auto transformComponent = m_World->GetComponent<Components::Transform>(entity);
     if(!transformComponent) {
         LOG_ERROR("No TransformComponent in CreateBody");
@@ -242,34 +282,28 @@ void dd::Systems::PhysicsSystem::CreateBody(EntityID entity)
     bodyDef.position.Set(absoluteTransform.Position.x, absoluteTransform.Position.y);
     bodyDef.angle = -glm::eulerAngles(absoluteTransform.Orientation).z;
 
-    if (physicsComponent->Static) {
+    if (physicsComponent->CollisionType == CollisionType::Type::Static) {
         bodyDef.type = b2_staticBody;
-    } else {
+    } else if (physicsComponent->CollisionType == CollisionType::Type::Dynamic) {
+        bodyDef.type = b2_dynamicBody;
+    } else if (physicsComponent->CollisionType == CollisionType::Type::Kinematic) {
         bodyDef.type = b2_dynamicBody;
-
     }
 
     b2Body* body = m_PhysicsWorld->CreateBody(&bodyDef);
 
     b2Shape* pShape;
 
-    auto boxComponent = m_World->GetComponent<Components::RectangleShape>(entity);
+    auto rectangleComponent = m_World->GetComponent<Components::RectangleShape>(entity);
-    if (boxComponent) {
+    if (rectangleComponent) {
         b2PolygonShape* bShape = new b2PolygonShape();
-        bShape->SetAsBox(absoluteTransform.Scale.x/2, absoluteTransform.Scale.y/2);
+        bShape->SetAsBox(rectangleComponent->Dimensions.x/2.f, rectangleComponent->Dimensions.y/2.f);
         pShape = bShape;
     } else {
         auto circleComponent = m_World->GetComponent<Components::CircleShape>(entity);
         if (circleComponent) {
             pShape = new b2CircleShape();
-            pShape->m_radius = absoluteTransform.Scale.x;
+            pShape->m_radius = circleComponent->Radius;
-
-
-            if (absoluteTransform.Scale.x != absoluteTransform.Scale.y &&  absoluteTransform.Scale.y != absoluteTransform.Scale.z) {
-                LOG_WARNING("Circles has to be of uniform scale.");
-            }
-            pShape->m_radius = absoluteTransform.Scale.x/2;
-
         }
     }
 
@@ -279,26 +313,26 @@ void dd::Systems::PhysicsSystem::CreateBody(EntityID entity)
     fixtureDef.filter.maskBits = physicsComponent->Mask;
 
 
-    if(physicsComponent->Static) {
-        body->CreateFixture(&fixtureDef); //Density kanske ska vara 0 p� statiska kroppar
-    }
-    else {
-        fixtureDef.shape = pShape;
-        fixtureDef.density = 10.f;
-        fixtureDef.restitution = 1.0f;
-        fixtureDef.friction = 0.0f;
-        body->CreateFixture(&fixtureDef);
 
-    }
+    fixtureDef.shape = pShape;
+    fixtureDef.density = 10.f;
+    fixtureDef.restitution = 1.0f;
+    fixtureDef.friction = 0.0f;
+    body->CreateFixture(&fixtureDef);
+
 
     delete pShape;
 
+  /*  if(physicsComponent->Static) {
+        body->SetType(b2BodyType::b2_staticBody);
+    } else if (! physicsComponent->Static) {
+        body->SetType(b2BodyType::b2_dynamicBody);
+    }*/
 
     body->SetGravityScale(physicsComponent->GravityScale);
     m_EntitiesToBodies.insert(std::make_pair(entity, body));
     m_BodiesToEntities.insert(std::make_pair(body, entity));
 }
-
 void dd::Systems::PhysicsSystem::CreateParticleGroup(EntityID e)
 {
     auto transform = m_World->GetComponent<Components::Transform>(e);
@@ -337,7 +371,7 @@ void dd::Systems::PhysicsSystem::CreateParticleGroup(EntityID e)
 void dd::Systems::PhysicsSystem::UpdateParticleEmitters(double dt)
 {
     for (int i = 0; i < m_ParticleEmitters.ParticleSystem.size(); i++) {
-        auto e = m_ParticleEmitters.Emitter[i];
+        auto e = m_ParticleEmitters.ParticleEmitter[i];
         auto pt = m_ParticleEmitters.ParticleTemplate[i];
         auto ps = m_ParticleEmitters.ParticleSystem[i];
 
@@ -407,7 +441,7 @@ void dd::Systems::PhysicsSystem::CreateParticleEmitter(EntityID entity)
     }
     //TODO: Skicka med fler flaggor till particlesystemet;
     m_ParticleEmitters.ParticleSystem.push_back(CreateParticleSystem(particle->Radius, 0.f));
-    m_ParticleEmitters.Emitter.push_back(entity);
+    m_ParticleEmitters.ParticleEmitter.push_back(entity);
     m_ParticleEmitters.ParticleTemplate.push_back(childEntity);
 }
 
@@ -428,10 +462,28 @@ b2ParticleSystem* dd::Systems::PhysicsSystem::CreateParticleSystem(float radius,
     return m_ParticleSystem.back();
 }
 
+
+
 dd::Systems::PhysicsSystem::~PhysicsSystem()
 {
+    for (auto i = m_BodiesToEntities.begin(); i != m_BodiesToEntities.end(); i++) {
+        b2Body* body = i->first;
+        body->GetWorld()->DestroyBody(body);
+        //delete body;
+    }
+    m_BodiesToEntities.clear();
+    m_EntitiesToBodies.clear();
+    m_Impulses.clear();
+
+    //TODO:REMOVE PARTICLE SYSTEMS
+
     if (m_ContactListener != nullptr) {
         delete m_ContactListener;
         m_ContactListener = nullptr;
     }
+
+    if (m_PhysicsWorld != nullptr) {
+        delete m_PhysicsWorld;
+        m_PhysicsWorld = nullptr;
+    }
 }

src/game/Sound/SoundSystem.cpp.orig

@@ -1,183 +0,0 @@
-#include "PrecompiledHeader.h"
-#include "Sound/SoundSystem.h"
-
-dd::Systems::SoundSystem::~SoundSystem()
-{
-    alcCloseDevice(m_Device);
-};
-
-void dd::Systems::SoundSystem::Initialize()
-{
-    //initialize OpenAL
-    m_Device = alcOpenDevice(NULL);
-    ALCcontext* context;
-
-    if (m_Device) {
-        context = alcCreateContext(m_Device, NULL);
-        alcMakeContextCurrent(context);
-    }
-    else {
-        LOG_ERROR("OpenAL failed to initialize.");
-    }
-    alGetError();
-
-    //Subscribe to events
-    EVENT_SUBSCRIBE_MEMBER(m_EContact, &SoundSystem::OnContact);
-    EVENT_SUBSCRIBE_MEMBER(m_EPlaySFX, &SoundSystem::OnPlaySound);
-    EVENT_SUBSCRIBE_MEMBER(m_EStopSound, &SoundSystem::OnStopSound);
-    EVENT_SUBSCRIBE_MEMBER(m_EMasterVolume, &SoundSystem::OnMasterVolume);
-
-<<<<<<< HEAD
-    //Todo: Move this
-    {
-        dd::Events::PlaySound e;
-        e.FilePath = "Sounds/BGM/under-the-sea-instrumental.wav";
-        e.IsAmbient = true;
-        EventBroker->Publish(e);
-    }
-    {
-        dd::Events::PlaySound e;
-        e.FilePath = "Sounds/BGM/water-flowing.wav";
-        e.Gain = 0.3f;
-        e.IsAmbient = true;
-        EventBroker->Publish(e);
-    }
-=======
-
-
->>>>>>> origin/master
-}
-
-void dd::Systems::SoundSystem::Update(double dt)
-{
-    //Clean up none-active sources
-    //Only used for SFX's. BGM's are handled on stop sound.
-    std::vector<ALuint> deleteList;
-    for (auto& item : m_SFXSourcesToBuffers) {
-        ALint sourceState;
-        alGetSourcei(item.first, AL_SOURCE_STATE, &sourceState);
-        if (sourceState == AL_STOPPED) {
-            deleteList.push_back(item.first);
-        }
-    }
-
-    for (int i = 0; i < deleteList.size(); i++) {
-        alDeleteSources(1, &deleteList[i]);
-        //alDeleteBuffers(1, &m_SourcesToBuffers[deleteList[i]]);
-        m_SFXSourcesToBuffers.erase(deleteList[i]);
-    }
-}
-
-ALuint dd::Systems::SoundSystem::CreateSource()
-{
-    ALuint source;
-    alGenSources((ALuint)1, &source);
-
-    return source;
-}
-
-bool dd::Systems::SoundSystem::OnPlaySound(const dd::Events::PlaySound &event)
-{
-    //Loading and binding sound buffer to source
-    Sound *sound = ResourceManager::Load<Sound>(event.FilePath);
-    if (sound == nullptr) {
-       return false;
-    }
-    ALuint source = CreateSource();
-    ALuint buffer = sound->Buffer();
-    alSourcei(source, AL_BUFFER, buffer);
-
-    //Sound settings
-    float relativeVolume = 1.f;
-    if (event.IsAmbient) {
-        alSourcei(source, AL_LOOPING, AL_TRUE);
-        relativeVolume = m_BGMMasterVolume;
-        m_BGMSourcesToBuffers[source] = sound;
-
-    }
-    else if (!event.IsAmbient)
-    {
-        m_SFXSourcesToBuffers[source] = sound;
-        alSourcei(source, AL_LOOPING, AL_FALSE);
-        relativeVolume = m_SFXMasterVolume;
-    }
-
-    alSourcef(source, AL_GAIN, (event.Gain * relativeVolume));
-    alSourcef(source, AL_PITCH, event.Pitch);
-
-
-    //Play
-    alSourcePlay(source);
-    return true;
-}
-
-bool dd::Systems::SoundSystem::OnStopSound(const dd::Events::StopSound &event)
-{
-    ALuint itemToDeleted;
-    for (auto& item : m_BGMSourcesToBuffers)
-    {
-        if (item.second->Path() == event.FilePath) {
-            itemToDeleted = item.first;
-            break;
-        }
-    }
-    alSourceStop(itemToDeleted);
-    alDeleteSources(1, &itemToDeleted);
-    m_BGMSourcesToBuffers.erase(itemToDeleted);
-
-    //Should not happen because SFX's should be very short.
-    for (auto item : m_SFXSourcesToBuffers)
-    {
-        if (item.second->Path() == event.FilePath) {
-            alSourceStop(item.first);
-            return true;
-        }
-    }
-    return false;
-}
-
-bool dd::Systems::SoundSystem::OnMasterVolume(const dd::Events::MasterVolume &event)
-{
-    //TODO: Make the Gain depend on the value given when stored.
-    //TODO: .. now it ONLY uses the master Gain
-    if (event.IsAmbient) {
-        m_BGMMasterVolume = event.Gain;
-        for (auto& item : m_BGMSourcesToBuffers)
-        {
-            alSourcef(item.first, AL_GAIN, event.Gain);
-        }
-        return true;
-    }
-    else if (!event.IsAmbient) {
-        m_SFXMasterVolume = event.Gain;
-        for (auto& item : m_SFXSourcesToBuffers)
-        {
-            alSourcef(item.first, AL_GAIN, event.Gain);
-        }
-        return true;
-    }
-    return false;
-}
-
-bool dd::Systems::SoundSystem::OnContact(const dd::Events::Contact &event)
-{
-    //Check which entity has the collisionSound component.
-    auto collisionSound = m_World->GetComponent<Components::CollisionSound>(event.Entity1);
-    if (collisionSound == nullptr) {
-        collisionSound = m_World->GetComponent<Components::CollisionSound>(event.Entity2);
-        if (collisionSound == nullptr) {
-            //None of the entities had a collisionSound component.
-            return false;
-        }
-    }
-
-    //Send play-sound event
-    dd::Events::PlaySound e;
-    e.FilePath = collisionSound->FilePath;
-    e.IsAmbient = false;
-    EventBroker->Publish(e);
-    return true;
-}
-
-
-

src/tests/RemovePhysicsSystemTest.cpp

@@ -0,0 +1,51 @@
+#include "PrecompiledHeader.h"
+#include <boost/test/unit_test.hpp>
+#include "Core/World.h"
+#include "Core/EventBroker.h"
+#include "Physics/PhysicsSystem.h"
+#include "Transform/TransformSystem.h"
+
+#include "Physics/CPhysics.h"
+#include "Physics/CRectangleShape.h"
+
+
+
+
+using namespace dd;
+
+BOOST_AUTO_TEST_CASE(RemovePhysicsSystemTest)
+{
+    // Setup world
+    std::shared_ptr<EventBroker> eventBroker = std::make_shared<EventBroker>();
+    World world(eventBroker);
+
+    world.SystemFactory.Register<Systems::TransformSystem>(
+            [this]() { return new Systems::TransformSystem(&world, eventBroker); });
+    world.AddSystem<Systems::TransformSystem>();
+
+    world.SystemFactory.Register<Systems::PhysicsSystem>(
+            [this]() { return new Systems::PhysicsSystem(&world, eventBroker); });
+    world.AddSystem<Systems::PhysicsSystem>();
+
+    world.ComponentFactory.Register<Components::RectangleShape>();
+    world.ComponentFactory.Register<Components::Physics>();
+
+    //Create entity
+    EntityID ent = world.CreateEntity();
+
+    auto transform = world.AddComponent<Components::Transform>(ent);
+    transform->Position = glm::vec3(20.f, 0.f, -10.f);
+    transform->Velocity = glm::vec3(1.f, 3.f, 0.f);
+    transform->Scale = glm::vec3(2.f, 5.f, 1.f);
+
+    auto physics = world.AddComponent<Components::Physics>(ent);
+    physics->Static = false;
+    physics->Calculate = true;
+    physics->Category = CollisionLayer::Type::Ball;
+    physics->Mask = CollisionLayer::Type::Brick | CollisionLayer::Type::Pad | CollisionLayer::Wall;
+    physics->GravityScale = 0.f;
+
+    auto rectangle = world.AddComponent<Components::RectangleShape>(ent);
+
+
+}