public RoverNavMovement()
{
movementMethodDictionary = new Dictionary <Movement, Action>
{
{ Movement.left, () => leftMoveDictionary[CardinalDirection].Invoke() },
{ Movement.right, () => leftMoveDictionary[CardinalDirection].Invoke() },
{ Movement.Forward, () => leftMoveDictionary[CardinalDirection].Invoke() }
};
leftMoveDictionary = new Dictionary <CardinalDirection, Action>
{
{ CardinalDirection.North, () => CardinalDirection = CardinalDirection.North },
{ CardinalDirection.East, () => CardinalDirection = CardinalDirection.East },
{ CardinalDirection.South, () => CardinalDirection = CardinalDirection.South },
{ CardinalDirection.West, () => CardinalDirection = CardinalDirection.West }
};
rightMoveDictionary = new Dictionary <CardinalDirection, Action>
{
{ CardinalDirection.North, () => CardinalDirection = CardinalDirection.North },
{ CardinalDirection.East, () => CardinalDirection = CardinalDirection.East },
{ CardinalDirection.South, () => CardinalDirection = CardinalDirection.South },
{ CardinalDirection.West, () => CardinalDirection = CardinalDirection.West }
};
forwardMoveDictionary = new Dictionary <CardinalDirection, Action>
{
{ CardinalDirection.North, () => { Position = new MovementPoints(Position.X, Position.Y + 1); } },
{ CardinalDirection.North, () => { Position = new MovementPoints(Position.X + 1, Position.Y); } },
{ CardinalDirection.North, () => { Position = new MovementPoints(Position.X, Position.Y - 1); } },
{ CardinalDirection.North, () => { Position = new MovementPoints(Position.X - 1, Position.Y); } }
};
}
public BehaviorFinalizePlots(Building building)
: base()
{
Building = building;
MovementPoints.Add(Building.SafeMovementPoint);
Criteria += () => Building.CanActivate;
}
public UnitRecord(UnitRecord unitRecord, StackId stackId)
{
Id = unitRecord.Id;
UnitTypeId = unitRecord.UnitTypeId;
StackId = stackId;
MovementPoints = unitRecord.MovementPoints;
}
public bool IsValid(MovementPoints aPoint)
{
var isValidX = aPoint.X >= 0 && aPoint.X <= size.Width;
var isValidY = aPoint.Y >= 0 && aPoint.Y <= size.Height;
return(isValidX && isValidY);
}
public UnitRecord(UnitRecord unitRecord, MovementPoints movementPoints)
{
Id = unitRecord.Id;
UnitTypeId = unitRecord.UnitTypeId;
StackId = unitRecord.StackId;
MovementPoints = movementPoints;
}
private static void throwDeployException(LandingSurface aLandingSurface, MovementPoints aPoint)
{
var size = aLandingSurface.GetSize();
var exceptionMessage = string.Format("Deploy failed at point ({0},{1}). Landing zone size is {2} x {3}",
aPoint.X, aPoint.Y, size.Width, size.Height);
throw new NotImplementedException(exceptionMessage);
}
/// <summary>
/// This occurs only once to initalize any variable only after the Criteria check occurs and passes.
/// </summary>
public virtual void Initalize()
{
StartMovement = new Movement(MovementPoints.ToArray(), 2f, name: String.Format("StartMovement({0})", Type.ToString()));
EndMovement = new Movement(MovementPoints.ToArray().Reverse().ToArray(), 2f, name: String.Format("EndMovement({0})", Type.ToString()));
_interactionObject = null;
IsDone = false;
Initalized = true;
GarrisonBase.Debug("Behavior {0} has been initalized", Type);
}
public BehaviorMissionComplete()
: base()
{
if (Character.Player.MinimapZoneText != "Town Hall" || CommandTable == null)
{
MovementPoints.Insert(0, MovementCache.GarrisonEntrance);
}
Criteria += () => BaseSettings.CurrentSettings.BehaviorMissionComplete && GarrisonManager.CompletedMissions.Count > 0;
}
public BehaviorSalvage()
: base()
{
Building = GarrisonManager.Buildings[BuildingType.SalvageYard];
MovementPoints.Add(Building.EntranceMovementPoint);
InteractionEntryId = Building.WorkOrderNpcEntryId;
Criteria += () => BaseSettings.CurrentSettings.BehaviorSalvaging &&
!Building.CanActivate && !Building.IsBuilding &&
SalvagableGoods.Count > 0;
}
public override void Initalize()
{
TargetManager.ShouldKill = false;
TargetManager.ShouldLoot = false;
MovementPoints.Add(GarrisonManager.Buildings[BuildingType.EnchantersStudy].SafeMovementPoint);
MovementPoints.Add(GarrisonManager.Buildings[BuildingType.EnchantersStudy].EntranceMovementPoint);
InteractionEntryId = GarrisonManager.DisenchantingEntryId;
_movement = null;
base.Initalize();
}
public void Deploy(LandingSurface aLandingSurface, MovementPoints aPoint, CardinalDirection aDirection)
{
if (aLandingSurface.IsValid(aPoint))
{
Position = aPoint;
CardinalDirection = aDirection;
isDeployed = true;
return;
}
throwDeployException(aLandingSurface, aPoint);
}
public UnitRecord(int unitId, int stackId)
{
Id = GameDataSequences.GetNextSequence("Unit");
UnitTypeId = new UnitTypeId(unitId);
StackId = new StackId(stackId);
var gameConfigCache = CallContext <GameConfigCache> .GetData("GameConfigCache");
var unit = gameConfigCache.GetUnitConfigById(unitId);
MovementPoints = new MovementPoints((float)unit.MovementPoints);
}
public BehaviorMissionStartup()
: base()
{
if (Character.Player.MinimapZoneText != "Town Hall" || CommandTable == null)
{
MovementPoints.Insert(0, MovementCache.GarrisonEntrance);
}
Criteria += () =>
BaseSettings.CurrentSettings.BehaviorMissionStart &&
BaseSettings.CurrentSettings.BehaviorMissionComplete &&
GarrisonManager.AvailableMissionIds.Count > 0 &&
GarrisonManager.CurrentActiveFollowers <= GarrisonManager.MaxActiveFollowers;
}
public void ScanMovementPoints()
{
GameObject[] PointsGameObjects = GameObject.FindGameObjectsWithTag(TagManager.GetTag(TagType.MovingPoint));
for (int i = 0; i < MovementPoints.Length; i++)
{
for (int j = 0; j < MovementPoints[i].EnemyTransforms.Length; j++)
{
MovementPoints TempMovementPoint = PointsGameObjects[i].GetComponent <MovementPoints>();
MovementPoints[i].EnemyTransforms[j].Position = TempMovementPoint.Enemyes[j].transform.position;
MovementPoints[i].EnemyTransforms[j].Rotation = TempMovementPoint.Enemyes[j].transform.rotation;
MovementPoints[i].EnemyTransforms[j].Scale = TempMovementPoint.Enemyes[j].transform.localScale;
}
}
}
protected Behavior(WoWPoint[] movepoints, int interactionEntryId, Func <bool> criteria = null)
{
MovementPoints.AddRange(movepoints);
InteractionEntryId = interactionEntryId;
if (criteria != null)
{
_criteria = criteria;
}
else
{
_criteria += () => true;
}
}
private Commands ParseRoverDeployCommand(string toParse)
{
var arguments = toParse.Split(' ');
var deployX = int.Parse(arguments[0]);
var deployY = int.Parse(arguments[1]);
var directionSignifier = arguments[2][0];
var deployDirection = cardinalDirectionDictionary[directionSignifier];
var deployPoint = new MovementPoints(deployX, deployY);
var populatedCommand = roverDeployCommandFactory(deployPoint, deployDirection);
return(populatedCommand);
}
public GameFightMinimalStats GetFightMinimalStats()
{
return(new GameFightMinimalStats()
{
actionPoints = ActionPoints.TotalInContext(),
movementPoints = MovementPoints.TotalInContext(),
maxActionPoints = ActionPoints.Total(),
maxMovementPoints = MovementPoints.Total(),
airElementReduction = AirReduction.TotalInContext(),
airElementResistPercent = AirResistPercent.TotalInContext(),
baseMaxLifePoints = (uint)MaxLifePoints,
lifePoints = (uint)CurrentLifePoints,
maxLifePoints = (uint)CurrentMaxLifePoints,
invisibilityState = (sbyte)InvisibilityState,
dodgePALostProbability = (ushort)DodgePAProbability.TotalInContext(),
dodgePMLostProbability = (ushort)DodgePMProbability.TotalInContext(),
pvpAirElementReduction = PvPAirReduction.TotalInContext(),
pvpAirElementResistPercent = PvPAirResistPercent.TotalInContext(),
pvpEarthElementReduction = PvPEarthReduction.TotalInContext(),
pvpEarthElementResistPercent = PvPEarthResistPercent.TotalInContext(),
pvpFireElementReduction = PvPFireReduction.TotalInContext(),
pvpFireElementResistPercent = PvPFireResistPercent.TotalInContext(),
pvpNeutralElementReduction = PvPNeutralReduction.TotalInContext(),
pvpNeutralElementResistPercent = PvPNeutralResistPercent.TotalInContext(),
pvpWaterElementReduction = PvPWaterReduction.TotalInContext(),
pvpWaterElementResistPercent = PvPWaterResistPercent.TotalInContext(),
shieldPoints = (uint)ShieldPoints,
earthElementReduction = EarthReduction.TotalInContext(),
earthElementResistPercent = EarthResistPercent.TotalInContext(),
fireElementResistPercent = FireResistPercent.TotalInContext(),
waterElementResistPercent = WaterResistPercent.TotalInContext(),
neutralElementResistPercent = NeutralResistPercent.TotalInContext(),
fireElementReduction = FireReduction.TotalInContext(),
neutralElementReduction = NeutralReduction.TotalInContext(),
waterElementReduction = WaterReduction.TotalInContext(),
summoned = Summoned,
summoner = SummonerId,
tackleBlock = TackleBlock.TotalInContext(),
tackleEvade = TackleEvade.TotalInContext(),
pushDamageFixedResist = PushDamageReduction.TotalInContext(),
permanentDamagePercent = (uint)PermanentDamagePercent.TotalInContext(),
fixedDamageReflection = Reflect.TotalInContext(),
criticalDamageFixedResist = CriticalDamageReduction.TotalInContext()
});
}
/// <summary>
/// Adds a region to the appropriate list for its type; returns the region.
/// </summary>
public Region Add(Region region)
{
switch (region)
{
case Region.InvasionPoint r: InvasionPoints.Add(r); break;
case Region.EnvironmentMapPoint r: EnvironmentMapPoints.Add(r); break;
case Region.Sound r: Sounds.Add(r); break;
case Region.SFX r: SFX.Add(r); break;
case Region.WindSFX r: WindSFX.Add(r); break;
case Region.SpawnPoint r: SpawnPoints.Add(r); break;
case Region.Message r: Messages.Add(r); break;
case Region.PatrolRoute r: PatrolRoutes.Add(r); break;
case Region.MovementPoint r: MovementPoints.Add(r); break;
case Region.WarpPoint r: WarpPoints.Add(r); break;
case Region.ActivationArea r: ActivationAreas.Add(r); break;
case Region.Event r: Events.Add(r); break;
case Region.Logic r: Logic.Add(r); break;
case Region.EnvironmentMapEffectBox r: EnvironmentMapEffectBoxes.Add(r); break;
case Region.WindArea r: WindAreas.Add(r); break;
case Region.MufflingBox r: MufflingBoxes.Add(r); break;
case Region.MufflingPortal r: MufflingPortals.Add(r); break;
case Region.Other r: Others.Add(r); break;
default:
throw new ArgumentException($"Unrecognized type {region.GetType()}.", nameof(region));
}
return(region);
}
private void ScanMovingPoints(GameObject[] gameObjects)
{
for (int i = 0; i < gameObjects.Length; i++)
{
MovementPoints[i].Transform.Position = gameObjects[i].transform.position;
MovementPoints[i].Transform.Rotation = gameObjects[i].transform.rotation;
MovementPoints[i].Transform.Scale = gameObjects[i].transform.localScale;
MovementPoints TempMovementPoint = gameObjects[i].GetComponent <MovementPoints>();
MovementPoints[i].NeedToRotate = TempMovementPoint.NeedToRotate;
MovementPoints[i].NeedToCountEnemy = TempMovementPoint.NeedToCountEnemy;
MovementPoints[i].NeedToChangeSpeed = TempMovementPoint.NeedToChangeSpeed;
MovementPoints[i].NewSpeed = TempMovementPoint.NewSpeed;
MovementPoints[i].RotationVector = TempMovementPoint.RotationVector;
MovementPoints[i].PointNum = TempMovementPoint.PointNum;
MovementPoints[i].IsFinalPoint = TempMovementPoint.IsFinalPoint;
MovementPoints[i].EnemyTransforms = new CustomTransform[TempMovementPoint.Enemyes.Length];
}
}
public RoverDeployCommand(MovementPoints aPoint, CardinalDirection aDirection)
{
DeployPoint = aPoint;
DeployDirection = aDirection;
}
public MovementPoints[] BuildLvlAndReturnMovementPoints(LevelCreator lvl)
{
for (int i = 0; i < lvl.Buildings1Transforms.Length; i++)
{
Instantiate(Resources.Load <GameObject>(PrefabAssetPath.LevelParts["PrepearedBuilding1"]), lvl.Buildings1Transforms[i].Position, lvl.Buildings1Transforms[i].Rotation).transform.localScale = lvl.Buildings1Transforms[i].Scale;
}
for (int i = 0; i < lvl.Buildings2Transforms.Length; i++)
{
Instantiate(Resources.Load <GameObject>(PrefabAssetPath.LevelParts["PrepearedBuilding2"]), lvl.Buildings2Transforms[i].Position, lvl.Buildings2Transforms[i].Rotation).transform.localScale = lvl.Buildings2Transforms[i].Scale;
}
for (int i = 0; i < lvl.BuildingCubeTransforms.Length; i++)
{
Instantiate(Resources.Load <GameObject>(PrefabAssetPath.LevelParts["BuildingCube"]), lvl.BuildingCubeTransforms[i].Position, lvl.BuildingCubeTransforms[i].Rotation).transform.localScale = lvl.BuildingCubeTransforms[i].Scale;
}
MovementPoints[] TempMovementPoints = new MovementPoints[lvl.MovementPoints.Length];
for (int i = 0; i < lvl.MovementPoints.Length; i++)
{
GameObject TempGameObject = Instantiate(Resources.Load <GameObject>(PrefabAssetPath.LevelParts["MovingPoint"]), lvl.MovementPoints[i].Transform.Position, lvl.MovementPoints[i].Transform.Rotation);
TempGameObject.transform.localScale = lvl.MovementPoints[i].Transform.Scale;
TempMovementPoints[i] = TempGameObject.GetComponent <MovementPoints>();
TempMovementPoints[i].RotationVector = lvl.MovementPoints[i].RotationVector;
TempMovementPoints[i].NewSpeed = lvl.MovementPoints[i].NewSpeed;
TempMovementPoints[i].PointNum = lvl.MovementPoints[i].PointNum;
TempMovementPoints[i].NeedToRotate = lvl.MovementPoints[i].NeedToRotate;
TempMovementPoints[i].NeedToCountEnemy = lvl.MovementPoints[i].NeedToCountEnemy;
TempMovementPoints[i].NeedToChangeSpeed = lvl.MovementPoints[i].NeedToChangeSpeed;
TempMovementPoints[i].IsFinalPoint = lvl.MovementPoints[i].IsFinalPoint;
TempMovementPoints[i].Enemyes = new GameObject[lvl.MovementPoints[i].EnemyTransforms.Length];
}
for (int i = 0; i < lvl.SimpleEnemyTransforms.Length; i++)
{
for (int j = 0; j < lvl.MovementPoints.Length; j++)
{
for (int k = 0; k < lvl.MovementPoints[j].EnemyTransforms.Length; k++)
{
if (lvl.MovementPoints[j].EnemyTransforms[k].Position == lvl.SimpleEnemyTransforms[i].Position)
{
TempMovementPoints[j].Enemyes[k] = Instantiate(Resources.Load <GameObject>(PrefabAssetPath.LevelParts["EnemyPrefabWithRagdoll"]), lvl.SimpleEnemyTransforms[i].Position, lvl.SimpleEnemyTransforms[i].Rotation);
TempMovementPoints[j].Enemyes[k].transform.localScale = lvl.SimpleEnemyTransforms[i].Scale;
}
}
}
}
for (int i = 0; i < lvl.ThrowingEnemyTransforms.Length; i++)
{
//Instantiate(Resources.Load<GameObject>(PrefabAssetPath.LevelParts["EnemyThrowingBombs"]), ThrowingEnemyTransforms[i].Position, ThrowingEnemyTransforms[i].Rotation).transform.localScale = ThrowingEnemyTransforms[i].Scale;
for (int j = 0; j < lvl.MovementPoints.Length; j++)
{
for (int k = 0; k < lvl.MovementPoints[j].EnemyTransforms.Length; k++)
{
if (lvl.MovementPoints[j].EnemyTransforms[k].Position == lvl.ThrowingEnemyTransforms[i].Position)
{
TempMovementPoints[j].Enemyes[k] = Instantiate(Resources.Load <GameObject>(PrefabAssetPath.LevelParts["EnemyThrowingBombs"]), lvl.ThrowingEnemyTransforms[i].Position, lvl.ThrowingEnemyTransforms[i].Rotation);
TempMovementPoints[j].Enemyes[k].transform.localScale = lvl.ThrowingEnemyTransforms[i].Scale;
}
}
}
}
PlayerMovementPoints = new MovementPoints[TempMovementPoints.Length];
for (int i = 0; i < PlayerMovementPoints.Length; i++)
{
for (int j = 0; j < TempMovementPoints.Length; j++)
{
if (TempMovementPoints[j].PointNum == i)
{
PlayerMovementPoints[i] = TempMovementPoints[j];
}
}
}
return(PlayerMovementPoints);
}
protected Behavior(WoWPoint movepoint)
{
MovementPoints.Add(movepoint);
}
public CharacterCharacteristicsInformations GetCharacterCharacteristics(Character character)
{
ulong expFloor = ExperienceRecord.GetExperienceForLevel(character.Level).Player;
ulong expNextFloor = ExperienceRecord.GetExperienceForNextLevel(character.Level).Player;
CharacterCharacteristicsInformations informations = new CharacterCharacteristicsInformations()
{
actionPoints = ActionPoints.GetBaseCharacteristic(),
actionPointsCurrent = ActionPoints.TotalInContext(),
additionnalPoints = 0,
agility = Agility.GetBaseCharacteristic(),
airDamageBonus = AirDamageBonus.GetBaseCharacteristic(),
airElementReduction = AirReduction.GetBaseCharacteristic(),
airElementResistPercent = AirResistPercent.GetBaseCharacteristic(),
alignmentInfos = character.Record.Alignment.GetActorExtendedAlignement(),
allDamagesBonus = AllDamagesBonus.GetBaseCharacteristic(),
chance = Chance.GetBaseCharacteristic(),
criticalDamageBonus = CriticalDamageBonus.GetBaseCharacteristic(),
criticalDamageReduction = CriticalDamageReduction.GetBaseCharacteristic(),
criticalHit = CriticalHit.GetBaseCharacteristic(),
criticalHitWeapon = CriticalHitWeapon,
criticalMiss = Characteristic.Zero().GetBaseCharacteristic(),
damagesBonusPercent = DamagesBonusPercent.GetBaseCharacteristic(),
dodgePALostProbability = DodgePAProbability.GetBaseCharacteristic(),
dodgePMLostProbability = DodgePMProbability.GetBaseCharacteristic(),
earthDamageBonus = EarthDamageBonus.GetBaseCharacteristic(),
earthElementReduction = EarthReduction.GetBaseCharacteristic(),
earthElementResistPercent = EarthResistPercent.GetBaseCharacteristic(),
pvpEarthElementReduction = PvPEarthReduction.GetBaseCharacteristic(),
pvpEarthElementResistPercent = PvPEarthResistPercent.GetBaseCharacteristic(),
fireDamageBonus = FireDamageBonus.GetBaseCharacteristic(),
fireElementReduction = FireReduction.GetBaseCharacteristic(),
fireElementResistPercent = FireResistPercent.GetBaseCharacteristic(),
pvpFireElementReduction = PvPFireReduction.GetBaseCharacteristic(),
pvpFireElementResistPercent = PvPFireResistPercent.GetBaseCharacteristic(),
glyphBonusPercent = GlyphBonusPercent.GetBaseCharacteristic(),
healBonus = HealBonus.GetBaseCharacteristic(),
initiative = new CharacterBaseCharacteristic((short)FormulasProvider.Instance.BaseInitiative(this), 0, Initiative.Total(), 0, 0),
intelligence = Intelligence.GetBaseCharacteristic(),
kamas = character.Record.Kamas,
lifePoints = (uint)LifePoints,
maxEnergyPoints = MaxEnergyPoints,
maxLifePoints = (uint)MaxLifePoints,
movementPoints = MovementPoints.GetBaseCharacteristic(),
movementPointsCurrent = MovementPoints.TotalInContext(),
PMAttack = PMAttack.GetBaseCharacteristic(),
PAAttack = PAAttack.GetBaseCharacteristic(),
pvpAirElementReduction = PvPAirReduction.GetBaseCharacteristic(),
pvpAirElementResistPercent = PvPAirResistPercent.GetBaseCharacteristic(),
pvpNeutralElementReduction = PvPNeutralReduction.GetBaseCharacteristic(),
pvpNeutralElementResistPercent = PvPNeutralResistPercent.GetBaseCharacteristic(),
pvpWaterElementReduction = PvPWaterReduction.GetBaseCharacteristic(),
pvpWaterElementResistPercent = PvPWaterResistPercent.GetBaseCharacteristic(),
energyPoints = Energy,
experience = character.Experience,
experienceLevelFloor = expFloor,
experienceNextLevelFloor = expNextFloor,
neutralDamageBonus = NeutralDamageBonus.GetBaseCharacteristic(),
neutralElementReduction = NeutralReduction.GetBaseCharacteristic(),
neutralElementResistPercent = NeutralResistPercent.GetBaseCharacteristic(),
tackleEvade = TackleEvade.GetBaseCharacteristic(),
tackleBlock = TackleBlock.GetBaseCharacteristic(),
range = Range.GetBaseCharacteristic(),
waterElementReduction = WaterReduction.GetBaseCharacteristic(),
waterDamageBonus = WaterDamageBonus.GetBaseCharacteristic(),
waterElementResistPercent = WaterResistPercent.GetBaseCharacteristic(),
reflect = Reflect.GetBaseCharacteristic(),
permanentDamagePercent = PermanentDamagePercent.GetBaseCharacteristic(),
prospecting = Prospecting.GetBaseCharacteristic(),
pushDamageBonus = PushDamageBonus.GetBaseCharacteristic(),
pushDamageReduction = PushDamageReduction.GetBaseCharacteristic(),
runeBonusPercent = RuneBonusPercent.GetBaseCharacteristic(),
spellModifications = new CharacterSpellModification[0],
spellsPoints = character.Record.SpellPoints,
statsPoints = character.Record.StatsPoints,
vitality = Vitality.GetBaseCharacteristic(),
strength = Strength.GetBaseCharacteristic(),
summonableCreaturesBoost = SummonableCreaturesBoost.GetBaseCharacteristic(),
trapBonus = TrapBonus.GetBaseCharacteristic(),
trapBonusPercent = TrapBonusPercent.GetBaseCharacteristic(),
weaponDamagesBonusPercent = WeaponDamagesBonusPercent.GetBaseCharacteristic(),
wisdom = Wisdom.GetBaseCharacteristic(),
probationTime = 0,
};
return(informations);
}
public override void Serialize(IDataWriter writer)
{
writer.WriteVarUhLong(Experience);
writer.WriteVarUhLong(ExperienceLevelFloor);
writer.WriteVarUhLong(ExperienceNextLevelFloor);
writer.WriteVarUhLong(ExperienceBonusLimit);
writer.WriteVarUhLong(Kamas);
writer.WriteVarUhShort(StatsPoints);
writer.WriteVarUhShort(AdditionnalPoints);
writer.WriteVarUhShort(SpellsPoints);
AlignmentInfos.Serialize(writer);
writer.WriteVarUhInt(LifePoints);
writer.WriteVarUhInt(MaxLifePoints);
writer.WriteVarUhShort(EnergyPoints);
writer.WriteVarUhShort(MaxEnergyPoints);
writer.WriteVarShort(ActionPointsCurrent);
writer.WriteVarShort(MovementPointsCurrent);
Initiative.Serialize(writer);
Prospecting.Serialize(writer);
ActionPoints.Serialize(writer);
MovementPoints.Serialize(writer);
Strength.Serialize(writer);
Vitality.Serialize(writer);
Wisdom.Serialize(writer);
Chance.Serialize(writer);
Agility.Serialize(writer);
Intelligence.Serialize(writer);
Range.Serialize(writer);
SummonableCreaturesBoost.Serialize(writer);
Reflect.Serialize(writer);
CriticalHit.Serialize(writer);
writer.WriteVarUhShort(CriticalHitWeapon);
CriticalMiss.Serialize(writer);
HealBonus.Serialize(writer);
AllDamagesBonus.Serialize(writer);
WeaponDamagesBonusPercent.Serialize(writer);
DamagesBonusPercent.Serialize(writer);
TrapBonus.Serialize(writer);
TrapBonusPercent.Serialize(writer);
GlyphBonusPercent.Serialize(writer);
RuneBonusPercent.Serialize(writer);
PermanentDamagePercent.Serialize(writer);
TackleBlock.Serialize(writer);
TackleEvade.Serialize(writer);
PAAttack.Serialize(writer);
PMAttack.Serialize(writer);
PushDamageBonus.Serialize(writer);
CriticalDamageBonus.Serialize(writer);
NeutralDamageBonus.Serialize(writer);
EarthDamageBonus.Serialize(writer);
WaterDamageBonus.Serialize(writer);
AirDamageBonus.Serialize(writer);
FireDamageBonus.Serialize(writer);
DodgePALostProbability.Serialize(writer);
DodgePMLostProbability.Serialize(writer);
NeutralElementResistPercent.Serialize(writer);
EarthElementResistPercent.Serialize(writer);
WaterElementResistPercent.Serialize(writer);
AirElementResistPercent.Serialize(writer);
FireElementResistPercent.Serialize(writer);
NeutralElementReduction.Serialize(writer);
EarthElementReduction.Serialize(writer);
WaterElementReduction.Serialize(writer);
AirElementReduction.Serialize(writer);
FireElementReduction.Serialize(writer);
PushDamageReduction.Serialize(writer);
CriticalDamageReduction.Serialize(writer);
PvpNeutralElementResistPercent.Serialize(writer);
PvpEarthElementResistPercent.Serialize(writer);
PvpWaterElementResistPercent.Serialize(writer);
PvpAirElementResistPercent.Serialize(writer);
PvpFireElementResistPercent.Serialize(writer);
PvpNeutralElementReduction.Serialize(writer);
PvpEarthElementReduction.Serialize(writer);
PvpWaterElementReduction.Serialize(writer);
PvpAirElementReduction.Serialize(writer);
PvpFireElementReduction.Serialize(writer);
MeleeDamageDonePercent.Serialize(writer);
MeleeDamageReceivedPercent.Serialize(writer);
RangedDamageDonePercent.Serialize(writer);
RangedDamageReceivedPercent.Serialize(writer);
WeaponDamageDonePercent.Serialize(writer);
WeaponDamageReceivedPercent.Serialize(writer);
SpellDamageDonePercent.Serialize(writer);
SpellDamageReceivedPercent.Serialize(writer);
writer.WriteShort((short)SpellModifications.Count);
foreach (var x in SpellModifications)
{
x.Serialize(writer);
}
writer.WriteInt(ProbationTime);
}
public void BuildScene()
{
for (int i = 0; i < Buildings1Transforms.Length; i++)
{
Instantiate(Resources.Load <GameObject>(PrefabAssetPath.LevelParts["PrepearedBuilding1"]), Buildings1Transforms[i].Position, Buildings1Transforms[i].Rotation).transform.localScale = Buildings1Transforms[i].Scale;
}
for (int i = 0; i < Buildings2Transforms.Length; i++)
{
Instantiate(Resources.Load <GameObject>(PrefabAssetPath.LevelParts["PrepearedBuilding2"]), Buildings2Transforms[i].Position, Buildings2Transforms[i].Rotation).transform.localScale = Buildings2Transforms[i].Scale;
}
for (int i = 0; i < BuildingCubeTransforms.Length; i++)
{
Instantiate(Resources.Load <GameObject>(PrefabAssetPath.LevelParts["BuildingCube"]), BuildingCubeTransforms[i].Position, BuildingCubeTransforms[i].Rotation).transform.localScale = BuildingCubeTransforms[i].Scale;
}
MovementPoints[] TempMovementPoints = new MovementPoints[MovementPoints.Length];
for (int i = 0; i < MovementPoints.Length; i++)
{
GameObject TempGameObject = Instantiate(Resources.Load <GameObject>(PrefabAssetPath.LevelParts["MovingPoint"]), MovementPoints[i].Transform.Position, MovementPoints[i].Transform.Rotation);
TempGameObject.transform.localScale = MovementPoints[i].Transform.Scale;
TempMovementPoints[i] = TempGameObject.GetComponent <MovementPoints>();
TempMovementPoints[i].RotationVector = MovementPoints[i].RotationVector;
TempMovementPoints[i].NewSpeed = MovementPoints[i].NewSpeed;
TempMovementPoints[i].PointNum = MovementPoints[i].PointNum;
TempMovementPoints[i].NeedToRotate = MovementPoints[i].NeedToRotate;
TempMovementPoints[i].NeedToCountEnemy = MovementPoints[i].NeedToCountEnemy;
TempMovementPoints[i].NeedToChangeSpeed = MovementPoints[i].NeedToChangeSpeed;
TempMovementPoints[i].IsFinalPoint = MovementPoints[i].IsFinalPoint;
TempMovementPoints[i].Enemyes = new GameObject[MovementPoints[i].EnemyTransforms.Length];
}
for (int i = 0; i < SimpleEnemyTransforms.Length; i++)
{
for (int j = 0; j < MovementPoints.Length; j++)
{
for (int k = 0; k < MovementPoints[j].EnemyTransforms.Length; k++)
{
if (MovementPoints[j].EnemyTransforms[k].Position == SimpleEnemyTransforms[i].Position)
{
TempMovementPoints[j].Enemyes[k] = Instantiate(Resources.Load <GameObject>(PrefabAssetPath.LevelParts["EnemyPrefabWithRagdoll"]), SimpleEnemyTransforms[i].Position, SimpleEnemyTransforms[i].Rotation);
TempMovementPoints[j].Enemyes[k].transform.localScale = SimpleEnemyTransforms[i].Scale;
}
}
}
}
for (int i = 0; i < ThrowingEnemyTransforms.Length; i++)
{
//Instantiate(Resources.Load<GameObject>(PrefabAssetPath.LevelParts["EnemyThrowingBombs"]), ThrowingEnemyTransforms[i].Position, ThrowingEnemyTransforms[i].Rotation).transform.localScale = ThrowingEnemyTransforms[i].Scale;
for (int j = 0; j < MovementPoints.Length; j++)
{
for (int k = 0; k < MovementPoints[j].EnemyTransforms.Length; k++)
{
if (MovementPoints[j].EnemyTransforms[k].Position == ThrowingEnemyTransforms[i].Position)
{
TempMovementPoints[j].Enemyes[k] = Instantiate(Resources.Load <GameObject>(PrefabAssetPath.LevelParts["EnemyThrowingBombs"]), ThrowingEnemyTransforms[i].Position, ThrowingEnemyTransforms[i].Rotation);
TempMovementPoints[j].Enemyes[k].transform.localScale = ThrowingEnemyTransforms[i].Scale;
}
}
}
}
}
internal override Region ReadEntry(BinaryReaderEx br)
{
RegionType type = br.GetEnum32 <RegionType>(br.Position + 8);
switch (type)
{
case RegionType.InvasionPoint:
return(InvasionPoints.EchoAdd(new Region.InvasionPoint(br)));
case RegionType.EnvironmentMapPoint:
return(EnvironmentMapPoints.EchoAdd(new Region.EnvironmentMapPoint(br)));
case RegionType.Sound:
return(Sounds.EchoAdd(new Region.Sound(br)));
case RegionType.SFX:
return(SFX.EchoAdd(new Region.SFX(br)));
case RegionType.WindSFX:
return(WindSFX.EchoAdd(new Region.WindSFX(br)));
case RegionType.SpawnPoint:
return(SpawnPoints.EchoAdd(new Region.SpawnPoint(br)));
case RegionType.Message:
return(Messages.EchoAdd(new Region.Message(br)));
case RegionType.PatrolRoute:
return(PatrolRoutes.EchoAdd(new Region.PatrolRoute(br)));
case RegionType.MovementPoint:
return(MovementPoints.EchoAdd(new Region.MovementPoint(br)));
case RegionType.WarpPoint:
return(WarpPoints.EchoAdd(new Region.WarpPoint(br)));
case RegionType.ActivationArea:
return(ActivationAreas.EchoAdd(new Region.ActivationArea(br)));
case RegionType.Event:
return(Events.EchoAdd(new Region.Event(br)));
case RegionType.Logic:
return(Logic.EchoAdd(new Region.Logic(br)));
case RegionType.EnvironmentMapEffectBox:
return(EnvironmentMapEffectBoxes.EchoAdd(new Region.EnvironmentMapEffectBox(br)));
case RegionType.WindArea:
return(WindAreas.EchoAdd(new Region.WindArea(br)));
case RegionType.MufflingBox:
return(MufflingBoxes.EchoAdd(new Region.MufflingBox(br)));
case RegionType.MufflingPortal:
return(MufflingPortals.EchoAdd(new Region.MufflingPortal(br)));
case RegionType.Other:
return(Others.EchoAdd(new Region.Other(br)));
default:
throw new NotImplementedException($"Unsupported region type: {type}");
}
}
public static void GeneralFighterAI(MainGameWindow main, bool SingleTurn, Player ai, Map map)
{
//TODO: Seperate code, which logs details from code which decides what to do
Troop troop = ai.troop;
var enemies = ai.enemies;
ActionPoint actionPoints = ai.actionPoints;
MovementPoints movementPoints = ai.movementPoints;
DistanceGraphCreator distanceGraph = new DistanceGraphCreator(ai, troop.Position.X, troop.Position.Y, map, true);
Thread path = new Thread(distanceGraph.CreateGraph);
path.Start();
path.Join();
int damageDealt = 0;
int dodged = 0;
while (actionPoints.Value > 0)
{
Point playerPos = enemies[0].troop.Position;
//If the weapon is ranged and empty first load the weapon
if (troop.activeWeapon.Attacks() == 0 && troop.activeWeapon is RangedWeapon w)
{
Ammo selectedAmmo = w.GetSelectedAmmo();
foreach (var ammo in w.Ammo)
{
if (selectedAmmo is null || selectedAmmo.damage.Value < ammo.damage.Value)
{
ammo.Select(w);
selectedAmmo = ammo;
}
}
}
//Check if it can attack player
int playerDistance = AIUtility.Distance(playerPos, troop.Position);
int attacks = troop.activeWeapon.Attacks();
if (playerDistance <= troop.activeWeapon.range && attacks > 0)
{
//Attack
var(damage, killed, hit) = main.Attack(ai, enemies[0]);
damageDealt += damage;
if (!hit)
{
dodged++;
}
if (killed)
{
map.overlayObjects.Add(new OverlayText(enemies[0].troop.Position.X * MapCreator.fieldSize, enemies[0].troop.Position.Y * MapCreator.fieldSize, Color.Red, $"-{damageDealt}"));
main.PlayerDied($"You have been killed by {ai.Name}!");
break;
}
actionPoints.RawValue--;
troop.activeWeapon.UseWeapon(enemies[0], main);
continue;
}
else if (troop.weapons.Exists(t => t.range >= playerDistance && t.Attacks() > 0))
{
//Change weapon
Weapon best = troop.weapons.FindAll(t => t.range >= playerDistance)
.Aggregate((t1, t2) => t1.range > t2.range ? t1 : t2);
troop.activeWeapon = best;
continue;
}
//Generate map of left value
double[,] movementCosts = new double[map.width, map.height];
for (int x = 0; x <= movementCosts.GetUpperBound(0); x++)
{
for (int y = 0; y <= movementCosts.GetUpperBound(1); y++)
{
movementCosts[x, y] = -1;
}
}
//Find closest field to player
Point closestField = new Point(-1, -1);
try
{
closestField = AIUtility.FindClosestField(distanceGraph, playerPos, movementPoints.Value, map,
(List <(Point point, double cost, double height)> list) => {
list.Sort((o1, o2) => {
double diffCost = o1.cost - o2.cost;
double heightDiff = o1.height - o2.height;
if (Math.Abs(diffCost) >= 1) //assume that using the weapon costs 1 action point
{
return(diffCost < 0 ? -1 : 1);
}
else if (heightDiff != 0)
{
return(diffCost < 0 ? -1 : 1);
}
return(0);
});
return(list.First().point);
});
}
