Dictionary <ProBuilderMesh, HashSet <Face> > TestFacePick(PickerOptions options)
{
try
{
Rect selectionRect = new Rect(camera.pixelRect);
selectionRect.width /= EditorGUIUtility.pixelsPerPoint;
selectionRect.height /= EditorGUIUtility.pixelsPerPoint;
var faces = UnityEngine.ProBuilder.SelectionPicker.PickFacesInRect(
camera,
selectionRect,
selectables,
options,
EditorGUIUtility.pixelsPerPoint);
LogAssert.NoUnexpectedReceived();
return(faces);
}
catch (System.Exception e)
{
Debug.LogError(e.ToString());
return(null);
}
}
public static Dictionary <ProBuilderMesh, HashSet <int> > PickVerticesInRect(
Camera cam,
Rect rect,
Rect uiRootRect,
IList <ProBuilderMesh> selectable,
PickerOptions options,
float pixelsPerPoint = 1f)
{
if (options.depthTest)
{
return(m_renderer.PickVerticesInRect(
cam,
rect,
selectable,
true,
(int)(uiRootRect.width / pixelsPerPoint),
(int)(uiRootRect.height / pixelsPerPoint)));
}
// while the selectionpicker render path supports no depth test picking, it's usually faster to skip
// the render. also avoids issues with vertex billboards obscuring one another.
var selected = new Dictionary <ProBuilderMesh, HashSet <int> >();
foreach (var pb in selectable)
{
if (!pb.selectable)
{
continue;
}
IList <SharedVertex> sharedIndexes = pb.sharedVertices;
HashSet <int> inRect = new HashSet <int>();
IList <Vector3> positions = pb.positions;
var trs = pb.transform;
float pixelHeight = uiRootRect.height;
for (int n = 0; n < sharedIndexes.Count; n++)
{
Vector3 v = trs.TransformPoint(positions[sharedIndexes[n][0]]);
Vector3 p = cam.WorldToScreenPoint(v);
if (p.z < cam.nearClipPlane)
{
continue;
}
p.x /= pixelsPerPoint;
p.y = (pixelHeight - p.y) / pixelsPerPoint;
if (rect.Contains(p))
{
inRect.Add(n);
}
}
selected.Add(pb, inRect);
}
return(selected);
}
/// <summary>
/// Creates a Bootstrap date time picker control
/// </summary>
/// <param name="html">HtmlHelper extension</param>
/// <param name="name">Name of HTML control</param>
/// <param name="options">
/// [Optional] Date time picker options. Defaults to
/// <see cref="BootstrapSettings.DateTimePickerOptions" />
/// </param>
/// <param name="htmlAttributes">Extra HTML attributes to be applied to the text box</param>
/// <returns>A Bootstrap date time picker control</returns>
public static IExtendedHtmlString DateTimeTextBox(this HtmlHelpers html,
string name, PickerOptions options = null,
object htmlAttributes = null)
{
IHtmlComponent control = new DateTimePickerHtmlComponent(name, name, options, htmlAttributes);
return(new ExtendedHtmlString(control));
}
/// <summary>
/// Creates a Bootstrap date time picker control
/// </summary>
/// <typeparam name="TModel">Type to be scanned</typeparam>
/// <typeparam name="TValue">Property to be scanned</typeparam>
/// <param name="html">HtmlHelper extension</param>
/// <param name="expression">The property lamba expression</param>
/// <param name="options">Date time picker options</param>
/// <param name="htmlAttributes">Extra HTML attributes to be applied to the text box</param>
/// <returns>A Bootstrap date time picker control</returns>
public static IExtendedHtmlString DateTimeTextBoxFor <TModel, TValue>(this HtmlHelpers <TModel> html,
Expression <Func <TModel, TValue> > expression,
PickerOptions options, object htmlAttributes)
{
MemberExpression mex = expression.Body as MemberExpression;
string id = WebExtrasUtil.GetFieldIdFromExpression(mex);
string name = WebExtrasUtil.GetFieldNameFromExpression(mex);
IHtmlComponent control = new DateTimePickerHtmlComponent(name, id, options, htmlAttributes);
return(new ExtendedHtmlString(control));
}
Dictionary <ProBuilderMesh, HashSet <int> > TestVertexPick(PickerOptions options)
{
try
{
Rect selectionRect = new Rect(camera.pixelRect);
selectionRect.width /= EditorGUIUtility.pixelsPerPoint;
selectionRect.height /= EditorGUIUtility.pixelsPerPoint;
var vertices = UnityEngine.ProBuilder.SelectionPicker.PickVerticesInRect(
camera,
selectionRect,
selectables,
options,
EditorGUIUtility.pixelsPerPoint);
LogAssert.NoUnexpectedReceived();
return(vertices);
}
catch
{
return(null);
}
}
public static void DoMouseDrag(Rect mouseDragRect, SelectMode selectionMode, ScenePickerPreferences scenePickerPreferences)
{
var pickingOptions = new PickerOptions()
{
depthTest = scenePickerPreferences.cullMode == CullingMode.Back,
rectSelectMode = scenePickerPreferences.rectSelectMode
};
UndoUtility.RecordSelection("Drag Select");
bool isAppendModifier = EditorHandleUtility.IsAppendModifier(Event.current.modifiers);
if (!isAppendModifier)
{
MeshSelection.ClearElementSelection();
}
bool elementsInDragRect = false;
switch (selectionMode)
{
case SelectMode.Vertex:
case SelectMode.TextureVertex:
{
Dictionary <ProBuilderMesh, HashSet <int> > selected = SelectionPicker.PickVerticesInRect(
SceneView.lastActiveSceneView.camera,
mouseDragRect,
MeshSelection.topInternal,
pickingOptions,
EditorGUIUtility.pixelsPerPoint);
foreach (var kvp in selected)
{
var mesh = kvp.Key;
SharedVertex[] sharedIndexes = mesh.sharedVerticesInternal;
HashSet <int> common;
if (isAppendModifier)
{
common = mesh.GetSharedVertexHandles(mesh.selectedIndexesInternal);
if (scenePickerPreferences.selectionModifierBehavior == SelectionModifierBehavior.Add)
{
common.UnionWith(kvp.Value);
}
else if (scenePickerPreferences.selectionModifierBehavior == SelectionModifierBehavior.Subtract)
{
common.RemoveWhere(x => kvp.Value.Contains(x));
}
else if (scenePickerPreferences.selectionModifierBehavior == SelectionModifierBehavior.Difference)
{
common.SymmetricExceptWith(kvp.Value);
}
}
else
{
common = kvp.Value;
}
elementsInDragRect |= kvp.Value.Any();
mesh.SetSelectedVertices(common.SelectMany(x => sharedIndexes[x]));
}
break;
}
case SelectMode.Face:
case SelectMode.TextureFace:
{
Dictionary <ProBuilderMesh, HashSet <Face> > selected = SelectionPicker.PickFacesInRect(
SceneView.lastActiveSceneView.camera,
mouseDragRect,
MeshSelection.topInternal,
pickingOptions,
EditorGUIUtility.pixelsPerPoint);
foreach (var kvp in selected)
{
HashSet <Face> current;
if (isAppendModifier)
{
current = new HashSet <Face>(kvp.Key.selectedFacesInternal);
if (scenePickerPreferences.selectionModifierBehavior == SelectionModifierBehavior.Add)
{
current.UnionWith(kvp.Value);
}
else if (scenePickerPreferences.selectionModifierBehavior == SelectionModifierBehavior.Subtract)
{
current.RemoveWhere(x => kvp.Value.Contains(x));
}
else if (scenePickerPreferences.selectionModifierBehavior == SelectionModifierBehavior.Difference)
{
current.SymmetricExceptWith(kvp.Value);
}
}
else
{
current = kvp.Value;
}
elementsInDragRect |= kvp.Value.Any();
kvp.Key.SetSelectedFaces(current);
}
break;
}
case SelectMode.Edge:
case SelectMode.TextureEdge:
{
var selected = SelectionPicker.PickEdgesInRect(
SceneView.lastActiveSceneView.camera,
mouseDragRect,
MeshSelection.topInternal,
pickingOptions,
EditorGUIUtility.pixelsPerPoint);
foreach (var kvp in selected)
{
ProBuilderMesh mesh = kvp.Key;
Dictionary <int, int> common = mesh.sharedVertexLookup;
HashSet <EdgeLookup> selectedEdges = EdgeLookup.GetEdgeLookupHashSet(kvp.Value, common);
HashSet <EdgeLookup> current;
if (isAppendModifier)
{
current = EdgeLookup.GetEdgeLookupHashSet(mesh.selectedEdges, common);
if (scenePickerPreferences.selectionModifierBehavior == SelectionModifierBehavior.Add)
{
current.UnionWith(selectedEdges);
}
else if (scenePickerPreferences.selectionModifierBehavior == SelectionModifierBehavior.Subtract)
{
current.RemoveWhere(x => selectedEdges.Contains(x));
}
else if (scenePickerPreferences.selectionModifierBehavior == SelectionModifierBehavior.Difference)
{
current.SymmetricExceptWith(selectedEdges);
}
}
else
{
current = selectedEdges;
}
elementsInDragRect |= kvp.Value.Any();
mesh.SetSelectedEdges(current.Select(x => x.local));
}
break;
}
}
// if nothing was selected in the drag rect, clear the object selection too
if (!elementsInDragRect && !isAppendModifier)
{
MeshSelection.ClearElementAndObjectSelection();
}
ProBuilderEditor.Refresh();
SceneView.RepaintAll();
}
/// <summary>
/// Creates a Bootstrap date time picker control
/// </summary>
/// <typeparam name="TModel">Type to be scanned</typeparam>
/// <typeparam name="TValue">Property to be scanned</typeparam>
/// <param name="html">HtmlHelper extension</param>
/// <param name="expression">The property lamba expression</param>
/// <param name="options">Date time picker options</param>
/// <param name="htmlAttributes">Extra HTML attributes to be applied to the text box</param>
/// <returns>A Bootstrap date time picker control</returns>
public static IExtendedHtmlStringLegacy DateTimeTextBoxFor <TModel, TValue>(this HtmlHelper <TModel> html,
Expression <Func <TModel, TValue> > expression, PickerOptions options,
object htmlAttributes = (IDictionary <string, object>) null)
{
MemberExpression exp = expression.Body as MemberExpression;
PickerOptions pickerOptions =
options.GetHashCode() == BootstrapSettings.DateTimePickerOptions.GetHashCode()
? options.DeepClone()
: options;
pickerOptions = pickerOptions.TryFontAwesomeIcons();
var model = ((DateTime?)ModelMetadata.FromLambdaExpression(expression, html.ViewData).Model);
if (model.HasValue && model.Value > DateTime.MinValue)
{
pickerOptions.defaultDate = model;
}
string fieldId = WebExtrasUtil.GetFieldIdFromExpression(exp);
string fieldName = WebExtrasUtil.GetFieldNameFromExpression(exp);
// create the text box
HtmlComponent input = new HtmlComponent(EHtmlTag.Input);
var attribs = HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes)
.ToDictionary(k => k.Key, v => v.Value.ToString());
input.Attributes.Add(attribs);
input.Attributes["type"] = "text";
input.Attributes["name"] = fieldName;
if (input.Attributes.ContainsKey("class"))
{
input.Attributes["class"] += " form-control";
}
else
{
input.Attributes["class"] = "form-control";
}
// create icon
HtmlComponent icon = new HtmlComponent(EHtmlTag.I);
if (WebExtrasSettings.FontAwesomeVersion == EFontAwesomeVersion.V4)
{
icon.CssClasses.Add("fa fa-calendar");
}
else if (WebExtrasSettings.FontAwesomeVersion == EFontAwesomeVersion.V3)
{
icon.CssClasses.Add("icon-calendar");
}
else
{
icon.CssClasses.Add("glyphicon glyphicon-calendar");
}
// create addon
HtmlComponent addOn = new HtmlComponent(EHtmlTag.Span);
addOn.CssClasses.Add("input-group-addon");
addOn.AppendTags.Add(icon);
// create JSON dictionary of the picker options
string op = pickerOptions.ToJson(new JsonSerializerSettings {
NullValueHandling = NullValueHandling.Ignore
});
HtmlComponent script = new HtmlComponent(EHtmlTag.Script);
script.Attributes["type"] = "text/javascript";
script.InnerHtml = "$(function(){ $('#" + fieldId + "').datetimepicker(" + op + "); });";
// create the final component
IHtmlComponent control;
if (pickerOptions.useAddonField.Equals(false))
{
NullWrapperComponent wrapper = new NullWrapperComponent();
input.Attributes["id"] = fieldId;
wrapper.Components.Add(input);
wrapper.Components.Add(script);
control = wrapper;
}
else
{
control = new HtmlComponent(EHtmlTag.Div);
control.Attributes["id"] = fieldId;
control.Attributes["class"] = "input-group date";
control.AppendTags.Add(input);
control.AppendTags.Add(addOn);
control.AppendTags.Add(script);
}
return(new HtmlElement(control));
}
/// <summary>
/// Creates a Bootstrap date time picker control
/// </summary>
/// <typeparam name="TModel">Type to be scanned</typeparam>
/// <typeparam name="TValue">Property to be scanned</typeparam>
/// <param name="html">HtmlHelper extension</param>
/// <param name="expression">The property lamba expression</param>
/// <param name="options">Date time picker options</param>
/// <param name="htmlAttributes">Extra HTML attributes to be applied to the text box</param>
/// <returns>A Bootstrap date time picker control</returns>
public static MvcHtmlString DateTimeTextBoxFor <TModel, TValue>(this HtmlHelper <TModel> html,
Expression <Func <TModel, TValue> > expression, PickerOptions options,
object htmlAttributes = (IDictionary <string, object>) null)
{
MemberExpression exp = expression.Body as MemberExpression;
PickerOptions pickerOptions =
options.GetHashCode() == BootstrapSettings.DateTimePickerOptions.GetHashCode()
? options.DeepClone()
: options;
pickerOptions = pickerOptions.UpdateOptionsBasedOnView();
string fieldId = WebExtrasUtil.GetFieldIdFromExpression(exp);
string fieldName = WebExtrasUtil.GetFieldNameFromExpression(exp);
string datetimeformat = ConvertToCsDateFormat(pickerOptions.format);
// create the text box
TagBuilder input = new TagBuilder("input");
input.MergeAttributes(HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes));
input.Attributes["type"] = "text";
input.Attributes["value"] =
((DateTime)ModelMetadata.FromLambdaExpression(expression, html.ViewData).Model).ToString(datetimeformat);
input.Attributes["name"] = fieldName;
if (input.Attributes.ContainsKey("class"))
{
input.Attributes["class"] += " form-control";
}
else
{
input.Attributes["class"] = "form-control";
}
// create addon
TagBuilder addOn = new TagBuilder("span");
addOn.AddCssClass("add-on");
TagBuilder icons = new TagBuilder("i");
icons.AddCssClass("icon-calendar");
TagBuilder control = new TagBuilder("div");
control.Attributes["id"] = fieldId;
control.Attributes["class"] = "input-append date form_datetime";
addOn.InnerHtml = icons.ToString(TagRenderMode.Normal);
control.InnerHtml = input.ToString(TagRenderMode.SelfClosing) + addOn.ToString(TagRenderMode.Normal);
// create JSON dictionary of the picker options
string op = pickerOptions.ToJson();
TagBuilder script = new TagBuilder("script");
script.Attributes["type"] = "text/javascript";
script.InnerHtml = "$(function(){ $('#" + fieldId + "').datetimepicker(" + op + "); });";
return(MvcHtmlString.Create(control.ToString(TagRenderMode.Normal) + script.ToString(TagRenderMode.Normal)));
}
public PickerModel(List<IExchangeRecord> values, PickerOptions pickerOption)
{
_values = values;
_pickerOption = pickerOption;
}
public static Dictionary <ProBuilderMesh, HashSet <Edge> > PickEdgesInRect(
Camera cam,
Rect rect,
Rect uiRootRect,
IList <ProBuilderMesh> selectable,
PickerOptions options,
float pixelsPerPoint = 1f)
{
if (/*options.depthTest &&*/ options.rectSelectMode == RectSelectMode.Partial)
{
return(m_renderer.PickEdgesInRect(
cam,
rect,
selectable,
options.depthTest,
(int)(uiRootRect.width / pixelsPerPoint),
(int)(uiRootRect.height / pixelsPerPoint)));
}
var selected = new Dictionary <ProBuilderMesh, HashSet <Edge> >();
foreach (var pb in selectable)
{
if (!pb.selectable)
{
continue;
}
Transform trs = pb.transform;
var selectedEdges = new HashSet <Edge>();
IList <Face> faces = pb.faces;
IList <Vector3> positions = pb.positions;
for (int i = 0, fc = pb.faceCount; i < fc; i++)
{
var edges = faces[i].edges;
for (int n = 0, ec = edges.Count; n < ec; n++)
{
var edge = edges[n];
var posA = trs.TransformPoint(positions[edge.a]);
var posB = trs.TransformPoint(positions[edge.b]);
Vector3 a = ScreenToGuiPoint(uiRootRect, cam.WorldToScreenPoint(posA), pixelsPerPoint);
Vector3 b = ScreenToGuiPoint(uiRootRect, cam.WorldToScreenPoint(posB), pixelsPerPoint);
switch (options.rectSelectMode)
{
case RectSelectMode.Complete:
{
// if either of the positions are clipped by the camera we cannot possibly select both, skip it
if ((a.z < cam.nearClipPlane || b.z < cam.nearClipPlane))
{
continue;
}
if (rect.Contains(a) && rect.Contains(b))
{
if (!options.depthTest || !PBUtility.PointIsOccluded(cam, pb, (posA + posB) * .5f))
{
selectedEdges.Add(edge);
}
}
break;
}
case RectSelectMode.Partial:
{
// partial + depth test is covered earlier
if (RectIntersectsLineSegment(rect, a, b))
{
selectedEdges.Add(edge);
}
break;
}
}
}
}
selected.Add(pb, selectedEdges);
}
return(selected);
}
public void Setup()
{
var cache = new RedisCacheRepository(
connectionString: "localhost,abortConnect=false",
environment: "local",
functionalArea: "bts",
serializer: new XmlSerializer(),
logger: new FakeCacheLogger(),
expire: false);
var pitcherRepo = new CachedPitcherRepository(
new PitcherRepository(),
cache);
var lineupRepo = new CachedLineupRepository(
new LineupRepository(),
cache);
var statsRepo = new CachedPlayerStatsRepository(
new PlayerStatsRepository(),
cache);
var teamStatsRepo = new CachedTeamStatsRepository(
new TeamStatsRepository(),
cache);
var opposingPitcher = new OpposingPitcher(
pitcherRepo);
var lineupProjector = new LineupProjector(
lineupRepo,
opposingPitcher,
new FakeLogger(),
daysToGoBack: 10);
var gameLogRepository = new CachedGameLogRepository(
new GameLogRepository(),
cache);
var obaCalculator = new CalculateOpponentOba(
new FakeLogger(),
gameLogRepository);
_resultChecker = new ResultChecker(statsRepo);
var options = new Dictionary <string, string>
{
{ Constants.Options.HomePitchersOnly, "on" },
{ Constants.Options.LineupPositions, "4" },
{ Constants.Options.NoDaysOff, "on" },
{ Constants.Options.DaysOffDaysBack, "3" },
{ Constants.Options.HotBatters, "off" },
{ Constants.Options.HotBattersDaysBack, "30" },
{ Constants.Options.HotBattersMendozaLine, ".289" },
{ Constants.Options.PitchersMendozaLine, ".259" },
{ Constants.Options.PitcherDaysBack, "30" },
{ Constants.Options.TeamClip, "off" },
{ Constants.Options.PitchersTeamMendozaLine, ".555" },
{ Constants.Options.BattersTeamMendozaLine, ".399" },
};
var pickerOptions = new PickerOptions(options);
_picker = new DefaultPicker(
options: pickerOptions,
lineupRepository: lineupRepo,
pitcherRepository: pitcherRepo,
playerStatsRepository: statsRepo,
teamStatsRepository: teamStatsRepo,
lineupProjector: lineupProjector,
calculateOpponentOba: obaCalculator,
logger: new FakeLogger());
_sut = new CalculateStreak(_picker, _resultChecker);
}
static void Main(string[] args)
{
CalculateVersionInfo(
out Version versionInfo,
out DateTime computedDate);
var logger = new Implementations.NLogAdaptor();
logger.Info("-------------------------------------------------------------------------------------");
logger.Info($@"Beat The Streak ver:{
versionInfo
} built {
computedDate.ToLongDateString()
} Working Directory:{
Directory.GetCurrentDirectory()
}" );
var cacheLogger = new Cache.NLogAdaptor();
var cache = new RedisCacheRepository(
connectionString: "localhost,abortConnect=false",
environment: "local",
functionalArea: "bts",
serializer: new XmlSerializer(),
logger: cacheLogger,
expire: false);
var pitcherRepo = new CachedPitcherRepository(
new PitcherRepository(),
cache);
var lineupRepo = new CachedLineupRepository(
new LineupRepository(),
cache);
var statsRepo = new CachedPlayerStatsRepository(
new PlayerStatsRepository(),
cache);
var teamStatsRepo = new CachedTeamStatsRepository(
new TeamStatsRepository(),
cache);
var opposingPitcher = new OpposingPitcher(
pitcherRepo);
var lineupProjector = new LineupProjector(
lineupRepo,
opposingPitcher,
logger,
daysToGoBack: 10);
var resultChecker = new ResultChecker(statsRepo);
var configReader = new ConfigReader();
var mm = new MailMan2(configReader, logger);
var mailer = new MailBatterReport(mailMan: mm, logger: logger);
var gameLogRepository = new CachedGameLogRepository(
new GameLogRepository(),
cache);
var obaCalculator = new CalculateOpponentOba(
logger: logger,
gameLogRepository: gameLogRepository);
var options = new Dictionary <string, string>
{
{ Constants.Options.HomePitchersOnly, "on" },
{ Constants.Options.LineupPositions, "3" },
{ Constants.Options.NoDaysOff, "off" },
{ Constants.Options.DaysOffDaysBack, "3" },
{ Constants.Options.HotBatters, "off" },
{ Constants.Options.HotBattersDaysBack, "30" },
{ Constants.Options.HotBattersMendozaLine, ".289" },
{ Constants.Options.PitchersMendozaLine, ".259" },
{ Constants.Options.PitcherDaysBack, "30" },
{ Constants.Options.BattersToPick, "2" },
{ Constants.Options.TeamClip, "off" },
{ Constants.Options.PitchersTeamMendozaLine, ".555" },
{ Constants.Options.BattersTeamMendozaLine, ".455" },
};
var pickerOptions = new PickerOptions(options);
var sut = new DefaultPicker(
pickerOptions,
lineupRepo,
pitcherRepo,
statsRepo,
teamStatsRepo,
lineupProjector,
obaCalculator,
logger);
var gameDate = DateTime.Now; // US Date
try
{
var result = sut.Choose(
gameDate: gameDate,
numberRequired: 2);
if (Utility.GamePlayed(gameDate))
{
foreach (var selection in result.Selections)
{
selection.Result = resultChecker.Result(
selection.Batter,
gameDate);
}
}
result.Dump();
mailer.MailReport(result);
logger.Info("-------------------------------------------------------------------------------------");
}
catch (Exception ex)
{
logger.Error(ex.Message);
Environment.FailFast(message: null);
throw;
}
}
