CuongNV
525 lines
22 KiB
C#
525 lines
22 KiB
C#
using System.Reflection;
|
|
using System.Threading.Tasks;
|
|
using BrewMonster;
|
|
using BrewMonster.Network;
|
|
using BrewMonster.Scripts;
|
|
using CSNetwork.GPDataType;
|
|
using ModelRenderer.Scripts.Common;
|
|
using PerfectWorld.Scripts.Managers;
|
|
using TMPro;
|
|
using UnityEngine;
|
|
|
|
namespace PerfectWorld.Scripts
|
|
{
|
|
public class CECMatter : CECObject
|
|
{
|
|
private static Mesh s_itemNameQuadMesh;
|
|
private static Material s_itemNameBgMaterial;
|
|
|
|
// Matter information got from server
|
|
public struct INFO
|
|
{
|
|
public int mid; // Matter id
|
|
public int tid; // Template id
|
|
}
|
|
|
|
protected EC_ManMatter m_pMatterMan;
|
|
protected INFO m_MatterInfo;
|
|
protected int m_iLevelReq;
|
|
protected float m_fGatherDist;
|
|
protected uint m_dwMatterType; // Matter type flags / Matter type flags
|
|
private bool m_registeredToManMatter = false;
|
|
|
|
// Matter type constants / Matter type constants
|
|
public const uint MATTER_UNKNOWN = 0;
|
|
public const uint MATTER_ITEM = 1;
|
|
public const uint MATTER_MINE = 2;
|
|
public const uint MATTER_MONEY = 3;
|
|
public const uint MATTER_TYPEMASK = 0xff;
|
|
|
|
private const float MatterNameExtraWorldYOffset = 0.05f;
|
|
private const float MatterNameFallbackLocalY = 0.6f;
|
|
private const string ItemNameTextChildName = "ItemNameText";
|
|
|
|
// Constructor / Constructor
|
|
public CECMatter()
|
|
{
|
|
m_iCID = Class_ID.OCID_MATTER;
|
|
}
|
|
|
|
// Awake is called when the component is initialized / Awake is called when the component is initialized
|
|
private void Awake()
|
|
{
|
|
m_iCID = Class_ID.OCID_MATTER; // Ensure CID is set after Unity initialization / Ensure CID is set after Unity initialization
|
|
TryRegisterToManMatter();
|
|
}
|
|
|
|
private void OnEnable()
|
|
{
|
|
TryRegisterToManMatter();
|
|
}
|
|
|
|
private void TryRegisterToManMatter()
|
|
{
|
|
if (m_registeredToManMatter)
|
|
return;
|
|
|
|
// Only register once we have a valid mid.
|
|
int mid = GetMatterID();
|
|
if (mid == 0)
|
|
return;
|
|
|
|
var mono = BrewMonster.Managers.EC_ManMessageMono.Instance;
|
|
if (mono == null || mono.EC_ManMatter == null)
|
|
return;
|
|
|
|
mono.EC_ManMatter.RegisterExistingMatter(this);
|
|
m_registeredToManMatter = true;
|
|
}
|
|
|
|
// Override SetUpCECObject to set class ID / Override SetUpCECObject to set class ID
|
|
public override void SetUpCECObject()
|
|
{
|
|
base.SetUpCECObject();
|
|
m_iCID = Class_ID.OCID_MATTER; // Set after base call to override the reset / Set after base call to override the reset
|
|
}
|
|
|
|
public void SetMatterInfo(INFO matterInfo)
|
|
{
|
|
m_MatterInfo = matterInfo;
|
|
}
|
|
public int GetTemplateID()
|
|
{
|
|
return m_MatterInfo.tid;
|
|
}
|
|
|
|
public int GetLevelReq()
|
|
{
|
|
return m_iLevelReq;
|
|
}
|
|
|
|
public float GetGatherDist()
|
|
{
|
|
// 采集/拾取距离：某些情况下（例如场景预制体未走 Init 流程）m_fGatherDist 可能为 0。
|
|
// Gather/pickup distance: in some cases (e.g. scene prefab not created via Init) m_fGatherDist may be 0.
|
|
// Provide a safe default consistent with native behavior.
|
|
return m_fGatherDist > 0.01f ? m_fGatherDist : 3.0f;
|
|
}
|
|
|
|
// Is this matter a mine? / Is this matter a mine?
|
|
public bool IsMine()
|
|
{
|
|
return (m_dwMatterType & MATTER_TYPEMASK) == MATTER_MINE;
|
|
}
|
|
|
|
// Is this matter an item? / Is this matter an item?
|
|
public bool IsItem()
|
|
{
|
|
return (m_dwMatterType & MATTER_TYPEMASK) == MATTER_ITEM;
|
|
}
|
|
|
|
// Is this matter money? / Is this matter money?
|
|
public bool IsMoney()
|
|
{
|
|
return (m_dwMatterType & MATTER_TYPEMASK) == MATTER_MONEY;
|
|
}
|
|
public static async Task<CECMatter> Init(info_matter Info)
|
|
{
|
|
INFO matterInfo = new INFO();
|
|
matterInfo.mid = Info.mid;
|
|
matterInfo.tid = Info.tid & 0x0000ffff;
|
|
// get the matter template from elementdataman
|
|
DATA_TYPE DataType = DATA_TYPE.DT_INVALID;
|
|
var matterData = ElementDataManProvider.GetElementDataMan().get_data_ptr((uint)matterInfo.tid, ID_SPACE.ID_SPACE_ESSENCE, ref DataType);
|
|
|
|
// Determine matter type based on DataType / Determine matter type based on DataType
|
|
uint dwMatterType = MATTER_UNKNOWN;
|
|
if (DataType == DATA_TYPE.DT_MINE_ESSENCE)
|
|
{
|
|
dwMatterType = MATTER_MINE;
|
|
}
|
|
else
|
|
{
|
|
// Default to ITEM for other essence types / Default to ITEM for other essence types
|
|
dwMatterType = MATTER_ITEM;
|
|
}
|
|
// 钱币掉落 / Money drop
|
|
// 服务器用特殊 tid 表示金币/银币拾取物；不应占用背包格子。
|
|
// The server uses a special tid to represent money matters; they should not consume inventory slots.
|
|
if (GPDataTypeHelper.ISMONEYTID(matterInfo.tid))
|
|
{
|
|
dwMatterType = MATTER_MONEY;
|
|
}
|
|
|
|
if (matterData != null)
|
|
{
|
|
var matterDataType = matterData.GetType();
|
|
var fileMatterField = matterDataType.GetField("file_matter", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
|
|
if (fileMatterField == null)
|
|
{
|
|
fileMatterField = matterDataType.GetField("file_model", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
|
|
}
|
|
|
|
if (fileMatterField != null)
|
|
{
|
|
var fileMatterValue = fileMatterField.GetValue(matterData);
|
|
string filePath = ByteToStringUtils.ByteArrayToCP936String((byte[])fileMatterValue);
|
|
|
|
//var matterPrefab = await AddressableManager.Instance.LoadPrefabAsync(AFile.NormalizePath(filePath.ToLower(), true));
|
|
var matterObject = await PoolManager.Instance.SpawnAsync(AFile.NormalizePath(filePath.ToLower(), true), Vector3.zero, Quaternion.identity, memoryReleaseTTL: 0f);
|
|
if (matterObject != null)
|
|
{
|
|
//var matterObject = Instantiate(matterPrefab);
|
|
matterObject.transform.SetParent(ObjectSpawner.Instance.transform);
|
|
matterObject.name = $"Matter {matterObject.name} {matterInfo.tid} {matterInfo.mid}";
|
|
matterObject.transform.position = new Vector3(Info.pos.x, Info.pos.y, Info.pos.z);
|
|
matterObject.transform.localScale = new Vector3(1f, 1f, 1f);
|
|
// use same rotation as Prefab
|
|
// matterObject.transform.localRotation = Quaternion.identity;
|
|
matterObject.SetActive(true);
|
|
// Add a collider if it doesn't have one
|
|
if (matterObject.GetComponent<Collider>() == null)
|
|
{
|
|
var collider = matterObject.AddComponent<BoxCollider>();
|
|
//this is a workaround to fix the collider size issue when load prefab go wrong at some point
|
|
//TODO: remove this workaround after the prefab load issue is fixed
|
|
if (TryGetCombinedRendererBounds(matterObject.transform, null, out var combinedBounds))
|
|
{
|
|
Vector3 size = combinedBounds.size;
|
|
if (size.x < 0.5f) size.x = 0.5f;
|
|
if (size.y < 0.5f) size.y = 0.5f;
|
|
if (size.z < 0.5f) size.z = 0.5f;
|
|
collider.size = size;
|
|
collider.center = matterObject.transform.InverseTransformPoint(combinedBounds.center);
|
|
}
|
|
else
|
|
{
|
|
var firstRenderer = matterObject.GetComponentInChildren<Renderer>();
|
|
Vector3 size = firstRenderer != null ? firstRenderer.bounds.size : Vector3.one;
|
|
if (size.x < 0.5f) size.x = 0.5f;
|
|
if (size.y < 0.5f) size.y = 0.5f;
|
|
if (size.z < 0.5f) size.z = 0.5f;
|
|
collider.size = size;
|
|
}
|
|
}
|
|
// Create text object to display item name above the cube
|
|
CreateItemNameText(matterObject, Info.tid);
|
|
|
|
// Add a script to handle click events
|
|
// MatterCubeClickHandler clickHandler = matterObject.AddComponent<MatterCubeClickHandler>();
|
|
// clickHandler.Initialize(Info.mid, this);
|
|
CECMatter matterScript = matterObject.AddComponent<CECMatter>();
|
|
// Set CID immediately after AddComponent (before SetUpCECObject resets it) / Set CID immediately after AddComponent (before SetUpCECObject resets it)
|
|
matterScript.m_iCID = Class_ID.OCID_MATTER;
|
|
matterScript.SetMatterInfo(matterInfo);
|
|
matterScript.m_dwMatterType = dwMatterType; // Set matter type / Set matter type
|
|
|
|
// Set level requirement and gather distance for mines / Set level requirement and gather distance for mines
|
|
if (dwMatterType == MATTER_MINE && DataType == DATA_TYPE.DT_MINE_ESSENCE)
|
|
{
|
|
var levelReqField = matterData.GetType().GetField("level_required", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
|
|
if (levelReqField != null)
|
|
{
|
|
matterScript.m_iLevelReq = (int)levelReqField.GetValue(matterData);
|
|
}
|
|
var gatherDistField = matterData.GetType().GetField("gather_dist", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
|
|
if (gatherDistField != null)
|
|
{
|
|
float gatherDist = (float)gatherDistField.GetValue(matterData);
|
|
matterScript.m_fGatherDist = gatherDist > 3.0f ? gatherDist - 1.0f : 3.0f;
|
|
}
|
|
else
|
|
{
|
|
matterScript.m_fGatherDist = 3.0f;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// For non-mine items, set a default pickup distance / For non-mine items, set a default pickup distance
|
|
matterScript.m_fGatherDist = 3.0f; // Default pickup distance / Default pickup distance
|
|
}
|
|
|
|
matterScript.SetUpCECObject(); // This will reset m_iCID, so we set it again after / This will reset m_iCID, so we set it again after
|
|
// Force set CID again after SetUpCECObject (which resets it to OCID_OBJECT) / Force set CID again after SetUpCECObject (which resets it to OCID_OBJECT)
|
|
matterScript.m_iCID = Class_ID.OCID_MATTER;
|
|
|
|
// Store reference to the cube
|
|
// matterGameObjects[info.mid] = matterObject;
|
|
|
|
return matterScript;
|
|
}
|
|
else
|
|
{
|
|
Debug.LogWarning($"Failed to load matter prefab from path: {filePath}");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Debug.LogWarning($"file_matter field not found on matter data type {matterDataType.FullName}");
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Merge world-space bounds of all child Renderers (MeshRenderer + SkinnedMeshRenderer).
|
|
/// Reads sharedMesh.bounds (mesh local space) and manually converts to world space —
|
|
/// same approach as PlayerVisual/NPCVisual — to avoid stale renderer.bounds after SetActive.
|
|
/// 合并所有子 Renderer 的世界包围盒（MeshRenderer + SkinnedMeshRenderer）。
|
|
/// 直接读 sharedMesh.bounds（网格本地空间）再手动转为世界坐标，避免 SetActive 后同帧 renderer.bounds 未刷新的问题。
|
|
/// </summary>
|
|
private static bool TryGetCombinedRendererBounds(Transform matterRoot, Transform excludeSubtree, out Bounds combinedBounds)
|
|
{
|
|
combinedBounds = default;
|
|
if (matterRoot == null)
|
|
return false;
|
|
|
|
var renderers = matterRoot.GetComponentsInChildren<Renderer>(true);
|
|
bool hasAny = false;
|
|
for (int i = 0; i < renderers.Length; i++)
|
|
{
|
|
var renderer = renderers[i];
|
|
if (renderer == null)
|
|
continue;
|
|
if (excludeSubtree != null && renderer.transform.IsChildOf(excludeSubtree))
|
|
continue;
|
|
|
|
Mesh mesh = null;
|
|
if (renderer is SkinnedMeshRenderer smr)
|
|
{
|
|
mesh = smr.sharedMesh;
|
|
}
|
|
else if (renderer is MeshRenderer)
|
|
{
|
|
var mf = renderer.GetComponent<MeshFilter>();
|
|
if (mf != null)
|
|
mesh = mf.sharedMesh;
|
|
}
|
|
|
|
if (mesh == null)
|
|
continue;
|
|
|
|
// Manually build world-space bounds from mesh-local bounds + transform,
|
|
// identical to PlayerVisual/NPCVisual — reliable even right after SetActive(true).
|
|
// 与 PlayerVisual/NPCVisual 相同：从网格本地包围盒手动计算世界包围盒，SetActive 后同帧可靠。
|
|
var meshBounds = mesh.bounds;
|
|
var scale = renderer.transform.lossyScale;
|
|
var worldCenter = renderer.transform.TransformPoint(meshBounds.center);
|
|
var worldSize = new Vector3(
|
|
Mathf.Abs(meshBounds.size.x * scale.x),
|
|
Mathf.Abs(meshBounds.size.y * scale.y),
|
|
Mathf.Abs(meshBounds.size.z * scale.z));
|
|
var currentBounds = new Bounds(worldCenter, worldSize);
|
|
|
|
BMLogger.Log($"[Cuong] [CECMatter] renderer={renderer.name} meshLocalCenter={meshBounds.center} meshLocalSize={meshBounds.size} worldCenter={worldCenter} worldSize={worldSize} worldMaxY={currentBounds.max.y}");
|
|
|
|
if (!hasAny)
|
|
{
|
|
combinedBounds = currentBounds;
|
|
hasAny = true;
|
|
}
|
|
else
|
|
{
|
|
combinedBounds.Encapsulate(currentBounds);
|
|
}
|
|
}
|
|
|
|
return hasAny;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Name anchor at top of tallest mesh: combinedBounds.max.y in world, converted to local.
|
|
/// 名牌锚点位于最高 mesh 顶部：世界坐标 combinedBounds.max.y，再转为本地坐标。
|
|
/// </summary>
|
|
private static bool TryGetItemNameAnchorLocal(Transform matterRoot, out Vector3 localAnchor)
|
|
{
|
|
if (!TryGetCombinedRendererBounds(matterRoot, null, out var combinedBounds))
|
|
{
|
|
localAnchor = new Vector3(0f, MatterNameFallbackLocalY, 0f);
|
|
return false;
|
|
}
|
|
|
|
var worldAnchor = new Vector3(
|
|
combinedBounds.center.x,
|
|
combinedBounds.max.y + MatterNameExtraWorldYOffset,
|
|
combinedBounds.center.z);
|
|
localAnchor = matterRoot.InverseTransformPoint(worldAnchor);
|
|
return true;
|
|
}
|
|
|
|
private static void CreateItemNameText(GameObject matterObject, int tid)
|
|
{
|
|
if (matterObject == null)
|
|
return;
|
|
|
|
// Avoid duplicating if prefab already contains it (or Init called twice).
|
|
if (matterObject.transform.Find(ItemNameTextChildName) != null)
|
|
return;
|
|
|
|
var textObject = new GameObject(ItemNameTextChildName);
|
|
textObject.transform.SetParent(matterObject.transform, false);
|
|
if (!TryGetItemNameAnchorLocal(matterObject.transform, out var localAnchor))
|
|
{
|
|
Debug.LogWarning(
|
|
$"[Cuong] [CECMatter] No renderer bounds for '{matterObject.name}'; using fallback Y={MatterNameFallbackLocalY}");
|
|
}
|
|
textObject.transform.localPosition = localAnchor;
|
|
|
|
var textMesh = textObject.AddComponent<TextMeshPro>();
|
|
|
|
string itemName = null;
|
|
if (EC_IvtrItemUtils.Instance != null)
|
|
itemName = EC_IvtrItemUtils.Instance.ResolveItemName(tid);
|
|
|
|
// Some name resolvers return the localization key when the translation is missing
|
|
// (e.g. "BrewMonster.MINE_ESSENCE"). In that case we prefer showing nothing.
|
|
static bool LooksLikeUntranslatedKey(string s)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(s))
|
|
return false;
|
|
if (s.IndexOf(' ') >= 0 || s.IndexOf('\t') >= 0 || s.IndexOf('\n') >= 0 || s.IndexOf('\r') >= 0)
|
|
return false;
|
|
|
|
// Heuristic: "Namespace.KEY_NAME" (has '.' and '_' and mostly identifier chars).
|
|
if (s.IndexOf('.') < 0 || s.IndexOf('_') < 0)
|
|
return false;
|
|
|
|
for (int i = 0; i < s.Length; i++)
|
|
{
|
|
char c = s[i];
|
|
if (char.IsLetterOrDigit(c) || c == '_' || c == '.')
|
|
continue;
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
if (LooksLikeUntranslatedKey(itemName))
|
|
{
|
|
itemName = string.Empty;
|
|
}
|
|
else if (string.IsNullOrEmpty(itemName))
|
|
{
|
|
itemName = $"Item {tid}";
|
|
}
|
|
|
|
textMesh.text = itemName;
|
|
textMesh.fontSize = 2f;
|
|
textMesh.color = Color.white;
|
|
textMesh.alignment = TextAlignmentOptions.Center;
|
|
textMesh.textWrappingMode = TextWrappingModes.NoWrap;
|
|
textMesh.overflowMode = TextOverflowModes.Overflow;
|
|
|
|
textObject.AddComponent<Billboard>();
|
|
}
|
|
|
|
private static Mesh GetOrCreateItemNameQuadMesh()
|
|
{
|
|
if (s_itemNameQuadMesh != null)
|
|
return s_itemNameQuadMesh;
|
|
|
|
var quadMesh = new Mesh { name = "CECMatter_ItemNameQuad" };
|
|
quadMesh.vertices = new[]
|
|
{
|
|
new Vector3(-0.5f, -0.5f, 0),
|
|
new Vector3(0.5f, -0.5f, 0),
|
|
new Vector3(0.5f, 0.5f, 0),
|
|
new Vector3(-0.5f, 0.5f, 0)
|
|
};
|
|
quadMesh.triangles = new[] { 0, 1, 2, 0, 2, 3 };
|
|
quadMesh.uv = new[]
|
|
{
|
|
new Vector2(0, 0),
|
|
new Vector2(1, 0),
|
|
new Vector2(1, 1),
|
|
new Vector2(0, 1)
|
|
};
|
|
quadMesh.RecalculateNormals();
|
|
quadMesh.RecalculateBounds();
|
|
|
|
s_itemNameQuadMesh = quadMesh;
|
|
return s_itemNameQuadMesh;
|
|
}
|
|
|
|
private static Material GetOrCreateItemNameBgMaterial()
|
|
{
|
|
if (s_itemNameBgMaterial != null)
|
|
return s_itemNameBgMaterial;
|
|
|
|
var shader = Shader.Find("Unlit/Color");
|
|
if (shader == null)
|
|
shader = Shader.Find("Sprites/Default");
|
|
if (shader == null)
|
|
shader = Shader.Find("Standard");
|
|
|
|
if (shader == null)
|
|
return null;
|
|
|
|
var mat = new Material(shader) { name = "CECMatter_ItemNameBg" };
|
|
mat.color = new Color(0f, 0f, 0f, 0.7f);
|
|
|
|
// Best-effort: make it transparent if the shader supports it.
|
|
if (mat.HasProperty("_Mode"))
|
|
mat.SetFloat("_Mode", 3f);
|
|
if (mat.HasProperty("_Surface"))
|
|
mat.SetFloat("_Surface", 1f);
|
|
|
|
s_itemNameBgMaterial = mat;
|
|
return s_itemNameBgMaterial;
|
|
}
|
|
|
|
private new void Update()
|
|
{
|
|
base.Update();
|
|
|
|
// Recovery: after Unity domain reload, manager dictionaries reset but scene objects persist.
|
|
// Keep trying until we successfully register.
|
|
if (!m_registeredToManMatter)
|
|
TryRegisterToManMatter();
|
|
|
|
// Check for touch input (mobile)
|
|
if (Input.touchCount > 0)
|
|
{
|
|
Touch touch = Input.GetTouch(0);
|
|
if (touch.phase == TouchPhase.Began)
|
|
{
|
|
// Touch handling intentionally disabled for now. / Touch handling intentionally disabled for now.
|
|
}
|
|
}
|
|
// Check for mouse input (desktop)
|
|
// else if (Input.GetMouseButtonDown(0))
|
|
// {
|
|
// inputPressed = true;
|
|
// screenPosition = Input.mousePosition;
|
|
// }
|
|
//
|
|
// if (inputPressed)
|
|
// {
|
|
// Camera mainCamera = Camera.main;
|
|
// if (mainCamera == null)
|
|
// return;
|
|
//
|
|
// Ray ray = mainCamera.ScreenPointToRay(screenPosition);
|
|
//
|
|
// RaycastHit[] hits = Physics.RaycastAll(ray);
|
|
//
|
|
// foreach (RaycastHit hit in hits)
|
|
// {
|
|
// if (hit.collider.gameObject == this.gameObject ||
|
|
// hit.collider.transform.IsChildOf(this.transform))
|
|
// {
|
|
// Debug.Log($"CECMatter::RaycastHit():: mid: {m_MatterInfo.mid}");
|
|
// UnityGameSession.RequestPickupItem(m_MatterInfo.mid, m_MatterInfo.tid);
|
|
// break;
|
|
// }
|
|
// }
|
|
// }
|
|
}
|
|
|
|
public int GetMatterID()
|
|
{
|
|
return m_MatterInfo.mid;
|
|
}
|
|
}
|
|
}
|