New class for score management

  -Scores are raised when PopUp slides under the scorebg
  -1 to 6 Player support (even 5 Players(not supported by Core atm))
  -Display 3 Players instead of 2 when 4 Players are set in the Options and Screens=2

Ratingbar is not drawn by class atm.
Have to be done


git-svn-id: svn://svn.code.sf.net/p/ultrastardx/svn/trunk@430 b956fd51-792f-4845-bead-9b4dfca2ff2c

7 files changed, 1380 insertions, 526 deletions

diff --git a/Game/Code/Classes/UDraw.pas b/Game/Code/Classes/UDraw.pas
index 4c5d2ce0..5a175289 100644
--- a/Game/Code/Classes/UDraw.pas
+++ b/Game/Code/Classes/UDraw.pas
@@ -713,7 +713,7 @@ begin
   end;

   //end Singbar Mod

 

-  //PhrasenBonus - Line Bonus Mod

+  {//PhrasenBonus - Line Bonus Mod

   if Ini.LineBonus > 0 then begin

     A := GetTickCount div 33;

     if (A <> Tickold2) AND (Player[0].LineBonus_Visible) then begin

@@ -784,7 +784,7 @@ begin
       end;

     end;

   end;

-  //PhrasenBonus - Line Bonus Mod End

+  //PhrasenBonus - Line Bonus Mod End  }

 

 // Set the note heights according to the difficulty level

   case Ini.Difficulty of

@@ -1127,7 +1127,7 @@ begin
   end;

   //end Singbar Mod

 

-  //PhrasenBonus - Line Bonus Mod

+  {//PhrasenBonus - Line Bonus Mod

   if ((Ini.LineBonus > 0) AND (DLLMan.Selected.EnLineBonus_O)) OR (DLLMan.Selected.EnLineBonus) then begin

     A := GetTickCount div 33;

     if (A <> Tickold2) AND (Player[0].LineBonus_Visible) then begin

@@ -1214,7 +1214,7 @@ begin
       end;

     end;

   end;

-//PhrasenBonus - Line Bonus Mod End

+//PhrasenBonus - Line Bonus Mod End }

 

 // resize the notes according to the difficulty level

   case Ini.Difficulty of

diff --git a/Game/Code/Classes/UGraphic.pas b/Game/Code/Classes/UGraphic.pas
index f350d0d2..6ea89c0f 100644
--- a/Game/Code/Classes/UGraphic.pas
+++ b/Game/Code/Classes/UGraphic.pas
@@ -156,6 +156,9 @@ var
   Tex_SingLineBonusBack: array[0..8] of TTexture;

   //End PhrasenBonus - Line Bonus Mod

 

+  //ScoreBG Texs

+  Tex_ScoreBG: array [0..5] of TTexture;

+

 const

   Skin_BGColorR = 1;

   Skin_BGColorG = 1;

@@ -315,22 +318,48 @@ begin
   //Line Bonus PopUp

   for P := 0 to 8 do

     begin

-      Tex_SingLineBonusBack[P] :=  Texture.LoadTexture(pchar(Skin.GetTextureFileName('LineBonusBack')), 'PNG', 'Colorized', $FFFFFF);

+      Case P of

+        0: begin

+          R := 1;

+          G := 0;

+          B := 0;

+        end;

+        1..3: begin

+          R := 1;

+          G := (P * 0.25);

+          B := 0;

+        end;

+        4: begin

+          R := 1;

+          G := 1;

+          B := 0;

+        end;

+        5..7: begin

+          R := 1-((P-4)*0.25);

+          G := 1;

+          B := 0;

+        end;

+        8: begin

+          R := 0;

+          G := 1;

+          B := 0;

+        end;

+      End;

+

+      Col := $10000 * Round(R*255) + $100 * Round(G*255) + Round(B*255);

+      Tex_SingLineBonusBack[P] :=  Texture.LoadTexture(pchar(Skin.GetTextureFileName('LineBonusBack')), 'PNG', 'Colorized', Col);

     end;

+

+  //Score BG Textures

+  for P := 0 to 5 do begin

+    LoadColor(R, G, B, 'P' + IntToStr(P+1) + 'Light');

+    Col := $10000 * Round(R*255) + $100 * Round(G*255) + Round(B*255);

+    Tex_ScoreBG[P] := Texture.LoadTexture(pchar(Skin.GetTextureFileName('ScoreBG')),  'PNG', 'Colorized', Col);

+  end;

+

   {$ENDIF}

-    

-    

-  {//Set Texture to Font High

-  Tex_SingLineBonusL.H := 32; Tex_SingLineBonusL.W := 8;

-  Tex_SingLineBonusM.H := 32; //Tex_SingLineBonusM.TexW := Tex_SingLineBonusM.TexW/2;

-  Tex_SingLineBonusR.H := 32; Tex_SingLineBonusR.W := 8;  }

-  //PhrasenBonus - Line Bonus Mod End

 

   Log.LogStatus('Loading Textures - D', 'LoadTextures');

-

-  // tworzenie czcionek

-//  Log.LogStatus('Building Fonts', 'LoadTextures');

-//  BuildFont;

 end;

 

 procedure Initialize3D (Title: string);

diff --git a/Game/Code/Classes/USingNotes.pas b/Game/Code/Classes/USingNotes.pas
new file mode 100644
index 00000000..e2162bf1
--- /dev/null
+++ b/Game/Code/Classes/USingNotes.pas
@@ -0,0 +1,10 @@
+unit USingNotes;

+

+interface

+{ Dummy Unit atm

+  For further expantation

+  Placeholder for Class that will handle the Notes Drawing}

+

+implementation

+

+end.

diff --git a/Game/Code/Classes/USingScores.pas b/Game/Code/Classes/USingScores.pas
new file mode 100644
index 00000000..27a65b32
--- /dev/null
+++ b/Game/Code/Classes/USingScores.pas
@@ -0,0 +1,759 @@
+unit USingScores;

+

+interface

+uses UThemes, OpenGl12, UTexture;

+

+//Some Constances containing Options that could change by time

+const

+  MaxPlayers = 6;   //Maximum of Players that could be added

+  MaxPositions = 6; //Maximum of Score Positions that could be added

+

+type

+  //-----------

+  // TScorePlayer - Record Containing Information about a Players Score

+  //-----------

+  TScorePlayer = record

+    Position: Byte;    //Index of the Position where the Player should be Drawn

+    Enabled:  Boolean; //Is the Score Display Enabled

+    Visible:  Boolean; //Is the Score Display Visible

+    Score:    Word;    //Current Score of the Player

+    ScoreDisplayed: Word; //Score cur. Displayed(for counting up)

+    ScoreBG:  TTexture;//Texture of the Players Scores BG

+    Color:    TRGB;    //Teh Players Color

+  end;

+  aScorePlayer = array[0..MaxPlayers-1] of TScorePlayer;

+

+  //-----------

+  // TScorePosition - Record Containing Information about a Score Position, that can be used

+  //-----------

+  PScorePosition = ^TScorePosition;

+  TScorePosition = record

+    //The Position is Used for Which Playercount

+    PlayerCount: Byte;

+    // 1 - One Player per Screen

+    // 2 - 2 Players per Screen

+    // 4 - 3 Players per Screen

+    // 6 would be 2 and 3 Players per Screen

+

+    BGX: Real;     //X Position of the Score BG

+    BGY: Real;     //Y Position of the Score BG

+    BGW: Real;     //Width of the Score BG

+    BGH: Real;     //Height of the Score BG

+

+    RBX: Real;     //X Position of the Rating Bar

+    RBY: Real;     //Y Position of the Rating Bar

+    RBW: Real;     //Width of the Rating Bar

+    RBH: Real;     //Height of the Rating Bar

+

+    TextX: Real;        //X Position of the Score Text

+    TextY: Real;        //Y Position of the Score Text

+    TextFont: Byte;     //Font of the Score Text

+    TextSize: Byte;     //Size of the Score Text

+

+    PUW: Real;          //Width of the LineBonus Popup

+    PUH: Real;          //Height of the LineBonus Popup

+    PUFont: Byte;       //Font for the PopUps

+    PUFontSize: Byte;   //FontSize for the PopUps

+    PUStartX: Real;     //X Start Position of the LineBonus Popup

+    PUStartY: Real;     //Y Start Position of the LineBonus Popup

+    PUTargetX: Real;    //X Target Position of the LineBonus Popup

+    PUTargetY: Real;    //Y Target Position of the LineBonus Popup

+  end;

+  aScorePosition = array[0..MaxPositions-1] of TScorePosition;

+

+  //-----------

+  // TScorePopUp - Record Containing Information about a LineBonus Popup

+  // List, Next Item is Saved in Next attribute

+  //-----------

+  PScorePopUp = ^TScorePopUp;

+  TScorePopUp = record

+    Player:  Byte;          //Index of the PopUps Player

+    TimeStamp: Cardinal;    //Timestamp of Popups Spawn

+    Rating:    Byte;        //0 to 8, Type of Rating (Cool, bad, etc.)

+    ScoreGiven:Word;        //Score that has already been given to the Player

+    ScoreDiff: Word;        //Difference Between Cur Score at Spawn and Old Score

+    Next:      PScorePopUp; //Next Item in List

+  end;

+  aScorePopUp = array of TScorePopUp;

+

+  //-----------

+  // TSingScores - Class containing Scores Positions and Drawing Scores, Rating Bar + Popups

+  //-----------

+  TSingScores = class

+    private

+      Positions: aScorePosition;

+      aPlayers: aScorePlayer;

+      oPositionCount: Byte;

+      oPlayerCount: Byte;

+

+      //Saves the First and Last Popup of the List

+      FirstPopUp: PScorePopUp;

+      LastPopUp:  PScorePopUp;

+

+      //Procedure Draws a Popup by Pointer

+      Procedure DrawPopUp(const PopUp: PScorePopUp);

+

+      //Procedure Draws a Score by Playerindex

+      Procedure DrawScore(const Index: Integer);

+

+      //Procedure Removes a PopUp w/o destroying the List

+      Procedure KillPopUp(const last, cur: PScorePopUp);

+    public

+      Settings: record //Record containing some Displaying Options

+        Phase1Time: Real;     //time for Phase 1 to complete (in msecs)

+                              //The Plop Up of the PopUp

+        Phase2Time: Real;     //time for Phase 2 to complete (in msecs)

+                              //The Moving (mainly Upwards) of the Popup

+        Phase3Time: Real;     //time for Phase 3 to complete (in msecs)

+                              //The Fade out and Score adding

+

+        PopUpTex:   Array [0..8] of TTexture; //Textures for every Popup Rating

+

+        RatingBar_BG_Tex:   TTexture; //Rating Bar Texs

+        RatingBar_FG_Tex:   TTexture;

+        RatingBar_Bar_Tex:  TTexture;

+

+      end;

+

+      //Propertys for Reading Position and Playercount

+      Property PositionCount: Byte read oPositionCount;

+      Property PlayerCount: Byte read oPlayerCount;

+      Property Players: aScorePlayer read aPlayers;

+

+      //Constructor just sets some standard Settings

+      Constructor Create;

+

+      //Procedure Adds a Position to Array and Increases Position Count

+      Procedure AddPosition(const pPosition: PScorePosition);

+

+      //Procedure Adds a Player to Array and Increases Player Count

+      Procedure AddPlayer(const ScoreBG: TTexture; const Color: TRGB; const Score: Word = 0; const Enabled: Boolean = True; const Visible: Boolean = True);

+

+      //Change a Players Visibility, Enable

+      Procedure ChangePlayerVisibility(const Index: Byte; const pVisible: Boolean);

+      Procedure ChangePlayerEnabled(const Index: Byte; const pEnabled: Boolean);

+

+      //Procedure Deletes all Player Information

+      Procedure ClearPlayers;

+

+      //Procedure Deletes Positions and Playerinformation

+      Procedure Clear;

+

+      //Procedure Loads some Settings and the Positions from Theme

+      Procedure LoadfromTheme;

+

+      //Procedure has to be called after Positions and Players have been added, before first call of Draw

+      //It gives every Player a Score Position

+      Procedure Init;

+

+      //Spawns a new Line Bonus PopUp for the Player

+      Procedure SpawnPopUp(const PlayerIndex: Byte; const Rating: Byte; const Score: Word);

+

+      //Removes all PopUps from Mem

+      Procedure KillAllPopUps;

+

+      //Procedure Draws Scores and Linebonus PopUps

+      Procedure Draw;

+  end;

+

+

+implementation

+uses SDL, SysUtils, ULog, UGraphic, TextGL;

+

+//-----------

+//Constructor just sets some standard Settings

+//-----------

+Constructor TSingScores.Create;

+begin

+  //Clear PopupList Pointers

+  FirstPopUp := nil;

+  LastPopUp  := nil;

+  

+  //Clear Position Index

+  oPositionCount  := 0;

+  oPlayerCount    := 0;

+

+  Settings.Phase1Time := 1000;

+  Settings.Phase2Time := 2000;

+  Settings.Phase3Time := 2000;

+

+  Settings.PopUpTex[0].TexNum := High(gluInt);

+  Settings.PopUpTex[1].TexNum := High(gluInt);

+  Settings.PopUpTex[2].TexNum := High(gluInt);

+  Settings.PopUpTex[3].TexNum := High(gluInt);

+  Settings.PopUpTex[4].TexNum := High(gluInt);

+  Settings.PopUpTex[5].TexNum := High(gluInt);

+  Settings.PopUpTex[6].TexNum := High(gluInt);

+  Settings.PopUpTex[7].TexNum := High(gluInt);

+  Settings.PopUpTex[8].TexNum := High(gluInt);

+

+  Settings.RatingBar_BG_Tex.TexNum   := High(gluInt);

+  Settings.RatingBar_FG_Tex.TexNum   := High(gluInt);

+  Settings.RatingBar_Bar_Tex.TexNum  := High(gluInt);

+end;

+

+//-----------

+//Procedure Adds a Position to Array and Increases Position Count

+//-----------

+Procedure TSingScores.AddPosition(const pPosition: PScorePosition);

+begin

+  if (PositionCount < MaxPositions) then

+  begin

+    Positions[PositionCount] := pPosition^;

+

+    Inc(oPositionCount);

+  end;

+end;

+

+//-----------

+//Procedure Adds a Player to Array and Increases Player Count

+//-----------

+Procedure TSingScores.AddPlayer(const ScoreBG: TTexture; const Color: TRGB; const Score: Word; const Enabled: Boolean; const Visible: Boolean);

+begin

+  if (PlayerCount < MaxPlayers) then

+  begin

+    aPlayers[PlayerCount].Position  := High(byte);

+    aPlayers[PlayerCount].Enabled   := Enabled;

+    aPlayers[PlayerCount].Visible   := Visible;

+    aPlayers[PlayerCount].Score     := Score;

+    aPlayers[PlayerCount].ScoreDisplayed     := Score;

+    aPlayers[PlayerCount].ScoreBG   := ScoreBG;

+    aPlayers[PlayerCount].Color     := Color;

+

+    Inc(oPlayerCount);

+  end;

+end;

+

+//-----------

+//Change a Players Visibility

+//-----------

+Procedure TSingScores.ChangePlayerVisibility(const Index: Byte; const pVisible: Boolean);

+begin

+  if (Index < MaxPlayers) then

+    aPlayers[Index].Visible := pVisible;

+end;

+

+//-----------

+//Change Player Enabled

+//-----------

+Procedure TSingScores.ChangePlayerEnabled(const Index: Byte; const pEnabled: Boolean);

+begin

+  if (Index < MaxPlayers) then

+    aPlayers[Index].Enabled := pEnabled;

+end;

+

+//-----------

+//Procedure Deletes all Player Information

+//-----------

+Procedure TSingScores.ClearPlayers;    

+begin

+  KillAllPopUps;

+  oPlayerCount := 0;

+end;

+

+//-----------

+//Procedure Deletes Positions and Playerinformation

+//-----------

+Procedure TSingScores.Clear; 

+begin

+  KillAllPopUps;

+  oPlayerCount    := 0;

+  oPositionCount  := 0;

+end;

+

+//-----------

+//Procedure Loads some Settings and the Positions from Theme

+//-----------

+Procedure TSingScores.LoadfromTheme;

+var I: Integer;

+  Procedure AddbyStatics(const PC: Byte; const ScoreStatic, SingBarStatic: TThemeStatic; ScoreText: TThemeText);

+    var nPosition: TScorePosition;

+  begin

+    nPosition.PlayerCount := PC; //Only for one Player Playing

+

+    nPosition.BGX := ScoreStatic.X;

+    nPosition.BGY := ScoreStatic.Y;

+    nPosition.BGW := ScoreStatic.W;

+    nPosition.BGH := ScoreStatic.H;

+

+    nPosition.TextX     := ScoreText.X;

+    nPosition.TextY     := ScoreText.Y;

+    nPosition.TextFont  := ScoreText.Font;

+    nPosition.TextSize  := ScoreText.Size;

+

+    nPosition.RBX := SingBarStatic.X;

+    nPosition.RBY := SingBarStatic.Y;

+    nPosition.RBW := SingBarStatic.W;

+    nPosition.RBH := SingBarStatic.H;

+

+    nPosition.PUW := nPosition.BGW;

+    nPosition.PUH := nPosition.BGH;

+

+    nPosition.PUFont     := 2;

+    nPosition.PUFontSize := 6;

+

+    nPosition.PUStartX := nPosition.BGX;

+    nPosition.PUStartY := nPosition.TextY + 65;

+

+    nPosition.PUTargetX := nPosition.BGX;

+    nPosition.PUTargetY := nPosition.TextY;

+

+    AddPosition(@nPosition);

+  end;

+begin

+  Clear;

+

+  //Set Textures

+  //Popup Tex

+  For I := 0 to 8 do

+    Settings.PopUpTex[I] := Tex_SingLineBonusBack[I];

+

+  //Rating Bar Tex  

+  Settings.RatingBar_BG_Tex   :=  Tex_SingBar_Back;

+  Settings.RatingBar_FG_Tex   :=  Tex_SingBar_Front;

+  Settings.RatingBar_Bar_Tex  :=  Tex_SingBar_Bar;

+

+  //Load Positions from Theme

+

+  // Player1:

+  AddByStatics(1, Theme.Sing.StaticP1ScoreBG, Theme.Sing.StaticP1SingBar, Theme.Sing.TextP1Score);

+  AddByStatics(2, Theme.Sing.StaticP1TwoPScoreBG, Theme.Sing.StaticP1TwoPSingBar, Theme.Sing.TextP1TwoPScore);

+  AddByStatics(4, Theme.Sing.StaticP1ThreePScoreBG, Theme.Sing.StaticP1ThreePSingBar, Theme.Sing.TextP1ThreePScore);

+

+  // Player2:

+  AddByStatics(2, Theme.Sing.StaticP2RScoreBG, Theme.Sing.StaticP2RSingBar, Theme.Sing.TextP2RScore);

+  AddByStatics(4, Theme.Sing.StaticP2MScoreBG, Theme.Sing.StaticP2MSingBar, Theme.Sing.TextP2MScore);

+

+  // Player3:

+  AddByStatics(4, Theme.Sing.StaticP3RScoreBG, Theme.Sing.StaticP3RScoreBG, Theme.Sing.TextP3RScore);

+end;

+

+//-----------

+//Spawns a new Line Bonus PopUp for the Player

+//-----------

+Procedure TSingScores.SpawnPopUp(const PlayerIndex: Byte; const Rating: Byte; const Score: Word);

+var Cur: PScorePopUp;

+begin

+  Log.LogError('Spawn PopUp: Score: ' + InttoStr(Score));

+  if (PlayerIndex < PlayerCount) then

+  begin

+    //Get Memory and Add Data

+    GetMem(Cur, SizeOf(TScorePopUp));

+

+    Cur.Player  := PlayerIndex;

+    Cur.TimeStamp := SDL_GetTicks;

+    Cur.Rating    := Rating;

+    Cur.ScoreGiven:= 0;

+    If (Players[PlayerIndex].Score < Score) then

+    begin

+      Cur.ScoreDiff := Score - Players[PlayerIndex].Score;

+      aPlayers[PlayerIndex].Score := Score;

+    end

+    else

+      Cur.ScoreDiff := 0;

+    Cur.Next := nil;

+

+    //Log.LogError('TSingScores.SpawnPopUp| Player: ' + InttoStr(PlayerIndex) + ', Score: ' + InttoStr(Score) + ', ScoreDiff: ' + InttoStr(Cur.ScoreDiff));

+

+    //Add it to the Chain

+    if (FirstPopUp = nil) then

+      //the first PopUp in the List

+      FirstPopUp := Cur

+    else

+    //second or earlier popup

+      LastPopUp.Next := Cur;

+

+    //Set new Popup to Last PopUp in the List

+    LastPopUp := Cur;

+  end

+  else

+    Log.LogError('TSingScores: Try to add PopUp for not existing player');

+end;

+

+//-----------

+// Removes a PopUp w/o destroying the List

+//-----------

+Procedure TSingScores.KillPopUp(const last, cur: PScorePopUp);

+begin

+  //Give Player the Last Points that missing till now

+  aPlayers[Cur.Player].ScoreDisplayed := aPlayers[Cur.Player].ScoreDisplayed + Cur.ScoreDiff - Cur.ScoreGiven;

+

+  //If this is the First PopUp => Make Next PopUp the First

+  If (Cur = FirstPopUp) then

+    FirstPopUp := Cur.Next

+  //Else => Remove Curent Popup from Chain

+  else

+    Last.Next := Cur.Next;

+

+  //If this is the Last PopUp, Make PopUp before the Last

+  If (Cur = LastPopUp) then

+    LastPopUp := Last;

+

+  //Free the Memory

+  FreeMem(Cur, SizeOf(TScorePopUp));

+end;

+

+//-----------

+//Removes all PopUps from Mem

+//-----------

+Procedure TSingScores.KillAllPopUps;

+var

+  Cur:  PScorePopUp;

+  Last: PScorePopUp;

+begin

+  Cur := FirstPopUp;

+

+  //Remove all PopUps:

+  While (Cur <> nil) do

+  begin

+    Last := Cur;

+    Cur  := Cur.Next;

+    FreeMem(Last, SizeOf(TScorePopUp));

+  end;

+

+  FirstPopUp := nil;

+  LastPopUp := nil;

+end;

+

+//-----------

+//Init - has to be called after Positions and Players have been added, before first call of Draw

+//It gives every Player a Score Position

+//-----------

+Procedure TSingScores.Init;

+var

+  PlC: Array [0..1] of Byte; //Playercount First Screen and Second Screen

+  I, J: Integer;

+  MaxPlayersperScreen: Byte;

+  CurPlayer:           Byte;

+

+  Function GetPositionCountbyPlayerCount(bPlayerCount: Byte): Byte;

+  var I: Integer;

+  begin

+    Result := 0;

+    bPlayerCount := 1 shl (bPlayerCount - 1);

+

+    For I := 0 to PositionCount-1 do

+    begin

+      If ((Positions[I].PlayerCount AND bPlayerCount) <> 0) then

+        Inc(Result);

+    end;

+  end;

+

+  Function GetPositionbyPlayernum(bPlayerCount, bPlayer: Byte): Byte;

+  var I: Integer;

+  begin

+    bPlayerCount := 1 shl (bPlayerCount - 1);

+    Result := High(Byte);

+

+    For I := 0 to PositionCount-1 do

+    begin

+      If ((Positions[I].PlayerCount AND bPlayerCount) <> 0) then

+      begin

+        If (bPlayer = 0) then

+        begin

+          Result := I;

+          Break;

+        end

+        else

+          Dec(bPlayer);

+      end;

+    end;

+  end;

+

+begin

+

+  For I := 1 to 6 do

+  begin

+    //If there are enough Positions -> Write to MaxPlayers

+    If (GetPositionCountbyPlayerCount(I) = I) then

+      MaxPlayersperScreen := I

+    else

+      Break;

+  end;

+

+

+  //Split Players to both Screen or Display on One Screen

+  if (Screens = 2) and (MaxPlayersperScreen < PlayerCount) then

+  begin

+    PlC[0] := PlayerCount div 2 + PlayerCount mod 2;

+    PlC[1] := PlayerCount div 2;

+  end

+  else

+  begin

+    PlC[0] := PlayerCount;

+    PlC[1] := 0;

+  end;

+

+

+  //Check if there are enough Positions for all Players

+  For I := 0 to Screens - 1 do

+  begin

+    if (PlC[I] > MaxPlayersperScreen) then

+    begin

+      PlC[I] := MaxPlayersperScreen;

+      Log.LogError('More Players than available Positions, TSingScores');

+    end;

+  end;

+  

+  CurPlayer := 0;

+  //Give every Player a Position

+  For I := 0 to Screens - 1 do

+    For J := 0 to PlC[I]-1 do

+    begin

+      aPlayers[CurPlayer].Position := GetPositionbyPlayernum(PlC[I], J) OR (I shl 7);

+      //Log.LogError('Player ' + InttoStr(CurPlayer) + ' gets Position: ' + InttoStr(aPlayers[CurPlayer].Position));

+      Inc(CurPlayer);

+    end;

+end;

+

+//-----------

+//Procedure Draws Scores and Linebonus PopUps

+//-----------

+Procedure TSingScores.Draw;

+var

+  I: Integer;

+  CurTime: Cardinal;

+  CurPopUp, LastPopUp: PScorePopUp;

+begin

+  CurTime := SDL_GetTicks;

+  

+  //Draw Popups

+  LastPopUp := nil;

+  CurPopUp  := FirstPopUp;

+  

+  While (CurPopUp <> nil) do

+  begin

+    if (CurTime - CurPopUp.TimeStamp > Settings.Phase1Time + Settings.Phase2Time + Settings.Phase3Time) then

+    begin

+      KillPopUp(LastPopUp, CurPopUp);

+      if (LastPopUp = nil) then

+        CurPopUp := FirstPopUp

+      else

+        CurPopUp  := LastPopUp.Next;

+    end

+    else

+    begin

+      DrawPopUp(CurPopUp);

+      LastPopUp := CurPopUp;

+      CurPopUp  := LastPopUp.Next;

+    end;

+  end;

+

+

+  //Draw Players

+  For I := 0 to PlayerCount-1 do

+  begin

+    DrawScore(I);

+  end;

+end;

+

+//-----------

+//Procedure Draws a Popup by Pointer

+//-----------

+Procedure TSingScores.DrawPopUp(const PopUp: PScorePopUp);

+var

+  Progress: Real;

+  CurTime:  Cardinal;

+  X, Y, W, H, Alpha: Real;

+  FontSize: Byte;

+  TimeDiff: Cardinal;

+  PIndex:   Byte;

+  TextLen:  Real;

+  ScoretoAdd: Word;

+  PosDiff:  Real;

+begin

+  if (PopUp <> nil) then

+  begin

+    //Only Draw if Player has a Position

+    PIndex := Players[PopUp.Player].Position;

+    If PIndex <> high(byte) then

+    begin

+      //Only Draw if Player is on Cur Screen

+      If ((Players[PopUp.Player].Position AND 128) = 0) = (ScreenAct = 1) then

+      begin

+        CurTime := SDL_GetTicks;

+        TimeDiff := CurTime - PopUp.TimeStamp;

+

+        //Get Position of PopUp

+        PIndex := PIndex AND 127;

+

+    

+        //Check for Phase ...

+        If (TimeDiff <= Settings.Phase1Time) then

+        begin

+          //Phase 1 - The Ploping up

+          Progress := TimeDiff / Settings.Phase1Time;

+

+

+          W := Positions[PIndex].PUW * Sin(Progress/2*Pi);

+          H := Positions[PIndex].PUH * Sin(Progress/2*Pi);

+

+          X := Positions[PIndex].PUStartX + (Positions[PIndex].PUW - W)/2;

+          Y := Positions[PIndex].PUStartY + (Positions[PIndex].PUH - H)/2;

+

+          FontSize := Round(Progress * Positions[PIndex].PUFontSize);

+          Alpha := 1;

+        end

+

+        Else If (TimeDiff <= Settings.Phase2Time + Settings.Phase1Time) then

+        begin

+          //Phase 2 - The Moving

+          Progress := (TimeDiff - Settings.Phase1Time) / Settings.Phase2Time;

+

+          W := Positions[PIndex].PUW;

+          H := Positions[PIndex].PUH;

+

+          PosDiff := Positions[PIndex].PUTargetX - Positions[PIndex].PUStartX;

+          If PosDiff > 0 then

+            PosDiff := PosDiff + W;

+          X := Positions[PIndex].PUStartX + PosDiff * sqr(Progress);

+

+          PosDiff := Positions[PIndex].PUTargetY - Positions[PIndex].PUStartY;

+          If PosDiff < 0 then

+            PosDiff := PosDiff + Positions[PIndex].BGH;

+          Y := Positions[PIndex].PUStartY + PosDiff * sqr(Progress);

+

+          FontSize := Positions[PIndex].PUFontSize;

+          Alpha := 1 - 0.3 * Progress;

+        end

+

+        else

+        begin

+          //Phase 3 - The Fading out + Score adding

+          Progress := (TimeDiff - Settings.Phase1Time - Settings.Phase2Time) / Settings.Phase3Time;

+

+          If (PopUp.Rating > 0) then

+          begin

+            //Add Scores

+            ScoreToAdd := Round(PopUp.ScoreDiff * Progress) - PopUp.ScoreGiven;

+            Inc(PopUp.ScoreGiven, ScoreToAdd);

+            aPlayers[PopUp.Player].ScoreDisplayed := Players[PopUp.Player].ScoreDisplayed + ScoreToAdd;

+

+            //Set Positions etc.

+            Alpha    := 0.7 - 0.7 * Progress;

+

+            W := Positions[PIndex].PUW;

+            H := Positions[PIndex].PUH;

+

+            PosDiff := Positions[PIndex].PUTargetX - Positions[PIndex].PUStartX;

+            If (PosDiff > 0) then

+              PosDiff := W

+            else

+              PosDiff := 0;

+            X := Positions[PIndex].PUTargetX + PosDiff * Progress;

+

+            PosDiff := Positions[PIndex].PUTargetY - Positions[PIndex].PUStartY;

+            If (PosDiff < 0) then

+              PosDiff := -Positions[PIndex].BGH

+            else

+              PosDiff := 0;

+            Y := Positions[PIndex].PUTargetY - PosDiff * (1-Progress);

+

+            FontSize := Positions[PIndex].PUFontSize;

+          end

+          else

+          begin

+            //Here the Effect that Should be shown if a PopUp without Score is Drawn

+            //And or Spawn with the GraphicObjects etc.

+            //Some Work for Blindy to do :P

+

+            //ATM: Just Let it Slide in the Scores just like the Normal PopUp

+            Alpha := 0;

+          end;

+        end;

+

+        //Draw PopUp

+

+        if (Alpha > 0) then

+        begin

+          //Draw BG:

+          glEnable(GL_TEXTURE_2D);

+          glEnable(GL_BLEND);

+          glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

+

+          glColor4f(1,1,1, Alpha);

+          glBindTexture(GL_TEXTURE_2D, Settings.PopUpTex[PopUp.Rating].TexNum);

+

+          glBegin(GL_QUADS);

+            glTexCoord2f(0, 0); glVertex2f(X, Y);

+            glTexCoord2f(0, Settings.PopUpTex[PopUp.Rating].TexH); glVertex2f(X, Y + H);

+            glTexCoord2f(Settings.PopUpTex[PopUp.Rating].TexW, Settings.PopUpTex[PopUp.Rating].TexH); glVertex2f(X + W, Y + H);

+            glTexCoord2f(Settings.PopUpTex[PopUp.Rating].TexW, 0); glVertex2f(X + W, Y);

+          glEnd;

+

+          glDisable(GL_TEXTURE_2D);

+          glDisable(GL_BLEND);

+

+          //Set FontStyle and Size

+          SetFontStyle(Positions[PIndex].PUFont);

+          SetFontItalic(False);

+          SetFontSize(FontSize);

+

+          //Draw Text

+          TextLen := glTextWidth(PChar(Theme.Sing.LineBonusText[PopUp.Rating]));

+

+          //Color and Pos

+          SetFontPos (X + (W - TextLen) / 2, Y + 12);

+          glColor4f(1, 1, 1, Alpha);

+

+          //Draw

+          glPrint(PChar(Theme.Sing.LineBonusText[PopUp.Rating]));

+        end; //eo Alpha check

+      end; //eo Right Screen

+    end; //eo Player has Position

+  end

+  else

+    Log.LogError('TSingScores: Try to Draw a not existing PopUp');

+end;

+

+//-----------

+//Procedure Draws a Score by Playerindex

+//-----------

+Procedure TSingScores.DrawScore(const Index: Integer);

+var

+  Position: PScorePosition;

+  ScoreStr: String;

+begin

+  //Only Draw if Player has a Position

+  If Players[Index].Position <> high(byte) then

+  begin

+    //Only Draw if Player is on Cur Screen

+    If ((Players[Index].Position AND 128) = 0) = (ScreenAct = 1) then

+    begin

+      Position := @Positions[Players[Index].Position and 127];

+

+      //Draw ScoreBG

+      glEnable(GL_TEXTURE_2D);

+      glEnable(GL_BLEND);

+      glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

+

+      glColor4f(1,1,1, 1);

+      glBindTexture(GL_TEXTURE_2D, Players[Index].ScoreBG.TexNum);

+

+      glBegin(GL_QUADS);

+        glTexCoord2f(0, 0); glVertex2f(Position.BGX, Position.BGY);

+        glTexCoord2f(0, Players[Index].ScoreBG.TexH); glVertex2f(Position.BGX, Position.BGY + Position.BGH);

+        glTexCoord2f(Players[Index].ScoreBG.TexW, Players[Index].ScoreBG.TexH); glVertex2f(Position.BGX + Position.BGW, Position.BGY + Position.BGH);

+        glTexCoord2f(Players[Index].ScoreBG.TexW, 0); glVertex2f(Position.BGX + Position.BGW, Position.BGY);

+      glEnd;

+

+      glDisable(GL_TEXTURE_2D);

+      glDisable(GL_BLEND);

+

+      //Draw Score Text

+      SetFontStyle(Position.TextFont);

+      SetFontItalic(False);

+      SetFontSize(Position.TextSize);

+      SetFontPos(Position.TextX, Position.TextY);

+

+      ScoreStr := InttoStr(Players[Index].ScoreDisplayed div 10) + '0';

+      While (Length(ScoreStr) < 5) do

+        ScoreStr := '0' + ScoreStr;

+

+      glPrint(PChar(ScoreStr));

+

+    end; //eo Right Screen

+  end; //eo Player has Position

+end;

+

+end.

diff --git a/Game/Code/Screens/UScreenSing.pas b/Game/Code/Screens/UScreenSing.pas
index ff6bfe20..b953cc07 100644
--- a/Game/Code/Screens/UScreenSing.pas
+++ b/Game/Code/Screens/UScreenSing.pas
@@ -28,7 +28,8 @@ uses UMenu,
      UThemes,

      ULCD,

      UGraphicClasses,

-     UVideo;

+     UVideo,

+     USingScores;

 

 type

   TScreenSing = class(TMenu)

@@ -45,46 +46,51 @@ type
       //eoa TimeBar mod

 

       StaticP1:           integer;

-      StaticP1ScoreBG:    integer;

       TextP1:             integer;

-      TextP1Score:        integer;

+      {StaticP1ScoreBG:    integer;

+      TextP1Score:        integer;}

 

-      //moveable singbar mod

+      {//moveable singbar mod

       StaticP1SingBar:         integer;

       StaticP1ThreePSingBar:   integer;

       StaticP1TwoPSingBar:     integer;

       StaticP2RSingBar:        integer;

       StaticP2MSingBar:        integer;

       StaticP3SingBar:         integer;

-      //eoa moveable singbar

+      //eoa moveable singbar }

 

       //Added for ps3 skin

       //shown when game is in 2/4 player modus

       StaticP1TwoP:           integer;

-      StaticP1TwoPScoreBG:    integer;

       TextP1TwoP:             integer;

-      TextP1TwoPScore:        integer;

+

+      {StaticP1TwoPScoreBG:    integer;

+      TextP1TwoPScore:        integer;}

       //shown when game is in 3/6 player modus

       StaticP1ThreeP:           integer;

-      StaticP1ThreePScoreBG:    integer;

       TextP1ThreeP:             integer;

-      TextP1ThreePScore:        integer;

+

+      {TextP1ThreePScore:        integer;

+      StaticP1ThreePScoreBG:    integer;  }

       //eoa

 

       StaticP2R:          integer;

-      StaticP2RScoreBG:   integer;

       TextP2R:            integer;

-      TextP2RScore:       integer;

+

+      {StaticP2RScoreBG:   integer;

+      TextP2RScore:       integer;}

 

       StaticP2M:          integer;

-      StaticP2MScoreBG:   integer;

       TextP2M:            integer;

-      TextP2MScore:       integer;

+

+      {StaticP2MScoreBG:   integer;

+      TextP2MScore:       integer; }

 

       StaticP3R:          integer;

-      StaticP3RScoreBG:   integer;

       TextP3R:            integer;

-      TextP3RScore:       integer;

+

+      {StaticP3RScoreBG:   integer;

+      TextP3RScore:       integer;}

 

       Tex_Background:     TTexture;

       FadeOut:            boolean;

@@ -92,6 +98,9 @@ type
 //      LyricSub:           TLyric;

       Lyrics:             TLyricEngine;

 

+      //Score Manager:

+      Scores: TSingScores;

+

       constructor Create; override;

       procedure onShow; override;

       procedure onShowFinish; override;

@@ -205,6 +214,10 @@ var
 begin

   inherited Create;

 

+  //Create Score Class

+  Scores := TSingScores.Create;

+  Scores.LoadfromTheme;

+

   LoadFromTheme(Theme.Sing);

 

   //TimeBar

@@ -213,45 +226,51 @@ begin
 

 // 1 player       | P1

   StaticP1              := AddStatic(Theme.Sing.StaticP1);

-  StaticP1ScoreBG       := AddStatic(Theme.Sing.StaticP1ScoreBG);

   TextP1                := AddText(Theme.Sing.TextP1);

+

+  {StaticP1ScoreBG       := AddStatic(Theme.Sing.StaticP1ScoreBG);

   TextP1Score           := AddText(Theme.Sing.TextP1Score);

-  StaticP1SingBar       := AddStatic(Theme.Sing.StaticP1SingBar);

+  StaticP1SingBar       := AddStatic(Theme.Sing.StaticP1SingBar);}

 

 // 2 or 4 players | P1

   StaticP1TwoP          := AddStatic(Theme.Sing.StaticP1TwoP);

-  StaticP1TwoPScoreBG   := AddStatic(Theme.Sing.StaticP1TwoPScoreBG);

   TextP1TwoP            := AddText(Theme.Sing.TextP1TwoP);

+

+  {StaticP1TwoPScoreBG   := AddStatic(Theme.Sing.StaticP1TwoPScoreBG);

   TextP1TwoPScore       := AddText(Theme.Sing.TextP1TwoPScore);

-  StaticP1TwoPSingBar   := AddStatic(Theme.Sing.StaticP2RSingBar);

+  StaticP1TwoPSingBar   := AddStatic(Theme.Sing.StaticP2RSingBar);}

 

   //              | P2

   StaticP2R             := AddStatic(Theme.Sing.StaticP2R);

-  StaticP2RScoreBG      := AddStatic(Theme.Sing.StaticP2RScoreBG);

   TextP2R               := AddText(Theme.Sing.TextP2R);

+

+  {StaticP2RScoreBG      := AddStatic(Theme.Sing.StaticP2RScoreBG);

   TextP2RScore          := AddText(Theme.Sing.TextP2RScore);

-  StaticP2RSingBar      := AddStatic(Theme.Sing.StaticP2RSingBar);

+  StaticP2RSingBar      := AddStatic(Theme.Sing.StaticP2RSingBar); }

 

 // 3 or 6 players | P1

   StaticP1ThreeP        := AddStatic(Theme.Sing.StaticP1ThreeP);

-  StaticP1ThreePScoreBG := AddStatic(Theme.Sing.StaticP1ThreePScoreBG);

   TextP1ThreeP          := AddText(Theme.Sing.TextP1ThreeP);

+

+  {StaticP1ThreePScoreBG := AddStatic(Theme.Sing.StaticP1ThreePScoreBG);

   TextP1ThreePScore     := AddText(Theme.Sing.TextP1ThreePScore);

-  StaticP1ThreePSingBar := AddStatic(Theme.Sing.StaticP1ThreePSingBar);

+  StaticP1ThreePSingBar := AddStatic(Theme.Sing.StaticP1ThreePSingBar);}

 

   //              | P2

   StaticP2M             := AddStatic(Theme.Sing.StaticP2M);

-  StaticP2MScoreBG      := AddStatic(Theme.Sing.StaticP2MScoreBG);

   TextP2M               := AddText(Theme.Sing.TextP2M);

+

+  {StaticP2MScoreBG      := AddStatic(Theme.Sing.StaticP2MScoreBG);

   TextP2MScore          := AddText(Theme.Sing.TextP2MScore);

-  StaticP2MSingBar      := AddStatic(Theme.Sing.StaticP2MSingBar);

+  StaticP2MSingBar      := AddStatic(Theme.Sing.StaticP2MSingBar);}

 

   //              | P3

   StaticP3R             := AddStatic(Theme.Sing.StaticP3R);

-  StaticP3RScoreBG      := AddStatic(Theme.Sing.StaticP3RScoreBG);

   TextP3R               := AddText(Theme.Sing.TextP3R);

+

+  {StaticP3RScoreBG      := AddStatic(Theme.Sing.StaticP3RScoreBG);

   TextP3RScore          := AddText(Theme.Sing.TextP3RScore);

-  StaticP3SingBar       := AddStatic(Theme.Sing.StaticP3SingBar);

+  StaticP3SingBar       := AddStatic(Theme.Sing.StaticP3SingBar);}

 

   if ScreenAct = 2 then begin

       // katze und affe

@@ -273,10 +292,24 @@ var
   V2M:      boolean;

   V3R:      boolean;

   NR:       TRecR; //Line Bonus Mod

+

+  Color: TRGB;

 begin

   Log.LogStatus('Begin', 'onShow');

   FadeOut := false; // 0.5.0: early 0.5.0 problems were by this line commented

 

+  //SetUp Score Manager

+  Scores.ClearPlayers; //Clear Old Player Values

+  Color.R := 0; Color.G := 0; Color.B := 0; //Dummy atm

+  For P := 0 to PlayersPlay -1 do //Add new Ones

+  begin

+    Scores.AddPlayer(Tex_ScoreBG[P], Color);

+  end;

+

+  Scores.Init; //Get Positions for Players

+

+  

+

   // prepare players

   SetLength(Player, PlayersPlay);

 //  Player[0].ScoreTotalI := 0;

@@ -327,38 +360,44 @@ begin
 

   //This one is shown in 1P mode

   Static[StaticP1].Visible              := V1;

-  Static[StaticP1ScoreBG].Visible       := V1;

   Text[TextP1].Visible                  := V1;

-  Text[TextP1Score].Visible             := V1;

+

+  {Static[StaticP1ScoreBG].Visible       := V1;

+  Text[TextP1Score].Visible             := V1;}

 

 

   //This one is shown in 2/4P mode

   Static[StaticP1TwoP].Visible          := V1TwoP;

-  Static[StaticP1TwoPScoreBG].Visible   := V1TwoP;

   Text[TextP1TwoP].Visible              := V1TwoP;

-  Text[TextP1TwoPScore].Visible         := V1TwoP;

+

+  {Static[StaticP1TwoPScoreBG].Visible   := V1TwoP;

+  Text[TextP1TwoPScore].Visible         := V1TwoP;}

 

   Static[StaticP2R].Visible             := V2R;

-  Static[StaticP2RScoreBG].Visible      := V2R;

   Text[TextP2R].Visible                 := V2R;

-  Text[TextP2RScore].Visible            := V2R;

+

+  {Static[StaticP2RScoreBG].Visible      := V2R;

+  Text[TextP2RScore].Visible            := V2R;  }

 

 

   //This one is shown in 3/6P mode

   Static[StaticP1ThreeP].Visible        := V1ThreeP;

-  Static[StaticP1ThreePScoreBG].Visible := V1ThreeP;

   Text[TextP1ThreeP].Visible            := V1ThreeP;

-  Text[TextP1ThreePScore].Visible       := V1ThreeP;

+

+  {Static[StaticP1ThreePScoreBG].Visible := V1ThreeP;

+  Text[TextP1ThreePScore].Visible       := V1ThreeP; }

 

   Static[StaticP2M].Visible             := V2M;

-  Static[StaticP2MScoreBG].Visible      := V2M;

   Text[TextP2M].Visible                 := V2M;

-  Text[TextP2MScore].Visible            := V2M;

+

+  {Static[StaticP2MScoreBG].Visible      := V2M;

+  Text[TextP2MScore].Visible            := V2M; }

 

   Static[StaticP3R].Visible             := V3R;

-  Static[StaticP3RScoreBG].Visible      := V3R;

   Text[TextP3R].Visible                 := V3R;

-  Text[TextP3RScore].Visible            := V3R;

+

+  {Static[StaticP3RScoreBG].Visible      := V3R;

+  Text[TextP3RScore].Visible            := V3R; }

 

   // load notes

   ResetSingTemp;

@@ -559,7 +598,7 @@ begin
     GoldenRec.SentenceChange;

   //GoldenStarsTwinkle Mod End

 

-  //Set Position of Line Bonus - PhrasenBonus

+  {//Set Position of Line Bonus - PhrasenBonus

   if (Ini.LineBonus = 1) then //Show Line Bonus at Scores

   begin

   Case PlayersPlay of

@@ -790,7 +829,8 @@ begin
       Player[5].LineBonus_StartY  := 370 + 28;

     end;

   end;

-  end;

+  end; }

+  

   //Set Position of Line Bonus - PhrasenBonus End

   //Set Num of Empty Sentences for Phrasen Bonus

   NumEmptySentences := 0;

@@ -949,17 +989,19 @@ begin
 // okay this stuff appears again some lines beneath this one, I commented it out for testing what it does - seems like it's doing nothing

 // but I might be wrong, so what is this stuff here doing? O.o

   Static[StaticP1].Texture.X         := Static[StaticP1].Texture.X + 10*ScreenX;

-  Static[StaticP1ScoreBG].Texture.X  := Static[StaticP1ScoreBG].Texture.X + 10*ScreenX;

 

   Text[TextP1].X                     := Text[TextP1].X + 10*ScreenX;

-  Text[TextP1Score].X                := Text[TextP1Score].X + 10*ScreenX;

+

+  {Static[StaticP1ScoreBG].Texture.X  := Static[StaticP1ScoreBG].Texture.X + 10*ScreenX;

+  Text[TextP1Score].X                := Text[TextP1Score].X + 10*ScreenX;}

 

 

   Static[StaticP2R].Texture.X        := Static[StaticP2R].Texture.X + 10*ScreenX;

-  Static[StaticP2RScoreBG].Texture.X := Static[StaticP2RScoreBG].Texture.X + 10*ScreenX;

 

   Text[TextP2R].X                    := Text[TextP2R].X + 10*ScreenX;

-  Text[TextP2RScore].X               := Text[TextP2RScore].X + 10*ScreenX;

+

+  {Static[StaticP2RScoreBG].Texture.X := Static[StaticP2RScoreBG].Texture.X + 10*ScreenX;

+  Text[TextP2RScore].X               := Text[TextP2RScore].X + 10*ScreenX;}

 // end of weird stuff

 

  for S := 1 to 1 do              //wtf?

@@ -977,7 +1019,7 @@ begin
   if Sec < 10 then Text[TextTimeText].Text := Text[TextTimeText].Text + '0';

   Text[TextTimeText].Text := Text[TextTimeText].Text + IntToStr(Sec);

 

-  // .. and scores

+  {// .. and scores

   if PlayersPlay = 1 then begin

     Tekst := IntToStr(Player[0].ScoreTotalI);

     while Length(Tekst) < 5 do Tekst := '0' + Tekst;

@@ -1056,7 +1098,7 @@ begin
       while Length(Tekst) < 5 do Tekst := '0' + Tekst;

       Text[TextP3RScore].Text := Tekst;

     end;

-  end;

+  end;  }

 

   // draw static menu (BG)

   DrawBG;

@@ -1112,23 +1154,26 @@ begin
   GoldenRec.SpawnRec;

 //GoldenNoteStarsTwinkle Mod

 

+  //Draw Scores

+  Scores.Draw;

+

   // back stereo

 

 // weird stuff, maybe this is for "dual screen?", but where is player three then?

 // okay this stuff appears again some lines above this one, I commented it out for testing what it does - seems like it's doing nothing

 // but I might be wrong, so what is this stuff here doing? O.o

   Static[StaticP1].Texture.X         := Static[StaticP1].Texture.X - 10*ScreenX;

-  Static[StaticP1ScoreBG].Texture.X  := Static[StaticP1ScoreBG].Texture.X - 10*ScreenX;

-

   Text[TextP1].X                     := Text[TextP1].X - 10*ScreenX;

-  Text[TextP1Score].X                := Text[TextP1Score].X - 10*ScreenX;

 

+  {Static[StaticP1ScoreBG].Texture.X  := Static[StaticP1ScoreBG].Texture.X - 10*ScreenX;

+  Text[TextP1Score].X                := Text[TextP1Score].X - 10*ScreenX;}

 

-  Static[StaticP2R].Texture.X        := Static[StaticP2R].Texture.X - 10*ScreenX;

-  Static[StaticP2RScoreBG].Texture.X := Static[StaticP2RScoreBG].Texture.X - 10*ScreenX;

 

+  Static[StaticP2R].Texture.X        := Static[StaticP2R].Texture.X - 10*ScreenX;

   Text[TextP2R].X                    := Text[TextP2R].X - 10*ScreenX;

-  Text[TextP2RScore].X               := Text[TextP2RScore].X - 10*ScreenX;

+

+  {Static[StaticP2RScoreBG].Texture.X := Static[StaticP2RScoreBG].Texture.X - 10*ScreenX;

+  Text[TextP2RScore].X               := Text[TextP2RScore].X - 10*ScreenX;}

 //weird end

 

   for S := 1 to 1 do   // wtf?

@@ -1229,7 +1274,7 @@ begin
       //Update Total Score

       Player[I].ScoreTotalI := Player[I].ScoreI + Player[I].ScoreGoldenI + Player[I].ScoreLineI;

 

-      //Color

+      {//Color

       Case Floor(A) of

         0: begin

           Player[I].LineBonus_Color.R := 1;

@@ -1265,7 +1310,15 @@ begin
       Player[I].LineBonus_PosY  := Player[I].LineBonus_StartY;

       Player[I].LineBonus_Alpha := 0.92;

       Player[I].LineBonus_Visible := True;

-      Player[I].LineBonus_Age := 1;

+      Player[I].LineBonus_Age := 1;}

+

+      //Spawn PopUp

+      If (A >= 8) then

+        A := 8

+      else IF A < 0 then

+        A := 0;

+      //Round(Player[I].Score + Player[I].ScoreGolden - Player[I].ScoreLast + (1000 / (Length(Czesci[0].Czesc) - NumEmptySentences) * A / 8));

+      Scores.SpawnPopUp(I, Floor(A), Player[I].ScoreTotalI);

     end;

     //PhrasenBonus - Line Bonus Mod End// }

 

diff --git a/Game/Code/Screens/UScreenSingModi.pas b/Game/Code/Screens/UScreenSingModi.pas
index 455d7b40..44615662 100644
--- a/Game/Code/Screens/UScreenSingModi.pas
+++ b/Game/Code/Screens/UScreenSingModi.pas
@@ -1,4 +1,4 @@
-unit UScreenSingModi;
+unit UScreenSingModi;

 
 interface
 
@@ -158,456 +158,456 @@ begin
 end;
 
 procedure TScreenSingModi.onShow;
-var
-  I: Integer;
-begin
-
-  PlayersPlay := TeamInfo.NumTeams;
-
-  if DLLMan.Selected.LoadSong then //Start with Song
-  begin
-    inherited;
-  end
-  else //Start Without Song
-  begin
-    Music.CaptureStart;
-  end;
-
-//Set Playerinfo
-  PlayerInfo.NumPlayers := PlayersPlay;
-  for I := 0 to PlayerInfo.NumPlayers-1 do
-  begin
-    PlayerInfo.Playerinfo[I].Name    := PChar(Ini.Name[I]);
-    PlayerInfo.Playerinfo[I].Score   := 0;
-    PlayerInfo.Playerinfo[I].Bar     := 50;
-    PlayerInfo.Playerinfo[I].Enabled := True;
-  end;
-
-  for I := PlayerInfo.NumPlayers to high(PlayerInfo.Playerinfo) do
-  begin
-    PlayerInfo.Playerinfo[I].Score:=  0;
-    PlayerInfo.Playerinfo[I].Bar :=  0;
-    PlayerInfo.Playerinfo[I].Enabled := False;
-  end;
-
-  Case PlayersPlay of
-    1: begin
-      PlayerInfo.Playerinfo[0].PosX := Static[StaticP1ScoreBG].Texture.X;
-      PlayerInfo.Playerinfo[0].PosY := Static[StaticP1ScoreBG].Texture.Y + Static[StaticP1ScoreBG].Texture.H;
-    end;
-    2,4: begin
-      PlayerInfo.Playerinfo[0].PosX := Static[StaticP1TwoPScoreBG].Texture.X;
-      PlayerInfo.Playerinfo[0].PosY := Static[StaticP1TwoPScoreBG].Texture.Y + Static[StaticP1TwoPScoreBG].Texture.H;
-      PlayerInfo.Playerinfo[2].PosX := Static[StaticP1TwoPScoreBG].Texture.X;
-      PlayerInfo.Playerinfo[2].PosY := Static[StaticP1TwoPScoreBG].Texture.Y + Static[StaticP1TwoPScoreBG].Texture.H;
-      PlayerInfo.Playerinfo[1].PosX := Static[StaticP2RScoreBG].Texture.X;
-      PlayerInfo.Playerinfo[1].PosY := Static[StaticP2RScoreBG].Texture.Y + Static[StaticP2RScoreBG].Texture.H;
-      PlayerInfo.Playerinfo[3].PosX := Static[StaticP2RScoreBG].Texture.X;
-      PlayerInfo.Playerinfo[3].PosY := Static[StaticP2RScoreBG].Texture.Y + Static[StaticP2RScoreBG].Texture.H;
-    end;
-    3,6: begin
-      PlayerInfo.Playerinfo[0].PosX := Static[StaticP1ThreePScoreBG].Texture.X;
-      PlayerInfo.Playerinfo[0].PosY := Static[StaticP1ThreePScoreBG].Texture.Y + Static[StaticP1ThreePScoreBG].Texture.H;
-      PlayerInfo.Playerinfo[3].PosX := Static[StaticP1ThreePScoreBG].Texture.X;
-      PlayerInfo.Playerinfo[3].PosY := Static[StaticP1ThreePScoreBG].Texture.Y + Static[StaticP1ThreePScoreBG].Texture.H;
-      PlayerInfo.Playerinfo[1].PosX := Static[StaticP2MScoreBG].Texture.X;
-      PlayerInfo.Playerinfo[1].PosY := Static[StaticP2MScoreBG].Texture.Y + Static[StaticP2MScoreBG].Texture.H;
-      PlayerInfo.Playerinfo[4].PosX := Static[StaticP2MScoreBG].Texture.X;
-      PlayerInfo.Playerinfo[4].PosY := Static[StaticP2MScoreBG].Texture.Y + Static[StaticP2MScoreBG].Texture.H;
-      PlayerInfo.Playerinfo[2].PosX := Static[StaticP3RScoreBG].Texture.X;
-      PlayerInfo.Playerinfo[2].PosY := Static[StaticP3RScoreBG].Texture.Y + Static[StaticP3RScoreBG].Texture.H;
-      PlayerInfo.Playerinfo[5].PosX := Static[StaticP3RScoreBG].Texture.X;
-      PlayerInfo.Playerinfo[5].PosY := Static[StaticP3RScoreBG].Texture.Y + Static[StaticP3RScoreBG].Texture.H;
-    end;
-  end;
-
-  // play music (I)
-  //Music.CaptureStart;
-  //Music.MoveTo(AktSong.Start);
-
-  //Init Plugin
-  if not DLLMan.PluginInit(TeamInfo, PlayerInfo, ToSentences(Czesci[0]), LoadTex, Print, LoadSound, PlaySound) then
-  begin
-    //Fehler
-    Log.LogError('Could not Init Plugin');
-    Halt;
-  end;
-
-  // Set Background (Little Workaround, maybe change sometime)
-  if (DLLMan.Selected.LoadBack) AND (DLLMan.Selected.LoadSong) then
-    ScreenSing.Tex_Background := Tex_Background;
-
-  Winner := 0;
-
-  //Set Score Visibility
-  if PlayersPlay = 1 then begin
-    Text[TextP1Score].Visible := DLLMan.Selected.ShowScore;
-    Static[StaticP1ScoreBG].Visible := DLLMan.Selected.ShowScore;
-  end;
-
-  if (PlayersPlay = 2) OR (PlayersPlay = 4) then begin
-    Text[TextP1TwoPScore].Visible := DLLMan.Selected.ShowScore;
-    Static[StaticP1TwoPScoreBG].Visible := DLLMan.Selected.ShowScore;
-
-    Text[TextP2RScore].Visible := DLLMan.Selected.ShowScore;
-    Static[StaticP2RScoreBG].Visible := DLLMan.Selected.ShowScore;
-  end;
-
-  if (PlayersPlay = 3) OR (PlayersPlay = 6) then begin
-    Text[TextP1ThreePScore].Visible := DLLMan.Selected.ShowScore;
-    Static[StaticP1ThreePScoreBG].Visible := DLLMan.Selected.ShowScore;
-
-    Text[TextP2MScore].Visible := DLLMan.Selected.ShowScore;
-    Static[StaticP2MScoreBG].Visible := DLLMan.Selected.ShowScore;
-
-    Text[TextP3RScore].Visible := DLLMan.Selected.ShowScore;
-    Static[StaticP3RScoreBG].Visible := DLLMan.Selected.ShowScore;
-  end;
-end;
-
-function TScreenSingModi.Draw: boolean;
-var
-  Min:    integer;
-  Sec:    integer;
-  Tekst:  string;
-  S, I:      integer;
-  T:      integer;
-begin
-//Set Playerinfo
-  PlayerInfo.NumPlayers := PlayersPlay;
-  for I := 0 to PlayerInfo.NumPlayers-1 do
-  begin
-    PlayerInfo.Playerinfo[I].Name := PChar(Player[I].Name);
-    if PlayerInfo.Playerinfo[I].Enabled then
-    begin
-      if (Player[I].ScoreTotalI<=10000) then
-        PlayerInfo.Playerinfo[I].Score:=  Player[I].ScoreTotalI;
-      PlayerInfo.Playerinfo[I].Bar :=  Player[I].ScorePercent;
-    end;
-  end;
-
-//Show Score
-if DLLMan.Selected.ShowScore then
-begin
-  //ScoreBG Mod
-  // set player colors
-  if PlayersPlay = 4 then begin
-    if ScreenAct = 1 then begin
-      LoadColor(Static[StaticP1TwoP].Texture.ColR, Static[StaticP1TwoP].Texture.ColG,
-      Static[StaticP1TwoP].Texture.ColB, 'P1Dark');
-      LoadColor(Static[StaticP2R].Texture.ColR, Static[StaticP2R].Texture.ColG,
-      Static[StaticP2R].Texture.ColB, 'P2Dark');
-
-
-
-      LoadColor(Static[StaticP1TwoPScoreBG].Texture.ColR, Static[StaticP1TwoPScoreBG].Texture.ColG,
-      Static[StaticP1TwoPScoreBG].Texture.ColB, 'P1Dark');
-      LoadColor(Static[StaticP2RScoreBG].Texture.ColR, Static[StaticP2RScoreBG].Texture.ColG,
-      Static[StaticP2RScoreBG].Texture.ColB, 'P2Dark');
-
-
-
-    end;
-    if ScreenAct = 2 then begin
-      LoadColor(Static[StaticP1TwoP].Texture.ColR, Static[StaticP1TwoP].Texture.ColG,
-        Static[StaticP1TwoP].Texture.ColB, 'P3Dark');
-      LoadColor(Static[StaticP2R].Texture.ColR, Static[StaticP2R].Texture.ColG,
-        Static[StaticP2R].Texture.ColB, 'P4Dark');
-
-
-
-      LoadColor(Static[StaticP1TwoPScoreBG].Texture.ColR, Static[StaticP1TwoPScoreBG].Texture.ColG,
-        Static[StaticP1TwoPScoreBG].Texture.ColB, 'P3Dark');
-      LoadColor(Static[StaticP2RScoreBG].Texture.ColR, Static[StaticP2RScoreBG].Texture.ColG,
-        Static[StaticP2RScoreBG].Texture.ColB, 'P4Dark');
-
-
-
-     end;
-  end;
-
-  if PlayersPlay = 6 then begin
-    if ScreenAct = 1 then begin
-      LoadColor(Static[StaticP1ThreeP].Texture.ColR, Static[StaticP1ThreeP].Texture.ColG,
-        Static[StaticP1ThreeP].Texture.ColB, 'P1Dark');
-      LoadColor(Static[StaticP2M].Texture.ColR, Static[StaticP2M].Texture.ColG,
-        Static[StaticP2R].Texture.ColB, 'P2Dark');
-      LoadColor(Static[StaticP3R].Texture.ColR, Static[StaticP3R].Texture.ColG,
-        Static[StaticP3R].Texture.ColB, 'P3Dark');
-
-
-
-      LoadColor(Static[StaticP1ThreePScoreBG].Texture.ColR, Static[StaticP1ThreePScoreBG].Texture.ColG,
-        Static[StaticP1ThreePScoreBG].Texture.ColB, 'P1Dark');
-      LoadColor(Static[StaticP2MScoreBG].Texture.ColR, Static[StaticP2MScoreBG].Texture.ColG,
-        Static[StaticP2RScoreBG].Texture.ColB, 'P2Dark');
-      LoadColor(Static[StaticP3RScoreBG].Texture.ColR, Static[StaticP3RScoreBG].Texture.ColG,
-        Static[StaticP3RScoreBG].Texture.ColB, 'P3Dark');
-
-
-
-    end;
-    if ScreenAct = 2 then begin
-      LoadColor(Static[StaticP1ThreeP].Texture.ColR, Static[StaticP1ThreeP].Texture.ColG,
-        Static[StaticP1ThreeP].Texture.ColB, 'P4Dark');
-      LoadColor(Static[StaticP2M].Texture.ColR, Static[StaticP2M].Texture.ColG,
-        Static[StaticP2R].Texture.ColB, 'P5Dark');
-      LoadColor(Static[StaticP3R].Texture.ColR, Static[StaticP3R].Texture.ColG,
-        Static[StaticP3R].Texture.ColB, 'P6Dark');
-
-
-
-
-      LoadColor(Static[StaticP1ThreePScoreBG].Texture.ColR, Static[StaticP1ThreePScoreBG].Texture.ColG,
-        Static[StaticP1ThreePScoreBG].Texture.ColB, 'P4Dark');
-      LoadColor(Static[StaticP2MScoreBG].Texture.ColR, Static[StaticP2MScoreBG].Texture.ColG,
-        Static[StaticP2RScoreBG].Texture.ColB, 'P5Dark');
-      LoadColor(Static[StaticP3RScoreBG].Texture.ColR, Static[StaticP3RScoreBG].Texture.ColG,
-        Static[StaticP3RScoreBG].Texture.ColB, 'P6Dark');
-
-
-
-
-    end;
-  end;
-  //end ScoreBG Mod
-
-// set player names (for 2 screens and only Singstar skin)
-  if ScreenAct = 1 then begin
-    Text[TextP1].Text       := 'P1';
-    Text[TextP1TwoP].Text   := 'P1'; // added for ps3 skin
-    Text[TextP1ThreeP].Text := 'P1'; // added for ps3 skin
-    Text[TextP2R].Text      := 'P2';
-    Text[TextP2M].Text      := 'P2';
-    Text[TextP3R].Text      := 'P3';
-  end;
-
-  if ScreenAct = 2 then begin
-    case PlayersPlay of
-      4:  begin
-            Text[TextP1TwoP].Text := 'P3';
-            Text[TextP2R].Text := 'P4';
-          end;
-      6:  begin
-            Text[TextP1ThreeP].Text := 'P4';
-            Text[TextP2M].Text := 'P5';
-            Text[TextP3R].Text := 'P6';
-          end;
-    end; // case
-  end; // if
-
-
-  // stereo   <- and where iss P2M? or P3?
-  Static[StaticP1].Texture.X := Static[StaticP1].Texture.X + 10*ScreenX;
-  Static[StaticP1ScoreBG].Texture.X := Static[StaticP1ScoreBG].Texture.X + 10*ScreenX;
-
-  Text[TextP1].X := Text[TextP1].X + 10*ScreenX;
-  Text[TextP1Score].X := Text[TextP1Score].X + 10*ScreenX;
-
-  Static[StaticP2R].Texture.X := Static[StaticP2R].Texture.X + 10*ScreenX;
-  Static[StaticP2RScoreBG].Texture.X := Static[StaticP2RScoreBG].Texture.X + 10*ScreenX;
-
-  Text[TextP2R].X := Text[TextP2R].X + 10*ScreenX;
-  Text[TextP2RScore].X := Text[TextP2RScore].X + 10*ScreenX;
-
-  // .. and scores
-  if PlayersPlay = 1 then begin
-    Tekst := IntToStr(Player[0].ScoreTotalI);
-    while Length(Tekst) < 5 do Tekst := '0' + Tekst;
-    Text[TextP1Score].Text := Tekst;
-  end;
-
-  if PlayersPlay = 2 then begin
-    Tekst := IntToStr(Player[0].ScoreTotalI);
-    while Length(Tekst) < 5 do Tekst := '0' + Tekst;
-    Text[TextP1TwoPScore].Text := Tekst;
-
-    Tekst := IntToStr(Player[1].ScoreTotalI);
-    while Length(Tekst) < 5 do Tekst := '0' + Tekst;
-    Text[TextP2RScore].Text := Tekst;
-  end;
-
-  if PlayersPlay = 3 then begin
-    Tekst := IntToStr(Player[0].ScoreTotalI);
-    while Length(Tekst) < 5 do Tekst := '0' + Tekst;
-    Text[TextP1ThreePScore].Text := Tekst;
-
-    Tekst := IntToStr(Player[1].ScoreTotalI);
-    while Length(Tekst) < 5 do Tekst := '0' + Tekst;
-    Text[TextP2MScore].Text := Tekst;
-
-    Tekst := IntToStr(Player[2].ScoreTotalI);
-    while Length(Tekst) < 5 do Tekst := '0' + Tekst;
-    Text[TextP3RScore].Text := Tekst;
-  end;
-
-  if PlayersPlay = 4 then begin
-    if ScreenAct = 1 then begin
-      Tekst := IntToStr(Player[0].ScoreTotalI);
-      while Length(Tekst) < 5 do Tekst := '0' + Tekst;
-      Text[TextP1TwoPScore].Text := Tekst;
-
-      Tekst := IntToStr(Player[1].ScoreTotalI);
-      while Length(Tekst) < 5 do Tekst := '0' + Tekst;
-      Text[TextP2RScore].Text := Tekst;
-    end;
-    if ScreenAct = 2 then begin
-      Tekst := IntToStr(Player[2].ScoreTotalI);
-      while Length(Tekst) < 5 do Tekst := '0' + Tekst;
-      Text[TextP1TwoPScore].Text := Tekst;
-
-      Tekst := IntToStr(Player[3].ScoreTotalI);
-      while Length(Tekst) < 5 do Tekst := '0' + Tekst;
-      Text[TextP2RScore].Text := Tekst;
-    end;
-  end;
-
-  if PlayersPlay = 6 then begin
-    if ScreenAct = 1 then begin
-      Tekst := IntToStr(Player[0].ScoreTotalI);
-      while Length(Tekst) < 5 do Tekst := '0' + Tekst;
-      Text[TextP1ThreePScore].Text := Tekst;
-
-      Tekst := IntToStr(Player[1].ScoreTotalI);
-      while Length(Tekst) < 5 do Tekst := '0' + Tekst;
-      Text[TextP2MScore].Text := Tekst;
-
-      Tekst := IntToStr(Player[2].ScoreTotalI);
-      while Length(Tekst) < 5 do Tekst := '0' + Tekst;
-      Text[TextP3RScore].Text := Tekst;
-    end;
-    if ScreenAct = 2 then begin
-      Tekst := IntToStr(Player[3].ScoreTotalI);
-      while Length(Tekst) < 5 do Tekst := '0' + Tekst;
-      Text[TextP1ThreePScore].Text := Tekst;
-
-      Tekst := IntToStr(Player[4].ScoreTotalI);
-      while Length(Tekst) < 5 do Tekst := '0' + Tekst;
-      Text[TextP2MScore].Text := Tekst;
-
-      Tekst := IntToStr(Player[5].ScoreTotalI);
-      while Length(Tekst) < 5 do Tekst := '0' + Tekst;
-      Text[TextP3RScore].Text := Tekst;
-    end;
-  end;
-
-end; //ShowScore
-
-  for S := 1 to 1 do
-    Static[S].Texture.X := Static[S].Texture.X + 10*ScreenX;
-
-  for T := 0 to 1 do
-    Text[T].X := Text[T].X + 10*ScreenX;
-
-if DLLMan.Selected.LoadSong then
-begin
-  // update static menu with time ...
-  Min := Round(Czas.Teraz) div 60;
-  Sec := Round(Czas.Teraz) mod 60;
-  Text[TextTimeText].Text := '';
-  if Min < 10 then Text[TextTimeText].Text := '0';
-  Text[TextTimeText].Text := Text[TextTimeText].Text + IntToStr(Min) + ':';
-  if Sec < 10 then Text[TextTimeText].Text := Text[TextTimeText].Text + '0';
-  Text[TextTimeText].Text := Text[TextTimeText].Text + IntToStr(Sec);
-end;
-
-  // draw static menu (BG)
-  DrawBG;
-
-  //Draw Background
-  if (DllMan.Selected.LoadSong) AND (DllMan.Selected.LoadBack) then
-    SingDrawBackground;
-
-  // comment by blindy: wo zum henker wird denn in diesem screen ein video abgespielt?
-  // update and draw movie
-  // <mog> wie wo wadd? also in der selben funktion in der uscreensing kommt des video in der zeile 995, oder was wollteste wissen? :X
-{  if ShowFinish and AktSong.VideoLoaded AND DllMan.Selected.LoadVideo then begin
-    UpdateSmpeg; // this only draws
-  end;}
-
-  // draw static menu (FG)
-  DrawFG;
-
-  if ShowFinish then begin
-    if DllMan.Selected.LoadSong then
-    begin
-      if (not Music.Finished) and ((AktSong.Finish = 0) or (Czas.Teraz*1000 <= AktSong.Finish)) then begin
-        //Pause Mod:
-        if not Paused then
-          Sing(Self);       // analyze song
-      end else begin
-        if not FadeOut then begin
-          Finish;
-          FadeOut := true;
-          FadeTo(@ScreenPartyScore);
-        end;
-      end;
-    end;
-  end;
-
-  // draw custom items
-  SingModiDraw(PlayerInfo);  // always draw
-
-  //GoldenNoteStarsTwinkle Mod
-    GoldenRec.SpawnRec;
-  //GoldenNoteStarsTwinkle Mod
-
-  //Update PlayerInfo
-  for I := 0 to PlayerInfo.NumPlayers-1 do
-  begin
-    if PlayerInfo.Playerinfo[I].Enabled then
-    begin
-      PlayerInfo.Playerinfo[I].Bar :=  Player[I].ScorePercent;
-      PlayerInfo.Playerinfo[I].Score := Player[I].ScoreTotalI;
-    end;
-  end;
-
-  if ((ShowFinish) AND (NOT Paused)) then
-  begin
-    if not DLLMan.PluginDraw(Playerinfo, Czesci[0].Akt) then
-    begin
-      if not FadeOut then begin
-          Finish;
-          FadeOut := true;
-          FadeTo(@ScreenPartyScore);
-      end;
-    end;   
-  end;
-
-  //Change PlayerInfo/Changeables
-  for I := 0 to PlayerInfo.NumPlayers-1 do
-  begin
-    if (Player[I].ScoreTotalI <> PlayerInfo.Playerinfo[I].Score) then
-    begin
-      //Player[I].ScoreTotal   := Player[I].ScoreTotal + (PlayerInfo.Playerinfo[I].Score - Player[I].ScoreTotalI);
-      Player[I].ScoreTotalI := PlayerInfo.Playerinfo[I].Score;
-    end;
-    if (PlayerInfo.Playerinfo[I].Bar <> Player[I].ScorePercent) then
-      Player[I].ScorePercentTarget := PlayerInfo.Playerinfo[I].Bar;
-  end;
-
-  // back stereo
-  Static[StaticP1].Texture.X := Static[StaticP1].Texture.X - 10*ScreenX;
-  Static[StaticP1ScoreBG].Texture.X := Static[StaticP1ScoreBG].Texture.X - 10*ScreenX;
-
-  Text[TextP1].X := Text[TextP1].X - 10*ScreenX;
-  Text[TextP1Score].X := Text[TextP1Score].X - 10*ScreenX;
-
-
-  Static[StaticP2R].Texture.X := Static[StaticP2R].Texture.X - 10*ScreenX;
-  Static[StaticP2RScoreBG].Texture.X := Static[StaticP2RScoreBG].Texture.X - 10*ScreenX;
-
-  Text[TextP2R].X := Text[TextP2R].X - 10*ScreenX;
-  Text[TextP2RScore].X := Text[TextP2RScore].X - 10*ScreenX;
-
-
-  for S := 1 to 1 do
-    Static[S].Texture.X := Static[S].Texture.X - 10*ScreenX;
-
-  for T := 0 to 1 do
-    Text[T].X := Text[T].X - 10*ScreenX;
-
-
+var

+  I: Integer;

+begin

+

+  PlayersPlay := TeamInfo.NumTeams;

+

+  if DLLMan.Selected.LoadSong then //Start with Song

+  begin

+    inherited;

+  end

+  else //Start Without Song

+  begin

+    Music.CaptureStart;

+  end;

+

+//Set Playerinfo

+  PlayerInfo.NumPlayers := PlayersPlay;

+  for I := 0 to PlayerInfo.NumPlayers-1 do

+  begin

+    PlayerInfo.Playerinfo[I].Name    := PChar(Ini.Name[I]);

+    PlayerInfo.Playerinfo[I].Score   := 0;

+    PlayerInfo.Playerinfo[I].Bar     := 50;

+    PlayerInfo.Playerinfo[I].Enabled := True;

+  end;

+

+  for I := PlayerInfo.NumPlayers to high(PlayerInfo.Playerinfo) do

+  begin

+    PlayerInfo.Playerinfo[I].Score:=  0;

+    PlayerInfo.Playerinfo[I].Bar :=  0;

+    PlayerInfo.Playerinfo[I].Enabled := False;

+  end;

+

+  {Case PlayersPlay of

+    1: begin

+      PlayerInfo.Playerinfo[0].PosX := Static[StaticP1ScoreBG].Texture.X;

+      PlayerInfo.Playerinfo[0].PosY := Static[StaticP1ScoreBG].Texture.Y + Static[StaticP1ScoreBG].Texture.H;

+    end;

+    2,4: begin

+      PlayerInfo.Playerinfo[0].PosX := Static[StaticP1TwoPScoreBG].Texture.X;

+      PlayerInfo.Playerinfo[0].PosY := Static[StaticP1TwoPScoreBG].Texture.Y + Static[StaticP1TwoPScoreBG].Texture.H;

+      PlayerInfo.Playerinfo[2].PosX := Static[StaticP1TwoPScoreBG].Texture.X;

+      PlayerInfo.Playerinfo[2].PosY := Static[StaticP1TwoPScoreBG].Texture.Y + Static[StaticP1TwoPScoreBG].Texture.H;

+      PlayerInfo.Playerinfo[1].PosX := Static[StaticP2RScoreBG].Texture.X;

+      PlayerInfo.Playerinfo[1].PosY := Static[StaticP2RScoreBG].Texture.Y + Static[StaticP2RScoreBG].Texture.H;

+      PlayerInfo.Playerinfo[3].PosX := Static[StaticP2RScoreBG].Texture.X;

+      PlayerInfo.Playerinfo[3].PosY := Static[StaticP2RScoreBG].Texture.Y + Static[StaticP2RScoreBG].Texture.H;

+    end;

+    3,6: begin

+      PlayerInfo.Playerinfo[0].PosX := Static[StaticP1ThreePScoreBG].Texture.X;

+      PlayerInfo.Playerinfo[0].PosY := Static[StaticP1ThreePScoreBG].Texture.Y + Static[StaticP1ThreePScoreBG].Texture.H;

+      PlayerInfo.Playerinfo[3].PosX := Static[StaticP1ThreePScoreBG].Texture.X;

+      PlayerInfo.Playerinfo[3].PosY := Static[StaticP1ThreePScoreBG].Texture.Y + Static[StaticP1ThreePScoreBG].Texture.H;

+      PlayerInfo.Playerinfo[1].PosX := Static[StaticP2MScoreBG].Texture.X;

+      PlayerInfo.Playerinfo[1].PosY := Static[StaticP2MScoreBG].Texture.Y + Static[StaticP2MScoreBG].Texture.H;

+      PlayerInfo.Playerinfo[4].PosX := Static[StaticP2MScoreBG].Texture.X;

+      PlayerInfo.Playerinfo[4].PosY := Static[StaticP2MScoreBG].Texture.Y + Static[StaticP2MScoreBG].Texture.H;

+      PlayerInfo.Playerinfo[2].PosX := Static[StaticP3RScoreBG].Texture.X;

+      PlayerInfo.Playerinfo[2].PosY := Static[StaticP3RScoreBG].Texture.Y + Static[StaticP3RScoreBG].Texture.H;

+      PlayerInfo.Playerinfo[5].PosX := Static[StaticP3RScoreBG].Texture.X;

+      PlayerInfo.Playerinfo[5].PosY := Static[StaticP3RScoreBG].Texture.Y + Static[StaticP3RScoreBG].Texture.H;

+    end;

+  end;       }

+

+  // play music (I)

+  //Music.CaptureStart;

+  //Music.MoveTo(AktSong.Start);

+

+  //Init Plugin

+  if not DLLMan.PluginInit(TeamInfo, PlayerInfo, ToSentences(Czesci[0]), LoadTex, Print, LoadSound, PlaySound) then

+  begin

+    //Fehler

+    Log.LogError('Could not Init Plugin');

+    Halt;

+  end;

+

+  // Set Background (Little Workaround, maybe change sometime)

+  if (DLLMan.Selected.LoadBack) AND (DLLMan.Selected.LoadSong) then

+    ScreenSing.Tex_Background := Tex_Background;

+

+  Winner := 0;

+

+  //Set Score Visibility

+  {if PlayersPlay = 1 then begin

+    Text[TextP1Score].Visible := DLLMan.Selected.ShowScore;

+    Static[StaticP1ScoreBG].Visible := DLLMan.Selected.ShowScore;

+  end;

+

+  if (PlayersPlay = 2) OR (PlayersPlay = 4) then begin

+    Text[TextP1TwoPScore].Visible := DLLMan.Selected.ShowScore;

+    Static[StaticP1TwoPScoreBG].Visible := DLLMan.Selected.ShowScore;

+

+    Text[TextP2RScore].Visible := DLLMan.Selected.ShowScore;

+    Static[StaticP2RScoreBG].Visible := DLLMan.Selected.ShowScore;

+  end;

+

+  if (PlayersPlay = 3) OR (PlayersPlay = 6) then begin

+    Text[TextP1ThreePScore].Visible := DLLMan.Selected.ShowScore;

+    Static[StaticP1ThreePScoreBG].Visible := DLLMan.Selected.ShowScore;

+

+    Text[TextP2MScore].Visible := DLLMan.Selected.ShowScore;

+    Static[StaticP2MScoreBG].Visible := DLLMan.Selected.ShowScore;

+

+    Text[TextP3RScore].Visible := DLLMan.Selected.ShowScore;

+    Static[StaticP3RScoreBG].Visible := DLLMan.Selected.ShowScore;

+  end; }

+end;

+

+function TScreenSingModi.Draw: boolean;

+var

+  Min:    integer;

+  Sec:    integer;

+  Tekst:  string;

+  S, I:      integer;

+  T:      integer;

+begin

+//Set Playerinfo

+  PlayerInfo.NumPlayers := PlayersPlay;

+  for I := 0 to PlayerInfo.NumPlayers-1 do

+  begin

+    PlayerInfo.Playerinfo[I].Name := PChar(Player[I].Name);

+    if PlayerInfo.Playerinfo[I].Enabled then

+    begin

+      if (Player[I].ScoreTotalI<=10000) then

+        PlayerInfo.Playerinfo[I].Score:=  Player[I].ScoreTotalI;

+      PlayerInfo.Playerinfo[I].Bar :=  Player[I].ScorePercent;

+    end;

+  end;

+

+//Show Score

+if DLLMan.Selected.ShowScore then

+begin

+  {//ScoreBG Mod

+  // set player colors

+  if PlayersPlay = 4 then begin

+    if ScreenAct = 1 then begin

+      LoadColor(Static[StaticP1TwoP].Texture.ColR, Static[StaticP1TwoP].Texture.ColG,

+      Static[StaticP1TwoP].Texture.ColB, 'P1Dark');

+      LoadColor(Static[StaticP2R].Texture.ColR, Static[StaticP2R].Texture.ColG,

+      Static[StaticP2R].Texture.ColB, 'P2Dark');

+

+

+

+      LoadColor(Static[StaticP1TwoPScoreBG].Texture.ColR, Static[StaticP1TwoPScoreBG].Texture.ColG,

+      Static[StaticP1TwoPScoreBG].Texture.ColB, 'P1Dark');

+      LoadColor(Static[StaticP2RScoreBG].Texture.ColR, Static[StaticP2RScoreBG].Texture.ColG,

+      Static[StaticP2RScoreBG].Texture.ColB, 'P2Dark');

+

+

+

+    end;

+    if ScreenAct = 2 then begin

+      LoadColor(Static[StaticP1TwoP].Texture.ColR, Static[StaticP1TwoP].Texture.ColG,

+        Static[StaticP1TwoP].Texture.ColB, 'P3Dark');

+      LoadColor(Static[StaticP2R].Texture.ColR, Static[StaticP2R].Texture.ColG,

+        Static[StaticP2R].Texture.ColB, 'P4Dark');

+

+

+

+      LoadColor(Static[StaticP1TwoPScoreBG].Texture.ColR, Static[StaticP1TwoPScoreBG].Texture.ColG,

+        Static[StaticP1TwoPScoreBG].Texture.ColB, 'P3Dark');

+      LoadColor(Static[StaticP2RScoreBG].Texture.ColR, Static[StaticP2RScoreBG].Texture.ColG,

+        Static[StaticP2RScoreBG].Texture.ColB, 'P4Dark');

+

+

+

+     end;

+  end;

+

+  if PlayersPlay = 6 then begin

+    if ScreenAct = 1 then begin

+      LoadColor(Static[StaticP1ThreeP].Texture.ColR, Static[StaticP1ThreeP].Texture.ColG,

+        Static[StaticP1ThreeP].Texture.ColB, 'P1Dark');

+      LoadColor(Static[StaticP2M].Texture.ColR, Static[StaticP2M].Texture.ColG,

+        Static[StaticP2R].Texture.ColB, 'P2Dark');

+      LoadColor(Static[StaticP3R].Texture.ColR, Static[StaticP3R].Texture.ColG,

+        Static[StaticP3R].Texture.ColB, 'P3Dark');

+

+

+

+      LoadColor(Static[StaticP1ThreePScoreBG].Texture.ColR, Static[StaticP1ThreePScoreBG].Texture.ColG,

+        Static[StaticP1ThreePScoreBG].Texture.ColB, 'P1Dark');

+      LoadColor(Static[StaticP2MScoreBG].Texture.ColR, Static[StaticP2MScoreBG].Texture.ColG,

+        Static[StaticP2RScoreBG].Texture.ColB, 'P2Dark');

+      LoadColor(Static[StaticP3RScoreBG].Texture.ColR, Static[StaticP3RScoreBG].Texture.ColG,

+        Static[StaticP3RScoreBG].Texture.ColB, 'P3Dark');

+

+

+

+    end;

+    if ScreenAct = 2 then begin

+      LoadColor(Static[StaticP1ThreeP].Texture.ColR, Static[StaticP1ThreeP].Texture.ColG,

+        Static[StaticP1ThreeP].Texture.ColB, 'P4Dark');

+      LoadColor(Static[StaticP2M].Texture.ColR, Static[StaticP2M].Texture.ColG,

+        Static[StaticP2R].Texture.ColB, 'P5Dark');

+      LoadColor(Static[StaticP3R].Texture.ColR, Static[StaticP3R].Texture.ColG,

+        Static[StaticP3R].Texture.ColB, 'P6Dark');

+

+

+

+

+      LoadColor(Static[StaticP1ThreePScoreBG].Texture.ColR, Static[StaticP1ThreePScoreBG].Texture.ColG,

+        Static[StaticP1ThreePScoreBG].Texture.ColB, 'P4Dark');

+      LoadColor(Static[StaticP2MScoreBG].Texture.ColR, Static[StaticP2MScoreBG].Texture.ColG,

+        Static[StaticP2RScoreBG].Texture.ColB, 'P5Dark');

+      LoadColor(Static[StaticP3RScoreBG].Texture.ColR, Static[StaticP3RScoreBG].Texture.ColG,

+        Static[StaticP3RScoreBG].Texture.ColB, 'P6Dark');

+

+

+

+

+    end;

+  end;

+  //end ScoreBG Mod }

+

+// set player names (for 2 screens and only Singstar skin)

+  if ScreenAct = 1 then begin

+    Text[TextP1].Text       := 'P1';

+    Text[TextP1TwoP].Text   := 'P1'; // added for ps3 skin

+    Text[TextP1ThreeP].Text := 'P1'; // added for ps3 skin

+    Text[TextP2R].Text      := 'P2';

+    Text[TextP2M].Text      := 'P2';

+    Text[TextP3R].Text      := 'P3';

+  end;

+

+  if ScreenAct = 2 then begin

+    case PlayersPlay of

+      4:  begin

+            Text[TextP1TwoP].Text := 'P3';

+            Text[TextP2R].Text := 'P4';

+          end;

+      6:  begin

+            Text[TextP1ThreeP].Text := 'P4';

+            Text[TextP2M].Text := 'P5';

+            Text[TextP3R].Text := 'P6';

+          end;

+    end; // case

+  end; // if

+

+

+  // stereo   <- and where iss P2M? or P3?

+  Static[StaticP1].Texture.X := Static[StaticP1].Texture.X + 10*ScreenX;

+  Text[TextP1].X := Text[TextP1].X + 10*ScreenX;

+

+  {Static[StaticP1ScoreBG].Texture.X := Static[StaticP1ScoreBG].Texture.X + 10*ScreenX;

+  Text[TextP1Score].X := Text[TextP1Score].X + 10*ScreenX;}

+

+  Static[StaticP2R].Texture.X := Static[StaticP2R].Texture.X + 10*ScreenX;

+  Text[TextP2R].X := Text[TextP2R].X + 10*ScreenX;

+

+  {Static[StaticP2RScoreBG].Texture.X := Static[StaticP2RScoreBG].Texture.X + 10*ScreenX;

+  Text[TextP2RScore].X := Text[TextP2RScore].X + 10*ScreenX;}

+

+  // .. and scores

+  {if PlayersPlay = 1 then begin

+    Tekst := IntToStr(Player[0].ScoreTotalI);

+    while Length(Tekst) < 5 do Tekst := '0' + Tekst;

+    Text[TextP1Score].Text := Tekst;

+  end;

+

+  if PlayersPlay = 2 then begin

+    Tekst := IntToStr(Player[0].ScoreTotalI);

+    while Length(Tekst) < 5 do Tekst := '0' + Tekst;

+    Text[TextP1TwoPScore].Text := Tekst;

+

+    Tekst := IntToStr(Player[1].ScoreTotalI);

+    while Length(Tekst) < 5 do Tekst := '0' + Tekst;

+    Text[TextP2RScore].Text := Tekst;

+  end;

+

+  if PlayersPlay = 3 then begin

+    Tekst := IntToStr(Player[0].ScoreTotalI);

+    while Length(Tekst) < 5 do Tekst := '0' + Tekst;

+    Text[TextP1ThreePScore].Text := Tekst;

+

+    Tekst := IntToStr(Player[1].ScoreTotalI);

+    while Length(Tekst) < 5 do Tekst := '0' + Tekst;

+    Text[TextP2MScore].Text := Tekst;

+

+    Tekst := IntToStr(Player[2].ScoreTotalI);

+    while Length(Tekst) < 5 do Tekst := '0' + Tekst;

+    Text[TextP3RScore].Text := Tekst;

+  end;

+

+  if PlayersPlay = 4 then begin

+    if ScreenAct = 1 then begin

+      Tekst := IntToStr(Player[0].ScoreTotalI);

+      while Length(Tekst) < 5 do Tekst := '0' + Tekst;

+      Text[TextP1TwoPScore].Text := Tekst;

+

+      Tekst := IntToStr(Player[1].ScoreTotalI);

+      while Length(Tekst) < 5 do Tekst := '0' + Tekst;

+      Text[TextP2RScore].Text := Tekst;

+    end;

+    if ScreenAct = 2 then begin

+      Tekst := IntToStr(Player[2].ScoreTotalI);

+      while Length(Tekst) < 5 do Tekst := '0' + Tekst;

+      Text[TextP1TwoPScore].Text := Tekst;

+

+      Tekst := IntToStr(Player[3].ScoreTotalI);

+      while Length(Tekst) < 5 do Tekst := '0' + Tekst;

+      Text[TextP2RScore].Text := Tekst;

+    end;

+  end;

+

+  if PlayersPlay = 6 then begin

+    if ScreenAct = 1 then begin

+      Tekst := IntToStr(Player[0].ScoreTotalI);

+      while Length(Tekst) < 5 do Tekst := '0' + Tekst;

+      Text[TextP1ThreePScore].Text := Tekst;

+

+      Tekst := IntToStr(Player[1].ScoreTotalI);

+      while Length(Tekst) < 5 do Tekst := '0' + Tekst;

+      Text[TextP2MScore].Text := Tekst;

+

+      Tekst := IntToStr(Player[2].ScoreTotalI);

+      while Length(Tekst) < 5 do Tekst := '0' + Tekst;

+      Text[TextP3RScore].Text := Tekst;

+    end;

+    if ScreenAct = 2 then begin

+      Tekst := IntToStr(Player[3].ScoreTotalI);

+      while Length(Tekst) < 5 do Tekst := '0' + Tekst;

+      Text[TextP1ThreePScore].Text := Tekst;

+

+      Tekst := IntToStr(Player[4].ScoreTotalI);

+      while Length(Tekst) < 5 do Tekst := '0' + Tekst;

+      Text[TextP2MScore].Text := Tekst;

+

+      Tekst := IntToStr(Player[5].ScoreTotalI);

+      while Length(Tekst) < 5 do Tekst := '0' + Tekst;

+      Text[TextP3RScore].Text := Tekst;

+    end;

+  end;   }

+

+end; //ShowScore

+

+  for S := 1 to 1 do

+    Static[S].Texture.X := Static[S].Texture.X + 10*ScreenX;

+

+  for T := 0 to 1 do

+    Text[T].X := Text[T].X + 10*ScreenX;

+

+if DLLMan.Selected.LoadSong then

+begin

+  // update static menu with time ...

+  Min := Round(Czas.Teraz) div 60;

+  Sec := Round(Czas.Teraz) mod 60;

+  Text[TextTimeText].Text := '';

+  if Min < 10 then Text[TextTimeText].Text := '0';

+  Text[TextTimeText].Text := Text[TextTimeText].Text + IntToStr(Min) + ':';

+  if Sec < 10 then Text[TextTimeText].Text := Text[TextTimeText].Text + '0';

+  Text[TextTimeText].Text := Text[TextTimeText].Text + IntToStr(Sec);

+end;

+

+  // draw static menu (BG)

+  DrawBG;

+

+  //Draw Background

+  if (DllMan.Selected.LoadSong) AND (DllMan.Selected.LoadBack) then

+    SingDrawBackground;

+

+  // comment by blindy: wo zum henker wird denn in diesem screen ein video abgespielt?

+  // update and draw movie

+  // <mog> wie wo wadd? also in der selben funktion in der uscreensing kommt des video in der zeile 995, oder was wollteste wissen? :X

+{  if ShowFinish and AktSong.VideoLoaded AND DllMan.Selected.LoadVideo then begin

+    UpdateSmpeg; // this only draws

+  end;}

+

+  // draw static menu (FG)

+  DrawFG;

+

+  if ShowFinish then begin

+    if DllMan.Selected.LoadSong then

+    begin

+      if (not Music.Finished) and ((AktSong.Finish = 0) or (Czas.Teraz*1000 <= AktSong.Finish)) then begin

+        //Pause Mod:

+        if not Paused then

+          Sing(Self);       // analyze song

+      end else begin

+        if not FadeOut then begin

+          Finish;

+          FadeOut := true;

+          FadeTo(@ScreenPartyScore);

+        end;

+      end;

+    end;

+  end;

+

+  // draw custom items

+  SingModiDraw(PlayerInfo);  // always draw

+

+  //GoldenNoteStarsTwinkle Mod

+    GoldenRec.SpawnRec;

+  //GoldenNoteStarsTwinkle Mod

+

+  //Update PlayerInfo

+  for I := 0 to PlayerInfo.NumPlayers-1 do

+  begin

+    if PlayerInfo.Playerinfo[I].Enabled then

+    begin

+      PlayerInfo.Playerinfo[I].Bar :=  Player[I].ScorePercent;

+      PlayerInfo.Playerinfo[I].Score := Player[I].ScoreTotalI;

+    end;

+  end;

+

+  if ((ShowFinish) AND (NOT Paused)) then

+  begin

+    if not DLLMan.PluginDraw(Playerinfo, Czesci[0].Akt) then

+    begin

+      if not FadeOut then begin

+          Finish;

+          FadeOut := true;

+          FadeTo(@ScreenPartyScore);

+      end;

+    end;   

+  end;

+

+  //Change PlayerInfo/Changeables

+  for I := 0 to PlayerInfo.NumPlayers-1 do

+  begin

+    if (Player[I].ScoreTotalI <> PlayerInfo.Playerinfo[I].Score) then

+    begin

+      //Player[I].ScoreTotal   := Player[I].ScoreTotal + (PlayerInfo.Playerinfo[I].Score - Player[I].ScoreTotalI);

+      Player[I].ScoreTotalI := PlayerInfo.Playerinfo[I].Score;

+    end;

+    if (PlayerInfo.Playerinfo[I].Bar <> Player[I].ScorePercent) then

+      Player[I].ScorePercentTarget := PlayerInfo.Playerinfo[I].Bar;

+  end;

+

+  // back stereo

+  Static[StaticP1].Texture.X := Static[StaticP1].Texture.X - 10*ScreenX;

+  Text[TextP1].X := Text[TextP1].X - 10*ScreenX;

+

+  {Static[StaticP1ScoreBG].Texture.X := Static[StaticP1ScoreBG].Texture.X - 10*ScreenX;

+  Text[TextP1Score].X := Text[TextP1Score].X - 10*ScreenX;}

+

+

+  Static[StaticP2R].Texture.X := Static[StaticP2R].Texture.X - 10*ScreenX;

+  Text[TextP2R].X := Text[TextP2R].X - 10*ScreenX;

+

+  {Static[StaticP2RScoreBG].Texture.X := Static[StaticP2RScoreBG].Texture.X - 10*ScreenX;

+  Text[TextP2RScore].X := Text[TextP2RScore].X - 10*ScreenX;}

+

+

+  for S := 1 to 1 do

+    Static[S].Texture.X := Static[S].Texture.X - 10*ScreenX;

+

+  for T := 0 to 1 do

+    Text[T].X := Text[T].X - 10*ScreenX;

+

+

 end;
 
 procedure TScreenSingModi.Finish;
@@ -667,3 +667,4 @@ begin
 end;
 
 end.
+>>>>>>> .r429

diff --git a/Game/Code/UltraStar.dpr b/Game/Code/UltraStar.dpr
index f7dd7e9b..6aafda26 100644
--- a/Game/Code/UltraStar.dpr
+++ b/Game/Code/UltraStar.dpr
@@ -92,12 +92,14 @@ uses
   UParty in 'Classes\UParty.pas',

   UPlaylist in 'Classes\UPlaylist.pas',

   UCommandLine  in 'Classes\UCommandLine.pas',

+  USingScores in 'Classes\USingScores.pas',

+  USingNotes in 'Classes\USingNotes.pas',

 

   //------------------------------

   //Includes - Video Support

   //------------------------------

   UVideo in 'Classes\UVideo.pas',

-  

+

   //------------------------------

   //Includes - Screens

   //------------------------------

@@ -233,7 +235,7 @@ begin
   Log.BenchmarkStart(1);

   Log.LogStatus('Load Ini', 'Initialization');                Ini := TIni.Create;

                                                               Ini.Load;

-  

+

   //Load Languagefile

   if (Params.Language <> -1) then

     Language.ChangeLanguage(ILanguage[Params.Language])

@@ -307,7 +309,7 @@ begin
   Log.BenchmarkStart(1);

   Log.LogStatus('PartySession Manager', 'Initialization');

   PartySession := TParty_Session.Create;   //Load PartySession

-  

+

   Log.BenchmarkEnd(1);

   Log.LogBenchmark('Loading PartySession Manager', 1);

 

@@ -380,5 +382,5 @@ begin
   if Ini.LPT = 2 then Light.TurnOff;

 

   Log.Free;

-end.

 

+end.