protected override void Shot(IWorldObject source)
{
Scene.SoundManager.PlaySoundEffect("sounds/Bullet");
var bullet = new LaserBullet(Scene,
"textures/laser",
source.World.Translation,
Vector3.Normalize(source.World.Forward) * 1024.0f);
var animation = new LoopedSpriteAnimation("Main", new[]
{
new SpriteAnimationFrame
{
Duration = TimeSpan.FromSeconds(0.1d),
SourceRectangle = new Rectangle(0, 0, 256, 256)
},
new SpriteAnimationFrame
{
Duration = TimeSpan.FromSeconds(0.1d),
SourceRectangle = new Rectangle(256, 0, 256, 256)
},
new SpriteAnimationFrame
{
Duration = TimeSpan.FromSeconds(0.1d),
SourceRectangle = new Rectangle(512, 0, 256, 256)
}
});
bullet.AddAnimation(animation)
.SetCurrentAnimation(animation)
.Play();
Scene.AddComponent(bullet, "Models");
}
public FollowCamera(ICamera camera, IWorldObject target)
{
this.camera = camera;
this.target = target;
Distance = 1.0f;
TicksToCatchUp = 200;
}
internal ChasingCameraConfig(IWorldObject chasedObject)
{
_cameraConfig = new CameraConfig();
_chasedObject = chasedObject;
_positionOffset = Vector3.Backward;
_lookAtOffset = Vector3.Zero;
}
public ParticleEffect(XmlReader r, IWorldObject parent, WorldEditor app)
{
this.parent = parent;
this.app = app;
FromXml(r);
}
protected Weapon(Scene scene, TimeSpan chargeTime, Int32 munitions, IWorldObject source)
: base(scene)
{
_chargeTime = chargeTime;
_munitions = munitions;
_source = source;
}
public WorldTerrain(WorldEditor worldEditor)
{
app = worldEditor;
terrainDisplay = new AutoSplatTerrainDisplay(this, app);
terrainGenerator = DefaultTerrainGenerator();
}
public override void SetModel(IWorldObject model)
{
base.SetModel(model);
var m = model as TutorialTriggerVolumeWorldObject;
this.Height = m.Height;
this.Width = m.Width;
this.Text = m.Text;
}
public SmartGuid(IWorldObject obj)
{
if ((var player = obj as Player) != null)
{
Type = GuidType.Player;
MapId = (ushort)player.Data.Map;
CreationBits = player.Data.Guid;
}
}
public override void SetModel(IWorldObject model)
{
base.SetModel(model);
var m = model as ConcreteWorldObject;
this.Height = m.Height;
this.Width = m.Width;
this.SpriteKey = m.SpriteKey;
}
public void ShowProperties(String viewName, IWorldObject obj)
{
var view = this._viewFactory.GetView(viewName);
((WorldObjectPropertiesViewModel)(view.DataContext)).Context = this;
((WorldObjectPropertiesViewModel)(view.DataContext)).MoveModelToView(obj as IWorldObject);
this.PropertiesView = (UserControl)view;
RaisePropertyChanged(() => PropertiesView);
}
/// <summary>
/// This function will return the distance in meters.
/// The manual distance units are in map compass units, while the distance units used in the UI are meters.
/// In AC there are 240 meters in a kilometer; thus if you set your attack range to 1 in the UI it
/// will showas 0.00416666666666667in the manual options (0.00416666666666667 being 1/240).
/// </summary>
/// <param name="obj1"></param>
/// <param name="obj2"></param>
/// <returns></returns>
/// <exception cref="ArgumentOutOfRangeException">Object passed with an Id of 0</exception>
public static double GetDistance(IWorldObject obj1, IWorldObject obj2)
{
if (obj1.Id == 0)
throw new ArgumentOutOfRangeException("obj1", "Object passed with an Id of 0");
if (obj2.Id == 0)
throw new ArgumentOutOfRangeException("obj2", "Object passed with an Id of 0");
return REPlugin.Instance.WorldFilter.Distance(obj1.Id, obj2.Id) * 240;
}
public static WorldObjectMutex Obtain(IWorldObject wo)
{
bool owned;
var mutex = new Mutex(true, string.Format("Global\\re_{0}", wo.Id), out owned);
if (!owned)
mutex.WaitOne();
return new WorldObjectMutex(wo, mutex, true);
}
protected Emitter CreateEffectAtObjectPosition(string effectName, string textureName, IWorldObject targetObject)
{
Emitter effectEmitter = EmitterFactoryManager.EmitterFactories[effectName].CreateEmitter();
effectEmitter.ParticleRegistrationCallback = RegisterParticle;
effectEmitter.ParticleTexture = TextureManager.Textures[textureName];
effectEmitter.WorldPosition = targetObject.WorldPosition;
if (targetObject is ICameraRelative) { effectEmitter.CameraPosition = CameraController.WorldPosition; }
return effectEmitter;
}
public ParticleEffect(IWorldObject parent, WorldEditor app, string particleEffectName, float particleScale, float velocityScale, Quaternion orientation)
{
this.parent = parent;
this.app = app;
this.orientation = orientation;
this.particleEffectName = particleEffectName;
this.particleScale = particleScale;
this.velocityScale = velocityScale;
}
public DragObjectsInWorldCommand(WorldEditor worldEditor, List<IWorldObject> list, IWorldObject hit)
{
this.app = worldEditor;
this.hitObject = hit;
foreach (IWorldObject obj in list)
{
this.list.Add(obj);
this.dragObject.Add(obj as IObjectDrag);
origPosition.Add(new Vector3((obj as IObjectDrag).Position.x,(obj as IObjectDrag).Position.y, (obj as IObjectDrag).Position.z));
}
}
public override void MoveModelToView(IWorldObject model)
{
base.MoveModelToView(model);
var m = model as TerrainWorldObject;
this.Rows = m.Rows;
this.Columns = m.Columns;
this.TileHeight = m.TileHeight;
this.TileWidth = m.TileWidth;
}
/// <summary>
/// Requests the <see cref="Grid"/> to return a list of all <see cref="IWorldObject"/>s
/// which share a GridLocation with the given object.
/// </summary>
/// <param name="worldObject"></param>
/// <returns></returns>
public List<IWorldObject> getCollidableObjects(IWorldObject worldObject)
{
List<IWorldObject> collidables = new List<IWorldObject>();
// find all grid locations that contain the object
foreach (GridLocation gridLocation in Intersects(worldObject))
{
// compile a list of all objects contained in the found Grid Locations
collidables.AddRange(getLocationObjectsOf(gridLocation));
}
return collidables;
}
public DragMPPointCommandFactory(WorldEditor worldEditor, IWorldObject obj)
{
app = worldEditor;
this.obj = obj;
if (obj is MPPoint)
{
point = obj as MPPoint;
}
else
{
return;
}
}
public AsteroidEmitter(Scene scene,
String[] assets,
IWorldObject target,
ExplosionManager explosionManager)
: base(scene)
{
Verify.That(target).Named("target").IsNotNull();
_target = target;
_explosionManager = explosionManager;
_assets = assets;
_random = new Random();
}
public ChasingCamera(Scene scene, IChasingCameraConfig config)
: base(scene, config)
{
_chasedObject = config.ChasedObject;
_positionOffset = config.PositionOffset;
_lookAtOffset = config.LookAtOffset;
_stiffness = config.Stiffness;
_dampingFactor = config.DampingFactor;
_mass = config.Mass;
SetPosition(config.Position);
SetUp(config.Up);
UpdateRotation();
}
private void Draw(IWorldObject worldObject)
{
if (worldObject is Box)
{
this.Draw((Box)worldObject);
}
else if (worldObject is Circle)
{
this.Draw((Circle)worldObject);
}
else if (worldObject is Car)
{
this.Draw((Car)worldObject);
}
}
public void move()
{
if (WorldObject != null)
{
movedBy = WorldObject;
// HACK: GL.LoadIdentity should be called here
Direction direction = WorldObject.Direction;
GL.Rotate(direction.X, 1.0f, 0.0f, 0.0f);
GL.Rotate(direction.Rotation, 0.0f, 0.0f, 1.0f);
GL.Rotate(direction.Y, 0.0f, 1.0f, 0.0f);
WorldPosition position = WorldObject.Position;
GL.Translate(position.x, position.y, position.z);
}
}
public DragObjectsInWorldCommandFactory(WorldEditor worldEditor, List<IWorldObject> objList, IWorldObject hitObject)
{
this.app = worldEditor;
this.hitObject = hitObject;
foreach (IWorldObject obj in objList)
{
if (!(obj is IObjectDrag) || (obj is MPPoint))
{
return;
}
else
{
list.Add(obj);
}
}
}
public override void SetModel(IWorldObject model)
{
var m = model as ArchetypeBasedConcreteWorldObject;
this._archetypeKey = m.ArchetypeKey;
if (m.ArchetypeData != null)
this._archetypeData = (ConcreteWorldObjectArchetypeData)m.ArchetypeData;
else
{
var archetype = _packageRepository.Assets.Where(x => x.Key == _archetypeKey).Single();
this._archetypeData = (ConcreteWorldObjectArchetypeData)_packageRepository.GetAssetData<ArchetypeResource>(archetype.Id).Data;
m.SetArchetypeData(this._archetypeData);
}
this.Sprite = _spriteLoader.LoadSprite(_archetypeData.SpriteKey);
base.SetModel(model);
}
public override bool CanBeCrafted(
IWorldObject characterOrStationObject,
CraftingQueue craftingQueue,
ushort countToCraft)
{
if (characterOrStationObject is null)
{
// require character or station
return(false);
}
if (this.RecipeType != RecipeType.Hand &&
!this.StationTypes.Contains(characterOrStationObject.ProtoWorldObject))
{
// requires station
return(false);
}
return(base.CanBeCrafted(characterOrStationObject, craftingQueue, countToCraft));
}
/// <summary>
/// Init on component enabled.
/// </summary>
public override void Start(ClientComponent parentComponent)
{
base.Start(parentComponent);
// Check if there an action in progress.
if (PrivateState.CurrentActionState != null)
{
readyForInteraction = false;
lastActionState = PrivateState.CurrentActionState;
}
// Check if we opened loot container before enabling component.
var currentInteractionObject = InteractionCheckerSystem.SharedGetCurrentInteraction(CurrentCharacter);
if (currentInteractionObject?.ProtoWorldObject is ProtoObjectLootContainer)
{
readyForInteraction = false;
openedLootContainer = currentInteractionObject;
}
}
public void AttackTarget(IWorldObject targetObject, Vector2D intersectionPoint)
{
if (targetObject == null)
{
return;
}
var deltaPositionToMouseCursor = CurrentCharacter.Position +
GetWeaponOffset() -
intersectionPoint;
var rotationAngleRad =
Math.Abs(Math.PI + Math.Atan2(deltaPositionToMouseCursor.Y, deltaPositionToMouseCursor.X));
var moveModes = PlayerCharacter.GetPrivateState(CurrentCharacter).Input.MoveModes;
// TODO: don't prevent moving
var command = new CharacterInputUpdate(moveModes, (float)rotationAngleRad);
((PlayerCharacter)CurrentCharacter.ProtoCharacter).ClientSetInput(command);
// TODO: prevent user mousemove to interrupt it
SelectedItem.ProtoItem.ClientItemUseStart(SelectedItem);
}
public override void SharedOnHit(
WeaponFinalCache weaponCache,
IWorldObject damagedObject,
double damage,
WeaponHitData hitData,
out bool isDamageStop)
{
isDamageStop = true;
if (IsServer)
{
var explosionWorldPosition = SharedGetExplosionWorldPosition(damagedObject, hitData);
this.ServerExplodeAt(weaponCache, explosionWorldPosition, isHit: true);
}
else
{
var explosionWorldPosition = SharedGetExplosionWorldPosition(damagedObject, hitData);
this.ClientExplodeAt(weaponCache, explosionWorldPosition);
}
}
private void onWorldObjectDetect(IWorldObject wo, bool enter)
{
if (enter == true)
{
GameObject blip = Instantiate(blipPrefab, PositionOnEdge(wo), new Quaternion(0, 0, 0, 1));
blip.transform.parent = nodesContainer.transform;
// add to dict
blips[wo.id] = blip;
}
else
{
// destroy game object
GameObject blip = blips[wo.id];
Destroy(blip);
// remove from dict
blips.Remove(wo.id);
}
}
public static bool SharedUnregister(ICharacter character, IWorldObject worldObject, bool isAbort)
{
var pair = new Pair(character, worldObject);
if (!RegisteredActions.TryGetValue(pair, out var action))
{
return(false);
}
try
{
action.FinishAction?.Invoke(isAbort);
}
finally
{
RegisteredActions.Remove(pair);
}
return(true);
}
public IMovementPath GetPath(ICharacter user, IWorldObject targetObject)
{
Tile playerTile = user.Tile;
Vector2Ushort targetTilePos = targetObject.TilePosition;
if (playerTile.Position == targetTilePos) // User activated the script while already standing near to the target
{
return(new StraightMovementPath(user.Position, GeometryHelper.TileCenter(playerTile), targetObject));
}
SortedSet <PathCandidate> candidates = new SortedSet <PathCandidate>();
HashSet <Tile> visited = new HashSet <Tile>();
candidates.Add(PathCandidate.Init(playerTile, targetTilePos));
// Api.Logger.Dev($"Automaton: finding path from {playerTile.Position} to {targetTilePos}");
while (candidates.Count != 0)
{
PathCandidate withLeastWeight = candidates.Min();
candidates.Remove(withLeastWeight);
var undiscovered = new HashSet <Tile>(withLeastWeight.Neighbours).Except(visited);
visited.Add(withLeastWeight.Head);
foreach (Tile next in undiscovered)
{
if (next.Position == targetTilePos)
{
return(new WaypointMovementPath(withLeastWeight.Fork(next).AsTilesCenters(), targetObject));
}
if (CanTravel(user, withLeastWeight.Head, next) && withLeastWeight.Length < MAX_PATH_TILES)
{
candidates.Add(withLeastWeight.Fork(next));
}
}
}
// Api.Logger.Error($"Automaton: failed to find proper path from {playerTile.Position} to {targetTilePos}.");
return(new NoPathPath(user));
}
protected BaseSystemActionState(
ICharacter character,
IWorldObject targetWorldObject,
double durationSeconds)
: base(character)
{
durationSeconds = Api.Shared.RoundDurationByServerFrameDuration(durationSeconds);
if (Api.IsClient)
{
// Add ping to all client action durations.
// Otherwise the client will not see immediately the result of the action
// - the client will receive it only after RTT (ping) time.
// TODO: currently it's possible to cancel action earlier and start a new one, but completed action result will come from server - which looks like a bug to player
durationSeconds += Api.Client.CurrentGame.PingGameSeconds;
}
this.DurationSeconds = durationSeconds;
this.TargetWorldObject = targetWorldObject;
this.timeRemainsSeconds = durationSeconds;
}
void IInteractableProtoWorldObject.ServerOnMenuClosed(ICharacter who, IWorldObject worldObject)
{
var area = LandClaimSystem.ServerGetLandClaimArea((IStaticWorldObject)worldObject);
if (area == null)
{
// area could be null in the Editor for the land claim without owners
return;
}
var areasGroup = LandClaimArea.GetPublicState(area).LandClaimAreasGroup;
if (!LandClaimSystem.ServerIsOwnedArea(area, who) &&
(PlayerCharacterSpectator.SharedIsSpectator(who) ||
CreativeModeSystem.SharedIsInCreativeMode(who)))
{
Server.World.ExitPrivateScope(who, area);
}
Server.World.ExitPrivateScope(who, areasGroup);
}
public ICommand CreateCommand()
{
if (app.SelectedObject.Count > 0)
{
this.hitObject = app.SelectedObject[0];
foreach (IWorldObject obj in app.SelectedObject)
{
if (!(obj is IObjectDrag) || (obj is MPPoint))
{
return null;
}
else
{
list.Add(obj);
}
}
}
ICommand cmd = new DragObjectsFromMenuCommand(app, list, hitObject);
return cmd;
}
private TreeNode drawObject(IWorldObject obj)
{
var objectNode = new TreeNode();
if (obj != null)
{
objectNode.Text = obj.ToString();
foreach (var r in (obj as WorldObject).Relations)
{
var rNode = drawObject(r as RelationObject);
var objec = drawObject(r.Objective as WorldObject);
rNode.Nodes.Add(objec);
objectNode.Nodes.Add(rNode);
}
}
else
{
objectNode.Text = "null object";
}
return(objectNode);
}
public override void ServerOnDamageApplied(
IItem weapon,
ICharacter byCharacter,
IWorldObject damagedObject,
double damage)
{
base.ServerOnDamageApplied(weapon, byCharacter, damagedObject, damage);
if (IsClient)
{
// on client we cannot deduct energy
return;
}
// deduct energy on hit
var requiredEnergyAmount = SkillWeaponsEnergy.SharedGetRequiredEnergyAmount(
byCharacter,
this.EnergyUsePerHit);
CharacterEnergySystem.ServerDeductEnergyCharge(byCharacter, requiredEnergyAmount);
}
public static IComponentSpriteRenderer AddShadowRenderer(
IWorldObject worldObject,
float scaleMultiplier = 1f,
Vector2D?positionOffset = null)
{
if (scaleMultiplier <= 0f)
{
return(null);
}
var spriteRenderer = Api.Client.Rendering.CreateSpriteRenderer(
worldObject,
TextureResourceShadow,
drawOrder: DrawOrder.Shadow,
positionOffset: positionOffset ?? (0.5, 0.1),
// draw origin - center
spritePivotPoint: (0.5, 0.5));
spriteRenderer.Scale = 0.5 * scaleMultiplier;
return(spriteRenderer);
}
private void OnObjectSpawned(IWorldObject worldObject, double d, double d1, double d2, byte pitch, byte yaw)
{
if (!falling)
{
return;
}
var fallingOjbect = worldObject as FallingBlockObject;
if (fallingOjbect != null)
{
if (fallingOjbect.BlockType == 12)
{
NotifyUser(ApplyVariables("Falling sand block detected.", player.status.entity.location.ToLocation(0), new Location((int)d, (float)d1, (int)d2), "Sand"), 6, 6);
}
else if (fallingOjbect.BlockType == 46)
{
NotifyUser(ApplyVariables("Falling TNT block detected.", player.status.entity.location.ToLocation(0), new Location((int)d, (float)d1, (int)d2), "TNT"), 7, 7);
}
}
}
private void ObjectSpawned(IWorldObject worldObject, double X, double Y, double Z, byte pitch, byte yaw)
{
if (token.stopped)
{
return;
}
// We only care for fishing hook spawns.
if (worldObject.GetType() != ObjectTypes.FishingHook)
{
return;
}
var hook = (FishingFloatObject)worldObject;
if (hook.Owner != player.status.entity.entityId)
{
return; // We care only for our hook.
}
this.lureObject = hook; // Assign the lure object.
}
public ICommand CreateCommand()
{
if (app.SelectedObject.Count > 0)
{
this.hitObject = app.SelectedObject[0];
foreach (IWorldObject obj in app.SelectedObject)
{
if (!(obj is IObjectDrag) || (obj is MPPoint))
{
return(null);
}
else
{
list.Add(obj);
}
}
}
ICommand cmd = new DragObjectsFromMenuCommand(app, list, hitObject);
return(cmd);
}
public void SharedCreatePhysics(IWorldObject worldObject)
{
var physicsBody = worldObject.PhysicsBody;
if (physicsBody is null)
{
return;
}
physicsBody.Reset();
var createPhysicsData = new CreatePhysicsData((TWorldObject)worldObject, physicsBody);
this.SharedCreatePhysics(createPhysicsData);
this.SharedProcessCreatedPhysics(createPhysicsData);
if (physicsBody.HasShapes)
{
physicsBody.IsEnabled = true;
}
}
protected override void ServerOnStaticObjectZeroStructurePoints(
WeaponFinalCache weaponCache,
ICharacter byCharacter,
IWorldObject targetObject)
{
// do not use default implementation because it will destroy the object automatically
//base.ServerOnStaticObjectZeroStructurePoints(weaponCache, targetObject);
var worldObject = (IStaticWorldObject)targetObject;
var publicState = GetPublicState(worldObject);
if (byCharacter != null &&
(LandClaimSystem.ServerIsOwnedArea(publicState.LandClaimAreaObject, byCharacter) ||
CreativeModeSystem.SharedIsInCreativeMode(byCharacter)))
{
// this is the owner of the area or the player is in a creative mode
if (byCharacter.SharedGetPlayerSelectedHotbarItemProto() is ProtoItemToolCrowbar)
{
publicState.ServerTimeForDestruction = 0;
Logger.Important(
$"Land claim object {targetObject} destroyed by the owner with a crowbar - no destruction timer",
byCharacter);
this.ServerForceUpdate(worldObject, publicState);
return;
}
}
if (publicState.ServerTimeForDestruction.HasValue)
{
// destruction timer is already set
return;
}
// the land claim structure points is zero - it's broken now - set timer for destruction
publicState.ServerTimeForDestruction = Server.Game.FrameTime
+ this.DestructionTimeout.TotalSeconds;
Logger.Important($"Timer for destruction set: {targetObject}. Timeout: {this.DestructionTimeout}");
this.ServerForceUpdate(worldObject, publicState);
}
public static FactionMemberAccessRights SharedGetFactionAccessRightRequirementForObject(
IWorldObject worldObject)
{
if (worldObject is null)
{
Logger.Error("Game object is null for faction access right");
return(FactionMemberAccessRights.LandClaimManagement); // fallback
}
if (worldObject.IsStatic)
{
return(FactionMemberAccessRights.LandClaimManagement);
}
if (worldObject.ProtoGameObject is IProtoVehicle)
{
return(FactionMemberAccessRights.VehicleAccessManagement);
}
Logger.Error("Unknown game object type for faction access right: " + worldObject);
return(FactionMemberAccessRights.LandClaimManagement); // fallback
}
public override bool SharedOnDamage(
WeaponFinalCache weaponCache,
IWorldObject targetObject,
double damagePreMultiplier,
out double obstacleBlockDamageCoef,
out double damageApplied)
{
if (IsServer &&
(!weaponCache.Character?.IsNpc ?? false))
{
var mobPrivateState = GetPrivateState((ICharacter)targetObject);
mobPrivateState.CurrentAgroCharacter = weaponCache.Character;
//Logger.Dev(
// $"Mob damaged by player, let's agro: {targetObject} by {mobPrivateState.CurrentAgroCharacter}");
}
return(base.SharedOnDamage(weaponCache,
targetObject,
damagePreMultiplier,
out obstacleBlockDamageCoef,
out damageApplied));
}
protected Scene(PositronGame game, string name)
{
_Game = game;
_Name = name;
// TODO: This is awful. Fix it.
// TODO: Actually fix this.
// TODO: Seriously, make this -not suck-
ViewWidth = _Game.Window.CanvasWidth;
ViewHeight = _Game.Window.CanvasHeight;
Background = new RenderSet(this);
Rear = new RenderSet(this);
Stage = new RenderSet(this);
Tests = new RenderSet(this);
Front = new RenderSet(this);
WorldBlueprint = new RenderSet(this);
HUD = new RenderSet(this);
HUDBlueprint = new RenderSet(this);
HUDDebug = new RenderSet(this);
// This should contain everything AllRenderSetsInOrder would contain
// This is an optimization over using an enumerable
//All = new RenderSet(this, Background, Rear, Stage, Tests, Front, HUD, HUDBlueprint, HUDDebug);
SceneEntry += (sender, e) =>
{
foreach (RenderSet render_set in AllRenderSetsInOrder())
{
render_set.ForEach(element => {
if (element is IWorldObject)
{
IWorldObject w_o = (IWorldObject)element;
//Console.WriteLine("Rotation for {0} sprite with rotation {1}", w_o, w_o.Theta);
}
});
}
};
}
public Recipe MatchRecipe(IWorldObject objectManufacturer, CraftingQueue craftingQueue)
{
Recipe bestRecipe = null;
foreach (var recipe in this.Recipes)
{
if (bestRecipe != null
// TODO: compare by "value" of recipes?
&& recipe.InputItems.Count < bestRecipe.InputItems.Count)
{
// no need to check this recipe - already has a good recipe with the similar amount of items
continue;
}
if (recipe.CanBeCrafted(objectManufacturer, craftingQueue, countToCraft: 1))
{
bestRecipe = recipe;
}
}
return(bestRecipe);
}
public ViewModelWorldObjectFactionAccessEditorControl(IWorldObject worldObject)
{
this.worldObject = worldObject;
this.accessRight = WorldObjectAccessModeSystem.SharedGetFactionAccessRightRequirementForObject(worldObject);
if (worldObject.ProtoGameObject is not IProtoObjectWithAccessMode protoObjectWithAccessMode)
{
throw new Exception("This world object doesn't have an access mode");
}
this.isClosedModeAvailable = protoObjectWithAccessMode.IsClosedAccessModeAvailable;
this.isEveryoneModeAvailable = protoObjectWithAccessMode.IsEveryoneAccessModeAvailable;
this.privateState = worldObject.GetPrivateState <IObjectWithAccessModePrivateState>();
this.privateState.ClientSubscribe(_ => _.FactionAccessMode,
_ => this.RefreshCheckboxes(),
this);
FactionSystem.ClientCurrentFactionAccessRightsChanged += this.CurrentFactionAccessRightsChanged;
this.RecreateViewModelAccessModes();
}
public static double ServerCalculateTotalDamage(
WeaponFinalCache weaponFinalCache,
IWorldObject targetObject,
FinalStatsCache targetFinalStatsCache,
double damagePreMultiplier,
bool clampDefenseTo1)
{
if (weaponFinalCache.ProtoObjectExplosive != null &&
targetObject.ProtoWorldObject is IProtoStaticWorldObject targetStaticWorldObjectProto)
{
// special case - apply the explosive damage
return(ServerCalculateTotalDamageByExplosive(weaponFinalCache.ProtoObjectExplosive,
targetStaticWorldObjectProto,
damagePreMultiplier));
}
var damageValue = damagePreMultiplier * weaponFinalCache.DamageValue;
var invertedArmorPiercingCoef = weaponFinalCache.InvertedArmorPiercingCoef;
var totalDamage = 0d;
// calculate total damage by summing all the damage components
foreach (var damageDistribution in weaponFinalCache.DamageDistributions)
{
var defenseStatName = SharedGetDefenseStatName(damageDistribution.DamageType);
var defenseFraction = targetFinalStatsCache[defenseStatName];
defenseFraction = MathHelper.Clamp(defenseFraction, 0, clampDefenseTo1 ? 1 : double.MaxValue);
totalDamage += ServerCalculateDamageComponent(
damageValue,
invertedArmorPiercingCoef,
damageDistribution,
defenseFraction);
}
// multiply on final multiplier (usually used for expanding projectiles)
totalDamage *= weaponFinalCache.FinalDamageMultiplier;
return(totalDamage);
}
public static void ShowOn(IWorldObject worldObject, string message)
{
Hide();
var staticWorldObject = worldObject as IStaticWorldObject;
var protoStaticWorldObject = staticWorldObject?.ProtoStaticWorldObject;
var positionOffset = protoStaticWorldObject != null
? protoStaticWorldObject.SharedGetObjectCenterWorldOffset(staticWorldObject)
: (0, 0);
positionOffset += (0, 1.18);
lastControl = new WorldObjectTitleTooltip();
lastControl.Setup(message);
lastControl.attachedControl = Api.Client.UI.AttachControl(
worldObject,
lastControl,
positionOffset: positionOffset,
isFocusable: false);
}
protected override double ServerCalculateObjectEnvironmentalIntensity(
ICharacter character,
IWorldObject worldObject)
{
if (!(worldObject.ProtoWorldObject is IProtoObjectPsiSource protoPsiSource) ||
!protoPsiSource.ServerIsPsiSourceActive(worldObject))
{
return(0);
}
if (protoPsiSource is IProtoObjectPsiSourceCustom protoPsiSourceCustom)
{
return(MathHelper.Clamp(
protoPsiSourceCustom.ServerCalculatePsiIntensity(worldObject, character),
min: 0,
max: 1));
}
var position = worldObject switch
{
IStaticWorldObject staticWorldObject
=> staticWorldObject.TilePosition.ToVector2D()
+ staticWorldObject.ProtoStaticWorldObject.Layout.Center,
IDynamicWorldObject dynamicWorldObject
=> dynamicWorldObject.Position,
_ => throw new InvalidOperationException()
};
var distance = position.DistanceTo(character.Position);
var maxDistance = protoPsiSource.PsiRadiusMax;
var minDistance = protoPsiSource.PsiRadiusMin;
var distanceCoef = (distance - minDistance) / (maxDistance - minDistance);
var intensity = 1 - MathHelper.Clamp(distanceCoef, 0, 1);
return(intensity * MathHelper.Clamp(protoPsiSource.PsiIntensity, 0, 1));
}
protected override void ServerOnStaticObjectZeroStructurePoints(
WeaponFinalCache weaponCache,
ICharacter byCharacter,
IWorldObject targetObject)
{
base.ServerOnStaticObjectZeroStructurePoints(weaponCache, byCharacter, targetObject);
if (weaponCache == null ||
(weaponCache.ProtoWeapon == null &&
weaponCache.ProtoObjectExplosive == null) ||
PveSystem.ServerIsPvE)
{
return;
}
// the damage was dealt by a weapon or explosive - try to explode the deposit
var worldObjectDeposit = this.SharedGetDepositWorldObject(
Server.World.GetTile(targetObject.TilePosition));
((IProtoObjectDeposit)worldObjectDeposit?.ProtoStaticWorldObject)?
.ServerOnExtractorDestroyedForDeposit(worldObjectDeposit);
}
private string ServerRemote_SetOwners(IWorldObject worldObject, List <string> newOwners)
{
var maxOwners = worldObject.ProtoGameObject is IProtoObjectDoor
? StructureConstants.SharedDoorOwnersMax
: byte.MaxValue;
if (newOwners.Count > maxOwners)
{
return(DialogCannotSetOwners_AccessListSizeLimitExceeded);
}
var character = ServerRemoteContext.Character;
if (!worldObject.ProtoWorldObject.SharedCanInteract(character,
worldObject,
writeToLog: false))
{
throw new Exception("The player character cannot interact with " + worldObject);
}
return(ServerSetOwners(worldObject, newOwners, byOwner: character));
}
public static bool SharedCheckCanInteract(
ICharacter character,
IWorldObject worldObject,
bool writeToLog)
{
if (worldObject == null ||
worldObject.IsDestroyed)
{
return(false);
}
// it's possible to build/repair any building within a certain distance to the character
var staticWorldObject = (IStaticWorldObject)worldObject;
var canInteract = CheckCanInteractForConstruction(character,
staticWorldObject,
writeToLog,
checkRaidblock: false);
if (!canInteract)
{
return(false);
}
if (LandClaimSystem.SharedIsUnderRaidBlock(character, staticWorldObject))
{
// the building is in an area under the raid
if (writeToLog)
{
SharedShowCannotBuildNotification(
character,
LandClaimSystem.ErrorCannotBuild_RaidUnderWay,
staticWorldObject.ProtoStaticWorldObject);
}
return(false);
}
return(true);
}
private void ServerFinishInteractionInternal(ICharacter who, IWorldObject worldObject)
{
if (worldObject.IsDestroyed)
{
return;
}
Server.World.ExitPrivateScope(who, worldObject);
try
{
SharedGetProto(worldObject).ServerOnMenuClosed(who, worldObject);
}
catch (Exception ex)
{
Logger.Exception(
ex,
"Exception when calling " + nameof(IInteractableProtoWorldObject.ServerOnMenuClosed));
}
Logger.Info($"Finished object interaction with {worldObject} for {who}");
}
public override void ServerOnObjectHitByExplosion(
IWorldObject worldObject,
double damage,
WeaponFinalCache weaponCache)
{
base.ServerOnObjectHitByExplosion(worldObject, damage, weaponCache);
if (worldObject is ICharacter character)
{
if (damage >= 5)
{
character.ServerAddStatusEffect <StatusEffectDazed>(intensity: 0.5);
}
}
else if (worldObject is IDynamicWorldObject dynamicWorldObject &&
dynamicWorldObject.ProtoGameObject is IProtoVehicle protoVehicle)
{
// apply additional vehicle damage
var vehicleDamage = damage * VehicleAdditionalDamageMultiplier;
protoVehicle.ServerApplyDamage(dynamicWorldObject, vehicleDamage);
}
}
public DisplayObject(IWorldObject parent, WorldEditor app, string name, string type, SceneManager scene, string meshName, Vector3 position, Vector3 scale, Vector3 rotation, SubMeshCollection subMeshCollection)
{
this.name = name;
this.scene = scene;
this.meshName = meshName;
this.type = type;
this.parent = parent;
oidCounter++;
this.oid = oidCounter;
this.app = app;
// if we were passed a subMeshCollection, then use it, otherwise make one.
if (subMeshCollection == null)
{
this.subMeshCollection = new SubMeshCollection(meshName);
}
else
{
this.subMeshCollection = subMeshCollection;
}
AddToScene(position, scale, rotation);
}
public WorldObjectContainer(IWorldObject containedObject)
{
InitializeComponent();
Shape shape = null;
if (containedObject.ObjectType == WorldObjectType.Ellipse)
{
shape = new Ellipse();
}
else if (containedObject.ObjectType == WorldObjectType.Square)
{
shape = new Rectangle();
}
if (shape != null)
{
shape.Width = containedObject.Size;
shape.Height = containedObject.Size;
ContainedObject = containedObject;
shape.Fill = containedObject.ObjectColor;
LayoutRoot.Children.Add(shape);
}
}
private void SetObjectWorldPosition(IWorldObject objectToPosition, XElement dataSource)
{
}
public static bool WithinRangeOfSelf(IWorldObject wo, int maxDistance)
{
if (wo == null)
{
throw new ArgumentNullException("wo");
}
return WithinRangeOfSelf(wo.Coordinates(), maxDistance);
}
/// <summary>
/// This function will return the distance in meters.
/// The manual distance units are in map compass units, while the distance units used in the UI are meters.
/// In AC there are 240 meters in a kilometer; thus if you set your attack range to 1 in the UI it
/// will showas 0.00416666666666667in the manual options (0.00416666666666667 being 1/240).
/// </summary>
/// <param name="destObj"></param>
/// <returns></returns>
/// <exception cref="ArgumentOutOfRangeException">CharacterFilder.Id or Object passed with an Id of 0</exception>
public static double GetDistanceFromSelf(IWorldObject destObj)
{
if (REPlugin.Instance.CharacterFilter.Id == 0)
throw new ArgumentOutOfRangeException("destObj", "CharacterFilter.Id of 0");
if (destObj.Id == 0)
throw new ArgumentOutOfRangeException("destObj", "Object passed with an Id of 0");
return REPlugin.Instance.WorldFilter.Distance(REPlugin.Instance.CharacterFilter.Id, destObj.Id) * 240;
}
