diff --git a/osu.Game.Rulesets.Osu/Scoring/OsuScoreProcessor.cs b/osu.Game.Rulesets.Osu/Scoring/OsuScoreProcessor.cs
index 8ba92a8d30..3ee8f56665 100644
--- a/osu.Game.Rulesets.Osu/Scoring/OsuScoreProcessor.cs
+++ b/osu.Game.Rulesets.Osu/Scoring/OsuScoreProcessor.cs
@@ -1,8 +1,11 @@
 // Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
+using System;
 using System.Collections.Generic;
+using osu.Framework.Configuration;
 using osu.Framework.Extensions;
+using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Osu.Judgements;
 using osu.Game.Rulesets.Osu.Objects;
@@ -14,6 +17,8 @@ namespace osu.Game.Rulesets.Osu.Scoring
 {
     internal class OsuScoreProcessor : ScoreProcessor<OsuHitObject, OsuJudgement>
     {
+        public readonly Bindable<ScoringMode> Mode = new Bindable<ScoringMode>(ScoringMode.Exponential);
+
         public OsuScoreProcessor()
         {
         }
@@ -25,9 +30,31 @@ namespace osu.Game.Rulesets.Osu.Scoring
 
         private float hpDrainRate;
 
-        protected override void ComputeTargets(Game.Beatmaps.Beatmap<OsuHitObject> beatmap)
+        private int totalAccurateJudgements;
+
+        private readonly Dictionary<OsuScoreResult, int> scoreResultCounts = new Dictionary<OsuScoreResult, int>();
+        private readonly Dictionary<ComboResult, int> comboResultCounts = new Dictionary<ComboResult, int>();
+
+        private double comboMaxScore;
+
+        protected override void ComputeTargets(Beatmap<OsuHitObject> beatmap)
         {
             hpDrainRate = beatmap.BeatmapInfo.Difficulty.DrainRate;
+            totalAccurateJudgements = beatmap.HitObjects.Count;
+
+            foreach (var h in beatmap.HitObjects)
+            {
+                if (h != null)
+                {
+                    // TODO: add support for other object types.
+                    AddJudgement(new OsuJudgement
+                    {
+                        MaxScore = OsuScoreResult.Hit300,
+                        Score = OsuScoreResult.Hit300,
+                        Result = HitResult.Hit
+                    });
+                }
+            }
         }
 
         protected override void Reset()
@@ -41,9 +68,6 @@ namespace osu.Game.Rulesets.Osu.Scoring
             comboResultCounts.Clear();
         }
 
-        private readonly Dictionary<OsuScoreResult, int> scoreResultCounts = new Dictionary<OsuScoreResult, int>();
-        private readonly Dictionary<ComboResult, int> comboResultCounts = new Dictionary<ComboResult, int>();
-
         public override void PopulateScore(Score score)
         {
             base.PopulateScore(score);
@@ -63,6 +87,7 @@ namespace osu.Game.Rulesets.Osu.Scoring
                     scoreResultCounts[judgement.Score] = scoreResultCounts.GetOrDefault(judgement.Score) + 1;
                     comboResultCounts[judgement.Combo] = comboResultCounts.GetOrDefault(judgement.Combo) + 1;
                 }
+
                 switch (judgement.Score)
                 {
                     case OsuScoreResult.Hit300:
@@ -78,7 +103,7 @@ namespace osu.Game.Rulesets.Osu.Scoring
                         break;
 
                     case OsuScoreResult.SliderTick:
-                        Health.Value += System.Math.Max(7 - hpDrainRate, 0) * 0.01;
+                        Health.Value += Math.Max(7 - hpDrainRate, 0) * 0.01;
                         break;
 
                     case OsuScoreResult.Miss:
@@ -87,17 +112,51 @@ namespace osu.Game.Rulesets.Osu.Scoring
                 }
             }
 
-            int score = 0;
-            int maxScore = 0;
+            calculateScore();
+        }
+
+        private void calculateScore()
+        {
+            int baseScore = 0;
+            double comboScore = 0;
+
+            int baseMaxScore = 0;
 
             foreach (var j in Judgements)
             {
-                score += j.ScoreValue;
-                maxScore += j.MaxScoreValue;
+                baseScore += j.ScoreValue;
+                baseMaxScore += j.MaxScoreValue;
+
+                comboScore += j.ScoreValue * (1 + Combo.Value / 10d);
             }
 
-            TotalScore.Value = score;
-            Accuracy.Value = (double)score / maxScore;
+            Accuracy.Value = (double)baseScore / baseMaxScore;
+
+            if (comboScore > comboMaxScore)
+                comboMaxScore = comboScore;
+
+            if (baseScore == 0)
+                TotalScore.Value = 0;
+            else
+            {
+                // temporary to make scoring feel more like score v1 without being score v1.
+                float exponentialFactor = Mode.Value == ScoringMode.Exponential ? (float)Judgements.Count / 100 : 1;
+
+                TotalScore.Value =
+                    (int)
+                    (
+                        exponentialFactor *
+                        700000 * comboScore / comboMaxScore +
+                        300000 * Math.Pow(Accuracy.Value, 10) * ((double)Judgements.Count / totalAccurateJudgements) +
+                        0 /* bonusScore */
+                    );
+            }
+        }
+
+        public enum ScoringMode
+        {
+            Standardised,
+            Exponential
         }
     }
 }