// Use this for initialization
void Start()
{
m_obstacleController = GameObject.FindGameObjectWithTag(GameConsts.TAG_OBSTACLES_CONTROLLER).GetComponent <ObstacleController>();
}
// Use this for initialization
void Awake()
{
controller = gameObject.GetComponent <ObstacleController> ();
}
private void CreateObstacle()
{
GameObject[] objectPos = GameObject.FindGameObjectsWithTag("ObjectPos");
List <int> objectPosNoList = new List <int>();
if (0 < objectPos.Length)
{
// ランダムで生成場所を確保
for (int i = 0; i < obstacleGenerationCount; i++)
{
// ランダムな値を0～objectPos.Length - 1の間で生成
int objectPosNo = Random.Range(0, objectPos.Length);
if (objectPosNoList.Contains(objectPosNo))
{
continue;
}
else
{
_obstaclePosTF.Add(objectPos[objectPosNo].transform);
}
}
// 生成場所に生成
for (int i = 0; i < _obstaclePosTF.Count; i++)
{
Debug.Log("_obstaclePosTF[" + i.ToString() + "] : " + _obstaclePosTF[i].position.ToString());
// PhotonNetwork.InstantiateSceneObject("SnowyMt", _obstaclePosTF[i].position, Quaternion.identity, 0, null);
// プレイヤー用障害物生成
//GameObject ObstacleObjectForPlayer = PhotonNetwork.Instantiate("ObstacleSnowyMt01", _obstaclePosTF[i].position, Quaternion.identity, 0, null);
//GameObject ObstacleObjectForPlayer = PhotonNetwork.Instantiate("ObstacleSnowyMt01", _obstaclePosTF[i].position, _obstaclePosTF[i].rotation, 0, null);
GameObject ObstacleObjectForPlayer = Instantiate(obstacleObject, _obstaclePosTF[i].position, _obstaclePosTF[i].rotation);
ObstacleObjectForPlayer.name = "ObstacleSnowyMt01_Player";
ObstacleObjectForPlayer.tag = "PlayerObstacle";
ObstacleObjectForPlayer.layer = 8; // 8:Player
ObstacleController obstacleControllerForPlayer = ObstacleObjectForPlayer.GetComponent <ObstacleController>();
obstacleControllerForPlayer.SpriteObject.layer = 8; // 8:Player
obstacleControllerForPlayer.ArrowsSpriteObject.layer = 8; // 8:Player
ObstacleCancellationController _obstacleCancellationControllerForPlayer = obstacleControllerForPlayer.SpriteObject.GetComponent <ObstacleCancellationController>();
if (i == 0)
{
_obstacleCancellationControllerForPlayer.obstacleCancelDirection = "up";
}
else if (i == 1)
{
_obstacleCancellationControllerForPlayer.obstacleCancelDirection = "left";
}
else if (i == 2)
{
_obstacleCancellationControllerForPlayer.obstacleCancelDirection = "down";
}
else if (i == 3)
{
_obstacleCancellationControllerForPlayer.obstacleCancelDirection = "right";
}
else
{
_obstacleCancellationControllerForPlayer.obstacleCancelDirection = "up";
}
}
createObstacleFlg = true;
}
}
void Start()
{
OC = GetComponent <ObstacleController>();
StartCoroutine(StartScroll());
}
private static bool BoundsNullCheck(ObstacleController obstacleController)
{
return(obstacleController.bounds.size == _vectorZero);
}
/*
* OC ColorSO holders
*/
internal static void OCStart(ObstacleController oc, Color original)
{
OCColorManager.CreateOCColorManager(oc, original);
}
protected override void Stumble (ObstacleController obstacle)
{
}
void Awake()
{
Instance = this;
}
internal static OCColorManager GetOCColorManager(ObstacleController oc)
{
return(_ocColorManagers.FirstOrDefault(n => n._oc == oc));
}
public override void HandleObstacleDidDissolve(ObstacleController obstacleController)
{
Despawn(obstacleController);
}
private void Init()
{
// GameFacade.GetInstance().stageDataController.
playerController = gameObject.GetComponent <PlayerController>();
obstacleController = GameFacade.GetInstance().obstacleController;
}
public override void HandleObstacleFinishedMovement(ObstacleController obstacleController)
{
Despawn(obstacleController);
}
public override void Despawn(ObstacleController obstacleController)
{
RemoveObstacleEventCallbacks(obstacleController);
_obstaclePool.Despawn(obstacleController);
}
public bool Damage(int damage, float impact, Transform attackTran, Transform hitTran, Transform ownerTran)
{
if (hitTran == null || attackTran == null)
{
return(false);
}
bool isHit = false;
int hitDamage = 0;
switch (hitTran.tag)
{
case Common.CO.TAG_UNIT:
case Common.CO.TAG_ENEMY:
//ユニット
//被弾方向補正
Vector3 hitVector = attackTran.position - hitTran.position;
float damageRate = GetHitAngleRate(hitTran, hitVector);
damage = (int)(damage * damageRate);
hitDamage = hitTran.GetComponent <UnitController>().Hit(damage, impact * -hitVector.normalized, ownerTran);
if (hitDamage > 0)
{
SpawnDamageEffect(attackTran, hitTran);
}
isHit = true;
break;
case Common.CO.TAG_HQ:
case Common.CO.TAG_ENEMY_HQ:
//HQ
hitDamage = hitTran.GetComponent <UnitController>().Hit(damage, ownerTran);
isHit = true;
break;
case Common.CO.TAG_BREAK_OBSTACLE:
//破壊可能障害物
ObstacleController obstacleCtrl = hitTran.GetComponent <ObstacleController>();
if (ownerTran != null)
{
int obstacleSide = obstacleCtrl.GetSide();
if (obstacleSide != Common.CO.SIDE_UNKNOWN && obstacleSide == Common.Func.GetMySide(ownerTran.tag))
{
damage = 0;
}
}
if (damage > 0)
{
hitDamage = obstacleCtrl.Hit(damage, ownerTran);
}
if (hitDamage > 0)
{
SpawnDamageEffect(attackTran, hitTran);
}
isHit = true;
break;
case Common.CO.TAG_OBSTACLE:
case Common.CO.TAG_ARTILLERY_OBSTACLE:
//障害物
isHit = true;
break;
}
return(isHit);
}
#pragma warning disable SA1313 // Parameter names should begin with lower-case letter
private static void Prefix(
ObstacleController __instance,
ObstacleData ____obstacleData,
AudioTimeSyncController ____audioTimeSyncController,
float ____startTimeOffset,
ref Vector3 ____startPos,
ref Vector3 ____midPos,
ref Vector3 ____endPos,
float ____move1Duration,
float ____move2Duration,
float ____obstacleDuration,
ref Quaternion ____worldRotation,
ref Quaternion ____inverseWorldRotation,
ref Bounds ____bounds)
#pragma warning restore SA1313 // Parameter names should begin with lower-case letter
{
if (____obstacleData is CustomObstacleData customData)
{
dynamic dynData = customData.customData;
Track track = Trees.at(dynData, "track");
dynamic animationObject = Trees.at(dynData, "_animation");
if (track != null || animationObject != null)
{
// idk i just copied base game time
float elapsedTime = ____audioTimeSyncController.songTime - ____startTimeOffset;
float normalTime = (elapsedTime - ____move1Duration) / (____move2Duration + ____obstacleDuration);
AnimationHelper.GetObjectOffset(animationObject, track, normalTime, out Vector3? positionOffset, out Quaternion? rotationOffset, out Vector3? scaleOffset, out Quaternion? localRotationOffset, out float?dissolve, out float?_, out float?cuttable);
if (positionOffset.HasValue)
{
Vector3 startPos = Trees.at(dynData, "startPos");
Vector3 midPos = Trees.at(dynData, "midPos");
Vector3 endPos = Trees.at(dynData, "endPos");
Vector3 offset = positionOffset.Value;
____startPos = startPos + offset;
____midPos = midPos + offset;
____endPos = endPos + offset;
}
Transform transform = __instance.transform;
if (rotationOffset.HasValue || localRotationOffset.HasValue)
{
Quaternion worldRotation = Trees.at(dynData, "worldRotation");
Quaternion localRotation = Trees.at(dynData, "localRotation");
Quaternion worldRotationQuatnerion = worldRotation;
if (rotationOffset.HasValue)
{
worldRotationQuatnerion *= rotationOffset.Value;
Quaternion inverseWorldRotation = Quaternion.Euler(-worldRotationQuatnerion.eulerAngles);
____worldRotation = worldRotationQuatnerion;
____inverseWorldRotation = inverseWorldRotation;
}
worldRotationQuatnerion *= localRotation;
if (localRotationOffset.HasValue)
{
worldRotationQuatnerion *= localRotationOffset.Value;
}
transform.localRotation = worldRotationQuatnerion;
}
bool cuttableEnabled = true;
if (cuttable.HasValue)
{
cuttableEnabled = cuttable.Value >= 1;
if (cuttableEnabled)
{
if (____bounds.size != _vectorZero)
{
____bounds.size = _vectorZero;
}
}
else
{
Vector3 boundsSize = Trees.at(dynData, "boundsSize");
if (____bounds.size != boundsSize)
{
____bounds.size = boundsSize;
}
}
}
if (scaleOffset.HasValue)
{
transform.localScale = scaleOffset.Value;
}
if (dissolve.HasValue)
{
CutoutAnimateEffect cutoutAnimateEffect = Trees.at(dynData, "cutoutAnimateEffect");
if (cutoutAnimateEffect == null)
{
ObstacleDissolve obstacleDissolve = __instance.gameObject.GetComponent <ObstacleDissolve>();
cutoutAnimateEffect = _obstacleCutoutAnimateEffectAccessor(ref obstacleDissolve);
dynData.cutoutAnimateEffect = cutoutAnimateEffect;
}
cutoutAnimateEffect.SetCutout(1 - dissolve.Value);
}
}
}
}
/*
* OC ColorSO holders
*/
internal static void OCStart(ObstacleController oc)
{
OCColorManager.CreateOCColorManager(oc);
}
public static void SetActiveColors(this ObstacleController oc)
{
OCColorManager.GetOCColorManager(oc).SetActiveColors();
}
// Since start method in unity is not serialized
// I manually ask it waits for obstacles to build finish
// then draw reduced visibily graphs
void Start()
{
obstacleController = GameObject.FindObjectOfType <ObstacleController>();
Invoke(nameof(drawReducedVisibilityGraph), 0.05f);
}
private static bool Prefix(BeatmapObjectSpawnController __instance, BeatmapObjectData beatmapObjectData, ref bool ____disableSpawning, ref float ____moveDistance, ref float ____moveSpeed, ref float ____jumpDistance, ref float ____noteJumpMovementSpeed, ref float ____topObstaclePosY, ref float ____globalYJumpOffset, ref float ____verticalObstaclePosY, ref ObstacleController.Pool ____obstaclePool, ref float ____spawnAheadTime, ref float ____noteLinesDistance, ref Action <BeatmapObjectSpawnController, ObstacleController> ___obstacleDiStartMovementEvent, ref float ____topLinesZPosOffset, ref NoteController.Pool ____bombNotePool, ref NoteController.Pool ____noteAPool, ref NoteController.Pool ____noteBPool, ref int ____numberOfSpawnedBasicNotes, ref float ____firstBasicNoteTime, ref NoteController ____prevSpawnedNormalNoteController, ref bool ____disappearingArrows, ref bool ____ghostNotes, ref Action <BeatmapObjectSpawnController, BeatmapObjectData, float, float> ___beatmapObjectWasSpawnedEvent,
ref float ____topObstacleHeight, ref float ____verticalObstacleHeight)
{
if (!Plugin.active)
{
return(true);
}
float angleFloat;
Quaternion angle = ExtraBeatmapData.beatmapObjectsAngles.TryGetValue(beatmapObjectData.id, out angleFloat) ? Quaternion.Euler(0f, angleFloat, 0f) : Quaternion.identity;
if (____disableSpawning)
{
return(false);
}
float num2 = ____moveDistance / ____moveSpeed;
float num3 = ____jumpDistance / ____noteJumpMovementSpeed;
if (beatmapObjectData.beatmapObjectType == BeatmapObjectType.Obstacle)
{
ObstacleData obstacleData = (ObstacleData)beatmapObjectData;
Vector3 forward = __instance.transform.forward;
Vector3 vector = __instance.transform.position;
vector += forward * (____moveDistance + ____jumpDistance * 0.5f);
Vector3 vector2 = vector - forward * ____moveDistance;
Vector3 vector3 = vector - forward * (____moveDistance + ____jumpDistance);
Vector3 noteOffset = __instance.GetNoteOffset(beatmapObjectData.lineIndex, NoteLineLayer.Base);
noteOffset.y = ((obstacleData.obstacleType == ObstacleType.Top) ? (____topObstaclePosY + ____globalYJumpOffset) : ____verticalObstaclePosY);
float height = (obstacleData.obstacleType == ObstacleType.Top) ? ____topObstacleHeight : ____verticalObstacleHeight;
ObstacleController obstacleController = ____obstaclePool.Spawn();
__instance.SetObstacleEventCallbacks(obstacleController);
obstacleController.transform.SetPositionAndRotation(angle * (vector + noteOffset), angle);
obstacleController.Init(obstacleData, angle * (vector + noteOffset), angle * (vector2 + noteOffset), angle * (vector3 + noteOffset), num2, num3, beatmapObjectData.time - ____spawnAheadTime, ____noteLinesDistance, height);
___obstacleDiStartMovementEvent?.Invoke(__instance, obstacleController);
}
else
{
NoteData noteData = (NoteData)beatmapObjectData;
Vector3 forward2 = __instance.transform.forward;
Vector3 vector4 = __instance.transform.position;
vector4 += forward2 * (____moveDistance + ____jumpDistance * 0.5f);
Vector3 vector5 = vector4 - forward2 * ____moveDistance;
Vector3 vector6 = vector4 - forward2 * (____moveDistance + ____jumpDistance);
if (noteData.noteLineLayer == NoteLineLayer.Top)
{
vector6 += forward2 * ____topLinesZPosOffset * 2f;
}
Vector3 noteOffset2 = __instance.GetNoteOffset(noteData.lineIndex, noteData.startNoteLineLayer);
float jumpGravity = __instance.JumpGravityForLineLayer(noteData.noteLineLayer, noteData.startNoteLineLayer);
if (noteData.noteType == NoteType.Bomb)
{
NoteController noteController = ____bombNotePool.Spawn();
__instance.SetNoteControllerEventCallbacks(noteController);
noteController.transform.SetPositionAndRotation(angle * (vector4 + noteOffset2), angle);
lastSpawnedObjectId = beatmapObjectData.id;
noteController.Init(noteData, angle * (vector4 + noteOffset2), angle * (vector5 + noteOffset2), angle * (vector6 + noteOffset2), num2, num3, noteData.time - ____spawnAheadTime, jumpGravity);
}
else
{
if (noteData.noteType.IsBasicNote())
{
MemoryPool <NoteController> memoryPool = (noteData.noteType == NoteType.NoteA) ? ____noteAPool : ____noteBPool;
if (____numberOfSpawnedBasicNotes == 0)
{
____firstBasicNoteTime = noteData.time;
}
bool isFirstNote = ____firstBasicNoteTime == noteData.time;
NoteController noteController2 = memoryPool.Spawn();
__instance.SetNoteControllerEventCallbacks(noteController2);
Vector3 noteOffset3 = __instance.GetNoteOffset(noteData.flipLineIndex, noteData.startNoteLineLayer);
noteController2.transform.SetPositionAndRotation(angle * (vector4 + noteOffset3), angle);
GameNoteController gameNoteController = noteController2 as GameNoteController;
lastSpawnedObjectId = beatmapObjectData.id;
if (gameNoteController != null)
{
gameNoteController.Init(noteData, angle * (vector4 + noteOffset3), angle * (vector5 + noteOffset3), angle * (vector6 + noteOffset2), num2, num3, noteData.time - ____spawnAheadTime, jumpGravity, ____disappearingArrows, ____ghostNotes && !isFirstNote);
}
else
{
noteController2.Init(noteData, angle * (vector4 + noteOffset3), angle * (vector5 + noteOffset3), angle * (vector6 + noteOffset2), num2, num3, noteData.time - ____spawnAheadTime, jumpGravity);
}
____numberOfSpawnedBasicNotes++;
if (____prevSpawnedNormalNoteController != null)
{
float time = ____prevSpawnedNormalNoteController.noteData.time;
float time2 = noteController2.noteData.time;
}
____prevSpawnedNormalNoteController = noteController2;
}
}
}
___beatmapObjectWasSpawnedEvent?.Invoke(__instance, beatmapObjectData, num2, num3);
return(false);
}
private static void Prefix(
ObstacleController __instance,
ObstacleData ____obstacleData,
AudioTimeSyncController ____audioTimeSyncController,
float ____startTimeOffset,
ref Vector3 ____startPos,
ref Vector3 ____midPos,
ref Vector3 ____endPos,
float ____move1Duration,
float ____move2Duration,
float ____obstacleDuration,
ref Quaternion ____worldRotation,
ref Quaternion ____inverseWorldRotation,
ref Bounds ____bounds)
{
NoodleObstacleData?noodleData = TryGetObjectData <NoodleObstacleData>(____obstacleData);
if (noodleData == null)
{
return;
}
IEnumerable <Track>?tracks = noodleData.Track;
NoodleObjectData.AnimationObjectData?animationObject = noodleData.AnimationObject;
if (tracks != null || animationObject != null)
{
// idk i just copied base game time
float elapsedTime = ____audioTimeSyncController.songTime - ____startTimeOffset;
float normalTime = (elapsedTime - ____move1Duration) / (____move2Duration + ____obstacleDuration);
Animation.AnimationHelper.GetObjectOffset(animationObject, tracks, normalTime, out Vector3? positionOffset, out Quaternion? rotationOffset, out Vector3? scaleOffset, out Quaternion? localRotationOffset, out float?dissolve, out float?_, out float?cuttable);
if (positionOffset.HasValue)
{
Vector3 startPos = noodleData.StartPos;
Vector3 midPos = noodleData.MidPos;
Vector3 endPos = noodleData.EndPos;
Vector3 offset = positionOffset.Value;
____startPos = startPos + offset;
____midPos = midPos + offset;
____endPos = endPos + offset;
}
Transform transform = __instance.transform;
if (rotationOffset.HasValue || localRotationOffset.HasValue)
{
Quaternion worldRotation = noodleData.WorldRotation;
Quaternion localRotation = noodleData.LocalRotation;
Quaternion worldRotationQuatnerion = worldRotation;
if (rotationOffset.HasValue)
{
worldRotationQuatnerion *= rotationOffset.Value;
Quaternion inverseWorldRotation = Quaternion.Inverse(worldRotationQuatnerion);
____worldRotation = worldRotationQuatnerion;
____inverseWorldRotation = inverseWorldRotation;
}
worldRotationQuatnerion *= localRotation;
if (localRotationOffset.HasValue)
{
worldRotationQuatnerion *= localRotationOffset.Value;
}
transform.localRotation = worldRotationQuatnerion;
}
if (cuttable.HasValue)
{
if (cuttable.Value >= 1)
{
if (____bounds.size != Vector3.zero)
{
____bounds.size = Vector3.zero;
}
}
else
{
Vector3 boundsSize = noodleData.BoundsSize;
if (____bounds.size != boundsSize)
{
____bounds.size = boundsSize;
}
}
}
if (scaleOffset.HasValue)
{
transform.localScale = scaleOffset.Value;
}
if (dissolve.HasValue)
{
if (CutoutManager.ObstacleCutoutEffects.TryGetValue(__instance, out CutoutAnimateEffectWrapper cutoutAnimateEffect))
{
cutoutAnimateEffect.SetCutout(dissolve.Value);
}
}
}
if (noodleData.DoUnhide)
{
__instance.hide = false;
}
}
private void Awake()
{
instance = this;
initializeNativeObstacleMap(gridParams.x, gridParams.y);
}
private static void Postfix(ObstacleController ____obstacleController)
{
CutoutManager.ObstacleCutoutEffects.Remove(____obstacleController);
}
public virtual void HandleObstacleDiStartMovementEvent(BeatmapObjectSpawnController obstacleSpawnController, ObstacleController obstacleController)
{
try
{
StretchableObstacle _stretchableObstacle = ReflectionUtil.GetPrivateField <StretchableObstacle>(obstacleController, "_stretchableObstacle");
StretchableCube _stretchableCoreOutside = ReflectionUtil.GetPrivateField <StretchableCube>(_stretchableObstacle, "_stretchableCoreOutside");
StretchableCube _stretchableCoreInside = ReflectionUtil.GetPrivateField <StretchableCube>(_stretchableObstacle, "_stretchableCoreInside");
//MeshRenderer _meshRenderer = ReflectionUtil.GetPrivateField<MeshRenderer>(_stretchableCoreOutside, "_meshRenderer");
//MeshRenderer _meshRenderer2 = ReflectionUtil.GetPrivateField<MeshRenderer>(_stretchableCoreInside, "_meshRenderer");
_stretchableCoreOutside.gameObject.layer = WallLayer;
_stretchableCoreInside.gameObject.layer = WallLayer;
}
catch (Exception ex)
{
Console.WriteLine(ex.Message + "\n" + ex.StackTrace);
}
}
private static void Postfix(ObstacleController ____obstacleController, CutoutAnimateEffect ____cutoutAnimateEffect)
{
CutoutManager.ObstacleCutoutEffects.Add(____obstacleController, new CutoutAnimateEffectWrapper(____cutoutAnimateEffect));
}
// Use this for initialization
void Start()
{
Controller = GetComponent <ObstacleController>();
}
public DonutMover(ObstacleController obstacleController)
{
_movingStick = obstacleController.transform.GetChild(0).transform.GetChild(0);
}
private void Awake()
{
instance = this;
}
public static void Reset(this ObstacleController oc)
{
OCColorManager.GetOCColorManager(oc)?.Reset();
}
void Start()
{
obstController = (ObstacleController)ObstacleControllerObj.GetComponent(typeof(ObstacleController));
CreatePowerUps();
LoadPowerUpList();
}
public static void SetObstacleColor(this ObstacleController oc, Color color)
{
OCColorManager.GetOCColorManager(oc)?.SetObstacleColor(color);
}
public virtual void HandleObstacleDidStartMovementEvent(BeatmapObjectSpawnController obstacleSpawnController, ObstacleController obstacleController)
{
try
{
StretchableObstacle _stretchableObstacle = ReflectionUtil.GetPrivateField <StretchableObstacle>(obstacleController, "_stretchableObstacle");
StretchableCube _stretchableCore = ReflectionUtil.GetPrivateField <StretchableCube>(_stretchableObstacle, "_stretchableCore");
Transform _obstacleCore = ReflectionUtil.GetPrivateField <Transform>(_stretchableObstacle, "_obstacleCore");
//MeshRenderer _meshRenderer = ReflectionUtil.GetPrivateField<MeshRenderer>(_stretchableCoreOutside, "_meshRenderer");
//MeshRenderer _meshRenderer2 = ReflectionUtil.GetPrivateField<MeshRenderer>(_stretchableCoreInside, "_meshRenderer");
Logger.log.Debug("Setting stretchableCore layer to: " + Plugin.WallLayer + " from: " + _stretchableCore.gameObject.layer);
Logger.log.Debug("Setting obstacleCore layer to: " + Plugin.WallLayer + " from: " + _obstacleCore.gameObject.layer);
Logger.log.Debug("ObstacleController has layer: " + obstacleController.gameObject.layer);
Logger.log.Debug("_stretchableObstacle has layer: " + _stretchableObstacle.gameObject.layer);
_stretchableCore.gameObject.layer = Plugin.WallLayer;
_obstacleCore.gameObject.layer = Plugin.WallLayer;
}
catch (Exception ex)
{
Logger.log.Error(ex);
}
}
/** * Usado cuando el poder se topa con un obstáculo * */ protected abstract void Stumble (ObstacleController obstacle);
