private bool Move(SlotComponent slot, int step)
{
if (current != slot)
{
if (slot.IsEmpty)
{
slot.ReserveHold(this);
SetSlot(slot);
}
else if (slot.IsMergable(this))
{
slot.ReserveMerger(this);
SetSlot(slot);
}
else
{
Debug.LogError("maybe wrong box moving logic (id:" + id + ")");
return(false);
}
float t = Mathf.Clamp(Mathf.Abs(step), 0, 3) * 0.05f;
tween = true;
LeanTween.move(gameObject, slot.transform.position, t).setEase(LeanTweenType.linear).setOnComplete(HandleMove);
return(true);
}
return(false);
}
public void SetSlot(SlotComponent slot)
{
if (current != null)
{
current.Clear();
}
current = slot;
}
public static void AddComponents(Entity subject, IntVector2 relativeDirection, int pierceIncrease)
{
ItemBase.AddComponents(subject);
// Item stuff
Equippable.AddTo(subject, ShieldComponent.Hookable);
SlotComponent.AddTo(subject, Slot.Id);
}
public static void AddComponents(Entity subject)
{
ItemBase.AddComponents(subject);
Equippable.AddTo(subject, null);
SlotComponent.AddTo(subject, Slot.Id);
BowComponent.AddTo(subject);
ItemActivation.AddTo(subject, GetChargeAction);
}
public static void AddComponents(Entity subject)
{
ItemBase.AddComponents(subject);
// Item stuff
Equippable.AddTo(subject, null);
SlotComponent.AddTo(subject, Slot.Id);
ItemActivation.AddTo(subject, GetAction);
}
private void AddSlotComponent_ProductMode()
{
for (int i = 0; i < slotMax; i++)
{
if (i + 1 <= componentData_list.Count)
{
SlotComponent slotComponent_temp = Instantiate(slotComponent, content).GetComponent <SlotComponent>();
slotComponent_temp.ProcessMode(componentData_list[i]);
}
}
}
public void EquipSimple()
{
// The id of an unregistered factory is 0:0
var item = World.Global.SpawnEntity(itemFactory, IntVector2.Zero);
Equippable.AddTo(item, null);
var entity = World.Global.SpawnEntity(entityFactory, new IntVector2(1, 0));
var inventory = entity.GetInventory();
Assert.Zero(inventory._generalStorage.Count);
Assert.Zero(inventory._excess.Count);
Assert.Zero(inventory._slots.Count);
Assert.False(inventory.ContainsItem(item.typeId));
// Move onto the item
var moveAction = Moving.Action.Compile(new IntVector2(-1, 0));
entity.GetActing().ActivateWith(moveAction);
Assert.AreEqual(new IntVector2(0, 0), entity.GetTransform().position);
Assert.True(inventory.ContainsItem(item.typeId));
inventory.Remove(item.typeId);
Assert.False(inventory.ContainsItem(item.typeId));
// Reset acting flags (so that we can act again)
// acting._flags = 0;
// Move the entity back
entity.GetTransform().ResetPositionInGrid(new IntVector2(1, 0));
// Spawn two items this time
// Since two of the same items without a slot is not allowed, assign them a slot
var slot = new Slot(false); slot.Id = new Identifier(3, 1);
var item1 = World.Global.SpawnEntity(itemFactory, IntVector2.Zero);
Equippable.AddTo(item1, null);
SlotComponent.AddTo(item1, slot.Id);
var item2 = World.Global.SpawnEntity(itemFactory, IntVector2.Zero);
Equippable.AddTo(item2, null);
SlotComponent.AddTo(item2, slot.Id);
// item 1 gets picked up, then immediately replaced by item 2.
// item 1 is dropped back as excess.
entity.GetActing().ActivateWith(moveAction);
Assert.True(inventory.ContainsItem(item2.typeId));
Assert.AreSame(inventory.GetItem(item2.typeId), item2);
Assert.AreSame(item1.GetTransform().GetAllFromLayer(Layers.ITEM).Single().entity, item1);
Assert.AreSame(inventory.GetItemFromSlot(slot.Id), item2);
}
public void OnErase(SlotComponent slot)
{
BoxComponent box = slot.box;
slot.Clear();
boxCount--;
boxes.Remove(box.id);
GameObject.DestroyImmediate(box.gameObject);
// AudioPlayerComponent.Play ("fx_combo");
// EffectComponent.Show (effectBang [0], slot.transform.position);
blocked = false;
}
private void AddSlotComponent(List <ComponentData> componentData_list, Transform content)
{
foreach (ComponentData componentData in componentData_list)
{
SlotComponent slotComponent_temp = Instantiate(slotComponent, content).GetComponent <SlotComponent>();
slotComponent_temp.ResearchMode(componentData,
() =>
{
memberPanel.gameObject.SetActive(true);
RefreshSlotEmployee(componentData);
});
}
}
public void OnMerge(SlotComponent slot)
{
BoxComponent box1 = slot.box;
BoxComponent box2 = slot.target;
int level = box1.level + 1;
if (level >= boxPrefabs.Length)
{
Debug.LogError("biggest box can't merge");
return;
}
slot.Clear();
boxCount -= 2;
boxes.Remove(box1.id);
boxes.Remove(box2.id);
GameObject.DestroyImmediate(box1.gameObject);
GameObject.DestroyImmediate(box2.gameObject);
New(level, slot);
// insert score increament
bool isWin = AppendScore(level);
// Vector3 pos = slot.transform.position;
// insert effect 'bang'
// EffectComponent.Show (effectBang [level], pos);
// insert coin increment
// if (EffectComponent.Show (effectCoin [level], pos) != null) {
// AudioPlayerComponent.Play ("fx_coin");
// game.AppendCoin();
// }
// insert effect 'combo'
// if (EffectComponent.Show (effectCombo [(Mathf.Min(combo, effectCombo.Length-1))], pos) != null) {
// AudioPlayerComponent.Play ("fx_combo");
// }
if (isWin)
{
Victory();
blocked = true;
}
else
{
OnMoved(slot);
}
}
private void AddSlotComponent_CreateMode()
{
for (int i = 0; i < slotMax; i++)
{
if (i + 1 <= componentData_list.Count)
{
SlotComponent slotComponent_temp = Instantiate(slotComponent, content).GetComponent <SlotComponent>();
slotComponent_temp.CreateProductMode(componentData_list[i], componentData_list, RefreshComponentCard_CreateMode);
}
else
{
Instantiate(selectEmployeeButton, content).GetComponent <SelectComponentButton>().Set(categorieType, componentType, componentData_list, RefreshComponentCard_CreateMode, slotMax);
}
}
}
public GameObject Create()
{
GameObject slotObject = gridItemFactory.Create();
GameObject pieceObject = pieceFactory.Create();
pieceObject.transform.position = slotObject.transform.position;
pieceObject.transform.SetParent(slotObject.transform);
SlotComponent slotComponent = slotObject.GetComponent <SlotComponent>();
slotComponent.Construct(slotSelection);
PieceDestinationControllerComponent pieceDestinationController = slotObject.GetComponent <PieceDestinationControllerComponent>();
PieceTranslationControllerComponent pieceTranslationController = pieceObject.GetComponent <PieceTranslationControllerComponent>();
pieceDestinationController.Construct(pieceTranslationController, new StubWinController());
return(slotObject);
}
public bool Up()
{
if (current)
{
SlotComponent mUp = current.MostUp(this);
if (Move(mUp, mUp.y - current.y))
{
animator.SetTrigger("trigger_up");
}
else
{
return(false);
}
}
else
{
Debug.LogError("slot reference missing (id:" + id + ")");
}
return(true);
}
public bool Right()
{
if (current)
{
SlotComponent mRight = current.MostRight(this);
if (Move(mRight, mRight.x - current.x))
{
animator.SetTrigger("trigger_right");
}
else
{
return(false);
}
}
else
{
Debug.LogError("slot reference missing (id:" + id + ")");
}
return(true);
}
public bool Down()
{
if (current)
{
SlotComponent mDown = current.MostDown(this);
if (Move(mDown, mDown.y - current.y))
{
animator.SetTrigger("trigger_down");
}
else
{
return(false);
}
}
else
{
Debug.LogError("slot reference missing (id:" + id + ")");
}
return(true);
}
public void MoveToSphere(SlotComponent slot)
{
OnTable = false;
var slotTransform = slot.transform;
var selectedDetailParent = transform.parent;
selectedDetailParent.transform.parent = ModuleController.Instance.SphereDetails.transform;
ModuleController.Instance.SetDetailPositionOnSphere(slot, this);
var mini = 0f;
var minDist = float.MaxValue;
var selectedDetailVerts = Angles;
var slotDetailVerts = slot.Angles;
for (float i = 0; i < 360; i += 0.5f)
{
var dist = selectedDetailVerts.Sum(selecteDetailVert =>
slotDetailVerts.Min(slotDetailVert =>
Vector3.Distance(slotTransform.TransformPoint(slotDetailVert),
transform.TransformPoint(selecteDetailVert))));
if (dist < minDist)
{
minDist = dist;
mini = i;
}
var eulerAngles = selectedDetailParent.eulerAngles;
selectedDetailParent.eulerAngles = new Vector3(eulerAngles.x, eulerAngles.y, i);
}
selectedDetailParent.rotation = slotTransform.parent.transform.rotation;
var angles = selectedDetailParent.eulerAngles;
angles = new Vector3(angles.x, angles.y, mini);
selectedDetailParent.eulerAngles = angles;
}
public void OnMoved(SlotComponent slot)
{
if (IsMovable())
{
Flash(imageFrame, 0.3f, 0f, 0.25f);
RandomNew();
bool gameover = true;
foreach (SlotComponent s in slots)
{
if (s.IsEmpty || s.IsNeighbor())
{
gameover = false;
break;
}
}
if (gameover)
{
NoMoreMove();
blocked = true;
}
}
}
public BoxComponent New(int level = 0, SlotComponent slot = null)
{
level = Mathf.Clamp(level, 0, boxPrefabs.Length - 1);
// set position
if (slot == null)
{
ArrayList list = new ArrayList();
foreach (SlotComponent s in slots)
{
if (s.IsEmpty)
{
list.Add(s);
}
}
if (list.Count == 0)
{
Debug.LogError("nowhere found to create box");
return(null);
}
slot = list[(Random.Range(0, list.Count))] as SlotComponent;
}
// instantiate box
count++;
boxCount++;
BoxComponent box = Instantiate(boxPrefabs[level], slot.transform.position, Quaternion.identity) as BoxComponent;
box.transform.SetParent(transform, false);
box.transform.position = slot.transform.position;
box.Init(count.ToString(), level, slot);
slot.ReserveHold(box);
boxes.Add(box.id, box);
return(box);
}
private void AddSlotComponent()
{
if (categorieType == CategorieType.Game && componentType == ComponentType.Genre)
{
List <ComponentData> componentDatas = StartupStructure.instance.GetGenreResearchList();
for (int i = 0; i < componentDatas.Count; i++)
{
ComponentData componentData_temp = componentDatas[i];
SlotComponent slotComponent_temp = Instantiate(slotComponent, content).GetComponent <SlotComponent>();
if (!component_list.Contains(componentDatas[i]) && component_list.Count < maxComponentContent)
{
slotComponent_temp.ComponentListAddMode(componentData_temp, component_list, refreshConponentCard);
}
else
{
slotComponent_temp.DisplayOnlyMode(componentData_temp);
}
}
}
else if (categorieType == CategorieType.Game && componentType == ComponentType.Platform)
{
List <ComponentData> componentDatas = StartupStructure.instance.GetPlatformResearchList();
for (int i = 0; i < componentDatas.Count; i++)
{
ComponentData componentData_temp = componentDatas[i];
SlotComponent slotComponent_temp = Instantiate(slotComponent, content).GetComponent <SlotComponent>();
if (!component_list.Contains(componentDatas[i]) && component_list.Count < maxComponentContent)
{
slotComponent_temp.ComponentListAddMode(componentData_temp, component_list, refreshConponentCard);
}
else
{
slotComponent_temp.DisplayOnlyMode(componentData_temp);
}
}
}
else if (categorieType == CategorieType.Game && componentType == ComponentType.Feature)
{
List <ComponentData> componentDatas = StartupStructure.instance.GetFeatureResearchList();
for (int i = 0; i < componentDatas.Count; i++)
{
ComponentData componentData_temp = componentDatas[i];
SlotComponent slotComponent_temp = Instantiate(slotComponent, content).GetComponent <SlotComponent>();
if (!component_list.Contains(componentDatas[i]) && component_list.Count < maxComponentContent)
{
slotComponent_temp.ComponentListAddMode(componentData_temp, component_list, refreshConponentCard);
}
else
{
slotComponent_temp.DisplayOnlyMode(componentData_temp);
}
}
}
else if (categorieType == CategorieType.Game && componentType == ComponentType.Graphic)
{
List <ComponentData> componentDatas = StartupStructure.instance.GetGraphicResearchList();
for (int i = 0; i < componentDatas.Count; i++)
{
ComponentData componentData_temp = componentDatas[i];
SlotComponent slotComponent_temp = Instantiate(slotComponent, content).GetComponent <SlotComponent>();
if (!component_list.Contains(componentDatas[i]) && component_list.Count < maxComponentContent)
{
slotComponent_temp.ComponentListAddMode(componentData_temp, component_list, refreshConponentCard);
}
else
{
slotComponent_temp.DisplayOnlyMode(componentData_temp);
}
}
}
else if (categorieType == CategorieType.Game && componentType == ComponentType.Camera)
{
List <ComponentData> componentDatas = StartupStructure.instance.GetCameraResearchList();
for (int i = 0; i < componentDatas.Count; i++)
{
ComponentData componentData_temp = componentDatas[i];
SlotComponent slotComponent_temp = Instantiate(slotComponent, content).GetComponent <SlotComponent>();
if (!component_list.Contains(componentDatas[i]) && component_list.Count < maxComponentContent)
{
slotComponent_temp.ComponentListAddMode(componentData_temp, component_list, refreshConponentCard);
}
else
{
slotComponent_temp.DisplayOnlyMode(componentData_temp);
}
}
}
else if (categorieType == CategorieType.Game && componentType == ComponentType.Theme)
{
List <ComponentData> componentDatas = StartupStructure.instance.GetThemeResearchLst();
for (int i = 0; i < componentDatas.Count; i++)
{
ComponentData componentData_temp = componentDatas[i];
SlotComponent slotComponent_temp = Instantiate(slotComponent, content).GetComponent <SlotComponent>();
if (!component_list.Contains(componentDatas[i]) && component_list.Count < maxComponentContent)
{
slotComponent_temp.ComponentListAddMode(componentData_temp, component_list, refreshConponentCard);
}
else
{
slotComponent_temp.DisplayOnlyMode(componentData_temp);
}
}
}
}
public void Init(string id, int level, SlotComponent slot)
{
this.id = id;
this.level = level;
this.current = slot;
}
