private void OnTriggerExit2D(Collider2D collision)
{
if (_lastSpawnedInstance != null && collision.GetComponent <ElementInstance>() == _lastSpawnedInstance)
{
_lastSpawnedInstance = null;
}
}
public JsonResult EditElement(int gameId, int elementId, FormCollection elementData)
{
lock (Game)
{
try
{
Player player = Platform.GetCurrentPlayer(Game);
ElementInstance element = Game.GetElement(elementId);
if (element.PlayerId != player.Id && !player.IsModerator())
{
throw new Error.AccessDenied();
}
foreach (var key in elementData.AllKeys)
{
if (element.Definition.HasAttribute(key))
{
element.Definition.GetAttribute(key).Validate(elementData.Get(key));
element.SetAttributeValue(key, elementData.Get(key));
}
}
Game.Definition.OnEditElement(Game, element);
return(Json(Result.Succes));
}
catch (Error.AppError ex)
{
return(Json(new Result(ex.Message).AsFailure()));
}
}
}
private string TypeNameForDirectShapeType(ElementInstance instance)
{
var nameParts = new List <string>();
if (instance.BaseDefinition.AdditionalProperties.TryGetValue("discriminator", out var discriminator))
{
nameParts.Add(discriminator as string);
}
if (!string.IsNullOrWhiteSpace(instance.BaseDefinition.Name))
{
nameParts.Add(instance.BaseDefinition.Name);
}
var typeName = String.Join(" - ", nameParts);
if (typeNameNumber.TryGetValue(typeName, out var number))
{
typeNameNumber[typeName] = number + 1;
return(typeName + $" ({number++})"); //increment the number to be applied if a type name already exists with this name.
}
else
{
typeNameNumber[typeName] = 0;
return(typeName);
}
}
public StoryboardLayer(RenderTarget renderTarget, IReadOnlyList <Element> elements, Timing timing) : base(renderTarget)
{
if (elements == null)
{
return;
}
_vSize = new Size2F(renderTarget.Size.Width / 854f, renderTarget.Size.Height / 480f);
RenderThings[] instants = new RenderThings[elements.Count];
for (int i = 0; i < instants.Length; i++)
{
instants[i] = new RenderThings
{
Index = i,
Elment = elements[i],
Events = elements[i].EventList
}
}
;
_timing = timing ?? new Timing(0, new Stopwatch());
_instances = new ElementInstance[instants.Length];
for (var i = 0; i < instants.Length; i++)
{
var item = instants[i];
_instances[i] = new ElementInstance(RenderTarget, item.Elment, _vSize, _timing);
}
LoadFirstFrame(instants);
_timing.Watch.Start();
}
public void SubscribeActiveInstance(ElementInstance element)
{
if (_interactibleData.Contains(element.Data))
{
_activeInstances.Add(element);
}
}
public JsonResult AddElement(int gameId, int elementDefinitionId, FormCollection elementData)
{
lock (Game)
{
try
{
ElementInstance element = new ElementInstance(Game.Definition.GetElementDefinition(elementDefinitionId));
element.PlayerId = Platform.GameAuthentication.GetPlayerId(gameId);
foreach (var key in elementData.AllKeys)
{
if (element.Definition.HasAttribute(key))
{
element.SetAttributeValue(key, elementData.Get(key));
}
}
if (element.Definition.CanAdd(Platform.GetCurrentPlayer(Game)))
{
int id = Game.AddElement(element);
return(Json(new Result(new { elementId = id }).AsSuccess()));
}
else
{
throw new Error.AccessDenied();
}
}
catch (Error.AppError ex)
{
return(Json(new Result(ex.Message).AsFailure()));
}
}
}
public void AddTokensToElement(TokenDefinition token, ElementInstance element, int amount)
{
if (amount >= 0 && amount <= GetTokenAmount(token))
{
element.AddTokens(token, Id, amount);
AddTokens(token, Id, -amount);
}
}
public override void Interact(ElementInstance element)
{
if (element.dragging)
{
return;
}
element.transform.position += transform.up * pushPower * Time.deltaTime;
}
public override void Interact(ElementInstance element)
{
if (!absorbedElements.Contains(element))
{
element.Lock();
absorbedElements.Add(element);
}
}
void SpawnElement()
{
if (element != null)
{
_lastSpawnedInstance = Instantiate(Director.GetManager <CombinationManager>().emptyElementPrefab, transform.position, Quaternion.identity, elementContainer);
_lastSpawnedInstance.Data = element;
}
_currentSpawnTime = 0;
}
public JsonResult GetPlayerTokensAmount(int gameId, int tokenDefinitionId, int elementId)
{
ElementInstance element = Game.GetElement(elementId);
TokenDefinition token = Game.Definition.GetTokenDefinition(tokenDefinitionId);
int amount = element.GetTokenAmount(token, Platform.GetCurrentPlayer(Game).Id);
return(Json(new Result(new { tokensAmount = amount }).AsSuccess()));
}
public void CancelInteraction(ElementInstance a, ElementInstance b)
{
int hash = a.GetHashCode() + b.GetHashCode();
if (_activeInteractions.ContainsKey(hash))
{
_activeInteractions[hash].Kill();
}
}
public JsonResult SetTokens(int gameId, int tokenDefinitionId, int elementId, int amount)
{
lock (Game)
{
ElementInstance element = Game.GetElement(elementId);
TokenDefinition token = Game.Definition.GetTokenDefinition(tokenDefinitionId);
Game.SetTokens(Platform.GetCurrentPlayer(Game), token, element, amount);
return(Json(Result.Succes));
}
}
private void CheckElement(ElementInstance element)
{
if (element.GetAttributeValue("Status") == "Pożądany")
{
element.Color = element.Definition.Colors[1];
}
else
{
element.Color = element.Definition.Colors[0];
}
}
private static List <Element> CreateFramingPlanInstance(List <Beam> framing, double elevation)
{
var instanceBeams = new List <Element>();
foreach (var beam in framing)
{
var halfDepth = _halfDepths[_beamProfiles.IndexOf(beam.Profile)];
var beamInstance = new ElementInstance(beam, new Transform(new Vector3(0, 0, elevation - halfDepth)));
instanceBeams.Add(beamInstance);
}
return(instanceBeams);
}
public void OnTriggerStay2D(Collider2D other)
{
ElementInstance element = other.GetComponent <ElementInstance>();
if (element != null)
{
if (element != a && element != b)
{
Interact(element);
}
}
}
private void CheckElement(ElementInstance element)
{
if (element.GetTokenAmount(GetTokenDefinition(0)) >= int.Parse(element.GetAttributeValue("Cena")))
{
element.Color = element.Definition.Colors[1];
element.SetAttributeValue("Czy kupiony?", "Tak");
}
else
{
element.Color = element.Definition.Colors[0];
element.SetAttributeValue("Czy kupiony?", "Nie");
}
}
protected override void Reposition()
{
if (a.Data == airData)
{
_airInstance = a;
_powerInstance = b;
}
else
{
_airInstance = b;
_powerInstance = a;
}
transform.position = _airInstance.transform.position;
}
public void SetTokensToElement(TokenDefinition token, ElementInstance element, int amount)
{
if (amount < 0)
{
return;
}
int currentAmount = element.GetTokenAmount(token, Id);
int diff = amount - currentAmount;
if (diff <= GetTokenAmount(token))
{
element.AddTokens(token, Id, diff);
AddTokens(token, Id, -diff);
}
}
public override void Interact(ElementInstance element)
{
if (element != null)
{
foreach (var transformation in recipes)
{
if (transformation.input == element.Data)
{
element.Data = transformation.output;
Director.GetManager <AchievementManager>().AddCount(element.Data.creationAchievement);
break;
}
}
}
}
private void OnCollisionEnter2D(Collision2D collision)
{
if (collision.collider.isTrigger)
{
return;
}
ElementInstance element = collision.gameObject.GetComponent <ElementInstance>();
if (element != null && !element.locked && Director.GetManager <CombinationManager>().CombinationExists(this, element))
{
Lock();
Destroy(this.gameObject);
Destroy(element.gameObject);
}
}
public Interaction GetInteraction(ElementInstance a, ElementInstance b)
{
if (a == null || b == null)
{
return(null);
}
int hash = a.GetHashCode() + b.GetHashCode();
if (_activeInteractions.ContainsKey(hash))
{
return(_activeInteractions[hash]);
}
InteractionData validInteraction = null;
foreach (var interaction in availableInteractions)
{
if (interaction.IsFulfilledBy(a.Data, b.Data))
{
if (Vector3.Distance(a.transform.position, b.transform.position) < interaction.distance)
{
validInteraction = interaction;
}
else
{
CancelInteraction(a, b);
}
}
}
if (validInteraction != null)
{
Interaction newInteraction = Instantiate(validInteraction.interactionPrefab);
newInteraction.Birth(a, b);
newInteraction.OnKill += () => { _activeInteractions.Remove(hash); };
newInteraction.transform.position = (a.transform.position + b.transform.position) / 2;
_activeInteractions[hash] = newInteraction;
return(newInteraction);
}
return(null);
}
public bool CombinationExists(ElementInstance a, ElementInstance b)
{
ElementData validResult = null;
foreach (ElementData element in elements)
{
if (element.IsFulfilledBy(a.Data, b.Data))
{
validResult = element;
break;
}
}
if (validResult != null)
{
ElementInstance element = Instantiate(emptyElementPrefab, (a.transform.position + b.transform.position) / 2, Quaternion.identity, a.transform.parent);
element.Data = validResult;
Director.GetManager <AchievementManager>().AddCount(validResult.creationAchievement);
Director.GetManager <AchievementManager>().AddCount(combinationsAchievement);
}
return(validResult != null);
}
private DB.ElementId[] DirectShapeInstance(LoadContext context, DB.ElementId categoryId, ElementInstance instance)
{
var discriminator = "ElementInstance";
if (instance.BaseDefinition.AdditionalProperties.TryGetValue("discriminator", out var discriminatorValue) && discriminatorValue != null)
{
discriminator += $" of {discriminatorValue as string}";
}
if (!GeometryLoaderConfig.ShouldDirectShapeObject(instance.BaseDefinition))
{
return(Array.Empty <DB.ElementId>());
}
else
{
var defTypeId = DB.DirectShapeLibrary.GetDirectShapeLibrary(context.Document).FindDefinitionType(instance.BaseDefinition.Id.ToString());
// If a user uses "Undo" after we've created some direct shape objects the DirectShapeLibrary
// does not refresh and know that this element has been removed. This will look like it's going
// to work all the way until we go to regenerate the document, when a DocumentCorruption error
// will be posted resulting in the entire Load operation (all converters) to be rolled back.
var foundType = context.Document.GetElement(defTypeId);
if (defTypeId == DB.ElementId.InvalidElementId || foundType == null)
{
string typeName = TypeNameForDirectShapeType(instance);
var defType = DB.DirectShapeType.Create(context.Document, typeName, categoryId);
var shapeBuilder = instance.BaseDefinition.GetShapeBuilder(context.Document);
if (shapeBuilder != null)
{
defType.AppendShape(shapeBuilder);
}
else
{
return(Array.Empty <DB.ElementId>());
}
defTypeId = defType.Id;
DB.DirectShapeLibrary.GetDirectShapeLibrary(context.Document).AddDefinitionType(instance.BaseDefinition.Id.ToString(), defTypeId);
}
var completeTransform = new Transform();
if (instance.BaseDefinition.Transform != null)
{
completeTransform.Concatenate(instance.BaseDefinition.Transform);
completeTransform.Invert();
}
if (instance.Transform != null)
{
completeTransform.Concatenate(instance.Transform);
}
var directShape = DB.DirectShape.CreateElementInstance(context.Document,
defTypeId,
categoryId,
instance.BaseDefinition.Id.ToString(),
completeTransform.ToRevitTransform(true));
if (directShape == null)
{
return(Array.Empty <DB.ElementId>());
}
directShape.LookupParameter("Comments")?.Set(discriminator);
directShape.LookupParameter("Mark")?.Set(instance.Id.ToString());
return(new[] { directShape.Id });
}
}
override public void OnAddElement(GameInstance game, ElementInstance element)
{
CheckElement(element);
}
private void CheckElement(ElementInstance element)
{
}
override public void OnSetToken(GameInstance game, Player player, ElementInstance element, TokenDefinition token, int amount)
{
CheckElement(element);
}
virtual public void OnSetToken(GameInstance game, Player player, ElementInstance element, TokenDefinition token, int amount)
{
}
public ActionResult ElementListItem(int gameId, int elementId)
{
ElementInstance elements = Game.GetElement(elementId);
return(View("Partials/ElementListItem", elements));
}
virtual public void OnEditElement(GameInstance game, ElementInstance element)
{
}
