public MainController()
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
cypher = new Cypher();
form = new MainForm(this);
}
void HandleMoveSetModMovementForceMagnitudeAck(MovementSpeedAck setModMovementForceMagnitudeAck)
{
Unit mover = _player.GetUnitBeingMoved();
Cypher.Assert(mover != null); // there must always be a mover
_player.ValidateMovementInfo(setModMovementForceMagnitudeAck.Ack.Status);
// prevent tampered movement data
if (setModMovementForceMagnitudeAck.Ack.Status.Guid != mover.GetGUID())
{
Log.outError(LogFilter.Network, $"HandleSetModMovementForceMagnitudeAck: guid error, expected {mover.GetGUID()}, got {setModMovementForceMagnitudeAck.Ack.Status.Guid}");
return;
}
// skip all except last
if (_player.m_movementForceModMagnitudeChanges > 0)
{
--_player.m_movementForceModMagnitudeChanges;
if (_player.m_movementForceModMagnitudeChanges == 0)
{
float expectedModMagnitude = 1.0f;
MovementForces movementForces = mover.GetMovementForces();
if (movementForces != null)
{
expectedModMagnitude = movementForces.GetModMagnitude();
}
if (Math.Abs(expectedModMagnitude - setModMovementForceMagnitudeAck.Speed) > 0.01f)
{
Log.outDebug(LogFilter.Misc, $"Player {_player.GetName()} from account id {_player.GetSession().GetAccountId()} kicked for incorrect movement force magnitude (must be {expectedModMagnitude} instead {setModMovementForceMagnitudeAck.Speed})");
_player.GetSession().KickPlayer("WorldSession::HandleMoveSetModMovementForceMagnitudeAck Incorrect magnitude");
return;
}
}
}
setModMovementForceMagnitudeAck.Ack.Status.Time = AdjustClientMovementTime(setModMovementForceMagnitudeAck.Ack.Status.Time);
MoveUpdateSpeed updateModMovementForceMagnitude = new(ServerOpcodes.MoveUpdateModMovementForceMagnitude);
updateModMovementForceMagnitude.Status = setModMovementForceMagnitudeAck.Ack.Status;
updateModMovementForceMagnitude.Speed = setModMovementForceMagnitudeAck.Speed;
mover.SendMessageToSet(updateModMovementForceMagnitude, false);
}
bool UnloadMapImpl(uint mapId, uint x, uint y)
{
// check if we have this map loaded
MMapData mmap = GetMMapData(mapId);
if (mmap == null)
{
// file may not exist, therefore not loaded
Log.outDebug(LogFilter.Maps, "MMAP:unloadMap: Asked to unload not loaded navmesh map. {0:D4}{1:D2}{2:D2}.mmtile", mapId, x, y);
return(false);
}
// check if we have this tile loaded
uint packedGridPos = PackTileID(x, y);
if (!mmap.loadedTileRefs.ContainsKey(packedGridPos))
{
// file may not exist, therefore not loaded
Log.outDebug(LogFilter.Maps, "MMAP:unloadMap: Asked to unload not loaded navmesh tile. {0:D4}{1:D2}{2:D2}.mmtile", mapId, x, y);
return(false);
}
ulong tileRef = mmap.loadedTileRefs[packedGridPos];
// unload, and mark as non loaded
Detour.dtRawTileData data;
if (Detour.dtStatusFailed(mmap.navMesh.removeTile(tileRef, out data)))
{
// this is technically a memory leak
// if the grid is later reloaded, dtNavMesh.addTile will return error but no extra memory is used
// we cannot recover from this error - assert out
Log.outError(LogFilter.Maps, "MMAP:unloadMap: Could not unload {0:D4}{1:D2}{2:D2}.mmtile from navmesh", mapId, x, y);
Cypher.Assert(false);
}
else
{
mmap.loadedTileRefs.Remove(packedGridPos);
--loadedTiles;
Log.outInfo(LogFilter.Maps, "MMAP:unloadMap: Unloaded mmtile {0:D4}[{1:D2}, {2:D2}] from {3:D4}", mapId, x, y, mapId);
return(true);
}
return(false);
}
public bool GetObjectHitPos(Vector3 pPos1, Vector3 pPos2, out Vector3 pResultHitPos, float pModifyDist)
{
bool result = false;
float maxDist = (pPos2 - pPos1).magnitude();
// valid map coords should *never ever* produce float overflow, but this would produce NaNs too
Cypher.Assert(maxDist < float.MaxValue);
// prevent NaN values which can cause BIH intersection to enter infinite loop
if (maxDist < 1e-10f)
{
pResultHitPos = pPos2;
return(false);
}
Vector3 dir = (pPos2 - pPos1) / maxDist; // direction with length of 1
Ray ray = new Ray(pPos1, dir);
float dist = maxDist;
if (GetIntersectionTime(ray, ref dist, false, ModelIgnoreFlags.Nothing))
{
pResultHitPos = pPos1 + dir * dist;
if (pModifyDist < 0)
{
if ((pResultHitPos - pPos1).magnitude() > -pModifyDist)
{
pResultHitPos = pResultHitPos + dir * pModifyDist;
}
else
{
pResultHitPos = pPos1;
}
}
else
{
pResultHitPos = pResultHitPos + dir * pModifyDist;
}
result = true;
}
else
{
pResultHitPos = pPos2;
result = false;
}
return(result);
}
public void GetCypherByIdOk(int id)
{
// Given
Mock <ICypherRepository> mockRepo = new Mock <ICypherRepository>();
mockRepo.Setup(repo => repo.Get(It.IsAny <int>())).Returns <int>((i) => { return(Task.FromResult(cyphers.FirstOrDefault(c => c.Id == i))); });
CyphersController controller = new CyphersController(mockRepo.Object);
// When
IActionResult result = controller.GetById(id);
// Then
Assert.NotNull(result);
var objectResult = Assert.IsType <ObjectResult>(result);
Cypher cypherResult = Assert.IsType <Cypher>(objectResult.Value);
Assert.Equal(id, cypherResult.Id);
}
public long FindBadNumber()
{
for (int i = 0; i < Cypher.Count - Preamble; i++)
{
var numbers = Cypher.Skip(i).Take(Preamble).ToList();
var nextNumber = Cypher.Skip(i + Preamble).Take(1).FirstOrDefault();
if (!numbers.Any(x =>
{
var numberToMatch = nextNumber - x;
return(numbers.Contains(numberToMatch));
}))
{
BadNumber = nextNumber;
return(nextNumber);
}
}
return(0);
}
/// <summary>Updates the given entity.</summary>
/// <typeparam name="T">Generic type parameter.</typeparam>
/// <param name="entity">The entity.</param>
/// <returns>A T.</returns>
public T Update <T>(T entity)
{
var aux = _mapper.Map <RESERVACION>(entity);
aux = Cypher.EncryptObject(aux) as RESERVACION;
var pIDReservacion = new SqlParameter
{
ParameterName = "ID_Reservacion",
Value = aux.ID_RESERVACION
};
var pFechaEntrada = new SqlParameter
{
ParameterName = "Fecha_Entrada",
Value = aux.FECHA_ENTRADA
};
var pFechaSalida = new SqlParameter
{
ParameterName = "Fecha_Salida",
Value = aux.FECHA_SALIDA
};
var pTipoHabitacion = new SqlParameter
{
ParameterName = "Tipo_Habitacion",
Value = aux.TIPO_HABITACION
};
var pEstado = new SqlParameter
{
ParameterName = "Estado",
Value = aux.ESTADO_RESERVACION
};
//_mandiolaDbContext.RESERVACIONs.Attach(aux);
//_mandiolaDbContext.Entry(aux).State = EntityState.Modified;
aux = _mandiolaDbContext.Database.SqlQuery <RESERVACION>("exec EditReservacionAPI @ID_Reservacion,@Fecha_Entrada,@Fecha_Salida,@Tipo_Habitacion,@Estado", pIDReservacion, pFechaEntrada, pFechaSalida, pTipoHabitacion, pEstado).FirstOrDefault();
_mandiolaDbContext.SaveChanges();
return(_mapper.Map <T>(aux));
}
public void GetMultipleNodesById()
{
var node1 = Node.CreateNode();
var node2 = Node.CreateNode();
var node3 = Node.CreateNode();
var cypher = new Cypher();
cypher.Start(s => s.Node("node", node1.Id, node2.Id, node3.Id));
cypher.Return(r => r.Node("node"));
var result = cypher.Execute();
Assert.IsTrue(result.Count() == 3);
Assert.IsTrue(node1 == result.First().Field <Node>("node"));
Assert.IsTrue(node2 == result.ElementAt(1).Field <Node>("node"));
Assert.IsTrue(node3 == result.ElementAt(2).Field <Node>("node"));
}
public void MultipleNodeStartingPoints2()
{
var node1 = Node.CreateNode();
var node2 = Node.CreateNode();
var cypher = new Cypher();
cypher.Start(s => s.Node("n1", node1.Id));
cypher.Start(s => s.Node("n2", node2.Id));
cypher.Return(r => r.Node("n1"));
cypher.Return(r => r.Node("n2"));
var result = cypher.Execute();
Assert.IsTrue(result.Count() == 1);
Assert.IsTrue(node1 == result.First().Field <Node>("n1"));
Assert.IsTrue(node2 == result.First().Field <Node>("n2"));
}
public void GetNodeByIndexLookup()
{
var node1 = Node.CreateNode();
var value1 = UniqueValue();
node1.AddToIndex("nodes", "name", value1);
var cypher = new Cypher();
cypher.Start(s => s.Node("node", "nodes", "name", value1));
cypher.Return(r => r.Node("node"));
var result = cypher.Execute();
Assert.IsTrue(result.Count() == 1);
Assert.IsTrue(node1 == result.First().Field <Node>("node"));
}
public void GetNodeByIndexQuery()
{
var node1 = Node.CreateNode();
var value1 = DateTime.Now.Millisecond;
node1.AddToIndex("nodes", "name", value1);
var cypher = new Cypher();
cypher.Start(s => s.Node("node", "nodes", string.Format("name:{0}", value1)));
cypher.Return(r => r.Node("node"));
var result = cypher.Execute();
Assert.IsTrue(result.Count() == 1);
Assert.IsTrue(node1 == result.First().Field <Node>("node"));
}
public override void Update(uint diff)
{
// caster has to be always available and in the same map
Cypher.Assert(_caster != null);
Cypher.Assert(_caster.GetMap() == GetMap());
bool expired = false;
if (_aura != null)
{
if (!_aura.IsRemoved())
{
_aura.UpdateOwner(diff, this);
}
// _aura may be set to null in Aura.UpdateOwner call
if (_aura != null && (_aura.IsRemoved() || _aura.IsExpired()))
{
expired = true;
}
}
else
{
if (GetDuration() > diff)
{
_duration -= (int)diff;
}
else
{
expired = true;
}
}
if (expired)
{
Remove();
}
else
{
Global.ScriptMgr.OnDynamicObjectUpdate(this, diff);
}
}
public UsuarioAdministracaoAgenda Authenticate(UsuarioAdministracaoAgenda info)
{
DataBase dataBase = new DataBase();
UsuarioAdministracaoAgenda usuario = null;
StringBuilder sql = new StringBuilder();
sql.Append("select");
sql.Append(" uaa.UsuarioAdministracaoAgendaID");
sql.Append(", uaa.[Login]");
sql.Append(", uaa.Senha");
sql.Append(", uaa.Nome");
sql.Append(", uaa.Ativo");
sql.Append(" from");
sql.Append(" [dbo].[UsuarioAdministracaoAgenda] uaa");
sql.Append(" where");
sql.Append(String.Format(" uaa.[Login] = '{0}'", info.Login));
sql.Append(String.Format(" and uaa.Senha = '{0}'", info.Senha));
using (SqlConnection connection = dataBase.RetornaConexaoRastreabilidade())
{
using (SqlCommand command = new SqlCommand(sql.ToString(), connection))
{
connection.Open();
using (SqlDataReader dr = command.ExecuteReader())
{
while (dr.Read())
{
usuario = new UsuarioAdministracaoAgenda();
usuario.UsuarioAdministracaoAgendaID = Convert.ToInt32(dr["UsuarioAdministracaoAgendaID"]);
usuario.Login = dr["Login"].ToString();
usuario.Senha = Cypher.Decrypt(dr["Senha"].ToString());
usuario.Nome = dr["Nome"].ToString();
usuario.Ativo = Convert.ToBoolean(dr["Ativo"]);
}
}
}
}
return(usuario);
}
private void processUdpPacket(object sender, PacketReceivedEventArgs e)
{
if (secretkey != null)
{
byte[] packet = (byte[])e.Message;
byte[] nonce = new byte[24];
byte[] data;
Buffer.BlockCopy(packet, 0, nonce, 0, 12);
data = new byte[packet.Length - 12 - 16];
int payloadType = packet[1];
switch (payloadType)
{
case 120:
//Opus Audio
if (data.Length != Cypher.decrypt(packet, 12, packet.Length - 12, data, 0, nonce, secretkey))
{
throw new Exception("Conflicting sizes"); //Conflicting sizes
}
processVoicePacket(packet, data);
break;
case 101:
//VP8 Video
if (data.Length != Cypher.decrypt(packet, 12, packet.Length - 12, data, 0, nonce, secretkey))
{
throw new Exception("Conflicting sizes"); //Conflicting sizes
}
processVP8Packet(packet, data);
break;
case 102:
//TODO: RTX Video
Debug.WriteLine($"RTX payload: {payloadType}");
break;
default:
Debug.WriteLine($"Unknown payload Type: {payloadType}");
break;
}
}
}
void _ResetSave(KeyValuePair <uint, InstanceSave> pair)
{
// unbind all players bound to the instance
// do not allow UnbindInstance to automatically unload the InstanceSaves
lock_instLists = true;
bool shouldDelete = true;
var pList = pair.Value.m_playerList;
List <Player> temp = new List <Player>(); // list of expired binds that should be unbound
foreach (var player in pList)
{
InstanceBind bind = player.GetBoundInstance(pair.Value.GetMapId(), pair.Value.GetDifficultyID());
if (bind != null)
{
Cypher.Assert(bind.save == pair.Value);
if (bind.perm && bind.extendState != 0) // permanent and not already expired
{
// actual promotion in DB already happened in caller
bind.extendState = bind.extendState == BindExtensionState.Extended ? BindExtensionState.Normal : BindExtensionState.Expired;
shouldDelete = false;
continue;
}
}
temp.Add(player);
}
var gList = pair.Value.m_groupList;
while (!gList.Empty())
{
Group group = gList.First();
group.UnbindInstance(pair.Value.GetMapId(), pair.Value.GetDifficultyID(), true);
}
if (shouldDelete)
{
m_instanceSaveById.Remove(pair.Key);
}
lock_instLists = false;
}
void HandleEjectPassenger(EjectPassenger packet)
{
Vehicle vehicle = GetPlayer().GetVehicleKit();
if (!vehicle)
{
Log.outError(LogFilter.Network, "HandleEjectPassenger: {0} is not in a vehicle!", GetPlayer().GetGUID().ToString());
return;
}
if (packet.Passenger.IsUnit())
{
Unit unit = Global.ObjAccessor.GetUnit(GetPlayer(), packet.Passenger);
if (!unit)
{
Log.outError(LogFilter.Network, "{0} tried to eject {1} from vehicle, but the latter was not found in world!", GetPlayer().GetGUID().ToString(), packet.Passenger.ToString());
return;
}
if (!unit.IsOnVehicle(vehicle.GetBase()))
{
Log.outError(LogFilter.Network, "{0} tried to eject {1}, but they are not in the same vehicle", GetPlayer().GetGUID().ToString(), packet.Passenger.ToString());
return;
}
VehicleSeatRecord seat = vehicle.GetSeatForPassenger(unit);
Cypher.Assert(seat != null);
if (seat.IsEjectable())
{
unit.ExitVehicle();
}
else
{
Log.outError(LogFilter.Network, "{0} attempted to eject {1} from non-ejectable seat.", GetPlayer().GetGUID().ToString(), packet.Passenger.ToString());
}
}
else
{
Log.outError(LogFilter.Network, "HandleEjectPassenger: {0} tried to eject invalid {1}", GetPlayer().GetGUID().ToString(), packet.Passenger.ToString());
}
}
public string ToString(Cypher cypher)
{
var sb = new StringBuilder();
Pattern.ForEach(pt => sb.Append(pt.ToString(cypher)));
sb.Append("/");
Generators.ForEach(gen => sb.Append(gen.ToString(cypher)));
sb.Append("/");
Context.Before.ForEach(pt => sb.Append(pt.ToString(cypher)));
sb.Append("_");
Context.After.ForEach(pt => sb.Append(pt.ToString(cypher)));
if (Exception != null)
{
Exception.Before.ForEach(pt => sb.Append(pt.ToString(cypher)));
sb.Append("_");
Exception.After.ForEach(pt => sb.Append(pt.ToString(cypher)));
}
return(sb.ToString());
}
public void MatchByRelationshipTypeUseIdentifer3()
{
var node1 = Node.CreateNode();
var node2 = Node.CreateNode();
var node3 = Node.CreateNode();
var rel1 = node2.CreateRelationshipTo(node1, "knows");
var rel2 = node1.CreateRelationshipTo(node3, "blocks");
var cypher = new Cypher();
cypher.Start(s => s.Node("node1", node1.Id));
cypher.Match(m => m.Node("node1").From("r1", "knows").Node("matchedNode"));
cypher.Return(r => r.Relationship("r1"));
var result = cypher.Execute();
Assert.IsTrue(result.Count() == 1);
Assert.IsTrue(result.First().Field <Relationship>("r1") == rel1);
}
private void UpdateClientDevice(string device)
{
try
{
var connInfo = device.DeserializeAndDecrypt <GetDevice>();
var deviceModel = _repository.GetClientTerminalByHost(Cypher.Encrypt(Cypher.Encrypt(connInfo.Hn)));
if (deviceModel == null)
{
return;
}
deviceModel.Code = device;
_repository.SaveChanges();
}
catch (Exception ex)
{
SharedLogger.LogError(ex, device);
}
}
public void IncomingRelationships()
{
var node1 = Node.CreateNode();
var node2 = Node.CreateNode();
var node3 = Node.CreateNode();
var rel1 = node1.CreateRelationshipTo(node2, "like");
var rel2 = node3.CreateRelationshipTo(node1, "like");
var cypher = new Cypher();
cypher.Start(s => s.Node("node1", node1.Id));
cypher.Match(m => m.Node("node1").From().Node("matchedNode"));
cypher.Return(r => r.Node("matchedNode"));
var result = cypher.Execute();
Assert.IsTrue(result.Count() == 1);
Assert.IsTrue(result.First().Field <Node>("matchedNode") == node3);
}
public void SetNodeProperty1()
{
var p = new Properties();
p.SetProperty("name", "jack");
var node1 = Node.CreateNode();
var cypher = new Cypher();
cypher.Start(s => s.Node("node1", node1.Id));
cypher.Set(s => s.Node("node1", p));
cypher.Return(r => r.Node("node1"));
var results = cypher.Execute();
var n1 = results.First().Field <Node>("node1");
Assert.IsTrue(n1.GetProperty <string>("name") == "jack");
}
public void MultipleRelationshipStartingPoints1()
{
var node1 = Node.CreateNode();
var node2 = Node.CreateNode();
var node3 = Node.CreateNode();
var rel1 = node1.CreateRelationshipTo(node3, "like");
var rel2 = node2.CreateRelationshipTo(node3, "like");
var cypher = new Cypher();
cypher.Start(s => s.Relationship("r1", rel1.Id).Relationship("r2", rel2.Id));
cypher.Return(r => r.Relationship("r1").Relationship("r2"));
var result = cypher.Execute();
Assert.IsTrue(result.Count() == 1);
Assert.IsTrue(rel1 == result.First().Field <Relationship>("r1"));
Assert.IsTrue(rel2 == result.First().Field <Relationship>("r2"));
}
public void OnPostAsync()
{
Output = string.Empty;
if (InputFile != null)
{
var isParsed = FileService.ParseFile(InputFile, WebHostEnvironment.WebRootPath, out string parsingResult);
if (!isParsed)
{
ErrorMessage = Constants.Errors.ParsingError;
return;
}
Input = parsingResult;
}
if (string.IsNullOrEmpty(Input) || string.IsNullOrEmpty(Key))
{
return;
}
try
{
Output = EncryptMode
? Cypher.Encrypt(Input, Key)
: Cypher.Decrypt(Input, Key);
}
catch (Exception ex)
{
ErrorMessage = Constants.Errors.ProcessingError;
Logger.LogError(ex.Message);
}
var isCreated = FileService.CreateFiles(Output, WebHostEnvironment.WebRootPath);
if (!isCreated)
{
ErrorMessage = Constants.Errors.FilesCreationError;
return;
}
}
private static Dictionary <string, object> GetCypherPathParameters(Cypher cypherModel, PathString pathString, ILogger log)
{
log.LogInformation("Attempting to read parameters from path");
var cypherPathStatementParameters = new Dictionary <string, object>();
if (cypherModel.QueryParams == null)
{
return(cypherPathStatementParameters);
}
var pathParams = cypherModel.QueryParams.Where(x => x.PathOrdinalPosition.HasValue);
if (!pathParams.Any())
{
return(cypherPathStatementParameters);
}
var pathParameters = pathString.Value.Replace("/Execute/", string.Empty).Split('/');
foreach (var cypherParam in pathParams)
{
try
{
var parameterValue = pathParameters[cypherParam.PathOrdinalPosition.Value];
if (string.IsNullOrWhiteSpace(parameterValue))
{
throw ApiFunctionException.InternalServerError($"Required parameter {cypherParam.Name} has no value in path");
}
cypherPathStatementParameters.Add(cypherParam.Name, parameterValue);
}
catch (Exception)
{
throw ApiFunctionException.BadRequest($"Required parameter {cypherParam.Name} not found in path parameters");
}
}
return(cypherPathStatementParameters);
}
public IActionResult Signup(string username, string password, string repeatPassword)
{
var errors = new List <string>();
if (username == null || username.Length == 0)
{
errors.Add("Username is required.");
}
else if (_gymDb.Users.ToList().Find(user => user.Login == username) != null)
{
return(View(SignupViewModel.newErrorInstance("A user with that name already exists")));
}
else if (username.Length < 3)
{
errors.Add("Username too short.");
}
if (password == null || password.Length == 0)
{
errors.Add("Password is required.");
}
else if (password.Length < 8)
{
errors.Add("Password too short.");
}
else if (password != repeatPassword)
{
errors.Add("Different passwords were provided.");
}
if (errors.Count > 0)
{
return(View(SignupViewModel.newErrorInstance(string.Join(' ', errors))));
}
else
{
var user = new User(username, Cypher.sha256Hash(password));
_gymDb.Users.Add(user);
_gymDb.SaveChanges();
return(View(SignupViewModel.newSuccessInstance(username)));
}
}
private static void Search(string searchword, string relatives, string limit, string acceptability, string langCode)
{
var search = Cypher.Get().Nodes(searchTerm: searchword.Trim(), relatives: relatives.Trim(), limit: limit.Trim(), acceptability: acceptability.Trim(), langCode: langCode.Trim());
if (search.Id == null || search.Id == "" || search.Term == null || search.Term == "")
{
Console.WriteLine("\n" + "No search result.");
}
else
{
Console.WriteLine("\nConceptId: " + search.Id);
Console.WriteLine("Term: " + search.Term + "\n");
foreach (var s in search.Results)
{
Console.WriteLine("ConceptId: " + s.ConceptId);
Console.WriteLine("Term: " + s.Term);
}
}
Console.Write("\n");
}
public void DirectedRelationshipsAndIdentifier()
{
var node1 = Node.CreateNode();
var node2 = Node.CreateNode();
var node3 = Node.CreateNode();
var rel1 = node1.CreateRelationshipTo(node2, "knows");
var rel2 = node1.CreateRelationshipTo(node3, "blocks");
var cypher = new Cypher();
cypher.Start(s => s.Node("node1", node1.Id));
cypher.Match(m => m.Node("node1").To("r", string.Empty).Node());
cypher.Return(r => r.Relationship("r"));
var result = cypher.Execute();
Assert.IsTrue(result.Count() == 2);
Assert.IsTrue(result.First().Field <Relationship>("r") == rel1);
Assert.IsTrue(result.ElementAt(1).Field <Relationship>("r") == rel2);
}
public uint GenerateInstanceId()
{
if (_nextInstanceId == 0xFFFFFFFF)
{
Log.outError(LogFilter.Maps, "Instance ID overflow!! Can't continue, shutting down server. ");
Global.WorldMgr.StopNow();
return(_nextInstanceId);
}
uint newInstanceId = _nextInstanceId;
Cypher.Assert(newInstanceId < _freeInstanceIds.Length);
_freeInstanceIds[(int)newInstanceId] = false;
// Find the lowest available id starting from the current NextInstanceId (which should be the lowest according to the logic in FreeInstanceId()
int nextFreeId = -1;
for (var i = (int)_nextInstanceId++; i < _freeInstanceIds.Length; i++)
{
if (_freeInstanceIds[i])
{
nextFreeId = i;
break;
}
}
if (nextFreeId == -1)
{
_nextInstanceId = (uint)_freeInstanceIds.Length;
_freeInstanceIds.Length += 1;
_freeInstanceIds[(int)_nextInstanceId] = true;
}
else
{
_nextInstanceId = (uint)nextFreeId;
}
return(newInstanceId);
}
void InitCircularMovement(AreaTriggerCircularMovementInfo cmi, uint timeToTarget)
{
// Circular movement requires either a center position or an attached unit
Cypher.Assert(cmi.Center.HasValue || cmi.TargetGUID.HasValue);
// should be sent in object create packets only
updateValues[(int)AreaTriggerFields.TimeToTarget].UnsignedValue = timeToTarget;
_circularMovementInfo.Set(cmi);
_circularMovementInfo.Value.TimeToTarget = timeToTarget;
_circularMovementInfo.Value.ElapsedTimeForMovement = 0;
if (IsInWorld)
{
AreaTriggerReShape reshape = new AreaTriggerReShape();
reshape.TriggerGUID = GetGUID();
reshape.AreaTriggerCircularMovement = _circularMovementInfo;
SendMessageToSet(reshape, true);
}
}
void HandleMoveRemoveMovementForceAck(MoveRemoveMovementForceAck moveRemoveMovementForceAck)
{
Unit mover = _player.m_unitMovedByMe;
Cypher.Assert(mover != null);
_player.ValidateMovementInfo(moveRemoveMovementForceAck.Ack.Status);
// prevent tampered movement data
if (moveRemoveMovementForceAck.Ack.Status.Guid != mover.GetGUID())
{
Log.outError(LogFilter.Network, $"HandleMoveRemoveMovementForceAck: guid error, expected {mover.GetGUID()}, got {moveRemoveMovementForceAck.Ack.Status.Guid}");
return;
}
moveRemoveMovementForceAck.Ack.Status.Time += m_clientTimeDelay;
MoveUpdateRemoveMovementForce updateRemoveMovementForce = new MoveUpdateRemoveMovementForce();
updateRemoveMovementForce.Status = moveRemoveMovementForceAck.Ack.Status;
updateRemoveMovementForce.TriggerGUID = moveRemoveMovementForceAck.ID;
mover.SendMessageToSet(updateRemoveMovementForce, false);
}
public void GetRelationshipByIndexQuery()
{
var node1 = Node.CreateNode();
var node2 = Node.CreateNode();
var rel = node1.CreateRelationshipTo(node2, "like");
var value1 = DateTime.Now.Millisecond;
rel.AddToIndex("relationships", "name", value1);
var cypher = new Cypher();
cypher.Start(s => s.Relationship("rel", "relationships", string.Format("name:{0}", value1)));
cypher.Return(r => r.Relationship("rel"));
var result = cypher.Execute();
Assert.IsTrue(result.Count() == 1);
Assert.IsTrue(rel == result.First().Field <Relationship>("rel"));
}
private void comboBoxCypher_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
switch (comboBoxCypher.SelectedIndex)
{
case 0:
cypher = Cypher.ShiftCypher;
ShiftCypherPreparation();
if (checkBoxAnalysisMode != null)
{
checkBoxAnalysisMode.Visibility = Visibility.Visible;
}
break;
case 1:
cypher = Cypher.SubstitutionCypher;
SubstitutionCypherPreparation();
if (checkBoxAnalysisMode != null)
{
checkBoxAnalysisMode.Visibility = Visibility.Visible;
}
break;
case 2:
cypher = Cypher.VigenereCypher;
VigenereCypherPreparation();
if (checkBoxAnalysisMode != null)
{
checkBoxAnalysisMode.Visibility = Visibility.Hidden;
checkBoxAnalysisMode.IsChecked = false;
}
break;
}
}