Overwrite

Complete Overwrite of the Folder with the free shard. ServUO 57.3 has been added.

Scripts/Scripts-master/Games/Bomberman/Base/BoardGameData.cs

@@ -0,0 +1,333 @@
+using System;
+using System.IO;
+using System.Collections.Generic;
+using Server;
+
+namespace Solaris.BoardGames
+{
+	//this data class is used to keep track of player scores for various boardgames
+	public class BoardGameData
+	{
+		public const string SAVE_PATH = @"Saves\BoardGame Data";
+		public const string FILENAME = "boardgames.bin";
+		
+		protected static List<BoardGameData> _GameData;
+		
+		public static List<BoardGameData> GameData
+		{
+			get
+			{
+				if( _GameData == null )
+				{
+					_GameData = new List<BoardGameData>();
+				}
+				return _GameData;
+			}
+		}
+		
+		
+		protected string _GameName;
+		protected List<BoardGamePlayerScore> _Scores;
+		
+		public string GameName{ get{ return _GameName; } }
+		
+		public List<BoardGamePlayerScore> Scores
+		{
+			get
+			{
+				if( _Scores == null )
+				{
+					_Scores = new List<BoardGamePlayerScore>();
+				}
+				return _Scores;
+			}
+		}
+		
+		protected BoardGameData( string gamename )
+		{
+			_GameName = gamename;
+		}
+		
+		protected BoardGameData( GenericReader reader )
+		{
+			Deserialize( reader );
+		}
+		
+		protected virtual void Serialize( GenericWriter writer )
+		{
+			writer.Write( 0 );
+			
+			writer.Write( _GameName );
+			
+			writer.Write( Scores.Count );
+			
+			foreach( BoardGamePlayerScore score in Scores )
+			{
+				score.Serialize( writer );
+			}
+		}
+		
+		protected virtual void Deserialize( GenericReader reader )
+		{
+			int version = reader.ReadInt();
+			
+			_GameName = reader.ReadString();
+			
+			int count = reader.ReadInt();
+			
+			for( int i = 0; i < count; i++ )
+			{
+				BoardGamePlayerScore playerscore = new BoardGamePlayerScore( reader );
+				
+				if( playerscore.Player != null && !playerscore.Player.Deleted )
+				{
+					Scores.Add( playerscore );
+				}
+			}
+		}
+		
+		protected static BoardGamePlayerScore GetScoreData( string gamename, Mobile player )
+		{
+			List<BoardGamePlayerScore> scores = GetScores( gamename );
+			
+			if( scores == null )
+			{
+				BoardGameData gamedata = new BoardGameData( gamename );
+				GameData.Add( gamedata );
+				scores = gamedata.Scores;
+			}
+		
+			int index = BoardGamePlayerScore.IndexOf( scores, player );
+			
+			if( index == -1 )
+			{
+				BoardGamePlayerScore newscore = new BoardGamePlayerScore( player );
+				scores.Add( newscore );
+				return newscore;
+			}
+			else
+			{
+				return scores[ index ];
+			}
+		}
+		
+		public static List<BoardGamePlayerScore> GetScores( string gamename )
+		{
+			int gameindex = IndexOf( gamename );
+			
+			if( gameindex == -1 )
+			{
+				return null;
+			}
+			else
+			{
+				return GameData[ gameindex ].Scores;
+			}
+		}
+		
+		public static void SetScore( string gamename, Mobile player, int score )
+		{
+			BoardGamePlayerScore scoredata = GetScoreData( gamename, player );
+			
+			if( scoredata != null )
+			{
+				scoredata.Score = score;
+			}
+			else
+			{
+				
+			}
+		}
+		
+		public static int GetScore( string gamename, Mobile player )
+		{
+			BoardGamePlayerScore scoredata = GetScoreData( gamename, player );
+			
+			if( scoredata != null )
+			{
+				return scoredata.Score;
+			}
+			else
+			{
+				return 0;
+			}
+		}
+		
+		public static void ChangeScore( string gamename, Mobile player, int delta )
+		{
+			SetScore( gamename, player, Math.Max( 0, GetScore( gamename, player ) + delta ) );
+		}
+		
+		public static void AddWin( string gamename, Mobile player )
+		{
+			BoardGamePlayerScore playerscore = GetScoreData( gamename, player );
+			
+			playerscore.Wins += 1;
+		}
+		
+		public static void AddLose( string gamename, Mobile player )
+		{
+			BoardGamePlayerScore playerscore = GetScoreData( gamename, player );
+			
+			playerscore.Losses += 1;
+			
+		}
+		
+		public static void ResetScores( string gamename )
+		{
+			int gameindex = IndexOf( gamename );
+			
+			if( gameindex > -1 )
+			{
+				GameData.RemoveAt( gameindex );
+			}
+		}
+		
+		
+		public static int IndexOf( string gamename )
+		{
+			for( int i = 0; i < GameData.Count; i++ )
+			{
+				if( GameData[i].GameName == gamename )
+				{
+					return i;
+				}
+			}
+			return -1;
+		}
+		
+		
+		public static void Configure()
+		{
+			EventSink.WorldLoad += new WorldLoadEventHandler( OnLoad );
+			EventSink.WorldSave += new WorldSaveEventHandler( OnSave );
+		}
+		
+		public static void OnSave( WorldSaveEventArgs e )
+		{
+			if( !Directory.Exists( SAVE_PATH ) )
+			{
+				Directory.CreateDirectory( SAVE_PATH );
+			}
+
+			GenericWriter writer = new BinaryFileWriter( Path.Combine( SAVE_PATH, FILENAME ), true );
+
+			writer.Write( 0 );
+			
+			writer.Write( GameData.Count );
+			
+			foreach( BoardGameData data in GameData )
+			{
+				data.Serialize( writer );
+			}
+			
+			writer.Close();
+			
+		}
+		
+		public static void OnLoad()
+		{
+			//don't load the file if it don't exist!
+			if( !File.Exists( Path.Combine( SAVE_PATH, FILENAME ) ) )
+			{
+				return;
+			}
+
+			using( FileStream bin = new FileStream( Path.Combine( SAVE_PATH, FILENAME ), FileMode.Open, FileAccess.Read, FileShare.Read ) )
+			{
+				GenericReader reader = new BinaryFileReader( new BinaryReader( bin ) );
+				
+				int version = reader.ReadInt();
+				
+				int count = reader.ReadInt();
+
+				for( int i = 0; i < count; i++ )
+				{
+					GameData.Add( new BoardGameData( reader ) );
+				}
+				
+				reader.End();
+			}
+		}
+		
+	}
+	
+	public class BoardGamePlayerScore : IComparable
+	{
+		protected Mobile _Player;
+		
+		
+		public Mobile Player{ get{ return _Player; } }
+		
+		public int Score;
+		public int Wins;
+		public int Losses;
+		
+		public BoardGamePlayerScore( Mobile player ) : this( player, 0 )
+		{
+		}
+		
+		public BoardGamePlayerScore( Mobile player, int score )
+		{
+			_Player = player;
+			Score = score;
+		}
+		
+		//deserialize constructor
+		public BoardGamePlayerScore( GenericReader reader )
+		{
+			Deserialize( reader );
+		}
+		
+		public int CompareTo( object obj )
+		{
+			if( !( obj is BoardGamePlayerScore ) )
+			{
+				return 0;
+			}
+			
+			BoardGamePlayerScore comparescore = (BoardGamePlayerScore)obj;
+			
+			return -Score.CompareTo( comparescore.Score );
+		}
+		
+		public virtual void Serialize( GenericWriter writer )
+		{
+			writer.Write( 0 );
+			
+			writer.Write( _Player );
+			writer.Write( Score );
+			writer.Write( Wins );
+			writer.Write( Losses );
+			
+		}
+		
+		public virtual void Deserialize( GenericReader reader )
+		{
+			int version = reader.ReadInt();
+			
+			_Player = reader.ReadMobile();
+			Score = reader.ReadInt();
+			Wins = reader.ReadInt();
+			Losses = reader.ReadInt();
+		}
+		
+		public static int IndexOf( List<BoardGamePlayerScore> scores, Mobile player )
+		{
+			if( scores == null )
+			{
+				return -1;
+			}
+			
+			for( int i = 0; i < scores.Count; i++ )
+			{
+				if( scores[i].Player == player )
+				{
+					return i;
+				}
+			}
+			
+			return -1;
+		}
+	}
+}