private void Input(ICharacter player)
{
var info = Console.ReadKey();
switch (info.Key)
{
case ConsoleKey.Spacebar:
var ninja = Enemies.FirstOrDefault();
player.Atack(ninja);
if (ninja != null && ninja.Blood == 0)
{
Enemies.Remove(ninja);
}
break;
case ConsoleKey.LeftArrow:
player.Move(Direction.Left);
break;
case ConsoleKey.UpArrow:
player.Move(Direction.Up);
break;
case ConsoleKey.RightArrow:
player.Move(Direction.Right);
break;
case ConsoleKey.DownArrow:
player.Move(Direction.Down);
break;
}
}
public override void ExecuteCommand(ICharacter character, Identity target, string[] args)
{
Vendor v = Pool.Instance.GetObject<Vendor>(character.Playfield.Identity, target);
if (v != null)
{
int pfid = character.Playfield.Identity.Instance;
StatelData sd =
PlayfieldLoader.PFData[pfid].Statels.FirstOrDefault(x => x.Identity.Equals(v.OriginalIdentity));
if (sd != null)
{
int instance = (((sd.Identity.Instance) >> 16) & 0xff
| (character.Playfield.Identity.Instance << 16));
DBVendor dbv = new DBVendor();
dbv.Id = instance;
dbv.Playfield = pfid;
dbv.X = sd.X;
dbv.Y = sd.Y;
dbv.Z = sd.Z;
dbv.HeadingX = sd.HeadingX;
dbv.HeadingY = sd.HeadingY;
dbv.HeadingZ = sd.HeadingZ;
dbv.HeadingW = sd.HeadingW;
dbv.Name = "New shop, please fill me";
dbv.TemplateId = sd.TemplateId;
dbv.Hash = "";
VendorDao.Instance.Delete(dbv.Id);
VendorDao.Instance.Add(dbv, dontUseId: false);
}
}
}
public IEncounter CreateNewEncounter()
{
player = CharacterFactory.CreatePlayerCharacter();
monster = CharacterFactory.CreateMonster();
encounter = new Encounter(player, monster);
return encounter;
}
public virtual int Hit(ICharacter enemy)
{
int damage = (this.Damage +this.Master.AttackPoints/10)*(1000 - enemy.DefencePoints)/1000;
enemy.HealthPoints -= damage;
return damage;
}
public override CommandResult Execute(ICharacter subject)
{
ICharacter character = subject;
if (character.CurrentAnimationSeq == null) return new CommandResult(CommandStatusEnum.NotFinished);
if (character.CurrentAnimationSeq._isEnd) return new CommandResult(CommandStatusEnum.NotFinished);
switch (character.CurrentAnimationSeq._purpose)
{
case AnimationPurposeEnum.Moving:
if (!character.CurrentAnimationSeq._isEnd)
{
PointF point = character.CurrentAnimationSeq._destPoint;
character.DestAnimationPt = point;
if (Move(character))
{
character.CurrentAnimationSeq._isEnd = true;
}
}
break;
default:
if (character.CurrentAnimationRunner._isEnd)
character.CurrentAnimationSeq._isEnd = true;
break;
}
return new CommandResult(CommandStatusEnum.NotFinished);
}
public EnemyAI(ICharacter Character, Vector3 AttackPosition):base(Character)
{
m_AttackPosition = AttackPosition;
// 一開始起始的狀態
ChangeAIState(new IdleAIState());
}
public void RaiseAction(ICharacter character, int raise, ISingleBet bet)
{
character.HasRaised = true;
character.Raise(raise);
bet.AddBet(raise);
bet.LastBet = raise;
}
public override void Decide(ICharacter character, IList<ICard> cardCollection,
int firstCard, int secondCard, int botChips,
bool isFinalTurn, Label hasFolded, int botIndex,
double botPower, double behaviourPower, int callSum)
{
this.IsOnTurn = true;
}
public FieldType NextField(ICharacter character)
{
int x = character.PositionX;
int y = character.PositionY;
switch (character.ActualTurn)
{
case TurnType.Turn0:
x++;
break;
case TurnType.Turn90:
y--;
break;
case TurnType.Turn180:
x--;
break;
case TurnType.Turn270:
y++;
break;
}
if (x < 0 || x >= Level.BorderSize ||
y < 0 || y >= Level.BorderSize)
{
return FieldType.Obstacle;
}
return Level.GameBoard[x, y];
}
private int Choose(ICharacter player)
{
ICharacter target = new Enemy();
var random = new Random();
ConsoleKeyInfo option = Console.ReadKey(true);
switch (option.Key)
{
case ConsoleKey.Escape:
Environment.Exit(0);
break;
case ConsoleKey.A:
player.Move(Direction.Up);
break;
case ConsoleKey.B:
player.Atack(target);
break;
}
return random.Next(0, 1980);
}
/// <summary>
/// Initializes a new instance of the <see cref="OccupancyChangedEventArgs"/> class.
/// </summary>
/// <param name="occupant">The occupant.</param>
/// <param name="departureRoom">The departure room.</param>
/// <param name="arrivalRoom">The arrival room.</param>
public OccupancyChangedEventArgs(ICharacter occupant, ITravelDirection travelDirection, DefaultRoom departureRoom, DefaultRoom arrivalRoom)
{
this.Occupant = occupant;
this.DepartureRoom = departureRoom;
this.ArrivalRoom = arrivalRoom;
this.TravelDirection = travelDirection;
}
//TODO:from int to double return type
public void CheckHandPower(ICharacter player, IList<ICard> tableCards)
{
decimal powerToSet = 0;
powerToSet = CheckFourOfKind(player, tableCards);
if (powerToSet >= initialPowerFourOfKind)
{
player.Power = powerToSet;
return;
}
powerToSet = CheckForFullHouse(player, tableCards);
if (powerToSet >= initialPowerFullHouse)
{
player.Power = powerToSet;
return;
}
powerToSet = CheckForFlush(player, tableCards);
if (powerToSet >= initialPowerFlush)
{
player.Power = powerToSet;
return;
}
powerToSet = CheckForStraight(player, tableCards);
if (powerToSet >= initialPowerStraight)
{
player.Power = powerToSet;
return;
}
powerToSet = CheckForThreeOfKind(player, tableCards);
if (powerToSet >= initialPowerThreeOfKind)
{
player.Power = powerToSet;
return;
}
powerToSet = CheckForTwoPair(player, tableCards);
if (powerToSet >= initialPowerTwoPair)
{
player.Power = powerToSet;
return;
}
powerToSet = CheckForOnePair(player, tableCards);
if (powerToSet >= initialPowerOnePair)
{
player.Power = powerToSet;
return;
}
powerToSet = CheckForHighCard(player);
if (powerToSet >= 1)
{
player.Power = powerToSet;
}
}
public virtual void MapToEntity(ICharacterModel model, ref ICharacter entity, int currentDepth = 1)
{
currentDepth++;
// Assign Base properties
NameableEntityMapper.MapToEntity(model, ref entity);
// Character Properties
entity.RealName = model.RealName;
entity.DateOfBirth = model.DateOfBirth;
// Related Objects
entity.PrimaryImageFileId = model.PrimaryImageFileId;
entity.PrimaryImageFile = (ImageFile)model.PrimaryImageFile?.MapToEntity();
entity.FirstIssueAppearanceId = model.FirstIssueAppearanceId;
entity.FirstIssueAppearance = (Issue)model.FirstIssueAppearance?.MapToEntity();
entity.GenderId = model.GenderId;
entity.Gender = (Gender)model.Gender?.MapToEntity();
entity.OriginId = model.OriginId;
entity.Origin = (Origin)model.Origin?.MapToEntity();
entity.PublisherId = model.PublisherId;
entity.Publisher = (Publisher)model.Publisher?.MapToEntity();
// Associated Objects
entity.CharacterAliases = model.CharacterAliases?.Where(i => i.Active).Select(CharacterAliasMapperExtensions.MapToEntity).ToList();
entity.CharacterCreators = model.CharacterCreators?.Where(i => i.Active).Select(CharacterCreatorMapperExtensions.MapToEntity).ToList();
entity.CharacterEnemies = model.CharacterEnemies?.Where(i => i.Active).Select(CharacterEnemyMapperExtensions.MapToEntity).ToList();
entity.CharacterEnemyTeams = model.CharacterEnemyTeams?.Where(i => i.Active).Select(CharacterEnemyTeamMapperExtensions.MapToEntity).ToList();
entity.CharacterFriends = model.CharacterFriends?.Where(i => i.Active).Select(CharacterFriendMapperExtensions.MapToEntity).ToList();
entity.CharacterFriendlyTeams = model.CharacterFriendlyTeams?.Where(i => i.Active).Select(CharacterFriendlyTeamMapperExtensions.MapToEntity).ToList();
entity.CharacterIssuesAppearedIn = model.CharacterIssuesAppearedIn?.Where(i => i.Active).Select(CharacterAppearedInIssueMapperExtensions.MapToEntity).ToList();
entity.CharacterIssuesDiedIn = model.CharacterIssuesDiedIn?.Where(i => i.Active).Select(CharacterDiedInIssueMapperExtensions.MapToEntity).ToList();
entity.CharacterIssues = model.CharacterIssues?.Where(i => i.Active).Select(CharacterIssueMapperExtensions.MapToEntity).ToList();
entity.CharacterMovies = model.CharacterMovies?.Where(i => i.Active).Select(CharacterMovieMapperExtensions.MapToEntity).ToList();
entity.CharacterPowers = model.CharacterPowers?.Where(i => i.Active).Select(CharacterPowerMapperExtensions.MapToEntity).ToList();
entity.CharacterStoryArcs = model.CharacterStoryArcs?.Where(i => i.Active).Select(CharacterStoryArcMapperExtensions.MapToEntity).ToList();
entity.CharacterTeams = model.CharacterTeams?.Where(i => i.Active).Select(CharacterTeamMapperExtensions.MapToEntity).ToList();
entity.CharacterVolumes = model.CharacterVolumes?.Where(i => i.Active).Select(CharacterVolumeMapperExtensions.MapToEntity).ToList();
}
public InputCommandResult(bool isCommandCompleted, IInputCommand command, ICharacter executor)
{
this.Result = string.Empty;
this.IsCommandCompleted = isCommandCompleted;
this.CommandExecuted = command;
this.Executor = executor;
}
private void onSaveGameLoaded()
{
_panel = _game.Find<IPanel>(_panel.ID);
_inventoryItemIcon = _game.Find<IObject>(_inventoryItemIcon.ID);
_player = _game.State.Player;
_lastInventoryItem = null;
}
public override void Update(GameTime gameTime, ICharacter character)
{
this.TimeSinceLastFrame += gameTime.ElapsedGameTime.Milliseconds;
if (this.TimeSinceLastFrame < this.TimePerFrame)
{
return;
}
this.TimeSinceLastFrame = gameTime.ElapsedGameTime.Milliseconds;
KeyboardState keyState = Keyboard.GetState();
bool moving = ((Player)character).KbKeys.Any(key => keyState.IsKeyDown(key));
if (moving || this.CurrentFrame != 5)
{
if (this.reverse)
{
this.CurrentFrame--;
}
else
{
this.CurrentFrame++;
}
if (this.CurrentFrame == this.TotalFrames - 1 || this.CurrentFrame == 0)
{
this.reverse = !this.reverse;
}
}
}
public CommandCompletionArgs(string command, ICharacter owner, IEnumerable<string> args, InputCommandResult result)
{
this.Command = command;
this.Arguments = args;
this.Owner = owner;
this.CommandResult = result;
}
public void Draw(ICharacter character, SpriteBatch spriteBatch)
{
foreach (IStat stat in Stats)
{
stat.Draw(character, spriteBatch);
}
}
public static void ToStringModelView(ICharacter c, int nest, StringBuilder sb, out bool oneLiner)
{
if (c is Sprite)
{
((Sprite)c).ToStringModelView(nest, sb, out oneLiner);
}
else if (c is EditText)
{
((EditText)c).ToStringModelView(nest, sb, out oneLiner);
}
else if (c is StaticText)
{
((StaticText)c).ToStringModelView(nest, sb, out oneLiner);
}
else if (c is IImage)
{
((IImage)c).ToStringModelView(nest, sb, out oneLiner);
}
else if (c is IShape)
{
((IShape)c).ToStringModelView(nest, sb, out oneLiner);
}
else
{
throw new Exception("*** ERROR: CAN'T DUMP: " + c.ToString());
}
}
public void ModifyOnCreation(ICharacter subject)
{
subject.Hitpoints.Max = HitDie + subject.Constitution.Modifier;
subject.Hitpoints.Current = subject.Hitpoints.Max;
subject.Skills.AddRanks(GetSkillPointsCreation(subject));
ClassModifyOnCreation(subject);
}
//
// This constructor's purpose is entirely for making a deep copy of the object type
//
public Character(ICharacter c)
{
foreach (var property in typeof(Character).GetProperties())
{
property.SetValue(this, property.GetValue(c));
}
}
public void Add(ICharacter character)
{
if (character == null) throw new ArgumentNullException("character");
lock (_characters)
_characters.Add(character.Id, character);
}
/// <summary>
/// Sets the stat scaling on this weapon based on the user character's selected attribute. </summary>
/// <param name='userStats'> User character's stat module. </param>
public void SetScaling(ICharacter user)
{
switch (scalingAttribute) {
case CharacterAttribute.AttributeName.Vitality:
_scalingAtt = user.CharStats.Vitality;
break;
case CharacterAttribute.AttributeName.Endurance:
_scalingAtt = user.CharStats.Endurance;
break;
case CharacterAttribute.AttributeName.Spirit:
_scalingAtt = user.CharStats.Spirit;
break;
case CharacterAttribute.AttributeName.Strength:
_scalingAtt = user.CharStats.Strength;
break;
case CharacterAttribute.AttributeName.Dexterity:
_scalingAtt = user.CharStats.Dexterity;
break;
case CharacterAttribute.AttributeName.Mind:
_scalingAtt = user.CharStats.Mind;
break;
default:
_scalingAtt = null;
break;
}
if (_scalingAtt == null)
Debug.Log ("no scaling attribute set!");
}
private void onSavedGameLoaded()
{
_player = _game.State.Player;
_room = Rooms.Find(_game.State, _room);
_bottle = _room.Find<IObject>(_bottleId);
subscribeEvents();
}
public void AddText(ICharacter character, params string[] sentences)
{
foreach (string sentence in sentences)
{
Actions.Add(new AGSDialogAction (character, sentence));
}
}
public static bool CanCharacterIdentifyDestination(IMap map, ICharacter viewer, int targetX, int targetY)
{
//checks to see if it's one tile beyond sight
int viewerX = viewer.X;
int viewerY = viewer.Y;
//adjust for screen endings
if (viewerX < 10) viewerX = 10;
if (viewerX > map.MaxX - 9) viewerX = map.MaxX - 9;
if (viewerY < 7) viewerY = 7;
if (viewerY > map.MaxY - 7) viewerY = map.MaxY - 7;
//check to see if the target would be in the viewer's screen
if (targetX > viewerX + 10) return false;
if (targetX < viewerX - 11) return false;
if (targetY > viewerY + 8) return false;
if (targetY < viewerY - 8) return false;
int darkness;
if (viewer.Darkness > -2) {
darkness = viewer.Darkness;
} else {
darkness = map.Darkness;
}
if (darkness > -1) {
int distance = (int)System.Math.Ceiling(2 * System.Math.Sqrt(System.Math.Pow(viewer.X - targetX, 2) + System.Math.Pow(viewer.Y - targetY, 2)));
if (distance > darkness - 1) return false;
}
return true;
}
public void OnKeyboardDown(MagecrawlKey key, Map map, GameWindow window, IGameEngine engine)
{
switch (key)
{
case MagecrawlKey.Enter:
{
ICharacter possiblyTargettedMonster = engine.Map.Monsters.Where(x => x.Position == map.TargetPoint).FirstOrDefault();
// Rememeber last targetted monster so we can target them again by default next turn.
if (m_targettingType == TargettingType.Monster && possiblyTargettedMonster != null)
m_lastTargetted = possiblyTargettedMonster;
if (m_action != null)
{
m_action(window, engine, map.TargetPoint);
m_action = null;
}
Escape(map, window);
break;
}
case MagecrawlKey.Escape:
{
Escape(map, window);
break;
}
case MagecrawlKey.v:
{
Escape(map, window);
break;
}
case MagecrawlKey.Left:
HandleDirection(Direction.West, map, window, engine);
break;
case MagecrawlKey.Right:
HandleDirection(Direction.East, map, window, engine);
break;
case MagecrawlKey.Down:
HandleDirection(Direction.South, map, window, engine);
break;
case MagecrawlKey.Up:
HandleDirection(Direction.North, map, window, engine);
break;
case MagecrawlKey.Insert:
HandleDirection(Direction.Northwest, map, window, engine);
break;
case MagecrawlKey.Delete:
HandleDirection(Direction.Southwest, map, window, engine);
break;
case MagecrawlKey.PageUp:
HandleDirection(Direction.Northeast, map, window, engine);
break;
case MagecrawlKey.PageDown:
HandleDirection(Direction.Southeast, map, window, engine);
break;
default:
break;
}
}
protected override void ClassModifyOnCreation(ICharacter subject)
{
subject.IncreaseAbility(AbilityType.Strength, 2);
subject.DecreaseAbility(AbilityType.Intelligence, 2);
subject.DecreaseAbility(AbilityType.Charisma, 2);
subject.Features.Add(Feature.DarkVision);
}
public Skill(string name, int damage, int manaCost, ICharacter master)
{
this.Name = name;
this.Damage = damage;
this.ManaCost = manaCost;
this.Coordinates = new Point();
this.Master = master;
}
public ArrayList _path; // moving path
#endregion Fields
#region Constructors
public SubAction()
{
_character = null;
_animationSeqs = new ArrayList();
_currentAnimationSeq = null;
_path = null;
_isEnd = false;
}
public static void ServerSpawnMinions(
ICharacter characterBoss,
Vector2D characterBossCenterPosition,
IProtoCharacterMob protoMinion,
List <ICharacter> minionsList,
double spawnCheckDistanceSqr,
ServerBossDamageTracker bossDamageTracker,
double minionsPerPlayer,
int minionsTotalMin,
int minionsTotalMax,
int?minionsSpawnPerIterationLimit,
double baseMinionsNumber,
double spawnNoObstaclesCircleRadius,
double spawnDistanceMin,
double spawnDistanceMax)
{
// calculate how many minions required
var minionsRequired = baseMinionsNumber;
using var tempListCharacters = Api.Shared.GetTempList <ICharacter>();
Api.Server.World.GetScopedByPlayers(characterBoss, tempListCharacters);
foreach (var playerCharacter in tempListCharacters.AsList())
{
if (playerCharacter.ProtoGameObject is PlayerCharacterSpectator)
{
continue;
}
if (playerCharacter.Position.DistanceSquaredTo(characterBossCenterPosition)
<= spawnCheckDistanceSqr)
{
minionsRequired += minionsPerPlayer;
}
}
minionsRequired = MathHelper.Clamp(minionsRequired,
minionsTotalMin,
minionsTotalMax);
if (minionsSpawnPerIterationLimit.HasValue)
{
minionsRequired = Math.Min(minionsRequired, minionsSpawnPerIterationLimit.Value);
}
ServerProcessMinions(characterBoss,
protoMinion,
minionsList,
out var spawnedMinionsCount,
despawnDistanceSqr: spawnCheckDistanceSqr);
//Logger.Dev($"Minions required: {minionsRequired} minions have: {minionsHave}");
minionsRequired -= spawnedMinionsCount;
if (minionsRequired <= 0)
{
return;
}
// spawn minions
var attemptsRemains = 300;
var physicsSpace = characterBoss.PhysicsBody.PhysicsSpace;
while (minionsRequired > 0)
{
attemptsRemains--;
if (attemptsRemains <= 0)
{
// attempts exceeded
return;
}
var spawnDistance = spawnDistanceMin
+ RandomHelper.NextDouble() * (spawnDistanceMax - spawnDistanceMin);
var angle = RandomHelper.NextDouble() * MathConstants.DoublePI;
var spawnPosition = new Vector2D(
characterBossCenterPosition.X + spawnDistance * Math.Cos(angle),
characterBossCenterPosition.Y + spawnDistance * Math.Sin(angle));
if (ServerTrySpawnMinion(spawnPosition) is { } spawnedMinion)
{
// spawned successfully!
minionsRequired--;
minionsList.Add(spawnedMinion);
}
}
ICharacter ServerTrySpawnMinion(Vector2D spawnPosition)
{
if (physicsSpace.TestCircle(spawnPosition,
spawnNoObstaclesCircleRadius,
CollisionGroups.Default,
sendDebugEvent: true).EnumerateAndDispose().Any())
{
// obstacles nearby
return(null);
}
var spawnedCharacter = Api.Server.Characters.SpawnCharacter(protoMinion, spawnPosition);
if (spawnedCharacter is null)
{
return(null);
}
// write this boss' damage tracker into the minion character
// so any damage dealt to it will be counted in the winners ranking
var privateState = spawnedCharacter.GetPrivateState <ICharacterPrivateStateWithBossDamageTracker>();
privateState.DamageTracker = bossDamageTracker;
// start spawn animation
if (spawnedCharacter.ProtoGameObject is IProtoCharacterMob protoCharacterMob)
{
protoCharacterMob.ServerSetSpawnState(spawnedCharacter,
MobSpawnState.Spawning);
}
return(spawnedCharacter);
}
}
public void SecondSkill(ICharacter c)
{
Console.WriteLine($"Second skill from Malphite and this skill name is {secondSkillName}");
c.HealthPoint = c.HealthPoint + c.DefensePoint - (int)(c.HealthPoint * 0.3);
}
public static PlayerCharacterQuests SharedGetQuests(this ICharacter character)
{
return(PlayerCharacter.GetPrivateState(character)
.Quests);
}
public static IEnumerable <ILogicObject> ServerEnumerateCurrentStatusEffects(this ICharacter character)
{
return(InternalServerGetStatusEffects(character));
}
private static NetworkSyncList <ILogicObject> InternalServerGetStatusEffects(ICharacter character)
{
Api.ValidateIsServer();
return(InternalSharedGetStatusEffects(character));
}
public static void ClientOnWeaponHitOrTrace(
ICharacter firingCharacter,
IProtoItemWeapon protoWeapon,
IProtoItemAmmo protoAmmo,
IProtoCharacter protoCharacter,
Vector2Ushort fallbackCharacterPosition,
IReadOnlyList <WeaponHitData> hitObjects,
Vector2D endPosition,
bool endsWithHit)
{
if (firingCharacter is not null &&
!firingCharacter.IsInitialized)
{
firingCharacter = null;
}
var weaponTracePreset = protoWeapon.FireTracePreset
?? protoAmmo?.FireTracePreset;
var worldPositionSource = SharedCalculateWeaponShotWorldPositon(
firingCharacter,
protoWeapon,
protoCharacter,
fallbackCharacterPosition.ToVector2D(),
hasTrace: weaponTracePreset?.HasTrace ?? false);
protoWeapon.ClientOnWeaponHitOrTrace(firingCharacter,
worldPositionSource,
protoWeapon,
protoAmmo,
protoCharacter,
fallbackCharacterPosition,
hitObjects,
endPosition,
endsWithHit);
if (weaponTracePreset?.HasTrace ?? false)
{
ComponentWeaponTrace.Create(weaponTracePreset,
worldPositionSource,
endPosition,
hasHit: endsWithHit,
lastHitData: hitObjects.LastOrDefault(t => t.WorldObject is not null));
}
foreach (var hitData in hitObjects)
{
var hitWorldObject = hitData.WorldObject;
if (hitWorldObject is not null &&
!hitWorldObject.IsInitialized)
{
hitWorldObject = null;
}
var protoWorldObject = hitData.FallbackProtoWorldObject;
double delay;
{
var worldObjectPosition = CalculateWorldObjectPosition(hitWorldObject, hitData);
delay = weaponTracePreset?.HasTrace ?? false
? SharedCalculateTimeToHit(weaponTracePreset,
worldPositionSource : worldPositionSource,
endPosition : worldObjectPosition
+ hitData.HitPoint.ToVector2D())
: 0;
}
ClientTimersSystem.AddAction(
delay,
() =>
{
// re-calculate the world object position
var worldObjectPosition = CalculateWorldObjectPosition(hitWorldObject, hitData);
var fireScatterPreset = protoAmmo?.OverrideFireScatterPreset
?? protoWeapon.FireScatterPreset;
var projectilesCount = fireScatterPreset.ProjectileAngleOffets.Length;
var objectMaterial = hitData.FallbackObjectMaterial;
if (hitWorldObject is ICharacter hitCharacter &&
hitCharacter.IsInitialized)
{
objectMaterial = ((IProtoCharacterCore)hitCharacter.ProtoCharacter)
.SharedGetObjectMaterialForCharacter(hitCharacter);
}
protoWeapon.ClientPlayWeaponHitSound(hitWorldObject,
protoWorldObject,
fireScatterPreset,
objectMaterial,
worldObjectPosition);
if (weaponTracePreset is null)
{
return;
}
var randomRotation = !weaponTracePreset.HasTrace;
double?angleRad = null;
if (!randomRotation)
{
var deltaPos = endPosition - worldPositionSource;
ComponentWeaponTrace.CalculateAngleAndDirection(deltaPos,
out var angleRadLocal,
out _);
angleRad = angleRadLocal;
}
ClientAddHitSparks(weaponTracePreset.HitSparksPreset,
hitData,
hitWorldObject,
protoWorldObject,
worldObjectPosition,
projectilesCount,
objectMaterial,
randomizeHitPointOffset: !weaponTracePreset.HasTrace,
randomRotation: randomRotation,
rotationAngleRad: angleRad,
drawOrder: weaponTracePreset.DrawHitSparksAsLight
? DrawOrder.Light
: DrawOrder.Default);
});
public static PlayCardTask Any(Controller controller, string cardName, ICharacter target = null,
int zonePosition = -1, int chooseOne = 0, bool skipPrePhase = false)
{
return(new PlayCardTask(controller, controller.HandZone.First(p => p.Card.Name == cardName), target, zonePosition, chooseOne, skipPrePhase));
}
private static double ServerTryConsumeFuelItems(
ItemFuelRefillActionState state,
ICharacter character,
double fuelAmount,
double fuelCapacity)
{
var maxItemsToConsumePerRefill = MaxItemsToConsumePerRefill;
var consumedItems = new Dictionary <IProtoItem, int>();
foreach (var itemToConsume in state.ItemsToConsumeForRefill)
{
// check if character owns this item
if (!character.ProtoCharacter
.SharedEnumerateAllContainers(character, includeEquipmentContainer: false)
.Any(c => c.Items.Contains(itemToConsume)))
{
throw new Exception("The character doesn't own " + itemToConsume + " - cannot use it to reload");
}
int itemToConsumeCountToSubstract;
var itemToConsumeCount = itemToConsume.Count;
if (itemToConsumeCount == 0)
{
continue;
}
if (itemToConsumeCount > maxItemsToConsumePerRefill)
{
itemToConsumeCount = (ushort)maxItemsToConsumePerRefill;
}
var fuelAmountPerItem = ((IProtoItemFuel)itemToConsume.ProtoItem).FuelAmount;
if (fuelAmount + itemToConsumeCount * fuelAmountPerItem
>= fuelCapacity)
{
// there are more than enough item count in that item stack to fully refill
itemToConsumeCountToSubstract = (int)Math.Ceiling((fuelCapacity - fuelAmount)
/ fuelAmountPerItem);
fuelAmount = fuelCapacity;
}
else
{
// consume full item stack
itemToConsumeCountToSubstract = itemToConsumeCount;
fuelAmount += itemToConsumeCount * fuelAmountPerItem;
}
if (itemToConsumeCountToSubstract > 0)
{
maxItemsToConsumePerRefill -= itemToConsumeCountToSubstract;
// reduce item count
var itemToConsumeNewCount = itemToConsume.Count - itemToConsumeCountToSubstract;
Server.Items.SetCount(
itemToConsume,
itemToConsumeNewCount,
byCharacter: character);
// ReSharper disable once PossibleNullReferenceException
consumedItems.Add(itemToConsume.ProtoItem, -itemToConsumeCountToSubstract);
}
if (fuelAmount >= fuelCapacity)
{
// fully refilled
break;
}
if (maxItemsToConsumePerRefill <= 0)
{
// amount of bottles to consume exceeded
break;
}
}
NotificationSystem.ServerSendItemsNotification(character, consumedItems);
return(fuelAmount);
}
public ItemFuelRefillRequest ClientTryCreateRequest(ICharacter character, IItem item)
{
if (item?.ProtoGameObject is not IProtoItemWithFuel protoItemFuelRefillable)
{
// no item selected
return(null);
}
if (protoItemFuelRefillable.ItemFuelConfig.FuelProtoItemsList.Count == 0)
{
if (IsServer)
{
Logger.Warning("Cannot refill - not refillable: " + item, character);
}
else // if (IsClient)
{
NotificationSystem.ClientShowNotification(
NotificationNotRefillable,
color: NotificationColor.Bad,
icon: protoItemFuelRefillable.Icon);
}
return(null);
}
if (!SharedIsRefuelNeeded(item))
{
if (IsClient)
{
NotificationSystem.ClientShowNotification(
NotificationNoNeedToRefill,
color: NotificationColor.Neutral,
icon: protoItemFuelRefillable.Icon);
}
return(null);
}
if (!protoItemFuelRefillable.ClientCanStartRefill(item))
{
return(null);
}
var fuelItemsToConsume = ClientSelectItemsToConsume(protoItemFuelRefillable,
amountNeeded: SharedGetFuelAmountNeeded(item),
MaxItemsToConsumePerRefill);
if (fuelItemsToConsume.Count > 0)
{
return(new ItemFuelRefillRequest(character, item, fuelItemsToConsume));
}
NotificationSystem.ClientShowNotification(
NotificationNeedFuel_Title,
message: string.Format(NotificationNeedFuel_MessageFormat,
protoItemFuelRefillable.ItemFuelConfig.FuelProtoItemsList.Select(i => i.Name)
.GetJoinedString(", ")),
color: NotificationColor.Bad,
icon: protoItemFuelRefillable.Icon);
return(null);
}
protected override void ServerOnSpecialEffect(ICharacter damagedCharacter, double damage)
{
ServerWeaponSpecialEffectsHelper.OnFirearmHit(damagedCharacter, damage);
}
private void ServerGatheringSystemGatherHandler(ICharacter character, IStaticWorldObject worldObject)
{
if (worldObject.ProtoStaticWorldObject is not ObjectCorpse)
{
return;
}
// corpse looted
// find the device and vial
var itemDevice = character.SharedGetPlayerContainerEquipment()
.GetItemsOfProto(this)
.FirstOrDefault();
if (itemDevice is null)
{
// don't have an equipped device
return;
}
var protoItemVialEmpty = GetProtoEntity <ItemVialEmpty>();
// require at least one vial
if (!character.ContainsItemsOfType(protoItemVialEmpty, requiredCount: 1))
{
// don't have an empty vial
this.CallClient(character, _ => _.ClientRemote_NotEnoughEmptyVials());
return;
}
var protoMob = worldObject.GetPublicState <ObjectCorpse.PublicState>()
.ProtoCharacterMob;
var healthMax = protoMob.StatDefaultHealthMax;
var maxVialsToUse = (ushort)MathHelper.Clamp(
Math.Floor(protoMob.BiomaterialValueMultiplier * healthMax / 100.0),
min: 1,
max: 10);
// destroy empty vial
Server.Items.DestroyItemsOfType(
character,
protoItemVialEmpty,
maxVialsToUse,
out var destroyedEmptyVialsCount);
if (destroyedEmptyVialsCount == 0)
{
// cannot destroy any empty vial (should be impossible)
return;
}
// spawn biomaterial vials
var protoItemVialBiomaterial = Api.GetProtoEntity <ItemVialBiomaterial>();
var createItemResult = Server.Items.CreateItem(protoItemVialBiomaterial,
character,
count: destroyedEmptyVialsCount);
if (!createItemResult.IsEverythingCreated)
{
createItemResult.Rollback();
var groundItemsContainer =
ObjectGroundItemsContainer.ServerTryGetOrCreateGroundContainerAtTileOrNeighbors(character,
character.Tile);
if (groundItemsContainer is null)
{
Logger.Error("Not enough space around the player to drop a full vial");
// restore items
Server.Items.CreateItem(protoItemVialEmpty,
character,
destroyedEmptyVialsCount);
return;
}
createItemResult = Server.Items.CreateItem(protoItemVialBiomaterial,
groundItemsContainer,
count: destroyedEmptyVialsCount);
if (!createItemResult.IsEverythingCreated)
{
createItemResult.Rollback();
Logger.Error("Not enough space around the player to drop a full vial");
// restore items
Server.Items.CreateItem(protoItemVialEmpty,
character,
destroyedEmptyVialsCount);
return;
}
NotificationSystem.ServerSendNotificationNoSpaceInInventoryItemsDroppedToGround(character,
protoItemVialBiomaterial);
}
var itemChangedCount = NotificationSystem.SharedGetItemsChangedCount(createItemResult);
itemChangedCount.Add(protoItemVialEmpty, -(int)destroyedEmptyVialsCount);
NotificationSystem.ServerSendItemsNotification(character, itemChangedCount);
ItemDurabilitySystem.ServerModifyDurability(itemDevice, -DurabilityDecreasePerUse);
Logger.Info("Biomaterial collected successfully with Biomaterial collector", character);
}
public string Execute(TechGroup group, [CurrentCharacterIfNull] ICharacter player = null)
{
player.SharedGetTechnologies().ServerRemoveGroup(group);
return($"{player} tech group {group.NameWithTierName} removed.");
}
public void BasicAttack(ICharacter c)
{
Console.WriteLine("Basic attack from Malphite.");
c.HealthPoint = c.HealthPoint + c.DefensePoint - AttackPoint;
}
public static PlayCardTask SpellTarget(Controller controller, string cardName, ICharacter target, int chooseOne = 0,
bool skipPrePhase = false)
{
return(new PlayCardTask(controller, controller.HandZone.First(p => p.Card.Name == cardName), target, -1, chooseOne, skipPrePhase));
}
public static PlayCardTask SpellTarget(Controller controller, IPlayable source, ICharacter target, int chooseOne = 0,
bool skipPrePhase = false)
{
return(new PlayCardTask(controller, source, target, -1, chooseOne, skipPrePhase));
}
protected override void SharedOnActionCompletedInternal(ItemFuelRefillActionState state, ICharacter character)
{
if (IsClient)
{
return;
}
var item = state.Item;
var protoItemFuelRefillable = (IProtoItemWithFuel)item.ProtoItem;
var capacity = protoItemFuelRefillable.ItemFuelConfig.FuelCapacity;
var currentFuelAmount = protoItemFuelRefillable.ItemFuelConfig
.SharedGetFuelAmount(item);
currentFuelAmount = ServerTryConsumeFuelItems(state,
character,
currentFuelAmount,
capacity);
if (currentFuelAmount > capacity)
{
throw new Exception("Impossible - amount exceeded");
}
protoItemFuelRefillable.ItemFuelConfig
.SharedOnRefilled(item,
currentFuelAmount,
serverNotifyClients: true);
}
public static PlayCardTask Any(Controller controller, IPlayable source, ICharacter target = null,
int zonePosition = -1, int chooseOne = 0, bool skipPrePhase = false)
{
return(new PlayCardTask(controller, source, target, zonePosition, chooseOne, skipPrePhase));
}
protected override ItemFuelRefillRequest ClientTryCreateRequest(ICharacter character)
{
var item = character.SharedGetPlayerSelectedHotbarItem();
return(this.ClientTryCreateRequest(character, item));
}
private static NetworkSyncList <ILogicObject> InternalSharedGetStatusEffects(ICharacter character)
{
return(character.GetPrivateState <BaseCharacterPrivateState>()
.StatusEffects);
}
public static bool HeroPower(Controller c, ICharacter target = null)
{
return(HeroPowerBlock.Invoke(c, target));
}
public static void ServerAddStatusEffect(
this ICharacter character,
IProtoStatusEffect protoStatusEffect,
double intensity = 1.0)
{
if (protoStatusEffect == null)
{
throw new ArgumentNullException(nameof(protoStatusEffect));
}
if (intensity <= 0)
{
throw new ArgumentException(
$"Intensity to add must be > 0. Provided value: {intensity:F2}",
nameof(intensity));
}
if (character.ProtoCharacter is PlayerCharacterSpectator ||
ServerCharacters.IsSpectator(character))
{
// don't add status effects to the spectator characters
return;
}
if (intensity > 1)
{
// clamp intensity to add
intensity = 1;
}
ILogicObject statusEffect = null;
var statusEffects = InternalServerGetStatusEffects(character);
foreach (var existingStatusEffect in statusEffects)
{
if (existingStatusEffect.ProtoGameObject == protoStatusEffect)
{
statusEffect = existingStatusEffect;
break;
}
}
if (statusEffect == null)
{
// no such status effect instance exists - create and add it
statusEffect = ServerWorld.CreateLogicObject(protoStatusEffect);
protoStatusEffect.ServerSetup(statusEffect, character);
statusEffects.Add(statusEffect);
Logger.Info($"Status effect added: {statusEffect} to {character}");
}
protoStatusEffect.ServerAddIntensity(statusEffect, intensity);
var publicState = statusEffect.GetPublicState <StatusEffectPublicState>();
var damageContext = CharacterDamageContext.Current;
var byCharacter = damageContext.AttackerCharacter;
if (!ReferenceEquals(byCharacter, null))
{
publicState.ServerStatusEffectWasAddedByCharacter = byCharacter;
publicState.ServerStatusEffectWasAddedByCharacterWeaponSkill = damageContext.ProtoWeaponSkill;
}
}
public IEnemyState(EnemyFSMSystem fsm, ICharacter character)
{
mFSM = fsm;
mCharacter = character;
mTargetPosition = GameFacade.Instance.GetEnemyTargetPosition();
}
public override void SpellEffect(ICharacter caster, ICharacter target)
{
var damage = (3.375 * cMD * (cWND / 100) - .15 * tMR) * (100 / tWND);
DealDamage(damage);
}
public double GetGatheringSpeedMultiplier(IStaticWorldObject worldObject, ICharacter character)
{
return(character.SharedGetFinalStatMultiplier(StatName.HuntingLootingSpeed));
}
public FireMonsterBuilder(ICharacter character, int characterID, CharacterRefreshPO characterRefreshPO) : base(character, characterID, characterRefreshPO)
{
}
public void FirstSkill(ICharacter c)
{
Console.WriteLine($"First skill from Malphite and this skill name is {firstSkillName}");
c.HealthPoint = c.HealthPoint + c.DefensePoint - 20;
}
protected override void SharedOnActionCompletedInternal(GatheringActionState state, ICharacter character)
{
var worldObject = (IStaticWorldObject)state.TargetWorldObject;
var protoGatherable = (IProtoObjectGatherable)worldObject.ProtoWorldObject;
Logger.Info($"Gathering completed: {worldObject} by {character}", character);
if (IsClient)
{
return;
}
// Server-side only
if (protoGatherable.ServerGather(worldObject, character))
{
Api.SafeInvoke(() => ServerOnGather?.Invoke(character, worldObject));
}
}
private void Awake()
{
_character = _characterGO.GetComponent <ICharacter>();
}
public override void SpellEffect(ICharacter caster, ICharacter target)
{
BuffAllStats(target, .35);
}
public override void SpellEffect(ICharacter caster, ICharacter target)
{
var damage = 1.25 * cAD - .625 * tDEF;
DealDamage(damage);
}
