ParsePrefixOp(ref OperatorData prevOpData,
Operator <TTerm, TAfterString, TUserState> op,
ref Reply <TTerm> reply,
CharStream <TUserState> stream)
{
var opData = new OperatorData();
opData.Line = stream.Line;
opData.LineBegin = stream.LineBegin;
opData.IndexToken = stream.IndexToken;
opData.Operator = op;
var userState = stream.UserState;
#if DEBUG
var ok = stream.Skip(op.String);
Debug.Assert(ok);
#else
stream.Skip((uint)op.String.Length);
#endif
var stateTag = stream.StateTag;
var asReply = op.AfterStringParser.Invoke(stream);
if (asReply.Status == ReplyStatus.Ok)
{
opData.AfterStringValue = asReply.Result;
var prevOp = prevOpData.Operator;
if (prevOp.Precedence != op.Precedence ||
prevOp.Type != OperatorType.Prefix ||
(prevOp.Associativity | op.Associativity) != Associativity.None)
{
reply.Error = asReply.Error;
var nextOp = ParseExpression(ref opData, ref reply, stream);
if (reply.Status == ReplyStatus.Ok)
{
reply.Result = op.Mapping1.Invoke(opData.AfterStringValue, reply.Result);
}
return(nextOp);
}
// backtrack to the beginning of the operator
stream.Seek(opData.IndexToken);
stream.SetLine_WithoutCheckAndWithoutIncrementingTheStateTag(opData.Line);
stream.SetLineBegin_WithoutCheckAndWithoutIncrementingTheStateTag(opData.LineBegin);
stream.UserState = userState;
stream.StateTag = stateTag - 1;
ReportConflict(ref prevOpData, op, asReply.Result, ref reply, stream);
return(null);
}
else if (asReply.Status == ReplyStatus.Error && stateTag == stream.StateTag)
{
// backtrack to the beginning of the operator
stream.Seek(opData.IndexToken);
stream.StateTag = stateTag - 1;
return(ErrorOp);
}
else
{
reply.Error = asReply.Error;
reply.Status = asReply.Status;
return(null);
}
}
/// <summary>
/// Sets the status of the operator
/// </summary>
/// <param name="operatorData">Object containing all data for an operator</param>
/// <returns>New operator availability list</returns>
public JsonResult SetOperatorStatus(string operatorData)
{
string apiKey = (string)Session["apiKey"];
OperatorData od = JsonConvert.DeserializeObject <OperatorData>(operatorData);
DashboardAPI dashboardObj = new DashboardAPI(apiKey);
var nextStatus = 0;
if (od.StatusType == 1)
{
nextStatus = 2;
}
else if (od.StatusType == 2)
{
nextStatus = 1;
}
Response resp = dashboardObj.SetOperatorStatus(od.ServiceTypeID, od.LoginID, nextStatus, od.ClientID);
if (resp.Status.ToLower() == "success")
{
var operators = dashboardObj.GetOperatorStatus();
var activeOperators = operators.FindAll(o => o.StatusType != 0).DistinctBy(x => x.LoginID).ToList();
return(Json(new { success = true, activeOperators }, JsonRequestBehavior.AllowGet));
}
else
{
return(Json(new { success = false, error = "Could not change operator status" }, JsonRequestBehavior.AllowGet));
}
}
private async void RegisterCommandClicked(object obj)
{
//Validate();
try
{
OperatorData.Add(new CompagniesData()
{
CompagnyCode = CompagnyCode, PhoneNumber = PhoneNumber
});
if (await utilServices.UserRegistration(Username, Password, UserEmail, OperatorData))
{
RegistrationResult = $"Mr/Mrs {Username} à été correctement Enregistré sur GuiMiGomma";
Username = string.Empty;
UserEmail = string.Empty;
Password = string.Empty;
PhoneNumber = string.Empty;
CompagnyCode = string.Empty;
}
}
catch (Exception e)
{
RegistrationResult = e.Message;
}
}
public GameObject CreateOperator(GameObject operatorCreate, OperatorData operatorData, UISelectAvatar selectAvatar)
{
GameObject OperatorUI = Instantiate(MainController.OperatorInterfaseObject, operatorsParent.transform);
OperatorUI.name = operatorData.Name;
GameObject Operator = Instantiate(operatorCreate, OperatorUI.transform);
Operator.transform.SetSiblingIndex(0);
OperatorController operatorController = OperatorUI.GetComponent <OperatorController>();
operatorController.selectAvatar = selectAvatar;
operatorController._operatorObject = Operator;
operatorController._operatorData = operatorData;
operatorController.SetStartHP(operatorController._operatorData.maxHP);
operatorController.SetStartSkillPoint(operatorController._operatorData.skill.initCost, operatorController._operatorData.skill.cost);
CapsuleCollider capsuleCollider = OperatorUI.AddComponent <CapsuleCollider>();
capsuleCollider.radius = 0.35f;
Rigidbody rigidbody = OperatorUI.AddComponent <Rigidbody>();
rigidbody.useGravity = false;
rigidbody.constraints = RigidbodyConstraints.FreezeAll;
Operators.Add(OperatorUI);
OperatorUI.transform.position = new Vector3(9999f, 9999f, 9999f);
return(OperatorUI);
}
private void HandlePossibleConflict(ref OperatorData prevOpData,
Operator <TTerm, TAfterString, TUserState> op,
ref Reply <TTerm> reply,
CharStream <TUserState> stream)
{
// "possible" conflict, because it's not a conflict when the
// after-string-parser fails without changing the parser state.
var state = stream.State;
var ok = stream.Skip(op.String);
Debug.Assert(ok);
var stateTag = stream.StateTag;
var asReply = op.AfterStringParser.Invoke(stream);
if (asReply.Status == ReplyStatus.Ok)
{
stream.BacktrackTo(ref state);
ReportConflict(ref prevOpData, op, asReply.Result, ref reply, stream);
}
else if (asReply.Status == ReplyStatus.Error && stateTag == stream.StateTag)
{
// backtrack and ignore the operator
stream.BacktrackTo(ref state);
reply.Error = ErrorMessageList.Merge(reply.Error, ExpectedInfixOrPostfixOperator);
}
else
{
// report AfterStringParser error instead of conflict
reply.Error = asReply.Error;
reply.Status = asReply.Status;
}
}
public void updateSelectInfo(OperatorData operatorData)
{
if (operatorData != null)
{
UpdateSelectInfo(operatorData);
}
}
public OperatorData BackUpOperatorData(OperatorController operatorController)
{
tempData = operatorController._operatorData;
tempDataClear = Instantiate(operatorController._operatorData);
return(tempData);
}
public static void AddOperatorData(OperatorData data)
{
if (data.name == null)
{
return;
}
genericOperatorContainer.operators.Add(data);
}
void Start()
{
hoverOff = transform.localPosition;
hoverOn = transform.localPosition + new Vector3(0f, 10f, 0f);
if (operatorObject.TryGetComponent(out OperatorController operatorController))
{
_operatorData = operatorController._operatorData;
}
}
public override string GetData()
{
var data = new OperatorData()
{
Operation = Operation
};
return JsonConvert.SerializeObject(data);
}
public override string GetData()
{
var data = new OperatorData()
{
Operation = Operation
};
return(JsonConvert.SerializeObject(data));
}
public IEnumerable <OperatorStats> GetOperatorData()
{
if (!File.Exists(_operatorFile))
{
using var webClient = new WebClient();
webClient.DownloadFile("https://d6static.dragonfruit.network/data/operators.json", _operatorFile);
}
return(OperatorData.GetOperatorDataFromFile(_operatorFile));
}
public void RequestQueryParserOperatorsPrimitives()
{
CombinatorialEngine engine = CombinatorialEngine.FromDimensions(
new Dimension("Operator", OperatorData.Values),
new Dimension("LeftType", TypeData.Values),
new Dimension("RightType", TypeData.Values));
TypedCustomDataContext <AllTypes> .ClearValues();
TypedCustomDataContext <AllTypes> .ClearHandlers();
try
{
TypedCustomDataContext <AllTypes> .ValuesRequested += (x, y) =>
{
((TypedCustomDataContext <AllTypes>)x).SetValues(new object[] { new AllTypes() });
};
using (TestWebRequest request = TestWebRequest.CreateForInProcess())
{
request.DataServiceType = typeof(TypedCustomDataContext <AllTypes>);
TestUtil.RunCombinatorialEngineFail(engine, delegate(Hashtable values)
{
TypeData left = (TypeData)values["LeftType"];
TypeData right = (TypeData)values["RightType"];
if (!left.IsTypeSupported || !right.IsTypeSupported)
{
return;
}
// Big matrix. Let's cut it down by assuming that left and right ordering does not matter.
if (Array.IndexOf(TypeData.Values, left) > Array.IndexOf(TypeData.Values, right))
{
return;
}
string leftName = AllTypes.PropertyNameForType(left.ClrType);
string rightName = AllTypes.PropertyNameForType(right.ClrType);
OperatorData o = (OperatorData)values["Operator"];
string requestText = "/Values?$filter=" + leftName + "%20" + o.Token + "%20" + rightName;
request.RequestUriString = requestText;
Exception exception = TestUtil.RunCatching(request.SendRequest);
TestUtil.AssertExceptionExpected(exception,
o.IsEqualityComparison && !left.IsEqualityComparableTo(right),
o.IsOrderingComparison && !left.IsOrderComparableTo(right));
});
}
}
finally
{
TypedCustomDataContext <AllTypes> .ClearValues();
TypedCustomDataContext <AllTypes> .ClearHandlers();
}
}
public void bigSizeWhenchosen(string createTime)
{
foreach (GameObject cube in storedData.Operators)
{
OperatorData cubeData = cube.GetComponent <OperatorData>();
cube.transform.localScale = cubeData.localscale;
if (cubeData.createTime.Equals(createTime))
{
cube.transform.localScale = new Vector3(3f * cubeData.localscale.x, 3f * cubeData.localscale.y, 3f * cubeData.localscale.z);
}
}
}
public void UpdateSelectInfoOnlySkill(OperatorData operatorData)
{
if (operatorData.skill.isActive)
{
SkillSlider.maxValue = operatorData.skill.duration;
SkillSlider.value = operatorData.skill.curDurationTime;
}
else
{
SkillSlider.maxValue = operatorData.skill.cost;
SkillSlider.value = operatorData.skill.curSkillPoint;
}
}
public Guid OperatorStart(string userName)
{
var od = new OperatorData()
{
OperatorID = Guid.NewGuid(),
OperatorName = userName,
OnlineTime = DateTime.Now,
LastOperationTime = DateTime.Now
};
_operators.Add(od);
return(od.OperatorID);
}
public void OnEnable()
{
if (SkillEvent == null)
{
SkillEvent = new MySkillEvent();
}
tempData = new OperatorData();
curSkillPoint = 0;
curDurationTime = 0;
isActive = false;
isCanActive = false;
tempData = null;
}
private void HandleMissingTernary2ndStringError(ref OperatorData opData,
ref Reply <TTerm> reply,
CharStream <TUserState> stream)
{
var firstStringIndex = opData.IndexToken.GetIndex(stream);
var firstStringColumn = firstStringIndex - opData.LineBegin + 1;
var firstStringPos = new Position(stream.Name, firstStringIndex, opData.Line, firstStringColumn);
var secondStringPos = stream.Position;
var error1 = ExpectedInfixOrPostfixOperator;
var error2 = MissingTernary2ndStringErrorFormatter.Invoke(Tuple.Create(firstStringPos, secondStringPos, (TernaryOperator <TTerm, TAfterString, TUserState>)opData.Operator, opData.AfterStringValue));
reply.Error = ErrorMessageList.Merge(reply.Error, ErrorMessageList.Merge(error1, error2));
reply.Status = ReplyStatus.Error;
}
public override string GetData()
{
var vplType = Type;
if (vplType == null)
return null;
var data = new OperatorData()
{
VplTypeId = vplType.Id
};
return JsonConvert.SerializeObject(data);
}
private void ReportConflict(ref OperatorData prevOpData,
Operator <TTerm, TAfterString, TUserState> op,
TAfterString afterStringValue,
ref Reply <TTerm> reply,
CharStream <TUserState> stream)
{
var prevOpIndex = prevOpData.IndexToken.GetIndex(stream);
var prevOpColumn = prevOpIndex - prevOpData.LineBegin + 1;
var prevOpPos = new Position(stream.Name, prevOpIndex, prevOpData.Line, prevOpColumn);
var error = _OperatorConflictErrorFormatter.Invoke(
Tuple.Create(prevOpPos, prevOpData.Operator, prevOpData.AfterStringValue),
Tuple.Create(stream.Position, op, afterStringValue));
reply.Error = ErrorMessageList.Merge(reply.Error, error);
reply.Status = ReplyStatus.Error;
}
public override string GetData()
{
var vplType = Type;
if (vplType == null)
{
return(null);
}
var data = new OperatorData()
{
VplTypeId = vplType.Id
};
return(JsonConvert.SerializeObject(data));
}
public bool Contains(OperatorData data)
{
foreach (var d in operators)
{
if (d.ID == data.ID &&
d.name == data.name &&
d.posX == data.posX &&
d.posY == data.posY &&
d.posZ == data.posZ &&
d.parent == data.parent)
{
return(true);
}
}
return(false);
}
/// <summary>
/// Fills _Operators struct with config received
/// </summary>
private void CreateOperatorsData()
{
OperatorData operatorTA = null;
List <OperatorData> operatorsCopy = new List <OperatorData>();
foreach (DireccionamientoSIP dirSip in _SystemCfg.PlanDireccionamientoSIP)
{
SectorData sector = new SectorData();
operatorTA = null;
foreach (StrNumeroAbonado num in dirSip.NumerosAbonadoQueAtiende)
{
if (operatorTA == null)
{
operatorTA = operatorsCopy.Find(x => x.idGroupName.Equals(num.IdAgrupacion));
if (operatorTA == null)
{
operatorTA = new OperatorData();
operatorTA.idGroupName = num.IdAgrupacion;
foreach (AsignacionUsuariosTV tv in _SystemCfg.PlanAsignacionUsuarios)
{
if ((tv.IdUsuario != STR_SECTOR_FS) && (tv.IdUsuario != STR_PUESTO_FS))
{
if (tv.IdUsuario.Equals(dirSip.IdUsuario))
{
operatorTA.idHost = tv.IdHost;
break;
}
}
}
}
}
CfgRecursoEnlaceInterno cfg = new CfgRecursoEnlaceInterno();
cfg.NombreRecurso = dirSip.IdUsuario;
cfg.NumeroAbonado = num.NumeroAbonado;
cfg.Prefijo = num.Prefijo;
sector.numberData.Add(cfg);
sector.idUser = dirSip.IdUsuario;
}
operatorTA.sectorData.Add(sector);
if (operatorsCopy.Contains(operatorTA) == false)
{
operatorsCopy.Add(operatorTA);
}
}
_Operators = operatorsCopy;
}
public void confirmAction()
{
if (ControlObj.GetComponent <CommonControl>().canDrawLine || ControlObj.GetComponent <PaintOnMap>().isModify)
{
descriptionText.text = textField.text;
gameObject.SetActive(false);
ControlObj.GetComponent <PaintOnMap>().isModify = false;
}
else
{
if (textField.text.Length == 0)
{
MNPopup mNPopup = new MNPopup("Info", "Add some information about this step");
mNPopup.AddAction("Ok", () => { Debug.Log("Ok action callback"); });
mNPopup.Show();
//EditorUtility.DisplayDialog("Error", "Add some information about this step", "OK", "Cancel");
return;
}
OperatorData objdata = operatorObj.GetComponent <OperatorData>();
CommonData storeData = ControlObj.GetComponent <CommonData>();
StepDetail detail = storeData.newStrategy.steps[storeData.chosenStepIndex];
Debug.Log(JsonUtility.ToJson(objdata));
//Text infotext = textCanvas.GetComponentInChildren<Text>();
//infotext.text = "Detail";
//int stepIndex = objdata.actionNumber;
foreach (StepDetailAction step in detail.detailActions)
{
if (step.createTime.Equals(objdata.createTime))
{
step.actionInfo = textField.text;
}
}
objdata.actionInfo = textField.text;
Debug.Log(JsonUtility.ToJson(storeData));
textField.text = "";
storeData.isUpdated = true;
gameObject.SetActive(false);
}
}
public void TestGenerateOperatorData()
{
MethodInfo op = typeof(TestClass).GetMethod("op_Subtraction");
IReadOnlyList <MemberRef> expectedAttr = new MemberRef[]
{ new MemberRef("STAThreadAttribute", MemberRefType.Class, typeof(STAThreadAttribute).MetadataToken) };
methodGen.GenerateName(op).Returns("CSDocNet.TestDoc.TestClass.op_Subtraction");
methodGen.GenerateAttributes(op).Returns(expectedAttr);
MemberData member = gen.GenerateMemberData(op);
MethodData method = methodGen.GenerateMethodData(op);
OperatorData opData = gen.GenerateOperatorData(op);
Assert.AreEqual(member, opData.Member);
Assert.AreEqual(method, opData.Method);
Assert.AreEqual(Operator.Subtraction, opData.Operator);
}
protected override void Execute(CodeActivityContext context)
{
// Get the current data structures
ActivityConfig a = ActivityData.Get(context);
OperatorConfig o = OperatorData.Get(context);
if (Review.Get(context))
{
a.ResetEval();
o.ResetEval();
}
else
{
a.IncrementEvalCount();
o.IncrementEvalCount();
}
// Return the updated data
ActivityData.Set(context, a);
OperatorData.Set(context, o);
}
public static GenericOperator CreateGenericOperator(OperatorData data)
{
Vector3 position = new Vector3();
List <GenericOperator> parents = new List <GenericOperator>();
List <GameObject> prefabList = obs.GetOperatorPrefabs();
foreach (var prefab in prefabList)
{
if (data.name == prefab.name)
{
parents = new List <GenericOperator>();
position = new Vector3(data.posX, data.posY, data.posZ);
int parentID = 0;
foreach (var child in obs.GetOperators())
{
parentID = child.Id;
if (parentID == data.parent)
{
parents.Add(child.GetComponent <GenericOperator>());
break;
}
}
GameObject go = obs.CreateOperator(prefab, parents);
GenericOperator op = go.GetComponent <GenericOperator>() ?? go.AddComponent <GenericOperator>();
//waiting for one frame, due to generating icons and children
instance.StartCoroutine(instance.SetIconLocation(op, position));
instance.StartCoroutine(instance.DestroyNewOperatorChildren(op.Children));
op.Id = data.ID;
op.LoadSpecificData(data);
operatorList.Add(op);
return(op);
}
}
return(null);
}
/// <summary> /// The visit implementation for <see cref="OperatorData"/> instances. /// </summary> public virtual void VisitOperatorData(OperatorData item) => DefaultVisit(item);
public override void LoadSpecificData(OperatorData data)
{
splitCustomData = (CustomSplitData)data.customData;
threshold = splitCustomData.thr;
axis = splitCustomData.axis;
}
public void RequestQueryParserOperatorsReferences()
{
// AllTypesWithReferences
var referenceTypes = new Type[]
{
typeof(object), // an open property
null // a null literal
};
CombinatorialEngine engine = CombinatorialEngine.FromDimensions(
new Dimension("Operator", OperatorData.Values),
new Dimension("LeftType", referenceTypes),
new Dimension("RightType", TypeData.Values));
OpenTypeContextWithReflection <AllTypesWithReferences> .ClearHandlers();
try
{
OpenTypeContextWithReflection <AllTypesWithReferences> .ValuesRequested += (x, y) =>
{
((OpenTypeContextWithReflection <AllTypesWithReferences>)x).SetValues(new object[] { new AllTypesWithReferences() });
};
using (TestWebRequest request = TestWebRequest.CreateForInProcess())
{
request.DataServiceType = typeof(OpenTypeContextWithReflection <AllTypesWithReferences>);
TestUtil.RunCombinatorialEngineFail(engine, delegate(Hashtable values)
{
Type left = (Type)values["LeftType"];
TypeData right = (TypeData)values["RightType"];
if (!right.IsTypeSupported)
{
return;
}
string leftName = AllTypesWithReferences.PropertyNameForReferenceType(left);
string rightName = AllTypesWithReferences.PropertyNameForType(right.ClrType);
OperatorData o = (OperatorData)values["Operator"];
string requestText = "/Values?$filter=" + leftName + "%20" + o.Token + "%20" + rightName;
request.RequestUriString = requestText;
Trace.WriteLine("Sending request " + requestText);
Exception exception = TestUtil.RunCatching(request.SendRequest);
if (left == null)
{
// Anything can be compared to null (but only for equality, no ordering supported).
TestUtil.AssertExceptionExpected(exception, !o.IsEqualityComparison);
}
else if (left == typeof(object))
{
// Anything can be compared to an open property for anything at parse time.
// At execution time, ordering will only be supported for types which can be
// ordered as well.
//
// NOTE: because the sample values are null, reference checks will succeed at runtime.
// (we normally would just fail this at parse time, but because these are reference
// types and provides the open type comparer, it passes; that's probably OK, in case
// a back-end does provider order for these types)
TestUtil.AssertExceptionExpected(exception,
!o.IsEqualityComparison && !right.IsOrderComparableTo(right) &&
right.ClrType != typeof(byte[]) && right.ClrType != typeof(System.Data.Linq.Binary) &&
right.ClrType != typeof(System.Xml.Linq.XElement) &&
!(null != Nullable.GetUnderlyingType(right.ClrType)));
}
});
}
}
finally
{
OpenTypeContextWithReflection <AllTypesWithReferences> .ClearHandlers();
}
}
public void UpdateSelectInfo(OperatorData operatorData)
{
operatorDataSelect = operatorData;
Name.text = operatorData.Name;
Level.text = operatorData.Level.ToString();
if (operatorData.OperatorType == OperatorData.OperatorTypeEnum.Caster)
{
operatorTypeImage.sprite = operatorTypeSprite.Caster;
}
if (operatorData.OperatorType == OperatorData.OperatorTypeEnum.Guard)
{
operatorTypeImage.sprite = operatorTypeSprite.Guard;
}
if (operatorData.OperatorType == OperatorData.OperatorTypeEnum.Medic)
{
operatorTypeImage.sprite = operatorTypeSprite.Medic;
}
if (operatorData.OperatorType == OperatorData.OperatorTypeEnum.Sniper)
{
operatorTypeImage.sprite = operatorTypeSprite.Sniper;
}
if (operatorData.OperatorType == OperatorData.OperatorTypeEnum.Specialist)
{
operatorTypeImage.sprite = operatorTypeSprite.Specialist;
}
if (operatorData.OperatorType == OperatorData.OperatorTypeEnum.Supporter)
{
operatorTypeImage.sprite = operatorTypeSprite.Supporter;
}
if (operatorData.OperatorType == OperatorData.OperatorTypeEnum.Defender)
{
operatorTypeImage.sprite = operatorTypeSprite.Defender;
}
if (operatorData.OperatorType == OperatorData.OperatorTypeEnum.Vanguard)
{
operatorTypeImage.sprite = operatorTypeSprite.Vanguard;
}
if (operatorData.Elite == OperatorData.EliteEnum.Elite_0)
{
OperatorElitImage.sprite = OperatorElitImages.Elite_0;
artBig.sprite = operatorData.artBig_Ellite0;
}
if (operatorData.Elite == OperatorData.EliteEnum.Elite_1)
{
OperatorElitImage.sprite = OperatorElitImages.Elite_1;
artBig.sprite = operatorData.artBig_Ellite0;
}
if (operatorData.Elite == OperatorData.EliteEnum.Elite_2)
{
OperatorElitImage.sprite = OperatorElitImages.Elite_2;
artBig.sprite = operatorData.artBig_Ellite2;
}
HP.maxValue = operatorData.maxHP;
HP.value = operatorData.curHP;
HPText.text = $"{operatorData.curHP}/{operatorData.maxHP}";
Attack.text = operatorData.Attack.ToString();
Defense.text = operatorData.Defense.ToString();
RES.text = operatorData.RES.ToString();
Block.text = operatorData.Block.ToString();
BlockBig.text = $"Blocks {operatorData.Block} enemies";
SkillImage.sprite = operatorData.skill.skillImage;
SkillName.text = operatorData.skill.name;
SkillDescription.text = operatorData.skill.description;
if (operatorData.skill.isActive)
{
SkillSlider.maxValue = operatorData.skill.duration;
SkillSlider.value = operatorData.skill.curDurationTime;
}
else
{
SkillSlider.maxValue = operatorData.skill.cost;
SkillSlider.value = operatorData.skill.curSkillPoint;
}
killButton.killOperatorObject = operatorController;
}
public override void LoadSpecificData(OperatorData data)
{
}
