public ClientVC(NetworkReader nr)
: base(new Vec2i(0,0), 0)
{
this.data = new VesselTile[VesselChunk.DATA_COUNT];
index.x = nr.ReadInt32();
index.y = nr.ReadInt32();
version = nr.ReadUInt32();
tileCount = nr.ReadInt32();
for (int i = 0; i < tileCount; i++) {
//read in vessel tile
Vec2i tileI;
tileI.x = nr.ReadInt32();
tileI.y = nr.ReadInt32();
FloorType floor0 = (FloorType)nr.ReadByte();
FloorType floor1 = (FloorType)nr.ReadByte();
WallTypeMask wallMask = (WallTypeMask)nr.ReadByte();
bool wallNode = nr.ReadBoolean();
VesselTile tile = new VesselTile(wallMask, wallNode, floor0, floor1, (uint)VesselTile.FLAGS.NONE);
SetTile(tileI, tile);
}
}
public override void OnDeserialize(NetworkReader reader, bool initialState)
{
if (reader.ReadPackedUInt32() != 0)
{
this.m_Slot = reader.ReadByte();
this.m_ReadyToBegin = reader.ReadBoolean();
}
}
public override void Deserialize(NetworkReader reader)
{
this.scripts = new CRCMessageEntry[(int) reader.ReadUInt16()];
for (int index = 0; index < this.scripts.Length; ++index)
this.scripts[index] = new CRCMessageEntry()
{
name = reader.ReadString(),
channel = reader.ReadByte()
};
}
public override void Deserialize(NetworkReader reader)
{
int num = reader.ReadUInt16();
this.scripts = new CRCMessageEntry[num];
for (int i = 0; i < this.scripts.Length; i++)
{
this.scripts[i] = new CRCMessageEntry {
name = reader.ReadString(),
channel = reader.ReadByte()
};
}
}
public override void Deserialize(NetworkReader reader)
{
int num = reader.ReadUInt16();
this.scripts = new CRCMessageEntry[num];
for (int i = 0; i < this.scripts.Length; i++)
{
this.scripts[i] = new CRCMessageEntry {
name = reader.ReadString(), channel = reader.ReadByte()
};
}
}
public void Receive_ClientRecieveTransmission(NetworkReader reader)
{
Int32 transmissionId = reader.ReadInt32();
Int32 recBuffer_count = reader.ReadInt32();
System.Byte[] recBuffer = new System.Byte[recBuffer_count];
for (int recBuffer_index = 0; recBuffer_index < recBuffer_count; recBuffer_index++)
{
recBuffer[recBuffer_index] = reader.ReadByte();
}
ClientRecieveTransmission(transmissionId, recBuffer);
}
public override void OnDeserialize(NetworkReader reader, bool initialState)
{
var dirty = reader.ReadPackedUInt32();
if (dirty == 0)
{
return;
}
m_Slot = reader.ReadByte();
m_ReadyToBegin = reader.ReadBoolean();
}
/// <summary>
/// Read up to 40 bytes of a NetworkReader into a bitstream. This resets the bitstream before copying.
/// </summary>
/// <param name="reader"></param>
/// <param name="bitstream"></param>
public static void Read(this NetworkReader reader, ref Bitstream bitstream)
{
bitstream.Reset();
// Copy the reader into our buffer so we can extra the packed bits. UNET uses a byte reader so we can't directly read bit fragments out of it.
int count = System.Math.Min(40, reader.Length);
for (int i = (int)reader.Position; i < count; ++i)
{
byte b = reader.ReadByte();
bitstream.WriteByte(b);
}
}
public override void Deserialize(NetworkReader reader)
{
int num = (int)reader.ReadUInt16();
this.scripts = new CRCMessageEntry[num];
for (int i = 0; i < this.scripts.Length; i++)
{
CRCMessageEntry cRCMessageEntry = default(CRCMessageEntry);
cRCMessageEntry.name = reader.ReadString();
cRCMessageEntry.channel = reader.ReadByte();
this.scripts[i] = cRCMessageEntry;
}
}
public void SerializeDeltaWritesNetIdAndComponentIndex()
{
SyncVarNetworkBehaviour <EmptyBehaviour> field = new SyncVarNetworkBehaviour <EmptyBehaviour>(serverComponent);
NetworkWriter writer = new NetworkWriter();
field.OnSerializeDelta(writer);
NetworkReader reader = new NetworkReader(writer.ToArraySegment());
Assert.That(reader.ReadUInt(), Is.EqualTo(serverComponent.netId));
Assert.That(reader.ReadByte(), Is.EqualTo(serverComponent.ComponentIndex));
}
private static void ReadBlock(ref byte[] values, NetworkReader reader, int blockIndex)
{
var fullBlockMask = new FullBlockMask();
var maskIndex = 0;
while (true)
{
var blockBytes = reader.ReadByte();
uint mask, xor;
do
{
(mask, xor) = GetMask(maskIndex++);
}while ((blockBytes & mask ^ xor) != 0);
fullBlockMask[maskIndex - 1] = blockBytes;
if ((blockBytes & highestBitInByte) != 0)
{
break;
}
}
var bitesSkipped = 0;
for (var i = 0; i < 32; i++)
{
if ((blockValuesMask & highestBitInInt >> i) == 0)
{
bitesSkipped++;
continue;
}
if ((fullBlockMask.integer & highestBitInInt >> i) != 0)
{
var valueIndex = (blockIndex * valuesPerBlock) + i - bitesSkipped;
ResizeOrInitIfNeeded(ref values, valueIndex);
values[valueIndex] = reader.ReadByte();
}
}
}
public static BoneSyncData DeSerialize(NetworkReader reader)
{
var boneSyncData = new BoneSyncData();
boneSyncData.boneId = reader.ReadByte();
boneSyncData.position = reader.ReadVector3();
boneSyncData.rotation = reader.ReadVector3();
if (boneSyncData.boneId == 0)
{
boneSyncData.velocity = reader.ReadVector3();
}
return(boneSyncData);
}
// public void PopulateMessage(NetworkBehaviour behaviour, NetworkWriter writer)
// {
// this.NetworkId = behaviour.NetworkId;
// this.BehaviourIndex = behaviour.BehaviourIndex;
// this.DataLength = writer.Position;
//
// reader.Replace(writer.RawBuffer);
// reader.ReadBytes(this.Data, this.DataLength);
// }
public override void Deserialize(NetworkReader reader)
{
base.Deserialize(reader);
this.NetworkId = (long)reader.ReadPackedUInt64();
this.BehaviourIndex = (int)reader.ReadPackedUInt32();
this.DataLength = (int)reader.ReadPackedUInt32();
for (int i = 0; i < this.DataLength; i++)
{
this.Data[i] = reader.ReadByte();
}
}
public void Deserialize([NotNull] NetworkReader reader)
{
var arr = SerializationBuffers.Get();
var length = reader.ReadUInt16();
for (var i = 0; i < length; i++)
{
arr[i] = reader.ReadByte();
}
Data = new ArraySegment <byte>(arr, 0, length);
}
// Alternative to reading in a Byte array with the UNET reader - which allocates a new Array to do it. This SHOULD produce less garbage.
/// <summary>
/// Alternative to HLAPI NetworkReader ReadBytes(), which creates a new byte[] every time. This reuses a byte[] and reads the bytes in
/// one at a time, hopefully eliminating GC.
/// </summary>
/// <param name="reader"></param>
/// <param name="count"></param>
/// <returns>Returns the same byte array as the on in the arguments.</returns>
public static byte[] ReadBytesNonAlloc(this NetworkReader reader, byte[] targetbytearray, int count = -1)
{
if (count == -1)
{
count = targetbytearray.Length;
}
for (int i = 0; i < count; i++)
{
targetbytearray[i] = reader.ReadByte();
}
return(targetbytearray);
}
// Token: 0x06000AD9 RID: 2777 RVA: 0x000358D4 File Offset: 0x00033AD4
public void Deserialize(NetworkReader reader)
{
this.origin = reader.ReadVector3();
this.rotation = reader.ReadQuaternion();
this.rootObject = reader.ReadGameObject();
this.modelChildIndex = (short)(reader.ReadByte() - 1);
this.scale = reader.ReadSingle();
this.color = reader.ReadColor32();
this.start = reader.ReadVector3();
this.genericUInt = reader.ReadPackedUInt32();
this.genericFloat = reader.ReadSingle();
this.genericBool = reader.ReadBoolean();
}
/// <summary>
/// Reads a compressed quaternion from a reader.
/// </summary>
/// <param name="reader"></param>
/// <returns></returns>
public static Quaternion ReadCompressedQuaternion(NetworkReader reader)
{
byte largest = reader.ReadByte();
short a = 0, b = 0, c = 0;
if (!Quaternions.UseLargestOnly(largest))
{
a = reader.ReadInt16();
b = reader.ReadInt16();
c = reader.ReadInt16();
}
return(Quaternions.DecompressQuaternion(largest, a, b, c));
}
// Token: 0x060018E1 RID: 6369 RVA: 0x0006B220 File Offset: 0x00069420
public void Read(NetworkReader reader)
{
this.gameResultType = (GameResultType)reader.ReadByte();
this.gameModeIndex = (int)reader.ReadPackedUInt32();
this.seed = reader.ReadUInt64();
this.snapshotTime = reader.ReadFixedTimeStamp();
this.runStopwatchValue = reader.ReadSingle();
reader.ReadRuleBook(this.ruleBook);
int newSize = (int)reader.ReadByte();
Array.Resize <RunReport.PlayerInfo>(ref this.playerInfos, newSize);
for (int i = 0; i < this.playerInfos.Length; i++)
{
if (this.playerInfos[i] == null)
{
this.playerInfos[i] = new RunReport.PlayerInfo();
}
this.playerInfos[i].Read(reader);
}
Array.Sort <RunReport.PlayerInfo>(this.playerInfos, delegate(RunReport.PlayerInfo a, RunReport.PlayerInfo b)
{
if (a.isLocalPlayer == b.isLocalPlayer)
{
if (a.isLocalPlayer)
{
return(b.localPlayerIndex - a.localPlayerIndex);
}
return(0);
}
else
{
if (!a.isLocalPlayer)
{
return(1);
}
return(-1);
}
});
}
public static DissonanceNetworkMessage Deserialize([NotNull] this NetworkReader reader)
{
var arr = SerializationBuffers.Get();
var length = reader.ReadUInt16();
for (var i = 0; i < length; i++)
{
arr[i] = reader.ReadByte();
}
return(new DissonanceNetworkMessage(new ArraySegment <byte>(arr, 0, length)));
}
public void Deserialize(NetworkReader reader)
{
this.damage = reader.ReadDamageInfo();
this.target = reader.ReadHurtBoxReference().ResolveHurtBox();
Byte flags = reader.ReadByte();
Byte mask = (Byte)0b0000_0001u;
this.callDamage = (flags & mask) > 0;
flags >>= 1;
this.callHitEnemy = (flags & mask) > 0;
flags >>= 1;
this.callHitWorld = (flags & mask) > 0;
}
public override void Deserialize(NetworkReader reader)
{
int numScripts = reader.ReadUInt16();
scripts = new CRCMessageEntry[numScripts];
for (int i = 0; i < scripts.Length; ++i)
{
var entry = new CRCMessageEntry();
entry.name = reader.ReadString();
entry.channel = reader.ReadByte();
scripts[i] = entry;
}
}
public override void Deserialize(NetworkReader reader)
{
int num = reader.ReadUInt16();
scripts = new CRCMessageEntry[num];
for (int i = 0; i < scripts.Length; i++)
{
CRCMessageEntry cRCMessageEntry = default(CRCMessageEntry);
cRCMessageEntry.name = reader.ReadString();
cRCMessageEntry.channel = reader.ReadByte();
scripts[i] = cRCMessageEntry;
}
}
public static NetworkBehaviour.NetworkBehaviourSyncVar ReadNetworkBehaviourSyncVar(this NetworkReader reader)
{
uint netId = reader.ReadUInt();
byte componentIndex = default;
// if netId is not 0, then index is also sent to read before returning
if (netId != 0)
{
componentIndex = reader.ReadByte();
}
return(new NetworkBehaviour.NetworkBehaviourSyncVar(netId, componentIndex));
}
public override void Deserialize(NetworkReader reader)
{
this.scripts = new CRCMessageEntry[(int)reader.ReadUInt16()];
for (int index = 0; index < this.scripts.Length; ++index)
{
this.scripts[index] = new CRCMessageEntry()
{
name = reader.ReadString(),
channel = reader.ReadByte()
}
}
;
}
public static LineInstance DeSerializeLine(NetworkReader reader)
{
var lineInstance = new LineInstance();
var num1 = reader.ReadSByte();
var flag = reader.ReadBoolean();
lineInstance.isChasing = flag;
lineInstance.m_positions.Clear();
for (var index = 0; index <= (int)num1; ++index)
{
var num2 = reader.ReadByte();
var num3 = reader.ReadByte();
var gridPos = new GridPos(
num2,
num3,
-1 // TODO (int) Board.\u000E().\u000E(gridPos.x, gridPos.y)
);
lineInstance.m_positions.Add(gridPos);
}
return(lineInstance);
}
public void NetworkDeserialize(NetworkReader reader)
{
position = reader.ReadVector3();
rotation = Quaternion.Euler(reader.ReadVector3());
jumpReady = reader.ReadBoolean();
isPushed = reader.ReadBoolean();
isRunning = reader.ReadBoolean();
isGrounded = reader.ReadBoolean();
jumpTimer = reader.ReadSingle();
stamina = reader.ReadSingle();
actionId = (ActionTypes)reader.ReadByte();
actionTimer = reader.ReadSingle();
}
public override void Deserialize(NetworkReader reader)
{
if (reader == null)
{
return;
}
List <Mahjong.RuleNode> ruleNodes = null;
int count = reader.ReadByte();
for (int i = 0; i < count; ++i)
{
if (ruleNodes == null)
{
ruleNodes = new List <Mahjong.RuleNode>();
}
ruleNodes.Add(new Mahjong.RuleNode((Mahjong.RuleType)reader.ReadByte(), reader.ReadByte(), reader.ReadByte()));
}
this.ruleNodes = ruleNodes == null ? null : ruleNodes.AsReadOnly();
}
internal void Execute(INetworkConnection connection, NetworkReader reader)
{
byte header = reader.ReadByte();
var handler = handlers[header];
if (handler == null)
{
return;
}
var message = new NetworkDataMessage(connection, reader);
handler(message);
}
public void OnDeserializeDelta(NetworkReader reader)
{
// This list can now only be modified by synchronization
IsReadOnly = true;
bool raiseOnChange = false;
int changesCount = (int)reader.ReadPackedUInt32();
for (int i = 0; i < changesCount; i++)
{
var operation = (Operation)reader.ReadByte();
// apply the operation only if it is a new change
// that we have not applied yet
bool apply = changesAhead == 0;
switch (operation)
{
case Operation.OP_ADD:
DeserializeAdd(reader, apply);
break;
case Operation.OP_SET:
DeserializeSet(reader, apply);
break;
case Operation.OP_CLEAR:
DeserializeClear(apply);
break;
case Operation.OP_REMOVE:
DeserializeRemove(reader, apply);
break;
}
if (apply)
{
raiseOnChange = true;
}
// we just skipped this change
else
{
changesAhead--;
}
}
if (raiseOnChange)
{
OnChange?.Invoke();
}
}
public static UpdateTileMessage.NetMessage Deserialize(this NetworkReader reader)
{
var message = new UpdateTileMessage.NetMessage();
message.Changes = new List <UpdateTileMessage.DelayedData>();
message.MatrixSyncNetID = reader.ReadUInt();
while (true)
{
var Continue = reader.ReadBool();
if (Continue == false)
{
break;
}
var WorkingOn = new UpdateTileMessage.DelayedData
{
Position = reader.ReadVector3Int(),
TileType = (TileType)reader.ReadInt(),
layerType = (LayerType)reader.ReadInt(),
TileName = reader.ReadString(),
MatrixSyncNetID = message.MatrixSyncNetID,
TransformMatrix = Matrix4x4.identity,
Colour = Color.white
};
while (true)
{
byte Operation = reader.ReadByte();
if (Operation == (byte)EnumOperation.NoMoreData)
{
break;
}
if (Operation == (byte)EnumOperation.Colour)
{
WorkingOn.Colour = reader.ReadColor();
}
if (Operation == (byte)EnumOperation.Matrix4x4)
{
WorkingOn.TransformMatrix = reader.ReadMatrix4x4();
}
}
message.Changes.Add(WorkingOn);
}
return(message);
}
public void Deserialize(NetworkReader reader)
{
_damage = reader.ReadDamageInfo();
_target = reader.ReadHurtBoxReference().ResolveHurtBox();
byte flags = reader.ReadByte();
const byte mask = 0b0001;
_callDamage = (flags & mask) > 0;
flags >>= 1;
_callHitEnemy = (flags & mask) > 0;
flags >>= 1;
_callHitWorld = (flags & mask) > 0;
}
public void Desearialize(NetworkReader reader)
{
int count = reader.ReadInt32();
m_Days.Clear();
for (int i = 0; i < count; i++)
{
DayInfo di = new DayInfo();
di.m_Year = reader.ReadInt16();
di.m_Month = reader.ReadByte();
di.m_Day = reader.ReadByte();
int starsCount = reader.ReadByte();
di.RebuildStarName(starsCount);
di.RebuildStarCount(starsCount);
for (int j = 0; j < starsCount; j++)
{
di.SetStarName(j, reader.ReadString());
di.SetStarCount(j, reader.ReadByte());
}
di.OnRebuild();
m_Days.Add(di);
}
}
/// <summary>
/// Deserialize the snapshot without compression.
/// </summary>
/// <param name="reader"></param>
public override void Deserialize(NetworkReader reader)
{
m_num_snapshots = (int)reader.ReadByte();
for (int i = 0; i < m_num_snapshots; i++)
{
NetworkInstanceId net_id = reader.ReadNetworkId();
Vector3 pos = default(Vector3);
pos.x = reader.ReadSingle();
pos.y = reader.ReadSingle();
pos.z = reader.ReadSingle();
Quaternion rot = reader.ReadQuaternion();
m_snapshots[i] = new PlayerSnapshot(net_id, pos, rot);
}
}
// Alternative to reading in a Byte array with the UNET reader - which allocates a new Array to do it. This SHOULD produce less garbage.
/// <summary>
/// Alternative to HLAPI NetworkReader ReadBytes(), which creates a new byte[] every time. This reuses a byte[] and reads the bytes in
/// one at a time, hopefully eliminating GC.
/// </summary>
/// <param name="reader"></param>
/// <param name="count"></param>
/// <returns>Returns the same byte array as the on in the arguments.</returns>
public static byte[] ReadBytesNonAlloc(this NetworkReader reader, byte[] targetbytearray, int count = -1)
{
if (count == -1)
{
count = reader.Length;
}
// TODO does this write 0s once the reader is empty? It needs to.
for (int i = 0; i < count; i++)
{
targetbytearray[i] = reader.ReadByte();
}
return(targetbytearray);
}
public void Deserialize(ref SerializeContext context, ref NetworkReader reader)
{
this.tick = reader.ReadInt32();
velocity = reader.ReadVector3Q();
action = (Action)reader.ReadInt32();
actionStartTick = reader.ReadInt32();
locoState = (LocoState)reader.ReadInt32();
locoStartTick = reader.ReadInt32();
position = reader.ReadVector3Q();
jumpCount = reader.ReadInt32();
sprinting = reader.ReadBoolean() ? 1 : 0;
cameraProfile = (CameraProfile)reader.ReadByte();
damageTick = reader.ReadInt32();
damageDirection = reader.ReadVector3Q();
}
public override void Deserialize(NetworkReader reader)
{
base.Deserialize(reader);
byte setType = reader.ReadByte();
switch (setType) {
case (byte)0: _actionSet = new SinglePanelActionSet(); break;
case (byte)1: _actionSet = new ReplacementPanelActionSet(); break;
case (byte)2: _actionSet = new CodePanelActionSet(); break;
default: throw new Exception("Unexpected Action Set ID " + setType);
}
_actionSet.Deserialize(reader);
_x = reader.ReadInt32();
_y = reader.ReadInt32();
_prefabIndex = reader.ReadInt32();
}
private void ReceiveTileStroke(NetworkReader reader,
int connectionID)
{
byte tile = reader.ReadByte();
uint[] values = UnpackBits(reader, 5, 5, 5, 5, 4, 4);
Vector2 start = new Vector2(values[0], values[1]);
Vector2 end = new Vector2(values[2], values[3]);
Color color = world.palette[values[4]];
int thickness = (int)values[5];
if (hosting)
{
if (!locks.ContainsKey(tile) || locks[tile].id != connectionID) return;
SendAll(StrokeMessage(tile, color, thickness, start, end), except: connectionID);
}
SpriteDrawing sprite = world.tiles[tile];
if (thickness > 0)
{
sprite.DrawLine(start, end, thickness, color, Blend.Alpha);
}
else
{
sprite.Fill(start, color);
}
sprite.Sprite.texture.Apply();
}
private void ReceiveLockTile(NetworkReader reader)
{
World.Avatar avatar = ID2Avatar(reader.ReadInt32());
byte tile = reader.ReadByte();
if (avatar != null)
{
Debug.LogFormat("{0} locking {1}", avatar.id, tile);
locks[tile] = avatar;
if (avatar == worldView.viewer) OpenForEdit(tile);
if (hosting) SendAll(LockTileMessage(avatar, tile));
}
else if (locks.ContainsKey(tile))
{
Debug.LogFormat("unlocking {0}", tile);
locks.Remove(tile);
if (hosting) SendAll(LockTileMessage(null, tile));
}
tilePalette.Refresh();
}
private void Update()
{
if (Input.GetKeyDown(KeyCode.LeftBracket))
{
paletteEditor.gameObject.SetActive(!paletteEditor.gameObject.activeSelf);
}
bool editing = tileEditor.gameObject.activeSelf;
bool chatting = chatOverlay.gameObject.activeSelf;
bool mapping = Input.GetKey(KeyCode.Tab)
&& !chatting;
if (editing && !chatting)
{
tileEditor.CheckInput();
}
if (Input.GetKeyDown(KeyCode.Escape))
{
if (chatting)
{
chatOverlay.Hide();
}
else if (editing)
{
tileEditor.OnClickedSave();
}
else if (hostID != -1)
{
OnApplicationQuit();
SceneManager.LoadScene("Main");
return;
}
else
{
Application.Quit();
return;
}
}
else if (Input.GetKeyDown(KeyCode.F12))
{
string selfies = Application.persistentDataPath + "/selfies";
Directory.CreateDirectory(selfies);
Application.CaptureScreenshot(string.Format("{0}/{1}.png", selfies, System.DateTime.Now.Ticks));
}
else if (Input.GetKeyDown(KeyCode.F11))
{
string maps = Application.persistentDataPath + "/maps";
Directory.CreateDirectory(maps);
mapCamera.Render();
var old = RenderTexture.active;
RenderTexture.active = mapTexture;
mapTextureLocal.ReadPixels(Rect.MinMaxRect(0, 0, 1024, 1024), 0, 0);
RenderTexture.active = old;
File.WriteAllBytes(string.Format("{0}/{1}.png", maps, System.DateTime.Now.Ticks), mapTextureLocal.EncodeToPNG());
}
else if (Input.GetKeyDown(KeyCode.F2))
{
scale = 3 - scale;
Screen.SetResolution(512 * scale, 512 * scale, false);
}
if (hostID == -1) return;
config.hideTutorial |= !tutorialChat.activeSelf
&& !tutorialMove.activeSelf
&& !tutorialTile.activeSelf
&& !tutorialWall.activeSelf;
tutorialObject.SetActive(!config.hideTutorial);
mapCamera.gameObject.SetActive(mapping);
mapObject.SetActive(mapping);
camera.orthographicSize = Mathf.Lerp(128, 32, zoom);
if (Input.GetKeyDown(KeyCode.Return))
{
if (chatting)
{
chatOverlay.OnClickedSend();
}
else
{
chatOverlay.Show();
}
}
if (!chatting && !editing)
{
if (Input.GetKey(KeyCode.UpArrow) || Input.GetKey(KeyCode.W))
{
Move(Vector2.up);
}
else if (Input.GetKey(KeyCode.LeftArrow) || Input.GetKey(KeyCode.A))
{
Move(Vector2.left);
}
else if (Input.GetKey(KeyCode.RightArrow) || Input.GetKey(KeyCode.D))
{
Move(Vector2.right);
}
else if (Input.GetKey(KeyCode.DownArrow) || Input.GetKey(KeyCode.S))
{
Move(Vector2.down);
}
}
if (Input.GetKeyDown(KeyCode.Space) && stickypalette)
{
stickypalette = false;
}
if (!chatting
&& !editing
&& Input.GetKey(KeyCode.Space))
{
if (!tilePalette.gameObject.activeSelf)
{
stickypalette = Input.GetKey(KeyCode.LeftControl);
tilePalette.Show();
}
}
else if (!stickypalette)
{
tilePalette.Hide();
}
if (!UnityEngine.EventSystems.EventSystem.current.IsPointerOverGameObject()
&& Rect.MinMaxRect(0, 0, Screen.width, Screen.height).Contains(Input.mousePosition)
&& !editing)
{
bool picker = Input.GetKey(KeyCode.LeftAlt) || Input.GetKey(KeyCode.RightAlt);
bool waller = !picker && (Input.GetKey(KeyCode.LeftShift) || Input.GetKey(KeyCode.RightShift));
tileCursor.gameObject.SetActive(true);
pickerCursor.SetActive(picker);
tileCursor.sprite = this.world.tiles[tilePalette.SelectedTile];
Vector2 mouse = Input.mousePosition;
Vector3 world;
RectTransformUtility.ScreenPointToWorldPointInRectangle(worldView.transform as RectTransform,
mouse,
camera,
out world);
int x = Mathf.FloorToInt(world.x / 32);
int y = Mathf.FloorToInt(world.y / 32);
tileCursor.transform.position = new Vector2(x * 32, y * 32);
byte tile = tilePalette.SelectedTile;
int location = (y + 16) * 32 + (x + 16);
if (location >= 0
&& location < 1024)
{
if (waller && Input.GetMouseButtonDown(0))
{
tile = this.world.tilemap[location];
bool wall = !this.world.walls.Contains(tile);
SendAll(SetWallMessage(tile, wall));
if (this.world.walls.Set(tile, wall))
{
tutorialWall.SetActive(false);
audio.PlayOneShot(placeSound);
}
worldView.RefreshWalls();
}
else if (!waller && Input.GetMouseButton(0))
{
if (!picker && this.world.tilemap[location] != tile)
{
audio.PlayOneShot(placeSound);
worldView.SetTile(location, tile);
if (tile != 0) tutorialTile.SetActive(false);
SendAll(SetTileMessage(location, tile));
}
else if (picker)
{
tilePalette.SetSelectedTile(this.world.tilemap[location]);
}
}
}
}
else
{
tileCursor.gameObject.SetActive(false);
}
var eventType = NetworkEventType.Nothing;
int connectionID;
int channelId;
int receivedSize;
byte error;
do
{
// Get events from the server/client game connection
eventType = NetworkTransport.ReceiveFromHost(hostID,
out connectionID,
out channelId,
recvBuffer,
recvBuffer.Length,
out receivedSize,
out error);
if ((NetworkError)error != NetworkError.Ok)
{
group.interactable = true;
popups.Show("Network Error: " + (NetworkError)error,
delegate { });
}
if (eventType == NetworkEventType.ConnectEvent)
{
connected = true;
if (hosting)
{
OnNewClientConnected(connectionID);
}
else
{
OnConnectedToHost(connectionID);
}
}
else if (eventType == NetworkEventType.DisconnectEvent)
{
if (hosting)
{
OnClientDisconnected(connectionID);
}
else
{
OnDisconnectedFromHost(connectionID);
}
}
else if (eventType == NetworkEventType.DataEvent)
{
var reader = new NetworkReader(recvBuffer);
{
Type type = (Type) reader.ReadByte();
if (type == Type.Tilemap)
{
world.tilemap = reader.ReadBytesAndSize();
worldView.SetWorld(world);
}
else if (type == Type.Palette)
{
for (int i = 0; i < 16; ++i)
{
world.palette[i] = reader.ReadColor32();
SetPalette((byte) i, world.palette[i]);
}
}
else if (type == Type.PaletteEdit)
{
ReceivePaletteEdit(reader);
}
else if (type == Type.Walls)
{
world.walls.Clear();
foreach (var wall in reader.ReadBytesAndSize())
{
world.walls.Add(wall);
}
worldView.RefreshWalls();
}
else if (type == Type.Tileset)
{
int id = reader.ReadInt32();
tiledata[id] = reader.ReadBytesAndSize();
}
else if (type == Type.ReplicateAvatar)
{
ReceiveCreateAvatar(reader);
}
else if (type == Type.DestroyAvatar)
{
ReceiveDestroyAvatar(reader);
}
else if (type == Type.GiveAvatar)
{
ReceiveGiveAvatar(reader);
}
else if (type == Type.MoveAvatar)
{
World.Avatar avatar = ID2Avatar(reader.ReadInt32());
Vector2 dest = reader.ReadVector2();
if (hosting)
{
if (connectionID == avatar.id
&& !Blocked(avatar, dest))
{
avatar.source = avatar.destination;
avatar.destination = dest;
avatar.u = 0;
SendAll(MoveAvatarMessage(avatar, avatar.destination), except: avatar.id);
}
else
{
Send(connectionID, MoveAvatarMessage(avatar, avatar.destination));
}
}
else
{
avatar.source = avatar.destination;
avatar.destination = dest;
avatar.u = 0;
}
}
else if (type == Type.Chat)
{
World.Avatar avatar = ID2Avatar(reader.ReadInt32());
string message = reader.ReadString();
if (hosting)
{
if (connectionID == avatar.id)
{
SendAll(ChatMessage(avatar, message), except: connectionID);
Chat(avatar, message);
}
}
else
{
Chat(avatar, message);
}
}
else if (type == Type.SetTile)
{
ReceiveSetTile(reader);
}
else if (type == Type.SetWall)
{
ReceiveSetWall(reader);
}
else if (type == Type.TileChunk)
{
ReceiveTileChunk(reader, connectionID);
}
else if (type == Type.LockTile)
{
ReceiveLockTile(reader);
}
else if (type == Type.AvatarChunk)
{
ReceiveAvatarChunk(reader, connectionID);
}
else if (type == Type.TileStroke)
{
ReceiveTileStroke(reader, connectionID);
}
}
}
}
while (eventType != NetworkEventType.Nothing);
}
private void ReceiveTileChunk(NetworkReader reader, int connectionID)
{
byte tile = reader.ReadByte();
int offset = reader.ReadInt32();
byte[] chunk = UncrunchBytes(reader.ReadBytesAndSize());
int x = tile % 16;
int y = tile / 16;
bool locked = locks.ContainsKey(tile);
// if we're the host, disallow chunks not send by someone with a lock
if (hosting && (!locked || locks[tile].id != connectionID)) return;
// we're editing this tile, so ignore it
if (locked && locks[tile] == worldView.viewer) return;
Color[] colors = world.tileset.GetPixels(x * 32, y * 32, 32, 32);
for (int i = 0; i < chunk.Length; ++i)
{
colors[i + offset] = world.palette[chunk[i]];
}
world.tileset.SetPixels(x * 32, y * 32, 32, 32, colors);
world.tileset.Apply();
if (hosting)
{
SendAll(TileInChunksMessages(world, tile));
}
}
private void ReceivePaletteEdit(NetworkReader reader)
{
byte index = reader.ReadByte();
Color color = reader.ReadColor32();
world.palette[index] = color;
paletteEditor.Refresh();
SetPalette(index, color);
}
public override void Deserialize(NetworkReader reader)
{
this.slotId = reader.ReadByte();
this.readyState = reader.ReadBoolean();
}
private void ReceiveSetWall(NetworkReader reader)
{
byte tile = reader.ReadByte();
bool wall = reader.ReadBoolean();
if (hosting)
{
SendAll(SetWallMessage(tile, wall));
}
if (world.walls.Contains(tile) != wall)
{
audio.PlayOneShot(placeSound);
if (wall)
{
world.walls.Add(tile);
}
else
{
world.walls.Remove(tile);
}
}
worldView.RefreshWalls();
}
private void ReceiveSetTile(NetworkReader reader)
{
int location = reader.ReadInt32();
byte tile = reader.ReadByte();
if (hosting)
{
SendAll(SetTileMessage(location, tile));
}
if (world.tilemap[location] != tile)
{
audio.PlayOneShot(placeSound);
worldView.SetTile(location, tile);
}
}
