public static void AddFriends(JSONObject json) {
if (json["friends"].Count > 0) {
json = json["friends"];
for (int i = 0; i < json.keys.Count; i++) {
ServerEntity temp = new ServerEntity();
temp.sid = json.keys[i];
temp.episodes = json[i]["episodes"].list.ConvertAll<int>(JSONObjectToInt);
temp.petition.life = json[i]["petitions"]["life"].b;
temp.petition.episode = json[i]["petitions"]["episode"].b;
temp.received.life = json[i]["received"]["life"].b;
temp.received.boosters = json[i]["received"]["boosters"].list.ConvertAll<int>(JSONObjectToInt);
temp.sended.life = json[i]["sended"]["life"].b;
temp.sended.boosters = json[i]["sended"]["boosters"].list.ConvertAll<int>(JSONObjectToInt);
temp.levelsHistory = json[i]["history"].list.ConvertAll<ServerEntity.Level>(JSONObjectToLevelHistory);
serverEntities.Add(temp);
foreach (int episode in temp.episodes) {
Map.Instance.episodes[episode - 1].sids.Add(temp.sid);
}
}
}
onStartInitializeSuccess(2);
}
public StartWindow()
{
ch = new BLL.CamearHelper();
bool res = ch.getMysqlConfig();
if (res == true)
{
LoginPark lp = new LoginPark();
lp.ShowDialog();
this.Close();
}
else
{
InitializeComponent();
cc = new ServerPreferencesControl();
cc.LoadDefaultConfig();
//传参数到UI界面
ServerEntity SQLdata = cc.GetServerConfig();
txtservername.Text = SQLdata.Server;
txtport.Text = SQLdata.Port.ToString();
txtsqlname.Text = SQLdata.Database;
txtusername.Text = SQLdata.User;
txtpwd.Text = SQLdata.Password;
}
}
/// <summary>
/// 读取服务器配置文件
/// </summary>
/// <param name="serverFilePath"></param>
public List <ServerEntity> ReadXml(string serverFilePath)
{
List <ServerEntity> seList = new List <ServerEntity>();
XmlDocument xmlDoc = new XmlDocument();
XmlReaderSettings setting = new XmlReaderSettings();
setting.IgnoreComments = true;
xmlDoc.Load(serverFilePath);
XmlNode root = xmlDoc.SelectSingleNode("serverlist");
XmlNodeList xn1 = root.ChildNodes;
//位置在info中
foreach (XmlNode item in xn1)
{
ServerEntity se = new ServerEntity();
XmlElement xe = (XmlElement)item;
se.Name = xe.GetAttribute("name");
//位置在server中
XmlNodeList xn = item.ChildNodes;
se.ServerIP = xn[0].InnerText;
se.ServerPort = xn[1].InnerText;
se.ServerUserName = xn[2].InnerText;
se.ServerPassword = xn[3].InnerText;
XmlNodeList xn2 = xn[4].ChildNodes;
foreach (XmlNode child in xn2)
{
se.ServerDBName.Add(child.InnerText);
}
seList.Add(se);
}
return(seList);
}
public void Test1()
{
_server_api = new OpenServerApi("./server_information.json");
_server_mapper = new ServerEntityMapper();
_server_repository = new ServerRepository(_server_api, _server_mapper);
_server_creator = new ServerCreatorRequest(_server_repository);
_server_activator = new ServerActivatorRequest(_server_repository);
ServerEntity server = _server_creator.Handle(666);
Assert.IsNotNull(server);
Assert.AreEqual(666, server.Port);
ServerEntity server2 = _server_creator.Handle(667);
Assert.IsNotNull(server2);
Assert.AreEqual(667, server2.Port);
Assert.AreEqual(666, server.Port);
Assert.AreNotSame(server, server2);
server = _server_activator.Handle(server, true, new ServerAcceptCallback(server));
Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
socket.Connect(new IPEndPoint(IPAddress.Parse("127.0.0.1"), 666));
Assert.AreEqual(true, socket.Connected);
Assert.AreEqual(true, server.IsRunning);
Assert.AreEqual(false, server2.IsRunning);
server = _server_activator.Handle(server, false, null);
Assert.AreEqual(false, server.IsRunning);
}
/// <summary>
/// Tries to move a user in to a new zone.
/// </summary>
public bool RequestZoneTransfer(ServerEntity entity, int newZoneID)
{
//Check the zone exists
if (m_zones.ContainsKey(newZoneID))
{
Zone newZone = m_zones[newZoneID];
//See if the user is already in a zone
if (m_userZones.ContainsKey(entity))
{
//Remove them from their current zone
Zone currentZone = m_userZones[entity];
currentZone.RemoveEntity(entity);
}
else
{
//Add them to the zone index
m_userZones.Add(entity, newZone);
}
//Move them in to their new zone
m_userZones[entity] = newZone;
newZone.AddEntity(entity);
return(true);
}
return(false);
}
private void OnEntityUse(int player, ServerEntityId id)
{
ServerEntity e = m.EntityGet(id);
if (e.sign == null)
{
return;
}
// TODO: Check permissions
Dialog d = new Dialog();
d.Width = 400;
d.Height = 200;
d.IsModal = true;
d.Widgets = new Widget[4];
int widgetCount = 0;
var font = new DialogFont("Verdana", 11f, DialogFontStyle.Bold);
d.Widgets[widgetCount++] = Widget.MakeSolid(0, 0, 300, 200, Color.FromArgb(255, 50, 50, 50).ToArgb());
d.Widgets[widgetCount++] = Widget.MakeTextBox(e.sign.text, font, 50, 50, 200, 50, Color.FromArgb(255, 0, 0, 0).ToArgb());
Widget okHandler = Widget.MakeSolid(100, 100, 100, 50, Color.FromArgb(255, 100, 100, 100).ToArgb());
okHandler.ClickKey = (char)13;
okHandler.Id = "UseSign_OK";
d.Widgets[widgetCount++] = okHandler;
d.Widgets[widgetCount++] = Widget.MakeText("OK", font, 100, 100, Color.FromArgb(255, 0, 0, 0).ToArgb());
editingSign[player] = id;
m.SendDialog(player, "UseSign", d);
}
public async Task <ServerEntity> CreateUpdateServerAsync(CreateUpdateServerRequest request, int userId)
{
var server = await _database.ServerList.FindAsync(request.Id);
if (server == null)
{
server = new ServerEntity
{
Name = request.Name,
Description = request.Description,
IpAddress = request.IpAddress,
Port = request.Port,
OwnerUserId = userId,
StarCount = 0,
ImageUrl = request.ImageUrl
};
await _database.ServerList.AddAsync(server);
}
else
{
if (userId != server.OwnerUserId)
{
return(null);
}
server.Name = request.Name;
server.Description = request.Description;
server.IpAddress = request.IpAddress;
server.Port = request.Port;
server.ImageUrl = request.ImageUrl;
_database.ServerList.Update(server);
}
await _database.SaveChangesAsync();
return(server);
}
private void OnEntityUpdate(ServerEntityId id)
{
ServerEntity e = m.EntityGet(id);
if (e.sign == null)
{
return;
}
if (e.drawModel == null)
{
e.drawModel = new ServerEntityAnimatedModel();
}
e.drawModel.model = "signmodel.txt";
e.drawModel.texture = "signmodel.png";
e.drawModel.modelHeight = 1.3f;
if (e.drawText == null)
{
e.drawText = new ServerEntityDrawText();
}
e.drawText.text = e.sign.text;
e.drawText.dx = 0.1f;
e.drawText.dy = 1.1f;
e.drawText.dz = 0.1f;
e.usable = true;
if (e.drawName == null)
{
e.drawName = new ServerEntityDrawName();
e.drawName.name = "Sign";
e.drawName.onlyWhenSelected = true;
}
}
public async Task <DaoResultMessage> CreateServerEntity(string id, ServerEntity entity)
{
DaoResultMessage message = new DaoResultMessage();
try
{
using (var context = new DjLiveCpContext())
{
entity.Id = id;
var item = context.Server.Add(entity);
await context.SaveChangesAsync();
message.Code = DaoResultCode.Success;
message.Message = "添加成功!";
message.para = item;
}
}
catch (Exception e)
{
LogHelper.Error(e.Message, e);
message.Code = DaoResultCode.UnExpectError;
message.Message = e.Message;
}
return(message);
}
public async Task <List <ServerEntity> > LoadServers()
{
var documents = await serversCollection.GetDocumentsListAsync();
serversList.Clear();
foreach (var document in documents)
{
var server = new ServerEntity
{
Id = document["Id"].AsInt32,
Name = document["Name"].AsString,
Ip = document["IP"].AsString,
Port = document["Port"].AsInt32,
Region = (Region)document["Region"].AsInt32,
PlayersCount = document["PlayersCount"].AsInt32,
PlayersMax = document["PlayersMax"].AsInt32,
MinutesToNextLevelChange = document["MinutesToNextLevelChange"].AsInt32,
LastUpdateDateTime = document["LastUpdateDateTime"].ToLocalTime()
};
serversList.Add(server);
}
//serversList = serversList.OrderBy(s => s.Id).ToList();
return(serversList);
}
public async Task <DaoResultMessage> Add2Account(string accountId, ServerEntity entity)
{
DaoResultMessage message = new DaoResultMessage();
try
{
using (var context = new DjLiveCpContext())
{
var dbentity = context.Account.FirstOrDefault(obj => obj.Id == accountId);
if (dbentity != null)
{
entity.AccountEntities.Add(dbentity);
context.Server.Add(entity);
await context.SaveChangesAsync();
}
else
{
message.Code = DaoResultCode.ItemNotExist;
message.Message = "修改失败,对象不存在!";
}
}
}
catch (Exception e)
{
LogHelper.Error(e.Message, e);
message.Code = DaoResultCode.UnExpectError;
message.Message = e.Message;
}
return(message);
}
public static HostOption Parse2Conf(this ServerEntity server)
{
var serviceConfig = JsonConvert.DeserializeObject <LiveServiceConfig>(server.Option);
HostOption hostOption = new HostOption();
if (serviceConfig != null)
{
hostOption.listen = serviceConfig.RtmpPort != 0 ? serviceConfig.RtmpPort : hostOption.listen;
hostOption.http_api = new ApiOption("")
{
listen = serviceConfig.ApiPort != 0 ? serviceConfig.ApiPort : 1985,
};
hostOption.http_server = new HttpOption("")
{
listen = serviceConfig.HttpPort != 0 ? serviceConfig.HttpPort : 8080,
};
}
if (server.Domains != null)
{
foreach (DomainEntity serverDomain in server.Domains)
{
hostOption.VHostOptions.Add(serverDomain.Parse2Conf());
}
}
return(hostOption);
}
public async Task <int> GetServerNodesCount(string userId, ServerEntity entityDelta)
{
try
{
using (var context = new DjLiveCpContext())
{
var sql = $@"SELECT Count(0) FROM sys_servernode";
var paraObjects = new object[] { };
if (!string.IsNullOrEmpty(userId))
{
sql = $@"SELECT Count(0) FROM sys_servernode as b
join sys_alli_account_servernode as c
on c.AccountId = {"{0}"}
and b.Id = c.NodeId";
paraObjects = new object[] { userId };
}
var objs = context.Database.SqlQuery <int>(sql, paraObjects);
return(await objs.FirstOrDefaultAsync());
}
}
catch (Exception e)
{
LogHelper.Error(e.Message, e);
return(0);
}
}
public static ServerEntity LoadServerConfig()
{
ServerEntity result = new ServerEntity();
string path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Configurations/Server.xml");
XDocument xml = XDocument.Load(path);
XElement root = xml.Root;
result.RunWays = root.Element("RunWays").Value.Trim();
result.Port = int.Parse(root.Element("Port").Value.Trim());
result.SendThreads = int.Parse(root.Element("SendThreads").Value.Trim());
result.MaxPostLength = long.Parse(root.Element("MaxPostLength").Value.Trim());
result.MaxHeaderLines = int.Parse(root.Element("MaxHeaderLines").Value.Trim());
result.MaxQueuedRequests = int.Parse(root.Element("MaxQueuedRequests").Value.Trim());
result.HostList = new List <string>();
XElement hostList = root.Element("HostList");
foreach (XElement item in hostList.Elements("Host"))
{
result.HostList.Add(string.Format("{0}:{1}", item.Value.Trim(), result.Port));
}
result.CommandList = new List <string>();
XElement commandList = root.Element("CommandList");
foreach (XElement item in commandList.Elements("Command"))
{
result.CommandList.Add(item.Value.Trim());
}
return(result);
}
void OnUseWithTool(int player, int x, int y, int z, int tool)
{
if (server.modManager.GetBlockName(tool) == "Sign")
{
ServerChunk c = server.d_Map.GetChunk(x, y, z);
if (c == null)
{
return;
}
if (!server.CheckBuildPrivileges(player, x, y, z))
{
return;
}
ServerEntity e = new ServerEntity();
e.position = new ServerEntityPositionAndOrientation();
e.position.x = x + one / 2;
e.position.y = z;
e.position.z = y + one / 2;
e.position.heading = EntityHeading.GetHeading(server.modManager.GetPlayerPositionX(player), server.modManager.GetPlayerPositionY(player), e.position.x, e.position.z);
e.sign = new ServerEntitySign();
e.sign.text = "Hello world!";
server.AddEntity(x, y, z, e);
}
}
public static void HandleActiveEntityList(PacketReader Reader)
{
Log.PrintIncomingPacket("GameWorldState.HandleActiveEntityList");
int EntityCount = Reader.ReadInt();
for (int i = 0; i < EntityCount; i++)
{
//Extract each entities information as we loop through the packet data
string EntityType = Reader.ReadString();
string EntityID = Reader.ReadString();
Vector3 EntityPosition = Reader.ReadVector3();
int EntityHealth = Reader.ReadInt();
//Spawn each new entity into the game world and store them in the entity manager
GameObject EntitySpawn = ItemSpawner.Instance.SpawnItem(EntityPrefabs.GetEntityPrefab(EntityType), EntityPosition, Quaternion.identity);
ServerEntity EntityDetails = EntitySpawn.GetComponent <ServerEntity>();
EntityDetails.ID = EntityID;
EntityDetails.Health = EntityHealth;
EntityDetails.MaxHealth = EntityHealth;
EntitySpawn.GetComponent <ServerEntity>().ID = EntityID;
EntitySpawn.GetComponentInChildren <TextMesh>().text = EntityType + " " + EntityDetails.Health + "/" + EntityDetails.MaxHealth;
EntityManager.AddNewEntity(EntityID, EntitySpawn);
}
//Now request from the server the active item list
//GameWorldStatePacketSender.SendActiveItemRequest();
}
void StartTcpServer()
{
try
{
while (true)
{
string data = null;
int j = 0;
while (true)
{
byte[] bytes = new byte[11000000];
int i;
stream = List[j].Client.GetStream();
if (stream.DataAvailable)
{
i = stream.Read(bytes, 0, bytes.Length);
data = Encoding.ASCII.GetString(bytes, 0, i);
if (data.Contains("PNG"))
{
SentClient(bytes, List[j].Id);
ServerEntity serverEntity = new ServerEntity();
serverEntity.Message = data;
var action = new Action(() => { ServerList.Add(serverEntity); });
Task.Run(() => App.Current.Dispatcher.BeginInvoke(action)).Wait();
data = null;
bytes = null;
}
else
{
ServerEntity serverEntity = new ServerEntity();
string[] arr = data.Split('`');
serverEntity.Message = arr[0];
var action = new Action(() => { ServerList.Add(serverEntity); });
Task.Run(() => App.Current.Dispatcher.BeginInvoke(action)).Wait();
byte[] msg = Encoding.ASCII.GetBytes(arr[0]);
SentClient(msg, List[j].Id);
}
}
j++;
if (j == List.Count)
{
j = 0;
}
}
client.Close();
}
}
catch (SocketException e)
{
MessageBox.Show("SocketException: {0}", e.Message);
}
catch (Exception e)
{
MessageBox.Show("Exception" + e.Message);
}
finally
{
server.Stop();
}
}
public async Task <List <ServerNodeModel> > GetSimpleServerNodes(string userId, ServerNodeModel delta)
{
try
{
ServerEntity entityDelta = null;
if (delta != null)
{
entityDelta = new ServerEntity()
{
Name = delta.Name
};
}
var entities = await ServerDao.GetServerEntitys(userId);
return(entities?.Select(item => new ServerNodeModel()
{
Id = item.Id,
Name = item.Name,
}).ToList());
}
catch (Exception e)
{
throw;
}
}
/// <summary>
/// Remove an entity from this zone
/// </summary>
public void RemoveEntity(ServerEntity entity)
{
if (mEntities.ContainsKey(entity.WorldID))
{
mEntities.Remove(entity.WorldID);
}
}
/// <summary>
/// Insert a new record about a server.
/// </summary>
/// <param name="model">The server.</param>
/// <returns>The server's identifier that has been inserted.</returns>
public Int64 InsertServer(ServerModel model)
{
logger.WriteTrace("Inserting {0} into the database...", model);
if (model.Id != 0)
{
throw new ArgumentException("Model's identifier should be 0. Now it is " + model.Id, "model");
}
logger.WriteTrace("Converting {0} into the entity...", model);
ServerEntity entity = serverConverter.Convert(model);
logger.WriteTrace("{0} has been converted. Generating sql command for {1}...", model, entity);
string sqlCommand = string.Format(insertStatement, sqlSettings.WiseQueueDefaultSchema, serverTableName, entity.Name, entity.Description, entity.HeartbeatLifetime);
logger.WriteTrace("The SqlCommand has been generated. Result: {0}", sqlCommand);
logger.WriteTrace("Executing sql command...");
using (IDbConnection connection = connectionFactory.CreateConnection())
{
using (IDbCommand command = connection.CreateCommand())
{
command.CommandText = sqlCommand;
Int64 result = (Int64)command.ExecuteScalar();
logger.WriteTrace("The command has been executed. Entity identifier is {0}", result);
return(result);
}
}
}
/// <summary>
/// Sends states of nearby enemies to each other
/// </summary>
public void PushNearbyEntities(ServerEntity entity)
{
const int minSqrDistance = 768 * 768;
foreach (var e in mEntities.Values)
{
if (e.AuthState != EEntityAuthState.Authorised || e.WorldID == entity.WorldID)
{
//Skip unauthorised entities and don't send to self
continue;
}
float xDiff = entity.LastState.X - e.LastState.X;
float yDiff = entity.LastState.Y - e.LastState.Y;
var sqrdistance = (xDiff * xDiff) + (yDiff * yDiff);
if (sqrdistance > minSqrDistance)
{
continue;
}
//Add a push state into the coalesced data packet for this entity
var state = PacketFactory.CreatePacket <PushState>();
state.WorldID = e.WorldID;
state.State = e.LastState;
entity.DeferredSendPacket(state);
}
}
/// <summary>
/// Tells all zones to push states to entities that are near to each other.
/// </summary>
public void PushNearbyEntities(ServerEntity entity) {
Zone zone;
mUserZones.TryGetValue(entity, out zone);
if (zone != null) {
zone.PushNearbyEntities(entity);
}
}
void OnUseWithTool(int player, int x, int y, int z, int tool)
{
if (server.modManager.GetBlockName(tool) == "PermissionSign")
{
ServerChunk c = server.d_Map.GetChunk(x, y, z);
if (c == null)
{
return;
}
if (!server.CheckBuildPrivileges(player, x, y, z))
{
return;
}
if (!server.PlayerHasPrivilege(player, ServerClientMisc.Privilege.area_add))
{
server.SendMessage(player, server.colorError + server.language.Get("Server_CommandInsufficientPrivileges"));
return;
}
ServerEntity e = new ServerEntity();
e.position = new ServerEntityPositionAndOrientation();
e.position.x = x + one / 2;
e.position.y = z;
e.position.z = y + one / 2;
e.position.heading = EntityHeading.GetHeading(server.modManager.GetPlayerPositionX(player), server.modManager.GetPlayerPositionY(player), e.position.x, e.position.z);
e.permissionSign = new ServerEntityPermissionSign();
e.permissionSign.name = "Admin";
e.permissionSign.type = PermissionSignType.Group;
server.AddEntity(x, y, z, e);
}
}
/// <summary>
/// Remove an entity from the zone that they are in
/// </summary>
public void RemoveEntity(ServerEntity entity) {
Zone zone;
mUserZones.TryGetValue(entity, out zone);
if (zone != null) {
zone.RemoveEntity(entity);
}
}
/// <summary>
/// Sends states of nearby enemies to each other
/// </summary>
public void PushNearbyEntities(ServerEntity entity)
{
foreach (ServerEntity e in m_entities.Values)
{
if (e.AuthState != EntityAuthState.Authorised || e.WorldID == entity.WorldID)
{
//Skip unauthorised entities and don't send to self
continue;
}
float xDiff = entity.LastState.X - e.LastState.X;
float yDiff = entity.LastState.Y - e.LastState.Y;
float sqrdistance = (xDiff * xDiff) + (yDiff * yDiff);
if (sqrdistance < 768*768)
{
//Add a push state into the coalesced data packet for this entity
PushState state = PacketFactory.CreatePacket<PushState>();
state.WorldID = e.WorldID;
state.State = e.LastState;
entity.DeferredSendPacket(state);
}
}
}
/// <summary>
/// Canned Execution method for an Activity for processing Items. This method will:
/// 1. validate the entity as an Item
/// 2. verify the item type
/// 3. check whether the target field is set on the Item and set state appropriately
/// 4. check whether the user made a selection (via the data parameter) and set state appropriately
/// 5. if none of this is true, add a set of suggestions from a suggestion function passed in
/// </summary>
/// <param name="workflowInstance">Workflow instance to process</param>
/// <param name="entity">Entity to process</param>
/// <param name="data">User selection data passed in</param>
/// <param name="suggestionFunction">Suggestion function to invoke</param>
/// <returns>return value for the Function</returns>
protected Status Execute(
WorkflowInstance workflowInstance,
ServerEntity entity,
object data,
Guid expectedItemType,
Func <WorkflowInstance, ServerEntity, Dictionary <string, string>, Status> suggestionFunction)
{
Item item = entity as Item;
if (item == null)
{
TraceLog.TraceError("Entity is not an Item");
return(Status.Error);
}
if (VerifyItemType(item, expectedItemType) == false)
{
return(Status.Error);
}
// if the target field has been set, this state can terminate
if (CheckTargetField(workflowInstance, item))
{
return(Status.Complete);
}
// check for user selection
if (data != null)
{
return(ProcessActivityData(workflowInstance, data));
}
return(CreateSuggestions(workflowInstance, entity, suggestionFunction));
}
/// <summary>
/// Run a workflow until it is blocked for user input or is terminated
/// </summary>
/// <param name="instance"></param>
/// <param name="entity"></param>
public void Run(WorkflowInstance instance, ServerEntity entity)
{
TraceLog.TraceInfo("Running workflow " + instance.WorkflowType);
var status = WorkflowActivity.Status.Complete;
try
{
// invoke the workflow and process steps until workflow is blocked for user input
while (status == WorkflowActivity.Status.Complete)
{
status = Execute(instance, entity);
}
}
catch (Exception ex)
{
TraceLog.TraceException("Workflow execution failed", ex);
}
// if the workflow is done or experienced a fatal error, terminate it
if (status == WorkflowActivity.Status.WorkflowDone ||
status == WorkflowActivity.Status.Error)
{
try
{
SuggestionsContext.WorkflowInstances.Remove(instance);
SuggestionsContext.SaveChanges();
}
catch (Exception ex)
{
TraceLog.TraceException("Could not remove workflow instance", ex);
}
}
}
protected HttpResponseMessageWrapper <T> ReturnResult <T>(HttpRequestMessage req, Operation operation, T t, HttpStatusCode code)
{
try
{
if (operation != null)
{
operation.StatusCode = (int?)code;
// fix the EntityID (some clients like the web-client have the server assign the ID for new entities)
if (operation.EntityID == Guid.Empty)
{
ServerEntity entity = t as ServerEntity;
if (entity != null)
{
operation.EntityID = entity.ID;
}
}
this.StorageContext.SaveChanges();
}
}
catch (Exception ex)
{
TraceLog.TraceException("Could not log operation status", ex);
}
return(new HttpResponseMessageWrapper <T>(req, t, code));
}
void UpdateEntity(int chunkx, int chunky, int chunkz, int id)
{
ServerEntity e = server.GetEntity(chunkx, chunky, chunkz, id);
if (e.sign == null)
{
return;
}
if (e.drawModel == null)
{
e.drawModel = new ServerEntityAnimatedModel();
}
e.drawModel.model = "signmodel.txt";
e.drawModel.texture = "signmodel.png";
e.drawModel.modelHeight = one * 13 / 10;
if (e.drawText == null)
{
e.drawText = new ServerEntityDrawText();
}
e.drawText.text = e.sign.text;
e.drawText.dx = one * 3 / 32;
e.drawText.dy = one * 36 / 32;
e.drawText.dz = one * 3 / 32;
e.usable = true;
if (e.drawName == null)
{
e.drawName = new ServerEntityDrawName();
e.drawName.name = "Sign";
e.drawName.onlyWhenSelected = true;
}
}
/// <summary>
/// Tries to move a user in to a new zone.
/// </summary>
public bool RequestZoneTransfer(ServerEntity entity, int newZoneID)
{
//Check the zone exists
if (m_zones.ContainsKey(newZoneID))
{
Zone newZone = m_zones[newZoneID];
//See if the user is already in a zone
if (m_userZones.ContainsKey(entity))
{
//Remove them from their current zone
Zone currentZone = m_userZones[entity];
currentZone.RemoveEntity(entity);
}
else
{
//Add them to the zone index
m_userZones.Add(entity, newZone);
}
//Move them in to their new zone
m_userZones[entity] = newZone;
newZone.AddEntity(entity);
return true;
}
return false;
}
public void WriteXml(ServerEntity se)
{
XmlDocument doc = new XmlDocument();
XmlElement servers = null;
if (File.Exists(serverFilePath))
{
doc.Load(serverFilePath);
servers = doc.DocumentElement;
}
else
{
//创建声明
XmlDeclaration dec = doc.CreateXmlDeclaration("1.0", "gb2312", null);
doc.AppendChild(dec);
//创建根节点
servers = doc.CreateElement("serverlist");
doc.AppendChild(servers);
}
XmlElement childServer = doc.CreateElement("info");
childServer.SetAttribute("name", se.Name);
servers.AppendChild(childServer);
XmlElement inner1 = doc.CreateElement("serverIP");
inner1.InnerText = se.ServerIP;
childServer.AppendChild(inner1);
XmlElement inner2 = doc.CreateElement("serverPort");
inner2.InnerText = se.ServerPort;
childServer.AppendChild(inner2);
XmlElement inner3 = doc.CreateElement("serverUserName");
inner3.InnerText = se.ServerUserName;
childServer.AppendChild(inner3);
XmlElement inner4 = doc.CreateElement("serverPassword");
inner4.InnerText = se.ServerPassword;
childServer.AppendChild(inner4);
XmlElement inner5 = doc.CreateElement("serverCatalog");
childServer.AppendChild(inner5);
foreach (string item in se.ServerDBName)
{
XmlElement inner6 = doc.CreateElement("List");
inner6.InnerText = item;
inner5.AppendChild(inner6);
}
doc.Save(serverFilePath);
}
public void Connect(ServerEntity server, DefAction callBack)
{
this.connectCallBack = callBack;
StateObj state = new StateObj();
state.OnConnect = OnConnect;
clientSocket.ConnectServer(server.ip, server.port, state);
}
public ServerModel(string serverId)
{
_server = new ServerEntity
{
Id = Guid.NewGuid(),
Name = serverId
};
}
/// <summary>
/// Convert server entity into the server model.
/// </summary>
/// <param name="serverEntity">The <see cref="ServerEntity"/> instance.</param>
/// <returns>The <see cref="ServerModel"/> instance.</returns>
public ServerModel Convert(ServerEntity serverEntity)
{
ServerModel result = (serverEntity.Id > 0)
? new ServerModel(serverEntity.Id, serverEntity.Name, serverEntity.Description,
serverEntity.HeartbeatLifetime)
: new ServerModel(serverEntity.Name, serverEntity.Description, serverEntity.HeartbeatLifetime);
return(result);
}
/// <summary>
/// Default implementation for the Workflow's Process method.
/// Get the current state
/// Invoke the corresponding action (with the data object passed in)
/// Add any results to the Item's SuggestionsList
/// Move to the next state and terminate the workflow if it is at the end
/// </summary>
/// <param name="instance">Workflow instance</param>
/// <param name="entity">Entity to process</param>
/// <param name="data">Extra data to pass to Activity</param>
/// <returns>true if completed, false if not</returns>
protected virtual WorkflowActivity.Status Process(WorkflowInstance instance, ServerEntity entity, object data)
{
try
{
// get current state and corresponding activity
TraceLog.TraceInfo(String.Format("Workflow {0} entering state {1}", instance.WorkflowType, instance.State));
WorkflowState state = States.Single(s => s.Name == instance.State);
//var activity = PrepareActivity(instance, state.Activity, UserContext, SuggestionsContext);
WorkflowActivity activity = null;
if (state.Activity != null)
{
activity = WorkflowActivity.CreateActivity(state.Activity);
}
else if (state.ActivityDefinition != null)
{
activity = WorkflowActivity.CreateActivity(state.ActivityDefinition, instance);
}
if (activity == null)
{
TraceLog.TraceError("Could not find or prepare Activity");
return(WorkflowActivity.Status.Error);
}
else
{
activity.UserContext = UserContext;
activity.SuggestionsContext = SuggestionsContext;
}
// invoke the activity
TraceLog.TraceInfo(String.Format("Workflow {0} invoking activity {1}", instance.WorkflowType, activity.Name));
var status = activity.Function.Invoke(instance, entity, data);
TraceLog.TraceInfo(String.Format("Workflow {0}: activity {1} returned status {2}", instance.WorkflowType, activity.Name, status.ToString()));
instance.LastModified = DateTime.Now;
// if the activity completed, advance the workflow state
if (status == WorkflowActivity.Status.Complete)
{
// store next state and terminate the workflow if next state is null
instance.State = state.NextState;
if (instance.State == null)
{
status = WorkflowActivity.Status.WorkflowDone;
TraceLog.TraceInfo(String.Format("Workflow {0} is done", instance.WorkflowType));
}
}
SuggestionsContext.SaveChanges();
return(status);
}
catch (Exception ex)
{
TraceLog.TraceException("Process failed", ex);
return(WorkflowActivity.Status.Error);
}
}
public void StumpsServerInstanceTests_SetUp()
{
_serverId = "ABCD";
var proxyEntity = new ServerEntity()
{
AutoStart = false,
RemoteServerHostName = "stumps-project.com",
Port = 9000,
ServerId = _serverId,
UseSsl = false
};
_dal = Substitute.For<IDataAccess>();
_dal.ServerFind("ABCD").Returns(proxyEntity);
}
public static void StartGame(JSONObject json) {
ServerEntity player = new ServerEntity();
player.levelsHistory = json["history"].list.ConvertAll<ServerEntity.Level>(JSONObjectToLevelHistory);
if (Main.user.levelsHistory.Count < player.levelsHistory.Count) {
for (int i = 0; i < Main.user.levelsHistory.Count; i++) {
if (Main.user.levelsHistory[i] < player.levelsHistory[i].scores) {
Main.user.levelsHistory[i] = player.levelsHistory[i].scores;
}
}
for (int i = Main.user.levelsHistory.Count; i < player.levelsHistory.Count; i++) {
if (player.levelsHistory[i].scores > 0) {
Main.user.levelsHistory.Add(player.levelsHistory[i].scores);
}
}
}
else {
for (int i = 0; i < player.levelsHistory.Count; i++) {
if (Main.user.levelsHistory[i] < player.levelsHistory[i].scores) {
Main.user.levelsHistory[i] = player.levelsHistory[i].scores;
}
}
}
for (int i = 0; i < JSONObjectToInt(json["game"]["episode"]) - 1; i++) {
player.episodes.Add(i+2);
}
string tutorial = json["tutorial"].ToString();
//Debug.Log(tutorial);
//for (int i = 0; i < tutorial.Length; i++) {
// Debug.Log(Convert.ToInt32(tutorial[i]));
// Main.user.tutorial.Add((int)ch);
//}
Main.user.MusicSettings = json["game"]["music"].b;
Main.user.SoundSettings = json["game"]["sound"].b;
Main.user.unlockedEpisodes = player.episodes;
LocalStorage.Save();
onStartInitializeSuccess(1);
}
public void Constructor_PortInUse_ThrowsException()
{
int port = NetworkInformation.FindRandomOpenPort();
string externalHostName = "www.foo.com";
bool autoStart = false;
bool useSsl = true;
var proxyEntity = new ServerEntity
{
AutoStart = autoStart,
RemoteServerHostName = externalHostName,
Port = port,
UseSsl = useSsl,
ServerId = RandomGenerator.GenerateIdentifier()
};
var dataAccess = Substitute.For<IDataAccess>();
dataAccess.ServerFind(Arg.Any<string>()).Returns(proxyEntity);
// create a TcpListener already listening on the port
var tcpListener = new TcpListener(IPAddress.Loopback, port);
try
{
tcpListener.Start();
StumpsHost proxy = new StumpsHost(Substitute.For<IServerFactory>(), dataAccess);
Assert.That(
() => proxy.CreateServerInstance(externalHostName, port, useSsl, autoStart),
Throws.Exception.TypeOf<StumpsNetworkException>().With.Property("Message").EqualTo("The port is already in use."));
}
finally
{
tcpListener.Stop();
}
}
protected static void PopulateEntity(SqlDataReader reader, ServerEntity entity, Dictionary<string, PropertyInfo> propMap)
{
for (int i = 0; i < reader.FieldCount; i++)
{
String columnName = reader.GetName(i);
// Special case for when we select a range of values with an EntityBroker, just ignore
if (columnName.Equals("RowNum"))
continue;
if (columnName.Equals("GUID"))
{
Guid uid = reader.GetGuid(i);
entity.SetKey(new ServerEntityKey(entity.Name, uid));
continue;
}
if (columnName.Equals(entity.Name) && columnName.Contains("Enum"))
columnName = "Enum";
PropertyInfo prop;
if (!propMap.TryGetValue(columnName, out prop))
throw new EntityNotFoundException("Unable to match column to property: " + columnName, null);
if (columnName.Contains("GUID"))
columnName = columnName.Replace("GUID", "Key");
if (reader.IsDBNull(i))
{
prop.SetValue(entity, null, null);
continue;
}
Type propType = prop.PropertyType;
if (propType == typeof(String))
prop.SetValue(entity, reader.GetString(i), null);
else if (propType == typeof(ServerEntityKey))
{
Guid uid = reader.GetGuid(i);
prop.SetValue(entity, new ServerEntityKey(columnName.Replace("Key", String.Empty), uid), null);
}
else if (propType == typeof(DateTime))
prop.SetValue(entity, reader.GetDateTime(i), null);
else if (propType == typeof(DateTime?))
{
if (reader.IsDBNull(i))
{
prop.SetValue(entity, null, null);
}
else
{
prop.SetValue(entity, reader.GetDateTime(i), null);
}
}
else if (propType == typeof(bool))
prop.SetValue(entity, reader.GetBoolean(i), null);
else if (propType == typeof(Int32))
prop.SetValue(entity, reader.GetInt32(i), null);
else if (propType == typeof(Int16))
prop.SetValue(entity, reader.GetInt16(i), null);
else if (propType == typeof(double))
prop.SetValue(entity, reader.GetDouble(i), null);
else if (propType == typeof(Decimal))
prop.SetValue(entity, reader.GetDecimal(i), null);
else if (propType == typeof(float))
prop.SetValue(entity, reader.GetFloat(i), null);
else if (propType == typeof(XmlDocument))
{
SqlXml xml = reader.GetSqlXml(i);
if (xml!=null && !xml.IsNull)
{
XmlReader xmlReader = xml.CreateReader();
if (xmlReader != null)
{
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.Load(xmlReader);
prop.SetValue(entity, xmlDoc, null);
}
else
prop.SetValue(entity, null, null);
}
else
{
prop.SetValue(entity, null, null);
}
}
else if (typeof(ServerEnum).IsAssignableFrom(propType))
{
short enumVal = reader.GetInt16(i);
ConstructorInfo construct = prop.PropertyType.GetConstructor(new Type[0]);
ServerEnum val = (ServerEnum)construct.Invoke(null);
val.SetEnum(enumVal);
prop.SetValue(entity, val, null);
}
else
throw new EntityNotFoundException("Unsupported property type: " + propType, null);
}
}
Packet_ServerEntity ToNetworkEntity(ServerPlatform platform, ServerEntity entity)
{
Packet_ServerEntity p = new Packet_ServerEntity();
if (entity.position != null)
{
p.Position = ToNetworkEntityPosition(platform, entity.position);
}
if (entity.drawModel != null)
{
p.DrawModel = new Packet_ServerEntityAnimatedModel();
p.DrawModel.EyeHeight = platform.FloatToInt(entity.drawModel.eyeHeight * 32);
p.DrawModel.Model_ = entity.drawModel.model;
p.DrawModel.ModelHeight = platform.FloatToInt(entity.drawModel.modelHeight * 32);
p.DrawModel.Texture_ = entity.drawModel.texture;
p.DrawModel.DownloadSkin = entity.drawModel.downloadSkin ? 1 : 0;
}
if (entity.drawName != null)
{
p.DrawName_ = new Packet_ServerEntityDrawName();
p.DrawName_.Name = entity.drawName.name;
p.DrawName_.Color = entity.drawName.color;
p.DrawName_.OnlyWhenSelected = entity.drawName.onlyWhenSelected;
p.DrawName_.ClientAutoComplete = entity.drawName.clientAutoComplete;
}
if (entity.drawText != null)
{
p.DrawText = new Packet_ServerEntityDrawText();
p.DrawText.Dx = platform.FloatToInt(entity.drawText.dx * 32);
p.DrawText.Dy = platform.FloatToInt(entity.drawText.dy * 32);
p.DrawText.Dz = platform.FloatToInt(entity.drawText.dz * 32);
p.DrawText.Rotx = platform.FloatToInt(entity.drawText.rotx);
p.DrawText.Roty = platform.FloatToInt(entity.drawText.roty);
p.DrawText.Rotz = platform.FloatToInt(entity.drawText.rotz);
p.DrawText.Text = entity.drawText.text;
}
if (entity.push != null)
{
p.Push = new Packet_ServerEntityPush();
p.Push.RangeFloat = platform.FloatToInt(entity.push.range * 32);
}
p.Usable = entity.usable;
if (entity.drawArea != null)
{
p.DrawArea = new Packet_ServerEntityDrawArea();
p.DrawArea.X = entity.drawArea.x;
p.DrawArea.Y = entity.drawArea.y;
p.DrawArea.Z = entity.drawArea.z;
p.DrawArea.Sizex = entity.drawArea.sizex;
p.DrawArea.Sizey = entity.drawArea.sizey;
p.DrawArea.Sizez = entity.drawArea.sizez;
p.DrawArea.VisibleToClientId = entity.drawArea.visibleToClientId;
}
return p;
}
/// <summary>
/// Event handler for TCP connections.
/// </summary>
private void Tcp_SocketConnected(Socket socket) {
//Keep going until we find an ID for them
while (true) {
//Generate an ID
var worldID = mRng.Next();
//See if it's unique
if (!mEntities.ContainsKey(worldID)) {
//Add them in
var entity = new ServerEntity(socket, worldID, this, mAsyncPool);
if (mEntities.TryAdd(worldID, entity)) {
//DONE!
Console.WriteLine(worldID + " joined");
break;
}
}
}
}
/// <summary>
/// Add an entity to this zone
/// </summary>
public void AddEntity(ServerEntity entity)
{
m_entities.Add(entity.WorldID, entity);
}
/// <summary>
/// Remove an entity from this zone
/// </summary>
public void RemoveEntity(ServerEntity entity)
{
if (m_entities.ContainsKey(entity.WorldID))
{
m_entities.Remove(entity.WorldID);
}
}
void OnUseWithTool(int player, int x, int y, int z, int tool)
{
if (server.modManager.GetBlockName(tool) == "PermissionSign")
{
ServerChunk c = server.d_Map.GetChunk(x, y, z);
if (c == null)
{
return;
}
if (!server.CheckBuildPrivileges(player, x, y, z))
{
return;
}
if (!server.PlayerHasPrivilege(player, ServerClientMisc.Privilege.area_add))
{
server.SendMessage(player, server.colorError + server.language.Get("Server_CommandInsufficientPrivileges"));
return;
}
ServerEntity e = new ServerEntity();
e.position = new ServerEntityPositionAndOrientation();
e.position.x = x + one / 2;
e.position.y = z;
e.position.z = y + one / 2;
e.position.heading = EntityHeading.GetHeading(server.modManager.GetPlayerPositionX(player), server.modManager.GetPlayerPositionY(player), e.position.x, e.position.z);
e.permissionSign = new ServerEntityPermissionSign();
e.permissionSign.name = "Admin";
e.permissionSign.type = PermissionSignType.Group;
server.AddEntity(x, y, z, e);
}
}
/// <summary>
/// Creates a new instance of a Stumps server.
/// </summary>
/// <param name="remoteServerHostName">The host name for the remote server by the Stumps server.</param>
/// <param name="port">The TCP port used to listen for incomming HTTP requests.</param>
/// <param name="useSsl"><c>true</c> if the remote server requires SSL.</param>
/// <param name="autoStart"><c>true</c> to automatically start the Stumps server.</param>
/// <returns>
/// A <see cref="T:Stumps.Server.StumpsServerInstance" /> represeting the new Stumps server.
/// </returns>
/// <exception cref="System.ArgumentNullException"><paramref name="remoteServerHostName"/> is null.</exception>
/// <exception cref="System.ArgumentOutOfRangeException"><paramref name="port"/> exceeds the allowed TCP port range.</exception>
/// <exception cref="StumpsNetworkException">The port is already in use.</exception>
public StumpsServerInstance CreateServerInstance(string remoteServerHostName, int port, bool useSsl, bool autoStart)
{
if (string.IsNullOrWhiteSpace(remoteServerHostName))
{
throw new ArgumentNullException("remoteServerHostName");
}
if (port < IPEndPoint.MinPort || port > IPEndPoint.MaxPort)
{
throw new ArgumentOutOfRangeException("port");
}
if (NetworkInformation.IsPortBeingUsed(port))
{
throw new StumpsNetworkException(Resources.PortIsInUseError);
}
// Create a new data entity representing the Stumps server
var serverEntity = new ServerEntity
{
AutoStart = autoStart,
RemoteServerHostName = remoteServerHostName,
Port = port,
UseSsl = useSsl,
ServerId = RandomGenerator.GenerateIdentifier()
};
// Persist the server data entity
_dataAccess.ServerCreate(serverEntity);
// Create a new service instance from the entity
UnwrapAndRegisterServer(serverEntity);
var server = _serverInstances[serverEntity.ServerId];
if (autoStart)
{
server.Start();
}
return server;
}
private void UnwrapAndRegisterServer(ServerEntity entity)
{
var server = new StumpsServerInstance(_serverFactory, entity.ServerId, _dataAccess)
{
AutoStart = entity.AutoStart,
ListeningPort = entity.Port,
RemoteServerHostName = entity.RemoteServerHostName,
UseHttpsForIncommingConnections = entity.UseHttpsForIncommingConnections,
UseSsl = entity.UseSsl
};
_serverInstances.AddOrUpdate(server.ServerId, server, (key, oldServer) => server);
}
private static DataAccess CreateDataAccessLayerWithProxy()
{
var temporaryDirectory = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName());
Directory.CreateDirectory(temporaryDirectory);
var dataAccess = new DataAccess(temporaryDirectory);
var entity = new ServerEntity
{
AutoStart = false,
RemoteServerHostName = SampleHostName,
Port = 500,
ServerId = "ABCD",
UseSsl = false
};
dataAccess.ServerCreate(entity);
return dataAccess;
}
public DataAccessTests()
{
_sampleProxyServer = new ServerEntity
{
AutoStart = false,
RemoteServerHostName = SampleHostName,
Port = 500,
ServerId = "ABCD",
UseSsl = false
};
var originalRequest = new HttpRequestEntity()
{
HttpMethod = "GET",
BodyResourceName = null,
Headers = new List<NameValuePairEntity>(),
ProtocolVersion = "1.1",
RawUrl = "/"
};
var originalResponse = new HttpResponseEntity()
{
BodyResourceName = null,
Headers = new List<NameValuePairEntity>()
{
new NameValuePairEntity
{
Name = "Content-Type",
Value = "text/plain"
}
},
RedirectAddress = null,
StatusCode = 200,
StatusDescription = "OK"
};
var response = new HttpResponseEntity()
{
BodyResourceName = null,
Headers = new List<NameValuePairEntity>()
{
new NameValuePairEntity
{
Name = "Content-Type",
Value = "text/plain"
}
},
RedirectAddress = null,
StatusCode = 200,
StatusDescription = "OK"
};
_sampleStump = new StumpEntity
{
OriginalRequest = originalRequest,
OriginalResponse = originalResponse,
Response = response,
Rules = new List<RuleEntity>(),
StumpCategory = "Uncategorized",
StumpId = "ABCD",
StumpName = "MyStump"
};
_sampleBytes = new byte[]
{
1, 2, 3
};
}
void OnUseWithTool(int player, int x, int y, int z, int tool)
{
if (server.modManager.GetBlockName(tool) == "Sign")
{
ServerChunk c = server.d_Map.GetChunk(x, y, z);
if (c == null)
{
return;
}
if (!server.CheckBuildPrivileges(player, x, y, z))
{
return;
}
ServerEntity e = new ServerEntity();
e.position = new ServerEntityPositionAndOrientation();
e.position.x = x + one / 2;
e.position.y = z;
e.position.z = y + one / 2;
e.position.heading = EntityHeading.GetHeading(server.modManager.GetPlayerPositionX(player), server.modManager.GetPlayerPositionY(player), e.position.x, e.position.z);
e.sign = new ServerEntitySign();
e.sign.text = "Hello world!";
server.AddEntity(x, y, z, e);
}
}
/// <summary>
/// Creates an entry for a new stumps server.
/// </summary>
/// <param name="server">The <see cref="T:Stumps.Server.Data.ServerEntity" /> to create.</param>
/// <exception cref="System.ArgumentNullException">server</exception>
public void ServerCreate(ServerEntity server)
{
if (server == null)
{
throw new ArgumentNullException("server");
}
var serverFile = Path.Combine(_storagePath, server.ServerId + DataAccess.StumpsServerFileExtension);
JsonUtility.SerializeToFile(server, serverFile);
Directory.CreateDirectory(Path.Combine(_storagePath, server.ServerId));
Directory.CreateDirectory(Path.Combine(_storagePath, server.ServerId, DataAccess.StumpsPathName));
}
