public TriggerSchema (TriggerSchema trigger)
: base (trigger)
{
tableName = trigger.tableName;
triggerType = trigger.triggerType;
triggerFireType = trigger.triggerFireType;
triggerEvent = trigger.triggerEvent;
position = trigger.position;
isActive = trigger.isActive;
source = trigger.source;
}
public override void Trigger(TriggerEvent triggerEvent)
{
switch (triggerEvent) {
case TriggerEvent.StartHover:
((SbModel)model).StartHover ();
break;
case TriggerEvent.StopHover:
((SbModel)model).StopHover ();
break;
case TriggerEvent.OnLeftClick:
((SbModel)model).OnLeftClick ();
break;
default:
break;
}
}
/**
* TODO
*/
public virtual void Trigger(TriggerEvent triggerEvent)
{
switch (triggerEvent) {
case TriggerEvent.StartHover:
model.StartHover ();
break;
case TriggerEvent.StopHover:
model.StopHover ();
break;
case TriggerEvent.OnLeftClick:
model.OnLeftClick ();
break;
case TriggerEvent.OnRightClick:
model.OnRightClick ();
break;
default:
break;
}
}
public override bool Effect(TriggerEvent triggerEvent, Room room, Player player, ref object data, Player ask_who, TriggerStruct info)
{
return(OnPhaseChange(room, player, info));
}
virtual public TriggerStruct Cost(TriggerEvent triggerEvent, Room room, Player player, ref object data, Player ask_who, TriggerStruct info)
{
return(info);
}
public void HandleEvent(string previous, int pivot, TriggerEvent _event)
{
if (!contextMap.ContainsKey(previous))
contextMap[previous] = new Dictionary<int, TriggerEvent>();
contextMap[previous][pivot] = _event;
}
/// <summary>
/// Automatically executes an action when a triggering event occurs.
/// </summary>
/// <param name="triggerEvent">The triggering event.</param>
/// <param name="triggerAction">The action to execute when triggered.</param>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="triggerAction"/> is null.</exception>
public void AutoExecute(TriggerEvent triggerEvent, Action triggerAction)
{
AutoExecute(triggerEvent, triggerAction, null);
}
/// <summary>
/// Automatically embeds a screenshot when a trigger event occurs.
/// </summary>
/// <remarks>
/// <para>
/// If screenshots cannot be captured, the method will embed a warning message to that effect.
/// </para>
/// </remarks>
/// <param name="triggerEvent">The trigger event.</param>
/// <param name="attachmentName">The name to give to the image attachment, or null to assign one automatically.</param>
/// <param name="parameters">The capture parameters.</param>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="parameters"/> is null.</exception>
/// <seealso cref="TestContext.AutoExecute(TriggerEvent, Action)"/>
public static void AutoEmbedScreenshot(TriggerEvent triggerEvent, string attachmentName, CaptureParameters parameters)
{
if (parameters == null)
throw new ArgumentNullException("parameters");
TestContext context = TestContext.CurrentContext;
if (context != null)
{
context.AutoExecute(triggerEvent, () =>
{
try
{
Bitmap bitmap = Screenshot(parameters);
context.LogWriter.Default.EmbedImage(attachmentName, bitmap);
}
catch (ScreenshotNotAvailableException ex)
{
context.LogWriter.Default.WriteException(ex, "Screenshot not available.");
}
});
}
}
public void unregister(TriggerEvent aEnter, TriggerEvent aStay, TriggerEvent aExit)
{
m_Enter -= aEnter;
m_Stay -= aStay;
m_Exit -= aExit;
}
public void Execute(TriggerEvent triggerEvent)
{
var txAutotrophConsts = environmentSettings[0].txAutotrophConsts;
var eA = triggerEvent.Entities.EntityA;
var eB = triggerEvent.Entities.EntityB;
Entity e;
Entity eOther;
if (txAutotrophPhenotype.Exists(eA))
{
var swap = translations[eA].Value.y + txAutotrophPhenotype[eA].height > translations[eB].Value.y
+ txAutotrophPhenotype[eB].height;
if (swap)
{
e = eB;
eOther = eA;
}
else
{
e = eA;
eOther = eB;
}
var l0 = math.max(txAutotrophConsts.minShadeRadius,
txAutotrophPhenotype[e].leaf) * txAutotrophConsts.leafShadeRadiusMultiplier;
var l1 = math.max(txAutotrophConsts.minShadeRadius,
txAutotrophPhenotype[eOther].leaf) * txAutotrophConsts.leafShadeRadiusMultiplier;
var dSqr = math.distancesq(translations[e].Value, translations[eOther].Value);
var r0 = math.max(l0, l1);
var r1 = math.min(l0, l1);
var rSub = r0 - r1;
var minD = rSub * rSub;
var num = dSqr - minD;
if (!shadeDict.ContainsKey(e))
{
if (num <= 0)
{
shadeDict[e] = r1;
}
else
{
var rAdd = r0 + r1;
var maxD = rAdd * rAdd - minD;
shadeDict[e] = (1 - ((maxD - num) / maxD)) * r1;
}
}
else
{
if (num <= 0)
{
shadeDict[e] += r1;
}
else
{
var rAdd = r0 + r1;
var maxD = rAdd * rAdd - minD;
shadeDict[e] += (1 - ((maxD - num) / maxD)) * r1;
}
}
}
}
public void Execute(TriggerEvent triggerEvent) => TriggerEvents.Add(new StatefulTriggerEvent(triggerEvent));
public void Execute(TriggerEvent triggerEvent)
{
TriggerEvents.Add(new StatefulTriggerEvent(
triggerEvent.EntityA, triggerEvent.EntityB, triggerEvent.BodyIndexA, triggerEvent.BodyIndexB,
triggerEvent.ColliderKeyA, triggerEvent.ColliderKeyB));
}
public void Parse(GameBitBuffer buffer)
{
Field0 = buffer.ReadInt(32);
Field1 = new TriggerEvent();
Field1.Parse(buffer);
}
public void HandleEvent(string previous, TriggerEvent _event)
{
if (!contextMap.ContainsKey(previous))
contextMap[previous] = new Dictionary<int, TriggerEvent>();
contextMap[previous][EventHelper.NO_PIVOT] = _event;
}
public override int GetHashCode()
{
return(MessageType.GetHashCode() + TriggerEvent.GetHashCode() + ProcessingId.GetHashCode() + Version.GetHashCode());
}
public EventTrigger(Action function, TriggerEvent @event)
{
Function = function;
Event = @event;
}
public virtual void OnEvent(TrustedAI ai, TriggerEvent triggerEvent, Player player, object data)
{
}
public Trigger(TriggerEvent triggerEvent, TriggerTime triggerTime)
{
TriggerTime = triggerTime;
TriggerEvent = triggerEvent;
}
public void Execute(TriggerEvent triggerEvent)
{
TestEntityTrigger(triggerEvent.Entities.EntityA, triggerEvent.Entities.EntityB);
TestEntityTrigger(triggerEvent.Entities.EntityB, triggerEvent.Entities.EntityA);
}
void Invoke()
{
TriggerEvent?.Invoke(this, new TriggerEventArgs(triggersCache ?? (triggersCache = triggers.Select(t => t.Convert()).ToArray())));
}
public override void Event(TriggerEvent triggerEvent, Player player, object data)
{
if (!self.Alive)
{
return;
}
base.Event(triggerEvent, player, data);
if (triggerEvent == TriggerEvent.EventPhaseStart || triggerEvent == TriggerEvent.BuryVictim)
{
UpdatePlayers();
}
if (triggerEvent == TriggerEvent.CardsMoveOneTime && data is CardsMoveOneTimeStruct move)
{
bool open = false;
bool pile_open = false;
Player from = move.From;
Player to = move.To;
foreach (Player p in room.GetAlivePlayers())
{
if (p.HasFlag("Global_GongxinOperator") && (p == self || self.IsSameCamp(p)))
{
open = true;
break;
}
}
if ((from != null && (from == self || self.IsSameCamp(from))) || (to != null && (to == self || self.IsSameCamp(to)) && move.To_place != Player.Place.PlaceSpecial))
{
open = true;
}
if (!open && to != null && !string.IsNullOrEmpty(move.To_pile_name) && !move.To_pile_name.StartsWith("#") && move.To != null)
{
if (move.To.GetPileOpener(move.To_pile_name).Count == room.GetAllPlayers(true).Count)
{
pile_open = true;
}
else
{
foreach (string name in move.To.GetPileOpener(move.To_pile_name))
{
Player who = room.FindPlayer(name, true);
if (who != null && (who == self || self.IsSameCamp(who)))
{
open = true;
break;
}
}
}
}
if (to != null && move.To_place == Player.Place.PlaceHand)
{
foreach (int id in move.Card_ids)
{
int index = move.Card_ids.IndexOf(id);
WrappedCard card = room.GetCard(id);
if (card.HasFlag("visible") || pile_open ||
move.From_places[index] == Player.Place.PlaceEquip || move.From_places[index] == Player.Place.PlaceDelayedTrick ||
move.From_places[index] == Player.Place.DiscardPile || move.From_places[index] == Player.Place.PlaceTable)
{
public_handcards[to].Add(id);
private_handcards[to].Add(id);
ClearCardLack(to, id);
}
else if (open)
{
private_handcards[to].Add(id);
ClearCardLack(to, id);
}
else
{
ClearCardLack(to);
}
}
}
if (to != null && move.To_place == Player.Place.PlaceSpecial && move.To_pile_name == "wooden_ox")
{
foreach (int id in move.Card_ids)
{
if (open)
{
wooden_cards[to].Add(id);
}
}
}
if (from != null && move.From_places.Contains(Player.Place.PlaceHand))
{
foreach (int id in move.Card_ids)
{
if (room.GetCard(id).HasFlag("visible") || pile_open || move.To_place == Player.Place.PlaceEquip ||
move.To_place == Player.Place.PlaceDelayedTrick || move.To_place == Player.Place.DiscardPile ||
move.To_place == Player.Place.PlaceTable)
{
public_handcards[from].RemoveAll(t => t == id);
private_handcards[from].RemoveAll(t => t == id);
}
else
{
public_handcards[from].Clear();
if (open)
{
private_handcards[from].RemoveAll(t => t == id);
}
else
{
private_handcards[from].Clear();
}
}
}
}
if (from != null && move.From_places.Contains(Player.Place.PlaceSpecial) && move.From_pile_names.Contains("wooden_ox"))
{
foreach (int id in move.Card_ids)
{
int index = move.Card_ids.IndexOf(id);
if (open && move.From_pile_names[index] == "wooden_ox" && move.From_places[index] == Player.Place.PlaceSpecial)
{
wooden_cards[move.From].RemoveAll(t => t == id);
}
}
}
foreach (int id in move.Card_ids)
{
int index = move.Card_ids.IndexOf(id);
WrappedCard card = room.GetCard(id);
if (move.From_places[index] == Player.Place.DrawPile)
{
if (move.To != null && move.To_place == Player.Place.PlaceHand && card.HasFlag("visible2" + self.Name))
{
private_handcards[move.To].Add(id);
}
if (guanxing.Key != null && guanxing.Value.Contains(id))
{
if (guanxing.Value[0] != id)
{
List <int> top_cards = new List <int>(guanxing.Value);
for (int y = top_cards.IndexOf(id); y < top_cards.Count; y++)
{
guanxing.Value.RemoveAt(y);
}
}
else
{
guanxing.Value.RemoveAll(t => t == id);
}
if (guanxing.Value.Count == 0)
{
guanxing = new KeyValuePair <Player, List <int> >();
}
}
}
}
}
if (triggerEvent == TriggerEvent.CardTargetAnnounced && data is CardUseStruct use)
{
FunctionCard fcard = Engine.GetFunctionCard(use.Card.Name);
string class_name = fcard.Name;
if (fcard is Slash)
{
class_name = Slash.ClassName;
}
UseCard e = Engine.GetCardUsage(class_name);
if (e != null)
{
e.OnEvent(this, triggerEvent, player, data);
}
}
if (triggerEvent == TriggerEvent.ChoiceMade && data is string str)
{
List <string> choices = new List <string>(str.Split(':'));
foreach (SkillEvent e in skill_events.Values)
{
if (e.Key.Contains(choices[0]))
{
e.OnEvent(this, triggerEvent, player, data);
}
}
foreach (UseCard e in Engine.GetCardUsages())
{
if (e.Key.Contains(choices[0]))
{
e.OnEvent(this, triggerEvent, player, data);
}
}
if (choices[0] == "viewCards")
{
List <int> ids = player.GetCards("h");
if (choices[choices.Count - 1] == "all")
{
public_handcards[player] = ids;
private_handcards[player] = ids;
}
else if (choices[choices.Count - 1] == self.Name)
{
private_handcards[player] = ids;
}
}
else if (choices[0] == "showCards")
{
List <int> ids = JsonUntity.StringList2IntList(new List <string>(choices[2].Split('+')));
if (choices[choices.Count - 1] == "all")
{
foreach (int id in ids)
{
if (!public_handcards[player].Contains(id))
{
public_handcards[player].Add(id);
}
if (!private_handcards[player].Contains(id))
{
private_handcards[player].Add(id);
}
}
}
else if (choices[choices.Count - 1] == self.Name)
{
foreach (int id in ids)
{
if (!private_handcards[player].Contains(id))
{
private_handcards[player].Add(id);
}
}
}
}
else if (choices[0] == "cardShow")
{
int id = int.Parse(choices[choices.Count - 1].Substring(1, choices[choices.Count - 1].Length - 2));
if (!public_handcards[player].Contains(id))
{
public_handcards[player].Add(id);
}
if (!private_handcards[player].Contains(id))
{
private_handcards[player].Add(id);
}
}
else if (choices[0] == "ViewTopCards" || choices[0] == "ViewBottomCards")
{
bool open = choices[choices.Count - 1] == "open";
List <int> drawpile = new List <int>(room.DrawPile);
List <int> moves = JsonUntity.StringList2IntList(new List <string>(choices[2].Split('+')));
if (choices[0] == "ViewTopCards")
{
guanxing = new KeyValuePair <Player, List <int> >();
if (open)
{
for (int index = 0; index < moves.Count; index++)
{
int id = moves[index];
room.SetCardFlag(id, "visible");
}
}
else
{
foreach (int id in moves)
{
if (player == self || player.IsSameCamp(self))
{
room.SetCardFlag(id, "visible2" + self.Name);
}
}
guanxing = new KeyValuePair <Player, List <int> >(player, moves);
}
}
else
{
if (open)
{
for (int index = 0; index < moves.Count; index++)
{
int id = moves[index];
room.SetCardFlag(id, "visible");
}
}
else
{
foreach (int id in moves)
{
room.SetCardFlag(id, "visible2" + choices[1]);
}
}
}
}
}
}
/// <summary>
/// Automatically embeds a video of the test run from this point forward when a trigger event occurs.
/// </summary>
/// <remarks>
/// <para>
/// Recording a screen capture video can be very CPU and space intensive particularly
/// when running tests on a single-core CPU. We recommend calling
/// <see cref="AutoEmbedRecording(TriggerEvent, string, CaptureParameters, double)" /> with
/// a <see cref="CaptureParameters.Zoom" /> factor of 0.25 or less and a frame rate
/// of no more than 5 to 10 frames per second.
/// </para>
/// <para>
/// If screenshots cannot be captured, the method will embed a warning message to that effect.
/// </para>
/// </remarks>
/// <param name="triggerEvent">The trigger event.</param>
/// <param name="attachmentName">The name to give the video attachment, or null to assign one automatically.</param>
/// <param name="parameters">The capture parameters.</param>
/// <param name="framesPerSecond">The number of frames per second to capture.</param>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="parameters"/> is null.</exception>
/// <seealso cref="TestContext.AutoExecute(TriggerEvent, Action)"/>
public static void AutoEmbedRecording(TriggerEvent triggerEvent, string attachmentName, CaptureParameters parameters, double framesPerSecond)
{
if (parameters == null)
throw new ArgumentNullException("parameters");
TestContext context = TestContext.CurrentContext;
if (context != null)
{
try
{
ScreenRecorder recorder = StartRecording(parameters, framesPerSecond);
context.AutoExecute(triggerEvent, () =>
{
recorder.Stop();
if (recorder.Video.FrameCount != 0)
context.LogWriter.Default.EmbedVideo(attachmentName, recorder.Video);
}, recorder.Dispose);
}
catch (ScreenshotNotAvailableException ex)
{
context.AutoExecute(triggerEvent, () =>
{
context.LogWriter.Default.WriteException(ex, "Recording not available.");
});
}
}
}
/// <summary>
/// Automatically embeds a video of the test run from this point forward when a trigger event occurs.
/// </summary>
/// <remarks>
/// <para>
/// Recording a screen capture video can be very CPU and space intensive particularly
/// when running tests on a single-core CPU. We recommend specifying a zoom with of 0.25 or
/// less and a frame rate of no more than 5 to 10 frames per second.
/// </para>
/// <para>
/// If screenshots cannot be captured, the method will embed a warning message to that effect.
/// </para>
/// </remarks>
/// <example>
/// <code><![CDATA[
/// [Test]
/// [AutoEmbedRecording(TriggerEvent.TestPassed, Zoom = 0.25, FramesPerSecond = 3)]
/// public void Test()
/// {
/// // Code logic here.
/// }
/// ]]></code>
/// </example>
/// <param name="triggerEvent">The trigger event.</param>
public AutoEmbedRecordingAttribute(TriggerEvent triggerEvent)
: base(triggerEvent)
{
}
/// <summary>
/// Returns true if a trigger event has been satisfied.
/// </summary>
/// <remarks>
/// <para>
/// This method assumes that the body of the test has already finished and is
/// currently running tear down, dispose, or finishing actions.
/// </para>
/// </remarks>
/// <param name="triggerEvent">The trigger event.</param>
/// <returns>True if the trigger event is satisfied.</returns>
public bool IsTriggerEventSatisfied(TriggerEvent triggerEvent)
{
switch (triggerEvent)
{
case TriggerEvent.TestFinished:
return true;
case TriggerEvent.TestPassed:
return Outcome.Status == TestStatus.Passed;
case TriggerEvent.TestPassedOrInconclusive:
return Outcome.Status == TestStatus.Passed || Outcome.Status == TestStatus.Inconclusive;
case TriggerEvent.TestInconclusive:
return Outcome.Status == TestStatus.Inconclusive;
case TriggerEvent.TestFailed:
return Outcome.Status == TestStatus.Failed;
case TriggerEvent.TestFailedOrInconclusive:
return Outcome.Status == TestStatus.Failed || Outcome.Status == TestStatus.Inconclusive;
default:
return false;
}
}
public void Read(MpqFileStream stream)
{
this.F0 = stream.ReadValueF32();
this.Event = new TriggerEvent(stream);
}
public virtual void Record(TriggerEvent triggerEvent, Room room, Player player, ref object data)
{
}
public override void OnTriggerKeep(TriggerEvent evt)
{
}
virtual public bool Effect(TriggerEvent triggerEvent, Room room, Player player, ref object data, Player ask_who, TriggerStruct info)
{
return(false);
}
public override void OnTriggerOut(TriggerEvent evt)
{
MainAnimator.SetInteger("state", 0);
}
public override TriggerStruct Cost(TriggerEvent triggerEvent, Room room, Player player, ref object data, Player ask_who, TriggerStruct info)
{
return(base.Cost(triggerEvent, room, player, ref data, ask_who, info));
}
public override void OnTriggerIn(TriggerEvent evt)
{
JudgeSpeed(evt);
}
public PerformDBOperationExpression CreateTriggerExpression(string tableName, string triggerName, bool onBefore, TriggerEvent onEvent, string triggerBody)
{
tableName = truncator.Truncate(tableName);
triggerName = truncator.Truncate(triggerName);
CheckTable(tableName);
LockTable(tableName);
PerformDBOperationExpression createTrigger = new PerformDBOperationExpression();
createTrigger.Operation = (connection, transaction) =>
{
string triggerSql = String.Format(@"CREATE TRIGGER {0} FOR {1} ACTIVE {2} {3} POSITION 0
{4}
", quoter.Quote(triggerName), quoter.Quote(tableName),
onBefore ? "before" : "after",
onEvent.ToString().ToLower(),
triggerBody
);
Announcer.Sql(triggerSql);
using (var cmd = Factory.CreateCommand(triggerSql, connection, transaction))
{
cmd.CommandTimeout = Options.Timeout;
cmd.ExecuteNonQuery();
}
};
return(createTrigger);
}
public void Add(string name, TriggerEvent e)
{
SaveManager.instance.data.UnlockedLevels.Add(name, e);
SaveManager.instance.SaveData(); // save the newly unlocked level
}
private static Node[] GetWorkflowTemplates(Node currentNode, TriggerEvent triggerEvent)
{
var listPath = NodeHead.Get(currentNode.ContentListId).Path;
var templatesPath = RepositoryPath.Combine(listPath, "WorkflowTemplates");
Node[] templates;
if (SearchManager.ContentQueryIsAllowed)
{
string query = null;
switch (triggerEvent)
{
case TriggerEvent.Created: query = SafeQueries.WorkflowsAutostartWhenCreated; break;
case TriggerEvent.Changed: query = SafeQueries.WorkflowsAutostartWhenChanged; break;
case TriggerEvent.Published: query = SafeQueries.WorkflowsAutostartWhenPublished; break;
default:
throw new SnNotSupportedException("Unkown TriggerEvent: " + triggerEvent);
}
var result = ContentQuery.Query(query, null, templatesPath);
templates = result.Nodes.ToArray();
}
else
{
QueryPropertyData[] propData;
switch (triggerEvent)
{
case TriggerEvent.Created:
// fieldClause = "+AutostartOnCreated:yes";
propData = new[] { new QueryPropertyData {
PropertyName = "AutostartOnCreated", QueryOperator = Operator.Equal, Value = 1
} };
break;
case TriggerEvent.Changed:
// fieldClause = "+AutostartOnChanged:yes";
propData = new[] { new QueryPropertyData {
PropertyName = "AutostartOnChanged", QueryOperator = Operator.Equal, Value = 1
} };
break;
case TriggerEvent.Published:
// fieldClause = "+(AutostartOnPublished:yes AutostartOnChanged:yes)";
propData = new[] { new QueryPropertyData {
PropertyName = "AutostartOnPublished", QueryOperator = Operator.Equal, Value = 1
} };
break;
default:
throw new SnNotSupportedException("Unkown TriggerEvent: " + triggerEvent);
}
var queryPropertyData = new List <QueryPropertyData>(propData);
var nodeType = ActiveSchema.NodeTypes["Workflow"];
templates = NodeQuery.QueryNodesByTypeAndPathAndProperty(nodeType, false, templatesPath, false, queryPropertyData).Nodes.ToArray();
if (templates.Length == 0 && triggerEvent == TriggerEvent.Published)
{
propData = new[] { new QueryPropertyData {
PropertyName = "AutostartOnChanged", QueryOperator = Operator.Equal, Value = 1
} };
templates = NodeQuery.QueryNodesByTypeAndPathAndProperty(nodeType, false, templatesPath, false, queryPropertyData).Nodes.ToArray();
}
}
return(templates);
}
private static void Register(TriggerEvent triggerEvent)
{
Capture.AutoEmbedScreenshot(triggerEvent, null, new CaptureParameters() { Zoom = 0.25 });
}
void Invoke(GameObject collidedObject)
{
TriggerEvent?.Invoke(this, new TriggerEventArgs(triggersCache ?? (triggersCache = triggers.Select(t => t.Convert()).ToArray()), collidedObject));
}
private static void Register(TriggerEvent triggerEvent)
{
Capture.AutoEmbedRecording(triggerEvent, null, new CaptureParameters() { Zoom = 0.25 }, 5);
}
public void register(TriggerEvent aEnter, TriggerEvent aStay, TriggerEvent aExit)
{
m_Enter += aEnter;
m_Stay += aStay;
m_Exit += aExit;
}
public override TriggerStruct Cost(TriggerEvent trigger_event, Room room, Player player, ref object data, Player target, TriggerStruct trigger_struct)
{
room.ShowGeneral(player, false, true);
return(new TriggerStruct());
}
public void Execute(TriggerEvent triggerEvent)
{
Check(triggerEvent.Entities.EntityA, triggerEvent.Entities.EntityB);
Check(triggerEvent.Entities.EntityB, triggerEvent.Entities.EntityA);
}
public override bool Effect(TriggerEvent triggerEvent, Room room, Player player, ref object data, Player target, TriggerStruct trigger_info)
{
if (room.ContainsTag("SkipGameRule") && (bool)room.GetTag("SkipGameRule"))
{
room.RemoveTag("SkipGameRule");
return(false);
}
// Handle global events
if (player == null)
{
if (triggerEvent == TriggerEvent.GameStart)
{
OnGameStart(room, ref data);
}
if (triggerEvent != TriggerEvent.BeforeCardsMove && triggerEvent != TriggerEvent.CardsMoveOneTime)
{
return(false);
}
}
switch (triggerEvent)
{
case TriggerEvent.TurnStart:
OnTurnStart(room, player, ref data);
break;
case TriggerEvent.EventPhaseProceeding:
OnPhaseProceed(room, player, ref data);
break;
case TriggerEvent.EventPhaseEnd:
OnPhaseEnd(room, player, ref data);
break;
case TriggerEvent.EventPhaseChanging:
OnPhaseChanging(room, player, ref data);
break;
case TriggerEvent.PreCardUsed:
OnPreCardUsed(room, player, ref data);
break;
case TriggerEvent.CardUsed:
OnCardUsed(room, player, ref data);
break;
case TriggerEvent.CardFinished:
CardUseStruct use = (CardUseStruct)data;
room.ClearCardFlag(use.Card);
//以askforcard形式使用的卡牌没有onUse的trigger，但有finish
if (use.Reason != CardUseStruct.CardUseReason.CARD_USE_REASON_RESPONSE)
{
List <CardUseStruct> use_list = (List <CardUseStruct>)room.GetTag("card_proceeing"); //remove when finished
if (use_list.Count > 0)
{
use_list.RemoveAt(use_list.Count - 1);
}
room.SetTag("card_proceeing", use_list);
//room.RemoveTag("targets" + RoomLogic.CardToString(room, use.Card));
}
if (Engine.GetFunctionCard(use.Card.Name).IsNDTrick())
{
room.RemoveTag(RoomLogic.CardToString(room, use.Card) + "HegnullificationTargets");
}
foreach (Client p in room.Clients)
{
room.DoNotify(p, CommandType.S_COMMAND_NULLIFICATION_ASKED, new List <string> {
"."
});
}
if (Engine.GetFunctionCard(use.Card.Name) is Slash)
{
use.From.RemoveTag("Jink_" + RoomLogic.CardToString(room, use.Card));
}
break;
case TriggerEvent.EventAcquireSkill:
case TriggerEvent.EventLoseSkill:
InfoStruct info = (InfoStruct)data;
string skill_name = info.Info;
Skill skill = Engine.GetSkill(skill_name);
bool refilter = skill is FilterSkill;
if (!refilter && skill is TriggerSkill)
{
TriggerSkill trigger = (TriggerSkill)skill;
ViewAsSkill vsskill = trigger.ViewAsSkill;
if (vsskill != null && (vsskill is FilterSkill))
{
refilter = true;
}
}
if (refilter)
{
room.FilterCards(player, player.GetCards("he"), triggerEvent == TriggerEvent.EventLoseSkill);
}
CheckBigKingdoms(room);
break;
case TriggerEvent.PostHpReduced:
if (player.Hp > 0 || player.HasFlag("Global_Dying")) // newest GameRule -- a player cannot enter dying when it is dying.
{
break;
}
if (data is DamageStruct damage)
{
room.EnterDying(player, damage);
}
else
{
room.EnterDying(player, new DamageStruct());
}
break;
case TriggerEvent.AskForPeaches:
OnAskforPeach(room, player, ref data);
break;
case TriggerEvent.AskForPeachesDone:
{
if (player.Hp <= 0 && player.Alive)
{
DyingStruct dying = (DyingStruct)data;
room.KillPlayer(player, dying.Damage);
}
break;
}
case TriggerEvent.ConfirmDamage:
{
damage = (DamageStruct)data;
if (damage.Card != null && damage.To.GetMark("SlashIsDrank") > 0)
{
LogMessage log = new LogMessage
{
Type = "#AnalepticBuff",
From = damage.From.Name,
To = new List <string> {
damage.To.Name
},
Arg = damage.Damage.ToString()
};
damage.Damage += damage.To.GetMark("SlashIsDrank");
damage.To.SetMark("SlashIsDrank", 0);
log.Arg2 = damage.Damage.ToString();
room.SendLog(log);
data = damage;
}
break;
}
case TriggerEvent.DamageDone:
{
damage = (DamageStruct)data;
if (damage.From != null && !damage.From.Alive)
{
damage.From = null;
}
data = damage;
room.SendDamageLog(damage);
bool reduce = !room.ApplyDamage(player, damage);
if (damage.Nature != DamageNature.Normal && player.Chained && !damage.Chain)
{
int n = room.ContainsTag("is_chained") ? (int)room.GetTag("is_chained") : 0;
n++;
room.SetTag("is_chained", n);
}
if (reduce)
{
room.RoomThread.Trigger(TriggerEvent.PostHpReduced, room, player, ref data);
}
break;
}
case TriggerEvent.DamageComplete:
{
damage = (DamageStruct)data;
if (damage.Prevented)
{
return(false);
}
if (damage.Nature != DamageNature.Normal && player.Chained)
{
room.ChainedRemoveOnDamageDone(player);
//player.Chained = false;
//room.BroadcastProperty(player, "Chained");
}
if (room.ContainsTag("is_chained") && (int)room.GetTag("is_chained") > 0)
{
if (damage.Nature != DamageNature.Normal && !damage.Chain)
{
// iron chain effect
int n = (int)room.GetTag("is_chained");
n--;
room.SetTag("is_chained", n);
List <Player> chained_players = new List <Player>();
if (!room.Current.Alive)
{
chained_players = room.GetOtherPlayers(room.Current);
}
else
{
chained_players = room.GetAllPlayers();
}
foreach (Player chained_player in chained_players)
{
if (chained_player.Chained)
{
Thread.Sleep(500);
LogMessage log = new LogMessage
{
Type = "#IronChainDamage",
From = chained_player.Name
};
room.SendLog(log);
DamageStruct chain_damage = damage;
chain_damage.To = chained_player;
chain_damage.Chain = true;
chain_damage.Transfer = false;
chain_damage.TransferReason = null;
room.Damage(chain_damage);
}
}
}
}
foreach (Player p in room.GetAllPlayers())
{
if (p.HasFlag("Global_DFDebut"))
{
p.SetFlags("-Global_DFDebut");
room.RoomThread.Trigger(TriggerEvent.DFDebut, room, p);
}
}
break;
}
case TriggerEvent.CardEffect:
{
if (data is CardEffectStruct effect)
{
if (Engine.GetFunctionCard(effect.Card.Name) is DelayedTrick)
{
CardMoveReason reason = new CardMoveReason(CardMoveReason.MoveReason.S_REASON_DELAYTRICK_EFFECT,
effect.To.Name, effect.Card.Skill, effect.Card.Name)
{
CardString = RoomLogic.CardToString(room, effect.Card)
};
room.MoveCardTo(effect.Card, effect.To, Place.PlaceTable, reason, true);
Thread.Sleep(500);
}
}
break;
}
case TriggerEvent.CardEffected:
{
if (data is CardEffectStruct effect)
{
FunctionCard fcard = Engine.GetFunctionCard(effect.Card.Name);
if (!(fcard is Slash) && effect.Nullified)
{
LogMessage log = new LogMessage
{
Type = "#Cardnullified",
From = effect.To.Name,
Arg = effect.Card.Name
};
room.SendLog(log);
return(true);
}
else if (fcard.TypeID == CardType.TypeTrick && room.IsCanceled(effect))
{
effect.To.SetFlags("Global_NonSkillnullify");
return(true);
}
object _effect = effect;
room.RoomThread.Trigger(TriggerEvent.CardEffectConfirmed, room, effect.To, ref _effect);
room.SetTag("Global_CardEffected", _effect); //for AI
if (effect.To.Alive || fcard is Slash)
{
fcard.OnEffect(room, effect);
}
room.RemoveTag("Global_CardEffected");
}
break;
}
case TriggerEvent.SlashEffected:
{
SlashEffectStruct effect = (SlashEffectStruct)data;
if (effect.Nullified)
{
LogMessage log = new LogMessage
{
Type = "#Cardnullified",
From = effect.To.Name,
Arg = effect.Slash.Name
};
room.SendLog(log);
return(true);
}
if (effect.Jink_num > 0)
{
room.RoomThread.Trigger(TriggerEvent.SlashProceed, room, effect.From, ref data);
}
else
{
room.SlashResult(effect, null);
}
break;
}
case TriggerEvent.SlashProceed:
{
SlashEffectStruct effect = (SlashEffectStruct)data;
string slasher = effect.From.Name;
if (!effect.To.Alive)
{
break;
}
if (effect.Jink_num == 1)
{
CardResponseStruct resp = room.AskForCard(effect.To, Slash.ClassName, Jink.ClassName, "slash-jink:" + slasher, data, HandlingMethod.MethodUse, null, effect.From, false, false);
room.SlashResult(effect, room.IsJinkEffected(effect.To, resp) ? resp.Card : null);
}
else
{
WrappedCard jink = new WrappedCard(DummyCard.ClassName);
for (int i = effect.Jink_num; i > 0; i--)
{
string prompt = string.Format("@multi-jink{0}:{1}::{2}", i == effect.Jink_num ? "-start" : string.Empty, slasher, i);
CardResponseStruct resp = room.AskForCard(effect.To, Slash.ClassName, Jink.ClassName, prompt, data, HandlingMethod.MethodUse, null, effect.From, false, false);
if (!room.IsJinkEffected(effect.To, resp))
{
//delete jink;
room.SlashResult(effect, null);
return(false);
}
else
{
jink.AddSubCard(resp.Card);
}
}
room.SlashResult(effect, jink);
}
break;
}
case TriggerEvent.SlashHit:
{
SlashEffectStruct effect = (SlashEffectStruct)data;
if (effect.Drank > 0)
{
effect.To.SetMark("SlashIsDrank", effect.Drank);
}
room.Damage(new DamageStruct(effect.Slash, effect.From, effect.To, 1, effect.Nature));
break;
}
case TriggerEvent.BeforeGameOverJudge:
{
if (!player.General1Showed)
{
room.ShowGeneral(player, true, false, false);
}
if (!player.General2Showed)
{
room.ShowGeneral(player, false, false, false);
}
break;
}
case TriggerEvent.GameOverJudge:
{
string winner = GetWinner(room);
if (!string.IsNullOrEmpty(winner))
{
room.GameOver(winner);
return(true);
}
break;
}
case TriggerEvent.BuryVictim:
{
OnBuryVictim(room, player, ref data);
break;
}
case TriggerEvent.StartJudge:
{
int card_id = room.GetNCards(1)[0];
JudgeStruct judge_struct = (JudgeStruct)data;
judge_struct.Card = room.GetCard(card_id);
LogMessage log = new LogMessage
{
Type = "$InitialJudge",
From = judge_struct.Who.Name,
Card_str = card_id.ToString()
};
room.SendLog(log);
room.MoveCardTo(judge_struct.Card, null, judge_struct.Who, Place.PlaceJudge,
new CardMoveReason(CardMoveReason.MoveReason.S_REASON_JUDGE, judge_struct.Who.Name, null, null, judge_struct.Reason), true);
Thread.Sleep(500);
bool effected = judge_struct.Good == Engine.MatchExpPattern(room, judge_struct.Pattern, judge_struct.Who, judge_struct.Card);
judge_struct.UpdateResult(effected);
data = judge_struct;
break;
}
case TriggerEvent.FinishRetrial:
{
JudgeStruct judge = (JudgeStruct)data;
LogMessage log = new LogMessage
{
Type = "$JudgeResult",
From = player.Name,
Card_str = RoomLogic.CardToString(room, judge.Card)
};
room.SendLog(log);
//Thread.Sleep(500);
if (judge.PlayAnimation)
{
room.SendJudgeResult(judge);
Thread.Sleep(800);
}
break;
}
case TriggerEvent.FinishJudge:
{
JudgeStruct judge = (JudgeStruct)data;
if (room.GetCardPlace(judge.Card.Id) == Place.PlaceJudge)
{
CardMoveReason reason = new CardMoveReason(CardMoveReason.MoveReason.S_REASON_JUDGEDONE, judge.Who.Name, null, judge.Reason);
room.MoveCardTo(judge.Card, judge.Who, null, Place.DiscardPile, reason, true);
}
break;
}
case TriggerEvent.ChoiceMade:
{
foreach (Player p in room.GetAlivePlayers())
{
List <string> flags = new List <string>(p.Flags);
foreach (string flag in flags)
{
if (flag.StartsWith("Global_") && flag.EndsWith("Failed"))
{
p.SetFlags("-" + flag);
}
}
}
break;
}
case TriggerEvent.GeneralShown:
{
string winner = GetWinner(room);
if (!string.IsNullOrEmpty(winner))
{
room.GameOver(winner); // if all hasShownGenreal, and they are all friend, game over.
return(true);
}
if (!room.ContainsTag("TheFirstToShowRewarded"))
{
room.SetTag("TheFirstToShowRewarded", true);
room.SetPlayerMark(player, "@pioneer", 1);
room.AttachSkillToPlayer(player, "pioneer");
}
if (player.Alive && player.HasShownAllGenerals())
{
if (player.GetMark("CompanionEffect") > 0)
{
room.RemovePlayerMark(player, "CompanionEffect");
room.DoSuperLightbox(player, string.Empty, "companion");
room.SetPlayerMark(player, "@companion", 1);
room.AttachSkillToPlayer(player, "companion");
}
if (player.GetMark("HalfMaxHpLeft") > 0)
{
room.RemovePlayerMark(player, "HalfMaxHpLeft");
room.SetPlayerMark(player, "@megatama", 1);
room.AttachSkillToPlayer(player, "megatama");
}
}
CheckBigKingdoms(room);
break;
}
case TriggerEvent.BeforeCardsMove:
{
if (data is CardsMoveOneTimeStruct move)
{
bool should_find_io = false;
if (move.To_place == Place.DiscardPile)
{
if (move.Reason.Reason != CardMoveReason.MoveReason.S_REASON_USE)
{
should_find_io = true; // not use
}
else if (move.Card_ids.Count > 1)
{
should_find_io = true; // use card isn't IO
}
else
{
WrappedCard card = room.GetCard(move.Card_ids[0]);
if (card.Name == Edict.ClassName && !card.HasFlag("edict_order_normal_use"))
{
should_find_io = true; // use card isn't IO
}
}
}
if (should_find_io)
{
foreach (int id in move.Card_ids)
{
WrappedCard card = room.GetCard(id);
if (card.Name == Edict.ClassName)
{
room.MoveCardTo(card, null, Place.PlaceTable, true);
room.AddToPile(room.Players[0], "#edict", card, false);
LogMessage log = new LogMessage
{
Type = "#RemoveEdict",
Arg = Edict.ClassName
};
room.SendLog(log);
room.SetTag("EdictInvoke", true);
room.SetTag("EdictCard", card);
int i = move.Card_ids.IndexOf(id);
move.From_places.RemoveAt(i);
move.Open.RemoveAt(i);
move.From_pile_names.RemoveAt(i);
move.Card_ids.Remove(id);
data = move;
break;
}
}
}
}
break;
}
case TriggerEvent.Death:
{
OnDeath(room, player, ref data);
break;
}
case TriggerEvent.CardsMoveOneTime:
{
if (data is CardsMoveOneTimeStruct move)
{
if (move.From != null && move.From_places.Contains(Place.PlaceEquip))
{
foreach (int id in move.Card_ids)
{
WrappedCard card = room.GetCard(id);
if (card.Name == JadeSeal.ClassName)
{
CheckBigKingdoms(room);
break;
}
}
}
if (move.To != null && move.To_place == Place.PlaceEquip)
{
foreach (int id in move.Card_ids)
{
WrappedCard card = room.GetCard(id);
if (card.Name == JadeSeal.ClassName)
{
CheckBigKingdoms(room);
break;
}
}
}
}
break;
}
default:
break;
}
return(false);
}
/// <summary>
/// Automatically embeds a screenshot when a trigger event occurs.
/// </summary>
/// <remarks>
/// <para>
/// If screenshots cannot be captured, the method will embed a warning message to that effect.
/// </para>
/// </remarks>
/// <param name="triggerEvent">The trigger event.</param>
/// <param name="attachmentName">The name to give the image attachment, or null to assign one automatically.</param>
/// <seealso cref="TestContext.AutoExecute(TriggerEvent, Action)"/>
public static void AutoEmbedScreenshot(TriggerEvent triggerEvent, string attachmentName)
{
AutoEmbedScreenshot(triggerEvent, attachmentName, new CaptureParameters());
}
// unsafe writing to this?
public void Execute(TriggerEvent triggerEvent)
{
pCounter[0]++;
}
/// <summary>
/// Automatically embeds a video of the test run from this point forward when a trigger event occurs.
/// </summary>
/// <remarks>
/// <para>
/// Recording a screen capture video can be very CPU and space intensive particularly
/// when running tests on a single-core CPU. We recommend calling
/// <see cref="AutoEmbedRecording(TriggerEvent, string, CaptureParameters, double)" /> with
/// a <see cref="CaptureParameters.Zoom" /> factor of 0.25 or less and a frame rate
/// of no more than 5 to 10 frames per second.
/// </para>
/// <para>
/// If screenshots cannot be captured, the method will embed a warning message to that effect.
/// </para>
/// </remarks>
/// <param name="triggerEvent">The trigger event.</param>
/// <param name="attachmentName">The name to give the video attachment, or null to assign one automatically.</param>
/// <seealso cref="TestContext.AutoExecute(TriggerEvent, Action)"/>
public static void AutoEmbedRecording(TriggerEvent triggerEvent, string attachmentName)
{
AutoEmbedRecording(triggerEvent, attachmentName, new CaptureParameters(), 5);
}
private static void Register(TriggerEvent triggerEvent)
{
TestContext.CurrentContext.AutoExecute(triggerEvent,
() => TestLog.WriteLine("Triggered 1"));
TestContext.CurrentContext.AutoExecute(triggerEvent,
() => TestLog.WriteLine("Triggered 2"),
() => TestLog.WriteLine("Cleanup"));
}
private void HandleEmitSoundOnTrigger(EntityUid uid, EmitSoundOnTriggerComponent component, TriggerEvent args)
{
TryEmitSound(component);
args.Handled = true;
}
public abstract void OnEvent(TriggerEvent triggerEvent, Room room, Player player, object data);
public void AutoExecute(TriggerEvent triggerEvent, Action triggerAction, Action cleanupAction)
{
if (triggerAction == null)
throw new ArgumentNullException("triggerAction");
Finishing += (sender, e) =>
{
if (IsTriggerEventSatisfied(triggerEvent))
{
try
{
triggerAction();
}
catch (Exception ex)
{
UnhandledExceptionPolicy.Report("An exception occurred while performing an auto-execute trigger action.", ex);
}
}
if (cleanupAction != null)
{
try
{
cleanupAction();
}
catch (Exception ex)
{
UnhandledExceptionPolicy.Report("An exception occurred while performing an auto-execute cleanup action.", ex);
}
}
};
}
// double getCurrentPriority() const
// {
// return current_priority;
// }
// void setCurrentPriority(double p) const
// {
// current_priority = p;
// }
public void InsertPriority(TriggerEvent e, double value)
{
priority[e] = value;
}
/// <summary>
/// Automatically embeds a screenshot when a trigger event occurs.
/// </summary>
/// <remarks>
/// <para>
/// If screenshots cannot be captured, the method will embed a warning message to that effect.
/// </para>
/// </remarks>
/// <example>
/// <code><![CDATA[
/// [Test]
/// [AutoEmbedScreenshot(TriggerEvent.TestPassed, Zoom = 0.25)]
/// public void Test()
/// {
/// // Code logic here.
/// }
/// ]]></code>
/// </example>
/// <param name="triggerEvent">The trigger event.</param>
public AutoEmbedScreenshotAttribute(TriggerEvent triggerEvent)
{
this.triggerEvent = triggerEvent;
}
protected override void LoadContent(PloobsEngine.Engine.GraphicInfo GraphicInfo, PloobsEngine.Engine.GraphicFactory factory, IContentManager contentManager)
{
base.LoadContent(GraphicInfo, factory, contentManager);
#region Trigger
///Criacao de um Trigger
///Create a trigger
{
///Modelo cujo formato sera utilizado para disparar o trigger
///Model used as base the for the trigger
SimpleModel sm = new SimpleModel(factory,"..\\Content\\Model\\cubo" );
sm.SetTexture(factory.CreateTexture2DColor(1,1, Color.Red), TextureType.DIFFUSE); ///VERMELHO
///Criacao do Triangle Mesh
///Create the triangle mesh from the model
TriangleMeshObject tm = new TriangleMeshObject(sm,new Vector3(200, 5, 0),Matrix.Identity,Vector3.One * 10,MaterialDescription.DefaultBepuMaterial());
///Criacao do Evento q sera disparado qd o trigger for acionado
///Pode-se criar outros tipos de eventos, basta extender a classe IEvent
///O parametro passado eh o canal em que o trigger enviara suas mensagens
///Qualquer Entidade que extende IRecieveMessageEntity pode receber mensagens
///Create the eventr that the trigger will fire
///TriggerEvent is the name of the CHANNEL (SEE CHANGINGMESSAGESSCREEN.CS) where the trigger will send the messages. (you can change the name at your will, change also the channel that the other objects are listening)
TriggerEvent te = new TriggerEvent("TriggerEvent","TriggerTest1");
///Criacao do Trigger
///Creating and adding the trigger to the physic world
BepuPhysicWorld physicWorld = this.World.PhysicWorld as BepuPhysicWorld;
System.Diagnostics.Debug.Assert(physicWorld != null);
///Setting triggers configuration, IT RECIEVES A TRIANGLE MESH
///TRIGGERS ARE ALWAYS TRIANGLE MESHES !!!!
BepuTrigger bt = new BepuTrigger(physicWorld, tm, te, true, true, true, true);
///Adiciona o trigger ao mundo
this.World.AddTrigger(bt);
///Adicona um objeto na posicao do trigger (Objeto FANTASMA, nao sera detectado pelo trigger)
///Facilita na localizacao do Trigger
///CREATE A VISUAL OBJECT FOR THE TRIGGER (SO WE CAN SEE IT)
///GHOST OBJECT (NO COLLISION)
GhostObject ghost = new GhostObject(new Vector3(200, 5, 0), Matrix.Identity,Vector3.One * 10);
///material and shader
DeferredNormalShader shader = new DeferredNormalShader();
IMaterial mat = new DeferredMaterial(shader);
/// add the visual object (DONT NEED, WE ADDED JUST TO SEE THE TRIGGER)
IObject obj3 = new IObject(mat, sm, ghost);
this.World.AddObject(obj3);
}
#endregion
///Criacao de um Objeto q recebera mensagens do trigger
///THIS OBJECT THAT WILL RECIEVE MESSAGE FROM the trigger
#region Models
{
SimpleModel sm = new SimpleModel(factory,"..\\Content\\Model\\cubo");
sm.SetTexture(factory.CreateTexture2DColor(1,1, Color.White), TextureType.DIFFUSE); ///BRANCO
IPhysicObject pi = new TriangleMeshObject( sm,new Vector3(20,50,50), Matrix.Identity,Vector3.One * 10,MaterialDescription.DefaultBepuMaterial());
DeferredNormalShader shader = new DeferredNormalShader();
IMaterial mat = new DeferredMaterial(shader);
IObject obj3 = new IObject(mat, sm, pi);
///Cadastra uma funcao para tratar das mensagens recebidas
///existem outras maneiras de fazer isso, como Extender a classe IObject e sobrescrever o metodo HandleMessage
///MESSAGE HANDLER
obj3.OnRecieveMessage += new OnRecieveMessage(obj3_OnRecieveMessage);
this.World.AddObject(obj3);
///Adiciona o Objeto criado ao grupo "TriggerEvent" que recebera as mensagens do trigger
///Register to recieve TriggerEvent Messages (registering to the channel)
EntityMapper.getInstance().AddgrouptagRecieveEntity("TriggerEvent", obj3);
}
///Cenario de sempre
{
SimpleModel sm = new SimpleModel(factory, "..\\Content\\Model\\cenario");
IPhysicObject pi = new TriangleMeshObject(sm,Vector3.Zero,Matrix.Identity,Vector3.One,MaterialDescription.DefaultBepuMaterial());
DeferredNormalShader shader = new DeferredNormalShader();
IMaterial mat = new DeferredMaterial(shader);
IObject obj3 = new IObject(mat, sm, pi);
this.World.AddObject(obj3);
}
#endregion
///Demonstracao de que qualquer entidade pode receber mensagens
///Olhar a implementacao desta classe, esta no fim deste arquivo
///Creating an entity to recieve the trigger message also
///JUST to show that everyone can recieve messages
rmessage = new ReciveMessage();
cam = new CameraFirstPerson(GraphicInfo);
cam.FarPlane = 2000;
lt = new LightThrowBepu(this.World, factory);
#region NormalLight
///Conjunto de luzes direcionais
DirectionalLightPE ld1 = new DirectionalLightPE(Vector3.Left, Color.White);
DirectionalLightPE ld2 = new DirectionalLightPE(Vector3.Right, Color.White);
DirectionalLightPE ld3 = new DirectionalLightPE(Vector3.Backward, Color.White);
DirectionalLightPE ld4 = new DirectionalLightPE(Vector3.Forward, Color.White);
DirectionalLightPE ld5 = new DirectionalLightPE(Vector3.Down, Color.White);
float li = 0.4f;
ld1.LightIntensity = li;
ld2.LightIntensity = li;
ld3.LightIntensity = li;
ld4.LightIntensity = li;
ld5.LightIntensity = li;
this.World.AddLight(ld1);
this.World.AddLight(ld2);
this.World.AddLight(ld3);
this.World.AddLight(ld4);
this.World.AddLight(ld5);
#endregion
this.World.CameraManager.AddCamera(cam);
}
