public static TileEntity instantiateTileEntity(DungeonParameter dgparam, TileBasis tile, Vector2 pos,GameObject parent,bool isactive)
{
init(dgparam);
GameObject obj;
switch (tile.Type)
{
case TileBasis.TileType.ROAD:
obj = GameObject.Instantiate(RoadObj.gameObject) as GameObject;
break;
case TileBasis.TileType.WALL:
obj = GameObject.Instantiate(WallObj.gameObject) as GameObject;
break;
case TileBasis.TileType.WATERWAY:
obj = GameObject.Instantiate(WaterwayObj.gameObject) as GameObject;
break;
default:
obj = GameObject.Instantiate(WallObj.gameObject) as GameObject;
break;
}
//obj.SetActive(true);
obj.transform.position = pos;
obj.SetActive(false);
//obj.GetComponent<SpriteRenderer>().enabled = isvisible;
obj.transform.SetParent(parent.transform,false);
TileEntity ret = obj.GetComponent<TileEntity>();
ret.setActive(isactive);
return ret;
}
private void SubscribeItemEvent()
{
var createItem = ItemManager.instance.OnCreateItemAsObservable();
// キーを取得した時
createItem
.Where(item => item.itemData.type == ItemType.Key)
.SelectMany(item => item.OnTakeAsObservable())
.Subscribe(_ =>
{
var param = parameter;
param.getKeyNum++;
parameter = param;
});
// 宝石を取得した時
createItem
.Where(item => item.itemData.type == ItemType.Jewel)
.SelectMany(item => item.OnTakeAsObservable().Select(_ => item.itemData.attribute))
.Subscribe(attribute =>
{
TakePowerStock(attribute);
var param = parameter;
param.silling += 1000;
parameter = param;
});
// 魂を取得したとき
createItem
.Where(item => item.itemData.type == ItemType.Soul)
.SelectMany(item => item.OnTakeAsObservable().Select(_ => item.itemData.attribute))
.Subscribe(FillPowerStock);
}
public void RecoveryHp(int value)
{
var param = parameter;
param.hp += value;
parameter = param;
}
public MapGenerator2(DungeonParameter param, MonoBehaviour obj,RndGenerator rnd)
{
DgParam = param;
this.obj = obj;
Rnd = rnd;
reset();
}
private static float calcStartRank(DungeonParameter dgparam)
{
float ret = 0;
float x = dgparam.Rank / (dgparam.MaxFloorCount - 1 + dgparam.Rank);
float y = Mathf.Pow(dgparam.Rank, x);
ret = x * y;
return ret;
}
private void UpdatePowerStock(DungeonParameter parameter)
{
Enumerable.Range(0, 4)
.ToList()
.ForEach(index =>
{
charactersPowerStocks[index].stock = parameter.stocks[index];
});
}
private void SubscribePlayerWalkEvent()
{
// プレイヤーが歩き終わったあと
DungeonManager.instance.player.OnWalkEndAsObservable()
.Subscribe(_ =>
{
var param = parameter;
param.sp -= 1;
parameter = param;
});
}
protected override void setItems(DungeonParameter dgparam)
{
base.setItems(dgparam);
var items = dgparam.getDungeonClearTreasures();
var center = room.CenterToInt;
for (int i = 0; i < items.Count; i++) {
int x = (int)center.x + (i*2 - 2)%4;
int y = (int)center.y - (i*2 / 7);
ObjectEntityFactory.enableItemEntity(items[i], new Vector2(x,y));
}
}
public DungeonParameter createParameter(string dungeonname = "")
{
DgParameter = DungeonParameter.createDefaultDungeonParameter();
initalcomposition();
maincomposition();
finalcomposition();
// 各パラメータが上限・下限に収まるようにまるめる
DgParameter.correctParamterValue();
// 開始ランクと増分ランクを算出する
settleStartRank();
settleIncreaseRank();
// 最終ステップまでの補正込みで出現テーブルを算出する
settleAppranceTable();
DgParameter.DungeonName = dungeonname;
return DgParameter;
}
private void SubscribeBlockOpertateEvent()
{
var blockManager = BlockManager.instance;
// ブロックの破壊時
blockManager.OnCreateBlockAsObservable()
.SelectMany(block => block.OnBreakAsObservable())
.Subscribe(_ =>
{
var param = parameter;
param.sp -= 2;
parameter = param;
});
// ブロックのリセット時
blockManager.OnRandomizeAsObservable()
.Subscribe(_ =>
{
var param = parameter;
param.sp -= 2;
parameter = param;
});
}
protected virtual void setTraps(DungeonParameter dgparam)
{
}
private static void init(DungeonParameter dgparam)
{
if (Init) return;
GameObject obj = GameObject.Instantiate(org);
obj.SetActive(false);
TileEntity ret = obj.GetComponent<TileEntity>();
ret.init(new Wall(),dgparam);
WallObj = ret;
//
obj = GameObject.Instantiate(org);
obj.SetActive(false);
ret = obj.GetComponent<TileEntity>();
ret.init(new Road(),dgparam);
RoadObj = ret;
//
obj = GameObject.Instantiate(org);
obj.SetActive(false);
ret = obj.GetComponent<TileEntity>();
ret.init(new WaterWay(),dgparam);
WaterwayObj = ret;
Init = true;
}
public IEnumerator OnPlayEndBanner(Action endCb, float fSec) => default; // 0x007BE110-0x007BE1A0
private void UpdateDungeonParameterFromNative(DungeonParameter dungeonParameter)
{
} // 0x007BE1D0-0x007BE1E0
private void UpdateSillingValue(DungeonParameter parameter)
{
sillingValue.value = parameter.silling;
}
private void UpdateSpValue(DungeonParameter parameter)
{
spValue.value = parameter.sp;
maxSpValue.value = parameter.maxSp;
}
protected virtual void setEnemys(DungeonParameter dgparam)
{
}
public void init(DungeonParameter param)
{
CurrentDungeonParameter = param;
CurrentTurnCount = 0;
TotalTurnCount = 0;
Enemys = new List<MyCharacterController>();
Items = new List<ItemEntity>();
Traps = new List<TrapEntity>();
createUnknownItemNameTable(param.DistributionTable);
param.DistributionTable.setUnknownItemName(BookUnknownNames);
param.DistributionTable.setUnknownItemName(CaneUnknownNames);
param.DistributionTable.setUnknownItemName(PotUnknownNames);
param.DistributionTable.setUnknownItemName(PotionUnknownNames);
param.DistributionTable.setUnknownItemName(BangleUnknownNames);
ItemDetectionLevelTable = new Dictionary<Type, ItemBasis.DetectionLevel>();
setInitalDetectionLevel();
MoveResevationList = new Deque<EnemyController>();
GameController.PlayerUIController.setFloorNum(CurrentFloorNumber);
ListOfUnpaidCommodityWhichNotExistOnFiled = new List<ItemBasis>();
TileTypeTable = new TileBasis.TileType[(int)param.MaxMapSize.x][];
for (int x = 0; x < TileTypeTable.GetLength(0); x++) {
TileTypeTable[x] = new TileBasis.TileType[(int)param.MaxMapSize.y];
for (int y = 0; y < (int)param.MaxMapSize.y; y++)
{
TileTypeTable[x][y] = TileBasis.TileType.UNBREAKABLEWALL;
}
}
}
private void finalcomposition()
{
List<DgCOperatorBasis> ops = new List<DgCOperatorBasis>();
foreach (IDungeonMaterial material in DgMaterials)
{
ops.AddRange(material.finalcomposition());
}
ops.Sort();
foreach (DgCOperatorBasis op in ops)
{
DgParameter = op.operate(DgParameter);
}
}
public MapGenerator(DungeonParameter param)
{
DungeonParameter = param;
}
public DungeonCompositor(DungeonParameter dgparam)
{
DgMaterials = new List<IDungeonMaterial>();
DgParameter = dgparam;
}
public static IEnumerator ExecuteResultProcess(ResultProcessParameter param) => default; // 0x007BE1F0-0x007BE260
// [IteratorStateMachine] // 0x00623890-0x00623900
public IEnumerator MainLoop(DungeonParameter dungeonParameter) => default; // 0x007BE290-0x007BE310
} // 0x007BE1D0-0x007BE1E0
private void GetDungeonParameterBackup(DungeonParameter dungeonParameter)
{
} // 0x007BE1E0-0x007BE1F0
protected virtual void setItems(DungeonParameter dgparam)
{
}
public int indexOf(DungeonParameter value)
{
return Array.IndexOf<DungeonParameter>(table,value);
}
private void UpdateHpValue(DungeonParameter parameter)
{
hpValue.value = parameter.hp;
maxHpValue.value = parameter.maxHp;
}
public void init(TileBasis tile,DungeonParameter dgparam)
{
//Debug.Log(tile.Type);
Type = tile.Type;
string newtag = "";
//Sprite newsprite = null;
switch (Type)
{
case TileBasis.TileType.ROAD:
newtag = TagList.Road;
SpriteRenderer.sprite = dgparam!=null? dgparam.CurrentRoadSprite:GameSkins.getTileSprite(TileBasis.TileType.ROAD,0);
break;
case TileBasis.TileType.WALL:
newtag = TagList.Wall;
SpriteRenderer.sprite = dgparam != null ? dgparam.CurrentWallSprite : GameSkins.getTileSprite(TileBasis.TileType.WALL,0); ;
break;
case TileBasis.TileType.WATERWAY:
newtag = TagList.Wall;
SpriteRenderer.sprite = dgparam != null ? dgparam.CurrentWaterWaySprite : GameSkins.getTileSprite(TileBasis.TileType.WATERWAY,0); ;
break;
case TileBasis.TileType.UNBREAKABLEWALL:
newtag = TagList.Wall;
SpriteRenderer.sprite = dgparam != null ? dgparam.CurrentWallSprite : GameSkins.getTileSprite(TileBasis.TileType.WALL, 0); ;
break;
}
Entity = tile;
this.transform.tag = newtag;
SpriteRenderer.sortingLayerName = newtag;
gameObject.layer = LayerMask.NameToLayer(newtag);
this.name = Type.ToString();
}
private void UpdateKeyValue(DungeonParameter parameter)
{
getKeyValue.value = parameter.getKeyNum;
allKeyValue.value = parameter.allKeyNum;
}
public static TileEntity instantiateTileEntity(DungeonParameter dgparam, TileBasis tile, Vector2 pos)
{
GameObject parent;
switch (tile.Type)
{
case TileBasis.TileType.ROAD:
parent = RoadParent;
break;
case TileBasis.TileType.WALL:
parent = WallParent;
break;
case TileBasis.TileType.WATERWAY:
parent = WallParent;
break;
default:
parent = RoadParent;
break;
}
return instantiateTileEntity(dgparam,tile, pos, parent,true);
}
public static DungeonParameter createDefaultDungeonParameter()
{
DungeonParameter ret = new DungeonParameter(RankLowerLimit, Vector2.zero, Vector2.zero, AverageRoomCountLowerLimit,
MaxFloorCountLowerLimit, 1f, DefaultElemntalPowers, DefaultItemDetectionPowers, new ObjectDistributionTable());
ret.DistributionTable.initTable(GameController.ObjectList);
return ret;
}
} // 0x007BEB70-0x007BEC70
// Methods
// [IteratorStateMachine] // 0x006222B0-0x00622320
public static IEnumerator Execute(DungeonParameter dungeonParameter) => default; // 0x007BA2F0-0x007BA360
public static DungeonParameter getDebugParameter2()
{
DungeonParameter ret = new DungeonParameter(100, new Vector2(48, 32), new Vector2(6, 6), 4, 5, 0.8f, DefaultElemntalPowers, DefaultItemDetectionPowers, new ObjectDistributionTable());
ret.DistributionTable.initTable(GameController.ObjectList);
ret.AllowedCreatingMonsterHouse = true;
ret.AllowedRankOfMonsterHouseCreation = 1;
ret.ProbabilityOfCreatingMonsterHouse = 0f;
ret.AllowedCreatingShopRoom = true;
ret.AllowedRankOfShopRoomCreation = 1;
ret.ProbabilityOfCreatingShopRoom = 1f;
Debug.Log("ItemTable: " + ret.DistributionTable.ItemTable.Count);
ret.DistributionTable.ItemTable.ForEach(delegate (ObjectDistributionElements<ItemBasis> item) {
//Debug.Log(item.Element.Name);
if (!(item.Element is EquipmentItemBasis)) item.AppearanceDistributionOffset = 20;
if (item.Element is BookBasis)
{
item.UpperLimitofAppearanceFloor = 100;
item.LowerLimitofAppearanceFloor = 1;
}
else {
item.UpperLimitofAppearanceFloor = 0;
item.LowerLimitofAppearanceFloor = 0;
}
//Debug.Log(item.Element.Name+": "+item.LowerLimitofAppearanceFloor);
});
ret.DistributionTable.TrapTable.ForEach(delegate (ObjectDistributionElements<TrapBasis> item) {
item.UpperLimitofAppearanceFloor = 100;
item.LowerLimitofAppearanceFloor = 1;
});
ret.DistributionTable.EnemyTable.ForEach(delegate (ObjectDistributionElements<CharacterParameterBasis> item) {
item.UpperLimitofAppearanceFloor = 100;
item.LowerLimitofAppearanceFloor = 1;
});
ret.BlindMode = true;
ret.ItemDetectionPowers = Enumerable.Repeat<float>(1, Enum.GetNames(typeof(ItemBasis.ItemCode)).Length).ToArray();
ObjectDistributionElements<TrapBasis> trap = new ObjectDistributionElements<TrapBasis>(new SleepGasTrap(), 0.2f);
trap.UpperLimitofAppearanceFloor = 100;
trap.LowerLimitofAppearanceFloor = 1;
ret.DistributionTable.TrapTable.Add(trap);
ret.NumberOfCarryOnPermissionOfItemOffset = NumberOfCarryOnPermissionOfItemOffsetUpperLimit;
//ret.BlindMode = false;
ret.DungeonName = "DebugDungeon1";
return ret;
}
public void init(DungeonParameter param, int maxgeneratecount)
{
CurrentDungeounParameter = param;
mapgenerator = new MapGenerator(param);
init(maxgeneratecount);
}
public IEnumerator Perippaa_(Action setReviveCb) => default; // 0x00CB6FD0-0x00CB7050
// [IteratorStateMachine] // 0x00630500-0x00630570
public IEnumerator PerippaaDungeon_(DungeonParameter dungeonParameter, Action <bool> CbSuspended) => default; // 0x00CB7080-0x00CB7100
public void changeTileType(TileBasis.TileType newtype, DungeonParameter dgparam)
{
switch (newtype)
{
case TileBasis.TileType.ROAD:
init(road,dgparam);
//newtag = TagList.Road;
break;
case TileBasis.TileType.WALL:
init(wall,dgparam);
//newtag = TagList.Wall;
break;
case TileBasis.TileType.WATERWAY:
init(waterway,dgparam);
//newtag = TagList.Wall;
break;
case TileBasis.TileType.OVERLAPROAD:
init(road, dgparam);
string newtag = TagList.Road;
this.transform.tag = newtag;
SpriteRenderer.sortingLayerName = TagList.OverlapRoad;
gameObject.layer = LayerMask.NameToLayer(newtag);
//this.name += @"(Overlap)";
break;
case TileBasis.TileType.UNBREAKABLEWALL:
init(wall, dgparam);
Type = TileBasis.TileType.UNBREAKABLEWALL;
name = Type.ToString();
break;
}
}
