public BuildingCoverMaskGroup[,] BuildingCoverMaskMatrix_IncludingPreview; // column, row
public CityInventory(
string inventoryName,
DragAreaIndicator dragAreaIndicator,
DragProcessor dragProcessor,
int gridSize,
int rows,
int columns,
bool x_Mirror,
bool z_Mirror,
bool unlockedPartialGrids,
int unlockedGridCount,
bool dragOutDrop,
KeyDownDelegate rotateItemKeyDownHandler,
InstantiatePrefabDelegate instantiateCityInventoryGridHandler,
InstantiatePrefabDelegate instantiateCityInventoryVirtualOccupationQuadHandler
) : base(inventoryName, dragAreaIndicator, gridSize, rows, columns, x_Mirror, z_Mirror, unlockedPartialGrids, unlockedGridCount, dragOutDrop,
rotateItemKeyDownHandler,
(gridPos) => new GridPosR(gridPos.x + columns / 2, gridPos.z + rows / 2, gridPos.orientation),
(gp_matrix) => new GridPosR(gp_matrix.x - columns / 2, gp_matrix.z - rows / 2, gp_matrix.orientation),
(gridPos) => new GridPos(gridPos.x, gridPos.z),
(gp_matrix) => new GridPos(gp_matrix.x, gp_matrix.z)
)
{
DragProcessor = dragProcessor;
InstantiateCityInventoryGridHandler = instantiateCityInventoryGridHandler;
InstantiateCityInventoryVirtualOccupationQuadHandler = instantiateCityInventoryVirtualOccupationQuadHandler;
InventoryValidMatrix = new bool[columns, rows];
BuildingCoverMaskMatrix = new BuildingCoverMaskGroup[columns, rows];
BuildingCoverMaskMatrix_IncludingPreview = new BuildingCoverMaskGroup[columns, rows];
}
/// <summary>
/// Initialize the uiInventory manager.
/// </summary>
/// <param name="inventoryName">The inventory name</param>
/// <param name="dragAreaIndicator"></param>
/// <param name="dragProcessor"></param>
/// <param name="canvasDistance">the distance of canvas</param>
/// <param name="gridSize">the gridSize of inventory</param>
/// <param name="rows">how many rows in total</param>
/// <param name="columns">how many columns in total</param>
/// <param name="x_Mirror">is X axis mirrored</param>
/// <param name="z_Mirror">is Z axis mirrored</param>
/// <param name="unlockedPartialGrids">is there any grid locked at the beginning</param>
/// <param name="unlockedGridCount">how many grids are locked at the beginning</param>
/// <param name="dragOutDrop">allows item to be dragged and dropped outside inventory</param>
/// <param name="enableScreenClamp">enable inventory UI panel's screen-clamping</param>
/// <param name="enableLog">enable inventory log</param>
/// <param name="toggleUIInventoryKeyDownHandler">This handler should return a signal which toggles the uiInventory(e.g. return Input.GetKeyDown(KeyCode.B);)</param>
/// <param name="rotateItemKeyDownHandler">This handler should return a signal which rotates the uiInventory item(e.g. return Input.GetKeyDown(KeyCode.R);)</param>
/// <param name="instantiateUIInventoryGridHandler">This handler should instantiate a prefab with UIInventoryGrid component.</param>
/// <param name="instantiateUIInventoryItemHandler">This handler should instantiate a prefab with UIInventoryItem component.</param>
/// <param name="instantiateUIInventoryItemGridHandler">This handler should instantiate a prefab with UIInventoryItemGrid component.</param>
/// <param name="instantiateUIInventoryItemVirtualOccupationQuadHandler">This handler should instantiate a image for indicating the occupation.</param>
public UIInventory(
string inventoryName,
DragAreaIndicator dragAreaIndicator,
DragProcessor dragProcessor,
float canvasDistance,
int gridSize, int rows, int columns, bool x_Mirror, bool z_Mirror,
bool unlockedPartialGrids, int unlockedGridCount, bool dragOutDrop, bool enableScreenClamp, bool enableLog,
KeyDownDelegate toggleUIInventoryKeyDownHandler,
KeyDownDelegate rotateItemKeyDownHandler,
InstantiatePrefabDelegate instantiateUIInventoryGridHandler,
InstantiatePrefabDelegate instantiateUIInventoryItemHandler,
InstantiatePrefabDelegate instantiateUIInventoryItemGridHandler,
InstantiatePrefabDelegate instantiateUIInventoryItemVirtualOccupationQuadHandler
) : base(inventoryName, dragAreaIndicator, gridSize, rows, columns, x_Mirror, z_Mirror, unlockedPartialGrids, unlockedGridCount, dragOutDrop, enableLog, rotateItemKeyDownHandler,
(gridPos) => new GridPosR(gridPos.x, -gridPos.z),
(gridPos_matrix) => new GridPosR(gridPos_matrix.x, -gridPos_matrix.z),
(gridPos) => new GridPosR(gridPos.x, -gridPos.z),
(gridPos_matrix) => new GridPosR(gridPos_matrix.x, -gridPos_matrix.z))
{
DragProcessor = dragProcessor;
CanvasDistance = canvasDistance;
ToggleUIInventoryKeyDownHandler = toggleUIInventoryKeyDownHandler;
InstantiateUIInventoryGridHandler = instantiateUIInventoryGridHandler;
InstantiateUIInventoryItemHandler = instantiateUIInventoryItemHandler;
InstantiateUIInventoryItemGridHandler = instantiateUIInventoryItemGridHandler;
InstantiateUIInventoryItemVirtualOccupationQuadHandler = instantiateUIInventoryItemVirtualOccupationQuadHandler;
EnableScreenClamp = enableScreenClamp;
}
public void Init(MechaInfo mechaInfo)
{
DragProcessor = DragManager.Instance.GetDragProcessor <MechaComponent>();
Clear();
SetShown(false);
DragArea.DragAreaName = mechaInfo.MechaEditorInventory.DragArea.DragAreaName;
MechaEditorAreaGridRoot.Init();
}
public GraphicalComponentUserControl()
{
_graphicalComponent = new GraphicalComponent();
_dragProcessor = new DragProcessor();
InitializeComponent();
/* Handlers for application state modifications from UI changes */
Loaded += (_, __) => OnLoaded();
SizeChanged += (_, __) => OnSizeChanged();
}
private void InitDragProcessor()
{
DragProcessor_UIInventoryItem = new DragProcessor <UIInventoryItem>();
DragProcessor_UIInventoryItem.Init(
camera: GameManager.Instance.UICamera,
layerMask: 1 << UIInventoryItemGridPrefab.layer,
getScreenMousePositionHandler: (out Vector2 mouseScreenPos) =>
{
mouseScreenPos = Input.mousePosition;
return(true);
},
screenMousePositionToWorldHandler: UIInventory_Panel.UIInventoryDragAreaIndicator.GetMousePosOnThisArea,
onBeginDrag: null,
onCancelDrag: null);
}
private void Init()
{
foreach (Building buildingPrefab in BuildingPrefabList)
{
LevelManager.Instance.BuildingPrefabDict.Add(buildingPrefab.BuildingInfo.buildingKey, buildingPrefab);
LevelManager.Instance.BuildingInfoDict.Add(buildingPrefab.BuildingInfo.buildingKey, buildingPrefab.BuildingInfo);
}
DragProcessor <Building> DragProcessor_Building = new DragProcessor <Building>();
DragProcessor_Building.Init(
UIManager.Instance.UICamera,
BuildingLayerMask.value,
(out Vector2 mouseScreenPos) =>
{
mouseScreenPos = Input.mousePosition;
return(true);
},
City.CityEditAreaIndicator.GetMousePosOnThisArea,
delegate(Building building, Collider collider, DragProcessor dragProcessor) { },
delegate(Building building, Collider collider, DragProcessor dragProcessor) { }
);
CityInventory = new CityInventory(
InventoryName,
City.CityEditAreaIndicator,
DragProcessor_Building,
gridSize: ConfigManager.GRID_SIZE, // UI units
rows: Rows,
columns: Columns,
x_Mirror: false,
z_Mirror: false,
unlockedPartialGrids: false,
unlockedGridCount: Rows * Columns,
dragOutDrop: false,
rotateItemKeyDownHandler: () => Input.GetKeyDown(KeyCode.R), // Rotate building
instantiateCityInventoryVirtualOccupationQuadHandler: (parent) => Instantiate(CityInventoryVirtualOccupationQuadPrefab, parent).GetComponent <CityInventoryVirtualOccupationQuad>(),
instantiateCityInventoryGridHandler: (parent) => Instantiate(CityInventoryGridPrefab, parent).GetComponent <CityInventoryGrid>()
);
CityInventory.ToggleDebugKeyDownHandler = () => Input.GetKeyDown(KeyCode.BackQuote); // Toggle debug log
City.Init(CityInventory, CityConfig);
CityInventory.City = City;
}
public void Init()
{
DragManager.Instance.Init(
() => Input.GetMouseButtonDown(0),
() => Input.GetMouseButtonUp(0),
Debug.LogError,
LayerManager.Instance.LayerMask_DragAreas);
DragProcessor <Building> dragProcessor_Building = new DragProcessor <Building>(); // building里面不包含draggable组件，因此不响应拖拽事件
dragProcessor_Building.Init(
CameraManager.Instance.MainCamera,
LayerManager.Instance.LayerMask_BuildingHitBox,
(out Vector2 mouseScreenPos) =>
{
mouseScreenPos = Input.mousePosition;
return(true);
}
,
ScreenMousePositionToWorld_CityInventory,
delegate(Building building, Collider collider, DragProcessor dragProcessor) { },
delegate(Building building, Collider collider, DragProcessor dragProcessor) { }
);
}
public void Init(UIInventory uiInventory)
{
UIInventory = uiInventory;
DragProcessor = DragManager.Instance.GetDragProcessor <UIInventoryItem>();
}
/// <summary>
/// Add drag gesture on link end
/// </summary>
/// <param name="con"></param>
/// <param name="thumb"></param>
private void AddGesture(Connection con, UIElement thumb)
{
var begsurface = TouchSurfaceWPF.GetOrCreateTouchSurface(thumb);
var drag = new DragProcessor() { UseMinimalDisplacement = false };
drag.GestureStart += delegate(object sender, GestureEventArgs arg)
{
var data = new Dictionary<string, object>();
data.Add("connector", con);
data.Add("thumb", sender);
var dd = DragAndDrop.StartDragDrop(drag, new DragDropParameters { Data = data }, thumb);
if (sender == con.BeginThumb)
{
con.Source = null;
con.SourceAnchor = new TargetAnchor() { Mode = TargetAnchor.AnchorMode.FreeAnchor, TargetPoint = new SofthinkCore.UI.Controls.Connector.Anchor { Point = arg.Transform.ConvertToVisual(conlayer).Center /*arg.GetCurrentPositionForElement(conlayer)*/ } };
}
else
{
con.Sink = null;
con.SinkAnchor = new TargetAnchor() { Mode = TargetAnchor.AnchorMode.FreeAnchor, TargetPoint = new SofthinkCore.UI.Controls.Connector.Anchor { Point = arg.Transform.ConvertToVisual(conlayer).Center /*arg.GetCurrentPositionForElement(conlayer)*/ } };
}
con.IsHitTestVisible = false;
dd.Cancel += delegate(object s, DragDropArgs e)
{
con.IsHitTestVisible = true;
};
};
drag.GestureMove += delegate(object sender, GestureEventArgs arg)
{
if (sender == con.BeginThumb)
{
con.SourceAnchor.TargetPoint = new SofthinkCore.UI.Controls.Connector.Anchor { Point = arg.Transform.ConvertToVisual(conlayer).Center /*arg.GetCurrentPositionForElement(conlayer)*/ };
}
else
{
con.SinkAnchor.TargetPoint = new SofthinkCore.UI.Controls.Connector.Anchor { Point = arg.Transform.ConvertToVisual(conlayer).Center /*arg.GetCurrentPositionForElement(conlayer)*/ };
}
};
begsurface.AddGestureProcessor(drag);
}
public void Init(CityInventory cityInventory)
{
CityInventory = cityInventory;
DragProcessor = DragManager.Instance.GetDragProcessor <Building>();
}
public void Init(Backpack backpack)
{
Backpack = backpack;
DragArea = new DragArea(backpack.DragArea.DragAreaName);
DragProcessor = DragManager.Instance.GetDragProcessor <BackpackItem>();
}
public void Init()
{
DragProcessor <BackpackItem> dragProcessor_BackpackItem = new DragProcessor <BackpackItem>();
dragProcessor_BackpackItem.Init(
UIManager.Instance.UICamera,
LayerManager.Instance.LayerMask_BackpackItemGrid,
(out Vector2 mouseScreenPos) =>
{
if (ControlManager.Instance.BuildingInputActionEnabled)
{
mouseScreenPos = ControlManager.Instance.Building_MousePosition;
return(true);
}
else
{
mouseScreenPos = Vector2.zero;
return(false);
}
},
ScreenMousePositionToWorld_BackpackDragArea,
delegate(BackpackItem bi, Collider collider, DragProcessor dragProcessor) { },
delegate(BackpackItem bi, Collider collider, DragProcessor dragProcessor) { }
);
DragProcessor <MechaComponentDropSprite> dragProcessor_MechaComponentDropSprite = new DragProcessor <MechaComponentDropSprite>();
dragProcessor_MechaComponentDropSprite.Init(
CameraManager.Instance.MainCamera,
LayerManager.Instance.LayerMask_ItemDropped,
(out Vector2 mouseScreenPos) =>
{
if (ControlManager.Instance.BuildingInputActionEnabled)
{
mouseScreenPos = ControlManager.Instance.Building_MousePosition;
return(true);
}
else
{
mouseScreenPos = Vector2.zero;
return(false);
}
},
ScreenMousePositionToWorld_MechaEditorInventory,
delegate(MechaComponentDropSprite mcds, Collider collider, DragProcessor dragProcessor)
{
Ray ray = CameraManager.Instance.MainCamera.ScreenPointToRay(ControlManager.Instance.Building_MousePosition);
MechaComponentInfo mci = mcds.MechaComponentInfo.Clone();
ClientBattleManager.Instance.PlayerMecha.MechaInfo.AddMechaComponentInfo(mci, GridPosR.Zero);
MechaComponent mc = ClientBattleManager.Instance.PlayerMecha.MechaComponentDict[mci.GUID];
GridPos gp = GridUtils.GetGridPosByMousePos(ClientBattleManager.Instance.PlayerMecha.transform, ray, Vector3.up, ConfigManager.GridSize);
mci.InventoryItem.SetGridPosition(gp);
DragManager.Instance.CurrentDrag = mc.GetComponent <Draggable>();
DragManager.Instance.CurrentDrag.SetOnDrag(true, collider, dragProcessor);
mcds.PoolRecycle();
},
delegate(MechaComponentDropSprite mcds, Collider collider, DragProcessor dragProcessor) { }
);
DragManager.Instance.Init(
() => ControlManager.Instance.Building_MouseLeft.Down,
() => ControlManager.Instance.Building_MouseLeft.Up,
Debug.LogError,
LayerManager.Instance.LayerMask_DragAreas);
DragProcessor <MechaComponent> dragProcessor_MechaComponent = new DragProcessor <MechaComponent>();
dragProcessor_MechaComponent.Init(
CameraManager.Instance.MainCamera,
LayerManager.Instance.LayerMask_ComponentHitBox_Player,
(out Vector2 mouseScreenPos) =>
{
if (ControlManager.Instance.BuildingInputActionEnabled)
{
mouseScreenPos = ControlManager.Instance.Building_MousePosition;
return(true);
}
else
{
mouseScreenPos = Vector2.zero;
return(false);
}
}
,
ScreenMousePositionToWorld_MechaEditorInventory,
delegate(MechaComponent mc, Collider collider, DragProcessor dragProcessor) { },
delegate(MechaComponent mc, Collider collider, DragProcessor dragProcessor) { }
);
}
