protected void moveHandle(Vector3 position, Quaternion rotation, Vector3 scale, bool doRotation, bool doScale)
{
DevkitTransactionManager.beginTransaction(new TranslatedText(new TranslationReference("#SDG::Devkit.Transactions.Transform")));
Matrix4x4 matrix4x = Matrix4x4.TRS(this.handlePosition, this.handleRotation, Vector3.one);
Matrix4x4 inverse = matrix4x.inverse;
Matrix4x4 matrix4x2 = Matrix4x4.TRS(Vector3.zero, Quaternion.Inverse(this.handleRotation) * rotation, Vector3.one);
matrix4x *= matrix4x2;
Vector3 vector = position - this.handlePosition;
foreach (DevkitSelection devkitSelection in DevkitSelectionManager.selection)
{
if (!(devkitSelection.gameObject == null))
{
DevkitTransactionUtility.recordObjectDelta(devkitSelection.transform);
if (doRotation)
{
Matrix4x4 matrix4x3 = inverse * devkitSelection.transform.localToWorldMatrix;
Matrix4x4 matrix = matrix4x * matrix4x3;
devkitSelection.transform.position = matrix.GetPosition();
devkitSelection.transform.rotation = matrix.GetRotation();
}
devkitSelection.transform.position += vector;
if (doScale)
{
devkitSelection.transform.localScale = scale;
}
}
}
this.transformSelection();
DevkitTransactionManager.endTransaction();
}
public static void load(LevelInfo newInfo)
{
Level._isEditor = false;
Level._isDevkit = false;
Level.isExiting = false;
Level._info = newInfo;
LoadingUI.updateScene();
SceneManager.LoadScene("Game");
if (!Dedicator.isDedicated)
{
string text = Level.info.name.ToLower();
if (text != null)
{
if (!(text == "germany"))
{
if (!(text == "hawaii"))
{
if (!(text == "pei"))
{
if (!(text == "russia"))
{
if (!(text == "yukon"))
{
if (text == "washington")
{
Provider.provider.achievementsService.setAchievement("Washington");
}
}
else
{
Provider.provider.achievementsService.setAchievement("Yukon");
}
}
else
{
Provider.provider.achievementsService.setAchievement("Russia");
}
}
else
{
Provider.provider.achievementsService.setAchievement("PEI");
}
}
else
{
Provider.provider.achievementsService.setAchievement("Hawaii");
}
}
else
{
Provider.provider.achievementsService.setAchievement("Peaks");
}
}
}
Provider.updateRichPresence();
DevkitTransactionManager.resetTransactions();
}
public static void edit(LevelInfo newInfo, bool Devkit)
{
Level._isEditor = true;
Level._isDevkit = Devkit;
Level.isExiting = false;
Level._info = newInfo;
LoadingUI.updateScene();
SceneManager.LoadScene("Game");
Provider.updateRichPresence();
DevkitTransactionManager.resetTransactions();
}
protected virtual void handleTextSubmitted(Sleek2Field field, string value)
{
if (this.leaf != null)
{
DevkitTransactionManager.beginTransaction(new TranslatedText(new TranslationReference("#SDG::Devkit.Transactions.Translation")));
DevkitTransactionUtility.recordObjectDelta(this.leaf);
DevkitTransactionUtility.recordObjectDelta(this.leaf.translation);
this.leaf.text = value;
this.leaf.version++;
this.leaf.translation.isDirty = true;
DevkitTransactionManager.endTransaction();
}
}
public static void exit()
{
if (Level.onLevelExited != null)
{
Level.onLevelExited();
}
if (!Level.isEditor && Player.player != null && PlayerUI.window != null && Level.info != null && PlayerUI.window.totalTime > 60f)
{
int fpsMin = PlayerUI.window.fpsMin;
int fpsMax = PlayerUI.window.fpsMax;
int num = (int)((float)PlayerUI.window.totalFrames / PlayerUI.window.totalTime);
string value = (!Level.info.canAnalyticsTrack) ? "Workshop" : Level.info.name;
Dictionary<string, object> dictionary = new Dictionary<string, object>
{
{
"FPS_Min",
fpsMin
},
{
"FPS_Max",
fpsMax
},
{
"FPS_Avg",
num
},
{
"Map",
value
},
{
"Network",
Provider.clients.Count > 1
}
};
Analytics.CustomEvent("Perf", dictionary);
}
Level._isEditor = false;
Level._isDevkit = false;
Level.isExiting = true;
Level._info = null;
LoadingUI.updateScene();
SceneManager.LoadScene("Menu");
Provider.updateRichPresence();
DevkitTransactionManager.resetTransactions();
}
// Token: 0x06000E00 RID: 3584 RVA: 0x00062290 File Offset: 0x00060690
public static void writeSplatmap(Bounds worldBounds, Landscape.LandscapeWriteSplatmapHandler callback)
{
if (callback == null)
{
return;
}
LandscapeBounds landscapeBounds = new LandscapeBounds(worldBounds);
for (int i = landscapeBounds.min.x; i <= landscapeBounds.max.x; i++)
{
for (int j = landscapeBounds.min.y; j <= landscapeBounds.max.y; j++)
{
LandscapeCoord landscapeCoord = new LandscapeCoord(i, j);
LandscapeTile tile = Landscape.getTile(landscapeCoord);
if (tile != null)
{
if (!Landscape.splatmapTransactions.ContainsKey(landscapeCoord))
{
LandscapeSplatmapTransaction landscapeSplatmapTransaction = new LandscapeSplatmapTransaction(tile);
DevkitTransactionManager.recordTransaction(landscapeSplatmapTransaction);
Landscape.splatmapTransactions.Add(landscapeCoord, landscapeSplatmapTransaction);
}
SplatmapBounds splatmapBounds = new SplatmapBounds(landscapeCoord, worldBounds);
for (int k = splatmapBounds.min.x; k <= splatmapBounds.max.x; k++)
{
for (int l = splatmapBounds.min.y; l <= splatmapBounds.max.y; l++)
{
SplatmapCoord splatmapCoord = new SplatmapCoord(k, l);
for (int m = 0; m < Landscape.SPLATMAP_LAYERS; m++)
{
Landscape.SPLATMAP_LAYER_BUFFER[m] = tile.sourceSplatmap[k, l, m];
}
Vector3 worldPosition = Landscape.getWorldPosition(landscapeCoord, splatmapCoord);
callback(landscapeCoord, splatmapCoord, worldPosition, Landscape.SPLATMAP_LAYER_BUFFER);
for (int n = 0; n < Landscape.SPLATMAP_LAYERS; n++)
{
tile.sourceSplatmap[k, l, n] = Mathf.Clamp01(Landscape.SPLATMAP_LAYER_BUFFER[n]);
}
}
}
tile.data.SetAlphamaps(0, 0, tile.sourceSplatmap);
}
}
}
}
// Token: 0x06001334 RID: 4916 RVA: 0x0007A7AC File Offset: 0x00078BAC
protected void updateList()
{
this.panel.clearElements();
Sleek2TranslatedLabel sleek2TranslatedLabel = new Sleek2TranslatedLabel();
sleek2TranslatedLabel.transform.anchorMin = new Vector2(0f, 1f);
sleek2TranslatedLabel.transform.anchorMax = new Vector2(1f, 1f);
sleek2TranslatedLabel.transform.pivot = new Vector2(0.5f, 1f);
sleek2TranslatedLabel.transform.sizeDelta = new Vector2(0f, 50f);
sleek2TranslatedLabel.translation = new TranslatedText(new TranslationReference("SDG", "Devkit.Window.Transaction.Undo"));
sleek2TranslatedLabel.translation.format();
this.panel.addElement(sleek2TranslatedLabel);
foreach (DevkitTransactionGroup newGroup in DevkitTransactionManager.getUndoable())
{
TransactionUndoButton transactionUndoButton = new TransactionUndoButton(newGroup);
transactionUndoButton.transform.anchorMin = new Vector2(0f, 1f);
transactionUndoButton.transform.anchorMax = new Vector2(1f, 1f);
transactionUndoButton.transform.pivot = new Vector2(0.5f, 1f);
transactionUndoButton.transform.sizeDelta = new Vector2(0f, 30f);
transactionUndoButton.clicked += this.handleUndoButtonClicked;
this.panel.addElement(transactionUndoButton);
}
Sleek2TranslatedLabel sleek2TranslatedLabel2 = new Sleek2TranslatedLabel();
sleek2TranslatedLabel2.transform.anchorMin = new Vector2(0f, 1f);
sleek2TranslatedLabel2.transform.anchorMax = new Vector2(1f, 1f);
sleek2TranslatedLabel2.transform.pivot = new Vector2(0.5f, 1f);
sleek2TranslatedLabel2.transform.sizeDelta = new Vector2(0f, 50f);
sleek2TranslatedLabel2.translation = new TranslatedText(new TranslationReference("SDG", "Devkit.Window.Transaction.Redo"));
sleek2TranslatedLabel2.translation.format();
this.panel.addElement(sleek2TranslatedLabel2);
foreach (DevkitTransactionGroup newGroup2 in DevkitTransactionManager.getRedoable())
{
TransactionRedoButton transactionRedoButton = new TransactionRedoButton(newGroup2);
transactionRedoButton.transform.anchorMin = new Vector2(0f, 1f);
transactionRedoButton.transform.anchorMax = new Vector2(1f, 1f);
transactionRedoButton.transform.pivot = new Vector2(0.5f, 1f);
transactionRedoButton.transform.sizeDelta = new Vector2(0f, 30f);
transactionRedoButton.clicked += this.handleRedoButtonClicked;
this.panel.addElement(transactionRedoButton);
}
}
public static void instantiate(ObjectAsset asset, Vector3 position, Quaternion rotation, Vector3 scale)
{
if (asset == null)
{
return;
}
if (!Level.isEditor)
{
return;
}
TranslationReference newReference = new TranslationReference("#SDG::Devkit.Transactions.Spawn");
TranslatedText translatedText = new TranslatedText(newReference);
translatedText.format(asset.objectName);
DevkitTransactionManager.beginTransaction(translatedText);
DevkitHierarchyWorldObject devkitHierarchyWorldObject = LevelObjects.addDevkitObject(asset.GUID, position, rotation, scale, ELevelObjectPlacementOrigin.MANUAL);
DevkitTransactionUtility.recordInstantiation(devkitHierarchyWorldObject.gameObject);
DevkitTransactionManager.endTransaction();
}
public static void instantiate(Type type, Vector3 position, Quaternion rotation, Vector3 scale)
{
if (!Level.isEditor)
{
return;
}
TranslationReference newReference = new TranslationReference("#SDG::Devkit.Transactions.Spawn");
TranslatedText translatedText = new TranslatedText(newReference);
translatedText.format(type.Name);
DevkitTransactionManager.beginTransaction(translatedText);
IDevkitHierarchySpawnable devkitHierarchySpawnable;
if (typeof(MonoBehaviour).IsAssignableFrom(type))
{
GameObject gameObject = new GameObject();
gameObject.name = type.Name;
gameObject.transform.position = position;
gameObject.transform.rotation = rotation;
gameObject.transform.localScale = scale;
DevkitTransactionUtility.recordInstantiation(gameObject);
devkitHierarchySpawnable = (gameObject.AddComponent(type) as IDevkitHierarchySpawnable);
}
else
{
devkitHierarchySpawnable = (Activator.CreateInstance(type) as IDevkitHierarchySpawnable);
}
if (devkitHierarchySpawnable != null)
{
devkitHierarchySpawnable.devkitHierarchySpawn();
}
IDevkitHierarchyItem devkitHierarchyItem = devkitHierarchySpawnable as IDevkitHierarchyItem;
if (devkitHierarchyItem != null)
{
LevelHierarchy.initItem(devkitHierarchyItem);
}
DevkitTransactionManager.endTransaction();
}
// Token: 0x06000DFF RID: 3583 RVA: 0x00062118 File Offset: 0x00060518
public static void writeHeightmap(Bounds worldBounds, Landscape.LandscapeWriteHeightmapHandler callback)
{
if (callback == null)
{
return;
}
LandscapeBounds landscapeBounds = new LandscapeBounds(worldBounds);
for (int i = landscapeBounds.min.x; i <= landscapeBounds.max.x; i++)
{
for (int j = landscapeBounds.min.y; j <= landscapeBounds.max.y; j++)
{
LandscapeCoord landscapeCoord = new LandscapeCoord(i, j);
LandscapeTile tile = Landscape.getTile(landscapeCoord);
if (tile != null)
{
if (!Landscape.heightmapTransactions.ContainsKey(landscapeCoord))
{
LandscapeHeightmapTransaction landscapeHeightmapTransaction = new LandscapeHeightmapTransaction(tile);
DevkitTransactionManager.recordTransaction(landscapeHeightmapTransaction);
Landscape.heightmapTransactions.Add(landscapeCoord, landscapeHeightmapTransaction);
}
HeightmapBounds heightmapBounds = new HeightmapBounds(landscapeCoord, worldBounds);
for (int k = heightmapBounds.min.x; k <= heightmapBounds.max.x; k++)
{
for (int l = heightmapBounds.min.y; l <= heightmapBounds.max.y; l++)
{
HeightmapCoord heightmapCoord = new HeightmapCoord(k, l);
float num = tile.sourceHeightmap[k, l];
Vector3 worldPosition = Landscape.getWorldPosition(landscapeCoord, heightmapCoord, num);
tile.sourceHeightmap[k, l] = Mathf.Clamp01(callback(landscapeCoord, heightmapCoord, worldPosition, num));
}
}
tile.data.SetHeightsDelayLOD(0, 0, tile.sourceHeightmap);
}
}
}
}
// Token: 0x06001336 RID: 4918 RVA: 0x0007AAE8 File Offset: 0x00078EE8
protected void handleRedoButtonClicked(Sleek2ImageButton button)
{
DevkitTransactionGroup group = (button as TransactionRedoButton).group;
for (DevkitTransactionGroup devkitTransactionGroup = null; devkitTransactionGroup != group; devkitTransactionGroup = DevkitTransactionManager.redo())
{
}
}
public virtual void update()
{
if (this.copySelectionDelay.Count > 0)
{
DevkitSelectionManager.clear();
foreach (GameObject newGameObject in this.copySelectionDelay)
{
DevkitSelectionManager.add(new DevkitSelection(newGameObject, null));
}
this.copySelectionDelay.Clear();
}
if (!DevkitNavigation.isNavigating)
{
if (DevkitInput.canEditorReceiveInput)
{
if (Input.GetKeyDown(113))
{
this.mode = DevkitSelectionTool.ESelectionMode.POSITION;
}
if (Input.GetKeyDown(119))
{
this.mode = DevkitSelectionTool.ESelectionMode.ROTATION;
}
if (Input.GetKeyDown(114))
{
this.mode = DevkitSelectionTool.ESelectionMode.SCALE;
}
}
Ray pointerToWorldRay = DevkitInput.pointerToWorldRay;
RaycastHit raycastHit;
if (!Physics.Raycast(pointerToWorldRay, ref raycastHit, 8192f, RayMasks.LOGIC))
{
Physics.Raycast(pointerToWorldRay, ref raycastHit, 8192f, (int)DevkitSelectionToolOptions.instance.selectionMask);
if (DevkitInput.canEditorReceiveInput && Input.GetKeyDown(101) && raycastHit.transform != null)
{
if (DevkitSelectionManager.selection.Count > 0)
{
this.handleTeleportTransformed(raycastHit.point, raycastHit.normal);
}
else
{
this.instantiate(raycastHit.point, raycastHit.normal);
}
}
}
if (DevkitInput.canEditorReceiveInput)
{
if (Input.GetKeyDown(323))
{
this.drag = new DevkitSelection((!(raycastHit.transform != null)) ? null : raycastHit.transform.gameObject, raycastHit.collider);
if (this.drag.isValid)
{
DevkitSelectionManager.data.point = raycastHit.point;
this.isDragging = DevkitSelectionManager.beginDrag(this.drag);
if (this.isDragging)
{
DevkitTransactionManager.beginTransaction(new TranslatedText(new TranslationReference("#SDG::Devkit.Transactions.Transform")));
foreach (DevkitSelection devkitSelection in DevkitSelectionManager.selection)
{
DevkitTransactionUtility.recordObjectDelta(devkitSelection.transform);
}
}
}
if (!this.isDragging)
{
DevkitSelectionManager.data.point = raycastHit.point;
this.beginAreaSelect = DevkitInput.pointerViewportPoint;
this.beginAreaSelectTime = Time.time;
}
}
if (Input.GetKey(323) && !this.isDragging && !this.isAreaSelecting && Time.time - this.beginAreaSelectTime > 0.1f)
{
this.isAreaSelecting = true;
this.areaSelection.Clear();
if (!Input.GetKey(304) && !Input.GetKey(306))
{
DevkitSelectionManager.clear();
}
}
}
if (this.isDragging && this.drag.collider != null)
{
DevkitSelectionManager.data.point = raycastHit.point;
DevkitSelectionManager.continueDrag(this.drag);
}
if (this.isAreaSelecting)
{
Vector3 pointerViewportPoint = DevkitInput.pointerViewportPoint;
Vector2 vector;
Vector2 vector2;
if (pointerViewportPoint.x < this.beginAreaSelect.x)
{
vector.x = pointerViewportPoint.x;
vector2.x = this.beginAreaSelect.x;
}
else
{
vector.x = this.beginAreaSelect.x;
vector2.x = pointerViewportPoint.x;
}
if (pointerViewportPoint.y < this.beginAreaSelect.y)
{
vector.y = pointerViewportPoint.y;
vector2.y = this.beginAreaSelect.y;
}
else
{
vector.y = this.beginAreaSelect.y;
vector2.y = pointerViewportPoint.y;
}
int selectionMask = (int)DevkitSelectionToolOptions.instance.selectionMask;
foreach (IDevkitHierarchyItem devkitHierarchyItem in LevelHierarchy.instance.items)
{
int num = 1 << devkitHierarchyItem.areaSelectGameObject.layer;
if ((num & selectionMask) == num)
{
Vector3 vector3 = MainCamera.instance.WorldToViewportPoint(devkitHierarchyItem.areaSelectCenter);
DevkitSelection devkitSelection2 = new DevkitSelection(devkitHierarchyItem.areaSelectGameObject, null);
if (vector3.z > 0f && vector3.x > vector.x && vector3.x < vector2.x && vector3.y > vector.y && vector3.y < vector2.y)
{
if (!this.areaSelection.Contains(devkitSelection2))
{
this.areaSelection.Add(devkitSelection2);
DevkitSelectionManager.add(devkitSelection2);
}
}
else if (this.areaSelection.Contains(devkitSelection2))
{
this.areaSelection.Remove(devkitSelection2);
DevkitSelectionManager.remove(devkitSelection2);
}
}
}
}
if (Input.GetKeyUp(323))
{
if (this.isDragging)
{
if (this.drag.isValid)
{
DevkitSelectionManager.data.point = raycastHit.point;
DevkitSelectionManager.endDrag(this.drag);
}
this.drag = DevkitSelection.invalid;
this.isDragging = false;
this.transformSelection();
DevkitTransactionManager.endTransaction();
}
else if (this.isAreaSelecting)
{
this.isAreaSelecting = false;
}
else if (DevkitInput.canEditorReceiveInput)
{
DevkitSelectionManager.select(this.drag);
}
}
if (raycastHit.transform != this.hover.transform || raycastHit.collider != this.hover.collider)
{
if (this.hover.isValid)
{
DevkitSelectionManager.data.point = raycastHit.point;
DevkitSelectionManager.endHover(this.hover);
}
this.hover.transform = raycastHit.transform;
this.hover.collider = raycastHit.collider;
if (this.hover.isValid)
{
DevkitSelectionManager.data.point = raycastHit.point;
DevkitSelectionManager.beginHover(this.hover);
}
}
}
if (DevkitSelectionManager.selection.Count > 0)
{
this.handlePosition = Vector3.zero;
this.handleRotation = Quaternion.identity;
bool flag = !DevkitSelectionToolOptions.instance.localSpace;
foreach (DevkitSelection devkitSelection3 in DevkitSelectionManager.selection)
{
if (!(devkitSelection3.gameObject == null))
{
this.handlePosition += devkitSelection3.transform.position;
if (!flag)
{
this.handleRotation = devkitSelection3.transform.rotation;
flag = true;
}
}
}
this.handlePosition /= (float)DevkitSelectionManager.selection.Count;
this.positionGameObject.SetActive(this.mode == DevkitSelectionTool.ESelectionMode.POSITION);
this.positionHandle.suggestTransform(this.handlePosition, this.handleRotation);
this.rotationGameObject.SetActive(this.mode == DevkitSelectionTool.ESelectionMode.ROTATION);
this.rotationHandle.suggestTransform(this.handlePosition, this.handleRotation);
this.scaleGameObject.SetActive(this.mode == DevkitSelectionTool.ESelectionMode.SCALE);
this.scaleHandle.suggestTransform(this.handlePosition, this.handleRotation);
if (DevkitInput.canEditorReceiveInput)
{
if (Input.GetKeyDown(99))
{
this.copyBuffer.Clear();
foreach (DevkitSelection devkitSelection4 in DevkitSelectionManager.selection)
{
this.copyBuffer.Add(devkitSelection4.gameObject);
}
}
if (Input.GetKeyDown(118))
{
TranslationReference newReference = new TranslationReference("#SDG::Devkit.Transactions.Paste");
TranslatedText name = new TranslatedText(newReference);
DevkitTransactionManager.beginTransaction(name);
foreach (GameObject gameObject in this.copyBuffer)
{
IDevkitSelectionCopyableHandler component = gameObject.GetComponent <IDevkitSelectionCopyableHandler>();
GameObject gameObject2;
if (component != null)
{
gameObject2 = component.copySelection();
}
else
{
gameObject2 = Object.Instantiate <GameObject>(gameObject);
}
IDevkitHierarchyItem component2 = gameObject2.GetComponent <IDevkitHierarchyItem>();
if (component2 != null)
{
component2.instanceID = LevelHierarchy.generateUniqueInstanceID();
}
DevkitTransactionUtility.recordInstantiation(gameObject2);
this.copySelectionDelay.Add(gameObject2);
}
DevkitTransactionManager.endTransaction();
}
if (Input.GetKeyDown(127))
{
TranslationReference newReference2 = new TranslationReference("#SDG::Devkit.Transactions.Delete_Selection");
TranslatedText name2 = new TranslatedText(newReference2);
DevkitTransactionManager.beginTransaction(name2);
foreach (DevkitSelection devkitSelection5 in DevkitSelectionManager.selection)
{
DevkitTransactionUtility.recordDestruction(devkitSelection5.gameObject);
}
DevkitSelectionManager.clear();
DevkitTransactionManager.endTransaction();
}
if (Input.GetKeyDown(98))
{
this.referencePosition = this.handlePosition;
this.referenceRotation = this.handleRotation;
this.referenceScale = Vector3.one;
this.hasReferenceScale = false;
if (DevkitSelectionManager.selection.Count == 1)
{
foreach (DevkitSelection devkitSelection6 in DevkitSelectionManager.selection)
{
if (!(devkitSelection6.gameObject == null))
{
this.referenceScale = devkitSelection6.transform.localScale;
this.hasReferenceScale = true;
}
}
}
}
if (Input.GetKeyDown(110))
{
this.moveHandle(this.referencePosition, this.referenceRotation, this.referenceScale, true, this.hasReferenceScale && DevkitSelectionManager.selection.Count == 1);
}
if (Input.GetKeyDown(102))
{
List <Collider> list = ListPool <Collider> .claim();
List <Renderer> list2 = ListPool <Renderer> .claim();
Bounds bounds;
bounds..ctor(this.handlePosition, Vector3.zero);
foreach (DevkitSelection devkitSelection7 in DevkitSelectionManager.selection)
{
if (!(devkitSelection7.gameObject == null))
{
list.Clear();
devkitSelection7.gameObject.GetComponentsInChildren <Collider>(list);
foreach (Collider collider in list)
{
bounds.Encapsulate(collider.bounds);
}
list2.Clear();
devkitSelection7.gameObject.GetComponentsInChildren <Renderer>(list2);
foreach (Renderer renderer in list2)
{
bounds.Encapsulate(renderer.bounds);
}
}
}
ListPool <Collider> .release(list);
ListPool <Renderer> .release(list2);
DevkitNavigation.focus(bounds);
}
}
}
else
{
this.positionGameObject.SetActive(false);
this.rotationGameObject.SetActive(false);
this.scaleGameObject.SetActive(false);
}
}
// Token: 0x060010CD RID: 4301 RVA: 0x0006E15F File Offset: 0x0006C55F
protected override void handleButtonClick()
{
DevkitTransactionManager.redo();
base.handleButtonClick();
}
private void Update()
{
if (EventSystem.current.currentSelectedGameObject != null && DevkitWindowManager.isActive)
{
return;
}
if (Player.player != null)
{
return;
}
if (Input.GetKey(304))
{
int num = -1;
if (Input.GetKeyDown(48))
{
num = 0;
}
else if (Input.GetKeyDown(49))
{
num = 1;
}
else if (Input.GetKeyDown(50))
{
num = 2;
}
else if (Input.GetKeyDown(51))
{
num = 3;
}
else if (Input.GetKeyDown(52))
{
num = 4;
}
else if (Input.GetKeyDown(53))
{
num = 5;
}
else if (Input.GetKeyDown(54))
{
num = 6;
}
else if (Input.GetKeyDown(55))
{
num = 7;
}
else if (Input.GetKeyDown(56))
{
num = 8;
}
else if (Input.GetKeyDown(57))
{
num = 9;
}
if (num != -1 && DevkitHotkeys.tools[num] != null)
{
DevkitHotkeys.tools[num].isActive = true;
}
}
if (Input.GetKeyDown(122) && Input.GetKey(306))
{
if (Input.GetKey(304))
{
DevkitTransactionManager.redo();
}
else
{
DevkitTransactionManager.undo();
}
}
}
// Token: 0x060010B5 RID: 4277 RVA: 0x0006DB48 File Offset: 0x0006BF48
private void Update()
{
if (EventSystem.current.currentSelectedGameObject != null && DevkitWindowManager.isActive)
{
return;
}
if (Player.player != null)
{
return;
}
if (Input.GetKey(KeyCode.LeftShift))
{
int num = -1;
if (Input.GetKeyDown(KeyCode.Alpha0))
{
num = 0;
}
else if (Input.GetKeyDown(KeyCode.Alpha1))
{
num = 1;
}
else if (Input.GetKeyDown(KeyCode.Alpha2))
{
num = 2;
}
else if (Input.GetKeyDown(KeyCode.Alpha3))
{
num = 3;
}
else if (Input.GetKeyDown(KeyCode.Alpha4))
{
num = 4;
}
else if (Input.GetKeyDown(KeyCode.Alpha5))
{
num = 5;
}
else if (Input.GetKeyDown(KeyCode.Alpha6))
{
num = 6;
}
else if (Input.GetKeyDown(KeyCode.Alpha7))
{
num = 7;
}
else if (Input.GetKeyDown(KeyCode.Alpha8))
{
num = 8;
}
else if (Input.GetKeyDown(KeyCode.Alpha9))
{
num = 9;
}
if (num != -1 && DevkitHotkeys.tools[num] != null)
{
DevkitHotkeys.tools[num].isActive = true;
}
}
if (Input.GetKeyDown(KeyCode.Z) && Input.GetKey(KeyCode.LeftControl))
{
if (Input.GetKey(KeyCode.LeftShift))
{
DevkitTransactionManager.redo();
}
else
{
DevkitTransactionManager.undo();
}
}
}
