From c7958c23bce4a8f1f235273c01a592ab30816c2b Mon Sep 17 00:00:00 2001
From: Jon Thysell <thysell@gmail.com>
Date: Mon, 8 Nov 2021 14:47:31 -0800
Subject: [PATCH] Imported more image assets, updated scenes

---
 img/next.gif          | Bin 0 -> 86 bytes
 img/retry.gif         | Bin 0 -> 82 bytes
 img/sound0.gif        | Bin 0 -> 62 bytes
 img/sound1.gif        | Bin 0 -> 64 bytes
 img/star0.gif         | Bin 0 -> 71 bytes
 img/star1.gif         | Bin 0 -> 74 bytes
 img/star2.gif         | Bin 0 -> 68 bytes
 src/Bitmaps.c         | 113 +++++++++++++++++++++++++++++++++++-------
 src/Bitmaps.h         |  13 ++++-
 src/GameEndScene.c    |  58 ++++++++++++++++------
 src/GameWindow.c      |  31 +++++-------
 src/GameWindow.h      |   1 -
 src/LevelEndScene.c   |  89 +++++++++++++++++++++++++--------
 src/MacCommon.c       |  96 +++++++++++++++++++++--------------
 src/MacCommon.h       |   3 ++
 src/MacLO.pi.bin      | Bin 15872 -> 15872 bytes
 src/MacLO.pi.rsrc.bin | Bin 10752 -> 12032 bytes
 src/PlayScene.c       |  81 +++++++++++++++++++++++-------
 src/Scenes.h          |  12 ++++-
 src/TitleScene.c      |   7 +--
 20 files changed, 365 insertions(+), 139 deletions(-)
 create mode 100644 img/next.gif
 create mode 100644 img/retry.gif
 create mode 100644 img/sound0.gif
 create mode 100644 img/sound1.gif
 create mode 100644 img/star0.gif
 create mode 100644 img/star1.gif
 create mode 100644 img/star2.gif

diff --git a/img/next.gif b/img/next.gif
new file mode 100644
index 0000000000000000000000000000000000000000..bb8ff1485dc73212c15d7c0bf1a28a70e505af85
GIT binary patch
literal 86
zcmZ?wbhEHb6ky<ESjfl#1pi?`@h1x-7XuT64oDOv&%mV4)7K_>syZrK=#-@P?#Slo
e#x4)PC+dsltZI}#7BnyGpk&J<zSeqH25SJ@B_1UJ

literal 0
HcmV?d00001

diff --git a/img/retry.gif b/img/retry.gif
new file mode 100644
index 0000000000000000000000000000000000000000..1b2694a1646c0c39b30d7a272d471e5a162b7651
GIT binary patch
literal 82
zcmZ?wbhEHb6ky<ESjfl#1pi?`@h1x-7XuT64oDOv&%mVIk}r5-?b#_Yc~K?j4@U=Y
bD2Y;WOqp4e`C_h~#oTExj;2+KGgt!vmSY}n

literal 0
HcmV?d00001

diff --git a/img/sound0.gif b/img/sound0.gif
new file mode 100644
index 0000000000000000000000000000000000000000..c90735c53c418effe459c97f25188fa1b4df6bee
GIT binary patch
literal 62
zcmZ?wbhEHbWM|-ESjfl#1pi?`@h1x-7XuT64oDOv&%ngrBA-6-1pneWTUIS+IK7L3
G!5RR15fnxM

literal 0
HcmV?d00001

diff --git a/img/sound1.gif b/img/sound1.gif
new file mode 100644
index 0000000000000000000000000000000000000000..68c439924f3d87616119b2aa69a5d4498f0550c9
GIT binary patch
literal 64
zcmZ?wbhEHbWM|-ESjfl#1pi?`@h1x-7XuT64oDOv&%h+u(l55-;sb>mZ@cczcYa-A
I5n-?f0IgIN!~g&Q

literal 0
HcmV?d00001

diff --git a/img/star0.gif b/img/star0.gif
new file mode 100644
index 0000000000000000000000000000000000000000..f4d04d0521e3d0602c9e0a2500392bfe9c42b70f
GIT binary patch
literal 71
zcmZ?wbh9u|6krfwXkcUjg8%>j>wsvG2m_N^3%}rr9XD@PUko@grL5|1R_y|IxhXGF
WrgkKyRUR#z<s*DtD>amX!5RSd)EHC%

literal 0
HcmV?d00001

diff --git a/img/star1.gif b/img/star1.gif
new file mode 100644
index 0000000000000000000000000000000000000000..8f5413145eb42597cdae93cfa88de91ab9056563
GIT binary patch
literal 74
zcmZ?wbh9u|6krfwXkcUjg8%>j>wsvG2m_O53%}rr6*q51f7I~0yEje$yypXD)r6as
ZKGWLfzHqv=?cA2s<QqKUb^#0w)&NGa8gBpq

literal 0
HcmV?d00001

diff --git a/img/star2.gif b/img/star2.gif
new file mode 100644
index 0000000000000000000000000000000000000000..511059085a81e39a4b6ac72b1e54a8c13eb0c0bb
GIT binary patch
literal 68
zcmZ?wbh9u|6krfwXkcUjg8%>j>wsvG2m_OH3%}rr6}N6hfAl%At}gTU{!#_Cx|x+#
Tnpr&|)(7XfUdk60Wv~VSrh*pe

literal 0
HcmV?d00001

diff --git a/src/Bitmaps.c b/src/Bitmaps.c
index c1f8256..68b099e 100644
--- a/src/Bitmaps.c
+++ b/src/Bitmaps.c
@@ -5,11 +5,14 @@
 
 #define TitlePictResID       BaseResID
 #define NumCharPictBaseResID (TitlePictResID + 1)
-#define ACharPictResID       (NumCharPictBaseResID + NumChars)
+#define ACharPictResID       (NumCharPictBaseResID + NumCharPictCount)
 #define BCharPictResID       (ACharPictResID + 1)
 #define SlashCharPictResID   (BCharPictResID + 1)
+#define StarPictBaseResID    (SlashCharPictResID + 1)
+#define NextButtonPictResID  (StarPictBaseResID + StarPictCount)
+#define RetryButtonPictResID (NextButtonPictResID + 1)
 
-void Bitmaps_DrawScaledPic(const PicHandle pic, const uint8_t scale);
+#define StarRectPadding 2
 
 void Bitmaps_Init(Bitmaps *pBitmaps)
 {
@@ -23,7 +26,7 @@ void Bitmaps_Init(Bitmaps *pBitmaps)
     }
     
     // Load number chars
-    for (i = 0; i < NumChars; i++)
+    for (i = 0; i < NumCharPictCount; i++)
     {
         pBitmaps->NumCharPicts[i] = GetPicture(NumCharPictBaseResID + i);
         if (pBitmaps->NumCharPicts[i] == nil)
@@ -52,20 +55,37 @@ void Bitmaps_Init(Bitmaps *pBitmaps)
     {
         ShowError("\pSlash char PICT resource missing!", true);
     }
-}
-
-void Bitmaps_DrawScaledPic(const PicHandle pic, const uint8_t scale)
-{
-    Point penPosition;
-    Rect destRect;
     
-    GetPen(&penPosition);
-    GetScaledPicFrame(pic, scale, &destRect);
+    // Load half-stars
+    for (i = 0; i < StarPictCount; i++)
+    {
+        pBitmaps->StarPicts[i] = GetPicture(StarPictBaseResID + i);
+        if (pBitmaps->StarPicts[i] == nil)
+        {
+            ShowError("\pStar PICT resource missing!", true);
+        }
+    }
     
-    OffsetRect(&destRect, penPosition.h, penPosition.v);
+    // Load next button
+    pBitmaps->SlashCharPict = GetPicture(SlashCharPictResID);
+    if (pBitmaps->SlashCharPict == nil)
+    {
+        ShowError("\pSlash char PICT resource missing!", true);
+    }
     
-    DrawPicture(pic, &destRect);
-    MoveTo(destRect.right, destRect.top);
+    // Load next button
+    pBitmaps->NextButtonPict = GetPicture(NextButtonPictResID);
+    if (pBitmaps->NextButtonPict == nil)
+    {
+        ShowError("\pNext button PICT resource missing!", true);
+    }
+    
+    // Load retry button
+    pBitmaps->RetryButtonPict = GetPicture(RetryButtonPictResID);
+    if (pBitmaps->RetryButtonPict == nil)
+    {
+        ShowError("\pRetry button PICT resource missing!", true);
+    }
 }
 
 void Bitmaps_GetNumberRect(const Bitmaps *pBitmaps, const uint32_t number, const uint8_t scale, Rect *pDestRect)
@@ -110,7 +130,7 @@ void Bitmaps_DrawNumber(const Bitmaps *pBitmaps, const uint32_t number, const ui
     
     if (number == 0)
     {
-        Bitmaps_DrawScaledPic(pBitmaps->NumCharPicts[0], scale);
+        DrawScaledPic(pBitmaps->NumCharPicts[0], scale);
         return;
     }
     
@@ -124,7 +144,7 @@ void Bitmaps_DrawNumber(const Bitmaps *pBitmaps, const uint32_t number, const ui
     
         if (started || (digit > 0 && digit < 10))
         {
-            Bitmaps_DrawScaledPic(pBitmaps->NumCharPicts[digit], scale);
+            DrawScaledPic(pBitmaps->NumCharPicts[digit], scale);
             started = true;
         }
     }
@@ -132,15 +152,70 @@ void Bitmaps_DrawNumber(const Bitmaps *pBitmaps, const uint32_t number, const ui
 
 void Bitmaps_DrawAChar(const Bitmaps *pBitmaps, const uint8_t scale)
 {
-    Bitmaps_DrawScaledPic(pBitmaps->ACharPict, scale);
+    DrawScaledPic(pBitmaps->ACharPict, scale);
 }
 
 void Bitmaps_DrawBChar(const Bitmaps *pBitmaps, const uint8_t scale)
 {
-    Bitmaps_DrawScaledPic(pBitmaps->BCharPict, scale);
+    DrawScaledPic(pBitmaps->BCharPict, scale);
 }
 
 void Bitmaps_DrawSlashChar(const Bitmaps *pBitmaps, const uint8_t scale)
 {
-    Bitmaps_DrawScaledPic(pBitmaps->SlashCharPict, scale);
+    DrawScaledPic(pBitmaps->SlashCharPict, scale);
+}
+
+void Bitmaps_GetHalfStarsRect(const Bitmaps *pBitmaps, const uint8_t halfStars, const uint8_t maxStars, const uint8_t scale, Rect *pDestRect)
+{
+    uint8_t stars;
+    Rect starRect, paddingRect;
+    
+    pDestRect->top = 0;
+    pDestRect->left = 0;
+    pDestRect->bottom = 0;
+    pDestRect->right = 0;
+    
+    if (maxStars == 0)
+    {
+        return;
+    }
+    
+    GetScaledPicFrame(pBitmaps->StarPicts[0], scale, &starRect);
+    paddingRect = starRect;
+    paddingRect.right = paddingRect.left + (StarRectPadding * scale);
+    
+    ConcatenateRect(pDestRect, &starRect, pDestRect);
+    
+    for (stars = 1; stars < maxStars; stars++)
+    {
+        ConcatenateRect(pDestRect, &paddingRect, pDestRect);
+        ConcatenateRect(pDestRect, &starRect, pDestRect);
+    }
+}
+
+void Bitmaps_DrawHalfStars(const Bitmaps *pBitmaps, const uint8_t halfStars, const uint8_t maxStars, const uint8_t scale)
+{
+    Point penPosition;
+    uint8_t i, progress, drawn;
+    
+    progress = halfStars;
+    drawn = 0;
+    
+    for (i = StarPictCount - 1; i > 0; i--)
+    {
+        while (drawn < maxStars && progress >= i)
+        {
+            DrawScaledPic(pBitmaps->StarPicts[i], scale);
+            GetPen(&penPosition);
+            MoveTo(penPosition.h + (StarRectPadding * scale), penPosition.v);
+            progress -= i;
+            drawn++;
+        }
+    }
+    
+    for (; drawn < maxStars; drawn++)
+    {
+        DrawScaledPic(pBitmaps->StarPicts[0], scale);
+        MoveTo(penPosition.h + (StarRectPadding * scale), penPosition.v);
+    }
 }
diff --git a/src/Bitmaps.h b/src/Bitmaps.h
index bb8e0e5..408a27f 100644
--- a/src/Bitmaps.h
+++ b/src/Bitmaps.h
@@ -6,15 +6,21 @@
 
 #include "MacCommon.h"
 
-#define NumChars 10
+#define NumCharPictCount 10
+#define StarPictCount    3
 
 typedef struct sBitmaps
 {
     PicHandle TitlePict;
-    PicHandle NumCharPicts[NumChars];
+    PicHandle NumCharPicts[NumCharPictCount];
     PicHandle ACharPict;
     PicHandle BCharPict;
     PicHandle SlashCharPict;
+    PicHandle StarPicts[StarPictCount];
+    PicHandle NextButtonPict;
+    PicHandle RetryButtonPict;
+    PicHandle SoundOffPict;
+    PicHandle SoundOnPict;
 } Bitmaps;
 
 void Bitmaps_Init(Bitmaps *pBitmaps);
@@ -26,4 +32,7 @@ void Bitmaps_DrawAChar(const Bitmaps *pBitmaps, const uint8_t scale);
 void Bitmaps_DrawBChar(const Bitmaps *pBitmaps, const uint8_t scale);
 void Bitmaps_DrawSlashChar(const Bitmaps *pBitmaps, const uint8_t scale);
 
+void Bitmaps_GetHalfStarsRect(const Bitmaps *pBitmaps, const uint8_t halfStars, const uint8_t maxStars, const uint8_t scale, Rect *pDestRect);
+void Bitmaps_DrawHalfStars(const Bitmaps *pBitmaps, const uint8_t halfStars, const uint8_t maxStars, const uint8_t scale);
+
 #endif
diff --git a/src/GameEndScene.c b/src/GameEndScene.c
index d596cab..02ca7d6 100644
--- a/src/GameEndScene.c
+++ b/src/GameEndScene.c
@@ -3,32 +3,60 @@
 
 #include "GameEndScene.h"
 
+#define SetTextScale   6
+#define ScoreTextScale 3
+
 void GameEndScene_Init(GameWindow *pGameWindow)
 {
+    Rect r;
+    
+    const Rect *pContentRect = &(pGameWindow->Window->portRect);
+    
+    // Setup set
+    GetScaledPicFrame(pGameWindow->Bitmaps.StarPicts[StarPictCount - 1], SetTextScale, &r);
+    GetScaledPicFrame(pGameWindow->Engine.SetB ? pGameWindow->Bitmaps.BCharPict : pGameWindow->Bitmaps.ACharPict, SetTextScale, &(pGameWindow->GameEndScene.SetRect));
+    ConcatenateRect(&r, &(pGameWindow->GameEndScene.SetRect), &(pGameWindow->GameEndScene.SetRect));
+    ConcatenateRect(&(pGameWindow->GameEndScene.SetRect), &r, &(pGameWindow->GameEndScene.SetRect));
+    
+    GetBoxRect(pContentRect, Top, &r);
+    GetBoxRect(&r, Bottom, &r);
+    CenterRect(&r, &(pGameWindow->GameEndScene.SetRect));
+    
+    // Setup score
+    Bitmaps_GetNumberRect(&(pGameWindow->Bitmaps), pGameWindow->Engine.Score, ScoreTextScale, &(pGameWindow->GameEndScene.ScoreRect));
+    GetScaledPicFrame(pGameWindow->Bitmaps.SlashCharPict, ScoreTextScale, &r);
+    ConcatenateRect(&(pGameWindow->GameEndScene.ScoreRect), &r, &(pGameWindow->GameEndScene.ScoreRect));
+    Bitmaps_GetNumberRect(&(pGameWindow->Bitmaps), PerfectScore, ScoreTextScale, &r);
+    ConcatenateRect(&(pGameWindow->GameEndScene.ScoreRect), &r, &(pGameWindow->GameEndScene.ScoreRect));
+    
+    GetBoxRect(pContentRect, Bottom, &r);
+    GetBoxRect(&r, Top, &r);
+    CenterRect(&r, &(pGameWindow->GameEndScene.ScoreRect));
 }
 
 void GameEndScene_Draw(const GameWindow *pGameWindow, bool fullRefresh)
 {
-    Str255 scoreStr;
-    
-    // TODO: Proper level end
-    if (fullRefresh)
+    // Draw set
+    MoveTo(pGameWindow->GameEndScene.SetRect.left, pGameWindow->GameEndScene.SetRect.top);
+    DrawScaledPic(pGameWindow->Bitmaps.StarPicts[StarPictCount - 1], SetTextScale);
+    if (pGameWindow->Engine.SetB)
     {
+        Bitmaps_DrawBChar(&(pGameWindow->Bitmaps), SetTextScale);
     }
+    else
+    {
+        Bitmaps_DrawAChar(&(pGameWindow->Bitmaps), SetTextScale);
+    }
+    DrawScaledPic(pGameWindow->Bitmaps.StarPicts[StarPictCount - 1], SetTextScale);
     
-    MoveTo(100, 100);
-    DrawString("\pGame complete! Click to continue.");
-    
-    MoveTo(100, 125);
-    DrawString("\pScore: ");
-    NumToString((int32_t)(pGameWindow->Engine.Score), &scoreStr);
-    DrawString(scoreStr);
-    DrawString("\p/300");
+    // Draw score
+    MoveTo(pGameWindow->GameEndScene.ScoreRect.left, pGameWindow->GameEndScene.ScoreRect.top);
+    Bitmaps_DrawNumber(&(pGameWindow->Bitmaps), pGameWindow->Engine.Score, ScoreTextScale);
+    Bitmaps_DrawSlashChar(&(pGameWindow->Bitmaps), ScoreTextScale);
+    Bitmaps_DrawNumber(&(pGameWindow->Bitmaps), PerfectScore, ScoreTextScale);
 }
 
 void GameEndScene_Click(GameWindow *pGameWindow, const Point *pPosition)
 {
-    // TODO: Proper click handling
-    
-    GameWindow_SetScene(pGameWindow, Title);
+    // Do nothing
 }
diff --git a/src/GameWindow.c b/src/GameWindow.c
index 98d7380..235306f 100644
--- a/src/GameWindow.c
+++ b/src/GameWindow.c
@@ -77,25 +77,20 @@ void GameWindow_Click(GameWindow *pGameWindow, const Point *pPosition)
 
 void GameWindow_SetScene(GameWindow *pGameWindow, const SceneId sceneId)
 {
-    GameWindow_Draw(pGameWindow, false);
-    if (!(pGameWindow->SceneIsInitialized[sceneId]))
+    switch (sceneId)
     {
-        switch (sceneId)
-        {
-            case Title:
-                TitleScene_Init(pGameWindow);
-                break;
-            case Play:
-                PlayScene_Init(pGameWindow);
-                break;
-            case LevelEnd:
-                LevelEndScene_Init(pGameWindow);
-                break;
-            case GameEnd:
-                GameEndScene_Init(pGameWindow);
-                break;
-        }
-        pGameWindow->SceneIsInitialized[sceneId] = true;
+        case Title:
+            TitleScene_Init(pGameWindow);
+            break;
+        case Play:
+            PlayScene_Init(pGameWindow);
+            break;
+        case LevelEnd:
+            LevelEndScene_Init(pGameWindow);
+            break;
+        case GameEnd:
+            GameEndScene_Init(pGameWindow);
+            break;
     }
     pGameWindow->CurrentSceneId = sceneId;
     GameWindow_Draw(pGameWindow, true);
diff --git a/src/GameWindow.h b/src/GameWindow.h
index 7e9ef54..44c0286 100644
--- a/src/GameWindow.h
+++ b/src/GameWindow.h
@@ -17,7 +17,6 @@ typedef struct sGameWindow
     GameEngine    Engine;
     Bitmaps       Bitmaps;
     SceneId       CurrentSceneId;
-    bool          SceneIsInitialized[NumScenes];
     TitleScene    TitleScene;
     PlayScene     PlayScene;
     LevelEndScene LevelEndScene;
diff --git a/src/LevelEndScene.c b/src/LevelEndScene.c
index 16f90c7..c788b06 100644
--- a/src/LevelEndScene.c
+++ b/src/LevelEndScene.c
@@ -3,47 +3,94 @@
 
 #include "LevelEndScene.h"
 
+#define LevelTextScale 4
+#define HalfStarScale  3
+#define ScoreTextScale 1
+
 void LevelEndScene_Init(GameWindow *pGameWindow)
 {
+    Rect r;
+    
+    const Rect *pContentRect = &(pGameWindow->Window->portRect);
+    
+    // Setup level
+    GetScaledPicFrame(pGameWindow->Engine.SetB ? pGameWindow->Bitmaps.BCharPict : pGameWindow->Bitmaps.ACharPict, LevelTextScale, &(pGameWindow->LevelEndScene.LevelRect));
+    Bitmaps_GetNumberRect(&(pGameWindow->Bitmaps), 1 + pGameWindow->Engine.Level, LevelTextScale, &r);
+    ConcatenateRect(&(pGameWindow->LevelEndScene.LevelRect), &r, &(pGameWindow->LevelEndScene.LevelRect));
+
+    GetBoxRect(pContentRect, Top, &r);
+    CenterRect(&r, &(pGameWindow->LevelEndScene.LevelRect));
+
+    // Setup half-stars
+    Bitmaps_GetHalfStarsRect(&(pGameWindow->Bitmaps), GameEngine_GetHalfStars(&(pGameWindow->Engine)), MaxStars, HalfStarScale, &(pGameWindow->LevelEndScene.HalfStarsRect));
+    
+    GetBoxRect(pContentRect, Center, &r);
+    CenterRect(&r, &(pGameWindow->LevelEndScene.HalfStarsRect));
+    
+    // Setup score
+    Bitmaps_GetNumberRect(&(pGameWindow->Bitmaps), pGameWindow->Engine.Score, ScoreTextScale, &(pGameWindow->LevelEndScene.ScoreRect));
+    GetScaledPicFrame(pGameWindow->Bitmaps.SlashCharPict, ScoreTextScale, &r);
+    ConcatenateRect(&(pGameWindow->LevelEndScene.ScoreRect), &r, &(pGameWindow->LevelEndScene.ScoreRect));
+    Bitmaps_GetNumberRect(&(pGameWindow->Bitmaps), PerfectScore, ScoreTextScale, &r);
+    ConcatenateRect(&(pGameWindow->LevelEndScene.ScoreRect), &r, &(pGameWindow->LevelEndScene.ScoreRect));
+    
+    GetBoxRect(pContentRect, Bottom, &r);
+    CenterRect(&r, &(pGameWindow->LevelEndScene.ScoreRect));
+    
+    // Setup retry button
+    GetPictureRect(pGameWindow->Bitmaps.RetryButtonPict, &(pGameWindow->LevelEndScene.RetryButtonRect));
+    
+    GetBoxRect(pContentRect, BottomLeft, &r);
+    CenterRect(&r, &(pGameWindow->LevelEndScene.RetryButtonRect));
+    
+    // Setup next button
+    GetPictureRect(pGameWindow->Bitmaps.NextButtonPict, &(pGameWindow->LevelEndScene.NextButtonRect));
+    
+    GetBoxRect(pContentRect, BottomRight, &r);
+    CenterRect(&r, &(pGameWindow->LevelEndScene.NextButtonRect));
 }
 
 void LevelEndScene_Draw(const GameWindow *pGameWindow, bool fullRefresh)
 {
-    Str255 halfStarsStr;
-    
-    // TODO: Proper level end
-    if (fullRefresh)
+    // Draw level
+    MoveTo(pGameWindow->LevelEndScene.LevelRect.left, pGameWindow->LevelEndScene.LevelRect.top);
+    if (pGameWindow->Engine.SetB)
     {
+        Bitmaps_DrawBChar(&(pGameWindow->Bitmaps), LevelTextScale);
     }
+    else
+    {
+        Bitmaps_DrawAChar(&(pGameWindow->Bitmaps), LevelTextScale);
+    }
+    Bitmaps_DrawNumber(&(pGameWindow->Bitmaps), 1 + pGameWindow->Engine.Level, LevelTextScale);
     
-    MoveTo(100, 100);
-    DrawString("\pLevel complete! Click to continue.");
+    // Draw half-stars
+    MoveTo(pGameWindow->LevelEndScene.HalfStarsRect.left, pGameWindow->LevelEndScene.HalfStarsRect.top);
+    Bitmaps_DrawHalfStars(&(pGameWindow->Bitmaps), GameEngine_GetHalfStars(&(pGameWindow->Engine)), MaxStars, HalfStarScale);
     
-    MoveTo(100, 125);
-    DrawString("\pReceived ");
-    NumToString((int32_t)GameEngine_GetHalfStars(&(pGameWindow->Engine)), &halfStarsStr);
-    DrawString(halfStarsStr);
-    DrawString("\p/6 half-stars.");
+    // Draw score
+    MoveTo(pGameWindow->LevelEndScene.ScoreRect.left, pGameWindow->LevelEndScene.ScoreRect.top);
+    Bitmaps_DrawNumber(&(pGameWindow->Bitmaps), pGameWindow->Engine.Score, ScoreTextScale);
+    Bitmaps_DrawSlashChar(&(pGameWindow->Bitmaps), ScoreTextScale);
+    Bitmaps_DrawNumber(&(pGameWindow->Bitmaps), PerfectScore, ScoreTextScale);
     
-    MoveTo(100, 200);
-    DrawString("\pRetry level.");
+    // Draw retry button
+    DrawPicture(pGameWindow->Bitmaps.RetryButtonPict, &(pGameWindow->LevelEndScene.RetryButtonRect));
     
-    MoveTo(350, 200);
-    DrawString("\pNext level.");
+    // Draw next button
+    DrawPicture(pGameWindow->Bitmaps.NextButtonPict, &(pGameWindow->LevelEndScene.NextButtonRect));
 }
 
 void LevelEndScene_Click(GameWindow *pGameWindow, const Point *pPosition)
 {
-    // TODO: Proper click handling
-    
-    if (pPosition->h < ((pGameWindow->Window->portRect.right - pGameWindow->Window->portRect.left) / 2))
+    if (PtInRect(*pPosition, &(pGameWindow->LevelEndScene.RetryButtonRect)))
     {
         GameEngine_ResetLevel(&(pGameWindow->Engine));
+        GameWindow_SetScene(pGameWindow, Play);
     }
-    else
+    else if (PtInRect(*pPosition, &(pGameWindow->LevelEndScene.NextButtonRect)))
     {
         GameEngine_NextLevel(&(pGameWindow->Engine));
+        GameWindow_SetScene(pGameWindow, GameEngine_IsGameOver(&(pGameWindow->Engine)) ? GameEnd : Play);
     }
-    
-    GameWindow_SetScene(pGameWindow, GameEngine_IsGameOver(&(pGameWindow->Engine)) ? GameEnd : Play);
 }
diff --git a/src/MacCommon.c b/src/MacCommon.c
index c0f7c95..bb1e189 100644
--- a/src/MacCommon.c
+++ b/src/MacCommon.c
@@ -47,6 +47,7 @@ void ConcatenateRect(const Rect *pLeftRect, const Rect *pRightRect, Rect *pDestR
 void GetBoxRect(const Rect *pOuterRect, const BoxAlignment boxAlignment, Rect *pBoxRect)
 {
     int32_t boxWidth, boxHeight;
+    Rect resultRect;
     
     boxWidth = (pOuterRect->right - pOuterRect->left) / 3;
     boxHeight = (pOuterRect->bottom - pOuterRect->top) / 3;
@@ -54,66 +55,87 @@ void GetBoxRect(const Rect *pOuterRect, const BoxAlignment boxAlignment, Rect *p
     switch (boxAlignment)
     {
         case Top:
-            pBoxRect->top = pOuterRect->top;
-            pBoxRect->left = pOuterRect->left + boxWidth;
-            pBoxRect->bottom = pOuterRect->top + boxHeight;
-            pBoxRect->right = pOuterRect->right - boxWidth;
+            resultRect.top = pOuterRect->top;
+            resultRect.left = pOuterRect->left + boxWidth;
+            resultRect.bottom = pOuterRect->top + boxHeight;
+            resultRect.right = pOuterRect->right - boxWidth;
             break;
         case TopLeft:
-            pBoxRect->top = pOuterRect->top;
-            pBoxRect->left = pOuterRect->left;
-            pBoxRect->bottom = pOuterRect->top + boxHeight;
-            pBoxRect->right = pOuterRect->left + boxWidth;
+            resultRect.top = pOuterRect->top;
+            resultRect.left = pOuterRect->left;
+            resultRect.bottom = pOuterRect->top + boxHeight;
+            resultRect.right = pOuterRect->left + boxWidth;
             break;
         case Left:
-            pBoxRect->top = pOuterRect->top + boxHeight;
-            pBoxRect->left = pOuterRect->left;
-            pBoxRect->bottom = pOuterRect->bottom - boxHeight;
-            pBoxRect->right = pOuterRect->left + boxWidth;
+            resultRect.top = pOuterRect->top + boxHeight;
+            resultRect.left = pOuterRect->left;
+            resultRect.bottom = pOuterRect->bottom - boxHeight;
+            resultRect.right = pOuterRect->left + boxWidth;
             break;
         case BottomLeft:
-            pBoxRect->top = pOuterRect->bottom - boxHeight;
-            pBoxRect->left = pOuterRect->left;
-            pBoxRect->bottom = pOuterRect->bottom;
-            pBoxRect->right = pOuterRect->left + boxWidth;
+            resultRect.top = pOuterRect->bottom - boxHeight;
+            resultRect.left = pOuterRect->left;
+            resultRect.bottom = pOuterRect->bottom;
+            resultRect.right = pOuterRect->left + boxWidth;
             break;
         case Bottom:
-            pBoxRect->top = pOuterRect->bottom - boxHeight;
-            pBoxRect->left = pOuterRect->left + boxWidth;
-            pBoxRect->bottom = pOuterRect->bottom;
-            pBoxRect->right = pOuterRect->right - boxWidth;
+            resultRect.top = pOuterRect->bottom - boxHeight;
+            resultRect.left = pOuterRect->left + boxWidth;
+            resultRect.bottom = pOuterRect->bottom;
+            resultRect.right = pOuterRect->right - boxWidth;
             break;
         case BottomRight:
-            pBoxRect->top = pOuterRect->bottom - boxHeight;
-            pBoxRect->left = pOuterRect->right - boxWidth;
-            pBoxRect->bottom = pOuterRect->bottom;
-            pBoxRect->right = pOuterRect->right;
+            resultRect.top = pOuterRect->bottom - boxHeight;
+            resultRect.left = pOuterRect->right - boxWidth;
+            resultRect.bottom = pOuterRect->bottom;
+            resultRect.right = pOuterRect->right;
             break;
         case Right:
-            pBoxRect->top = pOuterRect->top + boxHeight;
-            pBoxRect->left = pOuterRect->right - boxWidth;
-            pBoxRect->bottom = pOuterRect->bottom - boxHeight;
-            pBoxRect->right = pOuterRect->right;
+            resultRect.top = pOuterRect->top + boxHeight;
+            resultRect.left = pOuterRect->right - boxWidth;
+            resultRect.bottom = pOuterRect->bottom - boxHeight;
+            resultRect.right = pOuterRect->right;
             break;
         case TopRight:
-            pBoxRect->top = pOuterRect->top;
-            pBoxRect->left = pOuterRect->right - boxWidth;
-            pBoxRect->bottom = pOuterRect->top + boxHeight;
-            pBoxRect->right = pOuterRect->right;
+            resultRect.top = pOuterRect->top;
+            resultRect.left = pOuterRect->right - boxWidth;
+            resultRect.bottom = pOuterRect->top + boxHeight;
+            resultRect.right = pOuterRect->right;
             break;
         case Center:
-            pBoxRect->top = pOuterRect->top + boxHeight;
-            pBoxRect->left = pOuterRect->left + boxWidth;
-            pBoxRect->bottom = pOuterRect->bottom - boxHeight;
-            pBoxRect->right = pOuterRect->right - boxWidth;
+            resultRect.top = pOuterRect->top + boxHeight;
+            resultRect.left = pOuterRect->left + boxWidth;
+            resultRect.bottom = pOuterRect->bottom - boxHeight;
+            resultRect.right = pOuterRect->right - boxWidth;
             break;
     }
+    
+    *pBoxRect = resultRect;
+}
+
+void GetPictureRect(const PicHandle picHandle, Rect *pDestRect)
+{
+    *pDestRect = (**(picHandle)).picFrame;
 }
 
 void GetScaledPicFrame(const PicHandle picHandle, const uint8_t scale, Rect *pDestRect)
 {
-    *pDestRect = (**(picHandle)).picFrame;
+    GetPictureRect(picHandle, pDestRect);
     
     pDestRect->right = pDestRect->left + ((pDestRect->right - pDestRect->left) * max(scale, 1));
     pDestRect->bottom = pDestRect->top + ((pDestRect->bottom - pDestRect->top) * max(scale, 1));
 }
+
+void DrawScaledPic(const PicHandle pic, const uint8_t scale)
+{
+    Point penPosition;
+    Rect destRect;
+    
+    GetPen(&penPosition);
+    GetScaledPicFrame(pic, scale, &destRect);
+    
+    OffsetRect(&destRect, penPosition.h, penPosition.v);
+    
+    DrawPicture(pic, &destRect);
+    MoveTo(destRect.right, destRect.top);
+}
diff --git a/src/MacCommon.h b/src/MacCommon.h
index 58c5a4c..a87be46 100644
--- a/src/MacCommon.h
+++ b/src/MacCommon.h
@@ -39,6 +39,9 @@ void ConcatenateRect(const Rect *pLeftRect, const Rect *pRightRect, Rect *pDestR
 
 void GetBoxRect(const Rect *pOuterRect, const BoxAlignment boxAlignment, Rect *pBoxRect);
 
+void GetPictureRect(const PicHandle picHandle, Rect *pDestRect);
+
 void GetScaledPicFrame(const PicHandle picHandle, const uint8_t scale, Rect *pDestRect);
+void DrawScaledPic(const PicHandle pic, const uint8_t scale);
 
 #endif
diff --git a/src/MacLO.pi.bin b/src/MacLO.pi.bin
index bdb822f2d03eca0181ad3f06a6ddf1778a3d04b4..829953be2b62052cbea772c0c5ca8e8c40fd41e4 100644
GIT binary patch
delta 2991
zcmeHJT}&KR6rS0;l(w4z3WWj-IEADx8(4mtGy#F6i<Xdp)`h4st-9`B+%dz<c6OH1
z6gt~je;!PPTvMSXwWg%e#*DgaQtiBuw(+N?rlx7=1Do{07&Sf+t&I;Rc;;tica|VE
z>61=!cfL7u?m6fC?zwv>F_D;<>aV73S9c)&>f&Hpy}f&S+YaaP<KLW}KK3NNJbj}9
zslP9Ma_?PdVe-s8N}j%vnk#snrk&(O;lqmd);!XPKCU9|WDg7(#$BY%96;LauSh#x
zinKEeNPCY*+PQm3J3o%J4;)Clun$HAX&2}9IwF`I>>p+axDXa%*vBvpoDkyUVa(PK
zb25*Iz>a;9`YgMjlShL}G^SgbhA<xC1k4)F!+2aC3I%!0wlmC_$c0U_5##xOfs;Lb
z!BPA)CxpertT(#)(8wHRShxZ>B(u^Z1~z^|q7ai!vp3o+3NjXC!%698cX_fRH20Wc
zn|q?7WVkeDg=uMFhp-%vvJxbS8Ik+2yq^onaS7}3azhymfuKQ3_iC~y8&+1uF}(C3
zjaJHDC=yF%*sPlKgRB!HQ=?xTUn7uTRAgBk9l#@cX_A!}C>iR9q2zrMD7`kTy}gm3
zWU|U#we<=F`SxaWRI*6!lI~~bKQYsZ1-O?Y>oZew);_af{(ni$pG|E;%oKfFfGB^@
zoXqd|N2TClkJ-Vit)A2OP3()J$g?AHo)6#=3CALtod6xHPd7J^A({SYbu6r_C$o{p
z5>$r$TJ5@(D0Ob~gR9r2Uj8j@4f4W{TE>x9FLh)Fxx={0^|A%h!Hl`okA6y9gA|p!
zUAca>F7>;`v^B^wTbW{u4myy!7)T{b2#wU6n;}{y@s&2)XOdS+KSt`6gOI<9JW=Me
z)#NVrP<d6Qu9xkh@3$l(mqYR#!fx_qc~hRPs-o3qt0jjj@(OcA9H3)0QZF4P-&Y*6
zO?k-1)16wZ$*Z}Fac0EU@4Da&%E+kSbt#J|I-|UP2lXpyEA!U}$W&GQfo0C5xgwJ4
zn$ZWI=9ZT%LtkF3d)Ai9T^yl67F%a7)+~^nti3ZgBI$0Ve#(Q66{KrtV{s@?->NnD
z!3-I!FM`$XAkWp``oCk1zlr~7$C6{d2?f4an%Mn(@Q8KNPBN2>`4zW?62j&;QUJ@+
z5q}(xFCqIh*~oEcJIC`5pthXDZUB#A{;~Dbk_#<fNBQH^+qS2EZt>ENt*rowx6SJ)
zdrCLH+}1~vhQe^_^LD&tnst)8uHu3ZZ!Q&=koK-wB{^3~Q7bDHRqzE$&H+;$JH3Ee
z6QjF;YfRjH4ZcnPG;!;<fd8Nz#@w?gd1`_}I&N!6$#*`Z=#`c2R9h$b+&29?CjdWV
z;RN7cbgWQR=LwkHWxaR<Ui?UHGK!!eu@lfHD5wVTW-4JMy9_>eEc`y;C9{amHv!9L
k5uH;gdGagE{x-y4w(K(~Ia^}pDtHYgXXvZsTKAs60C*Dmwg3PC

delta 2875
zcmeH}Uu;uV9LImBr(O4l(XA_^V{;uK8_cZRFd?`M$^!|}NMy!{QcZlg5A$J(Ch7o}
z-Ae>DWQm)HL`+DONOa8z4r_dHY+MsHhOoH=|Lnh|1%o8UJrI~%dyn7K+wo`J13u`B
zcKP*w&+mTD@BGg1-k#r#4x^*{(KU?j{cL-3`pD0_rz6*P_Y|*o9y;{OrJl|f_HobX
zdLH>LeD>xCPWMTxgP&YD6+Pj4i;0%any7I<sB7PMaqW__(_H(h8ulD)ifdy#xi&t*
zwTXGI&Gd5Z@>5((%y8}37r1uqI@hiTVSBiCt1F#IHPz4oI;cz9MH{G^4$|w;d+*ZE
z!n?@qgW5#xbU+6bR#KNx>f_#Xja=XK(kCQfm#LR}U;?Ief+Exn>wzhKh5G0nST{`R
zt2BV|0LB9t4`4h9JqUgf{2+Wo&_jqfgm^=wC+Iu|=P|g5>qT6L0SrSAr*(ox5MTtp
z5d;`PfKe<k3g2j2U!@qvF^ppv$FN`=Iu1S#J`P_3I)Qiz#7p4s3iK7|^hdnMKGoe%
zJWjM?jvTs48&Yz$L4;Z)$zxJTCW*F^j&F}OPgDU)np9&+N?PRWR9L_OHcRBE5Wd|C
z>-dv6&u}q|@;ixH6f#Jcu@t#NF(NJ(h_NI%j}CAn0vZ6fD^MqZW{Pq`CJ~cHl9<N=
z83I`AkkU#~elu>UEOlw5h=nkhsn`xC<vcmL%%I5><uzlmH!SQ)?Incu5djmiqPaj$
zIjid?J%q5cV7G!*cclfk^ER834ub+I$<2VxB0I2d#WI-$+W}Tj$Gy!OsGmv~3Ff_|
zSnOkwb?PdaqzW6-5trO1)gkvJ`ER3h#8A&U;wE-!)5zbFPAfwrNB=B&qy&Qp;0A+X
z3^b;uV`GyxUC-oPipp5*4xUfN7kBO7LB*n=$SaN%?97kEYo~1!#l8~JzbelYB*%2*
ztZ&hTQCKe8N=z}n;<bWE;^=h7#2H_C!M)rA1(EoR2$wd|UFDCOh0i<qsTLzzRU{aX
z{BjP_{9>fIZs|<1-rLV3@$kE=%fuhvV0K;wg;`le+e)^uznhZqt*Xn8?h$RPs<YjX
zWV`Z&r?g=ix1-f70+nm9hmXYJ(wCPZP*}cLRCQH_jkZ^0ZK15txfCnJ#Ct2dlGx&d
zP**$*Kg%T0_pN9sd-Weq;9(x=n-O1@xBUz2d?C6k%f;Txeao%Ynq5@UUSW!_0!!c4
z`>89ob#)zzSt_QgHhFLoEh%zY_FIVG#&Plc+Lc^AQfuvx|G&lQ*YSR;?f<X5#ePv4
z>_Cgd0gcl*C7tLjCIuZP1uW@JpXW){g@{xiGSGLW!#@4ZJ9ss4v;voXo&)sU#2owB
zM<7H+t3aPt{pBu<apM;H=o~ew{%{w#5g?ic;swx7(A1a$1GB_!&XVG>`dWwA>?!s|
zkJi^RM{XQaTxh6u6n&?h`Hj1n3#$@EKik}zCn}pguBS`B_LA7#{JtKZoKp>$D5si-
zC(+iFcGmLn6ecLmZ@`ajDjkG>@&{YHK7_u3e>&iA4D#^!F}pU6TcC5%P^FI=w}Uxt
z^Epl)9@A{yWWaAKtrImJ#)SQu8*k&rIm$^VLC{lBIY_7idW;O^&shikc}C|#_uEM{
lbs^3(b`nk9(6NmF7!OZq8UJx4vBO@=^(Gj0LR{Fk<u71T(TV^7

diff --git a/src/MacLO.pi.rsrc.bin b/src/MacLO.pi.rsrc.bin
index 35d86e7b4330b21dc79e53ba8d5cdbf0ee4a4bcc..cf1de4c52bdac1a8454cda83657b8ce45a6b8885 100644
GIT binary patch
delta 1323
zcmc(eO=uHA6oB9EN)~O5EtD2YO;$~tCTbB;L=OqngIJ2z;>m*-8xh5(hdl_DWZPK(
z+azuef`}eGNWoBSbMRs|AnHMA4?U=~&7vYj3Qa*tG@Fg@P1<T~g?RD}v-8cHH}l@U
zH=~?XPDhV6z#r1uIXn2defG)ZhFDE~U4Osl7#VQbcSZp`*m*4$-ObI#p6{=Uf14?7
zZ|zh$ZeU#D#+sb)6dOr3wi>=@g(6DHj%jg4t(NKqTvvM??hx6Ll#iQMbY`fKEF|;k
za4KYm%w!>*U(7CM)A_l+clTa>#FHOF1p5&7Fp!@L{IjzG8YnWgQL3su79(jSb7>_7
zCYVY=%j;P^tL3%6)c=UZXZUgsg^B|TrwO{Ki<+Pbsqngai9?+Ix9zWWv9a~v^Mbal
zMzn{dd@R)nbwSe`w0muKi;cGc&+`_G&1ScIy}_VquBp#I#(@>)R7nzr3S%kyiVut}
zx)`2}-1lAf8I8GTOG{y0%=o^qy(^<I%Kpm=;yQO##5F5hU(U&DEND-8xj_3!%EwY(
zP-j36GRp^)h74*9Sd)_q;$UxP+3$gJe=Gi1{hIIt=HU^Hz%;fASb#66F+r7FwROK9
zvXD3tt@dDGjr_3M?uu}=<L_M?xljhe^kTP;35nwiaD~`@9(f)Hi5*VlPjHp-9I_7A
zh^4#8GjN@FTNm<MxIw(#iaZTB8NWoHf?LEp6y!H>o7i~>`85m?pK^Z1$qN{!NmE=%
z9F!qK+}w@&#}FlUH6TwwjPaC^=mfY!+%kZA4OC+HKI9G<Vf+EPTRrFAyJxe6!ahg*
ia$De1m;a31(t9}2Bl~+~n(UI=0<s*q*x^5m-24-|er;9&

delta 368
zcmZpOYY3U(DaFWu3N)qewm$Q^yYha;L_u+}#>TTAAbF4~wRH>(szA(?GjW10<CKZ}
zOu1LSjE3mel$y-Q*tEHUaf2$@M1)%At$`B+w1BE)n5-u2==3x4Zr-EA$yon}q51!R
z1_s#;%v=3mFtmW!a#=w31BO-*TV4gop25%tX5Ry{w=lGW*a|a%>?aHzAhu!<kiCJS
z6U0{H0kT&xbb;B&fb2O8-5|Dd1CZUp&;w$tSTS!65Mk&AvDs9<03|9W&(kwX3v*@Q
z_em{F&2i032~JMUOVvvT`gqCoL!2<oAjQDMz#u8_>*(yk$mN@u?2($7l3G;EkjKDy
Ucjb(77-o<Ig_Mkhk1M8`0A><)eE<Le

diff --git a/src/PlayScene.c b/src/PlayScene.c
index 679db09..7ca1738 100644
--- a/src/PlayScene.c
+++ b/src/PlayScene.c
@@ -8,39 +8,64 @@
 #define PlayfieldCornerSize 12
 #define LightMargin         6
 #define LightSize           50
-#define LightCornerSize     8
+#define LightCornerSize     12
 #define PlayfieldPattern    ltGray
 
 #define HUDMargin     PlayfieldMargin
 #define HUDCornerSize PlayfieldCornerSize
 #define HUDPattern    PlayfieldPattern
 
-#define LevelTextScale 2
+#define LevelTextScale 3
+#define HalfStarScale  2
+#define ScoreTextScale 1
 
 void PlayScene_Init(GameWindow *pGameWindow)
 {
-    Rect r1, r2;
+    Rect r;
+    
+    const Rect *pContentRect = &(pGameWindow->Window->portRect);
 
     // Setup Playfield
     pGameWindow->PlayScene.PlayfieldRect.top = PlayfieldMargin;
-    pGameWindow->PlayScene.PlayfieldRect.bottom = pGameWindow->Window->portRect.bottom - PlayfieldMargin;
+    pGameWindow->PlayScene.PlayfieldRect.bottom = pContentRect->bottom - PlayfieldMargin;
     pGameWindow->PlayScene.PlayfieldRect.left = pGameWindow->PlayScene.PlayfieldRect.top;
     pGameWindow->PlayScene.PlayfieldRect.right = pGameWindow->PlayScene.PlayfieldRect.bottom;
     
     // Setup HUD
     pGameWindow->PlayScene.HUDRect.top = HUDMargin;
-    pGameWindow->PlayScene.HUDRect.bottom = pGameWindow->Window->portRect.bottom - HUDMargin;
+    pGameWindow->PlayScene.HUDRect.bottom = pContentRect->bottom - HUDMargin;
     pGameWindow->PlayScene.HUDRect.left = pGameWindow->PlayScene.PlayfieldRect.right + HUDMargin;
-    pGameWindow->PlayScene.HUDRect.right = pGameWindow->Window->portRect.right - HUDMargin;
+    pGameWindow->PlayScene.HUDRect.right = pContentRect->right - HUDMargin;
     
-    // Setup Level
-    GetScaledPicFrame(pGameWindow->Engine.SetB ? pGameWindow->Bitmaps.BCharPict : pGameWindow->Bitmaps.ACharPict, LevelTextScale, &r1);
-    Bitmaps_GetNumberRect(&(pGameWindow->Bitmaps), 1 + pGameWindow->Engine.Level, LevelTextScale, &r2);
-    ConcatenateRect(&r1, &r2, &(pGameWindow->PlayScene.LevelRect));
+    // Setup level
+    GetScaledPicFrame(pGameWindow->Engine.SetB ? pGameWindow->Bitmaps.BCharPict : pGameWindow->Bitmaps.ACharPict, LevelTextScale, &(pGameWindow->PlayScene.LevelRect));
+    Bitmaps_GetNumberRect(&(pGameWindow->Bitmaps), 1 + pGameWindow->Engine.Level, LevelTextScale, &r);
+    ConcatenateRect(&(pGameWindow->PlayScene.LevelRect), &r, &(pGameWindow->PlayScene.LevelRect));
+
+    GetBoxRect(&(pGameWindow->PlayScene.HUDRect), Top, &r);
+    CenterRect(&r, &(pGameWindow->PlayScene.LevelRect));
+
+    // Setup half-stars
+    Bitmaps_GetHalfStarsRect(&(pGameWindow->Bitmaps), GameEngine_GetHalfStars(&(pGameWindow->Engine)), MaxStars, HalfStarScale, &(pGameWindow->PlayScene.HalfStarsRect));
     
-    GetBoxRect(&(pGameWindow->PlayScene.HUDRect), Top, &r1);
-    GetBoxRect(&r1, Bottom, &r2);
-    CenterRect(&r2, &(pGameWindow->PlayScene.LevelRect));
+    GetBoxRect(&(pGameWindow->PlayScene.HUDRect), Center, &r);
+    CenterRect(&r, &(pGameWindow->PlayScene.HalfStarsRect));
+    
+    // Setup score
+    Bitmaps_GetNumberRect(&(pGameWindow->Bitmaps), pGameWindow->Engine.Score, ScoreTextScale, &(pGameWindow->PlayScene.ScoreRect));
+    GetScaledPicFrame(pGameWindow->Bitmaps.SlashCharPict, ScoreTextScale, &r);
+    ConcatenateRect(&(pGameWindow->PlayScene.ScoreRect), &r, &(pGameWindow->PlayScene.ScoreRect));
+    Bitmaps_GetNumberRect(&(pGameWindow->Bitmaps), PerfectScore, ScoreTextScale, &r);
+    ConcatenateRect(&(pGameWindow->PlayScene.ScoreRect), &r, &(pGameWindow->PlayScene.ScoreRect));
+    
+    GetBoxRect(&(pGameWindow->PlayScene.HUDRect), Bottom, &r);
+    CenterRect(&r, &(pGameWindow->PlayScene.ScoreRect));
+    
+    // Setup retry button
+    GetPictureRect(pGameWindow->Bitmaps.RetryButtonPict, &(pGameWindow->PlayScene.RetryButtonRect));
+    
+    GetBoxRect(&(pGameWindow->PlayScene.HUDRect), BottomLeft, &r);
+    CenterRect(&r, &(pGameWindow->PlayScene.RetryButtonRect));
 }
 
 void PlayScene_SetLightRect(const GameWindow *pGameWindow, Rect *pRect, const int8_t c, const int8_t r)
@@ -59,8 +84,10 @@ void PlayScene_Draw(const GameWindow *pGameWindow, bool fullRefresh)
     if (fullRefresh)
     {
         // Fill backgrounds
-        FillRoundRect(&(pGameWindow->PlayScene.PlayfieldRect), PlayfieldCornerSize, PlayfieldCornerSize, PlayfieldPattern);
-        //FillRoundRect(&(pGameWindow->PlayScene.HUDRect), HUDCornerSize, HUDCornerSize, HUDPattern);
+        ForeColor(whiteColor);
+        FrameRoundRect(&(pGameWindow->PlayScene.PlayfieldRect), PlayfieldCornerSize, PlayfieldCornerSize);
+        FrameRoundRect(&(pGameWindow->PlayScene.HUDRect), HUDCornerSize, HUDCornerSize);
+        ForeColor(blackColor);
     }
     
     // Draw Playfield
@@ -80,14 +107,14 @@ void PlayScene_Draw(const GameWindow *pGameWindow, bool fullRefresh)
             else
             {
                 // Draw OFF light
-                FillRoundRect(&lightRect, LightCornerSize, LightCornerSize, black);
+                FillRoundRect(&lightRect, LightCornerSize, LightCornerSize, dkGray);
             }
         }
     }
     
     // Draw HUD
     
-    // Draw Level
+    // Draw level
     MoveTo(pGameWindow->PlayScene.LevelRect.left, pGameWindow->PlayScene.LevelRect.top);
     if (pGameWindow->Engine.SetB)
     {
@@ -99,7 +126,18 @@ void PlayScene_Draw(const GameWindow *pGameWindow, bool fullRefresh)
     }
     Bitmaps_DrawNumber(&(pGameWindow->Bitmaps), 1 + pGameWindow->Engine.Level, LevelTextScale);
     
-    // Draw Stars
+    // Draw half-stars
+    MoveTo(pGameWindow->PlayScene.HalfStarsRect.left, pGameWindow->PlayScene.HalfStarsRect.top);
+    Bitmaps_DrawHalfStars(&(pGameWindow->Bitmaps), GameEngine_GetHalfStars(&(pGameWindow->Engine)), MaxStars, HalfStarScale);
+    
+    // Draw score
+    MoveTo(pGameWindow->PlayScene.ScoreRect.left, pGameWindow->PlayScene.ScoreRect.top);
+    Bitmaps_DrawNumber(&(pGameWindow->Bitmaps), pGameWindow->Engine.Score, ScoreTextScale);
+    Bitmaps_DrawSlashChar(&(pGameWindow->Bitmaps), ScoreTextScale);
+    Bitmaps_DrawNumber(&(pGameWindow->Bitmaps), PerfectScore, ScoreTextScale);
+    
+    // Draw retry button
+    DrawPicture(pGameWindow->Bitmaps.RetryButtonPict, &(pGameWindow->PlayScene.RetryButtonRect));
 }
 
 void PlayScene_Click(GameWindow *pGameWindow, const Point *pPosition)
@@ -128,11 +166,18 @@ void PlayScene_Click(GameWindow *pGameWindow, const Point *pPosition)
         if (GameEngine_IsCompleted(&(pGameWindow->Engine)))
         {
             // Level was completed in the last click
+            GameWindow_Draw(pGameWindow, false);
             GameWindow_SetScene(pGameWindow, LevelEnd);
         }
     }
     else if (PtInRect(*pPosition, &(pGameWindow->PlayScene.HUDRect)))
     {
         // Click within HUD
+        
+        if (PtInRect(*pPosition, &(pGameWindow->PlayScene.RetryButtonRect)))
+        {
+            GameEngine_ResetLevel(&(pGameWindow->Engine));
+            GameWindow_Draw(pGameWindow, false);
+        }
     }
 }
diff --git a/src/Scenes.h b/src/Scenes.h
index 9d05482..f712b83 100644
--- a/src/Scenes.h
+++ b/src/Scenes.h
@@ -26,16 +26,24 @@ typedef struct sPlayScene
     Rect PlayfieldRect;
     Rect HUDRect;
     Rect LevelRect;
+    Rect HalfStarsRect;
+    Rect ScoreRect;
+    Rect RetryButtonRect;
 } PlayScene;
 
 typedef struct sLevelEndScene
 {
-    Rect temp;
+    Rect LevelRect;
+    Rect HalfStarsRect;
+    Rect ScoreRect;
+    Rect RetryButtonRect;
+    Rect NextButtonRect;
 } LevelEndScene;
 
 typedef struct sGameEndScene
 {
-    Rect temp;
+    Rect SetRect;
+    Rect ScoreRect;
 } GameEndScene;
 
 #endif
diff --git a/src/TitleScene.c b/src/TitleScene.c
index 8437d2b..1b3a283 100644
--- a/src/TitleScene.c
+++ b/src/TitleScene.c
@@ -13,7 +13,7 @@ void TitleScene_Init(GameWindow *pGameWindow)
     const Rect *pContentRect = &(pGameWindow->Window->portRect);
     
     // Setup rects
-    GetScaledPicFrame(pGameWindow->Bitmaps.TitlePict, 1, &(pGameWindow->TitleScene.TitleRect));
+    GetPictureRect(pGameWindow->Bitmaps.TitlePict, &(pGameWindow->TitleScene.TitleRect));
     CenterRect(pContentRect, &(pGameWindow->TitleScene.TitleRect));
     
     GetBoxRect(pContentRect, BottomLeft, &r);
@@ -27,11 +27,6 @@ void TitleScene_Init(GameWindow *pGameWindow)
 
 void TitleScene_Draw(const GameWindow *pGameWindow, bool fullRefresh)
 {
-    // TODO: Proper title
-    if (fullRefresh)
-    {
-    }
-    
     // Draw Title
     DrawPicture(pGameWindow->Bitmaps.TitlePict, &(pGameWindow->TitleScene.TitleRect));