Added project

core/assets/customFont1.fnt

@@ -0,0 +1,57 @@
+info face="Arial" size=12 bold=0 italic=0 charset="" unicode=1 stretchH=100 smooth=0 aa=1 padding=1,1,1,1 spacing=2,2 outline=0
+common lineHeight=12 base=9 scaleW=256 scaleH=256 pages=1 packed=0 alphaChnl=0 redChnl=3 greenChnl=3 blueChnl=3
+page id=0 file="customFont1_0.png"
+chars count=37
+char id=48   x=40    y=11    width=6     height=9     xoffset=-1    yoffset=1     xadvance=5     page=0  chnl=15
+char id=49   x=48    y=11    width=4     height=9     xoffset=0     yoffset=1     xadvance=5     page=0  chnl=15
+char id=50   x=191   y=0     width=6     height=9     xoffset=-1    yoffset=1     xadvance=5     page=0  chnl=15
+char id=51   x=199   y=0     width=6     height=9     xoffset=-1    yoffset=1     xadvance=5     page=0  chnl=15
+char id=52   x=83    y=0     width=7     height=9     xoffset=-1    yoffset=1     xadvance=5     page=0  chnl=15
+char id=53   x=207   y=0     width=6     height=9     xoffset=-1    yoffset=1     xadvance=5     page=0  chnl=15
+char id=54   x=215   y=0     width=6     height=9     xoffset=-1    yoffset=1     xadvance=5     page=0  chnl=15
+char id=55   x=223   y=0     width=6     height=9     xoffset=-1    yoffset=1     xadvance=5     page=0  chnl=15
+char id=56   x=231   y=0     width=6     height=9     xoffset=-1    yoffset=1     xadvance=5     page=0  chnl=15
+char id=57   x=239   y=0     width=6     height=9     xoffset=-1    yoffset=1     xadvance=5     page=0  chnl=15
+char id=58   x=60    y=11    width=3     height=7     xoffset=0     yoffset=3     xadvance=3     page=0  chnl=15
+char id=65   x=24    y=0     width=9     height=9     xoffset=-1    yoffset=1     xadvance=6     page=0  chnl=15
+char id=66   x=16    y=11    width=6     height=9     xoffset=1     yoffset=1     xadvance=6     page=0  chnl=15
+char id=67   x=137   y=0     width=7     height=9     xoffset=0     yoffset=1     xadvance=7     page=0  chnl=15
+char id=68   x=146   y=0     width=7     height=9     xoffset=0     yoffset=1     xadvance=7     page=0  chnl=15
+char id=69   x=155   y=0     width=7     height=9     xoffset=0     yoffset=1     xadvance=6     page=0  chnl=15
+char id=70   x=247   y=0     width=6     height=9     xoffset=0     yoffset=1     xadvance=6     page=0  chnl=15
+char id=71   x=164   y=0     width=7     height=9     xoffset=0     yoffset=1     xadvance=7     page=0  chnl=15
+char id=72   x=173   y=0     width=7     height=9     xoffset=0     yoffset=1     xadvance=7     page=0  chnl=15
+char id=73   x=54    y=11    width=6     height=9     xoffset=-1     yoffset=1     xadvance=3     page=0  chnl=15
+char id=74   x=8     y=11    width=6     height=9     xoffset=0    yoffset=1     xadvance=5     page=0  chnl=15
+char id=75   x=182   y=0     width=7     height=9     xoffset=0     yoffset=1     xadvance=6     page=0  chnl=15
+char id=76   x=32    y=11    width=6     height=9     xoffset=0     yoffset=1     xadvance=5     page=0  chnl=15
+char id=77   x=13    y=0     width=9     height=9     xoffset=0    yoffset=1     xadvance=7     page=0  chnl=15
+char id=78   x=55    y=0     width=8     height=9     xoffset=0     yoffset=1     xadvance=7     page=0  chnl=15
+char id=79   x=65    y=0     width=7     height=9     xoffset=0     yoffset=1     xadvance=7     page=0  chnl=15
+char id=80   x=24    y=11    width=6     height=9     xoffset=0     yoffset=1     xadvance=6     page=0  chnl=15
+char id=81   x=74    y=0     width=7     height=9     xoffset=0     yoffset=1     xadvance=7     page=0  chnl=15
+char id=82   x=92    y=0     width=7     height=9     xoffset=0     yoffset=1     xadvance=7     page=0  chnl=15
+char id=83   x=0     y=11    width=6     height=9     xoffset=0     yoffset=1     xadvance=6     page=0  chnl=15
+char id=84   x=101   y=0     width=7     height=9     xoffset=0    yoffset=1     xadvance=5     page=0  chnl=15
+char id=85   x=110   y=0     width=7     height=9     xoffset=0     yoffset=1     xadvance=7     page=0  chnl=15
+char id=86   x=35    y=0     width=9     height=9     xoffset=-1    yoffset=1     xadvance=6     page=0  chnl=15
+char id=87   x=0     y=0     width=11    height=9     xoffset=0    yoffset=1     xadvance=9     page=0  chnl=15
+char id=88   x=119   y=0     width=7     height=9     xoffset=1    yoffset=1     xadvance=5     page=0  chnl=15
+char id=89   x=128   y=0     width=7     height=9     xoffset=2     yoffset=1     xadvance=7     page=0  chnl=15
+char id=90   x=46    y=0     width=8     height=9     xoffset=1    yoffset=1     xadvance=6     page=0  chnl=15
+kernings count=15
+kerning first=89  second=65  amount=-1  
+kerning first=89  second=58  amount=-1  
+kerning first=86  second=65  amount=-1  
+kerning first=84  second=65  amount=-1  
+kerning first=84  second=58  amount=-1  
+kerning first=80  second=65  amount=-1  
+kerning first=76  second=89  amount=-1  
+kerning first=76  second=87  amount=-1  
+kerning first=76  second=86  amount=-1  
+kerning first=76  second=84  amount=-1  
+kerning first=49  second=49  amount=-1  
+kerning first=70  second=65  amount=-1  
+kerning first=65  second=84  amount=-1  
+kerning first=65  second=86  amount=-1  
+kerning first=65  second=89  amount=-1  

core/assets/customFont2.fnt

@@ -0,0 +1,57 @@
+info face="Arial" size=12 bold=0 italic=0 charset="" unicode=1 stretchH=100 smooth=0 aa=1 padding=1,1,1,1 spacing=2,2 outline=0
+common lineHeight=12 base=9 scaleW=256 scaleH=256 pages=1 packed=0 alphaChnl=0 redChnl=4 greenChnl=4 blueChnl=4
+page id=0 file="customFont2_0.png"
+chars count=37
+char id=48   x=40    y=11    width=6     height=9     xoffset=-1    yoffset=1     xadvance=5     page=0  chnl=15
+char id=49   x=48    y=11    width=4     height=9     xoffset=0     yoffset=1     xadvance=5     page=0  chnl=15
+char id=50   x=191   y=0     width=6     height=9     xoffset=-1    yoffset=1     xadvance=5     page=0  chnl=15
+char id=51   x=199   y=0     width=6     height=9     xoffset=-1    yoffset=1     xadvance=5     page=0  chnl=15
+char id=52   x=83    y=0     width=7     height=9     xoffset=-1    yoffset=1     xadvance=5     page=0  chnl=15
+char id=53   x=207   y=0     width=6     height=9     xoffset=-1    yoffset=1     xadvance=5     page=0  chnl=15
+char id=54   x=215   y=0     width=6     height=9     xoffset=-1    yoffset=1     xadvance=5     page=0  chnl=15
+char id=55   x=223   y=0     width=6     height=9     xoffset=-1    yoffset=1     xadvance=5     page=0  chnl=15
+char id=56   x=231   y=0     width=6     height=9     xoffset=-1    yoffset=1     xadvance=5     page=0  chnl=15
+char id=57   x=239   y=0     width=6     height=9     xoffset=-1    yoffset=1     xadvance=5     page=0  chnl=15
+char id=58   x=59    y=11    width=3     height=7     xoffset=0     yoffset=3     xadvance=3     page=0  chnl=15
+char id=65   x=24    y=0     width=9     height=9     xoffset=-1    yoffset=1     xadvance=6     page=0  chnl=15
+char id=66   x=16    y=11    width=6     height=9     xoffset=0     yoffset=1     xadvance=6     page=0  chnl=15
+char id=67   x=137   y=0     width=7     height=9     xoffset=0     yoffset=1     xadvance=7     page=0  chnl=15
+char id=68   x=146   y=0     width=7     height=9     xoffset=0     yoffset=1     xadvance=7     page=0  chnl=15
+char id=69   x=155   y=0     width=7     height=9     xoffset=0     yoffset=1     xadvance=6     page=0  chnl=15
+char id=70   x=247   y=0     width=6     height=9     xoffset=0     yoffset=1     xadvance=6     page=0  chnl=15
+char id=71   x=164   y=0     width=7     height=9     xoffset=0     yoffset=1     xadvance=7     page=0  chnl=15
+char id=72   x=173   y=0     width=7     height=9     xoffset=0     yoffset=1     xadvance=7     page=0  chnl=15
+char id=73   x=54    y=11    width=3     height=9     xoffset=0     yoffset=1     xadvance=3     page=0  chnl=15
+char id=74   x=8     y=11    width=6     height=9     xoffset=-1    yoffset=1     xadvance=5     page=0  chnl=15
+char id=75   x=182   y=0     width=7     height=9     xoffset=0     yoffset=1     xadvance=6     page=0  chnl=15
+char id=76   x=32    y=11    width=6     height=9     xoffset=0     yoffset=1     xadvance=5     page=0  chnl=15
+char id=77   x=13    y=0     width=9     height=9     xoffset=-1    yoffset=1     xadvance=7     page=0  chnl=15
+char id=78   x=56    y=0     width=7     height=9     xoffset=0     yoffset=1     xadvance=7     page=0  chnl=15
+char id=79   x=65    y=0     width=7     height=9     xoffset=0     yoffset=1     xadvance=7     page=0  chnl=15
+char id=80   x=24    y=11    width=6     height=9     xoffset=0     yoffset=1     xadvance=6     page=0  chnl=15
+char id=81   x=74    y=0     width=7     height=9     xoffset=0     yoffset=1     xadvance=7     page=0  chnl=15
+char id=82   x=92    y=0     width=7     height=9     xoffset=0     yoffset=1     xadvance=7     page=0  chnl=15
+char id=83   x=0     y=11    width=6     height=9     xoffset=0     yoffset=1     xadvance=6     page=0  chnl=15
+char id=84   x=101   y=0     width=7     height=9     xoffset=-1    yoffset=1     xadvance=5     page=0  chnl=15
+char id=85   x=110   y=0     width=7     height=9     xoffset=0     yoffset=1     xadvance=7     page=0  chnl=15
+char id=86   x=35    y=0     width=9     height=9     xoffset=-1    yoffset=1     xadvance=6     page=0  chnl=15
+char id=87   x=0     y=0     width=11    height=9     xoffset=-1    yoffset=1     xadvance=9     page=0  chnl=15
+char id=88   x=119   y=0     width=7     height=9     xoffset=-1    yoffset=1     xadvance=5     page=0  chnl=15
+char id=89   x=128   y=0     width=7     height=9     xoffset=0     yoffset=1     xadvance=7     page=0  chnl=15
+char id=90   x=46    y=0     width=8     height=9     xoffset=-1    yoffset=1     xadvance=6     page=0  chnl=15
+kernings count=15
+kerning first=89  second=65  amount=-1  
+kerning first=89  second=58  amount=-1  
+kerning first=86  second=65  amount=-1  
+kerning first=84  second=65  amount=-1  
+kerning first=84  second=58  amount=-1  
+kerning first=80  second=65  amount=-1  
+kerning first=76  second=89  amount=-1  
+kerning first=76  second=87  amount=-1  
+kerning first=76  second=86  amount=-1  
+kerning first=76  second=84  amount=-1  
+kerning first=49  second=49  amount=-1  
+kerning first=70  second=65  amount=-1  
+kerning first=65  second=84  amount=-1  
+kerning first=65  second=86  amount=-1  
+kerning first=65  second=89  amount=-1  

core/assets/customFont3.fnt

@@ -0,0 +1,42 @@
+info face="Arial" size=10 bold=0 italic=0 charset="" unicode=1 stretchH=100 smooth=0 aa=1 padding=1,1,1,1 spacing=2,2 outline=0
+common lineHeight=10 base=8 scaleW=256 scaleH=32 pages=1 packed=0 alphaChnl=0 redChnl=0 greenChnl=0 blueChnl=0
+page id=0 file="customFont3_0.png"
+chars count=26
+char id=65   x=11    y=0     width=7     height=12    xoffset=-1    yoffset=-1    xadvance=5     page=0  chnl=15
+char id=66   x=180   y=0     width=7     height=12    xoffset=0     yoffset=-1    xadvance=5     page=0  chnl=15
+char id=67   x=20    y=0     width=7     height=12    xoffset=-1    yoffset=-1    xadvance=6     page=0  chnl=15
+char id=68   x=129   y=0     width=7     height=12    xoffset=0     yoffset=-1    xadvance=6     page=0  chnl=15
+char id=69   x=138   y=0     width=6     height=12    xoffset=0     yoffset=-1    xadvance=5     page=0  chnl=15
+char id=70   x=189   y=0     width=6     height=12    xoffset=0     yoffset=-1    xadvance=5     page=0  chnl=15
+char id=71   x=29    y=0     width=7     height=12    xoffset=-1    yoffset=-1    xadvance=6     page=0  chnl=15
+char id=72   x=146   y=0     width=6     height=12    xoffset=0     yoffset=-1    xadvance=6     page=0  chnl=15
+char id=73   x=221   y=0     width=6     height=12    xoffset=0     yoffset=-1    xadvance=5     page=0  chnl=15
+char id=74   x=197   y=0     width=6     height=12    xoffset=-1    yoffset=-1    xadvance=4     page=0  chnl=15
+char id=75   x=38    y=0     width=7     height=12    xoffset=0     yoffset=-1    xadvance=5     page=0  chnl=15
+char id=76   x=205   y=0     width=6     height=12    xoffset=0     yoffset=-1    xadvance=4     page=0  chnl=15
+char id=77   x=47    y=0     width=8     height=12    xoffset=0     yoffset=-1    xadvance=7     page=0  chnl=15
+char id=78   x=154   y=0     width=7     height=12    xoffset=0     yoffset=-1    xadvance=6     page=0  chnl=15
+char id=79   x=57    y=0     width=7     height=12    xoffset=-1    yoffset=-1    xadvance=6     page=0  chnl=15
+char id=80   x=213   y=0     width=6     height=12    xoffset=0     yoffset=-1    xadvance=5     page=0  chnl=15
+char id=81   x=66    y=0     width=7     height=12    xoffset=-1    yoffset=-1    xadvance=6     page=0  chnl=15
+char id=82   x=163   y=0     width=6     height=12    xoffset=0     yoffset=-1    xadvance=6     page=0  chnl=15
+char id=83   x=75    y=0     width=7     height=12    xoffset=-1    yoffset=-1    xadvance=5     page=0  chnl=15
+char id=84   x=84    y=0     width=7     height=12    xoffset=0    yoffset=-1    xadvance=6     page=0  chnl=15
+char id=85   x=171   y=0     width=7     height=12    xoffset=0     yoffset=-1    xadvance=6     page=0  chnl=15
+char id=86   x=93    y=0     width=7     height=12    xoffset=-1    yoffset=-1    xadvance=5     page=0  chnl=15
+char id=87   x=0     y=0     width=9     height=12    xoffset=-1    yoffset=-1    xadvance=7     page=0  chnl=15
+char id=88   x=102   y=0     width=7     height=12    xoffset=-1    yoffset=-1    xadvance=5     page=0  chnl=15
+char id=89   x=111   y=0     width=7     height=12    xoffset=-1    yoffset=-1    xadvance=5     page=0  chnl=15
+char id=90   x=120   y=0     width=7     height=12    xoffset=-1    yoffset=-1    xadvance=5     page=0  chnl=15
+kernings count=11
+kerning first=89  second=65  amount=-1  
+kerning first=86  second=65  amount=-1  
+kerning first=84  second=65  amount=-1  
+kerning first=80  second=65  amount=-1  
+kerning first=76  second=89  amount=-1  
+kerning first=76  second=87  amount=-1  
+kerning first=76  second=86  amount=-1  
+kerning first=76  second=84  amount=-1  
+kerning first=65  second=89  amount=-1  
+kerning first=65  second=86  amount=-1  
+kerning first=65  second=84  amount=-1  

core/assets/customFont4.fnt

@@ -0,0 +1,66 @@
+info face="MS Gothic" size=-10 bold=0 italic=0 charset="" unicode=1 stretchH=100 smooth=0 aa=1 padding=1,2,1,2 spacing=2,2 outline=0
+common lineHeight=10 base=9 scaleW=256 scaleH=64 pages=1 packed=0 alphaChnl=0 redChnl=0 greenChnl=0 blueChnl=0
+page id=0 file="customFont4_0.png"
+chars count=62
+char id=48   x=200   y=14    width=8     height=12    xoffset=-2    yoffset=-1    xadvance=5     page=0  chnl=15
+char id=49   x=79    y=28    width=6     height=12    xoffset=-1    yoffset=-1    xadvance=5     page=0  chnl=15
+char id=50   x=40    y=28    width=8     height=12    xoffset=-2    yoffset=-1    xadvance=5     page=0  chnl=15
+char id=51   x=77    y=0     width=8     height=12    xoffset=-2    yoffset=-1    xadvance=5     page=0  chnl=15
+char id=52   x=44    y=0     width=9     height=12    xoffset=-2    yoffset=-1    xadvance=5     page=0  chnl=15
+char id=53   x=87    y=0     width=8     height=12    xoffset=-2    yoffset=-1    xadvance=5     page=0  chnl=15
+char id=54   x=97    y=0     width=8     height=12    xoffset=-2    yoffset=-1    xadvance=5     page=0  chnl=15
+char id=55   x=107   y=0     width=8     height=12    xoffset=-2    yoffset=-1    xadvance=5     page=0  chnl=15
+char id=56   x=117   y=0     width=8     height=12    xoffset=-2    yoffset=-1    xadvance=5     page=0  chnl=15
+char id=57   x=127   y=0     width=8     height=12    xoffset=-2    yoffset=-1    xadvance=5     page=0  chnl=15
+char id=65   x=137   y=0     width=8     height=12    xoffset=-2    yoffset=-1    xadvance=5     page=0  chnl=15
+char id=66   x=147   y=0     width=8     height=12    xoffset=-2    yoffset=-1    xadvance=5     page=0  chnl=15
+char id=67   x=157   y=0     width=8     height=12    xoffset=-2    yoffset=-1    xadvance=5     page=0  chnl=15
+char id=68   x=167   y=0     width=8     height=12    xoffset=-2    yoffset=-1    xadvance=5     page=0  chnl=15
+char id=69   x=177   y=0     width=8     height=12    xoffset=-2    yoffset=-1    xadvance=5     page=0  chnl=15
+char id=70   x=187   y=0     width=8     height=12    xoffset=-2    yoffset=-1    xadvance=5     page=0  chnl=15
+char id=71   x=197   y=0     width=8     height=12    xoffset=-2    yoffset=-1    xadvance=5     page=0  chnl=15
+char id=72   x=207   y=0     width=8     height=12    xoffset=-2    yoffset=-1    xadvance=5     page=0  chnl=15
+char id=73   x=87    y=28    width=5     height=12    xoffset=-1    yoffset=-1    xadvance=5     page=0  chnl=15
+char id=74   x=217   y=0     width=8     height=12    xoffset=-2    yoffset=-1    xadvance=5     page=0  chnl=15
+char id=75   x=227   y=0     width=8     height=12    xoffset=-2    yoffset=-1    xadvance=5     page=0  chnl=15
+char id=76   x=237   y=0     width=8     height=12    xoffset=-2    yoffset=-1    xadvance=5     page=0  chnl=15
+char id=77   x=0     y=0     width=9     height=12    xoffset=-2    yoffset=-1    xadvance=5     page=0  chnl=15
+char id=78   x=0     y=14    width=8     height=12    xoffset=-2    yoffset=-1    xadvance=5     page=0  chnl=15
+char id=79   x=70    y=14    width=8     height=12    xoffset=-2    yoffset=-1    xadvance=5     page=0  chnl=15
+char id=80   x=10    y=14    width=8     height=12    xoffset=-2    yoffset=-1    xadvance=5     page=0  chnl=15
+char id=81   x=20    y=14    width=8     height=12    xoffset=-2    yoffset=-1    xadvance=5     page=0  chnl=15
+char id=82   x=30    y=14    width=8     height=12    xoffset=-2    yoffset=-1    xadvance=5     page=0  chnl=15
+char id=83   x=40    y=14    width=8     height=12    xoffset=-2    yoffset=-1    xadvance=5     page=0  chnl=15
+char id=84   x=50    y=14    width=8     height=12    xoffset=-2    yoffset=-1    xadvance=5     page=0  chnl=15
+char id=85   x=60    y=14    width=8     height=12    xoffset=-2    yoffset=-1    xadvance=5     page=0  chnl=15
+char id=86   x=33    y=0     width=9     height=12    xoffset=-2    yoffset=-1    xadvance=5     page=0  chnl=15
+char id=87   x=22    y=0     width=9     height=12    xoffset=-2    yoffset=-1    xadvance=5     page=0  chnl=15
+char id=88   x=80    y=14    width=8     height=12    xoffset=-2    yoffset=-1    xadvance=5     page=0  chnl=15
+char id=89   x=11    y=0     width=9     height=12    xoffset=-2    yoffset=-1    xadvance=5     page=0  chnl=15
+char id=90   x=90    y=14    width=8     height=12    xoffset=-2    yoffset=-1    xadvance=5     page=0  chnl=15
+char id=97   x=100   y=14    width=8     height=12    xoffset=-2    yoffset=-1    xadvance=5     page=0  chnl=15
+char id=98   x=110   y=14    width=8     height=12    xoffset=-2    yoffset=-1    xadvance=5     page=0  chnl=15
+char id=99   x=120   y=14    width=8     height=12    xoffset=-2    yoffset=-1    xadvance=5     page=0  chnl=15
+char id=100  x=130   y=14    width=8     height=12    xoffset=-2    yoffset=-1    xadvance=5     page=0  chnl=15
+char id=101  x=140   y=14    width=8     height=12    xoffset=-2    yoffset=-1    xadvance=5     page=0  chnl=15
+char id=102  x=150   y=14    width=8     height=12    xoffset=-2    yoffset=-1    xadvance=5     page=0  chnl=15
+char id=103  x=160   y=14    width=8     height=12    xoffset=-2    yoffset=-1    xadvance=5     page=0  chnl=15
+char id=104  x=170   y=14    width=8     height=12    xoffset=-2    yoffset=-1    xadvance=5     page=0  chnl=15
+char id=105  x=94    y=28    width=5     height=12    xoffset=0     yoffset=-1    xadvance=5     page=0  chnl=15
+char id=106  x=70    y=28    width=7     height=12    xoffset=-2    yoffset=-1    xadvance=5     page=0  chnl=15
+char id=107  x=180   y=14    width=8     height=12    xoffset=-2    yoffset=-1    xadvance=5     page=0  chnl=15
+char id=108  x=101   y=28    width=5     height=12    xoffset=0     yoffset=-1    xadvance=5     page=0  chnl=15
+char id=109  x=55    y=0     width=9     height=12    xoffset=-2    yoffset=-1    xadvance=5     page=0  chnl=15
+char id=110  x=210   y=14    width=8     height=12    xoffset=-2    yoffset=-1    xadvance=5     page=0  chnl=15
+char id=111  x=220   y=14    width=8     height=12    xoffset=-2    yoffset=-1    xadvance=5     page=0  chnl=15
+char id=112  x=230   y=14    width=8     height=12    xoffset=-2    yoffset=-1    xadvance=5     page=0  chnl=15
+char id=113  x=240   y=14    width=8     height=12    xoffset=-2    yoffset=-1    xadvance=5     page=0  chnl=15
+char id=114  x=247   y=0     width=7     height=12    xoffset=-2    yoffset=-1    xadvance=5     page=0  chnl=15
+char id=115  x=190   y=14    width=8     height=12    xoffset=-2    yoffset=-1    xadvance=5     page=0  chnl=15
+char id=116  x=10    y=28    width=8     height=12    xoffset=-2    yoffset=-1    xadvance=5     page=0  chnl=15
+char id=117  x=20    y=28    width=8     height=12    xoffset=-2    yoffset=-1    xadvance=5     page=0  chnl=15
+char id=118  x=30    y=28    width=8     height=12    xoffset=-2    yoffset=-1    xadvance=5     page=0  chnl=15
+char id=119  x=66    y=0     width=9     height=12    xoffset=-2    yoffset=-1    xadvance=5     page=0  chnl=15
+char id=120  x=50    y=28    width=8     height=12    xoffset=-2    yoffset=-1    xadvance=5     page=0  chnl=15
+char id=121  x=60    y=28    width=8     height=12    xoffset=-2    yoffset=-1    xadvance=5     page=0  chnl=15
+char id=122  x=0     y=28    width=8     height=12    xoffset=-2    yoffset=-1    xadvance=5     page=0  chnl=15

core/assets/scores.txt

@@ -0,0 +1,11 @@
+19
+209
+314
+11
+8
+3
+6
+2
+2
+0
+4

core/build.gradle

@@ -0,0 +1,11 @@
+apply plugin: "java"
+
+sourceCompatibility = 1.6
+[compileJava, compileTestJava]*.options*.encoding = 'UTF-8'
+
+sourceSets.main.java.srcDirs = [ "src/" ]
+
+
+eclipse.project {
+    name = appName + "-core"
+}

core/src/com/jalenwinslow/game/Handler.java

@@ -0,0 +1,112 @@
+package com.jalenwinslow.game;
+
+import com.badlogic.gdx.files.FileHandle;
+import com.badlogic.gdx.graphics.Color;
+import com.badlogic.gdx.graphics.g2d.BitmapFont;
+import com.badlogic.gdx.graphics.g2d.SpriteBatch;
+import com.jalenwinslow.game.gameobjects.GameObjectHandler;
+import com.jalenwinslow.game.states.*;
+import com.jalenwinslow.game.utils.Score;
+import java.io.File;
+import java.io.IOException;
+
+public class Handler {
+    
+    //--- Propreties
+    private FileHandle scoreFile;
+    private Score score;
+    
+    private State menuState, gameState, gameOverState, pauseState, exitState;
+    private GameObjectHandler gameObjectHandler;
+    
+    private BitmapFont font;
+    private String message = "";
+    
+    //--- Constructor
+    public Handler() {
+        
+    }
+    
+    
+    //--- Methods
+    public void init() {
+        score = new Score(this);
+        
+        menuState = new MenuState(this);
+        gameState = new GameState(this);
+        gameOverState = new GameOverState(this);
+        pauseState = new PauseState(this);
+        exitState = new ExitState(this);
+        
+        gameObjectHandler = new GameObjectHandler(this);
+        
+        font = new BitmapFont();
+        font.setColor(Color.RED);
+        
+        createScoreFile();
+        
+        State.setCurrenState(menuState);
+        State.getCurrentState().init();
+        
+    }
+    
+    public void update(float dt) {
+        if (State.getCurrentState() != null) {
+            State.getCurrentState().update(dt);
+        }
+    }
+    
+    public void render(SpriteBatch batch) {
+        if (State.getCurrentState() != null) {
+            State.getCurrentState().render(batch);
+        }
+        font.draw(batch, message, 32, 32);
+    }
+    
+    public void dispose() { 
+        gameState.dispose();
+        menuState.dispose();
+        gameOverState.dispose();
+        gameObjectHandler.dispose();
+        
+        font.dispose();
+    }
+    
+    private void createScoreFile() {
+        File file = new File("scores.txt");
+        try {
+            file.createNewFile();
+        } catch (IOException ex) {
+            ex.printStackTrace();
+        }
+        scoreFile = new FileHandle(file);
+        if (scoreFile.readString().equals("")) {
+            String scoreString = "0\n"+
+                    "0\n" +
+                    "0\n"
+                    + "0\n"
+                    + "0\n"
+                    + "0\n"
+                    + "0\n"
+                    + "0\n"
+                    + "0\n"
+                    + "0\n"
+                    + "0";
+            scoreFile.writeString(scoreString, false);
+        }
+        score.getScoresFromFile();
+    }
+    
+    //--- Getters and Setters
+    public GameState getGameState() {return (GameState)gameState;}
+    public MenuState getMenuState() {return (MenuState)menuState;}
+    public State getGameOverState() {return gameOverState;}
+    public PauseState getPauseState() {return (PauseState)pauseState;}
+    public ExitState getExitState() {return (ExitState)exitState;}
+    public GameObjectHandler getGameObjectHandler() {return gameObjectHandler;}
+    public FileHandle getScoreFile() {return scoreFile;}
+    public Score getScore() {return score;}
+    
+    public String getMessage() {return message;}
+    public void setMessage(String message) {this.message = message;}
+}

core/src/com/jalenwinslow/game/Main.java

@@ -0,0 +1,48 @@
+package com.jalenwinslow.game;
+
+import com.badlogic.gdx.ApplicationAdapter;
+import com.badlogic.gdx.Gdx;
+import com.badlogic.gdx.files.FileHandle;
+import com.badlogic.gdx.graphics.Texture;
+import com.badlogic.gdx.graphics.g2d.BitmapFont;
+import com.badlogic.gdx.graphics.g2d.SpriteBatch;
+import com.badlogic.gdx.graphics.g2d.TextureRegion;
+
+public class Main extends ApplicationAdapter {
+    public static final int WIDTH = 640, HEIGHT = 640;
+    
+    SpriteBatch batch;
+    Handler handler;
+    //BitmapFont bf;
+	
+    @Override
+    public void create () {
+        batch = new SpriteBatch();
+        handler = new Handler();
+        handler.init();
+        //bf = new BitmapFont(Gdx.files.internal("b&w_DodgeGame_font1.fnt"), new TextureRegion(new Texture("b&w_DodgeGame_font1.png")));
+    }
+
+    @Override
+    public void render () {
+        //Update
+        handler.update(Gdx.graphics.getDeltaTime());
+        
+        
+        //Render
+	batch.begin();
+        
+        handler.render(batch); 
+        //bf.draw(batch, "Hello", 32, 32);
+        //bf.draw(batch, str, WIDTH, WIDTH, WIDTH, HEIGHT, true)
+	batch.end();
+        
+        
+    }
+	
+    @Override
+    public void dispose () {
+        batch.dispose();
+        handler.dispose();
+    }
+}

core/src/com/jalenwinslow/game/gameobjects/Arrow.java

@@ -0,0 +1,109 @@
+package com.jalenwinslow.game.gameobjects;
+
+import com.badlogic.gdx.graphics.Texture;
+import com.badlogic.gdx.graphics.g2d.SpriteBatch;
+import com.badlogic.gdx.graphics.g2d.TextureRegion;
+import com.badlogic.gdx.math.Rectangle;
+import com.jalenwinslow.game.Handler;
+import com.jalenwinslow.game.Main;
+import com.jalenwinslow.game.states.State;
+
+public class Arrow extends GameObject {
+    
+    //--- Propreties
+    public static final double MAX_SPEED = 4;
+    public static final double MIN_SPEED = 2.5; //normal -> maxSpeed: 4 && minSpeed: 2.5
+    
+    private int dir;
+    private double speed;
+    private double vecX, vecY;
+    //private static Texture boundsTexture = new Texture("DodgeGame_boundsMask.png");
+    
+    //--- Constructor
+    public Arrow(Handler handler, double x, double y, TextureRegion image, int dir) {
+        super(handler, x, y, image);
+        this.dir = dir;
+        speed = MIN_SPEED;
+        vecX = 0;
+        vecY = 0;
+        bounds = new Rectangle((int)x, (int)y, Main.WIDTH/40, Main.HEIGHT/40);
+    }
+    
+    
+    //--- Methods
+    @Override
+    public void update(float dt) {
+        isArrowVisible();
+        updateSpeed();
+        if (dir == 0) vecX = speed;
+        if (dir == 1) vecY = speed;
+        if (dir == 2) vecX = -speed;
+        if (dir == 3) vecY = -speed;
+        x += vecX;
+        y += vecY;
+        if (y < 96) depth = 0;
+        else depth = (int)y + Main.HEIGHT/20;
+        setBoundsPosition();
+        checkCollision();
+    }
+    
+    @Override
+    public void render(SpriteBatch batch) {
+        batch.draw(image, (int)x, (int)y, Main.WIDTH/10, Main.HEIGHT/10);
+        //batch.draw(boundsTexture, bounds.x, bounds.y, bounds.width, bounds.height);
+    }
+    
+    @Override
+    public void dispose() {
+        
+    }
+    
+    private void isArrowVisible() {
+        if (x < -128 || x > Main.WIDTH + Main.WIDTH/5 ||
+                y < -128 || y > Main.HEIGHT + Main.HEIGHT/5) {
+            //handler.getGameState().getArrowGen().getArrows().removeValue(this, false);
+            handler.getGameState().getArrowGen().getArrows().removeValue(this, false);
+        }
+    }
+    
+    private void updateSpeed() {
+        int modifier = handler.getGameState().getTimer().getTime() / 60;
+        speed = MIN_SPEED + (0.05 * modifier);
+        if (speed >= MAX_SPEED) speed = MAX_SPEED;
+    }
+    
+    private void setBoundsPosition() {
+        switch (dir) {
+            case 0: bounds.setPosition((float)x + 48, (float)y + 26); break;
+            case 1: bounds.setPosition((float) x + 26, (float)y + 48); break;
+            case 2: bounds.setPosition((float)x, (float)y + 26); break;
+            case 3: bounds.setPosition((float)x + 26, (float)y);break;
+        }
+    }
+    
+    private void checkCollision() {
+        if (bounds.overlaps(handler.getGameState().getPlayer().getBounds())) {
+            handler.getGameState().getTimer().stop();
+            State.setCurrenState(handler.getGameOverState());
+            State.getCurrentState().init();
+            handler.getGameObjectHandler().dispose();
+            handler.getGameState().dispose();
+        }
+        for (int i = 0; i < handler.getGameObjectHandler().getGameObjects().size; i++) {
+            if (handler.getGameObjectHandler().getGameObjects().get(i).toString().equalsIgnoreCase("TallWall")) {
+                TallWall wall = (TallWall)handler.getGameObjectHandler().getGameObjects().get(i);
+                if (bounds.overlaps(wall.getNoArrowBounds())) {
+                    wall.setHitPoints(wall.getHitPoints() - 6);
+                    handler.getGameState().getArrowGen().getArrows().removeValue(this, false);
+                }
+            }
+        }
+    }
+    
+    @Override
+    public String toString() {return "Arrow";}
+    
+    //--- Getters and Setters
+    
+    
+}

core/src/com/jalenwinslow/game/gameobjects/ArrowGenerator.java

@@ -0,0 +1,120 @@
+ package com.jalenwinslow.game.gameobjects;
+
+import com.badlogic.gdx.graphics.Color;
+import com.badlogic.gdx.graphics.g2d.BitmapFont;
+import com.badlogic.gdx.graphics.g2d.SpriteBatch;
+import com.badlogic.gdx.graphics.g2d.TextureRegion;
+import com.badlogic.gdx.utils.Array;
+import com.jalenwinslow.game.Handler;
+import com.jalenwinslow.game.Main;
+import java.util.Random;
+
+public class ArrowGenerator extends GameObject {
+    
+    //--- Propreties
+    private static final int MAX_ARROW_LIMIT = 40, MIN_ARROW_LIMIT = 5; // max: 40, min: 5
+    private static final double ARROW_DEPLOY_END_TIME = 0.07, ARROW_DEPLOY_START_TIME = 0.5; // endTime: 0.07, startTime: 0.5
+    
+    private int currentArrowLimit;
+    private double currentDeployTime;
+    private int highestAmountOfArrowsAtOnce;
+    private int amountOfArrowsCreated;
+    
+    private Random rand;
+    private TextureRegion[][] arrowTextures;
+    private Array<Arrow> arrows;
+    private float elapsedTime;
+    //private BitmapFont font;
+    
+    //--- Constructor
+    public ArrowGenerator(Handler handler, double x, double y, TextureRegion image) {
+        super(handler, x, y, image);
+        
+        currentArrowLimit = MIN_ARROW_LIMIT;
+        currentDeployTime = ARROW_DEPLOY_START_TIME;
+        highestAmountOfArrowsAtOnce = 0;
+        amountOfArrowsCreated = 0;
+        
+        rand = new Random();
+        arrowTextures = image.split(16, 16);
+        arrows = new Array<Arrow>();
+        elapsedTime = -3;
+        //font = new BitmapFont();
+        //font.setColor(Color.RED);
+    }
+    
+    
+    //--- Methods
+    @Override
+    public void update(float dt) {
+        elapsedTime += dt;
+        updateArrows();
+        if (arrows.size < currentArrowLimit && elapsedTime >= currentDeployTime) {
+            addArrow();
+            amountOfArrowsCreated++;
+            if (arrows.size > highestAmountOfArrowsAtOnce) highestAmountOfArrowsAtOnce = arrows.size;
+        }
+        for (Arrow arrow : arrows) arrow.update(dt);
+    }
+    
+    @Override
+    public void render(SpriteBatch batch) {
+        for (Arrow arrow : arrows) {
+            arrow.render(batch);
+        }
+        //font.draw(batch, "Current amount of arrows: " + String.valueOf(arrows.size), 64, 64);
+    }
+    
+    @Override
+    public void dispose() {
+        //font.dispose();
+    }
+    
+    @Override
+    public String toString() {return "ArrowGenerator";}
+    
+    private void updateArrows() {
+        int modifier = handler.getGameState().getTimer().getTime() / 30;
+        currentArrowLimit = MIN_ARROW_LIMIT + (1 * modifier);
+        if (currentArrowLimit > MAX_ARROW_LIMIT) currentArrowLimit = MAX_ARROW_LIMIT;
+        if (currentArrowLimit > 10 && handler.getGameState().getTimer().getTime() % 40 == 0) {
+            currentDeployTime -= 0.1;
+            if (currentDeployTime < ARROW_DEPLOY_END_TIME) currentDeployTime = ARROW_DEPLOY_END_TIME;
+        }
+    }
+    
+    private void addArrow() {
+            int dir = rand.nextInt(4);
+            TextureRegion texture = arrowTextures[0][dir];
+            int xx = Main.WIDTH, yy = Main.HEIGHT;
+            if (dir == 0 || dir == 2) {
+                if (dir == 0) {
+                    xx = -96;
+                }
+                if (dir == 2) {
+                    xx = Main.WIDTH + 32;
+                }
+                yy = rand.nextInt(Main.HEIGHT - 160) + 64;
+            } 
+            else {
+                
+                if (dir == 1) {
+                    yy = -96;
+                }
+                if (dir == 3) {
+                    yy = Main.HEIGHT + 32;
+                }
+                xx = rand.nextInt(Main.WIDTH - 160) + 64;
+            }
+            
+            //handler.getGameObjectHandler().add(new Arrow(handler, xx, yy, texture, dir));
+            arrows.add(new Arrow(handler, xx, yy, texture, dir));
+            elapsedTime = 0;
+    }
+    
+    //--- Getters and Setters
+    public Array<Arrow> getArrows() {return arrows;}
+    public int getAmountOfArrowsCreated() {return amountOfArrowsCreated;}
+    public int getHighestAmountOfArrowsAtOnce() {return highestAmountOfArrowsAtOnce;}
+    
+}

core/src/com/jalenwinslow/game/gameobjects/Button.java

@@ -0,0 +1,105 @@
+package com.jalenwinslow.game.gameobjects;
+
+import com.badlogic.gdx.Gdx;
+import com.badlogic.gdx.Input.Keys;
+import com.badlogic.gdx.graphics.Color;
+import com.badlogic.gdx.graphics.g2d.BitmapFont;
+import com.badlogic.gdx.graphics.g2d.SpriteBatch;
+import com.badlogic.gdx.graphics.g2d.TextureRegion;
+import com.badlogic.gdx.math.Rectangle;
+import com.badlogic.gdx.utils.Align;
+import com.jalenwinslow.game.Handler;
+import com.jalenwinslow.game.Main;
+import com.jalenwinslow.game.states.State;
+
+public class Button extends GameObject {
+    
+    //--- Propreties
+    private TextureRegion[][] images;
+    private BitmapFont font;
+    private String message;
+    private int imageIndex;
+    private boolean drawHealth;
+    private HealthBar health;
+    private int hitPoints;
+    
+    //--- Constructor
+    public Button(Handler handler, double x, double y, TextureRegion image, String message, int scale) {
+        super(handler, x, y, image);
+        bounds = new Rectangle((int)x, (int)y, Main.WIDTH/4+32, Main.HEIGHT/8);
+        images = image.split(112, 48);
+        font = new BitmapFont(Gdx.files.internal("customFont4.fnt"));
+        font.getData().setScale(scale);
+        font.setColor(Color.BLACK);
+        this.message = message;
+        imageIndex = 0;
+        drawHealth = false;
+        hitPoints = 60;
+        health = new HealthBar(handler, x, y, new TextureRegion(handler.getMenuState().getHealthTexture()), hitPoints);
+        health.setHealth(0);
+    }
+    
+    
+    //--- Methods
+    @Override
+    public void update(float dt) {
+        //checkIfMouseWithin();
+        checkPlayerCollision();
+        if (hitPoints < 0) {hitPoints = 0;}
+        health.setHealth(hitPoints);
+        if (hitPoints >= 60) {
+            buttonAction();
+        }
+    }
+    
+    @Override
+    public void render(SpriteBatch batch) {
+        batch.draw(images[imageIndex][0], bounds.x, bounds.y, bounds.width, bounds.height);
+        font.draw(batch, message, bounds.x+bounds.width/2, bounds.y+bounds.height, 0, Align.center, false);
+        if (drawHealth) health.render(batch);
+    }
+    
+    @Override
+    public void dispose() {
+        font.dispose();
+    }
+    
+    @Override
+    public String toString() {return "Button";}
+    
+    private void buttonAction() {
+        if (message.equalsIgnoreCase("play")) {
+            State.setCurrenState(handler.getGameState());
+            handler.getGameObjectHandler().dispose();
+            handler.getGameState().init();
+            handler.getMenuState().dispose();
+        } else if (message.equalsIgnoreCase("Stats")) {
+            handler.getMenuState().setSubState(1);
+        } else if (message.equalsIgnoreCase("Exit")) {
+            State.setCurrenState(handler.getExitState());
+            handler.getGameObjectHandler().dispose();
+            State.getCurrentState().init();
+            handler.getMenuState().dispose();
+        } else if (message.equalsIgnoreCase("back")) {
+            handler.getMenuState().setSubState(0);
+        }
+    }
+    
+    private void checkPlayerCollision() {
+        if (bounds.overlaps(handler.getMenuState().getPlayer().getBounds())) {
+            drawHealth = true;
+            imageIndex = 1;
+            if (Gdx.input.isKeyPressed(Keys.E)) {
+                hitPoints++;
+            } else {hitPoints--;}
+        } else {
+            drawHealth = false;
+            imageIndex = 0;
+            hitPoints--;
+        }
+    }
+    
+    //--- Getters and Setters
+    
+    
+}

core/src/com/jalenwinslow/game/gameobjects/GameObject.java

@@ -0,0 +1,48 @@
+package com.jalenwinslow.game.gameobjects;
+
+import com.badlogic.gdx.graphics.g2d.SpriteBatch;
+import com.badlogic.gdx.graphics.g2d.TextureRegion;
+import com.badlogic.gdx.math.Rectangle;
+import com.jalenwinslow.game.Handler;
+
+public abstract class GameObject {
+    
+    //--- Propreties
+    protected Handler handler;
+    protected double x, y;
+    protected int depth;
+    protected TextureRegion image;
+    protected Rectangle bounds;
+    
+    //--- Constructor
+    public GameObject(Handler handler, double x, double y, TextureRegion image) {
+        this.handler = handler;
+        this.x = x;
+        this.y = y;
+        this.depth = 0;
+        this.image = image;
+    }
+    
+    
+    //--- Methods
+    public abstract void update(float dt);
+    
+    public abstract void render(SpriteBatch batch);
+    
+    public abstract void dispose();
+    
+    @Override
+    public abstract String toString();
+    
+    public boolean getCollision(double x, double y) {
+        return (x <= bounds.x + bounds.width && x >= bounds.x && y >= bounds.y && y <= bounds.y + bounds.height);
+    }
+    
+    //--- Getters and Setters
+    public double getX() {return x;}
+    public double getY() {return y;}
+    public int getDepth() {return depth;}
+    public Rectangle getBounds() {return bounds;}
+    
+    
+}

core/src/com/jalenwinslow/game/gameobjects/GameObjectHandler.java

@@ -0,0 +1,78 @@
+package com.jalenwinslow.game.gameobjects;
+
+import com.badlogic.gdx.graphics.g2d.SpriteBatch;
+import com.badlogic.gdx.utils.Array;
+import com.jalenwinslow.game.Handler;
+
+public class GameObjectHandler {
+    
+    //--- Propreties
+    private Handler handler;
+    private Array<GameObject> gameObjects;
+    private int numberOfShortWalls;
+    private int numberOfTallWalls;
+    private int highestNumberOfShortWallsAtOnce;
+    private int highestNumberOfTallWallsAtOnce;
+    
+    //--- Constructor
+    public GameObjectHandler(Handler handler) {
+        this.handler = handler;
+        this.gameObjects = new Array<GameObject>();
+        numberOfShortWalls = 0;
+        numberOfTallWalls = 0;
+        highestNumberOfShortWallsAtOnce = 0;
+        highestNumberOfTallWallsAtOnce = 0;
+    }
+    
+    
+    //--- Methods
+    public void update(float dt) {
+        sort();
+        numberOfShortWalls = 0;
+        numberOfTallWalls = 0;
+        for (int i = 0; i < gameObjects.size; i++) {
+            //System.out.println(gameObjects.get(i).getClass().toString());
+            //if (gameObjects.get(i).toString().equalsIgnoreCase("TallWall")) {handler.setMessage("Its here");}
+            if (gameObjects.get(i).toString().equalsIgnoreCase("ShortWall")) {numberOfShortWalls++;}
+            if (gameObjects.get(i).toString().equalsIgnoreCase("TallWall")) numberOfTallWalls++;
+            gameObjects.get(i).update(dt);
+        }
+        numberOfShortWalls -= 10;
+        if (numberOfShortWalls > highestNumberOfShortWallsAtOnce) highestNumberOfShortWallsAtOnce = numberOfShortWalls;
+        if (numberOfTallWalls > highestNumberOfTallWallsAtOnce) highestNumberOfTallWallsAtOnce = numberOfTallWalls;
+        //handler.setMessage("number of short walls: " + numberOfShortWalls);
+    }
+    
+    public void render(SpriteBatch batch) {
+        
+        for (GameObject gameObj : gameObjects) {
+            gameObj.render(batch);
+        }
+        
+    }
+    
+    public void dispose() {
+        gameObjects.clear();
+    }
+    
+    public void sort() {
+        for (int i = 0; i < gameObjects.size - 1; i++) {
+            if (gameObjects.get(i).depth <= gameObjects.get(i+1).depth) {
+                gameObjects.swap(i, i+1);
+            }
+        }
+    }
+    
+    public void add(GameObject gameObject) {
+        gameObjects.add(gameObject);
+    }
+    
+    //--- Getters and Setters
+    public Array getGameObjects() {return gameObjects;}
+    public int getNumberOfShortWalls() {return numberOfShortWalls;}
+    public int getHighestNumberOfShortWallsAtOnce() {return highestNumberOfShortWallsAtOnce;}
+    public int getHighestNumberOfTallWallsAtOnce() {return highestNumberOfTallWallsAtOnce;}
+    
+    public void setGameObjects(Array array) {this.gameObjects = array;}
+    
+}

core/src/com/jalenwinslow/game/gameobjects/HealthBar.java

@@ -0,0 +1,57 @@
+package com.jalenwinslow.game.gameobjects;
+
+import com.badlogic.gdx.graphics.g2d.SpriteBatch;
+import com.badlogic.gdx.graphics.g2d.TextureRegion;
+import com.badlogic.gdx.math.Rectangle;
+import com.jalenwinslow.game.Handler;
+import com.jalenwinslow.game.Main;
+
+public class HealthBar extends GameObject {
+    
+    //--- Propreties
+    private TextureRegion backHealth;
+    private TextureRegion healthArea;
+    
+    private float health;
+    private float totalHealth;
+    
+    //--- Constructor
+    public HealthBar(Handler handler, double x, double y, TextureRegion image, int totalHealth) {
+        super(handler, x, y, image);
+        bounds = new Rectangle((int)x, (int)y, Main.WIDTH/10, Main.HEIGHT/40);
+        TextureRegion[][] images = image.split(16, 4);
+        backHealth = images[0][0];
+        healthArea = images[1][0];
+        this.totalHealth = totalHealth;
+        this.health = this.totalHealth;
+    }
+    
+    
+    //--- Methods
+    @Override
+    public void update(float dt) {
+        
+    }
+    
+    @Override
+    public void render(SpriteBatch batch) {
+        batch.draw(backHealth, bounds.x, bounds.y, bounds.width, bounds.height);
+        batch.draw(healthArea, bounds.x + 4, bounds.y + 4, (bounds.width - 8) * (health/totalHealth), bounds.height - 8);
+    }
+    
+    @Override
+    public void dispose() {
+        
+    }
+    
+    @Override
+    public String toString() {return "HealthBar";}
+    
+    //--- Getters and Setters
+    public float getHealth() {return health;}
+    public float getTotalHealth() {return totalHealth;}
+    
+    public void setHealth(float health) {this.health = health;}
+    public void setTotalHealth(float totalHealth) {this.totalHealth = totalHealth;}
+    
+}

core/src/com/jalenwinslow/game/gameobjects/PlayButton.java

@@ -0,0 +1,68 @@
+package com.jalenwinslow.game.gameobjects;
+
+import com.badlogic.gdx.Gdx;
+import com.badlogic.gdx.graphics.g2d.SpriteBatch;
+import com.badlogic.gdx.graphics.g2d.TextureRegion;
+import com.badlogic.gdx.math.Rectangle;
+import com.jalenwinslow.game.Handler;
+import com.jalenwinslow.game.Main;
+import com.jalenwinslow.game.states.State;
+
+public class PlayButton extends GameObject {
+    
+    //--- Propreties
+    TextureRegion[][] btnImages;
+    TextureRegion currentTexture;
+    
+    //--- Constructor
+    public PlayButton(Handler handler, double x, double y, TextureRegion image) {
+        super(handler, x, y, image);
+        btnImages = image.split(image.getRegionWidth(), 48);//image.getRegionHeight()/3);
+        currentTexture = btnImages[0][0];
+        bounds = new Rectangle((int)x - Main.WIDTH/8, (int)y - Main.HEIGHT/16, Main.WIDTH/4, Main.HEIGHT/8);
+    }
+    
+    
+    //--- Methods
+    @Override
+    public void update(float dt) {
+        handleAnimation();
+        if (Gdx.input.justTouched() && Gdx.input.getX() < bounds.x + bounds.width && Gdx.input.getX() > bounds.x &&
+                Gdx.input.getY() < bounds.y + bounds.height && Gdx.input.getY() > bounds.y) {
+            State.setCurrenState(handler.getGameState());
+            handler.getGameState().init();
+            handler.getMenuState().dispose();
+        }
+    }
+    
+    @Override
+    public void render(SpriteBatch batch) {  
+        batch.draw(currentTexture, (int)bounds.x, (int)bounds.y, Main.WIDTH/4, Main.HEIGHT/8);
+     }
+    
+    @Override
+    public void dispose() {
+          
+    }
+    
+    @Override
+    public String toString() {return "PlayButton";}
+    
+    public void handleAnimation() {
+        if (Gdx.input.getX() < bounds.x + bounds.width && Gdx.input.getX() > bounds.x &&
+                Gdx.input.getY() < bounds.y + bounds.height && Gdx.input.getY() > bounds.y) {
+            if (Gdx.input.isTouched()) {
+                currentTexture = btnImages[2][0];
+            } else {
+                currentTexture = btnImages[1][0];
+            }
+        } else {
+            currentTexture = btnImages[0][0];
+        }
+         
+    }
+    
+    //--- Getters and Setters
+    
+    
+}

core/src/com/jalenwinslow/game/gameobjects/Player.java

@@ -0,0 +1,258 @@
+package com.jalenwinslow.game.gameobjects;
+
+import com.badlogic.gdx.Gdx;
+import com.badlogic.gdx.Input.Keys;
+import com.badlogic.gdx.graphics.Texture;
+import com.badlogic.gdx.graphics.g2d.Animation;
+import com.badlogic.gdx.graphics.g2d.Animation.PlayMode;
+import com.badlogic.gdx.graphics.g2d.SpriteBatch;
+import com.badlogic.gdx.graphics.g2d.TextureRegion;
+import com.badlogic.gdx.math.Rectangle;
+import com.badlogic.gdx.utils.Array;
+import com.jalenwinslow.game.Handler;
+import com.jalenwinslow.game.Main;
+import com.jalenwinslow.game.gameobjects.TallWall.TallWallStates;
+
+public class Player extends GameObject {
+    
+    //--- Propreties
+    public static final double SPEED = 3.0;
+    
+    private int dir;
+    private double vecX, vecY;
+    private int wood;
+    private int highestNumberOfTallWallsCreated;
+    private int highestNumberOfTallWallsDestroyed;
+    private int numberOfWoodPickedUp;
+    
+    private Animation<TextureRegion> animDown, animUp, animRight;
+    private TextureRegion texture;
+    private float elapsedTime = 0;
+    private Rectangle boundsFeet;
+    
+    //private Texture boundsTexture = new Texture("DodgeGame_boundsMask.png");
+    
+    //--- Constructor
+    public Player(Handler handler, double x, double y, TextureRegion image) {
+        super(handler, x, y, image);
+        
+        dir = 3;
+        vecX = 0;
+        vecY = 0;
+        wood = 0;
+        highestNumberOfTallWallsCreated = 0;
+        highestNumberOfTallWallsDestroyed = 0;
+        numberOfWoodPickedUp = 0;
+        createAnimation();
+        bounds = new Rectangle((int)x, (int)y, Main.WIDTH/10 - 40, Main.HEIGHT/10 - 24);
+        boundsFeet = new Rectangle((int)x, (int)y, Main.WIDTH/10-40, Main.HEIGHT/10 -48);
+    }
+    
+    
+    //--- Methods
+    @Override
+    public void update(float dt) {
+        elapsedTime += dt;
+        handleInput();
+        handleCollision();
+        handleAnimation();
+        x += vecX;
+        y += vecY;
+        depth = (int)y + Main.HEIGHT/20;
+        bounds.setPosition((float)x + 20, (float)y + 8);
+        boundsFeet.setPosition((float)x + 20, (float)y);
+        checks();
+    }
+    
+    @Override
+    public void render(SpriteBatch batch) {
+        batch.draw(texture, (int)x, (int)y, Main.WIDTH/10, Main.HEIGHT/10);
+        //batch.draw(boundsTexture, bounds.x, bounds.y, bounds.width, bounds.height);
+    }
+    
+    @Override
+    public void dispose() {
+        //image.dispose();
+        //boundsTexture.dispose();
+    }
+    
+    private void createAnimation() {
+        TextureRegion[][] splitTexture = image.split(16, 16);
+        Array<TextureRegion> array = new Array(splitTexture.length * splitTexture[0].length);
+        for (int i = 0; i < splitTexture[0].length; i++) {
+            array.add(splitTexture[0][i]);
+        }
+        animDown = new Animation(0.1f, array, PlayMode.LOOP);
+        array.clear();
+        
+        for (TextureRegion t : splitTexture[1]) {
+            array.add(t);
+        }
+        animUp = new Animation(0.1f, array, PlayMode.LOOP);
+        array.clear();
+        
+        for (TextureRegion t : splitTexture[2]) {
+            array.add(t);
+        }
+        animRight = new Animation(0.1f, array, PlayMode.LOOP);
+        array.clear();
+        texture = animDown.getKeyFrame(elapsedTime);
+    }
+    
+    private void handleInput() {
+        if ( (Gdx.input.isKeyPressed(Keys.W) && Gdx.input.isKeyPressed(Keys.S)) || 
+                (!Gdx.input.isKeyPressed(Keys.W) && !Gdx.input.isKeyPressed(Keys.S)) ) {
+            vecY = 0;
+        } else if (Gdx.input.isKeyPressed(Keys.W)) {
+            vecY = SPEED;
+            dir = 1;
+        } else if (Gdx.input.isKeyPressed(Keys.S)) {
+            vecY = -SPEED;
+            dir = 3;
+        }
+        
+        if ( (Gdx.input.isKeyPressed(Keys.A) && Gdx.input.isKeyPressed(Keys.D)) || 
+                (!Gdx.input.isKeyPressed(Keys.A) && !Gdx.input.isKeyPressed(Keys.D)) ) {
+            vecX = 0;
+        } else if (Gdx.input.isKeyPressed(Keys.A)) {
+            vecX = -SPEED;
+            dir = 2;
+        } else if (Gdx.input.isKeyPressed(Keys.D)) {
+            vecX = SPEED;
+            dir = 0;
+        }
+        
+        if ( (Gdx.input.isKeyJustPressed(Keys.SPACE)) && wood >= 7) {
+            int arrayX = ((int)(boundsFeet.x + (boundsFeet.width/2))/64);
+            int arrayY = ((int)(boundsFeet.y + (boundsFeet.height/2))/64);
+            handler.getGameState().getGrid().setFree(false, arrayX, arrayY);
+            handler.getGameObjectHandler().add(new TallWall(handler, arrayX * 64, arrayY *64, new TextureRegion(handler.getGameState().getTallWallTexture())) );
+            wood -= 7;
+        }
+        
+    }
+    
+    private void handleCollision() {
+        if (boundsFeet.x + boundsFeet.width + vecX >= Main.WIDTH-64) {vecX = 0;}
+        if (boundsFeet.x + vecX <= 64) vecX = 0;
+        if (boundsFeet.y + boundsFeet.height + vecY >= Main.HEIGHT-64) vecY = 0;
+        if (boundsFeet.y + vecY <= 0) {vecY = 0;}
+        
+        handleWallCollision();
+    }
+    
+    private void handleWallCollision() {// Also breaking walls
+        
+        for (int i = 0; i < handler.getGameObjectHandler().getGameObjects().size; i++) {
+            if (handler.getGameObjectHandler().getGameObjects().get(i).toString().equalsIgnoreCase("ShortWall")) {
+                ShortWall wall = (ShortWall)handler.getGameObjectHandler().getGameObjects().get(i);
+                if (wall.getShowHealthBounds() != null && boundsFeet.overlaps(wall.getShowHealthBounds()) && Gdx.input.isKeyPressed(Keys.E)) {
+                    if (wall.getHitPoints() > 0) {
+                        wall.setHitPoints(wall.getHitPoints() - 1);
+                    }
+                }
+                if (vecX < 0) {
+                    if (wall.getCollision(boundsFeet.x + vecX, boundsFeet.y) || 
+                            wall.getCollision(boundsFeet.x + vecX, boundsFeet.y + boundsFeet.height)) {
+                        vecX = 0;
+                    }
+                } else if (vecX > 0) {
+                    if (wall.getCollision(boundsFeet.x + boundsFeet.width + vecX, boundsFeet.y) ||
+                            wall.getCollision(boundsFeet.x + boundsFeet.width + vecX, boundsFeet.y + boundsFeet.height)) {
+                        vecX = 0;
+                    }
+                }
+
+                if (vecY < 0) {
+                    if (wall.getCollision(boundsFeet.x, boundsFeet.y + vecY) || 
+                            wall.getCollision(boundsFeet.x + boundsFeet.width, boundsFeet.y + vecY)) {
+                        vecY = 0;
+                    }
+                } else if (vecY > 0) {
+                    if (wall.getCollision(boundsFeet.x, boundsFeet.y + boundsFeet.height + vecY) || 
+                            wall.getCollision(boundsFeet.x + boundsFeet.width, boundsFeet.y + boundsFeet.height + vecY)) {
+                        vecY = 0;
+                    }
+                }
+            }
+            if (handler.getGameObjectHandler().getGameObjects().get(i).toString().equalsIgnoreCase("TallWall")) {
+                TallWall wall = (TallWall)handler.getGameObjectHandler().getGameObjects().get(i);
+                if (wall.getState() == TallWallStates.startCreation) {
+                    if (wall.getShowHealthBounds() != null && boundsFeet.overlaps(wall.getShowHealthBounds()) && Gdx.input.isKeyPressed(Keys.E)) {
+                        if (wall.getHitPoints() < wall.getTotalHitPoints()) {
+                            wall.setHitPoints(wall.getHitPoints() + 1);
+                        }
+                    }
+                }
+                
+                if (vecX < 0) {
+                    if (wall.getCollision(boundsFeet.x + vecX, boundsFeet.y) || 
+                            wall.getCollision(boundsFeet.x + vecX, boundsFeet.y + boundsFeet.height)) {
+                        vecX = 0;
+                    }
+                } else if (vecX > 0) {
+                    if (wall.getCollision(boundsFeet.x + boundsFeet.width + vecX, boundsFeet.y) ||
+                            wall.getCollision(boundsFeet.x + boundsFeet.width + vecX, boundsFeet.y + boundsFeet.height)) {
+                        vecX = 0;
+                    }
+                }
+
+                if (vecY < 0) {
+                    if (wall.getCollision(boundsFeet.x, boundsFeet.y + vecY) || 
+                            wall.getCollision(boundsFeet.x + boundsFeet.width, boundsFeet.y + vecY)) {
+                        vecY = 0;
+                    }
+                } else if (vecY > 0) {
+                    if (wall.getCollision(boundsFeet.x, boundsFeet.y + boundsFeet.height + vecY) || 
+                            wall.getCollision(boundsFeet.x + boundsFeet.width, boundsFeet.y + boundsFeet.height + vecY)) {
+                        vecY = 0;
+                    }
+                }
+            }
+        }
+    }
+    
+    private void handleAnimation() {
+        Animation<TextureRegion> currentAnimation;
+        if (vecY > 0) dir = 1; 
+        else if (vecY < 0) dir = 3;
+        else if (vecX > 0) dir = 0;
+        else if (vecX < 0) dir = 2;
+        
+        switch (dir) {
+            case 0: currentAnimation = animRight; break;
+            case 1: currentAnimation = animUp; break;
+            case 2: currentAnimation = animRight; break;
+            case 3: currentAnimation = animDown; break;
+            default: currentAnimation = animDown; break;
+        }
+        
+        if (vecX != 0 || vecY != 0)
+            texture = currentAnimation.getKeyFrame(elapsedTime);
+        else texture = currentAnimation.getKeyFrame(0);
+        
+        if (texture.isFlipX()) texture.flip(true, false);
+        if (dir == 2 && !texture.isFlipX()) texture.flip(true, false);
+    }
+    
+    private void checks() {
+        if (wood < 0) wood = 0;
+        if (wood > 20) wood = 20;
+    }
+    
+    @Override
+    public String toString() {return "Player";}
+    
+    //--- Getters and Setters
+    public Rectangle getBoundsFeet() {return boundsFeet;}
+    public int getWood() {return wood;}
+    public int getHighestNumberOfTallWallsCreated() {return highestNumberOfTallWallsCreated;}
+    public int getHighestNumberOfTallWallsDestroyed() {return highestNumberOfTallWallsDestroyed;}
+    public int getNumberOfWoodPickedUp() {return numberOfWoodPickedUp;}
+    
+    public void setWood(int wood) {this.wood = wood;}
+    public void setHighestNumberOfTallWallsCreated(int tallWalls) {this.highestNumberOfTallWallsCreated = tallWalls;}
+    public void setHighestNumberOfTallWallsDestroyed(int tallWalls) {this.highestNumberOfTallWallsDestroyed = tallWalls;}
+    public void setNumberOfWoodPickedUp(int wood) {this.numberOfWoodPickedUp = wood;}
+    
+}

core/src/com/jalenwinslow/game/gameobjects/ScoreBoard.java

@@ -0,0 +1,78 @@
+package com.jalenwinslow.game.gameobjects;
+
+import com.badlogic.gdx.Gdx;
+import com.badlogic.gdx.graphics.Color;
+import com.badlogic.gdx.graphics.g2d.BitmapFont;
+import com.badlogic.gdx.graphics.g2d.SpriteBatch;
+import com.badlogic.gdx.graphics.g2d.TextureRegion;
+import com.badlogic.gdx.math.Rectangle;
+import com.badlogic.gdx.utils.Align;
+import com.jalenwinslow.game.Handler;
+import com.jalenwinslow.game.Main;
+
+public class ScoreBoard extends GameObject {
+    
+    //--- Propreties
+    private BitmapFont font;
+    private String message1;
+    private String messageOfScores;
+    
+    //--- Constructor
+    public ScoreBoard(Handler handler, double x, double y, TextureRegion image) {
+        super(handler, x, y, image);
+        bounds = new Rectangle((int)x, (int)y, Main.WIDTH*3/4, Main.HEIGHT/2 );
+        font = new BitmapFont(Gdx.files.internal("customFont4.fnt"));
+        font.getData().setScale(2f);
+        font.getData().down = -20.0f;
+        font.setColor(Color.BLACK);
+        message1 = "Seconds survived in last round\n"
+                + "Longest survived in game\n\n"
+                + "Highest amount of\n"
+                + "   arrows created\n"
+                + "   arrows shot at once\n"
+                + "   Short Walls created\n"
+                + "   Short Walls at once\n"
+                + "   Short Walls destroyed\n"
+                + "   Tall Walls created\n"
+                + "   Tall Walls at once\n"
+                + "   Tall Walls destroyed\n"
+                + "   wood picked up\n";
+        messageOfScores = "" + handler.getScore().currentSecSurvived + "\n"
+                + handler.getScore().highestSecSurvived + "\n\n\n"
+                + handler.getScore().highestNumberOfArrowsCreated + "\n"
+                + handler.getScore().highestNumberOfArrowsShotAtOnce + "\n"
+                + handler.getScore().highestNumberOfShortWallsCreated + "\n"
+                + handler.getScore().highestNumberOfShortWallsAtOnce + "\n"
+                + handler.getScore().highestNumberOfShortWallsDestroyed + "\n"
+                + handler.getScore().highestNumberOfTallWallsCreated + "\n"
+                + handler.getScore().highestNumberOfTallWallsAtOnce + "\n"
+                + handler.getScore().highestNumberOfTallWallsDestroyed + "\n"
+                + handler.getScore().highestNumberOfWoodPickedUp;
+    }
+    
+    
+    //--- Methods
+    @Override
+    public void update(float dt) {
+        
+    }
+    
+    @Override
+    public void render(SpriteBatch batch) {
+        batch.draw(image, bounds.x, bounds.y, bounds.width, bounds.height);
+        font.draw(batch, message1, bounds.x+bounds.width/20, bounds.y+bounds.height-8, 0, Align.topLeft, false);
+        font.draw(batch, messageOfScores, bounds.x + bounds.width - bounds.width/20, bounds.y+bounds.height-8, 0, Align.right,false);
+    }
+    
+    @Override
+    public void dispose() {
+        font.dispose();
+    }
+    
+    @Override
+    public String toString() {return "ScoreBoard";}
+    
+    //--- Getters and Setters
+    
+    
+}

core/src/com/jalenwinslow/game/gameobjects/ShortWall.java

@@ -0,0 +1,170 @@
+package com.jalenwinslow.game.gameobjects;
+
+import com.badlogic.gdx.Gdx;
+import com.badlogic.gdx.graphics.Texture;
+import com.badlogic.gdx.graphics.g2d.SpriteBatch;
+import com.badlogic.gdx.graphics.g2d.TextureRegion;
+import com.badlogic.gdx.math.Rectangle;
+import com.jalenwinslow.game.Handler;
+import com.jalenwinslow.game.Main;
+import com.jalenwinslow.game.states.State;
+import java.util.Random;
+
+public class ShortWall extends Wall {
+    
+    //--- Propreties
+    enum ShortWallStates {
+        creation,
+        normal,
+        standard
+    }
+    
+    private Random rand;
+    private ShortWallStates state;
+    private TextureRegion texture;
+    private Rectangle deathBounds;
+    private Rectangle showHealthBounds;
+    private Rectangle noPlayerBounds;
+    
+    private int hitPoints;
+    private HealthBar health;
+    private boolean breakable;
+    private boolean drawHealth;
+    private float timer;
+    private float elapsedTime;
+    private float alpha;
+    //Texture boundsTexture = new Texture("DodgeGame_boundsMask.png");
+    
+    //--- Constructor
+    public ShortWall(Handler handler, double x, double y, TextureRegion image) {
+        super(handler, x, y, image);
+        bounds = new Rectangle((int)x, (int)y, Main.WIDTH/10, Main.HEIGHT/10);
+        rand = new Random();
+        chooseImage();
+        depth = (int)y + Main.HEIGHT/20;
+        hitPoints = 1;
+        this.breakable = false;
+        drawHealth = false;
+        timer = 0;
+        elapsedTime = 0;
+        alpha = 1;
+        state = ShortWallStates.standard;
+    }
+    
+    public ShortWall(Handler handler, double x, double y, TextureRegion image, boolean breakable) {
+        super(handler, x, y, image);
+        bounds = new Rectangle();
+        noPlayerBounds = new Rectangle((int)x, (int)y, Main.WIDTH/10, Main.HEIGHT/10);
+        rand = new Random();
+        deathBounds = new Rectangle();
+        showHealthBounds = new Rectangle();
+        chooseImage();
+        depth = (int) y + Main.HEIGHT/20;
+        hitPoints = 900;
+        health = new HealthBar(handler, x, y, new TextureRegion(handler.getGameState().getHealthTexture()), hitPoints);
+        this.breakable = breakable;
+        drawHealth = false;
+        timer = 0;
+        elapsedTime = 0;
+        alpha = 0;
+        state = ShortWallStates.creation;
+    }
+    
+    
+    //--- Methods
+    @Override
+    public void update(float dt) {
+        
+        switch (state) {
+            case creation:
+                elapsedTime += dt;
+                if (!noPlayerBounds.overlaps(handler.getGameState().getPlayer().getBoundsFeet())) {
+                    bounds = new Rectangle(noPlayerBounds);
+                }
+                if (elapsedTime >= 0.25 && timer <= 2) {
+                    timer += 0.25;
+                    elapsedTime -= 0.25;
+                    if (alpha == 0) alpha = 1;
+                    else alpha = 0;
+                }
+                if (timer > 2) {
+                    alpha = 1;
+                    if (bounds == null) {
+                        bounds = new Rectangle((int)x, (int)y, Main.WIDTH/10, Main.HEIGHT/10);
+                    }
+                    deathBounds = new Rectangle((int)x+8, (int)y+8, Main.WIDTH/10-16, Main.HEIGHT/10-16);
+                    showHealthBounds = new Rectangle((int)x-8, (int)y-8, Main.WIDTH/10+16, Main.HEIGHT/10+16);
+                    health.bounds.x = bounds.x;
+                    health.bounds.y = bounds.y + bounds.height + (Main.HEIGHT/40) + 4;
+                    state = ShortWallStates.normal;
+                }
+                break;
+            case normal:
+                boundCollisions();
+                health.setHealth(hitPoints);
+                if (hitPoints <= 0) {
+                    for (int i = 0; i < handler.getGameObjectHandler().getGameObjects().size; i++) {
+                        if (handler.getGameObjectHandler().getGameObjects().get(i).equals(this)) {
+                            handler.getGameState().getPlayer().setWood(handler.getGameState().getPlayer().getWood()+2);
+                            handler.getGameState().getGrid().setFree(true, (int)(x / handler.getGameState().getGrid().getAreaWidth()), (int)(y / handler.getGameState().getGrid().getAreaHeight()));
+                            handler.getGameState().getWallGen().setHighestNumberOfShortWallsDestroyed(handler.getGameState().getWallGen().getHighestNumberOfShortWallsDestroyed() + 1);
+                            handler.getGameObjectHandler().getGameObjects().removeValue(this, false);
+                        }
+                    }
+                }
+                break;
+            case standard:
+                
+                break;
+            default:
+                
+                break;
+        }
+        
+    }
+    
+    @Override
+    public void render(SpriteBatch batch) {
+        batch.setColor(1, 1, 1, alpha);
+        batch.draw(texture, (int)x, (int)y, Main.WIDTH/10, Main.HEIGHT/10+(Main.HEIGHT/40));
+        batch.setColor(1, 1, 1, 1);
+        
+        if (drawHealth) {
+            health.render(batch);
+        }
+    }
+    
+    @Override
+    public void dispose() {
+        //boundsTexture.dispose();
+    }
+    
+    @Override
+    public String toString() {return "ShortWall";}
+    
+    private void chooseImage() {
+        TextureRegion[][] images = image.split(16, 20);
+        texture = images[0][rand.nextInt(images[0].length)];
+    }
+    
+    private void boundCollisions() {
+        if (deathBounds.overlaps(handler.getGameState().getPlayer().getBoundsFeet())) {
+            handler.getGameState().getTimer().stop();
+            State.setCurrenState(handler.getGameOverState());
+            State.getCurrentState().init();
+            handler.getGameObjectHandler().dispose();
+            handler.getGameState().dispose();
+        }
+        drawHealth = (showHealthBounds.overlaps(handler.getGameState().getPlayer().getBoundsFeet()));
+    }
+    
+    //--- Getters and Setters
+    public boolean isBreakable() {return breakable;}
+    public int getHitPoints() {return hitPoints;}
+    public Rectangle getDeathBounds() {return deathBounds;}
+    public Rectangle getShowHealthBounds() {return showHealthBounds;}
+    
+    public void setBreakable(boolean breakable) {this.breakable = breakable;}
+    public void setHitPoints(int hitPoints) {this.hitPoints = hitPoints;}
+    
+}

core/src/com/jalenwinslow/game/gameobjects/TallWall.java

@@ -0,0 +1,128 @@
+package com.jalenwinslow.game.gameobjects;
+
+import com.badlogic.gdx.graphics.Texture;
+import com.badlogic.gdx.graphics.g2d.SpriteBatch;
+import com.badlogic.gdx.graphics.g2d.TextureRegion;
+import com.badlogic.gdx.math.Rectangle;
+import com.jalenwinslow.game.Handler;
+import com.jalenwinslow.game.Main;
+
+public class TallWall extends Wall {
+    
+    //--- Propreties
+    enum TallWallStates{
+        waitingCreation,
+        startCreation,
+        normal
+    }
+    
+    private TextureRegion[][] texture;
+    private TallWallStates state;
+    private int imageIndex;
+    private int hitPoints;
+    private int totalHitPoints;
+    private boolean drawHealth;
+    private HealthBar health;
+    
+    private Rectangle showHealthBounds;
+    private Rectangle noPlayerBounds;
+    private Rectangle noArrowBounds;
+    
+    //private Texture boundsTexture = new Texture("DodgeGame_boundsMask.png");
+    
+    //--- Constructor
+    public TallWall(Handler handler, double x, double y, TextureRegion image) {
+        super(handler, x, y, image);
+        bounds = new Rectangle();
+        depth = (int)y + Main.HEIGHT/20;
+        texture = image.split(16, 24);
+        state = TallWallStates.waitingCreation;
+        imageIndex = 2;
+        hitPoints = 0;
+        totalHitPoints = 600;
+        drawHealth = false;
+        health = new HealthBar(handler, x, y, new TextureRegion(handler.getGameState().getHealthTexture()), totalHitPoints);
+        health.setHealth(hitPoints);
+        showHealthBounds = new Rectangle();
+        noPlayerBounds = new Rectangle((int)x, (int)y, Main.WIDTH/10, Main.HEIGHT/10);
+        noArrowBounds = new Rectangle();
+    }
+    
+    
+    //--- Methods
+    @Override
+    public void update(float dt) {
+        switch (state) {
+            case waitingCreation:
+                if (!noPlayerBounds.overlaps(handler.getGameState().getPlayer().getBoundsFeet())) {
+                    state = TallWallStates.startCreation;
+                    bounds = new Rectangle(noPlayerBounds);
+                    showHealthBounds = new Rectangle((int)x-8, (int)y-8, bounds.width+16, bounds.height+16);
+                    health.bounds.y = bounds.y+bounds.height+(Main.HEIGHT/20)+4;
+                    imageIndex = 1;
+                }
+                break;
+            case startCreation:
+                boundCollisions();
+                health.setHealth(hitPoints);
+                if (hitPoints >= totalHitPoints) {
+                    state = TallWallStates.normal;
+                    noArrowBounds = new Rectangle(bounds);
+                    noArrowBounds.width += 8;
+                    noArrowBounds.y += 16;
+                    imageIndex = 0;
+                    handler.getGameState().getPlayer().setHighestNumberOfTallWallsCreated(handler.getGameState().getPlayer().getHighestNumberOfTallWallsCreated() + 1);
+                }
+                break;
+            case normal:
+                boundCollisions();
+                health.setHealth(hitPoints);
+                if (hitPoints <= 0) {
+                    for (int i = 0; i < handler.getGameObjectHandler().getGameObjects().size; i++) {
+                        if (handler.getGameObjectHandler().getGameObjects().get(i).equals(this)) {
+                            handler.getGameState().getGrid().setFree(true, (int)(x / handler.getGameState().getGrid().getAreaWidth()), (int)(y / handler.getGameState().getGrid().getAreaHeight()));
+                            handler.getGameState().getPlayer().setHighestNumberOfTallWallsDestroyed(handler.getGameState().getPlayer().getHighestNumberOfTallWallsDestroyed()+1);
+                            handler.getGameObjectHandler().getGameObjects().removeValue(this, false);
+                        }
+                    }
+                }
+                break;
+            default:
+                
+                break;
+        }
+    }
+    
+    @Override
+    public void render(SpriteBatch batch) {
+        batch.draw(texture[0][imageIndex], noPlayerBounds.x, noPlayerBounds.y, noPlayerBounds.width, noPlayerBounds.height + (noPlayerBounds.height/2));
+        //batch.draw(boundsTexture, noArrowBounds.x, noArrowBounds.y, noArrowBounds.width, noArrowBounds.height);
+        if (drawHealth) {
+            health.render(batch);
+        }
+    }
+    
+    @Override
+    public void dispose() {
+        //boundsTexture.dispose();
+    }
+    
+    @Override
+    public String toString() {return "TallWall";}
+    
+    public void boundCollisions() {
+        drawHealth = (showHealthBounds.overlaps(handler.getGameState().getPlayer().getBoundsFeet()));
+    }
+    
+    //--- Getters and Setters
+    public int getHitPoints() {return hitPoints;}
+    public int getTotalHitPoints() {return totalHitPoints;}
+    public Rectangle getShowHealthBounds() {return showHealthBounds;}
+    public Rectangle getNoPlayerBounds() {return noPlayerBounds;}
+    public Rectangle getNoArrowBounds() {return noArrowBounds;}
+    public TallWallStates getState() {return state;}
+    
+    public void setHitPoints(int hitPoints) {this.hitPoints = hitPoints;}
+    public void setState(TallWallStates state) {this.state = state;}
+    
+}

core/src/com/jalenwinslow/game/gameobjects/Timer.java

@@ -0,0 +1,77 @@
+package com.jalenwinslow.game.gameobjects;
+
+import com.badlogic.gdx.Gdx;
+import com.badlogic.gdx.graphics.Color;
+import com.badlogic.gdx.graphics.Texture;
+import com.badlogic.gdx.graphics.g2d.SpriteBatch;
+import com.badlogic.gdx.graphics.g2d.TextureRegion;
+import com.badlogic.gdx.graphics.g2d.BitmapFont;
+import com.badlogic.gdx.scenes.scene2d.ui.Label;
+import com.badlogic.gdx.utils.Align;
+import com.jalenwinslow.game.Handler;
+import com.jalenwinslow.game.Main;
+
+public class Timer extends GameObject {
+    
+    //--- Propreties
+    private int time;
+    private float elapsedTime;
+    private BitmapFont font;
+    //private Label label;
+    private boolean playing;
+    private Texture timerCaseTexture;
+    
+    //--- Constructor
+    public Timer(Handler handler, double x, double y, TextureRegion image) {
+        super(handler, x, y, image);
+        time = 0;
+        elapsedTime = 0;
+        
+        font = new BitmapFont(Gdx.files.internal("customFont4.fnt"));
+        font.getData().setScale(3, 3);
+        font.setColor(Color.BLACK);
+        
+        playing = true;
+        timerCaseTexture = new Texture("b&w_DodgeGame_timerCase.png");
+    }
+    
+    
+    //--- Methods
+    @Override
+    public void update(float dt) {
+        if (playing) {
+            elapsedTime += dt;
+            if (elapsedTime >= 1) {
+                time++;
+                elapsedTime = 0;
+            }
+        }
+    }
+    
+    @Override
+    public void render(SpriteBatch batch) {
+        batch.draw(timerCaseTexture, Main.WIDTH/2-(Main.WIDTH/12), Main.HEIGHT-Main.HEIGHT/20, Main.WIDTH/6, Main.HEIGHT/20);
+        font.draw(batch, String.valueOf(time), Main.WIDTH/2, Main.HEIGHT+4, 0, Align.center, false);
+    }
+    
+    @Override
+    public void dispose() {
+        timerCaseTexture.dispose();
+        font.dispose();
+    }
+    
+    @Override
+    public String toString() {return "Timer";}
+    
+    public void stop() {
+        playing = false;
+    }
+    
+    //--- Getters and Setters
+    public int getTime() {return time;}
+    public boolean isPlaying() {return playing;}
+    
+    public void setTime(int time) {this.time = time;}
+    public void setPlaying(boolean playing) {this.playing = playing;}
+    
+}

core/src/com/jalenwinslow/game/gameobjects/Wall.java

@@ -0,0 +1,25 @@
+package com.jalenwinslow.game.gameobjects;
+
+import com.badlogic.gdx.graphics.g2d.TextureRegion;
+import com.jalenwinslow.game.Handler;
+
+public abstract class Wall extends GameObject {
+    
+    //--- Propreties
+    
+    
+    //--- Constructor
+    public Wall(Handler handler, double x, double y, TextureRegion image) {
+        super(handler, x, y, image);
+    }
+    
+    
+    //--- Methods
+    public boolean hasCollided(double x, double y) {
+        return (x >= bounds.x && y >= bounds.y && x <= bounds.x + bounds.width && y <= bounds.y + bounds.height);
+    }
+    
+    //--- Getters and Setters
+    
+    
+}

core/src/com/jalenwinslow/game/gameobjects/WallGenerator.java

@@ -0,0 +1,116 @@
+package com.jalenwinslow.game.gameobjects;
+
+import com.badlogic.gdx.graphics.g2d.SpriteBatch;
+import com.badlogic.gdx.graphics.g2d.TextureRegion;
+import com.jalenwinslow.game.Handler;
+import java.util.Random;
+
+public class WallGenerator extends GameObject {
+    
+    //--- Propreties
+    public static final byte MIN_WALL_COUNT = 5, MAX_WALL_COUNT = 30;
+    public static final int END_DEPLOY_TIME = 15, START_DEPLOY_TIME = 30;
+    
+    private Random rand;
+    
+    private int wallLimit;
+    private int baseTimeCount;
+    private int timeCount;
+    private int timer;
+    private float elapsedTime;
+    private int highestNumberOfShortWallsCreated;
+    private int highestNumberOfShortWallsDestroyed;
+    
+    //--- Constructor
+    public WallGenerator(Handler handler, double x, double y, TextureRegion image) {
+        super(handler, x, y, image);
+        
+        rand = new Random();
+        
+        wallLimit = MAX_WALL_COUNT;
+        baseTimeCount = START_DEPLOY_TIME;
+        timeCount = baseTimeCount + (rand.nextInt(7) - 3);
+        timer = 0;
+        elapsedTime = 0;
+        highestNumberOfShortWallsCreated = 0;
+        highestNumberOfShortWallsDestroyed = 0;
+        
+        for (int i = 0; i < 3; i++) {addWall();}
+    }
+    
+    
+    //--- Methods
+    @Override
+    public void update(float dt) {
+        elapsedTime += dt;
+        if (elapsedTime >= 1) {
+            timer++;
+            elapsedTime--;
+        }
+        if (timer >= timeCount && (handler.getGameObjectHandler().getNumberOfShortWalls() - 10) < wallLimit) {
+            if (rand.nextInt(100)+1 <= 75) {
+                addWall();
+            }
+            timer = 0;
+            if (baseTimeCount > END_DEPLOY_TIME) baseTimeCount--;
+            timeCount = baseTimeCount + (rand.nextInt(7)-3);
+        }
+        
+        
+    }
+    
+    @Override
+    public void render(SpriteBatch batch) {
+        
+    }
+    
+    @Override
+    public void dispose() {
+        
+    }
+    
+    @Override
+    public String toString() {return "WallGenerator";}
+    
+    public void updateWallStats() {
+        
+    }
+    
+    private void addWall() {
+        int arrayX = rand.nextInt(8)+1;
+        int arrayY = rand.nextInt(8)+1;
+        while (true) {
+            if (handler.getGameState().getGrid().isFree()[arrayY][arrayX] == true) {
+                        break;
+            } else {
+                if (arrayX < 8) arrayX++;
+                else {
+                    if (arrayY < 8) {
+                        arrayY++;
+                        arrayX = 1;
+                    } else {
+                        arrayY = 1;
+                        arrayX = 1;
+                    }
+                }
+            }
+        }
+
+        handler.getGameState().getGrid().setFree(false, arrayX, arrayY);
+
+        int xx = handler.getGameState().getGrid().getAreaWidth() * (arrayX);
+        int yy = handler.getGameState().getGrid().getAreaHeight() * (arrayY);
+
+        handler.getGameObjectHandler().add(new ShortWall(handler, xx, yy, image, true));
+        
+        highestNumberOfShortWallsCreated++;
+    }
+    
+    
+    //--- Getters and Setters
+    public int getHighestNumberOfShortWallsCreated() {return highestNumberOfShortWallsCreated;}
+    public int getHighestNumberOfShortWallsDestroyed() {return highestNumberOfShortWallsDestroyed;}
+    
+    public void setHighestNumberOfShortWallsDestroyed(int number) {this.highestNumberOfShortWallsDestroyed = number;}
+    
+}

core/src/com/jalenwinslow/game/gameobjects/Wood.java

@@ -0,0 +1,76 @@
+package com.jalenwinslow.game.gameobjects;
+
+import com.badlogic.gdx.graphics.g2d.SpriteBatch;
+import com.badlogic.gdx.graphics.g2d.TextureRegion;
+import com.badlogic.gdx.math.Rectangle;
+import com.jalenwinslow.game.Handler;
+import com.jalenwinslow.game.Main;
+import java.util.Random;
+
+public class Wood extends GameObject {
+    
+    //--- Propreties
+    private float timer;
+    private float elapsedTime;
+    private float alpha;
+    
+    //--- Constructor
+    public Wood(Handler handler, double x, double y, TextureRegion image) {
+        super(handler, x, y, image);
+        bounds = new Rectangle((int)x+16, (int)y+16, Main.WIDTH/20, Main.HEIGHT/20);
+        depth = (int)bounds.y + (int)bounds.width/2;
+        timer = 0;
+        elapsedTime = 0;
+        alpha = 1;
+    }
+    
+    
+    //--- Methods
+    @Override
+    public void update(float dt) {
+        elapsedTime += dt;
+        boundCollision();
+        if (timer >= 10) {
+            if (elapsedTime >= 0.25) {
+                if (alpha == 1) alpha = 0;
+                else alpha = 1;
+            }
+            if (timer >= 13) {
+                handler.getGameObjectHandler().getGameObjects().removeValue(this, false);
+            }
+        }
+        if (elapsedTime >= 0.25) {
+            timer += 0.25;
+            elapsedTime -= 0.25;
+        }
+        
+    }
+    
+    @Override
+    public void render(SpriteBatch batch) {
+        batch.setColor(1, 1, 1, alpha);
+        batch.draw(image, (int)x, (int)y, Main.WIDTH/10, Main.HEIGHT/10);
+        batch.setColor(1, 1, 1, 1);
+    }
+    
+    @Override
+    public void dispose() {
+        
+    }
+    
+    @Override
+    public String toString() {return "Wood";}
+    
+    public void boundCollision() {
+        if (bounds.overlaps(handler.getGameState().getPlayer().getBounds())) {
+            handler.getGameState().getPlayer().setWood(handler.getGameState().getPlayer().getWood() + 1);
+            handler.getGameState().getPlayer().setNumberOfWoodPickedUp(handler.getGameState().getPlayer().getNumberOfWoodPickedUp() + 1);
+            handler.getGameObjectHandler().getGameObjects().removeValue(this, false);
+        }
+    }
+    
+    
+    //--- Getters and Setters
+    
+    
+}

core/src/com/jalenwinslow/game/gameobjects/WoodGUI.java

@@ -0,0 +1,60 @@
+package com.jalenwinslow.game.gameobjects;
+
+import com.badlogic.gdx.Gdx;
+import com.badlogic.gdx.graphics.Color;
+import com.badlogic.gdx.graphics.Texture;
+import com.badlogic.gdx.graphics.g2d.BitmapFont;
+import com.badlogic.gdx.graphics.g2d.SpriteBatch;
+import com.badlogic.gdx.graphics.g2d.TextureRegion;
+import com.badlogic.gdx.math.Rectangle;
+import com.badlogic.gdx.utils.Align;
+import com.jalenwinslow.game.Handler;
+import com.jalenwinslow.game.Main;
+
+public class WoodGUI extends GameObject {
+    
+    //--- Propreties
+    private BitmapFont font;
+    private TextureRegion[][] texture;
+    private TextureRegion backTexture;
+    
+    private Texture boundsTexture = new Texture("DodgeGame_boundsMask.png");
+    
+    //--- Constructor
+    public WoodGUI(Handler handler, double x, double y, TextureRegion image) {
+        super(handler, x, y, image);
+        bounds = new Rectangle((int)x, (int)y, Main.WIDTH/5, Main.HEIGHT/20);
+        font = new BitmapFont(Gdx.files.internal("customFont4.fnt"));
+        font.getData().setScale(3, 3);
+        font.setColor(Color.WHITE);
+        backTexture = new TextureRegion(handler.getGameState().getHealthTexture()).split(16, 4)[0][0];
+        texture = image.split(16, 16);
+    }
+    
+    
+    //--- Methods
+    @Override
+    public void update(float dt) {
+        
+    }
+    
+    @Override
+    public void render(SpriteBatch batch) {
+        batch.draw(backTexture, bounds.x-bounds.width, bounds.y, bounds.width, bounds.height);
+        font.draw(batch, "x " + handler.getGameState().getPlayer().getWood(), bounds.x-64, bounds.y+Main.HEIGHT/20, 0, Align.left, false);
+        batch.draw(texture[0][0], bounds.x-bounds.width+16, bounds.y-4, Main.WIDTH/16, Main.HEIGHT/16);
+    }
+    
+    @Override
+    public void dispose() {
+        font.dispose();
+        boundsTexture.dispose();
+    }
+    
+    @Override
+    public String toString() {return "WoodGUI";}
+    
+    //--- Getters and Setters
+    
+    
+}

core/src/com/jalenwinslow/game/gameobjects/WoodGenerator.java

@@ -0,0 +1,92 @@
+package com.jalenwinslow.game.gameobjects;
+
+import com.badlogic.gdx.graphics.g2d.SpriteBatch;
+import com.badlogic.gdx.graphics.g2d.TextureRegion;
+import com.jalenwinslow.game.Handler;
+import java.util.Random;
+
+public class WoodGenerator extends GameObject {
+    
+    //--- Propreties
+    private Random rand;
+    private int timer;
+    private float elapsedTime;
+    private int baseTime;
+    private int countDown;
+    private int numberOfWoodCreated;
+    private TextureRegion[][] images;
+    
+    //--- Constructor
+    public WoodGenerator(Handler handler, double x, double y, TextureRegion image) {
+        super(handler, x, y, image);
+        rand = new Random();
+        timer = 0;
+        elapsedTime = 0;
+        baseTime = 20;
+        countDown = baseTime + rand.nextInt(11);
+        numberOfWoodCreated = 0;
+        images = image.split(16, 16);
+    }
+    
+    
+    //--- Methods
+    @Override
+    public void update(float dt) {
+        elapsedTime += dt;
+        if (elapsedTime >= 1) {
+            timer++;
+            elapsedTime--;
+        }
+        if (timer >= countDown) {
+            if (rand.nextInt(10)+1 <= 6) {
+                int arrayX = rand.nextInt(8)+1;
+                int arrayY = rand.nextInt(8)+1;
+                
+                while (true) {
+                    if (handler.getGameState().getGrid().isFree()[arrayY][arrayX]) {
+                        break;
+                    } else {
+                        if (arrayX < 8) arrayX++;
+                        else {
+                            if (arrayY < 8) {
+                                arrayY++;
+                                arrayX = 1;
+                            }
+                            else {
+                                arrayX = 1;
+                                arrayY = 1;
+                            }
+                        }
+                    }
+                }
+                
+                handler.getGameState().getGrid().setFree(false, arrayX, arrayY);
+                
+                int xx = handler.getGameState().getGrid().getAreaWidth() * arrayX;
+                int yy = handler.getGameState().getGrid().getAreaHeight() * arrayY;
+                
+                handler.getGameObjectHandler().add(new Wood(handler, xx, yy, images[0][rand.nextInt(8)]));
+                numberOfWoodCreated = 0;
+            }
+            timer = 0;
+            countDown = 20 + rand.nextInt(11);
+        }
+    }
+    
+    @Override
+    public void render(SpriteBatch batch) {
+        
+    }
+    
+    @Override
+    public void dispose() {
+        
+    }
+    
+    @Override
+    public String toString() {return "WoodGenerator";}
+    
+    //--- Getters and Setters
+    public int getNumberOfWoodCreated() {return numberOfWoodCreated;}
+    
+}

core/src/com/jalenwinslow/game/states/ExitState.java

@@ -0,0 +1,66 @@
+package com.jalenwinslow.game.states;
+
+import com.badlogic.gdx.Gdx;
+import com.badlogic.gdx.graphics.Color;
+import com.badlogic.gdx.graphics.Texture;
+import com.badlogic.gdx.graphics.g2d.BitmapFont;
+import com.badlogic.gdx.graphics.g2d.SpriteBatch;
+import com.badlogic.gdx.utils.Align;
+import com.jalenwinslow.game.Handler;
+import com.jalenwinslow.game.Main;
+
+public class ExitState extends State {
+    
+    //--- Propreties
+    BitmapFont font;
+    Texture texture;
+    float elapsedTime;
+    float timer;
+    String dots;
+    
+    //--- Constructor
+    public ExitState(Handler handler) {
+        super(handler);
+    }
+    
+    
+    //--- Methods
+    @Override
+    public void init() {
+        font = new BitmapFont(Gdx.files.internal("customFont4.fnt"));
+        font.getData().setScale(6);
+        font.setColor(Color.WHITE);
+        texture = new Texture("b&w_DodgeGame_gamePaused.png");
+        elapsedTime = 0;
+        timer = 0;
+        dots = "";
+    }
+    
+    @Override
+    public void update(float dt) {
+        elapsedTime += dt;
+        if (elapsedTime >= 1) {
+            timer++;
+            elapsedTime--;
+        }
+        if (timer >= 2) {
+            Gdx.app.exit();
+        }
+    }
+    
+    @Override
+    public void render(SpriteBatch batch) {
+        batch.draw(texture, 0, 0, Main.WIDTH, Main.HEIGHT);
+        font.draw(batch, "Exiting", Main.WIDTH/2, Main.HEIGHT/2, 0, Align.center, false);
+    }
+    
+    @Override
+    public void dispose() {
+        font.dispose();
+        texture.dispose();
+    }
+    
+    //--- Getters and Setters
+    
+    
+}

core/src/com/jalenwinslow/game/states/GameOverState.java

@@ -0,0 +1,62 @@
+package com.jalenwinslow.game.states;
+
+import com.badlogic.gdx.Gdx;
+import com.badlogic.gdx.graphics.Color;
+import com.badlogic.gdx.graphics.Texture;
+import com.badlogic.gdx.graphics.g2d.BitmapFont;
+import com.badlogic.gdx.graphics.g2d.SpriteBatch;
+import com.badlogic.gdx.utils.Align;
+import com.jalenwinslow.game.Handler;
+import com.jalenwinslow.game.Main;
+
+public class GameOverState extends State {
+    
+    //--- Propreties
+    private Texture gameOverTexture;
+    private BitmapFont font;
+    
+    //--- Constructor
+    public GameOverState(Handler handler) {
+        super(handler);
+    }
+    
+    
+    //--- Methods
+    @Override
+    public void init() {
+        handler.getScore().updateScores();
+        handler.getScore().updateScoreFile();
+        handler.getGameObjectHandler().dispose();
+        handler.getGameState().dispose();
+        gameOverTexture = new Texture("b&w_DodgeGame_GameOver.png");
+        font = new BitmapFont(Gdx.files.internal("customFont4.fnt"));
+        font.getData().setScale(3, 3);
+        font.setColor(Color.WHITE);
+    }
+    
+    @Override
+    public void update(float dt) {
+        if (Gdx.input.justTouched()) {
+            State.setCurrenState(handler.getMenuState());
+            State.getCurrentState().init();
+            dispose();
+        }
+    }
+    
+    @Override
+    public void render(SpriteBatch batch) {
+        batch.draw(gameOverTexture, 0, 0, Main.WIDTH, Main.HEIGHT);
+        font.draw(batch, "CLICK LEFT TO CONTINUE", 16, Main.HEIGHT-16);
+        font.draw(batch, "SURVIVED FOR " + String.valueOf(handler.getGameState().getTimer().getTime()) + " SEC", Main.WIDTH/2, Main.HEIGHT/2 - 64, 0, Align.center, false);
+    }
+    
+    @Override
+    public void dispose() {
+        if (gameOverTexture != null) gameOverTexture.dispose();
+        if (font != null) font.dispose();
+    }
+    
+    //--- Getters and Setters
+    
+    
+}

core/src/com/jalenwinslow/game/states/GameState.java

@@ -0,0 +1,117 @@
+package com.jalenwinslow.game.states;
+
+import com.badlogic.gdx.Gdx;
+import com.badlogic.gdx.Input.Keys;
+import com.badlogic.gdx.graphics.Texture;
+import com.badlogic.gdx.graphics.g2d.SpriteBatch;
+import com.badlogic.gdx.graphics.g2d.TextureRegion;
+import com.jalenwinslow.game.Handler;
+import com.jalenwinslow.game.Main;
+import com.jalenwinslow.game.gameobjects.*;
+import com.jalenwinslow.game.utils.Grid;
+import java.util.Random;
+
+public class GameState extends State{
+    
+    //--- Propreties
+    Texture background;
+    Texture playerTexture;
+    Texture woodTexture;
+    Texture arrowTexture;
+    Texture wallTexture;
+    Texture tallWallTexture;
+    Texture healthTexture;
+    
+    private Player player;
+    private WoodGUI woodGui;
+    private Grid grid;
+    private ArrowGenerator arrowGen;
+    private WallGenerator wallGen;
+    private WoodGenerator woodGen;
+    private Wall[] bottomWalls;
+    private Timer timer;
+    private Random rand;
+    
+    //--- Constructor
+    public GameState(Handler handler) {
+        super(handler);
+    }
+    
+    
+    //--- Methods
+    @Override
+    public void init() {
+        background = new Texture("b&w_DodgeGame_background2.png");
+        playerTexture = new Texture("b&w_DodgeGame_man1.png");
+        woodTexture = new Texture("b&w_DodgeGame_wood1.png");
+        arrowTexture = new Texture("b&w_DodgeGame_arrow.png");
+        wallTexture = new Texture("b&w_DodgeGame_wall1.png");
+        tallWallTexture = new Texture("b&w_DodgeGame_tallWall1.png");
+        healthTexture = new Texture("b&w_DodgeGame_health1.png");
+        player = new Player(handler, Main.WIDTH/2, Main.HEIGHT/2, new TextureRegion(playerTexture));
+        woodGui = new WoodGUI(handler, Main.WIDTH, 0, new TextureRegion(woodTexture));
+        grid = new Grid(handler);
+        arrowGen = new ArrowGenerator(handler, 0, 0, new TextureRegion(arrowTexture));
+        wallGen = new WallGenerator(handler, 0, 0, new TextureRegion(wallTexture));
+        woodGen = new WoodGenerator(handler, 0, 0, new TextureRegion(woodTexture));
+        bottomWalls = new Wall[Main.WIDTH/64];
+        for (int i = 0; i < Main.WIDTH/64; i++) {
+            bottomWalls[i] = new ShortWall(handler, 64*i, 0, new TextureRegion(wallTexture));
+        }
+        timer = new Timer(handler, Main.WIDTH/2, Main.HEIGHT-(Main.HEIGHT/10+32), null);
+        
+        handler.getGameObjectHandler().add(player);
+        handler.getGameObjectHandler().getGameObjects().addAll(bottomWalls, 0, bottomWalls.length);
+    }
+    
+    @Override
+    public void update(float dt) {
+        handler.getGameObjectHandler().update(dt);
+        arrowGen.update(dt);
+        wallGen.update(dt);
+        woodGen.update(dt);
+        timer.update(dt);
+        woodGui.update(dt);
+        if (Gdx.input.isKeyJustPressed(Keys.P)) {
+            State.setCurrenState(handler.getPauseState());
+            State.getCurrentState().init();
+        }
+    }
+    
+    @Override
+    public void render(SpriteBatch batch) {
+        batch.draw(background, 0, 0, Main.WIDTH, Main.HEIGHT);
+        handler.getGameObjectHandler().render(batch);
+        arrowGen.render(batch);
+        wallGen.render(batch);
+        woodGen.render(batch);
+        timer.render(batch);
+        woodGui.render(batch);
+    }
+    
+    @Override
+    public void dispose() {
+        if (background != null) background.dispose();
+        if (playerTexture != null) playerTexture.dispose();
+        if (arrowTexture != null) arrowTexture.dispose();
+        if (wallTexture != null) wallTexture.dispose();
+        if (woodTexture != null) woodTexture.dispose();
+        if (tallWallTexture != null) tallWallTexture.dispose();
+        if (healthTexture != null) healthTexture.dispose();
+        if (timer != null) timer.dispose();
+        if (woodGui != null) woodGui.dispose();
+    }
+    
+    //--- Getters and Setters
+    public Texture getHealthTexture() {return healthTexture;}
+    public Texture getTallWallTexture() {return tallWallTexture;}
+    
+    public Player getPlayer() {return player;}
+    public Grid getGrid() {return grid;}
+    public ArrowGenerator getArrowGen() {return arrowGen;}
+    public WallGenerator getWallGen() {return wallGen;}
+    public WoodGenerator getWoodGen() {return woodGen;}
+    public Wall[] getBottomWalls() {return bottomWalls;}
+    public Timer getTimer() {return timer;}
+    
+}

core/src/com/jalenwinslow/game/states/MenuState.java

@@ -0,0 +1,131 @@
+package com.jalenwinslow.game.states;
+
+import com.badlogic.gdx.graphics.Texture;
+import com.badlogic.gdx.graphics.g2d.SpriteBatch;
+import com.badlogic.gdx.graphics.g2d.TextureRegion;
+import com.jalenwinslow.game.Handler;
+import com.jalenwinslow.game.Main;
+import com.jalenwinslow.game.gameobjects.Button;
+import com.jalenwinslow.game.gameobjects.Player;
+import com.jalenwinslow.game.gameobjects.ScoreBoard;
+import com.jalenwinslow.game.gameobjects.ShortWall;
+import com.jalenwinslow.game.gameobjects.Wall;
+
+public class MenuState extends State{
+    
+    //--- Propreties
+    private int subState;
+    
+    Texture menuBg;
+    //Texture playButtonTexture;
+    Texture buttonTexture;
+    Texture playerTexture;
+    Texture wallTexture;
+    Texture healthTexture;
+    Texture scoreBoardTexture;
+    
+    private Button[] buttons;
+    private Button backButton;
+    private Player player;
+    private Wall[] bottomWalls;
+    private ScoreBoard scoreBoard;
+    //private PlayButton playBtn;
+    
+    //--- Constructor
+    public MenuState(Handler handler) {
+        super(handler);
+    }
+    
+    
+    //--- Methods
+    @Override
+    public void init() {
+        subState = 0;
+        
+        menuBg = new Texture("b&w_DodgeGame_background2.png");
+        //playButtonTexture = new Texture("b&w_DodgeGame_playButton.png");
+        buttonTexture = new Texture("b&w_DodgeGame_buttons1.png");
+        playerTexture = new Texture("b&w_DodgeGame_man1.png");
+        wallTexture = new Texture("b&w_DodgeGame_wall1.png");
+        healthTexture = new Texture("b&w_DodgeGame_health1.png");
+        scoreBoardTexture = new Texture("b&w_DodgeGame_scoreBoard.png");
+        buttons = new Button[3];
+        buttons[0] = new Button(handler, Main.WIDTH/4-64, Main.HEIGHT*3/4-96, new TextureRegion(buttonTexture), "PLAY", 6);
+        buttons[1] = new Button(handler, Main.WIDTH*3/4-(64*2), Main.HEIGHT*3/4-96, new TextureRegion(buttonTexture), "STATS", 6);
+        buttons[2] = new Button(handler, Main.WIDTH/4-64, Main.HEIGHT/4+32, new TextureRegion(buttonTexture), "EXIT", 6 );
+        player = new Player(handler, Main.WIDTH/2, Main.HEIGHT/2, new TextureRegion(playerTexture));
+        backButton = new Button(handler, Main.WIDTH/2-96, Main.HEIGHT/4-64, new TextureRegion(buttonTexture), "BACK", 6);
+        bottomWalls = new Wall[Main.WIDTH/64];
+        for (int i = 0; i < bottomWalls.length; i++) {
+            bottomWalls[i] = new ShortWall(handler, 64*i, 0, new TextureRegion(wallTexture));
+        }
+        scoreBoard = new ScoreBoard(handler, Main.WIDTH/8, Main.HEIGHT*3/8, new TextureRegion(scoreBoardTexture));
+        handler.getGameObjectHandler().add(player);
+        handler.getGameObjectHandler().getGameObjects().addAll(bottomWalls, 0, bottomWalls.length);
+        //playBtn = new PlayButton(handler, Main.WIDTH/2, Main.HEIGHT/2, new TextureRegion(playButtonTexture));
+    }
+    
+    @Override
+    public void update(float dt) {
+        switch (subState) {
+            case 0:
+                for (Button button : buttons) {
+                    if (button != null) button.update(dt);
+                }
+                break;
+            case 1:
+                backButton.update(dt);
+                break;
+            default:
+                
+                break;
+        }
+        handler.getGameObjectHandler().update(dt);
+    } 
+    
+    @Override
+    public void render(SpriteBatch batch) {
+        batch.draw(menuBg, 0, 0, Main.WIDTH, Main.HEIGHT);
+        switch (subState) {
+            case 0:
+                for (Button button : buttons) {
+                    if (button != null) button.render(batch);
+                }
+                break;
+            case 1:
+                scoreBoard.render(batch);
+                backButton.render(batch);
+                break;
+            default:
+                
+                break;
+        }
+        handler.getGameObjectHandler().render(batch);
+        
+    }
+    
+    @Override
+    public void dispose() {
+        menuBg.dispose();
+        buttonTexture.dispose();
+        playerTexture.dispose();
+        wallTexture.dispose();
+        healthTexture.dispose();
+        scoreBoardTexture.dispose();
+        scoreBoard.dispose();
+        for (Button button: buttons) {button.dispose();}
+        backButton.dispose();
+        //playButtonTexture.dispose();
+        //player = null;
+        //buttons = null;
+        //bottomWalls = null;
+    }
+    
+    //--- Getters and Setters
+    public Player getPlayer() {return player;}
+    public Texture getHealthTexture() {return healthTexture;}
+    public int getSubState() {return subState;}
+    
+    public void setSubState(int subState) {this.subState = subState;}
+    
+}

core/src/com/jalenwinslow/game/states/PauseState.java

@@ -0,0 +1,57 @@
+package com.jalenwinslow.game.states;
+
+import com.badlogic.gdx.Gdx;
+import com.badlogic.gdx.Input.Keys;
+import com.badlogic.gdx.graphics.Texture;
+import com.badlogic.gdx.graphics.g2d.BitmapFont;
+import com.badlogic.gdx.graphics.g2d.SpriteBatch;
+import com.badlogic.gdx.utils.Align;
+import com.jalenwinslow.game.Handler;
+import com.jalenwinslow.game.Main;
+
+public class PauseState extends State {
+    
+    //--- Propreties
+    Texture background;
+    BitmapFont font;
+    
+    //--- Constructor
+    public PauseState(Handler handler) {
+        super(handler);
+    }
+    
+    
+    //--- Methods
+    @Override
+    public void init() {
+        background = new Texture("b&w_DodgeGame_gamePaused.png");
+        font = new BitmapFont(Gdx.files.internal("customFont4.fnt"));
+        font.getData().setScale(6);
+    }
+    
+    @Override
+    public void update(float dt) {
+        if (Gdx.input.isKeyJustPressed(Keys.P)) {
+            State.setCurrenState(handler.getGameState());
+            dispose();
+        }
+    }
+    
+    @Override
+    public void render(SpriteBatch batch) {
+        batch.setColor(1, 1, 1, 0.2f);
+        batch.draw(background, 0, 0, Main.WIDTH, Main.HEIGHT);
+        batch.setColor(1, 1, 1, 1);
+        font.draw(batch, "Game Paused", Main.WIDTH/2, Main.HEIGHT/2, 0, Align.center, false);
+    }
+    
+    @Override
+    public void dispose() {
+        background.dispose();
+        font.dispose();
+    }
+    
+    //--- Getters and Setters
+    
+    
+}

core/src/com/jalenwinslow/game/states/State.java

@@ -0,0 +1,32 @@
+package com.jalenwinslow.game.states;
+
+import com.badlogic.gdx.graphics.g2d.SpriteBatch;
+import com.jalenwinslow.game.Handler;
+
+public abstract class State {
+    
+    //--- Propreties
+    protected static State currentState = null;
+    protected Handler handler;
+    
+    //--- Constructor
+    public State(Handler handler) {
+        this.handler = handler;
+    }
+    
+    
+    //--- Methods
+    public abstract void init();
+    
+    public abstract void update(float dt);
+    
+    public abstract void render(SpriteBatch batch);
+    
+    public abstract void dispose();
+    
+    //--- Getters and Setters
+    public static State getCurrentState() {return State.currentState;}
+    
+    public static void setCurrenState(State state) {currentState = state;}
+    
+}

core/src/com/jalenwinslow/game/utils/Grid.java

@@ -0,0 +1,59 @@
+package com.jalenwinslow.game.utils;
+
+import com.badlogic.gdx.Gdx;
+import com.jalenwinslow.game.Handler;
+import com.jalenwinslow.game.gameobjects.GameObject;
+
+public class Grid {
+    
+    //--- Propreties
+    private Handler handler;
+    private int width, height;
+    private int areaWidth;
+    private int areaHeight;
+    private boolean[][] free;
+    
+    //--- Constructor
+    public Grid(Handler handler) {
+        this.handler = handler;
+        this.width = Gdx.graphics.getWidth();
+        this.height = Gdx.graphics.getHeight();
+        this.areaWidth = width/10;
+        this.areaHeight = width/10;
+        this.free = new boolean[width/areaWidth][height/areaHeight];
+        for (int j = 0; j < free.length; j++) {
+            for (int i = 0; i < free[j].length; i++) {
+                free[j][i] = true;
+            }
+        }
+    }
+    public Grid(Handler handler, int width, int height, int areaWidth, int areaHeight) {
+        this(handler);
+        this.width = width;
+        this.height = height;
+        this.areaWidth = areaWidth;
+        this.areaHeight = areaHeight;
+        this.free = new boolean[width/areaWidth][height/areaHeight];
+        for (int j = 0; j < free.length; j++) {
+            for (int i = 0; i < free[j].length; i++) {
+                free[j][i] = true;
+            }
+        }
+    }
+    
+    
+    //--- Methods
+    
+    
+    //--- Getters and Setters
+    public int getWidth() {return width;}
+    public int getHeight() {return height;}
+    public int getAreaWidth() {return areaWidth;}
+    public int getAreaHeight() {return areaHeight;}
+    public boolean[][] isFree() {return free;}
+    
+    public void setFree(boolean free, int i, int j) {
+        this.free[j][i] = free;
+    }
+    
+}

core/src/com/jalenwinslow/game/utils/Score.java

@@ -0,0 +1,83 @@
+package com.jalenwinslow.game.utils;
+
+import com.jalenwinslow.game.Handler;
+
+public class Score {
+    
+    //--- Propreties
+    private Handler handler;
+    
+    public int currentSecSurvived;
+    public int highestSecSurvived;
+    public int highestNumberOfArrowsCreated, highestNumberOfArrowsShotAtOnce;
+    public int highestNumberOfShortWallsCreated, highestNumberOfShortWallsAtOnce, highestNumberOfShortWallsDestroyed;
+    public int highestNumberOfTallWallsCreated, highestNumberOfTallWallsAtOnce, highestNumberOfTallWallsDestroyed;
+    public int highestNumberOfWoodPickedUp;
+    
+    
+    //--- Constructor
+    public Score(Handler handler) {
+        this.handler = handler;
+    }
+    
+    
+    //--- Methods
+    public void updateScores() {
+        currentSecSurvived = handler.getGameState().getTimer().getTime();
+        if (currentSecSurvived > highestSecSurvived) highestSecSurvived = currentSecSurvived;
+        
+        if (handler.getGameState().getArrowGen().getAmountOfArrowsCreated() > highestNumberOfArrowsCreated) 
+            highestNumberOfArrowsCreated = handler.getGameState().getArrowGen().getAmountOfArrowsCreated();
+        if (handler.getGameState().getArrowGen().getHighestAmountOfArrowsAtOnce() > highestNumberOfArrowsShotAtOnce) 
+            highestNumberOfArrowsShotAtOnce = handler.getGameState().getArrowGen().getHighestAmountOfArrowsAtOnce();
+        
+        if (handler.getGameState().getWallGen().getHighestNumberOfShortWallsCreated() > highestNumberOfShortWallsCreated) 
+            highestNumberOfShortWallsCreated = handler.getGameState().getWallGen().getHighestNumberOfShortWallsCreated();
+        if (handler.getGameObjectHandler().getHighestNumberOfShortWallsAtOnce() > highestNumberOfShortWallsAtOnce) 
+            highestNumberOfShortWallsAtOnce = handler.getGameObjectHandler().getHighestNumberOfShortWallsAtOnce();
+        if (handler.getGameState().getWallGen().getHighestNumberOfShortWallsDestroyed() > highestNumberOfShortWallsDestroyed) 
+            highestNumberOfShortWallsDestroyed = handler.getGameState().getWallGen().getHighestNumberOfShortWallsDestroyed();
+        
+        if (handler.getGameState().getPlayer().getHighestNumberOfTallWallsCreated() > highestNumberOfTallWallsCreated) 
+            highestNumberOfTallWallsCreated = handler.getGameState().getPlayer().getHighestNumberOfTallWallsCreated();
+        if (handler.getGameObjectHandler().getHighestNumberOfTallWallsAtOnce() > highestNumberOfTallWallsAtOnce) 
+            highestNumberOfTallWallsAtOnce = handler.getGameObjectHandler().getHighestNumberOfTallWallsAtOnce();
+        if (handler.getGameState().getPlayer().getHighestNumberOfTallWallsDestroyed() > highestNumberOfTallWallsDestroyed) 
+            highestNumberOfTallWallsDestroyed = handler.getGameState().getPlayer().getHighestNumberOfTallWallsDestroyed();
+        
+        if (handler.getGameState().getPlayer().getNumberOfWoodPickedUp() > highestNumberOfWoodPickedUp) 
+            highestNumberOfWoodPickedUp = handler.getGameState().getPlayer().getNumberOfWoodPickedUp();
+    }
+    
+    public void getScoresFromFile() {
+        String[] strings = handler.getScoreFile().readString().split("\n");
+        currentSecSurvived = Integer.valueOf(strings[0]);
+        highestSecSurvived = Integer.valueOf(strings[1]);
+        
+        highestNumberOfArrowsCreated = Integer.valueOf(strings[2]);
+        highestNumberOfArrowsShotAtOnce = Integer.valueOf(strings[3]);
+        
+        highestNumberOfShortWallsCreated = Integer.valueOf(strings[4]);
+        highestNumberOfShortWallsAtOnce = Integer.valueOf(strings[5]);
+        highestNumberOfShortWallsDestroyed = Integer.valueOf(strings[6]);
+        
+        highestNumberOfTallWallsCreated = Integer.valueOf(strings[7]);
+        highestNumberOfTallWallsAtOnce = Integer.valueOf(strings[8]);
+        highestNumberOfTallWallsDestroyed = Integer.valueOf(strings[9]);
+        
+        highestNumberOfWoodPickedUp = Integer.valueOf(strings[10]);
+    }
+    
+    public void updateScoreFile() {
+        String message = currentSecSurvived + "\n" + highestSecSurvived + "\n"
+                + highestNumberOfArrowsCreated + "\n" + highestNumberOfArrowsShotAtOnce + "\n"
+                + highestNumberOfShortWallsCreated + "\n" + highestNumberOfShortWallsAtOnce + "\n" + highestNumberOfShortWallsDestroyed + "\n"
+                + highestNumberOfTallWallsCreated + "\n" + highestNumberOfTallWallsAtOnce + "\n" + highestNumberOfTallWallsDestroyed + "\n"
+                + highestNumberOfWoodPickedUp;
+        handler.getScoreFile().writeString(message, false);
+    }
+    
+    //--- Getters and Setters
+    
+    
+}