public void Reset()
{
_rposBits = 0;
BaseStream.Position = 0;
ReadList.Clear();
ResetBitReader();
}
public IActionResult WillRead(int BookID, ReadList BookAdded, string Navigate)
{
BookAdded.BookID = BookID;
BookAdded.ReaderID = (int)HttpContext.Session.GetInt32("id");
dbContext.Add(BookAdded);
dbContext.SaveChanges();
if (Navigate == "GenreFilter")
{
Book TheBook = dbContext.Books.FirstOrDefault(b => b.BookID == BookID);
return(RedirectToAction("Filter", new { Feature = "Genre", Word = TheBook.Genre }));
}
if (Navigate == "AuthorFilter")
{
Book TheBook = dbContext.Books.FirstOrDefault(b => b.BookID == BookID);
return(RedirectToAction("Filter", new { Feature = "Author", Word = TheBook.Author }));
}
if (Navigate == "SearchFilter")
{
Book TheBook = dbContext.Books.FirstOrDefault(b => b.BookID == BookID);
return(RedirectToAction("Filter", new { Feature = "Search", Word = "Search", search = TempData["search"] }));
}
if (Navigate == "UnreadFilter")
{
Book TheBook = dbContext.Books.FirstOrDefault(b => b.BookID == BookID);
return(RedirectToAction("Filter", new { Feature = "Dashboard", Word = "Unread" }));
}
return(RedirectToAction("Dashboard"));
}
private void ReadOrdinals(IDataReader reader, int cmd_bit)
{
string key;
IDynaField field;
ReadList.Clear();
foreach (var p in FieldDict.Values)
{
p.Ordinal = -1;
}
int i_ord, i_count = reader.FieldCount;
for (i_ord = 0; i_ord < i_count; i_ord++)
{
key = reader.GetName(i_ord);
if (FieldDict.Keys.Contains <string>(key))
{
field = FieldDict[key];
//read 1 - for select
//read 2 - for detail
if ((field.GetOutMask() & cmd_bit) > 0)
{
field.Ordinal = i_ord;
ReadList.Add(field);
}
}
}
}
// Use this for initialization
void Awake()
{
string binid = "MENU0004";
rl = new ReadList(binid);
int a_fairy = rl.items.Length;
fairy_names = new string[a_fairy];
info = new string[a_fairy];
for (int i = 0; i < a_fairy; i++)
{
fairy_names[i] = rl.items[i];
info[i] = rl.infos[i];
}
fys = new fairy[a_fairy];
fairy_collection = new bool[a_fairy];
fairy_list = Instantiate(list_tool, transform);
fairy_list.SetListPos(list_pos);
fairy_list.SetInfoPos(info_pos);
fairy_lv_bar = new Text[a_fairy];
fairy_lv_status = new Text[a_fairy];
for (int i = 0; i < a_fairy; i++)
{
fairy_lv_bar[i] = Instantiate(text, transform);
fairy_lv_bar[i].name = "lv_bar_" + i.ToString();
TextSetPos(fairy_lv_bar[i], new Rect(list_pos.x + 100, list_pos.y + i * 30, list_pos.width, list_pos.height));
fairy_lv_bar[i].text = lv_bar(i);
fairy_lv_status[i] = Instantiate(text, transform);
fairy_lv_status[i].name = "lv_status_" + i.ToString();
TextSetPos(fairy_lv_status[i], new Rect(list_pos.x + 300, list_pos.y + i * 30, list_pos.width, list_pos.height));
fys[i] = new fairy();
}
//crystals
crystal_amount = Instantiate(text, transform);
crystal_amount.name = "CrystalAmount";
TextSetPos(crystal_amount, crystal_pos);
feed_confirm = Instantiate(diag, transform);
feed_confirm.SetActive(false);
//instructions
instructions = Instantiate(text, transform);
instructions.name = "Instructions";
instructions.GetComponent <TextSetPos>().SetPos(instructions_pos);
instructions.text = "↑↓ 精灵选择 ←→ 效果A等级调整 ⓎⒶ 效果B等级调整 Ⓧ 精灵装备/卸下 Ⓑ 精灵升级";
//e for equipped
e = Instantiate(picture_e, transform);
FairyEquipUpdate();
}
public bool CanExecuteDeleteReadListCommand(object parameter)
{
ReadList selectedItem = parameter as ReadList;
if (selectedItem != null)
{
return(true);
}
return(false);
}
public IActionResult WontRead(int BookID)
{
IEnumerable <ReadList> YourReadLists = dbContext.ReadLists
.Where(b => b.BookID == BookID)
.Where(r => r.ReaderID == (int)HttpContext.Session.GetInt32("id"))
.ToList();
ReadList BookToRemove = YourReadLists.FirstOrDefault();
dbContext.Remove(BookToRemove);
dbContext.SaveChanges();
return(RedirectToAction("YourBooks", new { List = "ReadList" }));
}
public ActionResult Edit(ReadList rl)
{
try
{
string str = Client.UpdateReadList(rl);
return(View("Message", (object)str));
}
catch
{
return(View("Message", (object)"Оновлення не вдалося!"));
}
}
public ActionResult Delete(ReadList rl)
{
try
{
string str = Client.DeleteById(rl.Id);
return(View("Message", (object)str));
}
catch
{
return(View("Message", (object)"Видалення не вдалося!"));
}
}
public ActionResult Insert(ReadList rl)
{
try
{
string str = Client.InsertReadList(rl.AuthorName, rl.BookTitle, rl.ReadingDate, rl.Page, rl.Rating);
return(View("Message", (object)str));
}
catch
{
return(View("Message", (object)"Додання не вдалося!"));
}
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
public void Awake() {
vSetup = gameObject.GetComponent<HovercursorSetup>();
vFakeItem = new FakeItemState();
vFakeItem.ItemAutoId = 123;
vActiveCursorTypes = new ReadList<CursorType>();
ActiveCursorTypes = vActiveCursorTypes.ReadOnly;
vFakeInteractions = new ReadOnlyCollection<IBaseItemInteractionState>(
new List<IBaseItemInteractionState>());
vFakePlanes = new ReadOnlyCollection<PlaneData>(new List<PlaneData>());
}
void Start()
{
_instance = this; //创建单例
if (Preference.isFirst) //如果第一次进select场景
{
GetList();
SelectedSong = songList[0]; //默认选择歌曲为第一个
}
ShowItem();
Preference.isFirst = false;
ShowLevel();
PlayAudio(SelectedSong);
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
public void Awake()
{
vSetup = gameObject.GetComponent <HovercursorSetup>();
vFakeItem = new FakeItemState();
vFakeItem.ItemAutoId = 123;
vActiveCursorTypes = new ReadList <CursorType>();
ActiveCursorTypes = vActiveCursorTypes.ReadOnly;
vFakeInteractions = new ReadOnlyCollection <IBaseItemInteractionState>(
new List <IBaseItemInteractionState>());
vFakePlanes = new ReadOnlyCollection <PlaneData>(new List <PlaneData>());
}
// Use this for initialization
void Start()
{
labels = labelname.Length;
item = new string[labels][];
info = new string[labels][];
b_item = new bool[labels][];
rls = new ReadList[labels];
for (int i = 0; i < labels; i++)
{
int j = i + 1;
binid = "MENU000" + j.ToString();
rls[i] = new ReadList(binid);
item[i] = rls[i].items;
info[i] = rls[i].infos;
}
b_item[0] = GetComponent <SystemDataManager>().LoadBools("character_collection");
b_item[1] = GetComponent <SystemDataManager>().LoadBools("setting_collection");
b_item[2] = GetComponent <SystemDataManager>().LoadBools("ending_collection");
//message lock manage
for (int i = 0; i < item.Length; i++)
{
string[] messages = item[i];
int mes_len = messages.Length;
if (b_item[i].Length != mes_len)
{
Debug.Log("savedata wrong.");
}
for (int j = 0; j < mes_len; j++)
{
if (!b_item[i][j])
{
item[i][j] = "???";
info[i][j] = "???????";
}
}
}
{
db_list = Instantiate(listtool, transform);
db_list.SetListPos(list_pos);
db_list.SetInfoPos(info_pos);
db_list.InitText(rls[labelpos]);
}
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
public MenuState(IItemHierarchy pItemHierarchy, InteractionSettings pInteractSettings) {
vItemHierarchy = pItemHierarchy;
vInteractSettings = pInteractSettings;
vAllItems = new List<BaseItemState>();
vItems = new ReadList<BaseItemState>();
vLevelItems = new ReadList<IBaseItemState>();
vPalmItem = new BaseItemState(vItemHierarchy.NavigateBackItem, pInteractSettings);
vCurrentCursors = new List<ICursorState>();
OnLevelChange += (d => {});
vItemHierarchy.OnLevelChange += HandleLevelChange;
HandleLevelChange(0);
}
// Use this for initialization
void Awake()
{
alarm = Instantiate(text, transform);
alarm.GetComponent <TextSetPos>().SetPos(alarm_pos);
string binid = "DIAG000";
ReadList rl = new ReadList(binid);
string alarm_text = rl.items[0] + "\n" + rl.items[1];
alarm.text = alarm_text;
confirm_button = Instantiate(text, transform);
confirm_button.GetComponent <TextSetPos>().SetPos(selection_pos);
string selection_text = rl.infos[0] + " " + rl.infos[1];
confirm_button.text = selection_text;
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
public MenuState(IItemHierarchy pItemHierarchy, InteractionSettings pInteractSettings)
{
vItemHierarchy = pItemHierarchy;
vInteractSettings = pInteractSettings;
vAllItems = new List <BaseItemState>();
vItems = new ReadList <BaseItemState>();
vLevelItems = new ReadList <IBaseItemState>();
vPalmItem = new BaseItemState(vItemHierarchy.NavigateBackItem, pInteractSettings);
vCurrentCursors = new List <ICursorState>();
OnLevelChange += (d => {});
vItemHierarchy.OnLevelChange += HandleLevelChange;
HandleLevelChange(0);
}
public void ExecuteUpdateReadListCommand(object parameter)
{
ReadList selectedItem = parameter as ReadList;
if (selectedItem != null)
{
try
{
StatusString = _client.UpdateReadList(selectedItem);
}
catch (Exception e)
{
StatusString = "Оновлення не вдалося!";
}
ReadLists = null;
}
}
public IActionResult DidRead(int BookID, Read BookRead, string Navigate)
{
// Add to 'Already Read' list
BookRead.BookID = BookID;
BookRead.ReaderID = (int)HttpContext.Session.GetInt32("id");
dbContext.Add(BookRead);
dbContext.SaveChanges();
// If on 'To Read List', find and delete
IEnumerable <ReadList> BookToRead = dbContext.ReadLists
.Where(b => b.BookID == BookID)
.Where(r => r.ReaderID == (int)HttpContext.Session.GetInt32("id"))
.ToList();
if (BookToRead.Count() > 0)
{
ReadList BookToRemove = BookToRead.FirstOrDefault();
dbContext.Remove(BookToRemove);
dbContext.SaveChanges();
}
if (Navigate == "GenreFilter")
{
Book TheBook = dbContext.Books.FirstOrDefault(b => b.BookID == BookID);
return(RedirectToAction("Filter", new { Feature = "Genre", Word = TheBook.Genre }));
}
if (Navigate == "AuthorFilter")
{
Book TheBook = dbContext.Books.FirstOrDefault(b => b.BookID == BookID);
return(RedirectToAction("Filter", new { Feature = "Author", Word = TheBook.Author }));
}
if (Navigate == "SearchFilter")
{
Book TheBook = dbContext.Books.FirstOrDefault(b => b.BookID == BookID);
return(RedirectToAction("Filter", new { Feature = "Search", Word = "Search", search = TempData["search"] }));
}
if (Navigate == "UnreadFilter")
{
Book TheBook = dbContext.Books.FirstOrDefault(b => b.BookID == BookID);
return(RedirectToAction("Filter", new { Feature = "Dashboard", Word = "Unread" }));
}
if (Navigate == "YourList")
{
Book TheBook = dbContext.Books.FirstOrDefault(b => b.BookID == BookID);
return(RedirectToAction("YourBooks", new { List = "ReadList" }));
}
return(RedirectToAction("Dashboard"));
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
public HoverboardState(ItemPanel[] pItemPanels, HovercursorSetup pHovercusorSetup,
InteractionSettings pInterSett, Transform pBaseTx)
{
vInteractSett = pInterSett;
vHovercusorSetup = pHovercusorSetup;
vBaseTx = pBaseTx;
vProjectionMap = new ListMap <CursorType, ProjectionState>(EnumIntKeyComparer.CursorType);
////
var panels = new List <PanelState>();
var allItems = new List <ItemTree>();
foreach (ItemPanel itemPanel in pItemPanels)
{
var panel = new PanelState(itemPanel, vInteractSett);
panel.InteractionPlane = new PlaneData("Hoverboard.Panel-" + panels.Count,
((GameObject)panel.ItemPanel.DisplayContainer).transform, Vector3.up);
panels.Add(panel);
foreach (LayoutState layout in panel.FullLayouts)
{
layout.ItemLayout.SetRadioSiblingsFunc(GetRadioSiblings);
foreach (BaseItemState item in layout.FullItems)
{
var tree = new ItemTree {
Panel = panel,
Layout = layout,
Item = item
};
allItems.Add(tree);
}
}
}
vAllItems = allItems.ToArray();
vActiveItems = new List <ItemTree>();
vActiveCursorInteractions = new ReadList <IBaseItemInteractionState>();
vActiveCursorPlanes = new ReadList <PlaneData>();
FullPanels = panels.ToArray();
Panels = new ReadOnlyCollection <IHoverboardPanelState>(FullPanels);
ActiveCursorTypes = new ReadOnlyCollection <CursorType>(vInteractSett.Cursors);
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
public UiHoverMeshRect(GameObject pParent, string pBgName=null) {
Build(pParent);
Quaternion rot = Quaternion.FromToRotation(Vector3.forward, Vector3.up);
Background.transform.localRotation = rot;
Edge.transform.localRotation = rot;
Highlight.transform.localRotation = rot;
Select.transform.localRotation = rot;
if ( pBgName != null ) {
Background.name = pBgName;
}
vMeshW = -1;
vMeshH = -1;
vHoverPoints = new ReadList<Vector3>();
}
/*--------------------------------------------------------------------------------------------*/
public static void CalcHoverPoints(float pWidth, float pHeight, ReadList <Vector3> pResult)
{
int stepsX = (int)Math.Round(pWidth / UiItem.Size) * 6;
int stepsY = (int)Math.Round(pHeight / UiItem.Size) * 6;
float x0 = -pWidth / 2f;
float y0 = -pHeight / 2f;
float xInc = pWidth / stepsX;
float yInc = pHeight / stepsY;
pResult.Clear();
for (int xi = 1; xi < stepsX; xi += 2)
{
for (int yi = 1; yi < stepsY; yi += 2)
{
pResult.Add(new Vector3(x0 + xInc * xi, 0, y0 + yInc * yi)); //relative to parent
}
}
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
public HoverboardState(ItemPanel[] pItemPanels, HovercursorSetup pHovercusorSetup,
InteractionSettings pInterSett, Transform pBaseTx) {
vInteractSett = pInterSett;
vHovercusorSetup = pHovercusorSetup;
vBaseTx = pBaseTx;
vProjectionMap = new ListMap<CursorType, ProjectionState>(EnumIntKeyComparer.CursorType);
////
var panels = new List<PanelState>();
var allItems = new List<ItemTree>();
foreach ( ItemPanel itemPanel in pItemPanels ) {
var panel = new PanelState(itemPanel, vInteractSett);
panel.InteractionPlane = new PlaneData("Hoverboard.Panel-"+panels.Count,
((GameObject)panel.ItemPanel.DisplayContainer).transform, Vector3.up);
panels.Add(panel);
foreach ( LayoutState layout in panel.FullLayouts ) {
layout.ItemLayout.SetRadioSiblingsFunc(GetRadioSiblings);
foreach ( BaseItemState item in layout.FullItems ) {
var tree = new ItemTree {
Panel = panel,
Layout = layout,
Item = item
};
allItems.Add(tree);
}
}
}
vAllItems = allItems.ToArray();
vActiveItems = new List<ItemTree>();
vActiveCursorInteractions = new ReadList<IBaseItemInteractionState>();
vActiveCursorPlanes = new ReadList<PlaneData>();
FullPanels = panels.ToArray();
Panels = new ReadOnlyCollection<IHoverboardPanelState>(FullPanels);
ActiveCursorTypes = new ReadOnlyCollection<CursorType>(vInteractSett.Cursors);
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
protected void Build(GameObject pParent)
{
vParent = pParent;
vHoverPoints = new ReadList <Vector3>();
Background = new GameObject("Background");
Background.transform.SetParent(pParent.transform, false);
Background.AddComponent <MeshRenderer>();
Background.AddComponent <MeshFilter>();
Edge = new GameObject("Edge");
Edge.transform.SetParent(pParent.transform, false);
Edge.AddComponent <MeshRenderer>();
Edge.AddComponent <MeshFilter>();
Highlight = new GameObject("Highlight");
Highlight.transform.SetParent(pParent.transform, false);
Highlight.AddComponent <MeshRenderer>();
Highlight.AddComponent <MeshFilter>();
Select = new GameObject("Select");
Select.transform.SetParent(pParent.transform, false);
Select.AddComponent <MeshRenderer>();
Select.AddComponent <MeshFilter>();
BackgroundMeshBuilder = new MeshBuilder();
EdgeMeshBuilder = new MeshBuilder();
HighlightMeshBuilder = new MeshBuilder();
SelectMeshBuilder = new MeshBuilder();
Background.GetComponent <MeshFilter>().sharedMesh = BackgroundMeshBuilder.Mesh;
Edge.GetComponent <MeshFilter>().sharedMesh = EdgeMeshBuilder.Mesh;
Highlight.GetComponent <MeshFilter>().sharedMesh = HighlightMeshBuilder.Mesh;
Select.GetComponent <MeshFilter>().sharedMesh = SelectMeshBuilder.Mesh;
BackgroundColor = Color.clear;
EdgeColor = Color.clear;
SelectColor = Color.clear;
HighlightColor = Color.clear;
UpdateAfterResize();
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
public UiHoverMeshRect(GameObject pParent, string pBgName = null)
{
Build(pParent);
Quaternion rot = Quaternion.FromToRotation(Vector3.forward, Vector3.up);
Background.transform.localRotation = rot;
Edge.transform.localRotation = rot;
Highlight.transform.localRotation = rot;
Select.transform.localRotation = rot;
if (pBgName != null)
{
Background.name = pBgName;
}
vMeshW = -1;
vMeshH = -1;
vHoverPoints = new ReadList <Vector3>();
}
public void ExecuteAddReadListCommand(object parameter)
{
ReadList selectedItem = parameter as ReadList;
if (selectedItem != null)
{
try
{
StatusString = _client.InsertReadList(selectedItem.AuthorName, selectedItem.BookTitle, selectedItem.ReadingDate,
selectedItem.Page, selectedItem.Rating);
}
catch (Exception e)
{
StatusString = "Додавання нового значення не вдалося!";
}
ReadLists = null;
NewReadList = null;
}
}
public bool CanExecuteAddReadListCommand(object parameter)
{
ReadList selectedItem = parameter as ReadList;
if (selectedItem != null)
{
if (string.IsNullOrWhiteSpace(selectedItem.AuthorName) ||
string.IsNullOrWhiteSpace(selectedItem.BookTitle) ||
selectedItem.ReadingDate > DateTime.Now ||
selectedItem.Page <= 0 ||
selectedItem.Rating <= 0 || selectedItem.Rating > 5)
{
return(false);
}
return(true);
}
return(false);
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
protected void Build(GameObject pParent) {
vParent = pParent;
vHoverPoints = new ReadList<Vector3>();
Background = new GameObject("Background");
Background.transform.SetParent(pParent.transform, false);
Background.AddComponent<MeshRenderer>();
Background.AddComponent<MeshFilter>();
Edge = new GameObject("Edge");
Edge.transform.SetParent(pParent.transform, false);
Edge.AddComponent<MeshRenderer>();
Edge.AddComponent<MeshFilter>();
Highlight = new GameObject("Highlight");
Highlight.transform.SetParent(pParent.transform, false);
Highlight.AddComponent<MeshRenderer>();
Highlight.AddComponent<MeshFilter>();
Select = new GameObject("Select");
Select.transform.SetParent(pParent.transform, false);
Select.AddComponent<MeshRenderer>();
Select.AddComponent<MeshFilter>();
BackgroundMeshBuilder = new MeshBuilder();
EdgeMeshBuilder = new MeshBuilder();
HighlightMeshBuilder = new MeshBuilder();
SelectMeshBuilder = new MeshBuilder();
Background.GetComponent<MeshFilter>().sharedMesh = BackgroundMeshBuilder.Mesh;
Edge.GetComponent<MeshFilter>().sharedMesh = EdgeMeshBuilder.Mesh;
Highlight.GetComponent<MeshFilter>().sharedMesh = HighlightMeshBuilder.Mesh;
Select.GetComponent<MeshFilter>().sharedMesh = SelectMeshBuilder.Mesh;
BackgroundColor = Color.clear;
EdgeColor = Color.clear;
SelectColor = Color.clear;
HighlightColor = Color.clear;
UpdateAfterResize();
}
// Use this for initialization
void Start()
{
PlayerPrefs.DeleteAll();
farm_menu = Instantiate(data_canvas);
farm_menu.GetComponentInChildren <GameDataManager>().save_flag = false;
farm_menu.SetActive(false);
DataBaseMenu = Instantiate(DataBaseCanvas);
DataBaseMenu.SetActive(false);
//list
string binid = "MENU0000";
ReadList rl = new ReadList(binid);
main_menu = Instantiate(list_tool, transform);
main_menu.SetListPos(list_pos);
main_menu.SetInfoPos(info_pos);
main_menu.GetComponent <ListTool>().InitText(rl);
main_menu.SetInfoAlign(TextAnchor.MiddleCenter);
}
public void ExecuteDeleteReadListCommand(object parameter)
{
ReadList selectedItem = parameter as ReadList;
if (selectedItem != null)
{
try
{
StatusString = _client.DeleteById(selectedItem.Id);
selectedItem = _readLists.FirstOrDefault(find => find.Id == selectedItem.Id);
if (selectedItem != null)
{
_readLists.Remove(selectedItem);
}
}
catch (Exception e)
{
ReadLists = null;
StatusString = "Видалення не вдалося!";
}
}
}
/*--------------------------------------------------------------------------------------------*/
private ReadOnlyCollection <PlaneData> GetActiveCursorPlanes(CursorType pType)
{
UpdateActiveDelegates();
ReadList <PlaneData> planes;
if (!vActiveCursorPlaneMap.TryGetValue(pType, out planes))
{
planes = new ReadList <PlaneData>();
vActiveCursorPlaneMap.Add(pType, planes);
}
else
{
planes.Clear();
}
foreach (IHovercursorDelegate del in vActiveDelegates)
{
planes.AddRange(del.GetActiveCursorPlanes(pType));
}
return(vActiveCursorPlaneMap[pType].ReadOnly);
}
public void InitText(ReadList rl)
{
items = rl.items;
infos = rl.infos;
length = rl.items.Length;
if (ch_cursor == null)
{
ch_cursor = Instantiate(cursor, transform);
ch_list = Instantiate(list, transform);
RectTransform rt = ch_list.GetComponent <RectTransform>();
rt.SetInsetAndSizeFromParentEdge(RectTransform.Edge.Left, list_pos.x, list_pos.width);
rt.SetInsetAndSizeFromParentEdge(RectTransform.Edge.Top, list_pos.y, list_pos.height);
ch_info = Instantiate(info, transform);
rt = ch_info.GetComponent <RectTransform>();
rt.SetInsetAndSizeFromParentEdge(RectTransform.Edge.Left, info_pos.x, info_pos.width);
rt.SetInsetAndSizeFromParentEdge(RectTransform.Edge.Top, info_pos.y, info_pos.height);
}
ListUpdate();
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
public HovercastState(IItemHierarchy pItemHierarchy, HovercursorSetup pHovercusorSetup,
InteractionSettings pInterSett, IInput pInput, Transform pBaseTx) {
vInteractSettings = pInterSett;
vHovercursorSetup = pHovercusorSetup;
vInput = pInput;
BaseTransform = pBaseTx;
FullMenu = new MenuState(pItemHierarchy, vInteractSettings);
vActiveCursorInteractions = new ReadList<IBaseItemInteractionState>();
vMenuPlanes = new ReadList<PlaneData>();
vActiveCursorTypes = new ReadList<CursorType>();
ActiveCursorTypes = vActiveCursorTypes.ReadOnly;
vLeftCursorConvertMap =
new Dictionary<HovercastCursorType, CursorType>(HovercastCursorTypeComparer);
vLeftCursorConvertMap.Add(HovercastCursorType.Palm, CursorType.LeftPalm);
vLeftCursorConvertMap.Add(HovercastCursorType.Thumb, CursorType.LeftThumb);
vLeftCursorConvertMap.Add(HovercastCursorType.Index, CursorType.LeftIndex);
vLeftCursorConvertMap.Add(HovercastCursorType.Middle, CursorType.LeftMiddle);
vLeftCursorConvertMap.Add(HovercastCursorType.Ring, CursorType.LeftRing);
vLeftCursorConvertMap.Add(HovercastCursorType.Pinky, CursorType.LeftPinky);
vLeftCursorConvertMap.Add(HovercastCursorType.Look, CursorType.Look);
vRightCursorConvertMap =
new Dictionary<HovercastCursorType, CursorType>(HovercastCursorTypeComparer);
vRightCursorConvertMap.Add(HovercastCursorType.Palm, CursorType.RightPalm);
vRightCursorConvertMap.Add(HovercastCursorType.Thumb, CursorType.RightThumb);
vRightCursorConvertMap.Add(HovercastCursorType.Index, CursorType.RightIndex);
vRightCursorConvertMap.Add(HovercastCursorType.Middle, CursorType.RightMiddle);
vRightCursorConvertMap.Add(HovercastCursorType.Ring, CursorType.RightRing);
vRightCursorConvertMap.Add(HovercastCursorType.Pinky, CursorType.RightPinky);
vRightCursorConvertMap.Add(HovercastCursorType.Look, CursorType.Look);
OnSideChange += (() => {});
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
public BaseItemPointsState()
{
vWorldPoints = new ReadList <Vector3>();
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
public virtual void Build(IHovercastMenuState pMenuState, IBaseItemState pItemState,
float pArcAngle, IItemVisualSettings pSettings)
{
vMenuState = pMenuState;
vItemState = pItemState;
vAngle0 = -pArcAngle / 2f;
vAngle1 = pArcAngle / 2f;
vSettings = (ItemVisualSettingsStandard)pSettings;
vSliderItem = (ISliderItem)vItemState.Item;
vTicks = new GameObject[vSliderItem.Ticks];
const float pi = (float)Math.PI;
vGrabArc = pi / 40f;
vSlideDegree0 = (vAngle0 + vGrabArc / 2) / pi * 180;
vSlideDegrees = (vAngle1 - vAngle0 - vGrabArc) / pi * 180;
vZeroValue = (0 - vSliderItem.RangeMin) / (vSliderItem.RangeMax - vSliderItem.RangeMin);
////
vHiddenSlice = new UiHoverMeshSlice(gameObject, true);
vHiddenSlice.UpdateSize(1, 1.5f, pArcAngle);
vHiddenSlice.UpdateBackground(Color.clear);
var trackObj = new GameObject("Track");
trackObj.transform.SetParent(gameObject.transform, false);
trackObj.transform.localRotation = Quaternion.AngleAxis(vAngle0 / pi * 180, Vector3.up);
vTrack = new UiItemSliderTrackRenderer(trackObj);
vTrackSegments = new ReadList <DisplayUtil.TrackSegment>();
vTrackCuts = new ReadList <DisplayUtil.TrackSegment>();
////
if (vSliderItem.Ticks > 1)
{
Vector3 quadScale = new Vector3(UiHoverMeshSlice.AngleInset * 2, 0.36f, 0.1f);
float percPerTick = 1 / (float)(vSliderItem.Ticks - 1);
vTickMeshBuilder = new MeshBuilder();
MeshUtil.BuildQuadMesh(vTickMeshBuilder);
vTickMeshBuilder.Commit();
vTickMeshBuilder.CommitColors(Color.clear);
for (int i = 0; i < vSliderItem.Ticks; ++i)
{
var tickObj = new GameObject("Tick" + i);
tickObj.transform.SetParent(gameObject.transform, false);
tickObj.transform.localRotation = Quaternion.AngleAxis(
vSlideDegree0 + vSlideDegrees * i * percPerTick, Vector3.up);
vTicks[i] = tickObj;
var quadObj = new GameObject("Quad");
quadObj.transform.SetParent(tickObj.transform, false);
quadObj.transform.localPosition = new Vector3(0, 0, 1.25f);
quadObj.transform.localRotation = TickQuatRot;
quadObj.transform.localScale = quadScale;
quadObj.AddComponent <MeshRenderer>();
MeshFilter quadFilt = quadObj.AddComponent <MeshFilter>();
quadFilt.sharedMesh = vTickMeshBuilder.Mesh;
}
}
////
vGrabHold = new GameObject("GrabHold");
vGrabHold.transform.SetParent(gameObject.transform, false);
var grabObj = new GameObject("Grab");
grabObj.transform.SetParent(vGrabHold.transform, false);
vGrab = grabObj.AddComponent <UiItemSliderGrabRenderer>();
vGrab.Build(vMenuState, vItemState, vGrabArc, pSettings);
////
vHoverHold = new GameObject("HoverHold");
vHoverHold.transform.SetParent(gameObject.transform, false);
var hoverObj = new GameObject("Hover");
hoverObj.transform.SetParent(vHoverHold.transform, false);
vHover = new UiHoverMeshSlice(hoverObj, false, "Hover");
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
public BaseItemPointsState() {
vWorldPoints = new ReadList<Vector3>();
}
/*--------------------------------------------------------------------------------------------*/
public static void CalcHoverPoints(float pWidth, float pHeight, ReadList<Vector3> pResult) {
int stepsX = (int)Math.Round(pWidth/UiItem.Size)*6;
int stepsY = (int)Math.Round(pHeight/UiItem.Size)*6;
float x0 = -pWidth/2f;
float y0 = -pHeight/2f;
float xInc = pWidth/stepsX;
float yInc = pHeight/stepsY;
pResult.Clear();
for ( int xi = 1 ; xi < stepsX ; xi += 2 ) {
for ( int yi = 1 ; yi < stepsY ; yi += 2 ) {
pResult.Add(new Vector3(x0+xInc*xi, 0, y0+yInc*yi)); //relative to parent
}
}
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
public virtual void Build(IHoverboardPanelState pPanelState,
IHoverboardLayoutState pLayoutState, IBaseItemState pItemState,
IItemVisualSettings pSettings) {
vPanelState = pPanelState;
vLayoutState = pLayoutState;
vItemState = pItemState;
vSettings = (ItemVisualSettingsStandard)pSettings;
vSliderItem = (ISliderItem)vItemState.Item;
vTicks = new GameObject[vSliderItem.Ticks];
vWidth = UiItem.Size*vSliderItem.Width;
vHeight = UiItem.Size*vSliderItem.Height;
vIsVert = (vHeight > vWidth);
vGrabW = 1;
vZeroValue = (0-vSliderItem.RangeMin)/(vSliderItem.RangeMax-vSliderItem.RangeMin);
gameObject.transform.SetParent(gameObject.transform, false);
gameObject.transform.localPosition = new Vector3(vWidth/2, 0, vHeight/2f);
gameObject.transform.localRotation = Quaternion.AngleAxis((vIsVert ? 90 : 0), Vector3.up);
if ( vIsVert ) { //swap dimensions here + rotate graphics later
float tempW = vWidth;
vWidth = vHeight;
vHeight = tempW;
}
vSlideX0 = (vGrabW-vWidth)/2;
vSlideW = vWidth-vGrabW;
////
vHiddenRect = new UiHoverMeshRectBg(gameObject);
vHiddenRect.UpdateSize(vWidth, vHeight);
var trackObj = new GameObject("Track");
trackObj.transform.SetParent(gameObject.transform, false);
trackObj.transform.localPosition = new Vector3(-vWidth/2, 0, 0);
vTrack = new UiItemSliderTrackRenderer(trackObj);
vTrackSegments = new ReadList<DisplayUtil.TrackSegment>();
vTrackCuts = new ReadList<DisplayUtil.TrackSegment>();
////
if ( vSliderItem.Ticks > 1 ) {
Vector3 quadScale = new Vector3(UiHoverMeshRect.SizeInset*2, 0.36f, 0.1f);
float percPerTick = 1/(float)(vSliderItem.Ticks-1);
vTickMeshBuilder = new MeshBuilder();
MeshUtil.BuildQuadMesh(vTickMeshBuilder);
vTickMeshBuilder.Commit();
vTickMeshBuilder.CommitColors(Color.clear);
for ( int i = 0 ; i < vSliderItem.Ticks ; ++i ) {
GameObject tickObj = new GameObject("Tick"+i);
tickObj.transform.SetParent(gameObject.transform, false);
tickObj.transform.localPosition = Vector3.right*(vSlideX0+vSlideW*i*percPerTick);
tickObj.transform.localRotation = TickQuatRot;
tickObj.transform.localScale = quadScale;
tickObj.AddComponent<MeshRenderer>();
MeshFilter tickFilt = tickObj.AddComponent<MeshFilter>();
tickFilt.sharedMesh = vTickMeshBuilder.Mesh;
vTicks[i] = tickObj;
}
}
////
vGrabHold = new GameObject("GrabHold");
vGrabHold.transform.SetParent(gameObject.transform, false);
vGrabHold.transform.localRotation = Quaternion.Inverse(gameObject.transform.localRotation);
var grabObj = new GameObject("Grab");
grabObj.transform.SetParent(vGrabHold.transform, false);
vGrab = grabObj.AddComponent<UiItemSliderGrabRenderer>();
vGrab.IsVert = vIsVert;
vGrab.Build(vPanelState, vLayoutState, vItemState, vSettings);
if ( vIsVert ) {
vGrab.SetCustomSize(vHeight, vGrabW, false);
}
else {
vGrab.SetCustomSize(vGrabW, vHeight, false);
}
////
vHoverHold = new GameObject("HoverHold");
vHoverHold.transform.SetParent(gameObject.transform, false);
var hoverObj = new GameObject("Hover");
hoverObj.transform.SetParent(vHoverHold.transform, false);
vHover = new UiHoverMeshRect(hoverObj, "Hover");
}
public static T Last <T>(this ReadList <T> list)
{
return(list[list.Count - 1]);
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
public virtual void Build(IHovercastMenuState pMenuState, IBaseItemState pItemState,
float pArcAngle, IItemVisualSettings pSettings) {
vMenuState = pMenuState;
vItemState = pItemState;
vAngle0 = -pArcAngle/2f;
vAngle1 = pArcAngle/2f;
vSettings = (ItemVisualSettingsStandard)pSettings;
vSliderItem = (ISliderItem)vItemState.Item;
vTicks = new GameObject[vSliderItem.Ticks];
const float pi = (float)Math.PI;
vGrabArc = pi/40f;
vSlideDegree0 = (vAngle0+vGrabArc/2)/pi*180;
vSlideDegrees = (vAngle1-vAngle0-vGrabArc)/pi*180;
vZeroValue = (0-vSliderItem.RangeMin)/(vSliderItem.RangeMax-vSliderItem.RangeMin);
////
vHiddenSlice = new UiHoverMeshSlice(gameObject, true);
vHiddenSlice.UpdateSize(1, 1.5f, pArcAngle);
vHiddenSlice.UpdateBackground(Color.clear);
var trackObj = new GameObject("Track");
trackObj.transform.SetParent(gameObject.transform, false);
trackObj.transform.localRotation = Quaternion.AngleAxis(vAngle0/pi*180, Vector3.up);
vTrack = new UiItemSliderTrackRenderer(trackObj);
vTrackSegments = new ReadList<DisplayUtil.TrackSegment>();
vTrackCuts = new ReadList<DisplayUtil.TrackSegment>();
////
if ( vSliderItem.Ticks > 1 ) {
Vector3 quadScale = new Vector3(UiHoverMeshSlice.AngleInset*2, 0.36f, 0.1f);
float percPerTick = 1/(float)(vSliderItem.Ticks-1);
vTickMeshBuilder = new MeshBuilder();
MeshUtil.BuildQuadMesh(vTickMeshBuilder);
vTickMeshBuilder.Commit();
vTickMeshBuilder.CommitColors(Color.clear);
for ( int i = 0 ; i < vSliderItem.Ticks ; ++i ) {
var tickObj = new GameObject("Tick"+i);
tickObj.transform.SetParent(gameObject.transform, false);
tickObj.transform.localRotation = Quaternion.AngleAxis(
vSlideDegree0+vSlideDegrees*i*percPerTick, Vector3.up);
vTicks[i] = tickObj;
var quadObj = new GameObject("Quad");
quadObj.transform.SetParent(tickObj.transform, false);
quadObj.transform.localPosition = new Vector3(0, 0, 1.25f);
quadObj.transform.localRotation = TickQuatRot;
quadObj.transform.localScale = quadScale;
quadObj.AddComponent<MeshRenderer>();
MeshFilter quadFilt = quadObj.AddComponent<MeshFilter>();
quadFilt.sharedMesh = vTickMeshBuilder.Mesh;
}
}
////
vGrabHold = new GameObject("GrabHold");
vGrabHold.transform.SetParent(gameObject.transform, false);
var grabObj = new GameObject("Grab");
grabObj.transform.SetParent(vGrabHold.transform, false);
vGrab = grabObj.AddComponent<UiItemSliderGrabRenderer>();
vGrab.Build(vMenuState, vItemState, vGrabArc, pSettings);
////
vHoverHold = new GameObject("HoverHold");
vHoverHold.transform.SetParent(gameObject.transform, false);
var hoverObj = new GameObject("Hover");
hoverObj.transform.SetParent(vHoverHold.transform, false);
vHover = new UiHoverMeshSlice(hoverObj, false, "Hover");
}
/*--------------------------------------------------------------------------------------------*/
private ReadOnlyCollection<PlaneData> GetActiveCursorPlanes(CursorType pType) {
UpdateActiveDelegates();
ReadList<PlaneData> planes;
if ( !vActiveCursorPlaneMap.TryGetValue(pType, out planes) ) {
planes = new ReadList<PlaneData>();
vActiveCursorPlaneMap.Add(pType, planes);
}
else {
planes.Clear();
}
foreach ( IHovercursorDelegate del in vActiveDelegates ) {
planes.AddRange(del.GetActiveCursorPlanes(pType));
}
return vActiveCursorPlaneMap[pType].ReadOnly;
}
