static void Main(string[] args)
{
//RoomType room = new RoomType
//{
// BaseRate = 300,
// Type = ROOM_TYPE.QueenRoom,
// Inventory = 50,
// Ameneties = "am",
// Description = "desc",
// ImageUrl = "img"
//};
//RoomRepository roomRepo = new RoomRepository(new HotelModelContext());
//roomRepo.InsertRoom(room);
//roomRepo.Save();
ReservationHandler reservationHandler = new ReservationHandler();
RoomHandler roomHandler = new RoomHandler();
Guid confirmation = reservationHandler.MakeReservation(
"root",
ROOM_TYPE.QueenRoom,
DateTime.Today,
DateTime.Today.AddDays(5),
new List <Guest> {
new Guest
{
FirstName = "oot",
LastName = "R",
}
},
roomHandler.GetRoomPriceList(ROOM_TYPE.QueenRoom, DateTime.Today, DateTime.Today.AddDays(5))
);
Console.WriteLine(confirmation);
Console.ReadKey();
}
private void GrowATurtle(PlayerController arg1, HealthHaver arg2)
{
AIActor orLoadByGuid = EnemyDatabase.GetOrLoadByGuid("cc9c41aa8c194e17b44ac45f993dd212");
RoomHandler absoluteRoom = arg1.gameActor.CenterPosition.GetAbsoluteRoom();
CreateNewCompanion(arg1, arg2.gameActor.CenterPosition, absoluteRoom);
}
private void DoRealConfigure(bool activateNow)
{
if (ForceLeft)
{
transform.position += new Vector3(-1f, -1f, 0f);
}
else if (ForceRight)
{
transform.position += new Vector3(-3.5625f, -1f, 0f);
}
m_LastKnownPosition = transform.position;
tk2dSpriteAnimator spriteAnimator = base.spriteAnimator;
spriteAnimator.AnimationEventTriggered = (Action <tk2dSpriteAnimator, tk2dSpriteAnimationClip, int>)Delegate.Combine(spriteAnimator.AnimationEventTriggered, new Action <tk2dSpriteAnimator, tk2dSpriteAnimationClip, int>(HandleAnimationEvent));
m_room.Entered += delegate(PlayerController a) { Activate(); };
if (activateNow)
{
Activate();
}
if (DeactivateOnEnemiesCleared)
{
RoomHandler room = m_room;
room.OnEnemiesCleared = (Action)Delegate.Combine(room.OnEnemiesCleared, new Action(Deactivate));
}
}
private void RandomToadieAirDrop(GameObject lootCratePrefab, RoomHandler currentRoom, IntVector2?Clearence = null)
{
if (!Clearence.HasValue)
{
Clearence = new IntVector2(2, 2);
}
IntVector2?DropLocation = FindRandomDropLocation(currentRoom, Clearence.Value);
if (DropLocation.HasValue)
{
EmergencyCrateController lootCrate = Instantiate(lootCratePrefab, DropLocation.Value.ToVector2().ToVector3ZUp(1f), Quaternion.identity).GetComponent <EmergencyCrateController>();
if (lootCrate == null)
{
return;
}
lootCrate.ChanceToExplode = 0;
lootCrate.ChanceToSpawnEnemy = 1;
lootCrate.EnemyPlaceable = m_CustomEnemyPlacable(BraveUtility.RandomElement(ToadieGUIDs));
lootCrate.Trigger(new Vector3(-5f, -5f, -5f), DropLocation.Value.ToVector3() + new Vector3(15f, 15f, 15f), currentRoom, true);
currentRoom.ExtantEmergencyCrate = lootCrate.gameObject;
}
return;
}
private void CreateRoomAckEvent(string reqData, Hashtable roomList)
{
//Send(s, validUid+":"+roomName+":CreateRoomReq", 1000);
String[] roomData = reqData.Split(':');
try
{
/* example of roomList
* key: "fc1202" value:"title"
* in this case, fc1202 is the user creating a room called "title"
*/
roomList.Add(roomData[0], roomData[1]);
Console.WriteLine("We have " + roomList.Count.ToString() + " Rooms"
+ "\n" + roomData[0] + " creates room no." + roomData[1]);
//make a room class
room = new RoomHandler();
room.StartRoom(tcpClient);
room.hostName = roomData[0];
/* example of roomClassList
* key: "title" value: room that has been created by clicking a create room button
*/
roomClassList.Add(roomData[1], room);
Send(roomData[1] + ":CreateRoomAck");
}
//Handle Exception
catch (Exception ex)
{
Console.WriteLine(ex);
return;
}
}
public void Update(AttackBehaviorGroup attackGroup)
{
RoomHandler absoluteRoom = base.transform.position.GetAbsoluteRoom();
AIActor randomActiveEnemy = null;
if (randomActiveEnemy == null)
{
randomActiveEnemy = absoluteRoom.GetRandomActiveEnemy(false);
}
if (randomActiveEnemy == this.aiActor)
{
randomActiveEnemy = absoluteRoom.GetRandomActiveEnemy(false);
}
if (randomActiveEnemy.aiActor != this.aiActor)
{
randomActiveEnemy.sprite.renderer.material.SetFloat("_EmissivePower", 23.45f);
randomActiveEnemy.bulletBank.OnProjectileCreated += (Projectile rpoj) =>
{
Color c = rpoj.sprite.color;
c.a = 0.5f;
rpoj.sprite.color = c;
};
}
if (randomActiveEnemy.healthHaver.IsDead)
{
randomActiveEnemy = absoluteRoom.GetRandomActiveEnemy(false);
}
}
public static IEnumerator SpawnHammer(PlayerController user, float spawnDelay = 0)
{
if (spawnDelay > 0)
{
yield return(new WaitForSeconds(spawnDelay));
}
// Tools.Print("Spawning A Friendly Hammer!", "FFFFFF", false);
RoomHandler room = user.CurrentRoom;
IntVector2? spawnPosition = room.GetRandomVisibleClearSpot(2, 2);
yield return(new WaitForSeconds(1f));
if (!spawnPosition.HasValue)
{
spawnPosition = (user.CenterPosition.ToIntVector2() - user.CurrentRoom.area.basePosition);
}
if (spawnPosition.HasValue)
{
RoomHandler currentRoom = user.CurrentRoom;
GameObject ForgeHammer = DungeonPlaceableUtility.InstantiateDungeonPlaceable(ExpandPrefabs.EXFriendlyForgeHammer, currentRoom, spawnPosition.Value, true);
yield return(null);
if (ForgeHammer)
{
ForgeHammer.AddComponent <ExpandForgeHammerComponent>();
ExpandForgeHammerComponent expandForgeHammer = ForgeHammer.GetComponent <ExpandForgeHammerComponent>();
expandForgeHammer.m_Owner = user;
expandForgeHammer.ConfigureOnPlacement(currentRoom);
}
yield return(null);
}
yield break;
}
public override void Update()
{ // deathcontroller
if (host != null && host.healthHaver.GetCurrentHealth() == 0)
{
this.LastOwner.CurrentStoneGunTimer = 1f;
this.LastOwner.MovementModifiers -= this.NoMotionModifier;
this.LastOwner.IsStationary = false;
modifierController = 0;
this.LastOwner.IsEthereal = false;
this.LastOwner.SetIsStealthed(false, "cause they just are");
PassiveItem.DecrementFlag(this.LastOwner, typeof(LiveAmmoItem));
this.LastOwner.stats.RecalculateStats(LastOwner, true);
CamToggle = 0;
GameManager.Instance.MainCameraController.StartTrackingPlayer();
GameManager.Instance.MainCameraController.SetManualControl(false, true);
}
if (host != null && CamToggle == 1)
{
// in head state
CameraController m_camera = GameManager.Instance.MainCameraController;
m_camera.StopTrackingPlayer();
m_camera.SetManualControl(true, false);
m_camera.OverridePosition = host.CenterPosition;
TargetNumber1(host, this.LastOwner);
RoomHandler room = this.LastOwner.CurrentRoom;
proximity(this.LastOwner);
foreach (var enemy in room.GetActiveEnemies(RoomHandler.ActiveEnemyType.All))
{
System.Random rng = new System.Random();
int chanceToFire = rng.Next(1, 80);
if (chanceToFire == 1 && enemy != host)
{
enemy.aiShooter.ShootAtTarget();
}
}
//poison
List <AIActor> activeEnemies = base.LastOwner.CurrentRoom.GetActiveEnemies(RoomHandler.ActiveEnemyType.All);
Vector2 centerPosition = host.specRigidbody.UnitCenter;
foreach (AIActor aiactor in activeEnemies)
{
bool flag3 = Vector2.Distance(aiactor.CenterPosition, centerPosition) < 1.5f && aiactor.healthHaver.GetMaxHealth() > 0f && aiactor != null && aiactor.specRigidbody != null && base.LastOwner != null;
if (flag3 && aiactor != host)
{
aiactor.ApplyEffect(Game.Items["irradiated_lead"].GetComponent <BulletStatusEffectItem>().HealthModifierEffect, 4f, null);
aiactor.ApplyEffect(Game.Items["hot_lead"].GetComponent <BulletStatusEffectItem>().HealthModifierEffect, 4f, null);
aiactor.ApplyEffect(Game.Items["battery_bullets"].GetComponent <BulletStatusEffectItem>().HealthModifierEffect, 4f, null);
}
}
}
base.Update();
}
private IEnumerator HandleCombatRoomExpansion(PaydayDrillItem drillItem, RoomHandler sourceRoom, RoomHandler targetRoom, Chest sourceChest)
{
yield return(new WaitForSeconds(drillItem.DelayPreExpansion));
float duration = 5.5f;
float elapsed = 0f;
int numExpansionsDone = 0;
while (elapsed < duration)
{
elapsed += BraveTime.DeltaTime * 9f;
while (elapsed > numExpansionsDone)
{
numExpansionsDone++;
ExpandRoom(drillItem, targetRoom);
AkSoundEngine.PostEvent("Play_OBJ_rock_break_01", GameManager.Instance.gameObject);
}
yield return(null);
}
Dungeon d = GameManager.Instance.Dungeon;
Pathfinder.Instance.InitializeRegion(d.data, targetRoom.area.basePosition + new IntVector2(-5, -5), targetRoom.area.dimensions + new IntVector2(10, 10));
yield return(new WaitForSeconds(drillItem.DelayPostExpansionPreEnemies));
yield return(ExpandHandleCombatWaves(drillItem, d, targetRoom, sourceChest));
yield break;
}
protected override void Update()
{
if (Owner && Owner.CurrentRoom != null)
{
if (Owner.CurrentRoom != lastCheckedRoom)
{
RoomHandler curRoom = Owner.CurrentRoom;
bool isInOrAdjacentToBossRoom = false;
if (curRoom.area.PrototypeRoomCategory == PrototypeDungeonRoom.RoomCategory.BOSS)
{
isInOrAdjacentToBossRoom = true;
}
else
{
for (int i = 0; i < curRoom.connectedRooms.Count; i++)
{
if (curRoom.connectedRooms[i].area.PrototypeRoomCategory == PrototypeDungeonRoom.RoomCategory.BOSS)
{
isInOrAdjacentToBossRoom = true;
}
}
}
if (isInOrAdjacentToBossRoom && this.CanBeDropped)
{
this.CanBeDropped = false;
}
else if (!this.CanBeDropped)
{
this.CanBeDropped = true;
}
lastCheckedRoom = Owner.CurrentRoom;
}
}
base.Update();
}
private void HandleStealthEffect(TableTechChaosEffectIdentifier identifier, FlippableCover obj)
{
if (identifier == TableTechChaosEffectIdentifier.STEALTH)
{
PlayerController owner = base.Owner;
this.BreakStealth(owner);
owner.OnItemStolen += this.BreakStealthOnSteal;
owner.ChangeSpecialShaderFlag(1, 1f);
owner.healthHaver.OnDamaged += this.OnDamaged;
owner.SetIsStealthed(true, "table tech chaos");
owner.SetCapableOfStealing(true, "table tech chaos", null);
GameManager.Instance.StartCoroutine(this.Unstealthy());
if (base.Owner.PlayerHasActiveSynergy("#HIDDEN_TECH_SUPER_CHAOS"))
{
float num;
RoomHandler room = obj.transform.position.GetAbsoluteRoom();
if (room != null)
{
AIActor aiactor = room.GetNearestEnemy(obj.specRigidbody.UnitCenter, out num, true, true);
if (aiactor != null)
{
aiactor.PlayEffectOnActor(RedpoofVFX, Vector3.zero, false, true, false);
aiactor.healthHaver.ApplyDamage(UnityEngine.Random.Range(15, 30), obj.specRigidbody.UnitCenter - aiactor.sprite.WorldCenter, "Hidden Tech Assassin", CoreDamageTypes.None, DamageCategory.Unstoppable, true, null, false);
}
}
}
}
}
private void ConnectClusteredRooms(RoomHandler first, RoomHandler second, PrototypeDungeonRoom firstPrototype, PrototypeDungeonRoom secondPrototype, int firstRoomExitIndex, int secondRoomExitIndex, int room1ExitLengthPadding = 3, int room2ExitLengthPadding = 3)
{
if (first.area.instanceUsedExits == null | second.area.exitToLocalDataMap == null |
second.area.instanceUsedExits == null | first.area.exitToLocalDataMap == null)
{
return;
}
try {
first.area.instanceUsedExits.Add(firstPrototype.exitData.exits[firstRoomExitIndex]);
RuntimeRoomExitData runtimeRoomExitData = new RuntimeRoomExitData(firstPrototype.exitData.exits[firstRoomExitIndex]);
first.area.exitToLocalDataMap.Add(firstPrototype.exitData.exits[firstRoomExitIndex], runtimeRoomExitData);
second.area.instanceUsedExits.Add(secondPrototype.exitData.exits[secondRoomExitIndex]);
RuntimeRoomExitData runtimeRoomExitData2 = new RuntimeRoomExitData(secondPrototype.exitData.exits[secondRoomExitIndex]);
second.area.exitToLocalDataMap.Add(secondPrototype.exitData.exits[secondRoomExitIndex], runtimeRoomExitData2);
first.connectedRooms.Add(second);
first.connectedRoomsByExit.Add(firstPrototype.exitData.exits[firstRoomExitIndex], second);
first.childRooms.Add(second);
second.connectedRooms.Add(first);
second.connectedRoomsByExit.Add(secondPrototype.exitData.exits[secondRoomExitIndex], first);
second.parentRoom = first;
runtimeRoomExitData.linkedExit = runtimeRoomExitData2;
runtimeRoomExitData2.linkedExit = runtimeRoomExitData;
runtimeRoomExitData.additionalExitLength = room1ExitLengthPadding;
runtimeRoomExitData2.additionalExitLength = room2ExitLengthPadding;
} catch (Exception) {
ETGModConsole.Log("WARNING: Exception caused during CoonectClusteredRunTimeRooms method!");
return;
}
}
public void BlankModHook(Action <SilencerInstance, BlankModificationItem, Vector2, PlayerController> orig, SilencerInstance silencer, BlankModificationItem bmi, Vector2 centerPoint, PlayerController user)
{
orig(silencer, bmi, centerPoint, user);
if (user.HasPickupID(KinAmmoletID))
{
RoomHandler currentRoom = user.CurrentRoom;
if (currentRoom.IsSealed)
{
string enemyToSpawnGUID = "01972dee89fc4404a5c408d50007dad5";
bool shouldJam = false;
if (user.PlayerHasActiveSynergy("Shotgun Club") && UnityEngine.Random.value <= 0.5f)
{
enemyToSpawnGUID = "128db2f0781141bcb505d8f00f9e4d47";
}
if (user.PlayerHasActiveSynergy("Friends On The Other Side"))
{
shouldJam = true;
}
CompanionisedEnemyUtility.SpawnCompanionisedEnemy(user, enemyToSpawnGUID, centerPoint.ToIntVector2(), false, ExtendedColours.brown, 15, 2, shouldJam, true);
if ((user.PlayerHasActiveSynergy("Aim Twice, Shoot Once")))
{
CompanionisedEnemyUtility.SpawnCompanionisedEnemy(user, enemyToSpawnGUID, centerPoint.ToIntVector2(), false, ExtendedColours.brown, 15, 2, shouldJam, true);
}
}
}
}
private void StunEnemiesForTeleport(RoomHandler targetRoom, float StunDuration = 0.5f)
{
if (!targetRoom.HasActiveEnemies(RoomHandler.ActiveEnemyType.All))
{
return;
}
List <AIActor> activeEnemies = targetRoom.GetActiveEnemies(RoomHandler.ActiveEnemyType.All);
if (activeEnemies == null | activeEnemies.Count <= 0)
{
return;
}
for (int i = 0; i < activeEnemies.Count; i++)
{
if (activeEnemies[i].IsNormalEnemy && activeEnemies[i].healthHaver && !activeEnemies[i].healthHaver.IsBoss)
{
Vector2 vector = (!activeEnemies[i].specRigidbody) ? activeEnemies[i].sprite.WorldBottomLeft : activeEnemies[i].specRigidbody.UnitBottomLeft;
Vector2 vector2 = (!activeEnemies[i].specRigidbody) ? activeEnemies[i].sprite.WorldTopRight : activeEnemies[i].specRigidbody.UnitTopRight;
if (activeEnemies[i] && activeEnemies[i].behaviorSpeculator)
{
activeEnemies[i].behaviorSpeculator.Stun(StunDuration, false);
}
}
}
}
public void TeleportToRoom(PlayerController targetPlayer, RoomHandler targetRoom, bool isSecondaryPlayer = false)
{
m_IsTeleporting = true;
// if (targetPlayer.m_isStartingTeleport) { return; }
// targetPlayer.m_isStartingTeleport = true;
IntVector2?randomAvailableCell = targetRoom.GetRandomAvailableCell(new IntVector2?(new IntVector2(2, 2)), new CellTypes?(CellTypes.FLOOR), false, null);
if (!randomAvailableCell.HasValue)
{
m_IsTeleporting = false;
return;
}
if (GameManager.Instance.CurrentGameType == GameManager.GameType.COOP_2_PLAYER && !isSecondaryPlayer)
{
PlayerController otherPlayer = GameManager.Instance.GetOtherPlayer(targetPlayer);
if (otherPlayer)
{
TeleportToRoom(otherPlayer, targetRoom, true);
}
}
// targetPlayer.m_isStartingTeleport = false;
targetPlayer.DoVibration(Vibration.Time.Normal, Vibration.Strength.Medium);
GameManager.Instance.StartCoroutine(HandleTeleportToRoom(targetPlayer, randomAvailableCell.Value.ToCenterVector2()));
targetPlayer.specRigidbody.Velocity = Vector2.zero;
targetPlayer.knockbackDoer.TriggerTemporaryKnockbackInvulnerability(1f);
targetRoom.EnsureUpstreamLocksUnlocked();
// GameManager.Instance.StartCoroutine(DelayedRoomReset(targetPlayer, targetPlayer.CurrentRoom));
}
void OnClick()
{
Debug.Log("Click" + this.name);
RoomHandler handler = FindObjectOfType <RoomHandler>();
handler.OnRoomChoose(this.name);
}
private void GrabbyGrabTime(PlayerController player, float oof)
{
cooldown += oof;
if (cooldown >= 120)
{
AIActor actor;
RoomHandler absoluteRoom = base.transform.position.GetAbsoluteRoom();
actor = Owner.CurrentRoom.GetRandomActiveEnemy(true);
GameObject hand = UnityEngine.Object.Instantiate <GameObject>(CelsItems.hellDrag.HellDragVFX);
AkSoundEngine.PostEvent("Play_BOSS_lichB_grab_01", gameObject);
if (!actor.healthHaver.IsBoss)
{
actor.healthHaver.ApplyDamage(10000000, Vector2.zero, "GetFuckedNerd", CoreDamageTypes.Void, DamageCategory.Unstoppable, true, null, true);
actor.sprite.renderer.enabled = false;
actor.shadowDeathType = AIActor.ShadowDeathType.None;
tk2dBaseSprite corpsesprite = actor.CorpseObject.GetComponent <tk2dBaseSprite>();
corpsesprite.sprite.renderer.enabled = false;
}
else
{
if (actor.healthHaver.IsBoss)
{
actor.healthHaver.ApplyDamage(80, Vector2.zero, "GetFuckedNerdButSlightlyLessThanNormalNerds", CoreDamageTypes.Void, DamageCategory.Unstoppable, true, null, true);
}
}
tk2dBaseSprite component1 = hand.GetComponent <tk2dBaseSprite>();
component1.usesOverrideMaterial = true;
component1.PlaceAtLocalPositionByAnchor(actor.specRigidbody.UnitCenter, tk2dBaseSprite.Anchor.LowerCenter);
component1.renderer.material.shader = ShaderCache.Acquire("Brave/Effects/StencilMasked");
cooldown -= 120;
}
}
private void HandleFear(PlayerController user, bool active)
{
RoomHandler currentRoom = user.CurrentRoom;
bool flag = !currentRoom.HasActiveEnemies(RoomHandler.ActiveEnemyType.All);
if (!flag)
{
if (active)
{
foreach (AIActor aiactor in currentRoom.GetActiveEnemies(RoomHandler.ActiveEnemyType.All))
{
bool flag2 = aiactor.behaviorSpeculator != null;
if (flag2)
{
aiactor.behaviorSpeculator.FleePlayerData = this.fleeData;
FleePlayerData fleePlayerData = new FleePlayerData();
}
}
}
else
{
foreach (AIActor aiactor2 in currentRoom.GetActiveEnemies(RoomHandler.ActiveEnemyType.All))
{
bool flag3 = aiactor2.behaviorSpeculator != null && aiactor2.behaviorSpeculator.FleePlayerData != null;
if (flag3)
{
aiactor2.behaviorSpeculator.FleePlayerData.Player = null;
}
}
}
}
}
public static void DestroyEverything()
{
RoomHandler currentRoom = GameManager.Instance.PrimaryPlayer.CurrentRoom;
List <AIActor> activeenemies_typeall = currentRoom.GetActiveEnemies(RoomHandler.ActiveEnemyType.All);
//ETGModConsole.Log("");
for (int e = 0; e < activeenemies_typeall.Count; e++)
{
AIActor enemy = activeenemies_typeall[e];
GameObject objectToInstantiate = enemy.gameObject;
UnityEngine.Object.Destroy(objectToInstantiate);
//ETGModConsole.Log(string.Format("{3}: {4}: IsDead:{0}, LIDD1:{1}, LIDD2:{2}", isdead, lastIncurredDamageDirection.ToString(), lastIncurredDamageDirection2.ToString(), e, enemy.EnemyGuid));
}
ReadOnlyCollection <Projectile> allProjectiles = StaticReferenceManager.AllProjectiles;
//ETGModConsole.Log("Active Projectiles: " + allProjectiles.Count);
for (int i = allProjectiles.Count - 1; i >= 0; i--)
{
Projectile projectile = allProjectiles[i];
if (projectile)
{
GameObject projectileObject = projectile.gameObject;
UnityEngine.Object.Destroy(projectileObject);
}
}
}
private void Start()
{
if (GameManager.Instance.CurrentLevelOverrideState == GameManager.LevelOverrideState.FOYER | GameManager.Instance.IsLoadingLevel | Dungeon.IsGenerating)
{
return;
}
m_CurrentRoom = GameManager.Instance.BestActivePlayer.CurrentRoom;
m_SpawnTimer = Random.Range(MinTimeBetweenSpawns, MaxTimeBetweenSpawns);
if (m_CurrentRoom == null)
{
return;
}
if (m_CurrentRoom.area.PrototypeRoomCategory != PrototypeDungeonRoom.RoomCategory.BOSS)
{
return;
}
if (ToadieGUIDs == null | ToadieGUIDs.Count <= 0)
{
return;
}
AssetBundle assetBundle = ResourceManager.LoadAssetBundle("brave_resources_001");
m_LootCratePrefab = assetBundle.LoadAsset <GameObject>("EmergencyCrate");
assetBundle = null;
for (int i = 0; i < MaxToadiesPerWave; i++)
{
RandomToadieAirDrop(m_LootCratePrefab, m_CurrentRoom);
}
}
// This function doesn't null check orLoadByGuid. If non fake prefab custom enemies are spawned (like the special rats on Hollow), then this would cause exception.
// Added fall back GUIDs and use one of those for AIActor instead if this happens.
public void AddSpecificEnemyToRoomProcedurallyFixed(RoomHandler room, string enemyGuid, bool reinforcementSpawn = false, Vector2?goalPosition = null)
{
AIActor orLoadByGuid = EnemyDatabase.GetOrLoadByGuid(enemyGuid);
if (!orLoadByGuid)
{
List <string> FallbackGUIDs = new List <string>()
{
ExpandCustomEnemyDatabase.BootlegBullatGUID,
ExpandCustomEnemyDatabase.BootlegBulletManGUID,
ExpandCustomEnemyDatabase.BootlegBulletManBandanaGUID,
ExpandCustomEnemyDatabase.BootlegShotgunManBlueGUID,
ExpandCustomEnemyDatabase.BootlegShotgunManRedGUID
};
FallbackGUIDs = FallbackGUIDs.Shuffle();
orLoadByGuid = EnemyDatabase.GetOrLoadByGuid(BraveUtility.RandomElement(FallbackGUIDs));
}
IntVector2 clearance = orLoadByGuid.specRigidbody.UnitDimensions.ToIntVector2(VectorConversions.Ceil);
CellValidator cellValidator = delegate(IntVector2 c) {
for (int i = 0; i < clearance.x; i++)
{
int x = c.x + i;
for (int j = 0; j < clearance.y; j++)
{
int y = c.y + j;
if (GameManager.Instance.Dungeon.data.isTopWall(x, y))
{
return(false);
}
}
}
return(true);
};
IntVector2?intVector;
if (goalPosition != null)
{
intVector = room.GetNearestAvailableCell(goalPosition.Value, new IntVector2?(clearance), new CellTypes?(CellTypes.FLOOR), false, cellValidator);
}
else
{
intVector = room.GetRandomAvailableCell(new IntVector2?(clearance), new CellTypes?(CellTypes.FLOOR), false, cellValidator);
}
if (intVector != null)
{
AIActor aiactor = AIActor.Spawn(orLoadByGuid, intVector.Value, room, true, AIActor.AwakenAnimationType.Spawn, false);
if (aiactor && reinforcementSpawn)
{
if (aiactor.specRigidbody)
{
aiactor.specRigidbody.CollideWithOthers = false;
}
aiactor.HandleReinforcementFallIntoRoom(0f);
}
}
else
{
Debug.LogError("failed placement");
}
}
public void knightPlacer(PlayerController owner)
{
AIActor orLoadByGuid = EnemyDatabase.GetOrLoadByGuid("ec8ea75b557d4e7b8ceeaacdf6f8238c");
IntVector2 aim = Vector2Extensions.ToIntVector2(owner.unadjustedAimPoint, VectorConversions.Round);
RoomHandler room = GameManager.Instance.Dungeon.data.GetAbsoluteRoomFromPosition(aim);
if (room != null && room == owner.CurrentRoom && owner.IsInCombat)
{
AIActor aiActor = AIActor.Spawn(orLoadByGuid.aiActor, owner.CenterPosition, room, true, AIActor.AwakenAnimationType.Default, true);
PhysicsEngine.Instance.RegisterOverlappingGhostCollisionExceptions(aiActor.specRigidbody, null, false);
aiActor.CanTargetEnemies = true;
aiActor.CanTargetPlayers = false;
aiActor.IsHarmlessEnemy = true;
aiActor.CanDropCurrency = false;
aiActor.IgnoreForRoomClear = true;
aiActor.MovementSpeed = 6.3f;
aiActor.gameObject.AddComponent <KillOnRoomClear>();
aiActor.reinforceType = AIActor.ReinforceType.Instant;
aiActor.HandleReinforcementFallIntoRoom(.1f);
nut = aiActor;
MindControlEffect orAddComponent = aiActor.gameObject.GetOrAddComponent <MindControlEffect>();
orAddComponent.owner = (this.gun.CurrentOwner as PlayerController);
}
}
private void Start()
{
m_StartRoom = aiActor.GetAbsoluteParentRoom();
//This line determines what happens when an enemy dies. For now it's something simple like playing a death sound.
//A full list of all the sounds can be found in the SFX.txt document that comes with this github.
base.aiActor.healthHaver.OnPreDeath += (obj) => { AkSoundEngine.PostEvent("Play_VO_kali_death_01", base.aiActor.gameObject); };
}
private void Bounty()
{
int bighead = UnityEngine.Random.Range(1, 5);
if (bighead == 1)
{
RoomHandler absoluteRoom = base.transform.position.GetAbsoluteRoom();
AIActor randomActiveEnemy = absoluteRoom.GetRandomActiveEnemy(false);
randomActiveEnemy.aiActor.ApplyEffect(HelpfulLibrary.Money, 9999f, null);
}
if (bighead == 2)
{
RoomHandler absoluteRoom = base.transform.position.GetAbsoluteRoom();
AIActor randomActiveEnemy = absoluteRoom.GetRandomActiveEnemy(false);
randomActiveEnemy.aiActor.ApplyEffect(HelpfulLibrary.Money2, 9999f, null);
}
if (bighead == 3)
{
RoomHandler absoluteRoom = base.transform.position.GetAbsoluteRoom();
AIActor randomActiveEnemy = absoluteRoom.GetRandomActiveEnemy(false);
randomActiveEnemy.aiActor.ApplyEffect(HelpfulLibrary.hegymoney, 9999f, null);
}
if (bighead == 4)
{
RoomHandler absoluteRoom = base.transform.position.GetAbsoluteRoom();
AIActor randomActiveEnemy = absoluteRoom.GetRandomActiveEnemy(false);
randomActiveEnemy.aiActor.ApplyEffect(HelpfulLibrary.moneydebuff3, 9999f, null);
}
}
private void HandleFear(PlayerController user, bool active)
{
RoomHandler room = user.CurrentRoom;
if (!room.HasActiveEnemies(RoomHandler.ActiveEnemyType.All))
{
return;
}
if (active)
{
foreach (var enemy in room.GetActiveEnemies(RoomHandler.ActiveEnemyType.All))
{
if (enemy.behaviorSpeculator != null)
{
enemy.behaviorSpeculator.FleePlayerData = this.fleeData;
FleePlayerData fleePlayerData = new FleePlayerData();
}
}
}
else
{
foreach (var enemy in room.GetActiveEnemies(RoomHandler.ActiveEnemyType.All))
{
if (enemy.behaviorSpeculator != null && enemy.behaviorSpeculator.FleePlayerData != null)
{
enemy.behaviorSpeculator.FleePlayerData.Player = null;
}
}
}
}
private void EndEffect(PlayerController player)
{
if (UnityEngine.Random.value < this.m_exhaustionChance)
{
player.StartCoroutine(this.EndEffectCR(player));
}
if (UnityEngine.Random.value < this.m_exhaustionChance)
{
List <RoomHandler> rooms = new List <RoomHandler>();
foreach (RoomHandler room in GameManager.Instance.Dungeon.data.rooms)
{
if (!room.hasEverBeenVisited)
{
rooms.Add(room);
}
}
if (rooms.Count > 0)
{
RoomHandler randomRoom = BraveUtility.RandomElement(rooms);
IntVector2? randomAvailableCell = randomRoom.GetRandomAvailableCell(new IntVector2?(GreenChamberEyeController.hallucinationEyePrefab.GetComponent <GreenChamberEyeController>().specRigidbody.UnitDimensions.ToIntVector2(VectorConversions.Ceil)),
new CellTypes?(CellTypes.FLOOR | CellTypes.PIT), false, null);
if (randomAvailableCell.HasValue)
{
Instantiate(GreenChamberEyeController.hallucinationEyePrefab, randomAvailableCell.Value.ToVector3(0), Quaternion.identity).GetComponent <GreenChamberEyeController>().BindWithRoom(randomRoom);
}
}
}
this.m_exhaustionChance = Mathf.Min(this.m_exhaustionChance += 0.01f, 0.05f);
AkSoundEngine.PostEvent("Play_ENM_lighten_world_01", player.gameObject);
this.spriteAnimator.Play("unmelt");
}
public static void roomMagic(PlayerController user)
{
//tk2dTileMap tk2dTileMap = null;
user.CurrentRoom.CompletelyPreventLeaving = true;
List <RoomHandler> rooms = GameManager.Instance.Dungeon.data.rooms;
foreach (RoomHandler roomHandler in rooms)
{
roomHandler.visibility = RoomHandler.VisibilityStatus.OBSCURED;
//roomHandler = null;
}
//List<RoomHandler>.Enumerator enumerator = default(List<RoomHandler>.Enumerator);
WarpTarget = user.CenterPosition;
RoomHandler currentRoom = user.CurrentRoom;
user.ForceStopDodgeRoll();
//this.DoTentacleVFX(user);
IntVector2?targetCenter = new IntVector2?(user.CenterPosition.ToIntVector2(VectorConversions.Floor));
Vector2 startingpoint = user.CenterPosition;
//RoomHandler creepyRoom = GameManager.Instance.Dungeon.AddRuntimeRoom(new IntVector2(30, 30), (GameObject)BraveResources.Load(room));
RoomHandler creepyRoom = tools.AddCustomRuntimeRoom(room, false, false, false, null, DungeonData.LightGenerationStyle.STANDARD);
TeleportToRoom(user, creepyRoom);
user.WarpToPoint((creepyRoom.area.basePosition + new IntVector2(12, 4)).ToVector2(), false, false);
bool flag2 = GameManager.Instance.CurrentGameType == GameManager.GameType.COOP_2_PLAYER;
if (flag2)
{
GameManager.Instance.GetOtherPlayer(user).ReuniteWithOtherPlayer(user, false);
}
}
private static void DealDamageToEnemiesInArc(PlayerController owner, Vector2 arcOrigin, float arcAngle, float arcRadius, float overrideDamage, float overrideForce, List <GameActorEffect> statusEffects, float jammedDMGMult, float bossDMGMult, float slashDimensions, List <SpeculativeRigidbody> alreadyHit = null)
{
RoomHandler roomHandler = owner.CurrentRoom;
if (roomHandler == null)
{
return;
}
List <AIActor> activeEnemies = roomHandler.GetActiveEnemies(RoomHandler.ActiveEnemyType.All);
if (activeEnemies == null)
{
return;
}
for (int i = 0; i < activeEnemies.Count; i++)
{
AIActor aiactor = activeEnemies[i];
if (aiactor && aiactor.specRigidbody && aiactor.IsNormalEnemy && !aiactor.IsGone && aiactor.healthHaver)
{
if (alreadyHit == null || !alreadyHit.Contains(aiactor.specRigidbody))
{
for (int j = 0; j < aiactor.healthHaver.NumBodyRigidbodies; j++)
{
SpeculativeRigidbody bodyRigidbody = aiactor.healthHaver.GetBodyRigidbody(j);
PixelCollider hitboxPixelCollider = bodyRigidbody.HitboxPixelCollider;
if (hitboxPixelCollider != null)
{
Vector2 vector = BraveMathCollege.ClosestPointOnRectangle(arcOrigin, hitboxPixelCollider.UnitBottomLeft, hitboxPixelCollider.UnitDimensions);
float num = Vector2.Distance(vector, arcOrigin);
if (ObjectWasHitBySlash(vector, arcOrigin, arcAngle, arcRadius, slashDimensions))
{
bool flag = true;
int rayMask = CollisionMask.LayerToMask(CollisionLayer.HighObstacle, CollisionLayer.BulletBlocker, CollisionLayer.BulletBreakable);
RaycastResult raycastResult;
if (PhysicsEngine.Instance.Raycast(arcOrigin, vector - arcOrigin, num, out raycastResult, true, true, rayMask, null, false, null, null) && raycastResult.SpeculativeRigidbody != bodyRigidbody)
{
flag = false;
}
RaycastResult.Pool.Free(ref raycastResult);
if (flag)
{
float damage = DealSwordDamageToEnemy(owner, aiactor, arcOrigin, vector, arcAngle, overrideDamage, overrideForce, statusEffects, bossDMGMult, jammedDMGMult);
if (alreadyHit != null)
{
if (alreadyHit.Count == 0)
{
StickyFrictionManager.Instance.RegisterSwordDamageStickyFriction(damage);
}
alreadyHit.Add(aiactor.specRigidbody);
}
break;
}
}
}
}
}
}
}
}
//Add the item's functionality down here! I stole most of this from the Stuffed Star active item code!
protected override void DoEffect(PlayerController user)
{
if (ChallengeManager.Instance == false)
{
ChallengeManager.ChallengeModeType = ChallengeModeType.GunslingKingTemporary;
challengeLevel += 3;
RoomHandler absoluteRoom = base.transform.position.GetAbsoluteRoom();
absoluteRoom.IsGunslingKingChallengeRoom = true;
int rewards = UnityEngine.Random.Range(1, 9);
if (rewards == 1)
{
LootEngine.SpawnItem(Gungeon.Game.Items["junk"].gameObject, user.specRigidbody.UnitCenter, Vector2.down, 0.5f, false, true, false);
}
if (rewards == 2)
{
LootEngine.SpawnItem(PickupObjectDatabase.GetById(68).gameObject, user.specRigidbody.UnitCenter, Vector2.left, 1f, false, true, false);
}
if (rewards == 3)
{
LootEngine.SpawnItem(PickupObjectDatabase.GetById(70).gameObject, user.specRigidbody.UnitCenter, Vector2.left, 1f, false, true, false);
}
if (rewards == 4)
{
LootEngine.SpawnItem(PickupObjectDatabase.GetById(297).gameObject, user.specRigidbody.UnitCenter, Vector2.left, 1f, false, true, false);
}
if (rewards == 5)
{
LootEngine.SpawnItem(PickupObjectDatabase.GetById(120).gameObject, user.specRigidbody.UnitCenter, Vector2.left, 1f, false, true, false);
}
if (rewards == 6)
{
LootEngine.SpawnItem(PickupObjectDatabase.GetById(73).gameObject, user.specRigidbody.UnitCenter, Vector2.left, 1f, false, true, false);
}
if (rewards == 7)
{
LootEngine.SpawnItem(PickupObjectDatabase.GetById(224).gameObject, user.specRigidbody.UnitCenter, Vector2.left, 1f, false, true, false);
}
if (rewards == 8)
{
LootEngine.SpawnItem(PickupObjectDatabase.GetById(137).gameObject, user.specRigidbody.UnitCenter, Vector2.left, 1f, false, true, false);
}
if (ChallengeManager.Instance == false)
{
this.Notify("Consolation Prize", "Good Luck.");
int rewards2 = UnityEngine.Random.Range(1, 4);
if (rewards2 == 1)
{
LootEngine.SpawnItem(PickupObjectDatabase.GetById(70).gameObject, user.specRigidbody.UnitCenter, Vector2.left, 1f, false, true, false);
}
if (rewards2 == 2)
{
LootEngine.SpawnItem(PickupObjectDatabase.GetById(68).gameObject, user.specRigidbody.UnitCenter, Vector2.left, 1f, false, true, false);
}
if (rewards2 == 3)
{
LootEngine.SpawnItem(PickupObjectDatabase.GetById(70).gameObject, user.specRigidbody.UnitCenter, Vector2.left, 1f, false, true, false);
}
}
}
}
private IEnumerator HandleDoorAutoClose()
{
if (DoorLightObject && DoorLightObject.GetComponent <tk2dSprite>())
{
DoorLightObject.GetComponent <tk2dSprite>().SetSprite("EXSecretDoor_Light_Red");
}
RoomHandler PlayerParentRoom = GameManager.Instance.PrimaryPlayer.GetAbsoluteParentRoom();
if (PlayerParentRoom != null && PlayerParentRoom == m_parentRoom)
{
AkSoundEngine.PostEvent("Play_OBJ_cardoor_close_01", gameObject);
}
spriteAnimator.Play("door_close");
while (spriteAnimator.IsPlaying("door_clsoe"))
{
yield return(null);
}
specRigidbody.PixelColliders[0].Enabled = true;
if (sprite.HeightOffGround != -1.5f)
{
sprite.HeightOffGround = -1.5f;
sprite.UpdateZDepth();
}
m_IsInMovment = false;
yield break;
}
public override void Update()
{
base.Update();
if (!Dungeon.IsGenerating && m_PickedUp)
{
if (m_HammersHidden && LastOwner && LastOwner.GetAbsoluteParentRoom() != null)
{
if (!LastOwner.IsInCombat)
{
m_HammersHidden = false;
if (StaticReferenceManager.AllEnemies.Count > 0)
{
List <AIActor> m_BabyHammers = new List <AIActor>();
foreach (AIActor enemy in StaticReferenceManager.AllEnemies)
{
if (enemy.EnemyGuid == CompanionGuid && enemy.IsGone)
{
RoomHandler CurrentRoom = LastOwner.GetAbsoluteParentRoom();
// Vector3 ReturnPosition = (LastOwner.gameObject.transform.position + new Vector3(UnityEngine.Random.Range(0, 0.25f), 4.5f));
Vector3 ReturnPosition = (new Vector3(0, 5.5f) + LastOwner.CurrentRoom.GetBestRewardLocation(new IntVector2(2, 2), RoomHandler.RewardLocationStyle.PlayerCenter, false).ToVector3());
StartCoroutine(HandleHammerReturn(enemy, ReturnPosition));
}
}
}
}
}
}
}
//only the host of a room can destroy a room
private void DestroyRoomAckEvent(string reqData, Hashtable roomList, Hashtable roomClassList)
{
//reqData = roomNo+":"+validUid+":DestroyRoom"
roomData = reqData.Split(':');
/*roomClassList: key = room number, value = room class
*roomList: key = host id, value = room number
*/
try
{
room = (RoomHandler)roomClassList[roomData[0]];
room.SendToClient("DestroyRoomAck");
//remove everything related to the current room
roomClassList.Remove(roomData[0]);
roomList.Remove(roomData[1]);
}
//Handle Exception
catch (Exception ex)
{
Console.WriteLine(ex);
return;
}
}
private void StartAckEvent(string reqData, Hashtable roomList, Hashtable roomClassList)
{
//"StartReq"+roomNo+validUid
roomData = reqData.Split(':');
try
{
/*roomClassList: key = room title, value = room class
*roomList: key = host id, value = room title
*/
room = (RoomHandler)roomClassList[roomData[1]];
if (room.isFull == false) Send("GuestNotArriveNoti");
else if (room.isReady == true)
{
room.isStart = true;
//call start game function to allocate a game class instance
room.startGame();
room.SendToClient(roomData[1] + ":StartAck");
//remove a room number from a list, so that it doesn't appear on the lobby
roomList.Remove(roomData[2]);
}
else Send("GuestNotReadyNoti");
}
//Handle Exception
catch (Exception ex)
{
Console.WriteLine(ex);
return;
}
}
// send the list of possible moves of the clicked
private void PossiblePathAckEvent(string reqData, Hashtable roomClassList)
{
/* isHost+":"+roomNo+":"+"PossibleMoveReq"+":"+myPieceName+":"+myStartPos
*/
List<int> PossibleMoveList = new List<int>();
roomData = reqData.Split(':');
try
{ /* roomClassList: key = room number, value = room class
* find a right room for received room number from a client
* and send acknowledgement
*/
room = (RoomHandler)roomClassList[roomData[1]];
if (room.isStart == true)
{
/* only startPos and finalPos are needed to proceed the movement
* since the server knows a board status
*/
PossibleMoveList = room.getPossibleMove(int.Parse(roomData[4]));
/* send to the client only if PossibleMoveList contains an integer value
* meaning the clicked piece can be moved
*/
if (PossibleMoveList != null)
{
Send(string.Join(":", PossibleMoveList) + ":" + roomData[4] + ":PossiblePathAck");
}
}
else Send("NotStartNoti");
}
//Handle Exception
catch (Exception ex)
{
Console.WriteLine(ex);
return;
}
}
private void ReadyAckEvent(string reqData, Hashtable roomClassList)
{
//Send(s, "ReadyReq:"+roomNo, 1000);
roomData = reqData.Split(':');
try
{
/* roomClassList: key = room number, value = room class
* find a right room for received room number from a client
* and send acknowledgement
*/
room = (RoomHandler)roomClassList[roomData[1]];
room.isReady = !room.isReady;
if (room.isReady == true)
Send("ReadyAck");
else
Send("CancelReadyAck");
return;
}
//Handle Exception
catch (Exception ex)
{
Console.WriteLine(ex);
return;
}
}
//send the current status of captured piece
private void StatusAckEvent(Hashtable roomClassList)
{
try
{ /* roomClassList: key = room number, value = room class
* find a right room for received room number from a client
* and send acknowledgement
*/
room = (RoomHandler)roomClassList[roomData[1]];
Send(room.getCapturedPieceStatus()+":StatusAck");
}
//Handle Exception
catch (Exception ex)
{
Console.WriteLine(ex);
return;
}
}
void Start() {
roomHandler = this.GetComponent<RoomHandler>();
}
private void LeaveRoomAckEvent(string reqData, Hashtable roomClassList)
{
//reqData =roomNo+":"+validUid+":LeaveRoom"
roomData = reqData.Split(':');
try
{
room = (RoomHandler)roomClassList[roomData[0]];
room.ResetIsFull();
room.SendToClient(roomData[0] + ":LeaveRoomAck");
}
//Handle Exception
catch (Exception ex)
{
Console.WriteLine(ex);
return;
}
}
private void JoinRoomAckEvent(string reqData, Hashtable roomList)
{
//Send(s, validUid + ":" + roomName + ":JoinRoomReq", 1000);
roomData = reqData.Split(':');
try
{
/*roomClassList: key = room number, value = room class
*roomList: key = host id, value = room number
*/
room = (RoomHandler)roomClassList[roomData[1]];
//only if there is no guest in a room, a player can join
if (!room.isFull)
{
room.guestStartRoom(tcpClient);
room.guestName = roomData[0];
Console.WriteLine(room.guestName);
//indicates the room is already full
room.isFull = true;
//look for host id, and send it to a client
foreach (DictionaryEntry entry in roomList)
{
if (entry.Value.ToString() == roomData[1])
{
string result = entry.Key.ToString();
room.SendToClient(result + ":" + roomData[0] + ":JoinRoomAck");
room.isReady = false;
}
}
}
else
{
//if a room is full, a player cannot join a room
Send("FullRoomNoti");
}
}
catch (Exception ex)
{
throw ex;
}
}
//
private void MoveAckEvent(string reqData, Hashtable roomClassList)
{
/* isHost+":"+roomNo+":"+"MoveReq"+":"+myPieceName+":"+myStartPos+":"+myFinalPos
* isHost argument is needed for define who won the game and who lost the game
*/
roomData = reqData.Split(':');
try
{ /* roomClassList: key = room number, value = room class
* find a right room for the received room number
* and send acknowledgement
*/
room = (RoomHandler)roomClassList[roomData[1]];
if (room.isStart == true)
{
/* only startPos and finalPos are needed to proceed the movement
* since the server knows a board status
*/
bool isValidMove = room.getMovePos(int.Parse(roomData[4]), int.Parse(roomData[5]));
if (isValidMove)
{
room.setTurn(roomData[0]);
room.SendToClient(roomData[0] + ":" + roomData[1] + ":MoveAck:" + roomData[3] + ":" + roomData[4] + ":" + room.RealFinalPos);
/* any special move? like enpassant and castling?
* These two must be notified separately to the clients
*/
//EnPassant
if (room.Enpassant != null)
{
room.SendToClient(room.Enpassant.ToString() + ":EnPassant");
room.Enpassant = null;
}
//Castling
if (room.StartPosCastling != null)
{
room.SendToClient(room.StartPosCastling.ToString() + ":"+ room.FinalPosCastling.ToString() + ":Castling");
room.StartPosCastling = null;
room.FinalPosCastling = null;
}
/* then send the status of the game along with the roomData[0](isHost value).
* if either checkmate, draw then notifies the clients to end the game
* if check, notifies the client to show 'check' pop-up window
*/
switch (room.getStatus())
{
case "Check":
case "Stalemate":
case "Normal":
case "DrawByFiftyMove":
case "DrawByLackOfMaterial":
case "DrawByThreefold":
room.SendToClient(roomData[0] +":"+ room.getStatus());
break;
case "Checkmate":
room.SendToClient(roomData[0] +":"+ room.getStatus());
//if the move was made by the host, then do the number of the win games += 1 to host
if (roomData[0] == "True")
{
UpdateRankIfWin(room.hostName);
UpdateRankIfLose(room.guestName);
}
//if the move was made by the guset, then do the number of the win games += 1 to guest
else if (roomData[0] == "False")
{
UpdateRankIfWin(room.guestName);
UpdateRankIfLose(room.hostName);
}
break;
default:
break;
}
}
else {
//Send("NotMoveNoti");
}
}
//room.SendToClient(reqData);
else Send("NotStartNoti");
}
//Handle Exception
catch (Exception ex)
{
Console.WriteLine(ex);
return;
}
}
