private void Start()
{
monsterController = FindObjectOfType <MonsterController>();
playerController = FindObjectOfType <PlayerController>();
_level = 1;
_hp = 100;
_maxHp = 100;
_attack = 7;
_defense = 0;
_moveSpeed = 5.0f;
if (transform.gameObject.name == "Monster_blue")
{
monsterController._monsterType = MonsterController.MonsterType.Blue;
}
else if (transform.gameObject.name == "Monster_green")
{
monsterController._monsterType = MonsterController.MonsterType.Green;
}
else if (transform.gameObject.name == "Monster_red")
{
monsterController._monsterType = MonsterController.MonsterType.Red;
}
}
//加载怪物
public void LoadMonster(int wave)
{
List <MonsterSpawnData> monsterLst = this.mapCfg.monsterLst;
for (int i = 0; i < monsterLst.Count; i++)
{
if (monsterLst[i].mWave == wave)
{
MonsterSpawnData msd = monsterLst[i];
GameObject go = resSvc.LoadPrefab(msd.mCfg.resPath);
go.transform.localPosition = msd.mBornpos;
go.transform.localEulerAngles = msd.mBornRote;
go.transform.name = string.Format("{0}_{1}_{2}", msd.mCfg.id, msd.mWave, msd.mIndex);
MonsterController monsterCtrl = go.GetComponent <MonsterController>();
EntityMonster entityMonster = new EntityMonster();
entityMonster.SetMonsterCfg(msd);
entityMonster.Name = go.transform.name;
entityMonster.SetBattleMgr(this);
entityMonster.SetSkillMgr(this.skillMgr);
entityMonster.SetStateMgr(this.stateMgr);
entityMonster.SetBattleProps(msd.mCfg.bps);
entityMonster.SetController(monsterCtrl);
monsterDic.Add(go.name, entityMonster);
entityMonster.SetActive(false);
GameRoot.instance.dynamicWind.AddHpItemInfo(entityMonster.Name, entityMonster.HP, monsterCtrl.itemRoot);
}
}
}
private void OnTriggerEnter2D(Collider2D collision)
{
if (collision.tag == "Player" && !isConneted && !untouchable)
{
line = collision.GetComponent <PlayerController>().line;
me = line.Count;
front = me - 1;
if (front == 0)
{
playerCtrl = line[front].GetComponent <PlayerController>();
}
else
{
frontMonsterCtrl = line[front].GetComponent <MonsterController>();
}
playerCtrl = collision.GetComponent <PlayerController>();
playerCtrl.stompFX.Add(stompFX);
line.Add(transform);
parentPlayer = collision.transform;
gameObject.layer = LayerMask.NameToLayer("Monsters");
isConneted = true;
}
}
public void OnUpdate(MonsterController controller)
{
foreach (var skillExcute in skillExecutes)
{
skillExcute.OnUpdate(controller);
}
}
public void OnMonsterLoaded(GameObject m)
{
MonsterController controller = m.GetComponent <MonsterController>();
MonsterData md = controller.MonsterEntityData.MD;//晚于OnShow执行
EntityMonster em = new EntityMonster {
BattleMgr = this,
StateMgr = m_StateMgr,
SkillMgr = m_SkillMgr
};
//设置初始属性
em.Md = md;
em.SetBattleProps(md.mCfg.bps);
em.Name = "m" + md.mWave + "_" + md.mIndex;
MonsterController mc = m.GetComponent <MonsterController>();
mc.Init();
em.SetCtrl(mc);
mc.gameObject.SetActive(false);
monsterDic.Add(m.name, em);
if (md.mCfg.mType == MonsterType.Normal)
{
GameEntry.UI.AddHpItemInfo(m.name, mc.hpRoot, em.HP);
}
else if (md.mCfg.mType == MonsterType.Boss)
{
SetBossHPBarStateEventArgs stateEventArgs = ReferencePool.Acquire <SetBossHPBarStateEventArgs>();
stateEventArgs.Fill(true);
GameEntry.Event.Fire(this, stateEventArgs);
}
}
void Awake()
{
if(Instance == null)
{
Instance = this;
}
}
// OnStateEnter is called when a transition starts and the state machine starts to evaluate this state
override public void OnStateEnter(Animator animator, AnimatorStateInfo stateInfo, int layerIndex)
{
player = GameObject.FindObjectOfType <PlayerController>().gameObject;
controller = animator.gameObject.GetComponent <MonsterController>();
target = Random.insideUnitSphere + controller.transform.position;
target.z = 0;
}
private void HandleFeed()
{
Collider2D enemyCollider = Physics2D.OverlapCircle(transform.position, .2f, deadEnemyCollisionLayer);
if (enemyCollider != null)
{
MonsterController enemyController = enemyCollider.GetComponent <MonsterController>();
if (enemyController != null)
{
// TODO: Hide the body in the middle of the animation after the bite phase
//MonsterController enemyController = Utils.GetComponentAtPosition2D<MonsterController>(transform.position);
float healthGain = enemyController.Heal;
health.CurrentValue += healthGain;
eatenEnemies++;
Destroy(enemyController.gameObject);
EndTurn();
return;
}
else
{
Debug.LogError("No enemy controller found during feed!!");
}
}
else
{
Debug.LogError("No enemy collider found during feed!!");
}
Debug.LogError("Somehow tried to consume enemy that wasn't there (no collider or enemyController found under the player)!");
EndTurn();
}
// Start is called before the first frame update
public void Start()
{
seeker = GetComponent <Seeker>();
speed = GameManager.Instance.gridScale.x;
monsterController = GetComponent <MonsterController>();
//seeker.StartPath(transform.position, targetPosition.position, OnPathComplete);
}
void Shoot()
{
muzzleFlash.Play();
currentAmmo--;
RaycastHit hit;
if (Physics.Raycast(fpsCam.transform.position, fpsCam.transform.forward, out hit, range))
{
//Debug.Log(hit.transform.name);
CrateDamage crate = hit.transform.GetComponent <CrateDamage>();
MonsterController monster = hit.transform.GetComponent <MonsterController>();
if (crate != null)
{
crate.TakeDamage(damage);
}
if (monster != null)
{
player.playerScore += 10;
monster.TakeDamage(damage);
GameObject ImpactGO = Instantiate(impactEffect, hit.point, Quaternion.LookRotation(hit.normal));
Destroy(ImpactGO, 2f);
}
}
}
public void EndMonsterMove(MonsterController aMonster, int aRemainingVelocity)
{
if (monsterSelected != null && monsterSelected.gameObject == aMonster.gameObject)
{
BoardController.instance.ShowFloorCanMove(monsterSelected.idFloor, monsterSelected.playerOwner, aRemainingVelocity);
}
}
public IEnumerable ItIgnoresZeroAndNegativeDamage()
{
IMonster monster = GetMonsterMock();
MonsterController controller = GetControllerMock(monster);
controller = SetWithSingleWaypoint(controller, monster);
//zero
controller.GetDamage(0);
monster.DidNotReceiveWithAnyArgs().ChangeHealthBar(0.1f);
monster.DidNotReceiveWithAnyArgs().Die(10);
yield return(null);
monster.DidNotReceiveWithAnyArgs().ChangeColor(Color.black);
//negative
controller.GetDamage(-100);
monster.DidNotReceiveWithAnyArgs().ChangeHealthBar(0.1f);
monster.DidNotReceiveWithAnyArgs().Die(10);
yield return(null);
monster.DidNotReceiveWithAnyArgs().ChangeColor(Color.black);
}
public void Init()
{
monsterController = GameManager.Instance.monsterController;
if (monsterController.monsterData.hunger == monsterController.monsterData.MAX_HUNGER || monsterController.IsSick())
{
// TODO: play monster refusing animation
Debug.Log("Don't want to eat.");
ViewManager.Instance.DeactivateView(FEED_VIEW);
}
else
{
feedData = ViewManager.Instance.GetView(FEED_VIEW).GetComponent <FeedData>();
var view = ViewManager.Instance.GetView(FEED_VIEW);
CurrentFeedOption = ActionType.FeedOption.Meal;
panel = view.transform.GetChild(0).gameObject;
panel.SetActive(true);
meal = view.transform.GetChild(1).GetComponent <Image>();
meal.gameObject.SetActive(true);
Util.ShowObject(meal);
snack = view.transform.GetChild(2).GetComponent <Image>();
snack.gameObject.SetActive(true);
Util.MakeObjectSeeThrough(snack);
ViewManager.Instance.ActivateView(FEED_VIEW);
isDone = false;
}
}
public void UnRegisterMonster(MonsterController monster)
{
if (CurrentMonsters != null && CurrentMonsters.Contains(monster.gameObject))
{
CurrentMonsters.Remove(monster.gameObject);
}
}
public void GoBackToNest(MonsterController controller)
{
if (controller.path == null || controller.path.Count == 0)
{
controller.wayPointList = new List <Vector2>();
controller.wayPointList.Add(FindObjectOfType <MapController>().GetNestPosition());
controller.path = controller.aStart.GetPathFromTo(controller.transform.position, controller.wayPointList[0]);
}
else
{
if (controller.path == null || controller.path.Count == 0)
{
controller.path = controller.aStart.GetPathFromTo(controller.transform.position, controller.wayPointList[0]);
}
Vector2 direction = controller.path[0] - (Vector2)controller.transform.position;
direction.Normalize();
controller.body.velocity = direction * controller.stats.speed;
if (Vector2.Distance(controller.transform.position, controller.path[0]) < controller.stats.stopingDistance)
{
controller.path.RemoveAt(0);
if (Vector2.Distance(controller.transform.position, controller.wayPointList[0]) < controller.stats.stopingDistance)
{
FindObjectOfType <MonsterManager>().PlayerFounded();
Destroy(controller.gameObject);
}
}
}
}
void Update()
{
if (!isServer)
{
return;
}
RaycastHit hit;
Physics.Raycast(_light.transform.position, _light.transform.forward, out hit, 20);
if (hit.collider != null)
{
MonsterController monster = hit.collider.GetComponent <MonsterController>();
if (monster)
{
monster.Spot(_avatarName, _lastMonsterHit == monster);
_lastMonsterHit = monster;
}
else
{
if (_lastMonsterHit)
{
_lastMonsterHit.StopSpotting(_avatarName);
}
_lastMonsterHit = null;
}
}
}
///////////////////////End of Variables/////////////////////////
///////////////////////////Functions////////////////////////////
// Use this for initialization
void Start()
{
// Script references
questManager = GameObject.FindGameObjectWithTag(Tags.gameControllerTag).GetComponent <QuestManager>();
monsterManager = GameObject.FindGameObjectWithTag(Tags.gameControllerTag).GetComponent <MonsterManager>();
monsterController = GetComponent <MonsterController>();
}
protected override void OnUpdate()
{
if (IsPressDown() && joint == null)
{
if (lastCollider == null)
{
return;
}
Rigidbody targetRig = lastCollider.gameObject.GetComponent <Rigidbody>();
if (targetRig != null)
{
MonsterController monsterController = lastCollider.transform.GetComponentInParent <MonsterController>();
if (monsterController != null)
{
joint = gameObject.AddComponent <FixedJoint>();
joint.connectedBody = targetRig;
monsterController.Grab(Vector3.zero);
}
}
}
else if (joint != null && IsPressUP())
{
MonsterController monsterController = joint.transform.root.GetComponent <MonsterController>();
DestroyImmediate(joint);
if (monsterController != null)
{
monsterController.Drop();
}
joint = null;
}
}
public void OnSmallArcaneDummyDied(MonsterController monsterController)
{
smallArcaneDummy.GetComponent <MonsterController> ().OnMonsterDied -= OnSmallArcaneDummyDied;
outfitter.rightControllerTooltips.UpdateText(VRTK_ControllerTooltips.TooltipButtons.TriggerTooltip, "");
outfitter.leftControllerTooltips.UpdateText(VRTK_ControllerTooltips.TooltipButtons.TriggerTooltip, "");
scriptContinue = true;
}
void Explore(MonsterController controller)
{
if (controller.wayPointList.Count == 0)
{
controller.wayPointList.Add(FindObjectOfType <MapController>().GetPatrolPoint());
if (controller.wayPointList.Count != 0)
{
controller.path = controller.aStart.GetPathFromTo(controller.transform.position, controller.wayPointList[0]);
}
}
else
{
Vector2 direction = controller.path[0] - (Vector2)controller.transform.position;
direction.Normalize();
controller.body.velocity = direction * controller.stats.speed;
if (Vector2.Distance(controller.transform.position, controller.path[0]) < controller.stats.stopingDistance)
{
controller.path.RemoveAt(0);
if (controller.path.Count == 0)
{
controller.wayPointList.RemoveAt(0);
}
}
}
}
void OnTriggerEnter(Collider col)
{
if (col.GetComponent <MonsterController>() && col.GetComponent <MonsterController>().playerOwner != trapController.playerOwner)
{
monsterDetected = col.GetComponent <MonsterController>();
}
}
public OpdaterKendtegn(MonsterController monster, Menu menu)
{
InitializeComponent();
OpdaterList.ItemsSource = monster.list.Getmonster();
this.Menu = menu;
this.Monster = monster;
}
void Awake()
{
if (cardImage == null)
{
cardImage = GetComponent <Image>();
}
if (canvas == null)
{
canvas = GetComponent <Canvas>();
}
if (playerHandController == null)
{
playerHandController = GetComponentInParent <PlayerHandController>();
}
if (battleController == null)
{
battleController = GameObject.FindGameObjectWithTag("MainCamera").GetComponent <BattleController>();
}
if (playerController == null)
{
playerController = GameObject.FindGameObjectWithTag("Player").GetComponent <MonsterController>();
}
if (userController == null)
{
userController = GameObject.FindGameObjectWithTag("MainCamera").GetComponent <UserController>();
}
}
protected virtual void ProcessWeaponCollision(Collider collider, Vector3 dir, Vector3 hitPoint)
{
Vector3 direction = -dir * hitForce;
MonsterController monsterController = collider.transform.GetComponentInParent <MonsterController>();
if (monsterController != null)
{
target = monsterController.gameObject;
// targetRigidbody = target.GetComponent<Rigidbody>();
monsterController.Hit(collider, direction, hitPoint, damage);
}
int effectNum;
if (effects == null)
{
effectNum = 0;
}
else
{
effectNum = effects.Length;
}
if (effectNum > 0)
{
int eindex = Random.Range(0, effectNum);
GameObject go = (GameObject)GameObject.Instantiate(effects[eindex], hitPoint, Quaternion.identity);
Object.Destroy(go, 1);
}
}
public void UpdateMesh()
{
if (tasks == null)
{
tasks = new HashSet <Task>();
}
if (tasks.Count > 0 && FUtils.All(tasks, task => task == null || task.IsCompleted || task.IsFaulted || task.IsCanceled))
{
tasks.Clear();
FUtils.Elvis(eventManager, eventManager =>
eventManager.DiggingChanged(DiggingMode.NotDigging));
navMesh = new NavMesh();
foreach (VoxelSurface surface in GetComponentsInChildren <VoxelSurface>())
{
surface.UpdateMesh();
navMesh.Merge(surface.navMesh, surface.meshCoords, pointDensity, surface.transform);
}
Debug.Log("Finished generating mesh positions count=" + navMesh.positions.Count);
if (navMesh.positions.Count > 0)
{
player = FindObjectOfType <SimpleController>();
monster = FindObjectOfType <MonsterController>();
localPlayerPosition = transform.InverseTransformPoint(player.transform.position);
localCreaturePosition = transform.InverseTransformPoint(monster.transform.position);
playerCell = navMesh.ClosestCell(localPlayerPosition);
monsterCell = navMesh.ClosestCell(localCreaturePosition);
path = navMesh.FindPath(localPlayerPosition, localCreaturePosition);
}
}
}
void Start()
{
tintControl = GetComponentInChildren <TintControl>();
mController = GetComponent <MonsterController>();
pController = FindObjectOfType <PlayerController>();
contact = mController.detectLayer;
}
private bool CheckMeet(bool isRobiMove, MonsterController currentMonster = null)
{
bool willMeet = false;
if (isRobiMove)
{
Coordinate RobiNext = RobiController.GetNextPos();
foreach (var monster in MonsterControllers)
{
var monsterCoor = monster.GetCurrentPos();
if (Helper.CheckCoorEqual(RobiNext, monsterCoor))
{
willMeet = true;
break;
}
}
}
else
{
Coordinate robiCurrent = RobiController.GetCurrentPos();
Coordinate monsterNext = currentMonster.GetNextPos();
if (Helper.CheckCoorEqual(robiCurrent, monsterNext))
{
willMeet = true;
}
}
return(willMeet);
}
private void Patrol(MonsterController controller)
{
if (controller.wayPointList.Count == 0)
{
controller.wayPointList = FindObjectOfType <MapController>().GetPatrolsPointForRegion(controller.transform);
if (controller.wayPointList.Count != 0)
{
controller.path = controller.aStart.GetPathFromTo(controller.transform.position, controller.wayPointList[controller.nextWayPoint]);
}
}
else
{
if (controller.path == null || controller.path.Count == 0)
{
controller.path = controller.aStart.GetPathFromTo(controller.transform.position, controller.wayPointList[controller.nextWayPoint]);
}
Vector2 direction = controller.path[0] - (Vector2)controller.transform.position;
direction.Normalize();
controller.body.velocity = direction * controller.stats.speed;
if (Vector2.Distance(controller.transform.position, controller.path[0]) < controller.stats.stopingDistance)
{
controller.path.RemoveAt(0);
if (Vector2.Distance(controller.transform.position, controller.wayPointList[controller.nextWayPoint]) < controller.stats.stopingDistance)
{
controller.nextWayPoint = (controller.nextWayPoint + 1) % controller.wayPointList.Count;
controller.path = controller.aStart.GetPathFromTo(controller.transform.position, controller.wayPointList[controller.nextWayPoint]);
}
}
}
}
// Use this for initialization
void Start()
{
differenceBound = windowMaxBound - windowMinBound;
rangeWaitBound = 100.0f - windowMinBound;
positionY = transform.localPosition.y;
if (isPlayer)
{
playerController = trackedMonster.GetComponent <PlayerController>();
}
else
{
monsterController = trackedMonster.GetComponent <MonsterController>();
}
if (monsterController == null)
{
Debug.Log("monsterController for Tick GUI is null");
}
if (playerController == null)
{
Debug.Log("playerController for Tick GUI is null");
}
//must be called otherwise will not have an initial state to begin with
//currentState = GaugeState.INCREASING;
}
void CreateEntityGO(Entity e)
{
GameObject go = new GameObject(e.Name);
Transform parent;
if ((e.GetType() == typeof(Item)) || (e.GetType() == typeof(Weapon)))
{
ItemController controller = go.AddComponent <ItemController>();
controller.Item_data = e as Item;
parent = GameObject.Find("Items").GetComponent <Transform>();
go.transform.parent = parent;
}
else if (e.GetType() == typeof(Monster))
{
MonsterController controller = go.AddComponent <MonsterController>();
controller.Monster_data = e as Monster;
parent = GameObject.Find("Monsters").GetComponent <Transform>();
go.transform.parent = parent;
}
go.transform.position = new Vector3(e.Tile.X, e.Tile.Y, 0);
TextMeshPro tmp = go.AddComponent <TextMeshPro>();
tmp.text = e.Symbol.ToString();
// tmp.fontSize = 9;
tmp.color = e.Color;
tmp.alignment = TextAlignmentOptions.Center;
go.GetComponent <RectTransform>().sizeDelta = new Vector2(1, 1);
// controller.Refresh(e, go);
}
// Update is called once per frame
void Update()
{
m_mon = transform.GetComponentInChildren <MonsterController>(true);
if (m_mon != null)
{
m_mon.isFieldMon = true;
foreach (Item item in m_itemList)
{
m_mon.SetItem(item);
}
if (!m_mon.isActiveAndEnabled)
{
m_spawnTime += Time.deltaTime;
if (m_spawnTime >= 5.0f)
{
m_mon.gameObject.transform.position = gameObject.transform.position;
m_mon.gameObject.transform.LookAt(m_centerPos.transform);
m_mon.curState = MonsterController.CurrentState.idle;
m_mon.GetComponent <Animator>().speed = 1;
m_mon.gameObject.SetActive(true);
m_mon.Coroutine();
m_spawnTime = 0.0f;
}
}
}
}
public EnemyCharacter(CharacterType characterType, MonsterController controller) {
this.characterType = characterType;
MovementSpeed = GameProperties.DEFAULT_ENEMY_SPEED;
this.controller = controller;
OnDeathAction += OnDeath;
SetupCharacter();
}
void Start()
{
sequencer = GetComponent<Sequencer>();
sequencer.tempo = tempo;
sequencer.OnNextBar += OnNextBar;
cameraController = GetComponent<CameraController>();
monster =
GameObject.Instantiate(monsterPrefab).GetComponent<MonsterController>();
monster.speechGui = monsterSpeechGui;
monster.SetLeftEnd(cameraController.ScreenLeft);
monster.speakSpeed = 8.0f / tempo;
line = GameObject.Instantiate(groundPrefab).GetComponent<LineController>();
line.SetStartPoint(monster.GetRightEnd());
line.SetLength(0.5f * cameraController.ScreenSize - monster.GetRightEnd());
}
void Start()
{
vehicle = i_vehicle;
vehicleInner = i_vehicleInner;
labMusic = i_labMusic;
lhcMusic = i_lhcMusic;
labNoise = i_labNoise;
lhcNoise = i_lhcNoise;
lhcNoise = i_lhcNoise;
deathSound = i_deathSound;
mouseKeyboardInput = mouseKeyboard1nput;
monster = i_monster;
difficulty = 1.0f;
if(tutorialMode) tutorialSetup();
}
public void setControllers(MonsterController monsterController, PlayerController playerController)
{
this.monsters = monsterController;
this.players = playerController;
}
public void Attack(int attackType, MonsterController monster) {
int power = this._npc._attack_power;
float attack_margin = Random.Range(-0.2f,0f);
float weakness = monster.getWeaknessByChoosenAttack(attackType);
int damage_formula = (int) Mathf.Ceil(power + power*attack_margin + power*weakness);
Debug.Log ("Leroy hitted enemy by "+ damage_formula);
monster.getNpc().hit(damage_formula);
}
public static Character GetEnemyCharacter(CharacterType characterType, MonsterController controller) {
Character character = new EnemyCharacter(characterType, controller);
return character;
}
private static float Circle(MonsterController mc)
{
switch (mc.state)
{
case MonState.Derpy:
{
// run in circles
mc.randomSteer += Random.Range(-0.2f, 0.2f) * Time.fixedDeltaTime;
mc.randomSteer = Mathf.Clamp(mc.randomSteer, -0.05f, 0.05f);
return (((Time.time * mc.turningSpeed) + mc.randomSteer) % 1f);
}
case MonState.Escaping:
{
// continuously run towards chosen escape angle
return mc.escapeAngle;
}
default:
break;
}
return 0;
}
private static float RunToPointAndPause(MonsterController mc)
{
Debug.LogError("Error: Movement Function (Slow) has not yet been implemented");
return 0;
}
void Awake()
{
controllerScript = (MonsterController)target;
}
private static float Boss(MonsterController mc)
{
Debug.LogError("Error: Movement Function (Boss) has not yet been implemented");
return 0;
}
static IEnumerator ShowFinishUI(float waitTime, MonsterController mc)
{
yield return new WaitForSeconds(waitTime);
mc.finishUI.SetActive(true);
}
void Start()
{
pointsText.text = "0";
currentHealth = health;
initialHealthLength = healthUI.sizeDelta.x;
This = this;
target = transform.position;
redGlow.SetActive(false);
greenGlow.SetActive(false);
redLaserEffect = Instantiate(redLaserEffectPrefab);
redLaserEffect.SetActive(false);
greenLaserEffect = Instantiate(greenLaserEffectPrefab);
greenLaserEffect.SetActive(false);
}
public static Engine Start()
{
Container
.For<ConsoleWindow>()
.Provide(c => new ConsoleWindow(80, 220, "Explorer"))
.AsSingleton();
Container
.For<IGraphicsComponent>()
.Provide<AsciiGraphicsComponent>();
Container
.For<Player>()
.Provide(c =>
{
return new Player() { X = 10, Y = 15, EnergyDelta = 500 };
}).AsSingleton();
Container.For<ITileFactory>().Provide<NaturalCaveCaTileFactory>();
Container.For<World>()
.Provide(c =>
{
var world = new World();
world.Player = c.Resolve<Player>();
world.Map = MapLoader.LoadMap(c.Resolve<ITileFactory>());
return world;
}).AsSingleton();
Container
.For<IInputHandler>()
.Provide<InputHandler>();
Container
.For<IView<Creature>>()
.Provide<MonsterView>();
Container
.For<IView<Player>>()
.Provide<PlayerView>();
Container
.For<IView<Furniture>>()
.Provide<MapView>();
Container
.For<IView<GameLog>>()
.Provide<GameLogView>();
Container
.For<IFovStrategy>()
.Provide<AlwaysVisibleFovStrategy>();
Container
.For<PlayerController>()
.Provide<PlayerController>();
Container
.For<GameLog>()
.Provide(c => new GameLog { X = 1, Y = 60 })
.AsSingleton();
Container
.For<ILogController>()
.Provide<GameLogController>();
Container
.For<IMoveHelper>()
.Provide<EntityMoveHelper>();
Container
.For<Engine>()
.Provide<Engine>()
.AsSingleton();
var monsters = new List<Creature>()
{
new Creature() { X = 15, Y = 10, EnergyDelta = 100 },
new Creature() { X = 23, Y = 20, EnergyDelta = 250 },
new Creature() { X = 10, Y = 10, EnergyDelta = 100 },
new Creature() { X = 29, Y = 20, EnergyDelta = 10 },
new Creature() { X = 18, Y = 10, EnergyDelta = 100 },
new Creature() { X = 31, Y = 20, EnergyDelta = 100 },
new Creature() { X = 10, Y = 10, EnergyDelta = 100 },
new Creature() { X = 38, Y = 20, EnergyDelta = 250 },
new Creature() { X = 10, Y = 10, EnergyDelta = 100 },
new Creature() { X = 15, Y = 20, EnergyDelta = 10 },
new Creature() { X = 34, Y = 10, EnergyDelta = 100 },
new Creature() { X = 18, Y = 20, EnergyDelta = 300 },
new Creature() { X = 12, Y = 10, EnergyDelta = 100 },
new Creature() { X = 12, Y = 20, EnergyDelta = 250 },
new Creature() { X = 23, Y = 10, EnergyDelta = 100 },
new Creature() { X = 39, Y = 20, EnergyDelta = 10 },
new Creature() { X = 26, Y = 10, EnergyDelta = 100 },
new Creature() { X = 20, Y = 20, EnergyDelta = 500 },
};
var engine = Container.Resolve<Engine>();
foreach (var monster in monsters)
{
var controller = new MonsterController(monster,
Container.Resolve<IView<Creature>>(),
Container.Resolve<World>(),
Container.Resolve<IMoveHelper>(), Container.Resolve<ILogController>());
engine.AddActor(monster, controller);
}
engine.ActorControllers.Add(Container.Resolve<PlayerController>());
foreach (var tile in engine.World.Map.Tiles)
{
engine.FurnitureControllers.Add(new MapController(tile.Furniture, Container.Resolve<IView<Furniture>>(), Container.Resolve<World>(), Container.Resolve<ILogController>()));
}
return engine;
}
public IEnumerator TakeAttackDamage(MonsterController caster, WeaponController weapon, int numberOfMonsters)
{
attackedByHowMany += 1;
if (showingDamage){
showingDamage = false;
damageTaken = 0;
}
// set secondary bar //
var secondBar = weapon.transform.FindChild("SecondBar").transform.FindChild("mesh");
secondBar.renderer.material = new Material(secondBar.renderer.material);
secondBar.renderer.material.mainTexture = weapon.GetComponent<CardScript>().defaultTimer;
secondBar.renderer.material.SetFloat("_Cutoff", 1.0f);
secondBar.renderer.material.mainTexture.mipMapBias = -0.5f;
// Post turn check //
caster.GetComponent<EnemyAI>().PostTurn();
BattleManager.instance.MonsterPostTurn(caster.currentPosition);
// Attack cooldown //
float t = 0f;
bool block = false;
int stamp = attackedByHowMany;
while (t < 1.0f){
t += Time.deltaTime / (float)weapon.speed;
secondBar.renderer.material.SetFloat("_Cutoff", Mathf.Lerp(1.0f, 0.01f, t));
if (BattleManager.instance.blockedCards[currentPosition]){
block = true;
break;
}
if (stamp < attackedByHowMany){
yield return new WaitForSeconds(1f);
}
yield return new WaitForEndOfFrame();
}
BattleManager.instance.QueuedAttacks[currentPosition] = null;
BattleManager.instance.blockedCards[currentPosition] = false;
if (!block){
// On hit effect here //
caster.GetComponent<EnemyAI>().OnHit();
// Damage calculation //
int damage = Mathf.FloorToInt((caster.strength - defense/2) + weapon.power/3);
if (damage < 1)
damage = 1;
if (!isDead)
current_health -= damage;
damageTaken = damage;
if (current_health < 0 && !isDead){
isDead = true;
Die();
StartCoroutine(BattleManager.instance.PlayerPostDeath(currentPosition));
current_health = 0;
}
}
RestoreAttackPosition();
Teleport(weapon.gameObject);
attackedByHowMany -= 1;
// Damage section //
if (!block){
if (dmgText != null){
dmgText.text = damageTaken.ToString();
sharedTimer = 0f;
} else {
StartCoroutine(ShowDamage());
}
}
}
