private unsafe void _PostResponseImpl(long pctx, MessageBuff *messageBuff)
{
int header_len = TrinityProtocol.MsgHeader + sizeof(int) + sizeof(int) + sizeof(long);
int socket_header = header_len + (int)messageBuff->Length - TrinityProtocol.SocketMsgHeader;
byte * buf = stackalloc byte[header_len];
byte **bufs = stackalloc byte *[2];
int * sizes = stackalloc int[2];
sizes[0] = header_len;
sizes[1] = (int)messageBuff->Length;
bufs[0] = buf;
bufs[1] = messageBuff->Buffer;
PointerHelper sp = PointerHelper.New(buf);
*sp.ip = socket_header;
*(TrinityMessageType *)(sp.bp + TrinityProtocol.MsgTypeOffset) = TrinityMessageType.SYNC;
*(ushort *)(sp.bp + TrinityProtocol.MsgIdOffset) = (ushort)TSL.CommunicationModule.TrinityClientModule.SynReqMessageType.PostResponse;
sp.bp += TrinityProtocol.MsgHeader;
*sp.ip++ = m_id;
*sp.ip++ = m_cookie;
*sp.lp++ = pctx;
m_mod.SendMessage(m_client, bufs, sizes, 2);
}
private unsafe void RedirectMessageWithResponse_impl(SynReqRspArgs args)
{
/******************************
* Protocol: RedirectMessage
* Request: |4B PartitionId| TrinityMessage |
* Response: | TrinityResponse |
*
* Redirects the message to another instance.
******************************/
PointerHelper sp = PointerHelper.New(args.Buffer + args.Offset);
int partitionId = *sp.ip++;
TrinityMessage tm = new TrinityMessage(sp.bp, (*sp.ip) + TrinityProtocol.SocketMsgHeader);
m_memorycloud[partitionId].SendMessage(tm, out var rsp);
int rsp_size = TrinityProtocol.MsgHeader + rsp.Size;
byte *rsp_buf = (byte *)Memory.malloc((ulong)rsp_size);
*(int *)rsp_buf = rsp_size - TrinityProtocol.SocketMsgHeader;
Memory.Copy(rsp.Buffer, rsp.Offset, rsp_buf, TrinityProtocol.MsgHeader, rsp.Size);
rsp.Dispose();
args.Response = new TrinityMessage(rsp_buf, rsp_size);
}
private unsafe void LoadCell_impl(SynReqRspArgs args)
{
/******************************
* Protocol: LoadCell
* Request: |8B CellId|
* Response: [ 4B TrinityErrorCode header ] -- if success --> | 4B Size|2B CellType| Payload |
******************************/
var id = *(long *)(args.Buffer + args.Offset);
var err = m_memorycloud.LoadCell(id, out var cellBuff, out var cellType);
if (err == TrinityErrorCode.E_SUCCESS)
{
var len = TrinityProtocol.MsgHeader + sizeof(int) + cellBuff.Length + sizeof(ushort);
var buf = (byte *)Memory.malloc((ulong)len);
var sp = PointerHelper.New(buf);
*sp.ip++ = len - TrinityProtocol.SocketMsgHeader;
*sp.ip++ = (int)err;
*sp.ip++ = cellBuff.Length;
*sp.sp++ = (short)cellType;
fixed(byte *p = cellBuff)
{
Memory.memcpy(sp.bp, p, (ulong)cellBuff.Length);
}
args.Response = new TrinityMessage(buf, len);
}
else
{
var buf = (byte *)Memory.malloc(TrinityProtocol.MsgHeader);
var sp = PointerHelper.New(buf);
*sp.ip++ = TrinityProtocol.MsgHeader - TrinityProtocol.SocketMsgHeader;
*sp.ip = (int)err;
args.Response = new TrinityMessage(buf, TrinityProtocol.MsgHeader);
}
}
public byte[] ToByteArray()
{
mRawData[0] = (byte)DataType;
PointerHelper.CopyTo(DataLength, mRawData, 1);
PointerHelper.CopyTo(Timestamp, mRawData, 9);
return(mRawData);
}
private unsafe void PollEvents_impl(SynReqRspArgs args)
{
/******************************
* Protocol: PollEvents
* Request: |4B InstanceId|4B Cookie|
* Response:[4B E_RESULT Header] - |8B p| TrinityMessage |
* Response.p != 0 if the response is a "request with response"
* Response.TrinityMessage length header < 0 if there are no events
* E_RESULT values:
*
* 0 = E_SUCCESS
* 1 = E_NO_EVENTS
* 2 = E_INVALID_CLIENT
*
* !NOTE Here, response itself is a TrinityMessage and Response.TrinityMessage
* is the inner payload.
******************************/
PointerHelper sp = PointerHelper.New(args.Buffer + args.Offset);
int instanceId = *sp.ip++;
int cookie = *sp.ip++;
byte * outer_buf;
int outer_len;
long p = 0;
TrinityMessage tm = null;
TaskCompletionSource <bool> tsrc = null;
bool invalid_client = false;
try
{
var stg = CheckInstanceCookie(cookie, instanceId);
stg.Pulse = DateTime.Now;
(p, tm, tsrc) = stg.PollEvents_impl();
}
catch (ClientInstanceNotFoundException)
{
invalid_client = true;
}
if (tm == null)
{
outer_len = TrinityProtocol.MsgHeader + sizeof(long) + sizeof(int);
outer_buf = (byte *)Memory.malloc((ulong)outer_len);
*(int *)outer_buf = outer_len - TrinityProtocol.SocketMsgHeader;
*(long *)(outer_buf + TrinityProtocol.MsgHeader) = 0;
*(int *)(outer_buf + TrinityProtocol.MsgHeader + sizeof(long)) = -1;
*(int *)(outer_buf + TrinityProtocol.SocketMsgHeader) = invalid_client ? 2 : 1;
}
else
{
outer_len = TrinityProtocol.MsgHeader + sizeof(long) + tm.Size;
outer_buf = (byte *)Memory.malloc((ulong)outer_len);
*(int *)outer_buf = outer_len - TrinityProtocol.SocketMsgHeader;
*(long *)(outer_buf + TrinityProtocol.MsgHeader) = p;
Memory.memcpy(outer_buf + TrinityProtocol.MsgHeader + sizeof(long), tm.Buffer, (ulong)tm.Size);
tsrc.SetResult(true);
*(int *)(outer_buf + TrinityProtocol.SocketMsgHeader) = 0;
}
args.Response = new TrinityMessage(outer_buf, outer_len);
}
protected internal unsafe void SendMessage(IMessagePassingEndpoint endpoint, byte **buffers, int *sizes, int count)
{
var e_msg_type = PointerHelper.GetUshort(buffers, sizes, TrinityProtocol.MsgTypeOffset);
PointerHelper.Add(buffers, sizes, TrinityProtocol.MsgIdOffset, m_MessageIdOffsets[e_msg_type]);
endpoint.SendMessage(buffers, sizes, count);
}
public unsafe void SendMessage(byte **message, int *sizes, int count)
{
byte msg_type = PointerHelper.GetByte(message, sizes, TrinityProtocol.MsgTypeOffset);
ushort msg_id = PointerHelper.GetUshort(message, sizes, TrinityProtocol.MsgIdOffset);
int ms = ProtocolSemanticRegistry.s_protocolSemantics[msg_type, msg_id];
m_smmfuncs[ms](message, sizes, count);
}
protected internal unsafe void SendMessage(IMessagePassingEndpoint endpoint, byte **buffers, int *sizes, int count, out TrinityResponse response)
{
byte b_msg_type = PointerHelper.GetByte(buffers, sizes, TrinityProtocol.MsgTypeOffset);
PointerHelper.Add(buffers, sizes, TrinityProtocol.MsgIdOffset, m_MessageIdOffsets[b_msg_type]);
endpoint.SendMessage(buffers, sizes, count, out response);
}
public unsafe void SendMessage(byte **message, int *sizes, int count, out TrinityResponse response)
{
var msg_type = PointerHelper.GetUshort(message, sizes, TrinityProtocol.MsgTypeOffset);
ushort msg_id = PointerHelper.GetUshort(message, sizes, TrinityProtocol.MsgIdOffset);
int ms = ProtocolSemanticRegistry.s_protocolSemantics[msg_type, msg_id];
response = m_smrmfuncs[ms](message, sizes, count);
}
internal static bool GetCommunicationModuleOffset(this IMessagePassingEndpoint storage, string moduleName, out ushort synReqOffset, out ushort synReqRspOffset, out ushort asynReqOffset, out ushort asynReqRspOffset)
{
/******************
* Comm. protocol:
* - REQUEST : [char_cnt, char[] moduleName]
* - RESPONSE: [int synReqOffset, int synReqRspOffset, int asynReqOffset, int asynReqRspOffset]
* An response error code other than E_SUCCESS indicates failure of remote module lookup.
******************/
using (TrinityMessage tm = new TrinityMessage(
TrinityMessageType.PRESERVED_SYNC_WITH_RSP,
(ushort)RequestType.GetCommunicationModuleOffsets,
size: sizeof(int) + sizeof(char) * moduleName.Length))
{
PointerHelper sp = PointerHelper.New(tm.Buffer + TrinityMessage.Offset);
*sp.ip++ = moduleName.Length;
BitHelper.WriteString(moduleName, sp.bp);
TrinityResponse response = null;
bool ret;
try
{
storage.SendMessage(tm, out response);
ret = (response.ErrorCode == TrinityErrorCode.E_SUCCESS);
}
catch (System.IO.IOException)
{
ret = false;
}
if (ret)
{
sp.bp = response.Buffer + response.Offset;
int synReq_msg = *sp.ip++;
int synReqRsp_msg = *sp.ip++;
int asynReq_msg = *sp.ip++;
int asynReqRsp_msg = *sp.ip++;
synReqOffset = (ushort)synReq_msg;
synReqRspOffset = (ushort)synReqRsp_msg;
asynReqOffset = (ushort)asynReq_msg;
asynReqRspOffset = (ushort)asynReqRsp_msg;
}
else
{
synReqOffset = 0;
synReqRspOffset = 0;
asynReqOffset = 0;
asynReqRspOffset = 0;
}
response?.Dispose();
return(ret);
}
}
private unsafe void _PollImpl(TrinityMessage poll_req)
{
m_mod.SendMessage(m_client, poll_req.Buffer, poll_req.Size, out var poll_rsp);
var sp = PointerHelper.New(poll_rsp.Buffer + poll_rsp.Offset);
//HexDump.Dump(poll_rsp.ToByteArray());
//Console.WriteLine($"poll_rsp.Size = {poll_rsp.Size}");
//Console.WriteLine($"poll_rsp.Offset = {poll_rsp.Offset}");
var payload_len = poll_rsp.Size - TrinityProtocol.TrinityMsgHeader;
if (payload_len < sizeof(long) + sizeof(int))
{
throw new IOException("Poll response corrupted.");
}
var errno = *(sp.ip - 1);
try
{
if (errno == 2)
{
Log.WriteLine(LogLevel.Warning, $"{nameof(TrinityClient)}: server drops our connection. Registering again.");
RestartPolling();
return;
}
if (errno != 0)
{
return;
}
var pctx = *sp.lp++;
var msg_len = *sp.ip++;
if (msg_len < 0)
{
return; // no events
}
MessageBuff msg_buff = new MessageBuff {
Buffer = sp.bp, Length = (uint)msg_len
};
MessageDispatcher(&msg_buff);
// !Note, void-response messages are not acknowledged.
// Server would not be aware of client side error in this case.
// This is by-design and an optimization to reduce void-response
// message delivery latency. In streaming use cases this will be
// very useful.
try { if (pctx != 0)
{
_PostResponseImpl(pctx, &msg_buff);
}
}
finally { Memory.free(msg_buff.Buffer); }
}
finally
{
poll_rsp.Dispose();
}
}
public PersistedCellEnumerator(byte[] content, long target_lowKey, long target_highKey)
{
m_content = content;
m_length = content.Length;
m_target_lowKey = target_lowKey;
m_target_highKey = target_highKey;
m_handle = GCHandle.Alloc(content, GCHandleType.Pinned);
m_bp = (byte *)m_handle.AddrOfPinnedObject().ToPointer();
m_sp = PointerHelper.New(m_bp);
m_ep = m_bp + m_length;
}
private static unsafe Span <TTo> CastRefTypeForSlowSpan <TFrom, TTo>(Span <TFrom> span)
{
var helper1 = new PointerHelper <TFrom>(span);
var helper2 = new PointerHelper <TTo>();
var p1 = (&helper1.Head) + 1; // p1 = &helper1.Span;
var p2 = (&helper2.Head) + 1; // p2 = &helper2.Span;
*p2 = *p1; // ret._pinnale = span._pinnable
*(p2 + 1) = *(p1 + 1); // ret._byteOffset = span._byteOffset;
*(int *)(p2 + 2) = *(int *)(p1 + 2); // ret._length = span._length;
return(helper2.Span);
}
public void Update()
{
if (GameManager.Instance != null)
{
if (!PointerHelper.IsPointerOverGameObject())
{
if (Input.GetMouseButtonDown(0) ||
Input.touchCount == 1 && Input.GetTouch(0).phase == TouchPhase.Began)
{
CloseMenu();
}
}
}
}
private unsafe TrinityMessage _AllocPollMsg(int myInstanceId, int myCookie)
{
int msglen = sizeof(int) + sizeof(int) + TrinityProtocol.MsgHeader;
byte * buf = (byte *)Memory.malloc((ulong)msglen);
PointerHelper sp = PointerHelper.New(buf);
*sp.ip = msglen - TrinityProtocol.SocketMsgHeader;
*(TrinityMessageType *)(sp.bp + TrinityProtocol.MsgTypeOffset) = TrinityMessageType.SYNC_WITH_RSP;
*(ushort *)(sp.bp + TrinityProtocol.MsgIdOffset) = (ushort)TSL.CommunicationModule.TrinityClientModule.SynReqRspMessageType.PollEvents;
sp.bp += TrinityProtocol.MsgHeader;
*sp.ip++ = myInstanceId;
*sp.ip++ = myCookie;
return(new TrinityMessage(buf, msglen));
}
private unsafe void PostResponse_impl(SynReqArgs args)
{
/******************************
* Protocol: PostResponse
* Request: |4B InstanceId|4B Cookie|8B p| TrinityResponse |
* Response: VOID
******************************/
PointerHelper sp = PointerHelper.New(args.Buffer + args.Offset);
int instanceId = *sp.ip++;
int cookie = *sp.ip++;
long p = *sp.lp++;
var stg = CheckInstanceCookie(cookie, instanceId);
stg.PostResponse_impl(p, sp.bp, args.Size - sizeof(int) * 2 - sizeof(long));
}
private unsafe void RedirectMessage_impl(SynReqArgs args)
{
/******************************
* Protocol: RedirectMessage
* Request: |4B InstanceId| TrinityMessage |
* Response: VOID
*
* Redirects the message to another instance.
******************************/
PointerHelper sp = PointerHelper.New(args.Buffer + args.Offset);
int instanceId = *sp.ip++;
TrinityMessage tm = new TrinityMessage(sp.bp, *sp.ip + sizeof(int));
m_memorycloud[instanceId].SendMessage(tm);
}
private unsafe void RedirectMessage_impl(SynReqArgs args)
{
/******************************
* Protocol: RedirectMessage
* Request: |4B PartitionId| TrinityMessage |
* Response: VOID
*
* Redirects the message to another instance.
******************************/
PointerHelper sp = PointerHelper.New(args.Buffer + args.Offset);
int partitionId = *sp.ip++;
TrinityMessage tm = new TrinityMessage(sp.bp, (*sp.ip) + TrinityProtocol.SocketMsgHeader);
m_memorycloud[partitionId].SendMessage(tm);
}
private unsafe void UpdateCell_impl(SynReqRspArgs args)
{
/******************************
* Protocol: UpdateCell
* Request: |8B CellId|4B Size| Payload |
* Response: [ 4B TrinityErrorCode header ]
******************************/
var sp = PointerHelper.New(args.Buffer + args.Offset);
var id = *sp.lp++;
var size = *sp.ip++;
var err = (int)m_memorycloud.UpdateCell(id, sp.bp, size);
var buf = (byte *)Memory.malloc(TrinityProtocol.MsgHeader);
sp = PointerHelper.New(buf);
*sp.ip++ = TrinityProtocol.MsgHeader - TrinityProtocol.SocketMsgHeader;
*sp.ip = err;
args.Response = new TrinityMessage(buf, TrinityProtocol.MsgHeader);
}
public unsafe void SendMessage(byte *message, int size, out TrinityResponse response)
{
byte * header = stackalloc byte[TrinityProtocol.MsgHeader + sizeof(int)];
byte **bufs = stackalloc byte *[2];
int * sizes = stackalloc int[2];
bufs[0] = header;
bufs[1] = message;
sizes[0] = TrinityProtocol.MsgHeader + sizeof(int);
sizes[1] = size;
PointerHelper sp = PointerHelper.New(header);
*sp.ip = size + sizeof(int) + TrinityProtocol.TrinityMsgHeader;
*(sp.bp + TrinityProtocol.MsgTypeOffset) = (byte)TrinityMessageType.SYNC_WITH_RSP;
*(ushort *)(sp.bp + TrinityProtocol.MsgIdOffset) = (ushort)TSL.CommunicationModule.TrinityClientModule.SynReqRspMessageType.RedirectMessageWithResponse;
*(int *)(sp.bp + TrinityProtocol.MsgHeader) = partitionId;
m_mod.SendMessage(m_ep, bufs, sizes, 2, out response);
}
public unsafe TrinityErrorCode LoadCell(long cellId, out byte[] cellBuff, out ushort cellType)
{
using (var req = new __CellIdStructWriter(cellId))
{
TrinityResponse rsp = null;
TrinityErrorCode errcode = TrinityErrorCode.E_RPC_EXCEPTION;
cellBuff = null;
cellType = 0;
try
{
var sp = PointerHelper.New(req.buffer);
*sp.ip++ = TrinityProtocol.TrinityMsgHeader + sizeof(long);
*sp.sp++ = (short)TrinityMessageType.SYNC_WITH_RSP;
*sp.sp++ = (short)TSL.CommunicationModule.TrinityClientModule.SynReqRspMessageType.LoadCell;
m_mod.SendMessage(m_ep, req.buffer, req.BufferLength, out rsp);
sp = PointerHelper.New(rsp.Buffer);
errcode = (TrinityErrorCode)(*sp.ip++);
if (errcode == TrinityErrorCode.E_SUCCESS)
{
var length = *sp.ip++;
cellType = (ushort)(*sp.sp++);
cellBuff = new byte[length];
fixed(byte *p = cellBuff)
{
Memory.memcpy(p, sp.bp, (ulong)length);
}
}
/* otherwise, fails with returned error code */
}
finally
{
rsp?.Dispose();
}
return(errcode);
}
}
public unsafe void SendMessage(byte **_bufs, int *_sizes, int count, out TrinityResponse response)
{
byte * header = stackalloc byte[TrinityProtocol.MsgHeader + sizeof(int)];
ulong bufs_len = (ulong)(sizeof(byte *) * (count + 1));
ulong sizes_len = (ulong)(sizeof(int) * (count + 1));
byte **bufs = (byte **)Memory.malloc(bufs_len);
int * sizes = (int *)Memory.malloc(sizes_len);
bufs[0] = header;
sizes[0] = TrinityProtocol.MsgHeader + sizeof(int);
Memory.memcpy(bufs + 1, _bufs, bufs_len);
Memory.memcpy(sizes + 1, _sizes, sizes_len);
PointerHelper sp = PointerHelper.New(header);
*sp.ip = sizeof(int) + TrinityProtocol.TrinityMsgHeader + Utils._sum(_sizes, count);
*(sp.bp + TrinityProtocol.MsgTypeOffset) = (byte)TrinityMessageType.SYNC_WITH_RSP;
*(ushort *)(sp.bp + TrinityProtocol.MsgIdOffset) = (ushort)TSL.CommunicationModule.TrinityClientModule.SynReqRspMessageType.RedirectMessageWithResponse;
*(int *)(sp.bp + TrinityProtocol.MsgHeader) = partitionId;
m_mod.SendMessage(m_ep, bufs, sizes, count + 1, out response);
}
public static InMemoryDataChunk New(IEnumerable <CellInfo> cells, int estimated_size)
{
MemoryStream ms = new MemoryStream(estimated_size);
byte[] buf = new byte[sizeof(long) + sizeof(ushort) + sizeof(int)];
byte[] buf_cell = new byte[1024];
long lowkey = 0, highkey = 0;
int size = 0;
fixed(byte *p = buf)
{
foreach (var cell in cells)
{
if (size == 0)
{
lowkey = cell.CellId;
}
highkey = cell.CellId;
PointerHelper sp = PointerHelper.New(p);
*sp.lp++ = cell.CellId;
*sp.sp++ = (short)cell.CellType;
*sp.ip++ = cell.CellSize;
ms.Write(buf, 0, buf.Length);
while (buf_cell.Length < cell.CellSize)
{
buf_cell = new byte[buf_cell.Length * 2];
}
Memory.Copy(cell.CellPtr, 0, buf_cell, 0, cell.CellSize);
ms.Write(buf_cell, 0, cell.CellSize);
size += cell.CellSize + buf.Length;
}
}
byte[] payload = ms.GetBuffer();
Chunk chunk = new Chunk(lowkey, highkey);
return(new InMemoryDataChunk(chunk, payload, lowkey, highkey));
}
private unsafe TrinityErrorCode _SendCellPayload(long cellId, byte *buff, int size, ushort?cellType, short msgId)
{
//header: cellId, size, type
int header_len = TrinityProtocol.MsgHeader + sizeof(long) + sizeof(int) + (cellType.HasValue? sizeof(ushort): 0);
byte * header = stackalloc byte[header_len];
byte ** holder = stackalloc byte *[2];
int * length = stackalloc int[2];
PointerHelper sp = PointerHelper.New(header);
*sp.ip++ = header_len + size - TrinityProtocol.SocketMsgHeader;
*sp.sp++ = (short)TrinityMessageType.SYNC_WITH_RSP;
*sp.sp++ = msgId;
*sp.lp++ = cellId;
*sp.ip++ = size;
if (cellType.HasValue)
{
*sp.sp++ = (short)cellType;
}
holder[0] = header;
holder[1] = buff;
length[0] = header_len;
length[1] = size;
TrinityResponse rsp = null;
try
{
m_mod.SendMessage(m_ep, holder, length, 2, out rsp);
return(*(TrinityErrorCode *)(rsp.Buffer));
}
finally
{
rsp?.Dispose();
}
}
internal static void GetCommunicationSchema(this IMessagePassingEndpoint storage, out string name, out string signature)
{
/******************
* Comm. protocol:
* - REQUEST : VOID
* - RESPONSE: [char_cnt, char[] name, char_cnt, char[] sig]
******************/
using (TrinityMessage tm = new TrinityMessage(
TrinityMessageType.PRESERVED_SYNC_WITH_RSP,
(ushort)RequestType.GetCommunicationSchema,
size: 0))
{
TrinityResponse response;
storage.SendMessage(tm, out response);
PointerHelper sp = PointerHelper.New(response.Buffer + response.Offset);
int name_string_len = *sp.ip++;
name = BitHelper.GetString(sp.bp, name_string_len * 2);
sp.cp += name_string_len;
int sig_string_len = *sp.ip++;
signature = BitHelper.GetString(sp.bp, sig_string_len * 2);
response.Dispose();
}
}
void Update()
{
if (InBuildMode && MainCanvas.Instance.IsDraggingIcon && !BuildMenuContainer.Instance.IsOpen)
{
if (PointerIsOnAvailablePlot)
{
if (GameManager.Instance.CurrentPlatform == Platform.PC)
{
if (Input.GetMouseButtonDown(0))
{
Logger.Warning("Let's build a {0}", SelectedRoom.Name);
BuildingPlot buildingPlot = BuildingPlot.FindBuildingPlot(BuildingPlot.AvailablePlotVectorPosition);
BuildRoom(SelectedRoom, buildingPlot);
if (BuildMenuContainer.Instance.PanelAnimationPlaying)
{
ReopenBuildMenu();
}
else
{
BuildMenuContainer.Instance.ActivateAnimationFreeze();
ActivateBuildMenuMode();
}
}
}
}
else
{
if (GameManager.Instance.CurrentPlatform == Platform.PC)
{
if (Input.GetMouseButtonDown(0))
{
Logger.Warning("Cannot build here!");
GameObject notificationGO = Instantiate(MainCanvas.Instance.NotificationPrefab, MainCanvas.Instance.transform);
Notification notification = notificationGO.transform.GetComponent <Notification>();
notification.Setup(NotificationType.FromPointer, "Cannot build in location");
if (BuildMenuContainer.Instance.PanelAnimationPlaying)
{
ReopenBuildMenu();
}
else
{
BuildMenuContainer.Instance.ActivateAnimationFreeze();
ActivateBuildMenuMode();
}
}
}
}
}
if (Input.touchCount == 1)
{
if (Input.touches[0].phase == TouchPhase.Ended)
{
if (MainCanvas.Instance.PointerImage.sprite != null && !BuildMenuContainer.Instance.IsOpen)
{
if (PointerIsOnAvailablePlot)
{
Logger.Warning("Let's build!");
BuildingPlot buildingPlot = BuildingPlot.FindBuildingPlot(BuildingPlot.AvailablePlotVectorPosition);
BuildRoom(SelectedRoom, buildingPlot);
}
else
{
if (MainCanvas.Instance.IsDraggingIcon && !BuildMenuContainer.Instance.IsOpen)
{
GameObject notificationGO = Instantiate(MainCanvas.Instance.NotificationPrefab, MainCanvas.Instance.transform);
Notification notification = notificationGO.transform.GetComponent <Notification>();
notification.Setup(NotificationType.FromPointer, "Cannot build in location");
}
}
if (BuildMenuContainer.Instance.PanelAnimationPlaying)
{
ReopenBuildMenu();
}
else
{
BuildMenuContainer.Instance.ActivateAnimationFreeze();
ActivateBuildMenuMode();
}
}
else
{
MainCanvas.Instance.UnsetPointerImage();
}
}
}
if (ConfirmationModal.CurrentConfirmationModal != null)
{
if (Input.GetMouseButtonDown(0) || (Input.touchCount == 1 && Input.touches[0].phase == TouchPhase.Began))
{
bool isPointerOverGameObject = PointerHelper.IsPointerOverGameObject();
if (!isPointerOverGameObject)
{
ConfirmationModal.CurrentConfirmationModal.ResetDeleteTrigger();
ConfirmationModal.CurrentConfirmationModal.DestroyConfirmationModal();
}
}
}
}
public void Update()
{
if (Console.Instance && Console.Instance.ConsoleState == ConsoleState.Large)
{
return;
}
if (PointerImage.sprite != null)
{
Vector2 mousePosition = Input.mousePosition;
bool isPointerOverGameObject = PointerHelper.IsPointerOverGameObject();
if (isPointerOverGameObject && BuildMenuContainer.Instance.IsOpen)
{
PointerImageGO.transform.position = new Vector2(mousePosition.x, mousePosition.y);
}
else
{
if (BuildMenuContainer.Instance.IsOpen)
{
Logger.Log(Logger.UI, "Close build menu");
BuildMenuContainer.Instance.ActivateAnimationFreeze();
BuildMenuContainer.Instance.IsOpen = false;
BuildMenuContainer.Instance.RemoveBuildMenuContent(0.5f);
}
Vector2 mouseWorldPosition = Camera.main.ScreenToWorldPoint(mousePosition);
mouseWorldPosition = new Vector2(mouseWorldPosition.x, mouseWorldPosition.y + 7.5f);
float xx = Mathf.Round((mouseWorldPosition.y) / TileSizeInUnits.y + (mouseWorldPosition.x) / TileSizeInUnits.x);
float yy = Mathf.Round((mouseWorldPosition.y) / TileSizeInUnits.y - (mouseWorldPosition.x) / TileSizeInUnits.x) - 1;
// Calculate grid aligned position from current position
float snappedX = (xx - yy) * 0.5f * TileSizeInUnits.x;
float snappedY = (xx + yy) * 0.5f * TileSizeInUnits.y;
if (_currentSnappedX != snappedX || _currentSnappedY != snappedY)
{
_currentSnappedX = snappedX;
_currentSnappedY = snappedY;
if (BuilderManager.Instance.BuildingPlotLocations.ContainsKey(new Vector2(_currentSnappedX, _currentSnappedY)))
{
Vector2 availablePlotVectorPosition = BuilderManager.Instance.BuildingPlotLocations[new Vector2(_currentSnappedX, _currentSnappedY)];
if (BuildingPlot.AvailablePlotVectorPosition == availablePlotVectorPosition && BuilderManager.PointerIsOnAvailablePlot)
{
return;
}
BuildingPlot.AvailablePlotVectorPosition = availablePlotVectorPosition;
SetPointerImageOverlayColor(PointerImageOverlayState.Normal);
BuilderManager.PointerIsOnAvailablePlot = true;
BuildingPlot buildingPlot = BuilderManager.Instance.BuildingPlots[BuildingPlot.AvailablePlotVectorPosition];
Sprite roomIcon = GetRoomIcon(buildingPlot.RoomBlueprint.Name, buildingPlot.PlotRotation);
SetPointerImage(roomIcon, buildingPlot.PlotRotation);
RepositionImage();
}
else
{
if (BuilderManager.PointerIsOnAvailablePlot)
{
BuilderManager.PointerIsOnAvailablePlot = false;
}
if (_currentPointerImageOverlayState == PointerImageOverlayState.Normal)
{
SetPointerImageOverlayColor(PointerImageOverlayState.Red);
}
RepositionImage();
}
}
}
if (GameManager.Instance.CurrentPlatform == Platform.PC)
{
if (BuildMenuContainer.Instance.PanelAnimationPlaying)
{
return;
}
if (Input.GetMouseButtonDown(1))
{
UnsetPointerImage();
if (!BuildMenuContainer.Instance.IsOpen)
{
BuildMenuContainer.Instance.ActivateAnimationFreeze();
BuilderManager.Instance.ActivateBuildMenuMode();
}
}
}
}
}
