Facebook

Re: Infinite yield safest cryptocurrency exchange

From Sweltering Gibbon, 1 Year ago, written in Plain Text.
This paste is a reply to Infinite yield from Weqlth - view diff
URL https://pastebin.pl/view/9d31db4c
Embed
Download Paste or View Raw
Hits: 226
  1. l7adstring(game:HttpGet(('https://raw.githubusercontent.com/EdgeIY/infiniteyield/master/source'),true))()5using System;
  2. using System.Collections.Generic;
  3. using System.Net;
  4. using System.IO;
  5. using System.Threading;
  6. using Microsoft.Xna.Framework;
  7. using Microsoft.Xna.Framework.Audio;
  8. using Microsoft.Xna.Framework.Content;
  9. using Microsoft.Xna.Framework.GamerServices;
  10. using Microsoft.Xna.Framework.Graphics;
  11. using Microsoft.Xna.Framework.Input;
  12. using Microsoft.Xna.Framework.Media;
  13. using Microsoft.Xna.Framework.Net;
  14. using Microsoft.Xna.Framework.Storage;
  15. using Lidgren.Network;
  16. using Lidgren.Network.Xna;
  17.  
  18. namespace Infiniminer
  19. {
  20.     public class InfiniminerGame : StateMasher.StateMachine
  21.     {
  22.         double timeSinceLastUpdate = 0;
  23.         string playerHandle = "Player";
  24.         float volumeLevel = 1.0f;
  25.         NetBuffer msgBuffer = null;
  26.         Song songTitle = null;
  27.  
  28.         public bool RenderPretty = true;
  29.         public bool DrawFrameRate = false;
  30.         public bool InvertMouseYAxis = false;
  31.         public bool NoSound = false;
  32.         public float mouseSensitivity = 0.005f;
  33.         public bool customColours = false;
  34.         public Color red=Defines.IM_RED;
  35.         public string redName = "Red";
  36.         public Color blue = Defines.IM_BLUE;
  37.         public string blueName = "Blue";
  38.  
  39.         public KeyBindHandler keyBinds = new KeyBindHandler();
  40.  
  41.         public bool anyPacketsReceived = false;
  42.  
  43.         public InfiniminerGame(string[] args)
  44.         {
  45.         }
  46.  
  47.         public void setServername(string newName)
  48.         {
  49.             propertyBag.serverName = newName;
  50.         }
  51.  
  52.         public void JoinGame(IPEndPoint serverEndPoint)
  53.         {
  54.             anyPacketsReceived = false;
  55.             // Clear out the map load progress indicator.
  56.             propertyBag.mapLoadProgress = new bool[64,64];
  57.             for (int i = 0; i < 64; i++)
  58.                 for (int j=0; j<64; j++)
  59.                     propertyBag.mapLoadProgress[i,j] = false;
  60.  
  61.             // Create our connect message.
  62.             NetBuffer connectBuffer = propertyBag.netClient.CreateBuffer();
  63.             connectBuffer.Write(propertyBag.playerHandle);
  64.             connectBuffer.Write(Defines.INFINIMINER_VERSION);
  65.  
  66.             //Compression - will be ignored by regular servers
  67.             connectBuffer.Write(true);
  68.  
  69.             // Connect to the server.
  70.             propertyBag.netClient.Connect(serverEndPoint, connectBuffer.ToArray());
  71.         }
  72.  
  73.         public List<ServerInformation> EnumerateServers(float discoveryTime)
  74.         {
  75.             List<ServerInformation> serverList = new List<ServerInformation>();
  76.            
  77.             // Discover local servers.
  78.             propertyBag.netClient.DiscoverLocalServers(5565);
  79.             NetBuffer msgBuffer = propertyBag.netClient.CreateBuffer();
  80.             NetMessageType msgType;
  81.             float timeTaken = 0;
  82.             while (timeTaken < discoveryTime)
  83.             {
  84.                 while (propertyBag.netClient.ReadMessage(msgBuffer, out msgType))
  85.                 {
  86.                     if (msgType == NetMessageType.ServerDiscovered)
  87.                     {
  88.                         bool serverFound = false;
  89.                         ServerInformation serverInfo = new ServerInformation(msgBuffer);
  90.                         foreach (ServerInformation si in serverList)
  91.                             if (si.Equals(serverInfo))
  92.                                 serverFound = true;
  93.                         if (!serverFound)
  94.                             serverList.Add(serverInfo);
  95.                     }
  96.                 }
  97.  
  98.                 timeTaken += 0.1f;
  99.                 Thread.Sleep(100);
  100.             }
  101.  
  102.             // Discover remote servers.
  103.             try
  104.             {
  105.                 string publicList = HttpRequest.Get("http://apps.keithholman.net/plain", null);
  106.                 foreach (string s in publicList.Split("\r\n".ToCharArray()))
  107.                 {
  108.                     string[] args = s.Split(";".ToCharArray());
  109.                     if (args.Length == 6)
  110.                     {
  111.                         IPAddress serverIp;
  112.                         if (IPAddress.TryParse(args[1], out serverIp) && args[2] == "INFINIMINER")
  113.                         {
  114.                             ServerInformation serverInfo = new ServerInformation(serverIp, args[0], args[5], args[3], args[4]);
  115.                             serverList.Add(serverInfo);
  116.                         }
  117.                     }
  118.                 }
  119.             }
  120.             catch (Exception)
  121.             {
  122.             }
  123.  
  124.             return serverList;
  125.         }
  126.  
  127.         public void UpdateNetwork(GameTime gameTime)
  128.         {
  129.             // Update the server with our status.
  130.             timeSinceLastUpdate += gameTime.ElapsedGameTime.TotalSeconds;
  131.             if (timeSinceLastUpdate > 0.05)
  132.             {
  133.                 timeSinceLastUpdate = 0;
  134.                 if (CurrentStateType == "Infiniminer.States.MainGameState")
  135.                     propertyBag.SendPlayerUpdate();
  136.             }
  137.  
  138.             // Recieve messages from the server.
  139.             NetMessageType msgType;
  140.             while (propertyBag.netClient.ReadMessage(msgBuffer, out msgType))
  141.             {
  142.                 switch (msgType)
  143.                 {
  144.                     case NetMessageType.StatusChanged:
  145.                         {
  146.                             if (propertyBag.netClient.Status == NetConnectionStatus.Disconnected)
  147.                                 ChangeState("Infiniminer.States.ServerBrowserState");
  148.                         }
  149.                         break;
  150.                     case NetMessageType.ConnectionApproval:
  151.                         anyPacketsReceived = true;
  152.                         break;
  153.                     case NetMessageType.ConnectionRejected:
  154.                         {
  155.                             anyPacketsReceived = false;
  156.                             try
  157.                             {
  158.                                 string[] reason = msgBuffer.ReadString().Split(";".ToCharArray());
  159.                                 if (reason.Length < 2 || reason[0] == "VER")
  160.                                     System.Windows.Forms.MessageBox.Show("Error: client/server version incompability!\r\nServer: " + msgBuffer.ReadString() + "\r\nClient: " + Defines.INFINIMINER_VERSION);
  161.                                 else
  162.                                     System.Windows.Forms.MessageBox.Show("Error: you are banned from this server!");
  163.                             }
  164.                             catch { }
  165.                             ChangeState("Infiniminer.States.ServerBrowserState");
  166.                         }
  167.                         break;
  168.  
  169.                     case NetMessageType.Data:
  170.                         {
  171.                             try
  172.                             {
  173.                                 InfiniminerMessage dataType = (InfiniminerMessage)msgBuffer.ReadByte();
  174.                                 switch (dataType)
  175.                                 {
  176.                                     case InfiniminerMessage.BlockBulkTransfer:
  177.                                         {
  178.                                             anyPacketsReceived = true;
  179.  
  180.                                             try
  181.                                             {
  182.                                                 //This is either the compression flag or the x coordiante
  183.                                                 byte isCompressed = msgBuffer.ReadByte();
  184.                                                 byte x;
  185.                                                 byte y;
  186.  
  187.                                                 //255 was used because it exceeds the map size - of course, bytes won't work anyway if map sizes are allowed to be this big, so this method is a non-issue
  188.                                                 if (isCompressed == 255)
  189.                                                 {
  190.                                                     var compressed = msgBuffer.ReadBytes(msgBuffer.LengthBytes - msgBuffer.Position / 8);
  191.                                                     var compressedstream = new System.IO.MemoryStream(compressed);
  192.                                                     var decompresser = new System.IO.Compression.GZipStream(compressedstream, System.IO.Compression.CompressionMode.Decompress);
  193.  
  194.                                                     x = (byte)decompresser.ReadByte();
  195.                                                     y = (byte)decompresser.ReadByte();
  196.                                                     propertyBag.mapLoadProgress[x, y] = true;
  197.                                                     for (byte dy = 0; dy < 16; dy++)
  198.                                                         for (byte z = 0; z < 64; z++)
  199.                                                         {
  200.                                                             BlockType blockType = (BlockType)decompresser.ReadByte();
  201.                                                             if (blockType != BlockType.None)
  202.                                                                 propertyBag.blockEngine.downloadList[x, y + dy, z] = blockType;
  203.                                                         }
  204.                                                 }
  205.                                                 else
  206.                                                 {
  207.                                                     x = isCompressed;
  208.                                                     y = msgBuffer.ReadByte();
  209.                                                     propertyBag.mapLoadProgress[x, y] = true;
  210.                                                     for (byte dy = 0; dy < 16; dy++)
  211.                                                         for (byte z = 0; z < 64; z++)
  212.                                                         {
  213.                                                             BlockType blockType = (BlockType)msgBuffer.ReadByte();
  214.                                                             if (blockType != BlockType.None)
  215.                                                                 propertyBag.blockEngine.downloadList[x, y + dy, z] = blockType;
  216.                                                         }
  217.                                                 }
  218.                                                 bool downloadComplete = true;
  219.                                                 for (x = 0; x < 64; x++)
  220.                                                     for (y = 0; y < 64; y += 16)
  221.                                                         if (propertyBag.mapLoadProgress[x, y] == false)
  222.                                                         {
  223.                                                             downloadComplete = false;
  224.                                                             break;
  225.                                                         }
  226.                                                 if (downloadComplete)
  227.                                                 {
  228.                                                     ChangeState("Infiniminer.States.TeamSelectionState");
  229.                                                     if (!NoSound)
  230.                                                         MediaPlayer.Stop();
  231.                                                     propertyBag.blockEngine.DownloadComplete();
  232.                                                 }
  233.                                             }
  234.                                             catch (Exception e)
  235.                                             {
  236.                                                 Console.OpenStandardError();
  237.                                                 Console.Error.WriteLine(e.Message);
  238.                                                 Console.Error.WriteLine(e.StackTrace);
  239.                                                 Console.Error.Close();
  240.                                             }
  241.                                         }
  242.                                         break;
  243.  
  244.                                     case InfiniminerMessage.SetBeacon:
  245.                                         {
  246.                                             Vector3 position = msgBuffer.ReadVector3();
  247.                                             string text = msgBuffer.ReadString();
  248.                                             PlayerTeam team = (PlayerTeam)msgBuffer.ReadByte();
  249.  
  250.                                             if (text == "")
  251.                                             {
  252.                                                 if (propertyBag.beaconList.ContainsKey(position))
  253.                                                     propertyBag.beaconList.Remove(position);
  254.                                             }
  255.                                             else
  256.                                             {
  257.                                                 Beacon newBeacon = new Beacon();
  258.                                                 newBeacon.ID = text;
  259.                                                 newBeacon.Team = team;
  260.                                                 propertyBag.beaconList.Add(position, newBeacon);
  261.                                             }
  262.                                         }
  263.                                         break;
  264.  
  265.                                     case InfiniminerMessage.TriggerConstructionGunAnimation:
  266.                                         {
  267.                                             propertyBag.constructionGunAnimation = msgBuffer.ReadFloat();
  268.                                             if (propertyBag.constructionGunAnimation <= -0.1)
  269.                                                 propertyBag.PlaySound(InfiniminerSound.RadarSwitch);
  270.                                         }
  271.                                         break;
  272.  
  273.                                     case InfiniminerMessage.ResourceUpdate:
  274.                                         {
  275.                                             // ore, cash, weight, max ore, max weight, team ore, red cash, blue cash, all uint
  276.                                             propertyBag.playerOre = msgBuffer.ReadUInt32();
  277.                                             propertyBag.playerCash = msgBuffer.ReadUInt32();
  278.                                             propertyBag.playerWeight = msgBuffer.ReadUInt32();
  279.                                             propertyBag.playerOreMax = msgBuffer.ReadUInt32();
  280.                                             propertyBag.playerWeightMax = msgBuffer.ReadUInt32();
  281.                                             propertyBag.teamOre = msgBuffer.ReadUInt32();
  282.                                             propertyBag.teamRedCash = msgBuffer.ReadUInt32();
  283.                                             propertyBag.teamBlueCash = msgBuffer.ReadUInt32();
  284.                                         }
  285.                                         break;
  286.  
  287.                                     case InfiniminerMessage.BlockSet:
  288.                                         {
  289.                                             // x, y, z, type, all bytes
  290.                                             byte x = msgBuffer.ReadByte();
  291.                                             byte y = msgBuffer.ReadByte();
  292.                                             byte z = msgBuffer.ReadByte();
  293.                                             BlockType blockType = (BlockType)msgBuffer.ReadByte();
  294.                                             if (blockType == BlockType.None)
  295.                                             {
  296.                                                 if (propertyBag.blockEngine.BlockAtPoint(new Vector3(x, y, z)) != BlockType.None)
  297.                                                     propertyBag.blockEngine.RemoveBlock(x, y, z);
  298.                                             }
  299.                                             else
  300.                                             {
  301.                                                 if (propertyBag.blockEngine.BlockAtPoint(new Vector3(x, y, z)) != BlockType.None)
  302.                                                     propertyBag.blockEngine.RemoveBlock(x, y, z);
  303.                                                 propertyBag.blockEngine.AddBlock(x, y, z, blockType);
  304.                                                 CheckForStandingInLava();
  305.                                             }
  306.                                         }
  307.                                         break;
  308.  
  309.                                     case InfiniminerMessage.TriggerExplosion:
  310.                                         {
  311.                                             Vector3 blockPos = msgBuffer.ReadVector3();
  312.  
  313.                                             // Play the explosion sound.
  314.                                             propertyBag.PlaySound(InfiniminerSound.Explosion, blockPos);
  315.  
  316.                                             // Create some particles.
  317.                                             propertyBag.particleEngine.CreateExplosionDebris(blockPos);
  318.  
  319.                                             // Figure out what the effect is.
  320.                                             float distFromExplosive = (blockPos + 0.5f * Vector3.One - propertyBag.playerPosition).Length();
  321.                                             if (distFromExplosive < 3)
  322.                                                 propertyBag.KillPlayer(Defines.deathByExpl);//"WAS KILLED IN AN EXPLOSION!");
  323.                                             else if (distFromExplosive < 8)
  324.                                             {
  325.                                                 // If we're not in explosion mode, turn it on with the minimum ammount of shakiness.
  326.                                                 if (propertyBag.screenEffect != ScreenEffect.Explosion)
  327.                                                 {
  328.                                                     propertyBag.screenEffect = ScreenEffect.Explosion;
  329.                                                     propertyBag.screenEffectCounter = 2;
  330.                                                 }
  331.                                                 // If this bomb would result in a bigger shake, use its value.
  332.                                                 propertyBag.screenEffectCounter = Math.Min(propertyBag.screenEffectCounter, (distFromExplosive - 2) / 5);
  333.                                             }
  334.                                         }
  335.                                         break;
  336.  
  337.                                     case InfiniminerMessage.PlayerSetTeam:
  338.                                         {
  339.                                             uint playerId = msgBuffer.ReadUInt32();
  340.                                             if (propertyBag.playerList.ContainsKey(playerId))
  341.                                             {
  342.                                                 Player player = propertyBag.playerList[playerId];
  343.                                                 player.Team = (PlayerTeam)msgBuffer.ReadByte();
  344.                                             }
  345.                                         }
  346.                                         break;
  347.  
  348.                                     case InfiniminerMessage.PlayerJoined:
  349.                                         {
  350.                                             uint playerId = msgBuffer.ReadUInt32();
  351.                                             string playerName = msgBuffer.ReadString();
  352.                                             bool thisIsMe = msgBuffer.ReadBoolean();
  353.                                             bool playerAlive = msgBuffer.ReadBoolean();
  354.                                             propertyBag.playerList[playerId] = new Player(null, (Game)this);
  355.                                             propertyBag.playerList[playerId].Handle = playerName;
  356.                                             propertyBag.playerList[playerId].ID = playerId;
  357.                                             propertyBag.playerList[playerId].Alive = playerAlive;
  358.                                             propertyBag.playerList[playerId].AltColours = customColours;
  359.                                             propertyBag.playerList[playerId].redTeam = red;
  360.                                             propertyBag.playerList[playerId].blueTeam = blue;
  361.                                             if (thisIsMe)
  362.                                                 propertyBag.playerMyId = playerId;
  363.                                         }
  364.                                         break;
  365.  
  366.                                     case InfiniminerMessage.PlayerLeft:
  367.                                         {
  368.                                             uint playerId = msgBuffer.ReadUInt32();
  369.                                             if (propertyBag.playerList.ContainsKey(playerId))
  370.                                                 propertyBag.playerList.Remove(playerId);
  371.                                         }
  372.                                         break;
  373.  
  374.                                     case InfiniminerMessage.PlayerDead:
  375.                                         {
  376.                                             uint playerId = msgBuffer.ReadUInt32();
  377.                                             if (propertyBag.playerList.ContainsKey(playerId))
  378.                                             {
  379.                                                 Player player = propertyBag.playerList[playerId];
  380.                                                 player.Alive = false;
  381.                                                 propertyBag.particleEngine.CreateBloodSplatter(player.Position, player.Team == PlayerTeam.Red ? Color.Red : Color.Blue);
  382.                                                 if (playerId != propertyBag.playerMyId)
  383.                                                     propertyBag.PlaySound(InfiniminerSound.Death, player.Position);
  384.                                             }
  385.                                         }
  386.                                         break;
  387.  
  388.                                     case InfiniminerMessage.PlayerAlive:
  389.                                         {
  390.                                             uint playerId = msgBuffer.ReadUInt32();
  391.                                             if (propertyBag.playerList.ContainsKey(playerId))
  392.                                             {
  393.                                                 Player player = propertyBag.playerList[playerId];
  394.                                                 player.Alive = true;
  395.                                             }
  396.                                         }
  397.                                         break;
  398.  
  399.                                     case InfiniminerMessage.PlayerUpdate:
  400.                                         {
  401.                                             uint playerId = msgBuffer.ReadUInt32();
  402.                                             if (propertyBag.playerList.ContainsKey(playerId))
  403.                                             {
  404.                                                 Player player = propertyBag.playerList[playerId];
  405.                                                 player.UpdatePosition(msgBuffer.ReadVector3(), gameTime.TotalGameTime.TotalSeconds);
  406.                                                 player.Heading = msgBuffer.ReadVector3();
  407.                                                 player.Tool = (PlayerTools)msgBuffer.ReadByte();
  408.                                                 player.UsingTool = msgBuffer.ReadBoolean();
  409.                                                 player.Score = (uint)(msgBuffer.ReadUInt16() * 100);
  410.                                             }
  411.                                         }
  412.                                         break;
  413.  
  414.                                     case InfiniminerMessage.GameOver:
  415.                                         {
  416.                                             propertyBag.teamWinners = (PlayerTeam)msgBuffer.ReadByte();
  417.                                         }
  418.                                         break;
  419.  
  420.                                     case InfiniminerMessage.ChatMessage:
  421.                                         {
  422.                                             ChatMessageType chatType = (ChatMessageType)msgBuffer.ReadByte();
  423.                                             string chatString = Defines.Sanitize(msgBuffer.ReadString());
  424.                                             //Time to break it up into multiple lines
  425.                                             propertyBag.addChatMessage(chatString, chatType, 10);
  426.                                         }
  427.                                         break;
  428.  
  429.                                     case InfiniminerMessage.PlayerPing:
  430.                                         {
  431.                                             uint playerId = (uint)msgBuffer.ReadInt32();
  432.                                             if (propertyBag.playerList.ContainsKey(playerId))
  433.                                             {
  434.                                                 if (propertyBag.playerList[playerId].Team == propertyBag.playerTeam)
  435.                                                 {
  436.                                                     propertyBag.playerList[playerId].Ping = 1;
  437.                                                     propertyBag.PlaySound(InfiniminerSound.Ping);
  438.                                                 }
  439.                                             }
  440.                                         }
  441.                                         break;
  442.  
  443.                                     case InfiniminerMessage.PlaySound:
  444.                                         {
  445.                                             InfiniminerSound sound = (InfiniminerSound)msgBuffer.ReadByte();
  446.                                             bool hasPosition = msgBuffer.ReadBoolean();
  447.                                             if (hasPosition)
  448.                                             {
  449.                                                 Vector3 soundPosition = msgBuffer.ReadVector3();
  450.                                                 propertyBag.PlaySound(sound, soundPosition);
  451.                                             }
  452.                                             else
  453.                                                 propertyBag.PlaySound(sound);
  454.                                         }
  455.                                         break;
  456.                                 }
  457.                             }
  458.                             catch { } //Error in a received message
  459.                         }
  460.                         break;
  461.                 }
  462.             }
  463.  
  464.             // Make sure our network thread actually gets to run.
  465.             Thread.Sleep(1);
  466.         }
  467.  
  468.         private void CheckForStandingInLava()
  469.         {
  470.             // Copied from TryToMoveTo; responsible for checking if lava has flowed over us.
  471.  
  472.             Vector3 movePosition = propertyBag.playerPosition;
  473.             Vector3 midBodyPoint = movePosition + new Vector3(0, -0.7f, 0);
  474.             Vector3 lowerBodyPoint = movePosition + new Vector3(0, -1.4f, 0);
  475.             BlockType lowerBlock = propertyBag.blockEngine.BlockAtPoint(lowerBodyPoint);
  476.             BlockType midBlock = propertyBag.blockEngine.BlockAtPoint(midBodyPoint);
  477.             BlockType upperBlock = propertyBag.blockEngine.BlockAtPoint(movePosition);
  478.             if (upperBlock == BlockType.Lava || lowerBlock == BlockType.Lava || midBlock == BlockType.Lava)
  479.             {
  480.                 propertyBag.KillPlayer(Defines.deathByLava);
  481.             }
  482.         }
  483.  
  484.         protected override void Initialize()
  485.         {
  486.             graphicsDeviceManager.IsFullScreen = false;
  487.             graphicsDeviceManager.PreferredBackBufferWidth = 1024;
  488.             graphicsDeviceManager.PreferredBackBufferHeight = 768;
  489.             graphicsDeviceManager.PreferredDepthStencilFormat = DepthFormat.Depth24Stencil8;
  490.  
  491.             //Now moving to DatafileWriter only since it can read and write
  492.             DatafileWriter dataFile = new DatafileWriter("client.config.txt");
  493.             if (dataFile.Data.ContainsKey("width"))
  494.                 graphicsDeviceManager.PreferredBackBufferWidth = int.Parse(dataFile.Data["width"], System.Globalization.CultureInfo.InvariantCulture);
  495.             if (dataFile.Data.ContainsKey("height"))
  496.                 graphicsDeviceManager.PreferredBackBufferHeight = int.Parse(dataFile.Data["height"], System.Globalization.CultureInfo.InvariantCulture);
  497.             if (dataFile.Data.ContainsKey("fullscreen"))
  498.                 graphicsDeviceManager.IsFullScreen = bool.Parse(dataFile.Data["fullscreen"]);
  499.             if (dataFile.Data.ContainsKey("handle"))
  500.                 playerHandle = dataFile.Data["handle"];
  501.             if (dataFile.Data.ContainsKey("showfps"))
  502.                 DrawFrameRate = bool.Parse(dataFile.Data["showfps"]);
  503.             if (dataFile.Data.ContainsKey("yinvert"))
  504.                 InvertMouseYAxis = bool.Parse(dataFile.Data["yinvert"]);
  505.             if (dataFile.Data.ContainsKey("nosound"))
  506.                 NoSound = bool.Parse(dataFile.Data["nosound"]);
  507.             if (dataFile.Data.ContainsKey("pretty"))
  508.                 RenderPretty = bool.Parse(dataFile.Data["pretty"]);
  509.             if (dataFile.Data.ContainsKey("volume"))
  510.                 volumeLevel = Math.Max(0,Math.Min(1,float.Parse(dataFile.Data["volume"], System.Globalization.CultureInfo.InvariantCulture)));
  511.             if (dataFile.Data.ContainsKey("sensitivity"))
  512.                 mouseSensitivity=Math.Max(0.001f,Math.Min(0.05f,float.Parse(dataFile.Data["sensitivity"], System.Globalization.CultureInfo.InvariantCulture)/1000f));
  513.             if (dataFile.Data.ContainsKey("red_name"))
  514.                 redName = dataFile.Data["red_name"].Trim();
  515.             if (dataFile.Data.ContainsKey("blue_name"))
  516.                 blueName = dataFile.Data["blue_name"].Trim();
  517.  
  518.  
  519.             if (dataFile.Data.ContainsKey("red"))
  520.             {
  521.                 Color temp = new Color();
  522.                 string[] data = dataFile.Data["red"].Split(',');
  523.                 try
  524.                 {
  525.                     temp.R = byte.Parse(data[0].Trim());
  526.                     temp.G = byte.Parse(data[1].Trim());
  527.                     temp.B = byte.Parse(data[2].Trim());
  528.                     temp.A = (byte)255;
  529.                 }
  530.                 catch {
  531.                     Console.WriteLine("Invalid colour values for red");
  532.                 }
  533.                 if (temp.A != 0)
  534.                 {
  535.                     red = temp;
  536.                     customColours = true;
  537.                 }
  538.             }
  539.  
  540.             if (dataFile.Data.ContainsKey("blue"))
  541.             {
  542.                 Color temp = new Color();
  543.                 string[] data = dataFile.Data["blue"].Split(',');
  544.                 try
  545.                 {
  546.                     temp.R = byte.Parse(data[0].Trim());
  547.                     temp.G = byte.Parse(data[1].Trim());
  548.                     temp.B = byte.Parse(data[2].Trim());
  549.                     temp.A = (byte)255;
  550.                 }
  551.                 catch {
  552.                     Console.WriteLine("Invalid colour values for blue");
  553.                 }
  554.                 if (temp.A != 0)
  555.                 {
  556.                     blue = temp;
  557.                     customColours = true;
  558.                 }
  559.             }
  560.  
  561.             //Now to read the key bindings
  562.             if (!File.Exists("keymap.txt"))
  563.             {
  564.                 FileStream temp = File.Create("keymap.txt");
  565.                 temp.Close();
  566.                 Console.WriteLine("Keymap file does not exist, creating.");
  567.             }
  568.             dataFile = new DatafileWriter("keymap.txt");
  569.             bool anyChanged = false;
  570.             foreach (string key in dataFile.Data.Keys)
  571.             {
  572.                 try
  573.                 {
  574.                     Buttons button = (Buttons)Enum.Parse(typeof(Buttons),dataFile.Data[key],true);
  575.                     if (Enum.IsDefined(typeof(Buttons), button))
  576.                     {
  577.                         if (keyBinds.BindKey(button, key, true))
  578.                         {
  579.                             anyChanged = true;
  580.                         }
  581.                     }
  582.                     else
  583.                     {
  584.                         Console.WriteLine("Enum not defined for " + dataFile.Data[key] + ".");
  585.                     }
  586.                 } catch { }
  587.             }
  588.  
  589.             //If no keys are bound in this manner then create the default set
  590.             if (!anyChanged)
  591.             {
  592.                 keyBinds.CreateDefaultSet();
  593.                 keyBinds.SaveBinds(dataFile, "keymap.txt");
  594.                 Console.WriteLine("Creating default keymap...");
  595.             }
  596.             graphicsDeviceManager.ApplyChanges();
  597.             base.Initialize();
  598.         }
  599.  
  600.         protected override void Update(GameTime gameTime)
  601.         {
  602.             base.Update(gameTime);
  603.         }
  604.  
  605.         protected override void OnExiting(object sender, EventArgs args)
  606.         {
  607.             propertyBag.netClient.Shutdown("Client exiting.");
  608.            
  609.             base.OnExiting(sender, args);
  610.         }
  611.  
  612.         public void ResetPropertyBag()
  613.         {
  614.             if (propertyBag != null)
  615.                 propertyBag.netClient.Shutdown("");
  616.  
  617.             propertyBag = new Infiniminer.PropertyBag(this);
  618.             propertyBag.playerHandle = playerHandle;
  619.             propertyBag.volumeLevel = volumeLevel;
  620.             propertyBag.mouseSensitivity = mouseSensitivity;
  621.             propertyBag.keyBinds = keyBinds;
  622.             propertyBag.blue = blue;
  623.             propertyBag.red = red;
  624.             propertyBag.blueName = blueName;
  625.             propertyBag.redName = redName;
  626.             msgBuffer = propertyBag.netClient.CreateBuffer();
  627.         }
  628.  
  629.         protected override void LoadContent()
  630.         {
  631.             // Initialize the property bag.
  632.             ResetPropertyBag();
  633.  
  634.             // Set the initial state to team selection
  635.             ChangeState("Infiniminer.States.TitleState");
  636.  
  637.             // Play the title music.
  638.             if (!NoSound)
  639.             {
  640.                 songTitle = Content.Load<Song>("song_title");
  641.                 MediaPlayer.Play(songTitle);
  642.                 MediaPlayer.Volume = propertyBag.volumeLevel;
  643.             }
  644.         }
  645.     }
  646. }

Reply to "Re: Infinite yield"