protected override void SetOfflineData(OfflineDatabase offlineDatabase, IOfflineDefinitionLoader offlineDefinitions)
{
TubeData value = offlineDatabase.Read <TubeData>();
value.EquippedTubeId = TubeId;
offlineDatabase.Write(value);
}
private void CreateInteractableTile()
{
_grid = new GameObject[_gridSize, _gridSize];
foreach (GridPlacement placement in _specialTile)
{
GameObject newObj = PlaceTile(placement.xCoordinate, placement.yCoordinate, placement.spriteID);
TubeData tube = newObj.GetComponent <TubeData>();
if (tube != null)
{
tube.SetValue(placement.value);
}
}
for (int y = 0; y < _gridSize; y++)
{
for (int x = 0; x < _gridSize; x++)
{
if (_grid[x, y] == null)
{
PlaceTile(x, y, 0);
}
}
}
}
// consumer to tube
void linkConsumerToTube(int tubeIdx, int consumerIdx) // tube ==> consumer
{
//TubeData tube = tubes[tubeIdx];
//CanTakeState cts = endStates[tube.idxInEndStateArray];
//cts.init();
//cts.tailType = CTS_Consumer;
//cts.tailIdx = consumerIdx;
//cts.addNewHead(CTS_Tube, tubeIdx);
//endStates[tube.idxInEndStateArray] = cts;
CanTakeState cts = headStates[consumers[consumerIdx].headArrayIdx];
cts.init();
cts.tailType = CTS_Consumer;
cts.tailIdx = consumerIdx;
cts.addNewHead(CTS_Tube, tubeIdx);
headStates[consumers[consumerIdx].headArrayIdx] = cts;
TubeData tube = tubes[tubeIdx];
tube.tailArrayIdx = consumers[consumerIdx].headArrayIdx;
tubes[tubeIdx] = tube;
}
private void getTubeData()
{
CPDataEntityCollection cPDataEntityCollection = Service.Get <CPDataEntityCollection>();
if (cPDataEntityCollection.TryGetComponent(cPDataEntityCollection.LocalPlayerHandle, out TubeData component))
{
tubeData = component;
component.OnTubeSelected += onSelectedTubeChanged;
}
}
private void LateUpdate()
{
sampler.Begin();
generic[0].lateUpdate();
generic[1].lateUpdate();
#if !DEBUG_JOB
updateTubesJH.Complete();
#endif
//debugTube();
procTransfer();
// debug
float itemHeight = 0.13f;
itemPositions.Clear();
for (int j = 0; j < tubeCount; ++j)
{
TubeData d = tubes[j];
float offset = d.getOffset();
for (int i = 0; i < d.count; ++i)
{
Vector3 pos = Vector3.zero;
if (i > d.currentIndex)
{
pos = new Vector3(d.positions[i], itemHeight, j);
}
else
{
pos = new Vector3(d.positions[i] + offset, itemHeight, j);
}
itemPositions.Add(pos);
//Debug.DrawLine(pos, pos + Vector3.up, Color.green);
}
}
for (int i = 0; i < itemPositions.Count; ++i)
{
if (i >= itemObjs.Count)
{
GameObject newItemObj = GameObject.Instantiate(objPrefab, this.transform) as GameObject;
itemObjs.Add(newItemObj);
}
itemObjs[i].transform.localPosition = itemPositions[i];
itemObjs[i].SetActive(true);
}
for (int i = itemPositions.Count; i < itemObjs.Count; ++i)
{
itemObjs[i].SetActive(false);
}
currentIndex0 = tubes[0].currentIndex;
count0 = tubes[0].count;
dbgArray = tubes[0].positions;
}
// link converter to tube
void linkConverterToTube(int tubeIdx, int converterIdx) // tube ==> converter
{
TubeData tube = tubes[tubeIdx];
CanTakeState cts = headStates[tube.tailArrayIdx];
cts.tailType = CTS_Converter;
cts.tailIdx = converterIdx;
cts.addNewHead(CTS_Tube, tubeIdx);
headStates[tube.tailArrayIdx] = cts;
converters[converterIdx].headArrayIdx = tube.tailArrayIdx;
}
protected override void PerformOfflineAction(OfflineDatabase offlineDatabase, IOfflineDefinitionLoader offlineDefinitions)
{
TubeData value = offlineDatabase.Read <TubeData>();
value.EquippedTubeId = TubeId;
offlineDatabase.Write(value);
SignedEquipTubeResponse = new SignedResponse <EquipTubeResponse>
{
Data = new EquipTubeResponse
{
tubeId = TubeId
}
};
}
public virtual void Awake()
{
OnGetTube = delegate { };
OnDropTube = delegate { };
OnDeleteTube = delegate { };
OnGetSkill = delegate { };
OnDeleteSkill = delegate { };
OnCreateSkill = delegate { };
tubeData = FindObjectOfType <DataManager>().TubeData;
tubes = new List <Tube>();
skills = new List <Skill>();
}
void linkConverterToTubes(int[] tubeIdx, int converterIdx) // tubes ==> converter
{
ConverterData conv = converters[converterIdx];
//TubeData tube = tubes[tubeIdx];
CanTakeState cts = headStates[conv.headArrayIdx];
cts.init();
cts.tailType = CTS_Converter;
cts.tailIdx = converterIdx;
for (int i = 0; i < tubeIdx.Length; ++i)
{
cts.addNewHead(CTS_Tube, tubeIdx[i]);
TubeData tube = tubes[tubeIdx[i]];
tube.tailArrayIdx = conv.headArrayIdx;
tubes[tubeIdx[i]] = tube;
}
headStates[conv.headArrayIdx] = cts;
}
protected override void SetOfflineData(OfflineDatabase offlineDatabase, IOfflineDefinitionLoader offlineDefinitions)
{
TubeData value = offlineDatabase.Read <TubeData>();
value.EquippedTubeId = SignedJoinRoomData.Data.selectedTubeId;
offlineDatabase.Write(value);
ClubPenguin.Net.Offline.ConsumableInventory value2 = offlineDatabase.Read <ClubPenguin.Net.Offline.ConsumableInventory>();
value2.Inventory = SignedJoinRoomData.Data.playerRoomData.consumableInventory.inventoryMap;
offlineDatabase.Write(value2);
ClubPenguin.Net.Offline.PlayerAssets value3 = offlineDatabase.Read <ClubPenguin.Net.Offline.PlayerAssets>();
value3.Assets = SignedJoinRoomData.Data.playerRoomData.assets;
offlineDatabase.Write(value3);
ClubPenguin.Net.Offline.PlayerOutfitDetails value4 = offlineDatabase.Read <ClubPenguin.Net.Offline.PlayerOutfitDetails>();
value4.Parts = new List <CustomEquipment>(SignedJoinRoomData.Data.playerRoomData.outfit.parts);
offlineDatabase.Write(value4);
ClubPenguin.Net.Offline.Profile value5 = offlineDatabase.Read <ClubPenguin.Net.Offline.Profile>();
value5.Colour = SignedJoinRoomData.Data.playerRoomData.profile.colour;
value5.DateCreated = DateTime.UtcNow.AddDays(-1 * SignedJoinRoomData.Data.playerRoomData.profile.daysOld).GetTimeInMilliseconds();
offlineDatabase.Write(value5);
SetProgressOperation.SetOfflineQuestStateCollection(offlineDatabase, SignedJoinRoomData.Data.playerRoomData.quests);
}
void procTransfer()
{
// generator output
for (int i = 0; i < generic[0].tempGenericUpdateOps.Length; ++i)
{
if (generic[0].tempGenericUpdateOps[i] != 0)
{
GeneratorData gen = generators[i];
CanTakeState cts = headStates[gen.tailArrayIdx];
// check if this generator has space at its end?
if (tubes[cts.tailIdx].hasSpace(gen.itemId))
{
tubes[cts.tailIdx].push(gen.itemId);
// consume a unit of resource.
//Debug.LogFormat("generator {0} makes one at {1}", i, elapsedTime);
gen.pop();
generators[i] = gen;
}
else
{
Debug.LogFormat("generator {0} got blocked.", i);
gen.block();
generators[i] = gen;
}
}
}
// tubes output
for (int i = 0; i < arrayLength; ++i)
{
if (updateTubesJob.outputOps[i] != 0)
{
CanTakeState cts = headStates[tubes[i].tailArrayIdx];
TubeData srcTube = tubes[i];
if (cts.tailType == CTS_Tube) // tube
{
if (tubes[cts.tailIdx].hasSpace(srcTube.itemId))
{
srcTube.pop();
tubes[cts.tailIdx].push(srcTube.itemId);
Debug.LogFormat("{0} Tube {1} pops into {2}.", elapsedTime, i, cts.tailIdx);
cts = headStates[srcTube.headArrayIdx];
cts.invokeUnblock();
}
else
{
Debug.LogFormat("{0} Tube {1} blocked", elapsedTime, i);
srcTube.block();
}
}
else if (cts.tailType == CTS_Converter) // converter
{
ConverterData conv = converters[cts.tailIdx];
if (conv.hasSpace(srcTube.itemId))
{
srcTube.pop();
if (converters[cts.tailIdx].push(srcTube.itemId))
{
Debug.LogFormat("{0} Tube {1} pops into converter {2}.", elapsedTime, i, cts.tailIdx);
cts = headStates[srcTube.tailArrayIdx];
cts.invokeUnblock();
}
}
else
{
srcTube.block();
Debug.LogFormat("{0} Tube {1} got blocked by converter {2}.", elapsedTime, i, cts.tailIdx);
}
//Debug.LogFormat("{0} converter @ {1}, {2}", elapsedTime, conv.srcCurrent[0], conv.srcCurrent[1]);
}
else if (cts.tailType == CTS_Consumer) // consumer
{
ConsumerData consData = consumers[cts.tailIdx];
consData.attemptToTake(srcTube.itemId);
srcTube.pop();
consumers[cts.tailIdx] = consData;
Debug.LogFormat("{0} Tube {1} pops into consumer {2}.", elapsedTime, i, cts.tailIdx);
cts = headStates[srcTube.headArrayIdx];
cts.invokeUnblock();
}
tubes[i] = srcTube;
}
}
// converter output
for (int i = 0; i < generic[1].tempGenericUpdateOps.Length; ++i)
{
if (generic[1].tempGenericUpdateOps[i] != 0)
{
CanTakeState cts = headStates[converters[i].tailArrayIdx];
ConverterData conv = converters[i];
// check if this converter has space at its end?
if (cts.tailType == CTS_Tube) // the end entity of this converter is a tube
{
if (tubes[cts.tailIdx].hasSpace(conv.targetId))
{
Debug.Log("converter out!");
tubes[cts.tailIdx].push(conv.targetId);
//headStates[conv.headArrayIdx].invokeUnblock();
Debug.LogFormat("{0} converter {1} pops into tube {2}.", elapsedTime, i, cts.tailIdx);
}
else
{
//head_cts
Debug.LogFormat("{0} converter {1} got blocked by tube {2}.", elapsedTime, i, cts.tailIdx);
}
}
else if (cts.tailType == CTS_Converter) // converter
{
Debug.LogFormat("{0} converter {1} pops into converter {2}.", elapsedTime, i, cts.tailIdx);
}
if (conv.allMet())
{
converters[i].startUpdate();
headStates[conv.headArrayIdx].invokeUnblock();
}
}
}
sampler.End();
}
void debugTube()
{
// generator
for (int i = 0; i < generic[0].tempGenericUpdateOps.Length; ++i)
{
if (generic[0].tempGenericUpdateOps[i] != 0)
{
GeneratorData gen = generators[i];
CanTakeState cts = headStates[gen.tailArrayIdx];
// check if this generator has space at its end?
if (tubes[cts.tailIdx].hasSpace(gen.itemId))
{
tubes[cts.tailIdx].push(gen.itemId);
// consume a unit of resource.
gen.pop();
generators[i] = gen;
}
else
{
gen.block();
}
}
}
for (int i = 0; i < arrayLength; ++i)
{
int op = updateTubesJob.outputOps[i];
if (op != 0)
{
TubeData srcTube = tubes[i];
if (endState_Open)
{
srcTube.pop();
CanTakeState cts = headStates[srcTube.headArrayIdx];
cts.invokeUnblock();
}
else
{
srcTube.block();
}
//CanTakeState cts = endStates[tubes[i].idxInEndStateArray];
//if (cts.type == 0) // tube
//{
// if (tubes[cts.idx].hasSpace(srcTube.itemId)) {
// srcTube.pop();
// tubes[cts.idx].push(srcTube.itemId);
// // consume a unit of resource.
// }
// else {
// srcTube.saturate();
// }
//}
//else if (cts.type == 1) // converter
//{
// ConverterData conv = converters[cts.idx];
// if (conv.hasSpace(srcTube.itemId)) {
// srcTube.pop();
// conv.push(srcTube.itemId);
// converters[cts.idx] = conv;
// }
// else {
// srcTube.saturate();
// }
//}
//else if (cts.type == 2) { // consumer
// ConsumerData consData = consumers[cts.idx];
// consData.attemptToTake(srcTube.itemId);
// srcTube.pop();
// consumers[cts.idx] = consData;
//}
tubes[i] = srcTube;
}
}
if (prevEndState0 != endState_Open)
{
if (endState_Open)
{
tubes[0].unblock();
CanTakeState cts = headStates[tubes[0].headArrayIdx];
cts.invokeUnblock();
}
prevEndState0 = endState_Open;
}
}
