private void Connect()
{
TextureCoordinates.InitializeTextures();
NetworkHandler netHandler = new NetworkHandler();
_networkThread = new Thread(netHandler.NetThread);
_networkThread.IsBackground = true;
_networkThread.Start();
RenderFIFO fifo = new RenderFIFO();
_render = new Thread(fifo.CreateThreads);
_render.IsBackground = true;
_render.Start(GraphicsDevice);
}
public void Start()
{
if (networkServer == null)
{
networkHandler = new NetworkHandler <ReporterClient>();
networkHandler.SetConnectCallback(HandleConnectCallback);
networkHandler.SetHeartbeatCallback(HandleSendHeartbeat, 5000, 20000);
networkHandler.SetDisconnectCallback(HandleDisconnectCallback);
networkHandler.SetMessageCallback((int)MessageType.HEARTBEAT, HandleHeartbeat);
networkHandler.SetMessageCallback((int)MessageType.REPORT_V1, HandleReportV1);
networkHandler.SetMessageCallback((int)MessageType.REPORT_V2, HandleReportV2);
//Little endian format :(
networkServer = new NetworkServer <ReporterClient>(networkHandler, true);
networkServer.Start(new IPEndPoint(IPAddress.IPv6Any, settings.reporterPort));
}
}
public void InitServer(ushort port, string blowfishKey, IGame game, NetworkHandler <ICoreRequest> netReq, NetworkHandler <ICoreResponse> netResp)
{
_game = game;
_server = new Host();
_server.Create(new Address(_serverHost, port), 32, 32, 0, 0);
var key = Convert.FromBase64String(blowfishKey);
if (key.Length <= 0)
{
throw new InvalidKeyException("Invalid blowfish key supplied");
}
Blowfish = new BlowFish(key);
PacketHandlerManager = new PacketHandlerManager(Blowfish, _server, game, netReq, netResp);
}
public async Task Extra_parameters_on_backchannel_should_be_sent()
{
var client = new OidcClient(_options);
var state = await client.PrepareLoginAsync();
var url = $"?state={state.State}&nonce={state.Nonce}&code=bar";
var key = Crypto.CreateKey();
var idToken = Crypto.CreateJwt(key, "https://authority", "client",
new Claim("at_hash", Crypto.HashData("token")),
new Claim("sub", "123"),
new Claim("nonce", state.Nonce));
var tokenResponse = new Dictionary <string, object>
{
{ "access_token", "token" },
{ "expires_in", 300 },
{ "id_token", idToken },
{ "refresh_token", "refresh_token" }
};
_options.ProviderInformation.KeySet = Crypto.CreateKeySet(key);
var handler = new NetworkHandler(JsonSerializer.Serialize(tokenResponse), HttpStatusCode.OK);
_options.BackchannelHandler = handler;
var backChannel = new BackChannelParameters
{
Extra = new Parameters
{
{ "foo", "foo" },
{ "bar", "bar" }
}
};
var result = await client.ProcessResponseAsync(url, state, backChannel);
result.IsError.Should().BeFalse();
result.AccessToken.Should().Be("token");
result.IdentityToken.Should().NotBeNull();
result.User.Should().NotBeNull();
var body = handler.Body;
body.Should().Contain("foo=foo");
body.Should().Contain("bar=bar");
}
public async Task ClientAccessTokenParameters_should_propagate()
{
var handler = new NetworkHandler();
void options(ClientAccessTokenManagementOptions o)
{
o.Clients.Add("test", new ClientCredentialsTokenRequest
{
Address = "https://test",
ClientId = "test"
});
}
var service = Setup.ClientCollection(options, handler)
.BuildServiceProvider()
.GetRequiredService <IClientAccessTokenManagementService>();
var parameters = new ClientAccessTokenParameters
{
Resource = "urn:resource",
Context =
{
{ "context_item", "context_value" }
}
};
var result = await service.GetClientAccessTokenAsync(parameters : parameters);
var requestContent = await handler.Content.ReadAsStringAsync();
requestContent.Should().Contain("resource=urn%3Aresource");
#if NET5_0_OR_GREATER
parameters = handler.Options.SingleOrDefault(o => o.Key == AccessTokenManagementDefaults.AccessTokenParametersOptionsName).Value
as ClientAccessTokenParameters;
#else
var properties = handler.Properties;
parameters =
properties[AccessTokenManagementDefaults.AccessTokenParametersOptionsName] as
ClientAccessTokenParameters;
#endif
parameters.Should().NotBeNull();
parameters.Context["context_item"].First().Should().Be("context_value");
}
/// <summary>
/// Deserializes a json object into a HestiaServer object.
/// </summary>
/// <param name="jsonServer"></param>
/// <param name="networkHandler"></param>
/// <returns>A HestiaServer object</returns>
public HestiaServer DeserializeServer(JToken jsonServer, NetworkHandler networkHandler)
{
string id = jsonServer.Value <string>("server_id");
string name = jsonServer.Value <string>("server_name");
string address = jsonServer.Value <string>("server_address");
int port = jsonServer.Value <int>("server_port");
HestiaServerInteractor interactor = new HestiaServerInteractor(networkHandler, id);
HestiaServer server = new HestiaServer(false, interactor)
{
Id = id,
Name = name,
Address = address,
Port = port
};
return(server);
}
public DatabaseClient(TcpClient connectedConnection, DatabaseDriver databaseDriver)
{
connected = true;
this.databaseDriver = databaseDriver;
NetworkHandler <object> networkHandler = new NetworkHandler <object>();
networkHandler.SetHeartbeatCallback(HandleSendHeartbeat, 5000, 20000);
networkHandler.SetDisconnectCallback(HandleDisconnect);
networkHandler.SetMessageCallback((int)MessageType.HEARTBEAT, HandleHeartbeat);
networkHandler.SetMessageCallback((int)MessageType.CONNECT, HandleConnect);
networkHandler.SetMessageCallback((int)MessageType.REPORT, HandleReport);
networkHandler.SetMessageCallback((int)MessageType.DISCONNECT, HandleDisconnect);
networkClient = new NetworkClient <object>(networkHandler, connectedConnection, false);
if (networkClient == null)
{
//Shutup compiler.
}
}
void Start()
{
_networkHandler = Instantiate(NetworkHandlerPrefab, transform);
_networkHandler.Initialize(Config.ProgramQueryLimit);
SearchComponent.Setup();
SearchComponent.OnSearchStarted += HandleSearchStarted;
SearchComponent.OnSearchCanceled += HandleSearchCanceled;
ProgramListComponent.Setup(Config.NearBottomThreshold);
ProgramListComponent.OnReachEnd += HandleOnReachEnd;
ProgramListComponent.OnSelectDatum += HandleSelectDatum;
ProgramDetailComponent.Setup();
ProgramDetailComponent.OnBackPressed += HandleBackFromDetail;
LoadDefault();
}
public void Setup()
{
deserializer = new HestiaServerDeserializer();
jsonServer = new JObject
{
["created_at"] = "dummyTime",
["server_id"] = "dummyId",
["server_name"] = "dummyName",
["server_address"] = "https://dummyAddress",
["server_port"] = "1000",
["updated_at"] = "dummyType",
["user_id"] = "dummyId"
};
networkHandler = new NetworkHandler("https://dummyAddress:1000", "dummyToken");
Assert.IsNotNull(deserializer);
Assert.IsNotNull(jsonServer);
}
public DiscoveryCacheTests()
{
var discoFileName = FileName.Create("discovery.json");
var document = File.ReadAllText(discoFileName);
var jwksFileName = FileName.Create("discovery_jwks.json");
var jwks = File.ReadAllText(jwksFileName);
_successHandler = new NetworkHandler(request =>
{
if (request.RequestUri.AbsoluteUri.EndsWith("jwks"))
{
return(jwks);
}
return(document);
}, HttpStatusCode.OK);
}
public override void Connect(System.Action <StoryboardHook> invokeTransition)
{
// For a Unity UI Button we invoke our storyboard transition when
// our Button is clicked.
button.onClick.AddListener(() =>
{
// Instantiate network handler.
GameObject networkHandlerObject = Instantiate(networkHandlerPrefab);
// Get network handler component.
NetworkHandler = networkHandlerObject.GetComponent <NetworkHandler>();
// Check for custom connection text.
if (!string.IsNullOrEmpty(connectionInput.text))
{
// Split connection text to get address to get port.
string[] connection = connectionInput.text.Split(':');
// Check for new port.
if (connection.Length > 1)
{
// Parse port input.
Int32.TryParse(connection[1], out defaultPort);
}
// Assign address.
NetworkHandler.networkAddress = connection[0];
}
else
{
// Assign default address.
NetworkHandler.networkAddress = defaultAddress;
}
// Apply port to network handler.
NetworkHandler.networkPort = defaultPort;
Debug.Log(NetworkHandler.networkAddress);
Debug.Log(NetworkHandler.networkPort);
// Invoke transition to next canvas.
invokeTransition(this);
});
}
void Start()
{
if (networkHandler == null)
{
networkHandler = this;
messageQueue = new List <JSONNode>();
errorQueue = new List <JSONNode>();
authenticatedAs = null;
ws = new WebSocket(serverURL);
ws.OnOpen += (sender, e) =>
{
print("WEBSOCKET: Connected - " + e.ToString());
connected = true;
};
ws.OnMessage += (sender, e) =>
{
JSONNode data = JSON.Parse(e.Data);
messageQueue.Add(data);
};
ws.OnError += (sender, e) =>
{
JSONNode data = JSON.Parse(e.Message);
errorQueue.Add(data);
};
ws.OnClose += (sender, e) =>
{
print("WEBSOCKET: Closed - " + e.Reason);
connected = false;
};
ws.Connect();
}
else
{
Destroy(gameObject);
}
}
public GameScreen(Game1 game, String name, String IP, int port, string selectedChar)
{
this.game = game;
cam = new Camera2D(game.GraphicsDevice);
MediaPlayer.Volume = 0;
this.IP = IP;
this.port = port;
this.pName = name;
this.selectedChar = selectedChar;
MediaPlayer.Play(ContentChest.Instance.gameMusic);
pauseMenu = new PauseMenu();
Random ran = new Random();
netHandler = new NetworkHandler(game, this, name, IP, port, selectedChar);
map = new Map(this);
ui = new UserInterface(this);
}
// Switches from one panel to another by making it visible and hiding the others
private void SetPanel(GamePanel panel)
{
foreach (Panel p in panels)
{
if (p.Name.ToLower().Contains(panel.ToString().ToLower()))
{
if (currentPanel != null)
{
currentPanel.Visible = false;
}
currentPanel = p;
currentPanel.Visible = true;
currentGamePanel = panel;
BackColor = currentPanel.BackColor;
break;
}
}
// Load events for specific panels
switch (currentGamePanel)
{
case GamePanel.Ip:
IPTextBox.Text = NetworkHandler.GetLocalIpAddress().ToString();
break;
case GamePanel.Lobby:
break;
case GamePanel.Question:
break;
case GamePanel.Wait:
break;
case GamePanel.Scores:
break;
default:
break;
}
}
async private void LoadImageandSetImageBrush(IWallpaperHandler potd)
{
var networkHandler = new NetworkHandler();
if (networkHandler.checkInternetConnection())
{
InternetUnavailableMessage.Visibility = Visibility.Collapsed;
ImageBrush imageBrush = new ImageBrush();
stream = await potd.GetStreamOfImage();
await ImageBitmap.SetSourceAsync(stream.AsRandomAccessStream());
imageBrush.ImageSource = ImageBitmap;
WallsPage.Background = imageBrush;
}
else
{
InternetUnavailableMessage.Visibility = Visibility.Visible;
}
}
public async Task Start()
{
DataBases = new DataBases();
await DataBases.Open();
Console.WriteLine("Starting up...");
await Keys.LoadAPIKeys();
mHandler = new MainHandler();
mHandler.Start();
NetworkHandler = new NetworkHandler(1994);
NetworkHandler.Start();
DiscordClient = new DiscordClient(NetworkHandler);
Console.WriteLine($"{DesignFunctions.Time.GetTime()} Server started [ {NetworkHandler.tcpListener.LocalEndpoint.ToString()} ]");
await Task.Delay(-1);
}
/// <summary>
/// constructor
/// </summary>
/// <param name="_players">players list</param>
/// <param name="_playerinfo">player info list</param>
/// <param name="_gamepanel">game panel</param>
public TurnManager(Player[] _players, List <PlayerInfo> _playerinfo, GamePanel _gamepanel)
{
gamepanel = _gamepanel;
gamepanel.Deactivate();
playerPanels = _playerinfo;
players = _players.ToList(); // <-- first i do to array and then to list? might need fix?
nxtTrnCmd = new NetworkCommand("G:NTURN", Turn, false, true);
if (NetworkHandler.getInstance().isHost()) // <-- what if we have dedicated server?
{
nxtTrnCmd.send(new string[3] {
_players[0].ID.ToString(), "0", "0"
});
}
OnGameEnded += (x, y) => {
Account.updateScore(x == Account.name); // boi!
};
}
public async Task Using_default_configuration_with_single_client_config_should_succeed()
{
var handler = new NetworkHandler();
void options(AccessTokenManagementOptions o)
{
o.Client.Clients.Add("test", new ClientCredentialsTokenRequest
{
Address = "https://test",
ClientId = "test"
});
}
var service = Setup.ClientCollection(options, handler)
.BuildServiceProvider()
.GetRequiredService <IClientAccessTokenManagementService>();
var result = await service.GetClientAccessTokenAsync();
handler.Address.Should().Be(new Uri("https://test"));
}
public BrokerProtocolHandler(IMessageSerializer messageSerializer, NetworkHandler networkHandler)
{
this.messageSerializer = messageSerializer;
this.networkHandler = networkHandler;
subscriptions.Add(NetAction.DestinationType.TOPIC, new Dictionary <string, Subscription>());
subscriptions.Add(NetAction.DestinationType.QUEUE, new Dictionary <string, Subscription>());
networkHandler.MessageReceived += delegate(byte[] encodedData) {
try{
NetMessage netMessage = DecodeMessage(encodedData);
HandleIncommingMessage(netMessage);
}catch (Exception ex) {
DealWithException(ex);
}
};
networkHandler.IoFailed += new NetworkHandler.IoFailureHandler(IoFailHandler);
networkHandler.Start();
}
// Listener for the ip textbox
private void IPTextBox_KeyDown(object sender, KeyEventArgs e)
{
if (e.KeyCode != Keys.Return)
{
return;
}
e.Handled = true;
e.SuppressKeyPress = true;
string ipAddress = IPTextBox.Text;
if (!NetworkHandler.ValidateIPv4(ipAddress))
{
IPTextBox.Text = @"Invalid IP";
}
else
{
new Thread(networkHandler.RunClient).Start(IPTextBox.Text);
SetPanel(GamePanel.Lobby);
}
}
// Start is called before the first frame update
void Start()
{
networkHandler = GetComponent <NetworkHandler>();
/*for(int i = 0; i < 30; i++)
* {
* GameObject newUser = Instantiate(userPrefab);
* newUser.transform.SetParent(this.transform);
* newUser.transform.position = new Vector3(196, -105.55f, 0);
* users[i] = newUser;
* }*/
menu = normalMenu;
username = PlayerPrefs.GetString("Player_Username", "");
SetGlobalUserBenis(ulong.Parse(PlayerPrefs.GetString("UserBenis", "1024")));
benitrat0r.GetComponent <Benitrat0r>().SetBenis(userBenis);
//Invoke("StartBotGame", 2f);
//Invoke("StartNetworkGame", 2f);
}
private async Task WaitUntilScanned()
{
while (true)
{
string getResult = await netHandler.GETRequestAsync(qrStatusURL + "&tip=" + (qrCodeScanned ? "0" : "1"), true);
if (getResult.Contains("408"))
{
continue;
}
else if (getResult.Contains("400"))
{
QRCodeExpired?.Invoke(this, null);
return;
}
else if (getResult.Contains("201"))
{
NetworkHandler.ReadUntil(ref getResult, "base64,");
MemoryStream ms = new MemoryStream(Convert.FromBase64String(NetworkHandler.ReadUntil(ref getResult, "'")));
Image pp = Image.FromStream(ms);
qrCodeScanned = true;
QRCodeScanned.Invoke(this, new QRCodeScannedEventArgs()
{
profilePicture = pp
});
}
else if (getResult.Contains("200"))
{
NetworkHandler.ReadUntil(ref getResult, "uri=\"");
redirectUri = NetworkHandler.ReadUntil(ref getResult, "\"");
host = redirectUri;
NetworkHandler.ReadUntil(ref host, "//");
host = NetworkHandler.ReadUntil(ref host, "/");
LoginConfirmed.Invoke(this, null);
FinishLoginAsync();
break;
}
}
}
public async Task Sending_authorization_header_should_succeed()
{
_options.ClientSecret = "secret";
_options.TokenClientCredentialStyle = Client.ClientCredentialStyle.AuthorizationHeader;
var client = new OidcClient(_options);
var state = await client.PrepareLoginAsync();
var url = $"?state={state.State}&nonce={state.Nonce}&code=bar";
var key = Crypto.CreateKey();
var idToken = Crypto.CreateJwt(key, "https://authority", "client",
new Claim("at_hash", Crypto.HashData("token")),
new Claim("sub", "123"),
new Claim("nonce", state.Nonce));
var tokenResponse = new Dictionary <string, object>
{
{ "access_token", "token" },
{ "expires_in", 300 },
{ "id_token", idToken },
{ "refresh_token", "refresh_token" }
};
_options.ProviderInformation.KeySet = Crypto.CreateKeySet(key);
var backChannelHandler = new NetworkHandler(JsonSerializer.Serialize(tokenResponse), HttpStatusCode.OK);
_options.BackchannelHandler = backChannelHandler;
var result = await client.ProcessResponseAsync(url, state);
var request = backChannelHandler.Request;
request.Headers.Authorization.Should().NotBeNull();
request.Headers.Authorization.Scheme.Should().Be("Basic");
request.Headers.Authorization.Parameter.Should()
.Be(BasicAuthenticationOAuthHeaderValue.EncodeCredential("client", "secret"));
}
public void ConnectToServer(IPEndPoint endPoint)
{
// ToDo
const string token = "J²";
if (net != null)
{
net.OnDisconnected -= OnNetworkDisconnected;
net.Close();
}
byte[] clientIdentifier = Preferences.Get <byte[]>("ClientIdentifier");
if (clientIdentifier == null)
{
// Generate new client identifier
Guid guid = Guid.NewGuid();
clientIdentifier = guid.ToByteArray();
Preferences.Set <byte[]>("ClientIdentifier", clientIdentifier);
Preferences.Commit();
}
string userName = Preferences.Get <string>("UserName");
if (userName == null)
{
userName = TryGetDefaultUserName();
if (!string.IsNullOrEmpty(userName))
{
Preferences.Set <string>("UserName", userName);
Preferences.Commit();
}
}
net = new NetworkHandler(token, clientIdentifier, userName);
net.OnDisconnected += OnNetworkDisconnected;
net.RegisterCallback <LoadLevel>(OnNetworkLoadLevel);
net.Connect(endPoint);
}
public void SetUpDevice()
{
ActivatorState activatorState = new ActivatorState(false, "bool");
string activatorId = "1234";
string activatorName = "bob";
int activatorRank = 0;
activator = new Activator(activatorId, activatorName, activatorRank, activatorState);
activators = new List <Activator>
{
activator
};
networkHandler = new NetworkHandler(dummyAddress);
serverInteractor = new HestiaServerInteractor(networkHandler);
device = new Device(deviceId, deviceName, type, activators, serverInteractor);
activator.Device = device;
Assert.IsNotNull(device);
}
public void TryLogin()
{
/*
* if (string.IsNullOrEmpty(loginName.text) || string.IsNullOrEmpty(password.text))
* return;
*/
//Actually connect with pi
NetworkHandler net = new NetworkHandler("placeholderIP");
if (!net.Connect(loginName.text, password.text))
{
return;
}
//Create database and assign it to the main interface so it can display its contents
Database data = new Database(net);
MainInterface.Instance.data = data;
//Make screen invisible
StartCoroutine(LerpBlur());
}
/// <summary>
/// Raises the appearing event.
/// </summary>
protected override void OnAppearing()
{
base.OnAppearing();
if (DoctorsDataManager.Instance.isDoctorAlreadyLoaded(_doctorId))
{
DoctorModel doctor = DoctorsDataManager.Instance.GetModelById(_doctorId);
BindingContext = doctor;
_dataStack.IsVisible = true;
_activityIndicatorStack.IsVisible = false;
}
else
{
_dataStack.IsVisible = false;
_activityIndicatorStack.IsVisible = true;
Dictionary <string, string> networkParms = new Dictionary <string, string> ();
networkParms.Add(Constants.Constants.PARAM_ID, _doctorId);
_networkHandler = new NetworkHandler("doctors/{id}", networkParms, this, 1);
_networkHandler.GetJsonData(true, Constants.Constants.JSON_DOCTORS);
}
}
/// <summary>
/// generate lobby
/// </summary>
private void createLobby()
{
lobbyManager = new LobbyManager(Account.name);
tb_lobbyplayerdisplay.Text = Account.name + "\n";
lobbyManager.OnPlayerJoin += (x) =>
{
this.Dispatcher.Invoke(() =>
{
tb_lobbyplayerdisplay.Text += x + "\n";
if (NetworkHandler.getInstance().isHost())
{
_onGengreChange.send(tb_lobbygenre.Text);
}
});
};
lobbyManager.init();
lobbyManager.OnStart += (x) =>
{
string genre = tb_lobbygenredisplay.Text != "" ? tb_lobbygenredisplay.Text : "cute cats";
gamepanel = new GamePanel(5, 4, 120, 200, genre); // init the game panel
this.addChild(gamepanel);
List <PlayerInfo> playerInfo = new List <PlayerInfo>();
for (int i = 0; i < x.Length; i++)
{
PlayerInfo panel = new PlayerInfo(x[i].name, new Point(300, 70), (PlayerInfo.ScreenLocation)i, 20);
this.addChild(panel);
playerInfo.Add(panel);
}
turnManager = new TurnManager(x, playerInfo, gamepanel);
};
}
public void Run()
{
r.NextBytes(randomBytes);
//ByteRecycler must be allowed to allocate the size of the biggest message
ByteRecycler.AddPoolSize(128 * 1024 * 1024);
NetworkHandler <StateObject> handler = new NetworkHandler <StateObject>(false);
handler.RegisterConnectCallback(Connected);
handler.RegisterDisconnectCallback(Disconnected);
handler.RegisterCallback(0, GotMessage);
handler.RegisterCallback(1, ReliableReceive);
DarkNetwork <StateObject> dn = new DarkNetwork <StateObject>();
IPAddress netAddr = IPAddress.Parse("2403:5800:9100:5b00:76da:38ff:fea3:9dbe");
dn.SetupClient(new IPEndPoint(netAddr, 12345), handler);
Thread.Sleep(1000);
NetworkMessage nmbig = NetworkMessage.Create(1, randomBytes.Length, NetworkMessageType.ORDERED_RELIABLE);
Array.Copy(randomBytes, 0, nmbig.data.data, 0, randomBytes.Length);
handler.SendMessage(nmbig);
int messageID = 0;
while (running)
{
NetworkMessage nm = NetworkMessage.Create(0, 2048, NetworkMessageType.ORDERED_UNRELIABLE);
byte[] sendBytes = Encoding.UTF8.GetBytes("Message " + messageID++);
Array.Copy(sendBytes, 0, nm.data.data, 0, sendBytes.Length);
nm.data.size = sendBytes.Length;
handler.SendMessage(nm);
//Recycler<NetworkMessage>.GarbageCollect(500, 1000);
//ByteRecycler.GarbageCollect(2048, 500, 1000);
//ByteRecycler.GarbageCollect(128 * 1024 * 1024, 2, 4);
//PrintRecyclerStats();
Thread.Sleep(1000);
}
dn.Shutdown();
}
// Update is called once per frame
void Update()
{
List <Collider> removedObjects = collidedObjects.FindAll(colloided => colloided == null || !colloided.gameObject.activeSelf);
foreach (Collider collider in removedObjects)
{
OnTriggerExit(collider);
}
if (hover)
{
Debug.Log("hover time " + (Time.fixedTime - hoverTimer));
}
if (hover && (Time.fixedTime - hoverTimer) > HOVER_TIMER)
{
NetworkHandler network = GameObject.Find("MainBase").GetComponentInChildren <NetworkHandler>();
hoverTimer = Time.fixedTime;
}
if (selected)
{
float moveX = (Input.GetKey(KeyCode.Keypad4) ? -MOVE_SPEED : 0) + (Input.GetKey(KeyCode.Keypad6) ? MOVE_SPEED : 0);
float moveY = (Input.GetKey(KeyCode.Keypad3) ? -MOVE_SPEED : 0) + (Input.GetKey(KeyCode.Keypad9) ? MOVE_SPEED : 0);
float moveZ = (Input.GetKey(KeyCode.Keypad2) ? -MOVE_SPEED : 0) + (Input.GetKey(KeyCode.Keypad8) ? MOVE_SPEED : 0);
Vector3 move = new Vector3(moveX, moveY, moveZ);
transform.position += move * MOVE_SPEED * Time.deltaTime;
float scale = 1 + ((Input.GetKey(KeyCode.Keypad1) ? -SCALE_MULTIPLIER : 0) + (Input.GetKey(KeyCode.Keypad7) ? SCALE_MULTIPLIER : 0));
transform.localScale = transform.localScale * scale;
if (Input.GetKeyDown("delete"))
{
DataStore.Instance.RemoveOhObject(this.gameObject);
GetNetworkHandler().PublishItemList();
}
}
}
public void BeginProcess()
{
handler = new NetworkHandler(this, skt);
handler.BeginHandling();
}
// Use this for initialization
void Start()
{
networkHandler = new NetworkHandler();
fadeoutTexture = Resources.Load<Texture>("textures/solid");
Entities = new List<GameEntity>();
styles = new Dictionary<string, GUIStyle>();
maps = new List<MapDefinition>();
buyables = new List<BuyableDefinition>();
if (StyleDictionary != null)
ProcessStyleDictionary();
if (MapDictionary != null)
ProcessMapDictionary();
if (PurchaseDictionary != null)
ProcessBuyablesDictionary();
instance = this;
if (RunGameLogic)
StartGame();
else
{
//GameHUD.instance.s
MenuHandler.instance.SetMenuEnabled("MainMenu", true);
}
}
public static void Close()
{
Flush();
if (m_Server != null)
{
try
{
m_Server.Shutdown(SocketShutdown.Both);
}
catch
{
}
try
{
m_Server.Close();
}
catch
{
}
m_Server = null;
}
if (m_Logger != null)
{
m_Logger.WriteLine();
m_Logger.WriteLine("#####\tEnding packet log on {0}\t#####", DateTime.Now);
m_Logger.Flush();
m_Logger.Close();
m_Logger = null;
}
if (m_Protocol != null)
{
m_Protocol.WriteLine();
m_Protocol.WriteLine("#####\tEnding protocol log on {0}\t#####", DateTime.Now);
m_Protocol.Flush();
m_Protocol.Close();
m_Protocol = null;
}
m_ServerIP = null;
m_ServerIPEP = null;
m_ServerHost = null;
m_Tree = null;
m_Buffer = null;
OnRecv = null;
OnSend = null;
OnPacketHandle = null;
m_Table = null;
m_UnpackBuffer = null;
m_OutputBuffer = null;
m_CryptoProvider = null;
}
public Form1()
{
InitializeComponent();
network = new NetworkHandler();
}
