private void PutItem <T>(ObjectPool <T> pool) where T : MonoBehaviour
{
var item = pool.New();
StartCoroutine(UnityExtensions.FadeIn(item.GetComponent <SpriteRenderer>()));
item.transform.position = new Vector2(rand.Next(1, width - 1), rand.Next(1, height - 1));
}
void Update()
{
if (LaserTarget != null)
{
var targetRegion = UnityExtensions.CreateRectFromCamera(_camera, LaserTargetScreenPercentage);
if (targetRegion.Contains(LaserTarget.transform.position))
{
var direction = LaserTarget.transform.position - transform.position;
if (direction != Vector3.zero)
{
var offsetAngle = Mathf.Sin(Time.timeSinceLevelLoad) * LaserTargetMaxOffset;
var targetAngle = Mathf.Atan2(direction.y, direction.x) * Mathf.Rad2Deg;
var fixedTargetAngle = UnityExtensions.ClampAngle(targetAngle + TARGET_ANGLE_FIX);
var currentAngle = UnityExtensions.ClampAngle(transform.rotation.eulerAngles.z);
var angleDifference = UnityExtensions.ClampAngle(fixedTargetAngle - currentAngle + offsetAngle);
var finalAngle = currentAngle + angleDifference * Time.deltaTime * 5f * LaserTargetAimRate;
transform.rotation = Quaternion.Euler(0f, 0f, finalAngle);
}
}
}
}
public static IPumpkinTradeService GetPumpkinTradeService()
{
var dataSource = UnityExtensions.GetService <IRepository <PumpkinDeal> >() ??
PumpkinDealListRepository.Instance;
return(new PumpkinTradeService(dataSource));
}
private void OnTriggerEnter(Collider other)
{
if (!_engine.IsServer)
{
return;
}
var ue = other.gameObject.GetComponent <IUnityEntity>();
if (ue == null)
{
return;
}
var proxy = other.gameObject.GetComponent <IProxyPlayer>();
if (proxy != null)
{
_entities.Add(ue);
}
else if (ue == _puzzle.MyPlayer)
{
_entities.Add(ue);
}
var proxies = UnityExtensions.FindInterfaces <IProxyPlayer>();
if (_entities.Count == proxies.Count + 1)
{
SceneManager.LoadScene(SceneManager.GetActiveScene().buildIndex + 1);
}
}
IEnumerator Move()
{
while (this._isAlive)
{
yield return(Wait(0.5f));
if (!this._isAlive)
{
yield break;
}
if (Body.velocity.sqrMagnitude >= MinSqrMagnitudeToMove)
{
continue;
}
var preferedRegion = UnityExtensions.CreateRectFromCamera(_camera, PreferedScreenPercentage);
Vector2 moveDirection;
if (preferedRegion.Contains(transform.position))
{
moveDirection = Random.insideUnitCircle;
}
else
{
var targetPosition = RandomExtensions.PointInsideRect(preferedRegion);
moveDirection = targetPosition - new Vector2(transform.position.x, transform.position.y);
}
var impulse = Random.Range(MinImpulseForce, MaxImpulseForce);
this.Body.AddForce(moveDirection.normalized * impulse, ForceMode2D.Impulse);
}
}
private void GenerateLineRendererSegments()
{
if (startPoints.Length != endPoints.Length)
{
return;
}
foreach (var lr in GetComponentsInChildren <LineRenderer>())
{
lr.gameObject.Destroy();
}
_lineRenderer.Clear();
for (var index = 0; index < startPoints.Length; index++)
{
var lr = UnityExtensions.Instantiate(lineRendererPrefab, transform.position, Quaternion.identity, transform).GetComponent <LineRenderer>();
Vector3[] points = new Vector3[sections];
var startPoint = startPoints[index].position;
var endPoint = endPoints[index].position;
for (int i = 0; i < sections; i++)
{
points[i] = Vector3.Lerp(startPoint, endPoint, (float)i / sections);
}
lr.positionCount = sections;
lr.SetPositions(points);
_lineRenderer.Add(lr);
}
UpdateSimulation();
}
public void OnEntityAttack(EntityAttackPacket packet)
{
var attacker = UnityExtensions.GetEntity(packet.AttackerUID);
var defender = UnityExtensions.GetEntity(packet.DefenderUID);
var damage = packet.Damage;
attacker.PerformAttackAnimation(defender, damage);
}
static Matrix4x4 LookAtMatrix(Vector3 up_vector, Vector3 localPosition)
{
var z_axis = localPosition.normalized;
var x_axis = Vector3.Cross(up_vector, z_axis).normalized;
var y_axis = Vector3.Cross(z_axis, x_axis).normalized;
return(UnityExtensions.Matrix4x4FromColumns(x_axis, y_axis, z_axis, new Vector4(0, 0, 0, 1)));
}
public void OnEntityDeath(EntityDeathPacket packet)
{
var entity = UnityExtensions.GetEntity(packet.EntityUID);
if (!entity.Dead)
{
entity.WilLDie = true;
}
}
public static Matrix4x4 RotationToWorldAxis(this Matrix4x4 m)
{
return(UnityExtensions.Matrix4x4FromColumns(
m.MultiplyVector(Vector3.right),
m.MultiplyVector(Vector3.up),
m.MultiplyVector(Vector3.forward),
new Vector4(0, 0, 0, 1)
));
}
private void HandleDataChanged(
SliceUnitData <UnityWorldData> oldData,
ref SliceUnitData <UnityWorldData> newData,
GridItemPropertyChange changeType
)
{
// TODO should we do something?
if (changeType == GridItemPropertyChange.HealthChange)
{
newData.Data = oldData.Data;
return;
}
if (oldData.Data?.Structure != null)
{
UnityExtensions.Destroy(oldData.Data.Structure);
}
if (oldData.Data?.Tile != null)
{
UnityExtensions.Destroy(oldData.Data.Tile.gameObject);
}
var item = newData.GridItem;
var worldPosition = newData.Position.ToVector3();
var tileDescriptor = TileLookup.FindTileOrNull(item.TileType);
var tileBehavior = tileDescriptor.Construct(
new PositionAndRotation(worldPosition, PossibleRotations[(byte)item.TileRotation]),
WorldGrid,
newData.Position
);
GameObject placeableInstance = null;
if (item.StructureType != 0)
{
var associatedStructure = TileLookup.FindStructureOrNull(item.StructureType);
if (associatedStructure == null)
{
Debug.Log($"No object type of «{item.StructureType}» found while building world");
}
else
{
placeableInstance = associatedStructure.CreateInstanceInWorld(this, newData.Position);
}
}
newData.Data = new UnityWorldData
{
Tile = tileBehavior,
Structure = placeableInstance
};
}
public void Activate(string Id, Vector2 from, Vector2 to)
{
var model = Pool.New();
model.OwnerId = Id;
model.startPosition = from;
model.transform.position = from;
model.targetPosition = to;
// todo if weapon move no linear, moveUnit needless, example: stone model, bezier curve
model.moveUnit = UnityExtensions.CalculateDelta(from, to, Config.Speed);
}
private void OnEnterStrangerState(int previousStateId)
{
if (previousStateId == (int)Relationship.Inactive)
{
gameObject.SetActive(true);
// Give the NPC with random values so it behaves differently fromt other NPCs
nextDirectionChangeTime = GetNextDirectionChangeTime();
currentDirection = UnityExtensions.GetRandomUnitVector();
currentSpeed = Random.Range(minSpeed, maxSpeed);
}
}
private GameObject CreateWeaponTemplate()
{
var copy = WeaponTemplate.CreateInstance();
var weaponBehavior = copy.GetComponent <WeaponBehavior>();
MuzzleOffset = weaponBehavior.MuzzleOffset;
HeldPosition = weaponBehavior.HeldPosition;
UnityExtensions.Destroy(weaponBehavior);
copy.AddComponent <ProjectileWeaponBehavior>();
return(copy);
}
/// <summary>
/// Handle bullet collision with other entities
/// </summary>
/// <param name="collider">Colliding game object</param>
private void OnCollision(GameObject collider)
{
// Only detect collisions on appropriate layers
if (!UnityExtensions.LayerContains(CollisionMask, collider.layer))
{
return;
}
// Apply damage to collider if appropriate
Damageable damageableObject = collider.GetComponent <Damageable>();
if (damageableObject != null)
{
damageableObject.TakeDamage(Data.Damage, gameObject);
}
// TODO: Does this logic belong in Damageable component?
// Enemies react differently to being hit
Enemy enemy = collider.GetComponent <Enemy>();
if (enemy == null)
{
if (Data.HitEffect != null)
{
// Use collider material for hit effect
Material collidingMaterial = collider.GetComponent <Renderer>().material;
Data.HitEffect.GetComponent <Renderer>().material = collidingMaterial;
Instantiate(Data.HitEffect, transform.position, Quaternion.identity, TemporaryManager.Instance.TemporaryChildren);
}
// QUESTION: Should audio be moved to hit object (in "Hit-able" component)?
AudioManager.Instance.PlayEffect(Data.HitSound, transform.position);
}
else
{
if (enemy.Damageable.DamageEffect != null)
{
// Use collider material for hit effect
Material collidingMaterial = collider.GetComponent <Renderer>().material;
enemy.Damageable.DamageEffect.GetComponent <Renderer>().material = collidingMaterial;
Instantiate(enemy.Damageable.DamageEffect, transform.position, Quaternion.identity, TemporaryManager.Instance.TemporaryChildren);
}
AudioManager.Instance.PlayEffect(enemy.Damageable.DamageSound, transform.position);
}
Destroy(gameObject);
}
private void Show()
{
var t = UnityExtensions.FindInterfaces <IProxyPlayer>().FirstOrDefault();
if (t == null)
{
return;
}
_currentCam = t.Camera;
_currentCam.enabled = true;
_currentCam.targetTexture = _texture;
_transform.gameObject.SetActive(true);
_showing = true;
}
private void OnTriggerExit(Collider other)
{
if (!UnityExtensions.Contains(this._waterLayer, ((Component)other).get_gameObject().get_layer()))
{
return;
}
Rigidbody component = (Rigidbody)((Component)other).GetComponent <Rigidbody>();
if (Object.op_Equality((Object)component, (Object)null) || !this._rigidbodies.Contains(component))
{
return;
}
this._rigidbodies.Remove(component);
}
public void SetValue(float value, float max, bool isWalkable)
{
_value = value;
_isWalkable = isWalkable;
if (isWalkable)
{
_valueText.text = GetLabelText(value);
_mesh.material.color = UnityExtensions.MakeHeatColor(0, max, value, true);
}
else
{
_valueText.text = "#";
_mesh.material.color = new Color(1, 1, 1);
}
}
private void OnCollisionEnter2D(Collision2D collision)
{
// TODO make it so that projectiles from our team don't damage ourselves
var receiver = collision.gameObject.GetComponent <IDamageReceiver>();
if (receiver != null)
{
int damageDone = DamageProcessor.ApplyDamage(receiver, _weaponDescriptorTemplate.DamagePerShot);
var stat = _owner.Statistics.TryGetStatistic(KnownStats.DamageDone);
Debug.Log(stat);
stat?.Increment(damageDone);
}
UnityExtensions.Destroy(gameObject);
}
public static void BuildAndInstantiate(MonsterFactoryOpts opts)
{
var monsterObj = GameObject.Find(opts.Packet.MonsterUid);
if (monsterObj == null)
{
monsterObj = new GameObject(opts.Packet.MonsterUid);
monsterObj.transform.localScale = new Vector3(100, 100);
var spriteObj = new GameObject("Sprites_" + opts.Packet.MonsterUid);
spriteObj.transform.localScale = new Vector3(100, 100);
var spriteRenderer = spriteObj.AddComponent <SpriteRenderer>();
var spriteSheet = spriteObj.AddComponent <SpriteSheet>();
spriteRenderer.sortingOrder = 2;
var bodySprite = AssetHandler.LoadedAssets[DefaultAssets.SPR_MONTERS_1];
var spriteRow = bodySprite.SliceRow(opts.Packet.SpriteIndex).ToArray();
spriteSheet.SetSheet(spriteRow, rowSize: 2);
spriteRenderer.sprite = spriteSheet.WalkSouth[1];
spriteObj.transform.parent = monsterObj.transform;
// Moving Entity
var livingEntityBhv = monsterObj.AddComponent <LivingEntityBehaviour>();
livingEntityBhv.SpriteSheets.Add(spriteSheet);
var monsterEntityWrapper = new MonsterWrapper()
{
MonsterObj = monsterObj,
EntityType = EntityType.MONSTER,
MoveSpeed = opts.Packet.MoveSpeed,
UID = opts.Packet.MonsterUid,
Position = opts.Position,
Atk = opts.Packet.Atk,
Def = opts.Packet.Def,
HP = opts.Packet.HP,
MAXHP = opts.Packet.MAXHP
};
monsterObj.transform.parent = UnityExtensions.GetEntitiesContainer().transform;
livingEntityBhv.Entity = monsterEntityWrapper;
monsterObj.transform.position = opts.Position.ToUnityPosition();
UnityClient.Map.UpdateEntityPosition(monsterEntityWrapper, null, opts.Position);
FactoryMethods.AddCollider(monsterObj);
FactoryMethods.AddHealthBar(monsterObj);
}
}
/// <summary />
protected void LateUpdate()
{
if (_damagable == null)
return;
if (_owner.IsDestroyed())
{
_damagable = null;
_owner = null;
UnityExtensions.Destroy(gameObject);
return;
}
_healthImage.fillAmount = _damagable.Health / 100.0f;
_rectTransform.anchoredPosition = CalculateScreenPosition(_owner.transform.position + _positionOffset);
}
public List <Node> GetNeighbors(Node node)
{
List <Node> neighbors = new List <Node>();
UnityExtensions.MapNeighborIndexes(node.x, node.y, _map.GetLength(0), _map.GetLength(1), (x, y) =>
{
var ox = x - node.x;
var oy = y - node.y;
var isDiagonal = ox != 0 && oy != 0;
var isDiagonallyWalkable = !isDiagonal || (_map[x, y - oy].isWalkable || _map[x - ox, y].isWalkable);
if (_map[x, y].isWalkable && isDiagonallyWalkable)
{
neighbors.Add(_map[x, y]);
}
});
return(neighbors);
}
public void Initialize(Transform transform, Transform camTransform)
{
_transform = transform;
_camTransform = camTransform;
_engine = UnityExtensions.FindInterface <IEngineFacade>();
if (_engine == null)
{
throw new System.Exception("TODO: The network engine could not be found");
}
var e = _transform.GetComponent <IUnityEntity>();
if (e == null)
{
throw new System.Exception("TODO: No network entity was found on this object");
}
_entityId = e.Id;
}
void SetOff()
{
if (Scale)
{
transform.SetXYScale(OFF_SCALE, OFF_SCALE);
}
if (Icon)
{
Icon.color = UnityExtensions.SetAlpha(Icon.color, OFF_ALPHA);
}
if (BaseFades)
{
Toggle.targetGraphic.color = UnityExtensions.SetAlpha(Toggle.targetGraphic.color, OFF_ALPHA);
}
}
/// <summary>
/// This method will find a single Visual Editor Behaviour or IDialogueUIController
/// just for tapping in the OnApplicationQuit event.
/// If the selected component is deactivating the system will find a new one.
/// </summary>
static void FindBehaviour()
{
var b = GameObject.FindObjectOfType <VisualEditorBehaviour>();
if (b != null)
{
b.onApplicationQuit = OnApplicationQuit;
b.onInactivated = FindBehaviour;
return;
}
var c = UnityExtensions.FindObjectOfInterface <IDialogueUIController>();
if (c != null)
{
c.onApplicationQuit = OnApplicationQuit;
c.onInactivated = FindBehaviour;
return;
}
}
public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
{
position.width -= (BUTTON_WIDTH + 2) * 2;
EditorGUI.PropertyField(position, property, label, true);
position.x = position.xMax + 2;
position.width = BUTTON_WIDTH;
if (GUI.Button(position, "C"))
{
GUIUtility.systemCopyBuffer = property.animationCurveValue.AnimationCurveToJson();
}
position.x = position.xMax + 2;
if (GUI.Button(position, "P"))
{
var curve = UnityExtensions.AnimationCurveFromJson(GUIUtility.systemCopyBuffer);
if (curve == null)
{
return;
}
Undo.RecordObject(property.serializedObject.targetObject, "PasteCurve");
property.animationCurveValue = curve;
}
}
public void Initialization(int i, Vector2 position, Action <StoneSplash> disable)
{
Disable = disable;
transform.position = position;
if (i == 0)
{
target = position + 0.5f * Vector2.right;
}
if (i == 1)
{
target = position - 0.5f * Vector2.right;
}
if (i == 2)
{
target = position + 0.5f * Vector2.up;
}
if (i == 3)
{
target = position - 0.5f * Vector2.up;
}
afterInit = true;
delta = UnityExtensions.CalculateDelta(transform.position, target, speed);
}
// All physics calculations should always be done in FixedUpdate
private void FixedUpdate()
{
if (Time.time > pauseMovementEndTime)
{
// Resume movement
if (rb.isKinematic)
{
rb.isKinematic = false;
rb.velocity = savedVelocity;
}
// Get the new direction
if (Time.time > nextDirectionChangeTime)
{
currentSpeed = Random.Range(minSpeed, maxSpeed);
currentDirection = UnityExtensions.GetRandomUnitVector();
nextDirectionChangeTime = GetNextDirectionChangeTime();
}
// Call each of the state's FixedUpdates
stateMachine.FixedUpdate();
// Clamp the velocity
if (rb.velocity.sqrMagnitude > maxSpeed * maxSpeed)
{
rb.velocity = Vector2.ClampMagnitude(rb.velocity, maxSpeed);
}
}
else
{
// Pause movement
savedVelocity = rb.velocity;
rb.velocity = Vector2.zero;
rb.isKinematic = true;
}
}
static Matrix4x4 LookAtMatrixFromWorld(Vector3 from, Vector3 target)
{
var pos = new Vector4(from.x, from.y, from.z, 1);
return(LookAtMatrix(UnityExtensions.Matrix4x4FromColumns(Vector3.right, Vector3.up, Vector3.forward, pos), target));
}
public float GetEdgeCost(Node a, Node b)
{
return(UnityExtensions.Distance(a.x, a.y, b.x, b.y) * b.cost);
//return UnityExtensions.ManhattanDistance(a.x, a.y, b.x, b.y);
}
