diff --git a/core/assets/assets b/core/assets/assets
index 4084863..40cb189 160000
--- a/core/assets/assets
+++ b/core/assets/assets
@@ -1 +1 @@
-Subproject commit 4084863016fedbf0766bba783a780a6ac38f1485
+Subproject commit 40cb189bcfc1e00537382569def5ca220fe67374
diff --git a/core/src/me/srikavin/fbla/game/FBLAGame.kt b/core/src/me/srikavin/fbla/game/FBLAGame.kt
index 6194301..0770cf6 100644
--- a/core/src/me/srikavin/fbla/game/FBLAGame.kt
+++ b/core/src/me/srikavin/fbla/game/FBLAGame.kt
@@ -30,12 +30,15 @@ import com.strongjoshua.console.GUIConsole
 import ktx.assets.disposeSafely
 import me.srikavin.fbla.game.Scene.PLAYING
 import me.srikavin.fbla.game.Scene.TITLE
+import me.srikavin.fbla.game.award.Awards
 import me.srikavin.fbla.game.ecs.component.MinigameComponent
 import me.srikavin.fbla.game.ecs.system.*
 import me.srikavin.fbla.game.map.MapLoader
 import me.srikavin.fbla.game.minigame.dropcatch.DropcatchMinigame
 import me.srikavin.fbla.game.physics.ContactListenerManager
+import me.srikavin.fbla.game.state.GameState
 import me.srikavin.fbla.game.ui.MainMenu
+import me.srikavin.fbla.game.util.GameFonts
 
 const val cameraScale = 45f
 
@@ -138,7 +141,14 @@ class FBLAGame : ApplicationAdapter() {
                         reset(MapProperties().apply { put("subtype", stage); put("next_level", "level1.tmx") }, world, mapLoader)
                     }
                 })
+            }
+
+            fun addAward(name: String) {
+                gameState.addAward(name)
+            }
 
+            fun removeAward(name: String) {
+                gameState.removeAward(name)
             }
 
             fun debug(boolean: Boolean) {
@@ -162,6 +172,8 @@ class FBLAGame : ApplicationAdapter() {
         assetManager.setLoader(FreeTypeFontGenerator::class.java, FreeTypeFontGeneratorLoader(resolver))
         assetManager.setLoader(BitmapFont::class.java, ".ttf", FreetypeFontLoader(resolver))
 
+        GameFonts.loadFonts(assetManager, "assets/fonts/font.ttf")
+        Awards.init(assetManager)
 
         fun newCursor(name: String): Cursor {
             val p = Pixmap(Gdx.files.internal("assets/cursors/$name.png"))
@@ -170,21 +182,9 @@ class FBLAGame : ApplicationAdapter() {
 
         Gdx.graphics.setCursor(newCursor("cursor"))
 
-        val parameter = FreetypeFontLoader.FreeTypeFontLoaderParameter().apply {
-            fontParameters.apply {
-                size = 22
-                fontFileName = "assets/fonts/font.ttf"
-                gamma = .8f
-            }
-        }
-        assetManager.load("defaultFont.ttf", BitmapFont::class.java, parameter)
-        val font = assetManager.finishLoadingAsset<BitmapFont>("defaultFont.ttf")
-        font.data.apply {
-            markupEnabled = true
-        }
-
         val fontMap = ObjectMap<String, Any>()
-        fontMap.put("defaultFont", font)
+        fontMap.put("defaultFont", GameFonts.DEFAULT)
+        fontMap.put("menuFont", GameFonts.MENU)
 
         assetManager.load("assets/skin/skin.json", Skin::class.java, SkinLoader.SkinParameter(fontMap))
     }
@@ -198,6 +198,8 @@ class FBLAGame : ApplicationAdapter() {
         }
         mainMenuUI.build()
         scene = TITLE
+        startGame()
+        scene = PLAYING
     }
 
     override fun render() {
diff --git a/core/src/me/srikavin/fbla/game/GameState.kt b/core/src/me/srikavin/fbla/game/GameState.kt
deleted file mode 100644
index d9f2fc9..0000000
--- a/core/src/me/srikavin/fbla/game/GameState.kt
+++ /dev/null
@@ -1,3 +0,0 @@
-package me.srikavin.fbla.game
-
-data class GameState(var score: Int = 0, var lives: Int = 3)
\ No newline at end of file
diff --git a/core/src/me/srikavin/fbla/game/award/America.kt b/core/src/me/srikavin/fbla/game/award/America.kt
new file mode 100644
index 0000000..22f67b1
--- /dev/null
+++ b/core/src/me/srikavin/fbla/game/award/America.kt
@@ -0,0 +1,13 @@
+package me.srikavin.fbla.game.award
+
+import me.srikavin.fbla.game.state.GameRules
+
+class America : Award() {
+    override fun apply(gameRules: GameRules) {
+        gameRules.enemiesToGold = true
+    }
+
+    override fun getName(): String {
+        return "america"
+    }
+}
\ No newline at end of file
diff --git a/core/src/me/srikavin/fbla/game/award/Award.kt b/core/src/me/srikavin/fbla/game/award/Award.kt
new file mode 100644
index 0000000..b904b34
--- /dev/null
+++ b/core/src/me/srikavin/fbla/game/award/Award.kt
@@ -0,0 +1,30 @@
+package me.srikavin.fbla.game.award
+
+import com.badlogic.gdx.assets.AssetManager
+import com.badlogic.gdx.graphics.Texture
+import com.badlogic.gdx.scenes.scene2d.utils.TextureRegionDrawable
+import me.srikavin.fbla.game.state.GameRules
+
+abstract class Award {
+    private lateinit var texture: Texture
+    private lateinit var drawable: TextureRegionDrawable
+
+    abstract fun apply(gameRules: GameRules)
+
+    protected abstract fun getName(): String
+
+    fun loadDrawable(assetManager: AssetManager) {
+        val path = "assets/graphics/awards/${getName()}.png"
+        assetManager.load(path, Texture::class.java)
+        texture = assetManager.finishLoadingAsset(path)
+        drawable = TextureRegionDrawable(texture)
+    }
+
+    fun getTexture(): Texture {
+        return texture
+    }
+
+    fun getDrawable(): TextureRegionDrawable {
+        return drawable
+    }
+}
\ No newline at end of file
diff --git a/core/src/me/srikavin/fbla/game/award/Awards.kt b/core/src/me/srikavin/fbla/game/award/Awards.kt
new file mode 100644
index 0000000..b067d32
--- /dev/null
+++ b/core/src/me/srikavin/fbla/game/award/Awards.kt
@@ -0,0 +1,28 @@
+package me.srikavin.fbla.game.award
+
+import com.badlogic.gdx.assets.AssetManager
+
+object Awards {
+    val future: Future = Future()
+    val business: Business = Business()
+    val leader: Leader = Leader()
+    val america: America = America()
+
+    private val nameMap = mapOf(
+            "future" to future,
+            "business" to business,
+            "leader" to leader,
+            "america" to america
+    )
+
+    fun init(assetManager: AssetManager) {
+        future.loadDrawable(assetManager)
+        business.loadDrawable(assetManager)
+        leader.loadDrawable(assetManager)
+        america.loadDrawable(assetManager)
+    }
+
+    fun getAward(name: String): Award {
+        return nameMap.getValue(name)
+    }
+}
\ No newline at end of file
diff --git a/core/src/me/srikavin/fbla/game/award/Business.kt b/core/src/me/srikavin/fbla/game/award/Business.kt
new file mode 100644
index 0000000..8d1d6b0
--- /dev/null
+++ b/core/src/me/srikavin/fbla/game/award/Business.kt
@@ -0,0 +1,13 @@
+package me.srikavin.fbla.game.award
+
+import me.srikavin.fbla.game.state.GameRules
+
+class Business : Award() {
+    override fun apply(gameRules: GameRules) {
+        gameRules.coinMultiplier = 2
+    }
+
+    override fun getName(): String {
+        return "business"
+    }
+}
\ No newline at end of file
diff --git a/core/src/me/srikavin/fbla/game/award/Future.kt b/core/src/me/srikavin/fbla/game/award/Future.kt
new file mode 100644
index 0000000..90427e7
--- /dev/null
+++ b/core/src/me/srikavin/fbla/game/award/Future.kt
@@ -0,0 +1,13 @@
+package me.srikavin.fbla.game.award
+
+import me.srikavin.fbla.game.state.GameRules
+
+class Future : Award() {
+    override fun apply(gameRules: GameRules) {
+        gameRules.livesGainedPerLevel = 1
+    }
+
+    override fun getName(): String {
+        return "future"
+    }
+}
\ No newline at end of file
diff --git a/core/src/me/srikavin/fbla/game/award/Leader.kt b/core/src/me/srikavin/fbla/game/award/Leader.kt
new file mode 100644
index 0000000..539f5a4
--- /dev/null
+++ b/core/src/me/srikavin/fbla/game/award/Leader.kt
@@ -0,0 +1,13 @@
+package me.srikavin.fbla.game.award
+
+import me.srikavin.fbla.game.state.GameRules
+
+class Leader : Award() {
+    override fun apply(gameRules: GameRules) {
+        gameRules.enemiesToGold = true
+    }
+
+    override fun getName(): String {
+        return "leader"
+    }
+}
\ No newline at end of file
diff --git a/core/src/me/srikavin/fbla/game/dialogue/DialogueManager.kt b/core/src/me/srikavin/fbla/game/dialogue/DialogueManager.kt
index 5f6dd8c..f85375a 100644
--- a/core/src/me/srikavin/fbla/game/dialogue/DialogueManager.kt
+++ b/core/src/me/srikavin/fbla/game/dialogue/DialogueManager.kt
@@ -32,7 +32,7 @@ class DialogueManager(private val stage: Stage, skin: Skin) {
 
         private val dialogues = mapOf(
                 "meeting" to DialogueMeeting(),
-                "make_chapter" to DialogueMakeChapter(),
+                "recruit" to DialogueMakeChapter(),
                 "job_interview" to DialogueJobInterview(),
                 "office" to DialogueSpeech(),
                 "letter_rec" to DialogueLetterRec(),
diff --git a/core/src/me/srikavin/fbla/game/ecs/component/CreatedFromMap.kt b/core/src/me/srikavin/fbla/game/ecs/component/CreatedFromMap.kt
index b16091d..c5d8a61 100644
--- a/core/src/me/srikavin/fbla/game/ecs/component/CreatedFromMap.kt
+++ b/core/src/me/srikavin/fbla/game/ecs/component/CreatedFromMap.kt
@@ -2,7 +2,7 @@ package me.srikavin.fbla.game.ecs.component
 
 import com.artemis.Component
 import com.artemis.annotations.EntityId
-import me.srikavin.fbla.game.EntityInt
+import me.srikavin.fbla.game.util.EntityInt
 
 /**
  * Component indicating that an entity was the result of loading a map
diff --git a/core/src/me/srikavin/fbla/game/ecs/component/Dead.kt b/core/src/me/srikavin/fbla/game/ecs/component/Dead.kt
new file mode 100644
index 0000000..4e7e39c
--- /dev/null
+++ b/core/src/me/srikavin/fbla/game/ecs/component/Dead.kt
@@ -0,0 +1,7 @@
+package me.srikavin.fbla.game.ecs.component
+
+import com.artemis.Component
+
+class Dead : Component() {
+    var respawnRunnable: () -> Unit = {}
+}
\ No newline at end of file
diff --git a/core/src/me/srikavin/fbla/game/ecs/component/PhysicsBody.kt b/core/src/me/srikavin/fbla/game/ecs/component/PhysicsBody.kt
index a6a1a45..87008ab 100644
--- a/core/src/me/srikavin/fbla/game/ecs/component/PhysicsBody.kt
+++ b/core/src/me/srikavin/fbla/game/ecs/component/PhysicsBody.kt
@@ -2,7 +2,7 @@ package me.srikavin.fbla.game.ecs.component
 
 import com.artemis.Component
 import com.badlogic.gdx.physics.box2d.*
-import me.srikavin.fbla.game.GdxArray
+import me.srikavin.fbla.game.util.GdxArray
 
 /**
  * A component containing the necessary properties to represent an entity as a physics object
diff --git a/core/src/me/srikavin/fbla/game/ecs/component/SwitchableAnimation.kt b/core/src/me/srikavin/fbla/game/ecs/component/SwitchableAnimation.kt
index de14d09..d29e1d0 100644
--- a/core/src/me/srikavin/fbla/game/ecs/component/SwitchableAnimation.kt
+++ b/core/src/me/srikavin/fbla/game/ecs/component/SwitchableAnimation.kt
@@ -10,7 +10,31 @@ import ktx.collections.GdxMap
  */
 class SwitchableAnimation : Component() {
     lateinit var animations: GdxMap<String, Animation<TextureRegion>>
-    lateinit var currentState: String
+    private lateinit var _currentState: String
+    var currentState: String
+        get() = _currentState
+        set(value) {
+            if (locked <= 0) {
+                _currentState = value
+            }
+        }
     var mirror: Boolean = false
     var looping: Boolean = false
+    private var locked: Float = 0f
+
+    /**
+     * Lock this animation component to the given animation. Multiple calls to [lock] will override the previous ones.
+     *
+     * @param animationName The name of the animation to lock to.
+     */
+    fun lock(animationName: String) {
+        locked = animations[animationName].animationDuration
+        _currentState = animationName
+    }
+
+    fun getCurrentAndUpdate(delta: Float): Animation<TextureRegion> {
+        locked -= delta
+        return animations[currentState]
+    }
+
 }
\ No newline at end of file
diff --git a/core/src/me/srikavin/fbla/game/ecs/system/CameraFollowSystem.kt b/core/src/me/srikavin/fbla/game/ecs/system/CameraFollowSystem.kt
index deac57d..23b2a72 100644
--- a/core/src/me/srikavin/fbla/game/ecs/system/CameraFollowSystem.kt
+++ b/core/src/me/srikavin/fbla/game/ecs/system/CameraFollowSystem.kt
@@ -5,6 +5,7 @@ import com.artemis.ComponentMapper
 import com.artemis.annotations.Wire
 import com.artemis.managers.TagManager
 import com.badlogic.gdx.graphics.OrthographicCamera
+import me.srikavin.fbla.game.ecs.component.Dead
 import me.srikavin.fbla.game.ecs.component.Transform
 
 /**
@@ -16,12 +17,18 @@ import me.srikavin.fbla.game.ecs.component.Transform
 class CameraFollowSystem(var followVertical: Boolean = true, var followHorizontal: Boolean = true) : BaseSystem() {
     @Wire
     private lateinit var transformMapper: ComponentMapper<Transform>
+    private lateinit var deadMapper: ComponentMapper<Dead>
+
     @Wire
     internal lateinit var camera: OrthographicCamera
 
     override fun processSystem() {
         val player = world.getSystem(TagManager::class.java).getEntityId("PLAYER")
 
+        if (deadMapper.has(player)) {
+            return
+        }
+
         if (player != -1 && transformMapper.has(player)) {
             val pos = transformMapper[player].position
             if (followHorizontal) {
diff --git a/core/src/me/srikavin/fbla/game/ecs/system/EntityRenderSystem.kt b/core/src/me/srikavin/fbla/game/ecs/system/EntityRenderSystem.kt
index 0c011aa..053360f 100644
--- a/core/src/me/srikavin/fbla/game/ecs/system/EntityRenderSystem.kt
+++ b/core/src/me/srikavin/fbla/game/ecs/system/EntityRenderSystem.kt
@@ -55,7 +55,7 @@ class EntityRenderSystem : IteratingSystem() {
             switchableAnimationMapper.has(entityId) -> {
                 val animated = switchableAnimationMapper[entityId]
                 mirrored = animated.mirror
-                animated.animations[animated.currentState].getKeyFrame(stateTime, animated.looping)
+                animated.getCurrentAndUpdate(world.delta).getKeyFrame(stateTime, animated.looping)
             }
             animatedMapper.has(entityId) -> {
                 val animated = animatedMapper[entityId]
diff --git a/core/src/me/srikavin/fbla/game/ecs/system/InputSystem.kt b/core/src/me/srikavin/fbla/game/ecs/system/InputSystem.kt
index a128240..e292fd0 100644
--- a/core/src/me/srikavin/fbla/game/ecs/system/InputSystem.kt
+++ b/core/src/me/srikavin/fbla/game/ecs/system/InputSystem.kt
@@ -12,10 +12,7 @@ import com.badlogic.gdx.physics.box2d.ContactImpulse
 import com.badlogic.gdx.physics.box2d.ContactListener
 import com.badlogic.gdx.physics.box2d.Manifold
 import me.srikavin.fbla.game.GameActions
-import me.srikavin.fbla.game.ecs.component.DisableInput
-import me.srikavin.fbla.game.ecs.component.PhysicsBody
-import me.srikavin.fbla.game.ecs.component.PlayerControlled
-import me.srikavin.fbla.game.ecs.component.Transform
+import me.srikavin.fbla.game.ecs.component.*
 import me.srikavin.fbla.game.graphics.player_foot_fixture_id
 import me.srikavin.fbla.game.physics.ContactListenerManager
 
@@ -37,6 +34,9 @@ class InputSystem(private val listenerManager: ContactListenerManager) : Iterati
     @Wire
     private lateinit var physicsBodyMapper: ComponentMapper<PhysicsBody>
 
+    @Wire
+    private lateinit var deadMapper: ComponentMapper<Dead>
+
     private var allowJump: Int = 0
 
     inner class FootContactListener : ContactListener {
@@ -71,6 +71,10 @@ class InputSystem(private val listenerManager: ContactListenerManager) : Iterati
 
 
     override fun process(entityId: Int) {
+        if (deadMapper.has(entityId)) {
+            return
+        }
+
         val body = physicsBodyMapper[entityId].body
 
         if (allowJump == 0 && body.linearVelocity.y < -1f && body.linearVelocity.y > -15f) {
diff --git a/core/src/me/srikavin/fbla/game/ecs/system/MinigameRenderSystem.kt b/core/src/me/srikavin/fbla/game/ecs/system/MinigameRenderSystem.kt
index 10ddb6a..b1e63c0 100644
--- a/core/src/me/srikavin/fbla/game/ecs/system/MinigameRenderSystem.kt
+++ b/core/src/me/srikavin/fbla/game/ecs/system/MinigameRenderSystem.kt
@@ -14,9 +14,9 @@ import com.badlogic.gdx.scenes.scene2d.Stage
 import com.badlogic.gdx.scenes.scene2d.ui.Skin
 import com.badlogic.gdx.utils.viewport.ExtendViewport
 import ktx.log.info
-import me.srikavin.fbla.game.EntityInt
 import me.srikavin.fbla.game.ecs.component.MinigameComponent
-import me.srikavin.fbla.game.registerInputHandler
+import me.srikavin.fbla.game.util.EntityInt
+import me.srikavin.fbla.game.util.registerInputHandler
 
 /**
  * Handles rendering active minigames
diff --git a/core/src/me/srikavin/fbla/game/ecs/system/PhysicsSystem.kt b/core/src/me/srikavin/fbla/game/ecs/system/PhysicsSystem.kt
index e62b29e..d2652d6 100644
--- a/core/src/me/srikavin/fbla/game/ecs/system/PhysicsSystem.kt
+++ b/core/src/me/srikavin/fbla/game/ecs/system/PhysicsSystem.kt
@@ -91,8 +91,26 @@ class PhysicsSystem(var physicsWorld: World, private val contactManager: Contact
                     }
                 }
 
+                val filter = Filter()
+                filter.groupIndex = -1
+                fixtures.forEach {
+                    it.filterData = filter
+                }
+
 
                 if (e == world.getSystem(TagManager::class.java).getEntityId("PLAYER")) {
+                    // Increased friction when touching ground without affecting wall sliding
+                    val feet = FixtureDef().apply {
+                        //                        this.isSensor = true
+                        this.shape = PolygonShape().apply {
+                            setAsBox(0.6f, 0.05f, Vector2(0f, -1f), 0f)
+                        }
+                        friction = .9f
+                    }
+
+                    fixtures.add(physics.body.createFixture(feet))
+
+                    // Used to detect when the player is on the ground
                     val footBox = FixtureDef().apply {
                         //                        this.isSensor = true
                         this.shape = PolygonShape().apply {
@@ -103,9 +121,18 @@ class PhysicsSystem(var physicsWorld: World, private val contactManager: Contact
 
                     val fixture = physics.body.createFixture(footBox)
                     fixture.userData = player_foot_fixture_id
+                    fixture.isSensor = true
                     fixtures.add(fixture)
+
+
+                    // Apply a filter to allow for the death animation
+                    filter.groupIndex = 1
+                    fixtures.forEach {
+                        it.filterData = filter
+                    }
                 }
 
+
                 physics.fixtures = fixtures
             }
         }
diff --git a/core/src/me/srikavin/fbla/game/ecs/system/TriggerSystem.kt b/core/src/me/srikavin/fbla/game/ecs/system/TriggerSystem.kt
index 7227caf..4587fea 100644
--- a/core/src/me/srikavin/fbla/game/ecs/system/TriggerSystem.kt
+++ b/core/src/me/srikavin/fbla/game/ecs/system/TriggerSystem.kt
@@ -5,11 +5,11 @@ import com.artemis.ComponentMapper
 import com.artemis.annotations.All
 import com.artemis.managers.TagManager
 import com.badlogic.gdx.physics.box2d.*
-import me.srikavin.fbla.game.EntityInt
 import me.srikavin.fbla.game.ecs.component.MapTrigger
 import me.srikavin.fbla.game.ecs.component.PhysicsBody
 import me.srikavin.fbla.game.physics.ContactListenerManager
 import me.srikavin.fbla.game.trigger.TriggerManager
+import me.srikavin.fbla.game.util.EntityInt
 
 /**
  * Responsible for handling trigger
@@ -84,6 +84,7 @@ class TriggerSystem(private val listenerManager: ContactListenerManager) : BaseE
     }
 
     override fun processSystem() {
+        triggerManager.tick(world)
         collisions.forEach {
             if (triggerMapper.has(it.other)) {
                 triggerManager.handle(world, it.player, it.other, triggerMapper[it.other])
diff --git a/core/src/me/srikavin/fbla/game/ecs/system/TutorialSystem.kt b/core/src/me/srikavin/fbla/game/ecs/system/TutorialSystem.kt
index aefd2c0..7c99cbc 100644
--- a/core/src/me/srikavin/fbla/game/ecs/system/TutorialSystem.kt
+++ b/core/src/me/srikavin/fbla/game/ecs/system/TutorialSystem.kt
@@ -5,10 +5,10 @@ import com.artemis.annotations.All
 import com.artemis.annotations.Wire
 import com.artemis.systems.EntityProcessingSystem
 import com.badlogic.gdx.scenes.scene2d.Stage
-import me.srikavin.fbla.game.EntityInt
 import me.srikavin.fbla.game.ecs.component.MapTrigger
 import me.srikavin.fbla.game.ecs.component.PhysicsBody
 import me.srikavin.fbla.game.physics.ContactListenerManager
+import me.srikavin.fbla.game.util.EntityInt
 
 /**
  * Responsible for handling tutorial components
diff --git a/core/src/me/srikavin/fbla/game/ecs/system/UISystem.kt b/core/src/me/srikavin/fbla/game/ecs/system/UISystem.kt
index a46d854..52f200d 100644
--- a/core/src/me/srikavin/fbla/game/ecs/system/UISystem.kt
+++ b/core/src/me/srikavin/fbla/game/ecs/system/UISystem.kt
@@ -1,54 +1,60 @@
 package me.srikavin.fbla.game.ecs.system
 
 import com.artemis.BaseSystem
+import com.artemis.ComponentMapper
 import com.artemis.annotations.Wire
-import com.badlogic.gdx.Gdx
-import com.badlogic.gdx.scenes.scene2d.Stage
-import com.badlogic.gdx.scenes.scene2d.ui.Cell
-import com.badlogic.gdx.scenes.scene2d.ui.Label
-import com.badlogic.gdx.scenes.scene2d.ui.Table
+import com.artemis.managers.TagManager
+import com.badlogic.gdx.scenes.scene2d.ui.Skin
 import com.rafaskoberg.gdx.typinglabel.TypingConfig
-import me.srikavin.fbla.game.GameState
-import me.srikavin.fbla.game.registerInputHandler
+import me.srikavin.fbla.game.ecs.component.Dead
+import me.srikavin.fbla.game.state.GameState
+import me.srikavin.fbla.game.ui.DeadUI
+import me.srikavin.fbla.game.ui.GameHudUI
 
 /**
  * Responsible for drawing and updating UI elements
  */
 class UISystem : BaseSystem() {
-    @Wire
-    private lateinit var stage: Stage
-    @Wire
-    private lateinit var root: Table
-    @Wire
-    private lateinit var gameState: GameState
+    private lateinit var gameHudUI: GameHudUI
+    private lateinit var deadUI: DeadUI
 
-    private lateinit var scoreCell: Cell<Label>
-    private lateinit var livesCell: Cell<Label>
+    var showingDead = false
 
-    private var builder = StringBuilder("Score: ")
-    private var builderLives = StringBuilder("Lives: ")
+    @Wire
+    private lateinit var deadMapper: ComponentMapper<Dead>
 
     override fun initialize() {
         super.initialize()
         TypingConfig.DEFAULT_SPEED_PER_CHAR = 0.05f
 
-        registerInputHandler(stage)
+        gameHudUI = GameHudUI(world.getRegistered(Skin::class.java), world.getRegistered(GameState::class.java))
+        deadUI = DeadUI(world.getRegistered(Skin::class.java))
 
-        scoreCell = root.add("")
-        root.row()
-        livesCell = root.add("")
+        gameHudUI.build()
     }
 
     override fun processSystem() {
-        scoreCell.actor.setText("Score: ${gameState.score}")
-        livesCell.actor.setText("Lives: ${gameState.lives}")
-
-        stage.act(Gdx.graphics.deltaTime)
-        stage.draw()
+        gameHudUI.render()
+
+        val player = world.getSystem(TagManager::class.java).getEntityId("PLAYER")
+
+        showingDead = if (deadMapper.has(player)) {
+            if (!showingDead) {
+                deadUI.build(deadMapper[player])
+            }
+            true
+        } else {
+            false
+        }
+
+        if (showingDead) {
+            deadUI.render()
+        }
     }
 
     override fun dispose() {
         super.dispose()
-        stage.dispose()
+        gameHudUI.dispose()
+        deadUI.dispose()
     }
 }
\ No newline at end of file
diff --git a/core/src/me/srikavin/fbla/game/map/MapLoader.kt b/core/src/me/srikavin/fbla/game/map/MapLoader.kt
index e41a7a0..0028edd 100644
--- a/core/src/me/srikavin/fbla/game/map/MapLoader.kt
+++ b/core/src/me/srikavin/fbla/game/map/MapLoader.kt
@@ -18,14 +18,14 @@ import com.badlogic.gdx.physics.box2d.*
 import ktx.assets.disposeSafely
 import ktx.log.error
 import ktx.log.info
-import me.srikavin.fbla.game.EntityInt
-import me.srikavin.fbla.game.GdxArray
 import me.srikavin.fbla.game.ecs.component.*
 import me.srikavin.fbla.game.ecs.component.Transform
 import me.srikavin.fbla.game.ecs.system.CameraFollowSystem
 import me.srikavin.fbla.game.graphics.MAP_SCALE_FACTOR
 import me.srikavin.fbla.game.graphics.SpritesheetLoader
 import me.srikavin.fbla.game.trigger.TriggerType
+import me.srikavin.fbla.game.util.EntityInt
+import me.srikavin.fbla.game.util.GdxArray
 
 
 private const val COLLISION_LAYER_NAME = "Collision"
@@ -84,7 +84,7 @@ class MapLoader {
                     friction = 0f
                 })
                 .add(PlayerControlled())
-                .add(SpriteOffset(Vector2(-.75f, -1.1f)))
+                .add(SpriteOffset(Vector2(-0.85f, -1.1f)))
                 .add(Transform().apply { position = pos })
                 .add(SwitchableAnimation().apply { animations = playerAnimations; currentState = "Stand" })
                 .add(FixedRotation())
@@ -97,7 +97,7 @@ class MapLoader {
     /**
      * Creates a coin entity with the given world and given position
      */
-    private fun createCoin(world: World, pos: Vector2) {
+    fun createCoin(world: World, pos: Vector2) {
         world.createEntity().edit()
                 .add(Transform().apply { position = pos })
                 .add(Sprite().apply { sprite = coinSprite })
diff --git a/core/src/me/srikavin/fbla/game/minigame/Minigame.kt b/core/src/me/srikavin/fbla/game/minigame/Minigame.kt
index 0621928..27cd226 100644
--- a/core/src/me/srikavin/fbla/game/minigame/Minigame.kt
+++ b/core/src/me/srikavin/fbla/game/minigame/Minigame.kt
@@ -7,8 +7,8 @@ import com.badlogic.gdx.graphics.g2d.SpriteBatch
 import com.badlogic.gdx.maps.MapProperties
 import com.badlogic.gdx.scenes.scene2d.Stage
 import com.badlogic.gdx.scenes.scene2d.ui.Skin
-import me.srikavin.fbla.game.MapTriggerDelegate
 import me.srikavin.fbla.game.map.MapLoader
+import me.srikavin.fbla.game.util.MapTriggerDelegate
 
 /**
  * The baseclass that all minigames inherit from. This class handles level transitions and communications with outside
@@ -70,14 +70,17 @@ abstract class Minigame {
      */
     fun initialize(skin: Skin, stage: Stage) {
         active = true
-
         initializeMinigame(skin, stage)
     }
 
     /**
-     * Immediately ends the minigame and transitions to the next level.
+     * Ends the minigame and transitions to the next level.
+     * If an award is to be shown, it will be shown before the next level.
      */
     fun endMinigame() {
+        if (mapProperties.properties.containsKey("award")) {
+
+        }
         active = false
         Gdx.app.postRunnable {
             mapLoader.loadMap(world, "assets/maps/$nextLevel")
diff --git a/core/src/me/srikavin/fbla/game/minigame/dialogue/DialogueMinigame.kt b/core/src/me/srikavin/fbla/game/minigame/dialogue/DialogueMinigame.kt
index 2f73e33..05864d9 100644
--- a/core/src/me/srikavin/fbla/game/minigame/dialogue/DialogueMinigame.kt
+++ b/core/src/me/srikavin/fbla/game/minigame/dialogue/DialogueMinigame.kt
@@ -6,11 +6,11 @@ import com.badlogic.gdx.maps.MapProperties
 import com.badlogic.gdx.scenes.scene2d.Stage
 import com.badlogic.gdx.scenes.scene2d.ui.Skin
 import kotlinx.coroutines.channels.Channel
-import me.srikavin.fbla.game.GameState
 import me.srikavin.fbla.game.dialogue.DialogueCallable
 import me.srikavin.fbla.game.dialogue.DialogueManager
 import me.srikavin.fbla.game.ecs.component.DialogueComponent
 import me.srikavin.fbla.game.minigame.Minigame
+import me.srikavin.fbla.game.state.GameState
 
 class DialogueMinigame : Minigame() {
     lateinit var dialogueManager: DialogueManager
diff --git a/core/src/me/srikavin/fbla/game/minigame/dropcatch/DropcatchMinigame.kt b/core/src/me/srikavin/fbla/game/minigame/dropcatch/DropcatchMinigame.kt
index 3ae6406..5170873 100644
--- a/core/src/me/srikavin/fbla/game/minigame/dropcatch/DropcatchMinigame.kt
+++ b/core/src/me/srikavin/fbla/game/minigame/dropcatch/DropcatchMinigame.kt
@@ -23,9 +23,6 @@ import com.badlogic.gdx.scenes.scene2d.utils.NinePatchDrawable
 import com.badlogic.gdx.scenes.scene2d.utils.TextureRegionDrawable
 import com.badlogic.gdx.utils.ObjectMap
 import ktx.log.info
-import me.srikavin.fbla.game.EntityInt
-import me.srikavin.fbla.game.GameState
-import me.srikavin.fbla.game.GdxArray
 import me.srikavin.fbla.game.ecs.component.PhysicsBody
 import me.srikavin.fbla.game.ecs.component.Sprite
 import me.srikavin.fbla.game.ecs.component.SpriteOffset
@@ -36,6 +33,11 @@ import me.srikavin.fbla.game.graphics.MAP_SCALE_FACTOR
 import me.srikavin.fbla.game.map.MapLoader
 import me.srikavin.fbla.game.minigame.Minigame
 import me.srikavin.fbla.game.physics.ContactListenerManager
+import me.srikavin.fbla.game.state.GameState
+import me.srikavin.fbla.game.util.EntityInt
+import me.srikavin.fbla.game.util.GdxArray
+
+const val style_name = "menu"
 
 class DropcatchMinigame : Minigame() {
     private val inputs = GdxArray<Int>()
@@ -91,10 +93,8 @@ class DropcatchMinigame : Minigame() {
 
         container.addActor(table)
 
-        itemsLeft = Label("Items Left: ?", skin)
-        timeLeft = Label("Time Left: ?", skin)
-
-
+        itemsLeft = Label("Items Left: ?", skin, style_name)
+        timeLeft = Label("Time Left: ?", skin, style_name)
 
         table.add(itemsLeft)
         table.row()
@@ -134,8 +134,10 @@ class DropcatchMinigame : Minigame() {
                     if (comp.type == DropcatchItemType.GOOD) {
                         gameState.score += 1
                         goodItemsLeft -= 1
+                        goodCollected++
                     } else {
                         gameState.score -= 1
+                        badCollected++
                     }
                     Gdx.app.postRunnable {
                         world.delete(otherId)
@@ -186,68 +188,69 @@ class DropcatchMinigame : Minigame() {
                 "gooditem" -> {
                     editor.add(DropcatchItemComponent().apply { this.type = DropcatchItemType.GOOD })
                     goodItemsLeft++
-                    goodCollected++
                 }
                 "baditem" -> {
                     editor.add(DropcatchItemComponent().apply { this.type = DropcatchItemType.BAD })
-                    badCollected++
                 }
                 else -> {
                     error("Unknown dropcatch minigame type: $type")
                 }
             }
         }
+
+        infoPanel = container.table(NinePatchDrawable(table.skin.getPatch("menu-button-bg"))) {
+            it.add("Collect the items as fast as possible, while avoiding unwanted objects!", style_name)
+            it.row()
+            it.add().height(15f)
+            it.row()
+            it.table { t ->
+                t.table { inner ->
+                    inner.add("[green]Collect:[]", style_name).actor.setScale(3f)
+
+                    for (item in goodItems) {
+                        info { "$goodItems" }
+                        inner.row()
+                        inner.add(Image(item)).height(50f).width(50f * item.minWidth / item.minHeight)
+                    }
+                }
+
+                t.add().width(40f)
+
+                t.table { inner ->
+                    inner.add("[accent]Avoid:[]", style_name).actor.setScale(3f)
+
+                    for (item in badItems) {
+                        info { "$badItems" }
+                        inner.row()
+                        inner.add(Image(item)).height(50f).width(50f * item.minWidth / item.minHeight)
+                    }
+                }
+            }.center().bottom()
+        }.width(880f).height(150f).fill().actor
+
     }
 
     override fun render(camera: OrthographicCamera, batch: SpriteBatch, stage: Stage) {
         if (firstRender) {
             table.isTransform = true
             container.isTransform = true
+            table.clearActions()
             table.sequence(
                     Actions.moveTo(1920 / 2f - 150f, 1080 / 4f),
                     Actions.scaleTo(3f, 3f),
                     Actions.parallel(
-                            Actions.moveTo(1920 / 2f, table.y, 2.5f, Interpolation.pow2In),
+                            Actions.moveTo(1920 / 2f - 80f, table.y, 2.5f, Interpolation.pow2In),
                             Actions.scaleTo(1f, 1f, 2.5f, Interpolation.pow2In)
                     )
             )
-            infoPanel = container.table(NinePatchDrawable(table.skin.getPatch("menu-button-bg"))) {
-                it.add("Collect the items as fast as possible, while avoiding unwanted objects!")
-                it.row()
-                it.add().height(15f)
-                it.row()
-                it.table { t ->
-                    t.table { inner ->
-                        inner.add("[green]Collect:[]").actor.setScale(3f)
-
-                        for (item in goodItems) {
-                            info { "$goodItems" }
-                            inner.row()
-                            inner.add(Image(item)).height(50f).width(50f * item.minWidth / item.minHeight)
-                        }
-                    }
-
-                    t.add().width(40f)
-
-                    t.table { inner ->
-                        inner.add("[accent]Avoid:[]").actor.setScale(3f)
-
-                        for (item in badItems) {
-                            info { "$badItems" }
-                            inner.row()
-                            inner.add(Image(item)).height(50f).width(50f * item.minWidth / item.minHeight)
-                        }
-                    }
-                }.center().bottom()
-            }.width(880f).height(150f).fill().actor
 
+            infoPanel.clearActions()
             infoPanel.sequence(
                     Actions.fadeIn(7f),
                     Actions.fadeOut(3f),
                     Actions.hide()
             )
 
-
             firstRender = false
         }
 
@@ -275,11 +278,11 @@ class DropcatchMinigame : Minigame() {
                         goodItemsLeft < 10 -> "You could've gotten more."
                         else -> "Good effort! Better luck next time."
                     }
-                    it.add(response)
+                    it.add(response, style_name)
                     it.row()
-                    it.add("You collected [green]$goodCollected items[], but also [accent]$badCollected unwanted objects[]!")
+                    it.add("You collected [green]$goodCollected items[], but also [accent]$badCollected unwanted objects[]!", style_name)
                     it.row()
-                    it.add("Score: [green]${goodCollected + timeLeftVal.toInt() - badCollected}[]")
+                    it.add("Score: [green]${goodCollected - badCollected}[]", style_name)
                 }
 
                 infoPanel.sequence(
diff --git a/core/src/me/srikavin/fbla/game/minigame/quiz/QuizMinigame.kt b/core/src/me/srikavin/fbla/game/minigame/quiz/QuizMinigame.kt
index fc88886..46ad1c3 100644
--- a/core/src/me/srikavin/fbla/game/minigame/quiz/QuizMinigame.kt
+++ b/core/src/me/srikavin/fbla/game/minigame/quiz/QuizMinigame.kt
@@ -8,8 +8,8 @@ import com.badlogic.gdx.scenes.scene2d.Stage
 import com.badlogic.gdx.scenes.scene2d.ui.Skin
 import com.badlogic.gdx.scenes.scene2d.ui.Table
 import com.rafaskoberg.gdx.typinglabel.TypingLabel
-import me.srikavin.fbla.game.GdxArray
 import me.srikavin.fbla.game.minigame.Minigame
+import me.srikavin.fbla.game.util.GdxArray
 
 class QuizMinigame : Minigame() {
     private val inputs = GdxArray<Int>()
diff --git a/core/src/me/srikavin/fbla/game/state/GameRules.kt b/core/src/me/srikavin/fbla/game/state/GameRules.kt
new file mode 100644
index 0000000..249a32e
--- /dev/null
+++ b/core/src/me/srikavin/fbla/game/state/GameRules.kt
@@ -0,0 +1,7 @@
+package me.srikavin.fbla.game.state
+
+class GameRules {
+    var enemiesToGold = false
+    var livesGainedPerLevel = 0
+    var coinMultiplier = 1
+}
\ No newline at end of file
diff --git a/core/src/me/srikavin/fbla/game/state/GameState.kt b/core/src/me/srikavin/fbla/game/state/GameState.kt
new file mode 100644
index 0000000..1e29496
--- /dev/null
+++ b/core/src/me/srikavin/fbla/game/state/GameState.kt
@@ -0,0 +1,29 @@
+package me.srikavin.fbla.game.state
+
+import me.srikavin.fbla.game.award.Award
+import me.srikavin.fbla.game.award.Awards
+
+data class GameState(
+        var score: Int = 0,
+        var lives: Int = 3,
+        var gameRules: GameRules = GameRules(),
+        val awards: LinkedHashSet<Award> = LinkedHashSet(4),
+        var currentLevelPath: String = "level1.tmx"
+) {
+    fun addAward(name: String) {
+        addAward(Awards.getAward(name))
+    }
+
+    fun addAward(award: Award) {
+        awards.add(award)
+        award.apply(gameRules)
+    }
+
+    fun removeAward(name: String) {
+        removeAward(Awards.getAward(name))
+    }
+
+    fun removeAward(award: Award) {
+        awards.remove(award)
+    }
+}
diff --git a/core/src/me/srikavin/fbla/game/trigger/CoinTriggerHandler.kt b/core/src/me/srikavin/fbla/game/trigger/CoinTriggerHandler.kt
index dd29b43..10d9e5a 100644
--- a/core/src/me/srikavin/fbla/game/trigger/CoinTriggerHandler.kt
+++ b/core/src/me/srikavin/fbla/game/trigger/CoinTriggerHandler.kt
@@ -1,9 +1,9 @@
 package me.srikavin.fbla.game.trigger
 
 import com.artemis.World
-import me.srikavin.fbla.game.EntityInt
-import me.srikavin.fbla.game.GameState
 import me.srikavin.fbla.game.ecs.component.MapTrigger
+import me.srikavin.fbla.game.state.GameState
+import me.srikavin.fbla.game.util.EntityInt
 
 /**
  * Handles triggers resulting from player collision with coins.
@@ -13,7 +13,7 @@ class CoinTriggerHandler : TriggerHandler {
         world.delete(triggerEntity)
 
         val gameState = world.getRegistered(GameState::class.java)
-        gameState.score++
+        gameState.score += gameState.gameRules.coinMultiplier
         // TODO: Play Sound
     }
 }
\ No newline at end of file
diff --git a/core/src/me/srikavin/fbla/game/trigger/DamageTriggerHandler.kt b/core/src/me/srikavin/fbla/game/trigger/DamageTriggerHandler.kt
index ef1645f..1506630 100644
--- a/core/src/me/srikavin/fbla/game/trigger/DamageTriggerHandler.kt
+++ b/core/src/me/srikavin/fbla/game/trigger/DamageTriggerHandler.kt
@@ -2,16 +2,14 @@ package me.srikavin.fbla.game.trigger
 
 import com.artemis.World
 import com.badlogic.gdx.math.Vector2
+import com.badlogic.gdx.physics.box2d.Filter
 import com.badlogic.gdx.utils.TimeUtils
 import ktx.math.times
-import me.srikavin.fbla.game.EntityInt
-import me.srikavin.fbla.game.GameState
-import me.srikavin.fbla.game.ecs.component.MapTrigger
-import me.srikavin.fbla.game.ecs.component.PhysicsBody
-import me.srikavin.fbla.game.ecs.component.SpawnPoint
-import me.srikavin.fbla.game.ecs.component.Transform
+import me.srikavin.fbla.game.ecs.component.*
 import me.srikavin.fbla.game.ecs.system.TriggerSystem
 import me.srikavin.fbla.game.map.MapLoader
+import me.srikavin.fbla.game.state.GameState
+import me.srikavin.fbla.game.util.EntityInt
 
 private const val INVULNERABLE_TIME_MSEC: Long = 500
 
@@ -27,31 +25,61 @@ class DamageTriggerHandler : TriggerHandler {
             return
         }
 
+
         val gameState = world.getRegistered(GameState::class.java)
         val physicsMapper = world.getMapper(PhysicsBody::class.java)
         val transformMapper = world.getMapper(Transform::class.java)
 
-        gameState.lives -= 1
+        if (!physicsMapper.has(player) || !transformMapper.has(player)) {
+            return
+        }
 
-        lastDamageTime = TimeUtils.millis()
-        if (physicsMapper.has(player) && transformMapper.has(player)) {
-            val pBody = physicsMapper[player].body
-            val tBody = physicsMapper[triggerEntity].body
+        val pBody = physicsMapper[player].body
+        val tBody = physicsMapper[triggerEntity].body
+
+        val direction = pBody.position.sub(tBody.position).nor()
 
-            val direction = pBody.position.sub(tBody.position).nor()
+        pBody.applyLinearImpulse(knockbackImpulse.times(direction), transformMapper[player].position, true)
 
-            pBody.applyLinearImpulse(knockbackImpulse.times(direction), transformMapper[player].position, true)
+        if (gameState.gameRules.enemiesToGold && (trigger.properties.get("subtype", "", String::class.java) != "environmental")) {
+            val mapLoader = world.getRegistered(MapLoader::class.java)
+            mapLoader.createCoin(world, tBody.position)
+            mapLoader.createCoin(world, tBody.position.cpy().add(1f, 1f))
+            mapLoader.createCoin(world, tBody.position.cpy().add(-1f, 1f))
+            mapLoader.createCoin(world, tBody.position.cpy().add(-1f, 0f))
+            mapLoader.createCoin(world, tBody.position.cpy().add(-1f, -1f))
+            world.delete(triggerEntity)
+            return
         }
 
+        val animationMapper = world.getMapper(SwitchableAnimation::class.java)
+
+        gameState.lives -= 1
+
+        animationMapper[player].lock("Damage")
+
+        lastDamageTime = TimeUtils.millis()
+
         if (gameState.lives <= 0) {
-            val spawnPointMapper = world.getMapper(SpawnPoint::class.java)
-            if (spawnPointMapper.has(player) && physicsMapper.has(player)) {
-                val spawnPoint = spawnPointMapper[player].position.cpy()
-                world.delete(player)
-                world.getRegistered(MapLoader::class.java).createPlayer(world, spawnPoint)
-                world.getSystem(TriggerSystem::class.java).removePlayerFromCollision(player)
-                gameState.lives = 3
+            animationMapper[player].lock("Death")
+            val filter = Filter()
+            filter.groupIndex = -1
+            pBody.fixtureList.forEach {
+                it.filterData = filter
             }
+
+            world.getEntity(player).edit().add(Dead().apply {
+                respawnRunnable = {
+                    val spawnPointMapper = world.getMapper(SpawnPoint::class.java)
+                    if (spawnPointMapper.has(player) && physicsMapper.has(player)) {
+                        val spawnPoint = spawnPointMapper[player].position.cpy()
+                        world.delete(player)
+                        world.getRegistered(MapLoader::class.java).createPlayer(world, spawnPoint)
+                        world.getSystem(TriggerSystem::class.java).removePlayerFromCollision(player)
+                        gameState.lives = 3
+                    }
+                }
+            })
         }
     }
 }
\ No newline at end of file
diff --git a/core/src/me/srikavin/fbla/game/trigger/InteractiveTriggerHandler.kt b/core/src/me/srikavin/fbla/game/trigger/InteractiveTriggerHandler.kt
index 7d80756..04900d9 100644
--- a/core/src/me/srikavin/fbla/game/trigger/InteractiveTriggerHandler.kt
+++ b/core/src/me/srikavin/fbla/game/trigger/InteractiveTriggerHandler.kt
@@ -14,9 +14,9 @@ import com.badlogic.gdx.scenes.scene2d.Stage
 import com.badlogic.gdx.scenes.scene2d.ui.Dialog
 import com.badlogic.gdx.scenes.scene2d.ui.Label
 import com.badlogic.gdx.scenes.scene2d.ui.Skin
-import me.srikavin.fbla.game.EntityInt
 import me.srikavin.fbla.game.ecs.component.MapTrigger
 import me.srikavin.fbla.game.ecs.component.Transform
+import me.srikavin.fbla.game.util.EntityInt
 
 
 class InteractiveTriggerHandler : TriggerHandler {
diff --git a/core/src/me/srikavin/fbla/game/trigger/LevelTitleTriggerHandler.kt b/core/src/me/srikavin/fbla/game/trigger/LevelTitleTriggerHandler.kt
new file mode 100644
index 0000000..3c6fce6
--- /dev/null
+++ b/core/src/me/srikavin/fbla/game/trigger/LevelTitleTriggerHandler.kt
@@ -0,0 +1,64 @@
+package me.srikavin.fbla.game.trigger
+
+import com.artemis.World
+import com.badlogic.gdx.scenes.scene2d.Stage
+import com.badlogic.gdx.scenes.scene2d.actions.Actions
+import com.badlogic.gdx.scenes.scene2d.ui.Skin
+import com.badlogic.gdx.scenes.scene2d.ui.Table
+import com.badlogic.gdx.scenes.scene2d.utils.NinePatchDrawable
+import com.badlogic.gdx.utils.viewport.ExtendViewport
+import me.srikavin.fbla.game.ecs.component.MapTrigger
+import me.srikavin.fbla.game.ext.sequence
+import me.srikavin.fbla.game.ext.table
+import me.srikavin.fbla.game.state.GameState
+import me.srikavin.fbla.game.util.EntityInt
+import me.srikavin.fbla.game.util.GameFonts
+
+
+class LevelTitleTriggerHandler : TriggerHandler {
+    lateinit var skin: Skin
+    val stage = Stage(ExtendViewport(1920f, 1080f))
+
+    var initialized = false
+
+    lateinit var container: Table
+    lateinit var infoPanel: Table
+
+    override fun run(world: World, player: EntityInt, triggerEntity: EntityInt, trigger: MapTrigger) {
+        val state = world.getRegistered(GameState::class.java)
+        val message = (trigger.properties["message"] as String).replace("{score}", "${state.score}")
+        infoPanel.clear()
+        val act = infoPanel.add(message).actor
+
+        if (message.count { c -> c == '\n' } == 0) {
+            act.style.font = GameFonts.LARGE
+        }
+
+        infoPanel.isVisible = true
+        infoPanel.sequence(
+                Actions.fadeIn(0.5f),
+                Actions.fadeIn(1.5f),
+                Actions.fadeOut(0.5f),
+                Actions.hide()
+        )
+    }
+
+    fun tick(world: World) {
+        if (!initialized) {
+            initialized = true
+
+            val skin = world.getRegistered(Skin::class.java)
+
+            container = Table(skin)
+            container.setFillParent(true)
+            container.setSize(1920f, 1080f)
+            stage.addActor(container)
+
+            infoPanel = container.table(NinePatchDrawable(skin.getPatch("menu-button-bg"))) {
+            }.width(940f).height(200f).fill().actor
+        }
+
+        stage.act()
+        stage.draw()
+    }
+}
diff --git a/core/src/me/srikavin/fbla/game/trigger/MinigameTriggerHandler.kt b/core/src/me/srikavin/fbla/game/trigger/MinigameTriggerHandler.kt
index 4e301d5..75de657 100644
--- a/core/src/me/srikavin/fbla/game/trigger/MinigameTriggerHandler.kt
+++ b/core/src/me/srikavin/fbla/game/trigger/MinigameTriggerHandler.kt
@@ -1,11 +1,11 @@
 package me.srikavin.fbla.game.trigger
 
 import com.artemis.World
-import me.srikavin.fbla.game.EntityInt
 import me.srikavin.fbla.game.ecs.component.MapTrigger
 import me.srikavin.fbla.game.ecs.component.MinigameComponent
 import me.srikavin.fbla.game.map.MapLoader
 import me.srikavin.fbla.game.minigame.MinigameManager
+import me.srikavin.fbla.game.util.EntityInt
 
 /**
  * Handles triggers resulting from player collision with minigame triggers.
diff --git a/core/src/me/srikavin/fbla/game/trigger/TransitionTriggerHandler.kt b/core/src/me/srikavin/fbla/game/trigger/TransitionTriggerHandler.kt
index aab51d7..a8a23d5 100644
--- a/core/src/me/srikavin/fbla/game/trigger/TransitionTriggerHandler.kt
+++ b/core/src/me/srikavin/fbla/game/trigger/TransitionTriggerHandler.kt
@@ -1,9 +1,10 @@
 package me.srikavin.fbla.game.trigger
 
 import com.artemis.World
-import me.srikavin.fbla.game.EntityInt
 import me.srikavin.fbla.game.ecs.component.MapTrigger
 import me.srikavin.fbla.game.map.MapLoader
+import me.srikavin.fbla.game.state.GameState
+import me.srikavin.fbla.game.util.EntityInt
 
 /**
  * Handles triggers resulting from player collision with level transition triggers.
@@ -13,6 +14,10 @@ class TransitionTriggerHandler : TriggerHandler {
         val mapLoader = world.getRegistered(MapLoader::class.java)
         val newMap = world.getMapper(MapTrigger::class.java)[triggerEntity].properties["level_name"]!!.toString()
 
+        val gameState = world.getRegistered(GameState::class.java)
+        gameState.lives += gameState.gameRules.livesGainedPerLevel
+        gameState.currentLevelPath = newMap
+
         mapLoader.loadMap(world, newMap)
     }
 
diff --git a/core/src/me/srikavin/fbla/game/trigger/TriggerHandler.kt b/core/src/me/srikavin/fbla/game/trigger/TriggerHandler.kt
index c23e0e3..c8385fe 100644
--- a/core/src/me/srikavin/fbla/game/trigger/TriggerHandler.kt
+++ b/core/src/me/srikavin/fbla/game/trigger/TriggerHandler.kt
@@ -1,8 +1,8 @@
 package me.srikavin.fbla.game.trigger
 
 import com.artemis.World
-import me.srikavin.fbla.game.EntityInt
 import me.srikavin.fbla.game.ecs.component.MapTrigger
+import me.srikavin.fbla.game.util.EntityInt
 
 /**
  * Represents a handler for triggers.
diff --git a/core/src/me/srikavin/fbla/game/trigger/TriggerManager.kt b/core/src/me/srikavin/fbla/game/trigger/TriggerManager.kt
index d4a139e..f5bd232 100644
--- a/core/src/me/srikavin/fbla/game/trigger/TriggerManager.kt
+++ b/core/src/me/srikavin/fbla/game/trigger/TriggerManager.kt
@@ -1,8 +1,8 @@
 package me.srikavin.fbla.game.trigger
 
 import com.artemis.World
-import me.srikavin.fbla.game.EntityInt
 import me.srikavin.fbla.game.ecs.component.MapTrigger
+import me.srikavin.fbla.game.util.EntityInt
 
 /**
  * Handles delegation of triggers to their associated [TriggerHandler].
@@ -13,6 +13,7 @@ class TriggerManager {
     private val interactiveTriggerHandler = InteractiveTriggerHandler()
     private val minigameTriggerHandler = MinigameTriggerHandler()
     private val damageTriggerHandler = DamageTriggerHandler()
+    private val levelTitleTriggerHandler = LevelTitleTriggerHandler()
 
     fun handle(world: World, player: EntityInt, triggerEntity: EntityInt, trigger: MapTrigger) {
         when (trigger.type) {
@@ -21,6 +22,12 @@ class TriggerManager {
             TriggerType.INTERACTIVE -> interactiveTriggerHandler.run(world, player, triggerEntity, trigger)
             TriggerType.MINIGAME -> minigameTriggerHandler.run(world, player, triggerEntity, trigger)
             TriggerType.DAMAGE -> damageTriggerHandler.run(world, player, triggerEntity, trigger)
+//            TriggerType.TUTORIAL -> TODO()
+            TriggerType.LEVEL_TITLE -> levelTitleTriggerHandler.run(world, player, triggerEntity, trigger)
         }
     }
+
+    fun tick(world: World) {
+        levelTitleTriggerHandler.tick(world)
+    }
 }
\ No newline at end of file
diff --git a/core/src/me/srikavin/fbla/game/trigger/TriggerType.kt b/core/src/me/srikavin/fbla/game/trigger/TriggerType.kt
index 75348fa..88a9bd1 100644
--- a/core/src/me/srikavin/fbla/game/trigger/TriggerType.kt
+++ b/core/src/me/srikavin/fbla/game/trigger/TriggerType.kt
@@ -9,5 +9,6 @@ enum class TriggerType {
     INTERACTIVE,
     MINIGAME,
     DAMAGE,
-    TUTORIAL
+    TUTORIAL,
+    LEVEL_TITLE
 }
\ No newline at end of file
diff --git a/core/src/me/srikavin/fbla/game/trigger/TutorialTriggerHandler.kt b/core/src/me/srikavin/fbla/game/trigger/TutorialTriggerHandler.kt
index d626eab..0312987 100644
--- a/core/src/me/srikavin/fbla/game/trigger/TutorialTriggerHandler.kt
+++ b/core/src/me/srikavin/fbla/game/trigger/TutorialTriggerHandler.kt
@@ -1,8 +1,8 @@
 package me.srikavin.fbla.game.trigger
 
 import com.artemis.World
-import me.srikavin.fbla.game.EntityInt
 import me.srikavin.fbla.game.ecs.component.MapTrigger
+import me.srikavin.fbla.game.util.EntityInt
 
 enum class TutorialType {
     START,
diff --git a/core/src/me/srikavin/fbla/game/ui/DeadUI.kt b/core/src/me/srikavin/fbla/game/ui/DeadUI.kt
new file mode 100644
index 0000000..0641bc1
--- /dev/null
+++ b/core/src/me/srikavin/fbla/game/ui/DeadUI.kt
@@ -0,0 +1,70 @@
+package me.srikavin.fbla.game.ui
+
+import com.badlogic.gdx.Gdx
+import com.badlogic.gdx.math.MathUtils
+import com.badlogic.gdx.scenes.scene2d.Stage
+import com.badlogic.gdx.scenes.scene2d.ui.Skin
+import com.badlogic.gdx.scenes.scene2d.ui.Table
+import com.badlogic.gdx.scenes.scene2d.utils.NinePatchDrawable
+import com.badlogic.gdx.utils.viewport.ExtendViewport
+import me.srikavin.fbla.game.ecs.component.Dead
+import me.srikavin.fbla.game.ext.addImageTextButton
+import me.srikavin.fbla.game.ext.table
+import me.srikavin.fbla.game.util.registerInputHandler
+import me.srikavin.fbla.game.util.unregisterInputHandler
+
+class DeadUI(private val skin: Skin) : GameUI() {
+    private val stage = Stage(ExtendViewport(1920f, 1080f, 1920f, 1080f))
+    private val container = Table(skin)
+
+    private var deathMessages = listOf(
+            "Ouch! That must’ve hurt! Try again?",
+            "Dang! What happened?! Try again?",
+            "Oof! Wah! wah! wah! Try again?"
+    )
+
+    init {
+        registerInputHandler(stage)
+    }
+
+    private fun getRandomDeathString(): String {
+        val rand = MathUtils.random(0, deathMessages.size - 1)
+        return deathMessages[rand]
+    }
+
+    fun build(deadComponent: Dead) {
+        stage.viewport.update(Gdx.graphics.width, Gdx.graphics.height)
+        container.clear()
+
+        container.setFillParent(true)
+        container.setSize(1920f, 1080f)
+        stage.addActor(container)
+
+        container.table(NinePatchDrawable(skin.getPatch("menu-button-bg"))) {
+            it.table { inner ->
+                inner.add(getRandomDeathString())
+            }
+            it.row()
+            it.add().height(10f)
+            it.row()
+            it.table { inner ->
+                inner.addImageTextButton("[green]Restart Level[]", null, Runnable {
+                    deadComponent.respawnRunnable()
+                }, "menu")
+                inner.add().width(45f)
+                inner.addImageTextButton("[accent]Save and Quit[]", null, Runnable {
+                    Gdx.app.exit()
+                }, "menu")
+            }
+        }.width(1040f).height(150f).fill()
+    }
+
+    override fun render() {
+        stage.act()
+        stage.draw()
+    }
+
+    override fun dispose() {
+        unregisterInputHandler(stage)
+    }
+}
\ No newline at end of file
diff --git a/core/src/me/srikavin/fbla/game/ui/GameHudUI.kt b/core/src/me/srikavin/fbla/game/ui/GameHudUI.kt
new file mode 100644
index 0000000..eb89d03
--- /dev/null
+++ b/core/src/me/srikavin/fbla/game/ui/GameHudUI.kt
@@ -0,0 +1,71 @@
+package me.srikavin.fbla.game.ui
+
+import com.badlogic.gdx.Gdx
+import com.badlogic.gdx.scenes.scene2d.Stage
+import com.badlogic.gdx.scenes.scene2d.ui.Image
+import com.badlogic.gdx.scenes.scene2d.ui.Label
+import com.badlogic.gdx.scenes.scene2d.ui.Skin
+import com.badlogic.gdx.scenes.scene2d.ui.Table
+import com.badlogic.gdx.scenes.scene2d.utils.NinePatchDrawable
+import com.badlogic.gdx.utils.viewport.ExtendViewport
+import me.srikavin.fbla.game.ext.table
+import me.srikavin.fbla.game.state.GameState
+import me.srikavin.fbla.game.util.registerInputHandler
+import me.srikavin.fbla.game.util.unregisterInputHandler
+
+class GameHudUI(private val skin: Skin, private val gameState: GameState) : GameUI() {
+    private val stage = Stage(ExtendViewport(1920f, 1080f, 1920f, 1080f))
+    private val container = Table(skin)
+    private lateinit var livesLabel: Label
+    private lateinit var scoreLabel: Label
+
+    init {
+        registerInputHandler(stage)
+        stage.isDebugAll = true
+    }
+
+    fun build() {
+        stage.viewport.update(Gdx.graphics.width, Gdx.graphics.height)
+        container.clear()
+
+
+        container.setFillParent(true)
+        container.setSize(Gdx.graphics.width.toFloat(), Gdx.graphics.height.toFloat())
+
+        container.top().right()
+
+
+        container.table { t ->
+            gameState.awards.forEach { award ->
+                val drawable = award.getDrawable()
+                t.add(Image(drawable))
+                        .height(100f)
+                        .width(100f * 28 / 43f)
+                        .padLeft(10f)
+            }
+        }.padRight(10f)
+
+        container.table(NinePatchDrawable(skin.getPatch("menu-button-bg"))) { t ->
+            t.defaults()
+
+            t.add("Score: ")
+            scoreLabel = t.add("0").actor
+            t.row()
+            t.add("Lives: ")
+            livesLabel = t.add("3").actor
+        }
+
+        stage.addActor(container)
+    }
+
+    override fun render() {
+        scoreLabel.setText(gameState.score)
+        livesLabel.setText(gameState.lives)
+        stage.act()
+        stage.draw()
+    }
+
+    override fun dispose() {
+        unregisterInputHandler(stage)
+    }
+}
\ No newline at end of file
diff --git a/core/src/me/srikavin/fbla/game/ui/GameUI.kt b/core/src/me/srikavin/fbla/game/ui/GameUI.kt
new file mode 100644
index 0000000..bf25db9
--- /dev/null
+++ b/core/src/me/srikavin/fbla/game/ui/GameUI.kt
@@ -0,0 +1,7 @@
+package me.srikavin.fbla.game.ui
+
+import com.badlogic.gdx.utils.Disposable
+
+abstract class GameUI : Disposable {
+    abstract fun render()
+}
\ No newline at end of file
diff --git a/core/src/me/srikavin/fbla/game/ui/MainMenu.kt b/core/src/me/srikavin/fbla/game/ui/MainMenu.kt
index 8b244dc..185d443 100644
--- a/core/src/me/srikavin/fbla/game/ui/MainMenu.kt
+++ b/core/src/me/srikavin/fbla/game/ui/MainMenu.kt
@@ -11,25 +11,25 @@ import com.badlogic.gdx.scenes.scene2d.utils.Drawable
 import com.badlogic.gdx.scenes.scene2d.utils.NinePatchDrawable
 import com.badlogic.gdx.scenes.scene2d.utils.TextureRegionDrawable
 import com.badlogic.gdx.utils.Align
-import com.badlogic.gdx.utils.Disposable
 import com.badlogic.gdx.utils.Scaling
 import com.badlogic.gdx.utils.viewport.ExtendViewport
 import ktx.actors.alpha
-import me.srikavin.fbla.game.GdxArray
 import me.srikavin.fbla.game.ext.addImageTextButton
 import me.srikavin.fbla.game.ext.sequence
 import me.srikavin.fbla.game.ext.table
-import me.srikavin.fbla.game.registerInputHandler
-import me.srikavin.fbla.game.unregisterInputHandler
+import me.srikavin.fbla.game.util.GdxArray
+import me.srikavin.fbla.game.util.registerInputHandler
+import me.srikavin.fbla.game.util.unregisterInputHandler
 
-class MainMenu(private val skin: Skin, private val playRunnable: () -> Unit) : Disposable {
+private const val style_name = "menu"
+
+class MainMenu(private val skin: Skin, private val playRunnable: () -> Unit) : GameUI() {
     private val stage = Stage(ExtendViewport(1920f, 1080f, 1920f, 1080f))
     private val container = Table(skin)
     private val cloudContainer = Table(skin)
     private val bgStack = Stack()
     private val filterStack = Stack()
 
-
     private lateinit var submenu: Table
     private lateinit var infoPanel: Table
 
@@ -48,7 +48,6 @@ class MainMenu(private val skin: Skin, private val playRunnable: () -> Unit) : D
         logo = TextureRegionDrawable(Texture(Gdx.files.internal("assets/graphics/titlelogopic.png")))
         fblaLogo = TextureRegionDrawable(Texture(Gdx.files.internal("assets/graphics/fbla-logo.png")))
 
-
         cloud = TextureRegionDrawable(Texture(Gdx.files.internal("assets/graphics/backgrounds/cloud1.png")))
         cloud2 = TextureRegionDrawable(Texture(Gdx.files.internal("assets/graphics/backgrounds/cloud2.png")))
         cloud3 = TextureRegionDrawable(Texture(Gdx.files.internal("assets/graphics/backgrounds/cloud3.png")))
@@ -102,7 +101,6 @@ class MainMenu(private val skin: Skin, private val playRunnable: () -> Unit) : D
         animateCloud(cloud3, 45f, 700f, -120f)
         animateCloud(cloud, 35f, 500f, 0f)
 
-
         container.left()
         container.add().width(Gdx.graphics.width / 15f)
 
@@ -119,22 +117,31 @@ class MainMenu(private val skin: Skin, private val playRunnable: () -> Unit) : D
                     ),
                     Buttoni("Instructions", null, Runnable {
                         infoPanel.clearChildren()
-                        infoPanel.add(Label("[accent]Instructions[]", skin).apply { setFontScale(2f) })
+                        infoPanel.add(Label("[accent]Instructions[]", skin, "default"))
                         infoPanel.row()
                         infoPanel.add("Use the arrow keys to move.\n" +
                                 "Use the mouse or displayed numerical key\nto choose options on screen.\n" +
                                 "Use the escape key to quit.\n" +
-                                "Collect coins to increase your score!")
-                    }),
-                    Buttoni("About", null, Runnable {
-                        infoPanel.clearChildren()
-                        infoPanel.add("The [accent]Quest[] for [#00ff00]Success[]\n\n" +
-                                "Programming by [accent]Srikavin Ramkumar[]\n" +
-                                "Story by [#00ff00]David Rogers[]\n" +
-                                "Art by [#DA680F]Nicholas Quach[]"
-//                                "Made for the [#32527B]FBLA[] Computer Game &\n Simulation Programming Competition"
-                        )
+                                "Collect coins to increase your score!", style_name)
                     }),
+                    Buttoni("About", null,
+                            Buttoni("Credits", null, Runnable {
+                                infoPanel.clearChildren()
+                                infoPanel.add("The [accent]Quest[] for [#00ff00]Success[]\n\n" +
+                                        "Programming by [accent]Srikavin Ramkumar[]\n" +
+                                        "Story by [#00ff00]David Rogers[]\n" +
+                                        "Art by [#DA680F]Nicholas Quach[]\n\n" +
+                                        "Made for the [#32527B]FBLA[] Computer Game &\nSimulation Programming Competition",
+                                        style_name)
+                            }),
+                            Buttoni("License", null, Runnable {
+                                infoPanel.clearChildren()
+                                infoPanel.add("This game is licensed under the\n" +
+                                        "[accent]Apache 2.0 License[].\n" +
+                                        "A copy can be found in [#32527B]LICENSE.txt[]",
+                                        style_name)
+                            })
+                    ),
                     Buttoni("Exit", null, Runnable { Gdx.app.exit() })
 
             )
@@ -151,7 +158,7 @@ class MainMenu(private val skin: Skin, private val playRunnable: () -> Unit) : D
 
         val infoContainer = container
                 .table {
-                    it.top().add(Image(logo)).height(300f).width(300 * 166 / 133f)
+                    it.top().add(Image(logo)).height(400f).width(400 * 166 / 133f)
                 }.height(550f)
                 .width(800f)
                 .pad(20f)
@@ -163,7 +170,7 @@ class MainMenu(private val skin: Skin, private val playRunnable: () -> Unit) : D
         infoContainer.table {
             infoPanel = it.table(NinePatchDrawable(skin.getPatch("menu-button-bg")))
                     .width(550f)
-                    .padTop(((Gdx.graphics.height - 170f) / 2) - 250f)
+                    .padTop(((Gdx.graphics.height - 170f) / 2) - 350f)
                     .growY().actor
         }.height(350f)
 
@@ -244,7 +251,7 @@ class MainMenu(private val skin: Skin, private val playRunnable: () -> Unit) : D
                         b.runnable?.run()
                     }
                 }
-            }, "menu").actor
+            }, style_name).actor
             t.row()
 
             out[0]!!.padLeft(11f)
@@ -273,7 +280,7 @@ class MainMenu(private val skin: Skin, private val playRunnable: () -> Unit) : D
         }
     }
 
-    fun render() {
+    override fun render() {
         curButtons.forEach {
             it.isChecked = currentMenu == it
         }
@@ -282,7 +289,6 @@ class MainMenu(private val skin: Skin, private val playRunnable: () -> Unit) : D
 
         stage.act()
         stage.draw()
-
     }
 
     override fun dispose() {
diff --git a/core/src/me/srikavin/fbla/game/util/GameFonts.kt b/core/src/me/srikavin/fbla/game/util/GameFonts.kt
new file mode 100644
index 0000000..27c65fd
--- /dev/null
+++ b/core/src/me/srikavin/fbla/game/util/GameFonts.kt
@@ -0,0 +1,55 @@
+package me.srikavin.fbla.game.util
+
+import com.badlogic.gdx.assets.AssetManager
+import com.badlogic.gdx.graphics.g2d.BitmapFont
+import com.badlogic.gdx.graphics.g2d.freetype.FreetypeFontLoader
+
+object GameFonts {
+    /**
+     * Size 22
+     */
+    lateinit var MENU: BitmapFont
+
+    /**
+     * Size 36
+     */
+    lateinit var DEFAULT: BitmapFont
+
+    /**
+     * Size 48
+     */
+    lateinit var LARGE: BitmapFont
+
+    /**
+     * Size 72
+     */
+    lateinit var HUGE: BitmapFont
+
+    fun loadFonts(assetManager: AssetManager, path: String): Unit {
+        assetManager.load("$path-menu.ttf", BitmapFont::class.java, parameter(path, 22))
+        assetManager.load("$path-default.ttf", BitmapFont::class.java, parameter(path, 36))
+        assetManager.load("$path-large.ttf", BitmapFont::class.java, parameter(path, 48))
+        assetManager.load("$path-huge.ttf", BitmapFont::class.java, parameter(path, 72))
+
+
+        MENU = assetManager.finishLoadingAsset("$path-menu.ttf")
+        DEFAULT = assetManager.finishLoadingAsset("$path-default.ttf")
+        LARGE = assetManager.finishLoadingAsset("$path-large.ttf")
+        HUGE = assetManager.finishLoadingAsset("$path-huge.ttf")
+
+        MENU.data.markupEnabled = true
+        DEFAULT.data.markupEnabled = true
+        LARGE.data.markupEnabled = true
+        HUGE.data.markupEnabled = true
+    }
+
+    private fun parameter(path: String, s: Int): FreetypeFontLoader.FreeTypeFontLoaderParameter {
+        return FreetypeFontLoader.FreeTypeFontLoaderParameter().apply {
+            fontParameters.apply {
+                size = s
+                fontFileName = path
+            }
+            fontFileName = path
+        }
+    }
+}
\ No newline at end of file
diff --git a/core/src/me/srikavin/fbla/game/Util.kt b/core/src/me/srikavin/fbla/game/util/Util.kt
similarity index 98%
rename from core/src/me/srikavin/fbla/game/Util.kt
rename to core/src/me/srikavin/fbla/game/util/Util.kt
index 8097836..f0804fb 100644
--- a/core/src/me/srikavin/fbla/game/Util.kt
+++ b/core/src/me/srikavin/fbla/game/util/Util.kt
@@ -1,4 +1,4 @@
-package me.srikavin.fbla.game
+package me.srikavin.fbla.game.util
 
 import com.badlogic.gdx.Gdx
 import com.badlogic.gdx.InputMultiplexer
diff --git a/desktop/src/me/srikavin/fbla/game/desktop/DesktopLauncher.java b/desktop/src/me/srikavin/fbla/game/desktop/DesktopLauncher.java
index dceb0a8..4c62959 100644
--- a/desktop/src/me/srikavin/fbla/game/desktop/DesktopLauncher.java
+++ b/desktop/src/me/srikavin/fbla/game/desktop/DesktopLauncher.java
@@ -17,7 +17,7 @@ public static void main(String[] arg) {
         config.addIcon("assets/icon/QS-16.png", Files.FileType.Internal);
 //		config.foregroundFPS = 1000;
 //		config.vSyncEnabled = false;
-//		config.fullscreen = true;
+        config.fullscreen = true;
         new LwjglApplication(new FBLAGame(), config);
     }
 }