GameObject setFlagObject(TileData t, FlagData fd)
{
if (t.Owner == PlayerType.None)
{
if (fd.CurrentFlag != null)
{
Destroy(fd.CurrentFlag.gameObject);
fd.CurrentFlag = null;
}
return(null);
}
else
{
if (fd.CurrentFlag != null)
{
if (fd.CurrentType == t.Owner)
{
return(fd.CurrentFlag);
}
else
{
Destroy(fd.CurrentFlag.gameObject);
fd.CurrentFlag = null;
}
}
GameObject flagToSet = t.Owner == PlayerType.Battlebeard ? BattlebeardFlag : StormshaperFlag;
return((GameObject)Instantiate(flagToSet, fd.Marker.transform.position, fd.Marker.transform.rotation));
}
}
// Use this for initialization
void Start()
{
if (flagData.commonFlags == CommonFlags.None && flagData.valueFlags == ValueFlags.None)
{
flagData = new FlagData();
}
}
// Token: 0x060014AE RID: 5294 RVA: 0x000780E0 File Offset: 0x000762E0
private bool LoadFlagData(Item mailboxItem, FlagData flagData)
{
object obj = mailboxItem.TryGetProperty(ItemSchema.FlagStatus);
if (Enum.IsDefined(typeof(FlagStatus), obj) && (int)obj != 0)
{
flagData.Status = new int?((int)obj);
flagData.Type = (mailboxItem.TryGetProperty(ItemSchema.FlagRequest) as string);
flagData.DateCompleted = XsoFlagProperty.GetStoreDateTime(mailboxItem, ItemSchema.CompleteDate);
flagData.CompleteTime = XsoFlagProperty.GetStoreDateTime(mailboxItem, ItemSchema.FlagCompleteTime);
object obj2 = mailboxItem.TryGetProperty(ItemSchema.ReminderIsSet);
if (obj2 is bool)
{
flagData.ReminderSet = new bool?((bool)obj2);
}
flagData.ReminderTime = XsoFlagProperty.GetStoreDateTime(mailboxItem, ItemSchema.ReminderDueBy);
flagData.StartDate = XsoFlagProperty.GetStoreDateTime(mailboxItem, ItemSchema.LocalStartDate);
flagData.UtcStartDate = XsoFlagProperty.GetStoreDateTime(mailboxItem, ItemSchema.UtcStartDate);
flagData.DueDate = XsoFlagProperty.GetStoreDateTime(mailboxItem, ItemSchema.LocalDueDate);
flagData.UtcDueDate = XsoFlagProperty.GetStoreDateTime(mailboxItem, ItemSchema.UtcDueDate);
flagData.Subject = (base.XsoItem.TryGetProperty(ItemSchema.FlagSubject) as string);
flagData.OrdinalDate = XsoFlagProperty.GetStoreDateTime(mailboxItem, MessageItemSchema.ToDoOrdinalDate);
flagData.SubOrdinalDate = (base.XsoItem.TryGetProperty(MessageItemSchema.ToDoSubOrdinal) as string);
return(true);
}
return(false);
}
void M8.IModalPush.Push(M8.GenericParams parms)
{
ClearItems();
mFlagDataIndex = -1;
mCurIndex = 0;
mSearchKeywordData = null;
mKeywordResultIndex = 0;
if (parms != null)
{
if (parms.ContainsKey(parmSearchKeywordData))
{
mSearchKeywordData = parms.GetValue <SearchKeywordData>(parmSearchKeywordData);
}
if (parms.ContainsKey(parmSearchKeywordResultIndex))
{
mKeywordResultIndex = parms.GetValue <int>(parmSearchKeywordResultIndex);
}
}
//grab which item to use
FlagData itm = null;
if (mSearchKeywordData != null)
{
titleText.text = string.Format(M8.Localize.Get(titleTextRef), mSearchKeywordData.results[mKeywordResultIndex].text);
for (int i = 0; i < items.Length; i++)
{
var _itm = items[i];
if (_itm.sourceKeywordData == mSearchKeywordData && _itm.sourceKeywordResultIndex == mKeywordResultIndex)
{
itm = _itm;
mFlagDataIndex = i;
break;
}
}
}
else
{
}
if (itm != null)
{
//fill list
var dats = itm.data;
for (int i = 0; i < dats.Length; i++)
{
AllocateItem(itm, i);
}
UpdateSelectFlag();
}
scroller.normalizedPosition = new Vector2(0f, 1f);
}
private bool EnterFlags(FlagsType type, string name, uint offset, bool visible, uint pluginLine, string tooltip)
{
if (visible || _showInvisibles)
{
_currentFlags = new FlagData(name, offset, 0, type, pluginLine, tooltip);
return(true);
}
return(false);
}
public void LeaveFlags()
{
if (_currentFlags == null)
{
throw new InvalidOperationException("Cannot leave a flags field if one isn't active");
}
AddValue(_currentFlags);
_currentFlags = null;
}
// Token: 0x060014A9 RID: 5289 RVA: 0x00077AE0 File Offset: 0x00075CE0
private static void SetFlag(Item mailboxItem, FlagData flagData)
{
if (flagData.Type == null && !(mailboxItem is MeetingMessage))
{
throw new ConversionException("Missing required data from the client for non-MeetingMessage item: Type!");
}
if ((flagData.StartDate != null || flagData.UtcStartDate != null || flagData.DueDate != null || flagData.UtcDueDate != null) && (flagData.StartDate == null || flagData.UtcStartDate == null || flagData.DueDate == null || flagData.UtcDueDate == null))
{
throw new ConversionException(string.Format(CultureInfo.InvariantCulture, "Incorrect all or nothing datetime properties: StartDate={0}, UtcStartDate={1}, DueDate={2}, UtcDueDate={3}", new object[]
{
flagData.StartDate,
flagData.UtcStartDate,
flagData.DueDate,
flagData.UtcDueDate
}));
}
if (flagData.StartDate != null && (flagData.StartDate.Value > flagData.DueDate.Value || flagData.UtcStartDate.Value > flagData.UtcDueDate.Value))
{
throw new ConversionException(string.Format(CultureInfo.InvariantCulture, "Start date cannot be later than due date: StartDate={0}, UtcStartDate={1}, DueDate={2}, UtcDueDate={3}", new object[]
{
flagData.StartDate,
flagData.UtcStartDate,
flagData.DueDate,
flagData.UtcDueDate
}));
}
if (flagData.ReminderSet != null && flagData.ReminderSet.Value && flagData.ReminderTime == null)
{
throw new ConversionException("Missing ReminderTime while ReminderSet is true.");
}
if (flagData.ReminderSet == null)
{
flagData.ReminderSet = new bool?(false);
}
if (!flagData.ReminderSet.Value)
{
XsoFlagProperty.SetOrDeleteValueProperty <ExDateTime>(mailboxItem, MessageItemSchema.ReplyTime, null);
}
else
{
XsoFlagProperty.SetOrDeleteValueProperty <ExDateTime>(mailboxItem, MessageItemSchema.ReplyTime, flagData.ReminderTime);
}
if (mailboxItem.Reminder != null)
{
mailboxItem.Reminder.IsSet = flagData.ReminderSet.Value;
}
if (flagData.ReminderTime != null && mailboxItem.Reminder != null && !flagData.ReminderTime.Equals(mailboxItem.Reminder.DueBy))
{
mailboxItem.Reminder.DueBy = flagData.ReminderTime;
}
XsoFlagProperty.SetOrDeleteValueProperty <ExDateTime>(mailboxItem, MessageItemSchema.ToDoOrdinalDate, flagData.OrdinalDate);
XsoFlagProperty.SetOrDeleteProperty <string>(mailboxItem, MessageItemSchema.ToDoSubOrdinal, flagData.SubOrdinalDate);
mailboxItem.SetFlagForUtcSession(flagData.Type, flagData.StartDate, flagData.UtcStartDate, flagData.DueDate, flagData.UtcDueDate);
XsoFlagProperty.SetOrDeleteProperty <string>(mailboxItem, ItemSchema.FlagSubject, flagData.Subject);
}
public ValueUser()
{
Flag = FlagData.CLEAR;
NumberInt = 0;
Rectangle.xMin = 0.0f;
Rectangle.yMin = 0.0f;
Rectangle.xMax = 0.0f;
Rectangle.yMax = 0.0f;
Coordinate = Vector2.zero;
Text = "";
}
private FlagData CreateFlag()
{
FlagData flagData = new FlagData()
{
Name = Name,
Icon = Icon,
Image = FlagImage
};
return(flagData);
}
void OnWizardOtherButton()
{
if (FlagData)
{
Name = FlagData.Name;
FlagData.Icon = Icon;
FlagData.Image = FlagImage;
FlagData = null;
_data = null;
}
}
/// <summary>
/// Creates a new job.
/// </summary>
/// <param name="data">Data of the file which will be generated.</param>
public Job(Data data)
{
type = data switch
{
ClassData _ => JobType.Class,
FlagData _ => JobType.Flag,
EnumeratedData _ => JobType.Enumerated,
InterfaceData _ => JobType.Interface,
_ => type
};
this.data = data;
Console.WriteLine($"Created job for {data.Namespace}.{data.Name}.");
}
public void SetFlagForTile(TileData t)
{
FlagData flagData;
flagLookup.TryGetValue(t, out flagData);
if (flagData == null) {
flagData = new FlagData();
flagData.Marker = Utils.GetFirstChildWithTag("MarkerFlag", t.TileObject);
flagLookup.Add(t, flagData);
}
if (flagData.Marker) {
flagData.CurrentFlag = setFlagObject(t, flagData);
flagData.CurrentType = t.Owner;
}
}
public void SetFlagForTile(TileData t)
{
FlagData flagData;
flagLookup.TryGetValue(t, out flagData);
if (flagData == null)
{
flagData = new FlagData();
flagData.Marker = Utils.GetFirstChildWithTag("MarkerFlag", t.TileObject);
flagLookup.Add(t, flagData);
}
if (flagData.Marker)
{
flagData.CurrentFlag = setFlagObject(t, flagData);
flagData.CurrentType = t.Owner;
}
}
void OnWizardUpdate()
{
if (!Flag)
{
Flag = _flag;
}
if (!Equals(Flag, _flag))
{
_flag = Flag;
}
if (FlagData && FlagData != _data)
{
_data = FlagData;
OnWizardOtherButton();
}
Flag.FlagMesh.GetComponent <Renderer>().sharedMaterial.mainTexture = FlagImage;
}
void OnWizardCreate()
{
CreatIcons();
FlagData flag = CreateFlag();
string path = "Assets/BattleRoyale/_Flag/Data/" + Name + ".asset";
if (File.Exists(path))
{
if (!EditorUtility.DisplayDialog("FlagData Over Write",
"Are you sure you want to Over write " + Name
+ " ?", "Replace", "Do Not Replace"))
{
return;
}
}
AssetDatabase.CreateAsset(flag, path);
AssetDatabase.SaveAssets();
Repaint();
}
GameObject setFlagObject(TileData t, FlagData fd)
{
if (t.Owner == PlayerType.None) {
if (fd.CurrentFlag != null) {
Destroy(fd.CurrentFlag.gameObject);
fd.CurrentFlag = null;
}
return null;
} else {
if (fd.CurrentFlag != null) {
if (fd.CurrentType == t.Owner) {
return fd.CurrentFlag;
}
else {
Destroy(fd.CurrentFlag.gameObject);
fd.CurrentFlag = null;
}
}
GameObject flagToSet = t.Owner == PlayerType.Battlebeard ? BattlebeardFlag : StormshaperFlag;
return (GameObject)Instantiate(flagToSet, fd.Marker.transform.position, fd.Marker.transform.rotation);
}
}
// Token: 0x060014A7 RID: 5287 RVA: 0x000779E8 File Offset: 0x00075BE8
protected override void InternalCopyFromModified(IProperty srcProperty)
{
Item mailboxItem = (Item)base.XsoItem;
INestedProperty nestedProperty = (INestedProperty)srcProperty;
FlagData flagData = (FlagData)nestedProperty.NestedData;
if (flagData.Status == null || flagData.Status.Value == 0)
{
XsoFlagProperty.ClearFlag(mailboxItem);
return;
}
if (flagData.Status == 2)
{
XsoFlagProperty.SetFlag(mailboxItem, flagData);
return;
}
if (flagData.Status == 1)
{
XsoFlagProperty.CompleteFlag(mailboxItem, flagData);
return;
}
throw new ConversionException("Flag Status cannot be a value other than 0, 1, 2");
}
// Token: 0x060014AA RID: 5290 RVA: 0x00077E04 File Offset: 0x00076004
private static void CompleteFlag(Item mailboxItem, FlagData flagData)
{
if (flagData.CompleteTime == null)
{
throw new ConversionException(string.Format(CultureInfo.InvariantCulture, "Missing required data from the client: CompleteTime={0}", new object[]
{
flagData.CompleteTime
}));
}
if ((flagData.StartDate != null && flagData.DueDate != null && flagData.StartDate.Value > flagData.DueDate.Value) || (flagData.UtcStartDate != null && flagData.UtcDueDate != null && flagData.UtcStartDate.Value > flagData.UtcDueDate.Value))
{
throw new ConversionException(string.Format(CultureInfo.InvariantCulture, "Start date cannot be later than due date: StartDate={0}, UtcStartDate={1}, DueDate={2}, UtcDueDate={3}", new object[]
{
flagData.StartDate,
flagData.UtcStartDate,
flagData.DueDate,
flagData.UtcDueDate
}));
}
if (mailboxItem.Reminder != null)
{
mailboxItem.Reminder.IsSet = false;
}
XsoFlagProperty.SetOrDeleteValueProperty <ExDateTime>(mailboxItem, MessageItemSchema.ReplyTime, flagData.ReminderTime);
XsoFlagProperty.SetOrDeleteProperty <string>(mailboxItem, ItemSchema.FlagSubject, flagData.Subject);
if (!(mailboxItem is MeetingMessage))
{
XsoFlagProperty.SetOrDeleteProperty <string>(mailboxItem, ItemSchema.FlagRequest, flagData.Type);
}
XsoFlagProperty.SetOrDeleteValueProperty <ExDateTime>(mailboxItem, ItemSchema.LocalStartDate, flagData.StartDate);
XsoFlagProperty.SetOrDeleteValueProperty <ExDateTime>(mailboxItem, ItemSchema.LocalDueDate, flagData.DueDate);
XsoFlagProperty.SetOrDeleteValueProperty <ExDateTime>(mailboxItem, ItemSchema.UtcStartDate, flagData.UtcStartDate);
XsoFlagProperty.SetOrDeleteValueProperty <ExDateTime>(mailboxItem, ItemSchema.UtcDueDate, flagData.UtcDueDate);
XsoFlagProperty.SetOrDeleteValueProperty <ExDateTime>(mailboxItem, MessageItemSchema.ToDoOrdinalDate, flagData.OrdinalDate);
XsoFlagProperty.SetOrDeleteProperty <string>(mailboxItem, MessageItemSchema.ToDoSubOrdinal, flagData.SubOrdinalDate);
mailboxItem.CompleteFlagForUtcSession(flagData.DateCompleted, flagData.CompleteTime.Value);
}
// Token: 0x06000FEF RID: 4079 RVA: 0x0005AB74 File Offset: 0x00058D74
protected override void InternalCopyFrom(IProperty srcProperty)
{
INestedProperty nestedProperty = srcProperty as INestedProperty;
if (nestedProperty == null)
{
throw new UnexpectedTypeException("INestedProperty", srcProperty);
}
if (PropertyState.Modified != srcProperty.State)
{
throw new ConversionException("Property only supports conversion from Modified property state");
}
INestedData nestedData = nestedProperty.NestedData;
if (nestedData == null)
{
throw new ConversionException("nestedData is NULL");
}
base.XmlNode = base.XmlParentNode.OwnerDocument.CreateElement(base.AirSyncTagNames[0], base.Namespace);
IDictionaryEnumerator enumerator = nestedData.SubProperties.GetEnumerator();
while (enumerator.MoveNext())
{
string text = enumerator.Key as string;
string text2 = enumerator.Value as string;
if (text2 != null)
{
string namespaceURI = FlagData.IsTaskProperty(text) ? "Tasks:" : base.Namespace;
XmlNode newChild = base.XmlParentNode.OwnerDocument.CreateTextNode(text2);
XmlNode xmlNode = base.XmlParentNode.OwnerDocument.CreateElement(text, namespaceURI);
xmlNode.AppendChild(newChild);
base.XmlNode.AppendChild(xmlNode);
}
}
base.XmlParentNode.AppendChild(base.XmlNode);
}
private void LateUpdate()
{
if (currentMove != null)
{
FlagData flagData = flagHandler.Flags;
moveTime = moveTime == -1 ? 0 : moveTime + Time.deltaTime;
//get the state of the flags tracked by the move
CommonFlags moveFlags = (CommonFlags)currentMove.GetActiveFlags(moveTime, FlagTypes.CommonFlags);
//activate the flags that are active according to the move
//controllerFlags |= moveFlags;
flagData.commonFlags |= moveFlags;
//in the moveflags variable activate all flags not tracked by the move
moveFlags |= (CommonFlags) ~currentMove.GetTrackedFlags(FlagTypes.CommonFlags);
//turn off all flags not active acording to the move while leaving those not tracked by the move in their original state
//controllerFlags &= moveFlags;
flagData.commonFlags &= moveFlags;
flagData.valueFlags = (ValueFlags)currentMove.GetActiveFlags(moveTime, FlagTypes.ValueFlags);
flagHandler.Flags = flagData;
if (entityController != null && flagHandler.ValueFlags != ValueFlags.None)
{
float gravityMod = 1.0f;
if (!GetValue(ValueFlags.GravityModifier, out gravityMod))
{
gravityMod = 1.0f;
}
entityController.GravityModifier = gravityMod;
}
if (listenToMoveMotion && entityController != null && flagHandler.ValueFlags != ValueFlags.None)
{
Vector2 targetVelocity = entityController.TargetVelocity;
float val = 0;
if (GetValue(ValueFlags.xVelocity, out val))
{
targetVelocity.x = val * entityController.Facing;
}
if (GetValue(ValueFlags.yVelocity, out val))
{
targetVelocity.y = val;
}
entityController.TargetVelocity = targetVelocity;
}
if (currentMove.EndMove(moveTime))
{
bool exitConditions = true;
foreach (LinkCondition c in currentMove.ExitConditions)
{
if (!CheckCondition(c))
{
exitConditions = false;
break;
}
}
if (exitConditions)
{
StartMove(currentMove.ExitMove);
//EnterGenericState();
}
}
}
if (entityController != null)
{
entityController.AllowEntityCollision = (flagHandler.CommonFlags & CommonFlags.Dodgeing) == CommonFlags.None;
}
}
public ValueBools()
{
Flag = FlagData.CLEAR;
}
// Update is called once per frame
void Update()
{
if (Time.timeScale == 0)
{
return;
}
FlagData flagData = flagHandler.Flags;
Vector2 movementInput = Vector2.zero;
movementInput.x = directionalInput.x;
movementInput.y = directionalInput.y;
//movementInput.x = Input.GetAxisRaw("Horizontal");
//movementInput.y = Input.GetAxisRaw("Vertical");
Vector2 previousTarget = entityController.TargetVelocity;
Vector2 targetVelocity = Vector2.zero;
foreach (InputBuffer b in inputBuffers)
{
b.Update();
}
if ((flagData.commonFlags & CommonFlags.CanTurn) != CommonFlags.None)
{
if (movementInput.x != 0)
{
Vector3 sca = transform.localScale;
if (movementInput.x > 0)
{
sca.x = 1;
entityController.Facing = 1;
}
else
{
sca.x = -1;
entityController.Facing = -1;
}
transform.localScale = sca;
}
}
if ((flagData.commonFlags & CommonFlags.MoveWithInput) != CommonFlags.None)
{
targetVelocity.x = movementInput.x;
if ((flagData.commonFlags & CommonFlags.YMovement) != CommonFlags.None)
{
targetVelocity.y = movementInput.y * movementSpeed;
}
float xSpeedMult = movementSpeed;
if (!entityController.Grounded)
{
xSpeedMult = airMovementSpeed;
}
targetVelocity.x *= xSpeedMult;
}
if ((flagData.commonFlags & CommonFlags.MovementCancel) != CommonFlags.None)
{
if (movementInput.x != 0)
{
moveHandler.EnterGenericState("", 0.3f);
}
}
if ((flagData.commonFlags & CommonFlags.Dodgeing) != CommonFlags.None)
{
if (targetVelocity == Vector2.zero)
{
if (previousTarget == Vector2.zero)
{
targetVelocity.x = entityController.Facing * movementSpeed;
targetVelocity *= 6f;
}
else
{
targetVelocity = previousTarget;
}
}
else
{
//targetVelocity.y /= 2f;
targetVelocity *= 6f;
}
if (moveHandler.OverDodge != 0)
{
targetVelocity.y = movementSpeed;
}
/*animatorVec = targetVelocity;
* animatorVec.x *= facing;
* return animatorVec;*/
}
entityController.TargetVelocity = targetVelocity;
moveHandler.CheckMoves(CurrentMoves);
}
private void AllocateItem(FlagData flagData, int index)
{
ListItemData itm;
if (mListItemCache.Count > 0)
{
itm = mListItemCache[mListItemCache.Count - 1];
mListItemCache.RemoveAt(mListItemCache.Count - 1);
}
else
{
var newItemSelect = Instantiate(listItemTemplate);
newItemSelect.clickCallback += OnItemClick;
itm = new ListItemData(newItemSelect);
}
itm.itemSelect.transform.SetParent(listRoot, false);
itm.itemSelect.transform.SetSiblingIndex(index);
itm.itemSelect.Setup(index);
bool isFlaggable = flagData.flagDataIndex == index && flagData.flagData;
itm.itemSelect.isFlagged = isFlaggable && flagData.flagData.isFlagged;
itm.itemSelect.isSelected = index == mCurIndex;
var stringPairWidget = itm.stringPair;
stringPairWidget.counterText.text = index.ToString("X2");
//fill body
var dat = flagData.data[index];
var sbHex = new System.Text.StringBuilder();
var sbChars = new System.Text.StringBuilder();
//fill hex/char values
for (int i = 0; i < dat.Length; i++)
{
var c = dat[i];
if (c == ' ') //treat space as null
{
sbHex.Append("00");
}
else
{
sbHex.Append(((int)c).ToString("X2"));
}
sbHex.Append(' ');
sbChars.Append(c);
sbChars.Append(" ");
}
stringPairWidget.stringTextLeft.text = sbHex.ToString();
stringPairWidget.stringTextRight.text = sbChars.ToString();
stringPairWidget.highlightGO.SetActive(isFlaggable);
itm.itemSelect.gameObject.SetActive(true);
mListItemActive.Add(itm);
}
public ValueBools()
{
Flag = FlagData.CLEAR;
}
public ValueUser()
{
Flag = FlagData.CLEAR;
NumberInt = 0;
Rectangle.xMin = 0.0f;
Rectangle.yMin = 0.0f;
Rectangle.xMax = 0.0f;
Rectangle.yMax = 0.0f;
Coordinate = Vector2.zero;
Text = "";
}