/// <summary>
/// 16 byte key
/// </summary>
public NetXtea(NetPeer peer, byte[] key, int rounds)
: base(peer)
{
if (key.Length < c_keySize)
throw new NetException("Key too short!");
m_numRounds = rounds;
m_sum0 = new uint[m_numRounds];
m_sum1 = new uint[m_numRounds];
uint[] tmp = new uint[8];
int num2;
int index = num2 = 0;
while (index < 4)
{
tmp[index] = BitConverter.ToUInt32(key, num2);
index++;
num2 += 4;
}
for (index = num2 = 0; index < 32; index++)
{
m_sum0[index] = ((uint)num2) + tmp[num2 & 3];
num2 += -1640531527;
m_sum1[index] = ((uint)num2) + tmp[(num2 >> 11) & 3];
}
}
public NetCryptoProviderBase(NetPeer peer, SymmetricAlgorithm algo)
: base(peer)
{
m_algorithm = algo;
m_algorithm.GenerateKey();
m_algorithm.GenerateIV();
}
static void Main()
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
s_mainForm = new Form1();
WriteToConsole("Type 'connect <host> <port>' to connect to another peer, or 'connect <port>' to connect to another localhost peer");
NetConfiguration config = new NetConfiguration("p2pchat");
config.MaxConnections = 256;
s_peer = new NetPeer(config);
//s_peer.VerboseLog = true;
s_peer.SetMessageTypeEnabled(NetMessageType.ConnectionRejected | NetMessageType.BadMessageReceived | NetMessageType.VerboseDebugMessage, true);
// start listening for incoming connections
s_peer.Start();
// create a buffer to read data into
s_readBuffer = s_peer.CreateBuffer();
Application.Idle += new EventHandler(OnAppIdle);
Application.Run(s_mainForm);
s_peer.Shutdown("Application exiting");
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="manager">Local NetPeer</param>
/// <param name="con">NetConnection</param>
/// <param name="key">Encryption key</param>
/// <param name="nodeId">Node Id</param>
public Connection(NetPeer manager, NetConnection con, INetEncryption encryption, String nodeId)
{
// This keep alive timer is used to overcome BAD connections that drop ping/pong messages a lot.
// It simply sends an empty message every five seconds. As long as some messages are retained
// and received on the connection, all will be well
_keepAliveTimer = new System.Timers.Timer(5000);
_keepAliveTimer.Elapsed += new ElapsedEventHandler((Object state, ElapsedEventArgs args) =>
this.SendMessage(this.NetManager.CreateMessage(0), NetDeliveryMethod.Unreliable));
this.Username = (con.Tag as Handshake).Username;
this.NetManager = manager;
this.NetConnection = con;
this.NetConnection.Tag = this;
this.NodeId = nodeId;
if (encryption != null)
{
_netEncryption = encryption;
}
else
{
// You could write code that makes it possible to transfer users between server
// where you don't have any encryption key YET. The place to start that would
// be here.
this.IsTransfering = true;
_netEncryption = new NetXtea(new Byte[16]);
}
// Not connected until everything is done.
System.Threading.Thread.MemoryBarrier();
_connected = true;
_keepAliveTimer.Start();
}
/// <summary>
/// Creates and starts a new NetworkPeer object, for servers.
/// </summary>
/// <param name="port">The port the server should listen on.</param>
/// <param name="protocols">An array of messaging protocols.</param>
public NetworkPeer(int port, params Protocol[] protocols)
{
Protocols = new List<Protocol>(protocols);
netPeer = new NetPeer(new NetPeerConfiguration("N/A").GetStandardConfiguration(port));
netPeer.RegisterReceivedCallback(OnMessageReceivedCallback);
Start();
}
public static void ShellCallback(MessageBase msg, NetPeer peer, NetBuffer buff)
{
if(CallbackMapping.ContainsKey(msg.Id))
{
CallbackMapping[msg.Id](peer, buff, msg);
}
}
public Peer(NetPeer peer)
{
this.peer = peer;
//start the client
peer.Start();
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="manager">Local NetPeer</param>
/// <param name="con">NetConnection</param>
/// <param name="key">Encryption key</param>
/// <param name="nodeId">Node Id</param>
public Connection(NetPeer manager, NetConnection con, INetEncryption encryption, String nodeId)
{
NetManager = manager;
NetConnection = con;
_connected = true;
_netEncryption = encryption;
NetConnection.Tag = this;
NodeId = nodeId;
}
internal NetOutgoingMessage ToOutgoing(NetPeer Sender)
{
NetOutgoingMessage msg = Sender.CreateMessage("__msg");
StringBuilder sb = new StringBuilder();
StringWriter writer = new StringWriter(sb);
serializer.Serialize(writer, this);
msg.Write(sb.ToString());
return msg;
}
public Program()
{
NetPeerConfiguration config = new NetPeerConfiguration("masterserver");
config.SetMessageTypeEnabled(NetIncomingMessageType.UnconnectedData, true);
config.Port = API.MasterServer.MasterServerPort;
peer = new NetPeer(config);
peer.Start();
}
public void OnLoginMessage(NetPeer server, NetBuffer buff, MessageBase msg)
{
var srv = server as NetServer;
var im = buff as NetIncomingMessage;
if (srv != null && im != null)
{
LoginMessageImpl(srv, im, msg);
}
}
public void OnLoginMessage(NetPeer client, NetBuffer buff, MessageBase msg)
{
var srv = client as NetClient;
var im = buff as NetIncomingMessage;
if (srv != null && im != null)
{
LoginResultMessageImpl(srv, im, msg);
}
}
static void Main(string[] args)
{
NetPeerConfiguration config = new NetPeerConfiguration("unittests");
config.EnableUPnP = true;
NetPeer peer = new NetPeer(config);
peer.Start(); // needed for initialization
Console.WriteLine("Unique identifier is " + NetUtility.ToHexString(peer.UniqueIdentifier));
ReadWriteTests.Run(peer);
NetQueueTests.Run();
MiscTests.Run(peer);
BitVectorTests.Run();
EncryptionTests.Run(peer);
var om = peer.CreateMessage();
peer.SendUnconnectedMessage(om, new IPEndPoint(IPAddress.Loopback, 14242));
try
{
peer.SendUnconnectedMessage(om, new IPEndPoint(IPAddress.Loopback, 14242));
}
catch (NetException nex)
{
if (nex.Message != "This message has already been sent! Use NetPeer.SendMessage() to send to multiple recipients efficiently")
throw nex;
}
peer.Shutdown("bye");
// read all message
NetIncomingMessage inc = peer.WaitMessage(5000);
while (inc != null)
{
switch (inc.MessageType)
{
case NetIncomingMessageType.DebugMessage:
case NetIncomingMessageType.VerboseDebugMessage:
case NetIncomingMessageType.WarningMessage:
case NetIncomingMessageType.ErrorMessage:
Console.WriteLine("Peer message: " + inc.ReadString());
break;
case NetIncomingMessageType.Error:
throw new Exception("Received error message!");
}
inc = peer.ReadMessage();
}
Console.WriteLine("Done");
Console.ReadKey();
}
public void PeerListener(NetPeer peer)
{
while (true)
{
NetIncomingMessage msg;
while ((msg=peer.ReadMessage())!=null)
{
NetConnection connection = msg.SenderConnection;
switch (msg.MessageType)
{
case NetIncomingMessageType.StatusChanged:
switch (msg.SenderConnection.Status)
{
case NetConnectionStatus.Connected:
logger.Info("{0}: connected",connection.RemoteEndPoint.Address.ToString());
ExecuteCommand(new CmdInitOk(connection));
break;
case NetConnectionStatus.Disconnected:
logger.Info("{0}: disconnected", connection.RemoteEndPoint.Address.ToString());
break;
case NetConnectionStatus.Disconnecting:
logger.Info("{0}: disconnecting", connection.RemoteEndPoint.Address.ToString());
break;
}
break;
case NetIncomingMessageType.Data:
msg.Decrypt(new NetRC2Encryption(peer, connection.CryptoKey));
string[] OpData = msg.ReadString().Split('&');
var OpCode = (LoginOperation)Enum.Parse(typeof(LoginOperation), OpData[0]);
switch (OpCode)
{
case LoginOperation.AuthLog:
string[] authData = OpData[1].Split('#');
string login = authData[0];
string pass = authData[1];
ExecuteCommand(new CmdLoginOkFail(connection, login,pass));
break;
}
break;
}
peer.Recycle(msg);
}
}
}
public void Connect(string ip)
{
// Create client with config and tell it to start then connect to the given IP.
NetClient client = new NetClient(Config);
client.Start();
client.Connect(ip, 25000);
Peer = client;
Console.WriteLine("Client has started.");
}
public void Host()
{
// Create server and tell it to start listening for connections.
Config.Port = 25000;
NetServer server = new NetServer(Config);
server.Start();
// Assign it to NetPeer so it can be used interchangibly with client.
Peer = server;
Console.WriteLine("Server has started.");
}
public void Start()
{
peer = new NetPeer(config);
peer.Start();
localIdentifier = peer.UniqueIdentifier;
listener = new peerListener(peer, localIdentifier);
moveQueue = new Queue<string>();
NetThread = new Thread(new ThreadStart(listener.processNetwork));
NetThread.Start();
}
private void button1_Click(object sender, EventArgs e)
{
NetPeerConfiguration config = new NetPeerConfiguration("MMC");
config.MaximumConnections = 100;
config.Port = 3939;
// Enable DiscoveryResponse messages
config.EnableMessageType(NetIncomingMessageType.DiscoveryResponse);
config.EnableMessageType(NetIncomingMessageType.DiscoveryRequest);
s_server = new NetPeer(config);
Output("listening on " + config.Port.ToString());
s_server.Start();
}
public NetPeerSettingsWindow(string title, NetPeer peer)
{
Peer = peer;
InitializeComponent();
RefreshData();
this.Text = title;
// auto refresh now and then
timer = new Timer();
timer.Interval = 250;
timer.Tick += new EventHandler(timer_Tick);
timer.Enabled = true;
}
protected override bool HandleMessage(NetPeer peer, NetIncomingMessage msg)
{
switch (msg.MessageType)
{
case NetIncomingMessageType.DiscoveryResponse:
{
PostNotificationImmediately(NetworkNotifications.LocalServerDiscovered, msg);
return true;
}
}
return false;
}
internal NetConnection(NetPeer peer, IPEndPoint remoteEndpoint)
{
m_peer = peer;
m_peerConfiguration = m_peer.Configuration;
m_status = NetConnectionStatus.None;
m_visibleStatus = NetConnectionStatus.None;
m_remoteEndpoint = remoteEndpoint;
m_sendChannels = new NetSenderChannelBase[NetConstants.NumTotalChannels];
m_receiveChannels = new NetReceiverChannelBase[NetConstants.NumTotalChannels];
m_queuedAcks = new NetQueue<NetTuple<NetMessageType, int>>(4);
m_statistics = new NetConnectionStatistics(this);
m_averageRoundtripTime = -1.0f;
}
/// <summary>
/// Gets a <see cref="NetOutgoingMessage"/>.
/// </summary>
/// <param name="netPeer">The <see cref="NetPeer"/> instance that the message is to be used on.</param>
/// <param name="size">The minimum initial size of the <see cref="NetOutgoingMessage"/> in bytes.</param>
/// <returns>
/// The <see cref="NetOutgoingMessage"/> instance to use.
/// </returns>
public static NetOutgoingMessage GetNetOutgoingMessage(NetPeer netPeer, int size)
{
// Round up to the next power-of-2 size (if not already there) to make allocations a bit more consistency-sized
// and grabbing from the internal pool will hopefully be faster, even if it does mean over-allocating a bit more.
// Also, never use less than 16 bytes since there is not much point in cluttering things up with tiny buffers.
if (size < 16)
size = 16;
else
size = BitOps.NextPowerOf2(size);
// Grab the NetOutgoingMessage from the internal buffer
return netPeer.CreateMessage(size);
}
public static void Run(NetPeer peer)
{
//
// Test XTEA
//
NetXtea xtea = new NetXtea("TopSecret");
byte[] original = new byte[16];
NetRandom.Instance.NextBytes(original);
byte[] encrypted = new byte[original.Length];
xtea.EncryptBlock(original, 0, encrypted, 0);
xtea.EncryptBlock(original, 8, encrypted, 8);
byte[] decrypted = new byte[original.Length];
xtea.DecryptBlock(encrypted, 0, decrypted, 0);
xtea.DecryptBlock(encrypted, 8, decrypted, 8);
// compare!
for (int i = 0; i < original.Length; i++)
if (original[i] != decrypted[i])
throw new NetException("XTEA fail!");
Console.WriteLine("XTEA OK");
NetOutgoingMessage om = peer.CreateMessage();
om.Write("Hallon");
om.Write(42);
om.Write(5, 5);
om.Write(true);
om.Write("kokos");
om.Encrypt(xtea);
// convert to incoming message
NetIncomingMessage im = Program.CreateIncomingMessage(om.PeekDataBuffer(), om.LengthBits);
im.Decrypt(xtea);
if (im.ReadString() != "Hallon")
throw new NetException("fail");
if (im.ReadInt32() != 42)
throw new NetException("fail");
if (im.ReadInt32(5) != 5)
throw new NetException("fail");
if (im.ReadBoolean() != true)
throw new NetException("fail");
if (im.ReadString() != "kokos")
throw new NetException("fail");
Console.WriteLine("Message encryption OK");
}
/// <summary>
/// Start local network peer.
/// </summary>
public Network()
{
m_netPeerConfiguration.SetMessageTypeEnabled(NetIncomingMessageType.UnconnectedData, true);
m_netPeerConfiguration.Port = APIMain.MasterServerPort;
m_netPeer = new NetPeer(m_netPeerConfiguration);
m_netPeer.Start();
m_updateThread = new Thread(Update);
m_updateThread.Start();
m_updateServersListThread = new Thread(UpdateServerList);
m_updateServersListThread.Start();
}
public NetworkGame(Settings settings, NetPeer peer)
{
this.settings = settings;
this.peer = peer;
localPlayerField = new Playfield(settings.GameType, new Vector2(780f, 325f), settings.PlayfieldSize);
remotePlayerField = new RemotePlayfield(settings.GameType, new Vector2(300f, 325f), settings.PlayfieldSize);
xDiff = localPlayerField.Position.X - remotePlayerField.Position.X;
backgroundImage = new Image();
pauseImage = new Image();
timeText = new Text();
countdownText = new OutlineText();
if (peer.ConnectionsCount == 0)
NewScreen(new NetworkGameSetup(), "No Connection");
else
connection = peer.Connections.ToArray()[0];
}
internal NetConnection(NetPeer peer, NetEndPoint remoteEndPoint)
{
m_peer = peer;
m_peerConfiguration = m_peer.Configuration;
m_status = NetConnectionStatus.None;
m_outputtedStatus = NetConnectionStatus.None;
m_visibleStatus = NetConnectionStatus.None;
m_remoteEndPoint = remoteEndPoint;
m_sendChannels = new NetSenderChannelBase[NetConstants.NumTotalChannels];
m_receiveChannels = new NetReceiverChannelBase[NetConstants.NumTotalChannels];
m_queuedOutgoingAcks = new NetQueue<NetTuple<NetMessageType, int>>(4);
m_queuedIncomingAcks = new NetQueue<NetTuple<NetMessageType, int>>(4);
m_statistics = new NetConnectionStatistics(this);
m_averageRoundtripTime = -1.0f;
m_currentMTU = m_peerConfiguration.MaximumTransmissionUnit;
}
static void Main()
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
MainForm = new Form1();
NetPeerConfiguration config = new NetPeerConfiguration("unconntest");
config.EnableMessageType(NetIncomingMessageType.UnconnectedData);
config.AcceptIncomingConnections = false; // don't accept connections; we're just using unconnected messages in this sample
Peer = new NetPeer(config);
Peer.Start();
Application.Idle += new EventHandler(AppLoop);
Application.Run(MainForm);
}
public static void Run(NetPeer peer)
{
NetPeerConfiguration config = new NetPeerConfiguration("Test");
config.EnableMessageType(NetIncomingMessageType.UnconnectedData);
if (config.IsMessageTypeEnabled(NetIncomingMessageType.UnconnectedData) == false)
throw new NetException("setting enabled message types failed");
config.SetMessageTypeEnabled(NetIncomingMessageType.UnconnectedData, false);
if (config.IsMessageTypeEnabled(NetIncomingMessageType.UnconnectedData) == true)
throw new NetException("setting enabled message types failed");
Console.WriteLine("Misc tests OK");
Console.WriteLine("Hex test: " + NetUtility.ToHexString(new byte[]{0xDE,0xAD,0xBE,0xEF}));
}
internal void Discover(NetPeer peer)
{
string str =
"M-SEARCH * HTTP/1.1\r\n" +
"HOST: 239.255.255.250:1900\r\n" +
"ST:upnp:rootdevice\r\n" +
"MAN:\"ssdp:discover\"\r\n" +
"MX:3\r\n\r\n";
byte[] arr = System.Text.Encoding.UTF8.GetBytes(str);
peer.Socket.Broadcast = true;
peer.RawSend(arr, 0, arr.Length, new IPEndPoint(IPAddress.Broadcast, 1900));
peer.Socket.Broadcast = false;
// allow some extra time for router to respond
// System.Threading.Thread.Sleep(50);
}
private void Initialize() {
if(_role == AgentRole.Server) {
_config.EnableMessageType(NetIncomingMessageType.DiscoveryRequest);
_config.Port = _port;
_config.PingInterval = _pingInterval;
_config.ConnectionTimeout = _pingInterval + 1;
_peer = new NetServer(_config);
Log("Server starting on " + _config.LocalAddress + ":" + _config.Port);
} else if(_role == AgentRole.Client) {
_config.EnableMessageType(NetIncomingMessageType.DiscoveryResponse);
_config.PingInterval = _pingInterval;
_config.ConnectionTimeout = _pingInterval + 1;
_peer = new NetClient(_config);
}
_peer.Start();
}
/// <summary>
/// NetBlockEncryptionBase constructor
/// </summary>
public NetBlockEncryptionBase(NetPeer peer)
: base(peer)
{
}
/// <summary>
/// NetXorEncryption constructor
/// </summary>
public NetXorEncryption(NetPeer peer, byte[] key)
: base(peer)
{
m_key = key;
}
/// <summary>
/// NetXorEncryption constructor
/// </summary>
public NetXorEncryption(NetPeer peer, string key)
: base(peer)
{
m_key = Encoding.UTF8.GetBytes(key);
}
public NetAESEncryption(NetPeer peer)
#if UNITY
: base(peer, new RijndaelManaged())
#else
: base(peer, new AesCryptoServiceProvider())
/// <summary>
/// Initializes a new instance of the <see cref="NetDESEncryption"/> class.
/// </summary>
/// <param name="peer">The peer.</param>
/// <param name="key">The key.</param>
public NetDESEncryption(NetPeer peer, string key)
: base(peer, new DESCryptoServiceProvider())
{
SetKey(key);
}
internal NetPeerStatistics(NetPeer peer)
{
m_peer = peer;
Reset();
}
/// <summary>
/// NetUPnP constructor
/// </summary>
public NetUPnP(NetPeer peer)
{
m_peer = peer;
m_discoveryResponseDeadline = double.MinValue;
}
/// <summary>
/// 16 byte key
/// </summary>
public NetXtea(NetPeer peer, byte[] key)
: this(peer, key, 32)
{
}
/// <summary>
/// String to hash for key
/// </summary>
public NetXtea(NetPeer peer, string key)
: this(peer, NetUtility.ComputeSHAHash(Encoding.UTF8.GetBytes(key)), 32)
{
}
public LidgrenNetProvider(NetPeerConfiguration config)
{
_peer = new NetPeer(config);
_stream = new MemoryStream(_buffer);
_reader = new BinaryReader(_stream);
}
/// <summary>
/// Initializes a new instance of the <see cref="NetDESEncryption"/> class.
/// </summary>
/// <param name="peer">The peer.</param>
/// <param name="data">The data.</param>
/// <param name="offset">The offset.</param>
/// <param name="count">The count.</param>
public NetDESEncryption(NetPeer peer, byte[] data, int offset, int count)
: base(peer, new DESCryptoServiceProvider())
{
SetKey(data, offset, count);
}
/// <summary>
/// NetUPnP constructor
/// </summary>
public NetUPnP(NetPeer peer)
{
m_peer = peer;
}
/// <summary>
/// Initializes a new instance of the <see cref="NetDESEncryption"/> class.
/// </summary>
/// <param name="peer">The peer</param>
public NetDESEncryption(NetPeer peer)
: base(peer, new DESCryptoServiceProvider())
{
}
/// <summary>
/// String to hash for key
/// </summary>
public NetXtea(NetPeer peer, string key)
: this(peer, NetUtility.CreateSHA1Hash(key), 32)
{
}
public Rts(EventHandler callback, Lidgren.Network.NetPeer netpeer, short myTeam)
: base(callback)
{
netPeer = netpeer;
iAmServer = netPeer is NetServer;
Game1.Game.DebugMonitor.Position = Direction.NorthEast;
//Game1.Game.Graphics.SynchronizeWithVerticalRetrace = false;
//Game1.Game.IsFixedTimeStep = false;
//Game1.Game.Graphics.ApplyChanges();
//GameTimer.Restart();
//map = new Map(@"Content/map1.muh");
map = new Map("C:\\rts maps\\map2.muh");
pathFinder = new PathFinder(map);
map.InstantiateMapResources();
//Player.Me.Team = myTeam;
Player.Me = Player.Players[myTeam];
actualMapWidth = map.Width * map.TileSize;
actualMapHeight = map.Height * map.TileSize;
Unit.UnitCollisionSweeper.Thread.Suspend();
Unit.UnitCollisionSweeper.Thread.Resume();
Rts.pathFinder.ResumeThread();
uiViewport = GraphicsDevice.Viewport;
worldViewport = GraphicsDevice.Viewport;
minimapViewport = new Viewport(minimapBorderSize, uiViewport.Height - minimapSize - minimapBorderSize, minimapSize, minimapSize);
//minimapViewport = new Viewport(0, 0, minimapSize, minimapSize);
worldViewport.Height -= (minimapSize + minimapBorderSize * 2);
GraphicsDevice.Viewport = worldViewport;
camera = new Camera();
camera.Pos = new Vector2(worldViewport.Width / 2, worldViewport.Height / 2);
button1 = new BaseObject(new Rectangle(10, 25, 25, 25));
button2 = new BaseObject(new Rectangle(10, 52, 25, 25));
button3 = new BaseObject(new Rectangle(10, 79, 25, 25));
button4 = new BaseObject(new Rectangle(10, 106, 25, 25));
button5 = new BaseObject(new Rectangle(10, 133, 25, 25));
if (!contentLoaded)
{
pauseFont = Content.Load <SpriteFont>("spritefonts/pausefont");
fpsFont = Content.Load <SpriteFont>("spritefonts/fpsfont");
unitInfoUnitNameFont = Content.Load <SpriteFont>("spritefonts/UnitInfoUnitNameFont");
unitInfoHpFont = Content.Load <SpriteFont>("spritefonts/UnitInfoHpFont");
unitInfoKillCountFont = Content.Load <SpriteFont>("spritefonts/UnitInfoKillCountFont");
resourceCountFont = Content.Load <SpriteFont>("spritefonts/ResourceCountFont");
bigFont = Content.Load <SpriteFont>("spritefonts/BigMessage");
//brownGuyTexture = Content.Load<Texture2D>("unit textures/browncircleguy");
//brownGuySelectingTexture = Content.Load<Texture2D>("unit textures/browncircleguyselected2");
//brownGuySelectedTexture = Content.Load<Texture2D>("unit textures/browncircleguyselecting2");
greenTeamIndicatorTexture = Content.Load <Texture2D>("unit textures/green team indicator");
redTeamIndicatorTexture = Content.Load <Texture2D>("unit textures/red team indicator");
buttonTexture = Content.Load <Texture2D>("titlebutton1");
moveCommandShrinkerTexture = Content.Load <Texture2D>("greencircle2");
attackMoveCommandShrinkerTexture = Content.Load <Texture2D>("redcircle2");
//normalCursorTexture = Content.Load<Texture2D>("greencursor2");
//attackCommandCursorTexture = Content.Load<Texture2D>("crosshair");
normalCursor = Util.LoadCustomCursor(@"Content/cursors/SC2-cursor.cur");
attackCursor = Util.LoadCustomCursor(@"Content/cursors/SC2-target-none.cur");
boulder1Texture = Content.Load <Texture2D>("boulder1");
tree1Texture = Content.Load <Texture2D>("tree2");
rallyFlagTexture = Content.Load <Texture2D>("redflag");
redCircleTexture = Content.Load <Texture2D>("redcircle");
transparentTexture = Content.Load <Texture2D>("transparent");
transparentGrayTexture = Content.Load <Texture2D>("transparentgray");
transparentBlackTexture = Content.Load <Texture2D>("transparentblack");
whiteBoxTexture = Content.Load <Texture2D>("whitebox");
cogWheelTexture = Content.Load <Texture2D>("cogwheel");
rtsMusic = Content.Load <Song>("music/58 - Weapons Factory");
errorSoundEffect = Content.Load <SoundEffect>("sounds/Error");
//Unit.BulletTexture = Content.Load<Texture2D>("bullet");
Unit.Explosion1Textures = Util.SplitTexture(Content.Load <Texture2D>("explosionsheet1"), 45, 45);
Structure.Explosion1Textures = Util.SplitTexture(Content.Load <Texture2D>("explosionsheet1"), 45, 45);
contentLoaded = true;
}
winForm = (Form)Form.FromHandle(Game1.Game.Window.Handle);
//Cursor.Clip = new System.Drawing.Rectangle(winForm.Location, winForm.Size);
winForm.Cursor = normalCursor;
initializeMapTexture();
initializeCommandCardArea();
initializeSelectionInfoArea();
line.Alpha = .75f;
VisionUpdater = new VisionUpdater(map, Rts.pathFinder, Player.Me.Team);
SelectBox.InitializeSelectBoxLine(GraphicsDevice, Color.Green);
Initializeline(GraphicsDevice, Color.Yellow);
minimapScreenIndicatorBoxLine = new PrimitiveLine(GraphicsDevice, 1);
minimapScreenIndicatorBoxLine.Colour = Color.White;
for (int i = 0; i < HotkeyGroups.Length; i++)
{
HotkeyGroups[i] = new List <RtsObject>();
}
MediaPlayer.Play(rtsMusic);
MediaPlayer.Volume = MusicVolume;
MediaPlayer.IsRepeating = true;
/*new TownHall(map.StartingPoints[myTeam], myTeam);
* camera.Pos = new Vector2(map.StartingPoints[myTeam].X * map.TileSize, map.StartingPoints[myTeam].Y * map.TileSize);
* Player.Me.MaxSupply += StructureType.TownHall.Supply;*/
initializeStartingPoints();
//new Barracks(new Point(10, 14), 2);
//new Roks(new Point(3, 3));
//new Roks(new Point(3, 30));
Player.Me.Roks = 25;
clampCameraToMap();
initialHandShake();
}
/// <summary>
/// NetBlockEncryptionBase constructor
/// </summary>
public NetBlockEncryptionBase(NetPeer peer)
: base(peer)
{
m_tmp = new byte[BlockSize];
}
public LidgrenNetProvider(NetPeerConfiguration config, ILidgrenEvents logger = null)
{
_logger = logger;
_peer = new NetPeer(config);
}
public NetCryptoProviderEncryption(NetPeer peer)
: base(peer)
{
}
