public StarModel Refine(StarModel starModel)
{
foreach (var column in starModel.FactTable.Columns)
{
if (!column.DataType.IsString())
{
continue;
}
column.DataType.Length += 10;
}
foreach (var dimension in starModel.Dimensions)
{
foreach (var column in dimension.Columns)
{
if (!column.DataType.IsString())
{
continue;
}
column.DataType.Length += 10;
}
}
return(starModel);
}
void CreatePoints()
{
points = new ParticleSystem.Particle[skyModel.GetStars().Count];
currentStarSize = maxStarSize;
for (int i = 0; i < skyModel.GetStars().Count; i++)
{
StarModel star = skyModel.GetStars() [i];
points[i].position = star.GetEquatorialRectangularCoords() * sim.radius;
points[i].startColor = star.GetStarRGB();
points [i].startSize = maxStarSize * Mathf.Pow(star.getClampedMagnitude(), exponent) + minStarSize;
points[i].velocity = Vector3.zero;
points[i].angularVelocity = 0.0f;
points[i].rotation = 0.0f;
}
ps.maxParticles = Mathf.RoundToInt(points.Length);
ps.SetParticles(points, points.Length);
}
public void SellResource(PlayerModel player, string resourceName)
{
StarModel star = starService.GetStarByName(player.currentNodeName);
ResourceSlotModel resourceSlot = star.resourceList[resourceName];
playerAdapter.SellResource(player, resourceSlot);
}
/// <summary>
/// Логика по созданию звезды здесь. Здесь считываются введенные пользователем данные, преобразуются в нужный тип и отправляются в конструктор модели звезды. Готовая звезда отдается родительской форме, а исключения отлавливаются и показываются пользователю в виде понятного текста.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void ButtonCreateStar_Click(object sender, EventArgs e)
{
try
{
var largeRadius = double.Parse(TextBoxLargeRadius.Text);
var smallRadius = double.Parse(TextBoxSmallRadius.Text);
var centerPointX = float.Parse(TextBoxCenterX.Text);
var centerPointY = float.Parse(TextBoxCenterY.Text);
var degree = double.Parse(TextBoxDegree.Text);
var raysNumber = int.Parse(TextBoxRaysCount.Text);
var star = new StarModel(largeRadius, smallRadius, new PointF(centerPointX, centerPointY), degree, raysNumber);
var starViewModel = new StarViewModel(star, StarColor);
this.StarCreated?.Invoke(starViewModel);
this.Close();
}
catch (FormatException)
{
MessageBox.Show("Вы использовали недопустимые данные для ввода. Для ввода большего радиуса, малого радиуса, центральных точек и угла допускаются числа с плавающей запятой (целая часть от дробной разделяется запятой), а для количества лучей допускаются только целые числа.");
}
catch (Exception ex)
{
MessageBox.Show($"Ошибка! {ex.Message}");
}
}
public StarModel Refine(StarModel starModel)
{
var factTable = starModel.FactTable;
int ordinalOffset = 0;
List <StarColumn> foreignColumns = new List <StarColumn>();
// Create a column for each relation that lacks link columns
foreach (var relation in factTable.Relations.Where(r => Equals(r.LinkTable, factTable) && !r.HasLinkColumns()))
{
// Create column
var foreignColumn = new StarColumn(++ordinalOffset, $"{relation.AnchorTable.Name}_Key", new DataType(OleDbType.Integer), StarColumnType.Key);
foreignColumn.TableRef = factTable;
// Add to list of foreign columns, and add to relation
foreignColumns.Add(foreignColumn);
relation.LinkColumns.Add(foreignColumn);
}
// Shift ordinals of existing columns and insert foreign columns
factTable.Columns.ForEach(c => c.Ordinal += ordinalOffset);
foreignColumns.ForEach(c => factTable.Columns.Insert(c.Ordinal - 1, c));
factTable.Constraints.PrimaryKey = new PrimaryKey(foreignColumns);
return(starModel);
}
public async Task <IActionResult> LeaveStar(StarModel model)
{
var user = await _userManager.FindByEmailAsync(model.AuthorId);
var str = ctx.Stars.SingleOrDefault(s => s.AuthorId == user.Id && s.InstrumentId == model.InstrumentId);
if (str != null)
{
str.Mark = model.Mark;
}
else
{
ctx.Stars.Add(
new Star()
{
AuthorId = user.Id,
InstrumentId = model.InstrumentId,
Mark = model.Mark
}
);
}
await ctx.SaveChangesAsync();
return(Ok(new StarResult()
{
Successful = true
}));
}
public StarGraph(StarModel model)
{
BasedOn = model;
Dictionary <StarModelTableBase, StarNode> nodes = new Dictionary <StarModelTableBase, StarNode>();
nodes[model.FactTable] = new FactNode(model.FactTable);
foreach (var dimension in model.Dimensions)
{
if (!dimension.IsRolePlaying)
{
nodes[dimension] = new DimensionNode((Dimension)dimension.ActualTable);
}
}
AddVertexRange(nodes.Values);
List <StarNode> facts = nodes.Where(n => n.Key is FactTable).Select(kv => kv.Value).ToList();
List <StarNode> dimensions = nodes.Where(n => n.Key is Dimension).Select(kv => kv.Value).ToList();
foreach (DimensionNode dimension in dimensions)
{
foreach (var relation in dimension.Dimension.Relations)
{
var linkNode = nodes[relation.LinkTable.ActualTable];
AddEdge(new StarEdge(linkNode, dimension));
}
}
}
public async Task <bool> ToggleProjectStarredByUserId(string projectID, string userID)
{
ProjectModel DbProjectModel = await GetSingleProjectByProjectId(projectID);
if (DbProjectModel != null)
{
StarModel starProject = _context.StarModel.FirstOrDefault(p => p.ProjectId == projectID && p.StarredBy == userID);
if (starProject != null)
{
await Task.Run(() => _context.Remove(starProject));
await _context.SaveChangesAsync();
return(true);
}
else
{
var record = new StarModel
{
ProjectId = projectID,
StarredBy = userID
};
await _context.AddAsync(record);
await _context.SaveChangesAsync();
return(true);
}
}
return(false);
}
protected void OnLoginSuccessful(LoginSuccessfulEvent e)
{
StarService starService = application.serviceManager.get <StarService>() as StarService;
StarModel currentStar = starService.GetStarByName(e.player.currentNodeName);
welcomeText.text = "Welcome to " + currentStar.name;
}
public void TestCreateValidStar(double largeRadius, double smallRadius, float centerCoodinatesX, float centerCoodinatesY, double degree, int raysNumber)
{
var star = new StarModel(largeRadius, smallRadius, new PointF(centerCoodinatesX, centerCoodinatesY), degree, raysNumber);
Assert.IsNotNull(star);
Assert.IsTrue(star.Tops.Count == star.RaysNumber * 2);
}
public void TestCreateNotValidStar(double largeRadius, double smallRadius, float centerCoodinatesX, float centerCoodinatesY, double degree, int raysNumber)
{
Assert.Throws(typeof(Exception), () =>
{
var star = new StarModel(largeRadius, smallRadius, new PointF(centerCoodinatesX, centerCoodinatesY), degree, raysNumber);
});
}
public void OpenMarket(PlayerModel player)
{
StarModel star = starService.GetStarByName(player.currentNodeName);
PlayerOpenedMarketEvent playerOpenedMarketEvent = new PlayerOpenedMarketEvent(player, star);
eventManager.DispatchEvent <PlayerOpenedMarketEvent>(playerOpenedMarketEvent);
}
public void GenerateConstellations()
{
foreach (Constellation constellation in sim.skyModel.GetConstellations())
{
GameObject goConst = new GameObject();
goConst.transform.parent = gameObject.transform;
goConst.name = constellation.GetAbbr();
List <StarModel> stars = skyModel.GetStars();
int[] reverseMapping = skyModel.GetReverseMapping();
int i = 0;
foreach (int[] line in constellation.GetLines())
{
GameObject go = new GameObject();
go.transform.parent = goConst.transform;
LineRenderer renderer = go.AddComponent <LineRenderer> ();
renderer.useWorldSpace = false; //essential to make
renderer.name = "line_" + i;
renderer.SetVertexCount(2);
renderer.material = lineMaterial;
renderer.SetColors(lineColor, lineColor);
renderer.SetWidth(lineWidth, lineWidth);
renderer.enabled = true;
StarModel star1 = stars [reverseMapping [line [0]]];
StarModel star2 = stars [reverseMapping [line [1]]];
renderer.SetPosition(0, star1.GetEquatorialRectangularCoords() * (sim.radius + 1.0f));
renderer.SetPosition(1, star2.GetEquatorialRectangularCoords() * (sim.radius + 1.0f));
++i;
}
}
}
public override StarModel TranslateModel(StarModel starModel)
{
//TODO: overvej om man kan gøre sådan, at man finder dimensions først, og så bruger den i stedet for dette her.
//TODO: Det ser pt. på alm. table references.
//All fact tables across all star models
//List<FactTable> allFactTables = starModels.Select(sm => sm.FactTable).ToList();
//Within fact table -> check whether a column is a measure or not.
List <StarColumn> nnColumns = starModel.FactTable.Columns.Where(c => c.WasNotNull()).ToList();
//Assumption: If a column in the fact table is a foreign key to a dimension -> not a measure
foreach (StarColumn col in nnColumns)
{
//If the current column is not a foreign key for any dimension of the fact table ...
bool isForeignKeyFlag = starModel.Dimensions.Any(dim => col.WasForeignKeyInDimension(dim));
//... then it is a measure
if (isForeignKeyFlag == false)
{
col.ColumnType |= col.DataType.IsNumeric()
? StarColumnType.NumericMeasure
: StarColumnType.DescriptiveMeasure;
}
}
return(starModel);
}
private LocalCoords GetSelectedBodyLocalCoords()
{
if (selectedBody is StarModel)
{
StarModel star = (StarModel)selectedBody;
star.Update((double)sim.GetJD(), sim.GetLocationData());
return(star.GetLocalCoords());
}
return(selectedBody.GetLocalCoords());
}
public void BuyResource(PlayerModel player, string resourceName)
{
StarModel star = starService.GetStarByName(player.currentNodeName);
ResourceSlotModel resourceSlot = star.resourceList[resourceName];
if (player.credits >= resourceSlot.buyPrice)
{
playerAdapter.BuyResource(player, resourceSlot);
}
}
public StarModel Refine(StarModel starModel)
{
RemoveForeignKeyColumns(starModel.FactTable);
foreach (var dimension in starModel.Dimensions.Where(d => !(d is DateDimension || d is TimeDimension)))
{
RemoveForeignKeyColumns(dimension);
}
return(starModel);
}
private void CacheStar(StarSystemInfo systemInfo)
{
if (this._cachedStar != null)
{
this.App.ReleaseObject((IGameObject)this._cachedStar);
this._cachedStar = (StarModel)null;
}
this._cachedStarReady = false;
this._cachedStar = Kerberos.Sots.GameStates.StarSystem.CreateStar(this.App, Vector3.Zero, systemInfo, 1f, false);
this._cachedStar.PostSetProp("AutoDraw", false);
}
public IActionResult Get(string name)
{
StarModel star = repo.GetStarByName(name);
if (star == null)
{
return(NotFound());
}
return(Ok(jconv.Convert(star)));
}
public StarModel Refine(StarModel starModel)
{
AddSurrogateKey(starModel.FactTable);
// Add surrogate keys to all dimensions
foreach (var dimension in starModel.Dimensions.Where(d => !d.HasKey()))
{
AddSurrogateKey(dimension);
}
return(starModel);
}
public StarModel Refine(StarModel starModel)
{
starModel.FactTable.RenameDuplicateColumns();
FormatFactTable(starModel.FactTable);
foreach (var dimension in starModel.Dimensions)
{
dimension.RenameDuplicateColumns();
FormatDimension(dimension);
}
return(starModel);
}
public bool jumpPlayerToStar(PlayerModel player, StarModel star)
{
if (player.currentNodeName == star.name)
{
return(false);
}
Message msg = new Message();
msg.body.Add("player", player);
msg.body.Add("star", star);
mainServer.Emit("jumpPlayerToStar", msg.ToJson());
return(true);
}
internal void New(int type)
{
_selectedStar = GameModel.Copy(_starsConfig.Stars[type]);
ConvertUnitsToSI();
_selectedStar.Name = "Star" + _galaxy.CreatedStars;
_selectedStar._AvailableElements = GenerateStarElements(_galaxy.CreatedStars + 1);
_selectedStar.PlanetsCount = RandomUtil.FromRangeInt(_starsConfig.MinPlanets, _starsConfig.MaxPlanets);
_selectedStar.PlanetsCount = 1;
_stars.Add(_selectedStar);
_galaxy.CreatedStars++;
GameModel.Set <StarModel>(_selectedStar);
}
public StarModel Refine(StarModel starModel)
{
FactTable fact = starModel.FactTable;
// Create new dimension
List <StarColumn> stringColumns = new List <StarColumn>();
if (fact.Columns.Count(x => x.DataType.IsString()) == 0)
{
return(starModel);
}
var surrogateKey = new StarColumn(1, "SurKey", new DataType(OleDbType.Integer), StarColumnType.Key | StarColumnType.SurrogateKey);
stringColumns.Add(surrogateKey);
var junkColumns = fact.Columns.Where(x => x.DataType.IsString()).Select(c => new JunkColumn(c));
stringColumns.AddRange(junkColumns);
JunkDimension dimension = new JunkDimension($"Junk_{fact.Name}", stringColumns, fact.TableReference);
surrogateKey.TableRef = dimension;
dimension.Constraints.PrimaryKey.Columns.Add(surrogateKey);
dimension.Constraints.Uniques.Add(new Unique(stringColumns));
// Fact relation to new dimension
var foreignColumn = new StarColumn(0, $"{dimension.Name}_Key", new DataType(OleDbType.Integer), StarColumnType.Key);
foreignColumn.TableRef = fact;
fact.Columns.Add(foreignColumn);
// Remove string columns from fact table
starModel.FactTable.Columns.RemoveAll(c => c.DataType.IsString());
StarRelation r = new StarRelation(dimension, starModel.FactTable, new List <StarColumn>()
{
surrogateKey
}, new List <StarColumn>()
{
foreignColumn
}, Cardinality.ManyToOne);
fact.Relations.Add(r);
dimension.Relations.Add(r);
starModel.Dimensions.Add(dimension);
return(starModel);
}
public void StarConvert()
{
Console.WriteLine("JSON Star Convert Test");
JSONConvert jconv = new JSONConvert();
StarModel star = repo.GetStarByName("Dubhe");
List <StarModel> stars = repo.GetAllStars();
Console.WriteLine(jconv.Convert(star));
Console.WriteLine(jconv.Convert(stars));
}
protected void OnPlayerLandOnStar(PlayerLandOnStarEvent e)
{
StarModel star = starService.GetStarByName(e.player.currentNodeName);
welcomeText.text = "Welcome to " + star.name;
if (e.player.homePlanetName == star.name)
{
hangerButton.gameObject.SetActive(true);
}
else
{
hangerButton.gameObject.SetActive(false);
}
}
public override StarModel TranslateModel(StarModel starModel)
{
//All fact tables across all star models
FactTable factTable = starModel.FactTable;
List <Dimension> temporaryDimensions = starModel.Dimensions;
// Case 1, if dimensions have been found, simply flatten them
// Case 2, if dimensions have *not* been found, find all connected tables to the fact table and flatten them.
// Case 2
if (temporaryDimensions.Count == 0)
{
List <Table> tables =
factTable.TableReference.Relations
.Where(x => factTable.TableReference == x.LinkTable && x.Cardinality == Cardinality.ManyToOne &&
x.AnchorTable != factTable.TableReference)
.Select(x => x.AnchorTable)
.ToList();
temporaryDimensions = tables.Select(table => new Dimension(table)).ToList();
}
// Case 1
foreach (var dim in temporaryDimensions)
{
var tableRef = dim.TableReference;
var newColumns = Flatten(tableRef, new List <Table>()
{
tableRef
});
dim.Columns.AddRange(newColumns);
dim.Columns.ForEach(x => x.TableRef = dim);
}
factTable.Relations.Clear();
// Add relations from fact table to all dimensions
foreach (var dimension in temporaryDimensions)
{
var starRelation = new StarRelation(dimension, factTable, Cardinality.ManyToOne);
factTable.Relations.Add(starRelation);
dimension.Relations.Add(starRelation);
}
starModel.Dimensions.AddRange(temporaryDimensions);
return(starModel);
}
private void DisplayBodyDetailsByType()
{
if (selectedBody != null)
{
if (selectedBody is StarModel)
{
StarModel star = (StarModel)selectedBody;
star.Update((double)sim.dt.JulianDay(), sim.GetLocationData());
detailsGUI.text = star.GetBodyDetails();
}
else
{
detailsGUI.text = selectedBody.GetBodyDetails();
}
}
}
public override void FindNewTarget(IEnumerable <IGameObject> objs)
{
this.m_SpaceBattle = true;
List <StellarBody> source = new List <StellarBody>();
List <MoonData> moonDataList = new List <MoonData>();
List <StarModel> starModelList = new List <StarModel>();
foreach (IGameObject gameObject in objs)
{
if (gameObject is StellarBody)
{
StellarBody stellarBody = gameObject as StellarBody;
source.Add(stellarBody);
this.m_SpaceBattle = false;
}
else if (gameObject is StarModel)
{
StarModel starModel = gameObject as StarModel;
starModelList.Add(starModel);
this.m_SpaceBattle = false;
}
}
foreach (StellarBody stellarBody in source)
{
foreach (OrbitalObjectInfo moon in this.m_Game.GameDatabase.GetMoons(stellarBody.Parameters.OrbitalID))
{
OrbitalObjectInfo ooi = moon;
moonDataList.Add(new MoonData()
{
ParentID = ooi.ParentID.Value,
Moon = source.First <StellarBody>((Func <StellarBody, bool>)(x => x.Parameters.OrbitalID == ooi.ID))
});
}
}
foreach (MoonData moonData in moonDataList)
{
source.Remove(moonData.Moon);
}
this.m_Planets = source;
this.m_Moons = moonDataList;
this.m_Stars = starModelList;
if (!this.m_SpaceBattle)
{
return;
}
this.m_State = SystemKillerStates.SPACEBATTLE;
}
public StarModel Refine(StarModel starModel)
{
// Order columns
FactTable fact = starModel.FactTable;
fact.Columns = fact.Columns.OrderByDescending(x => (short)x.ColumnType & 3).ThenBy(x => x.Name).ToList();
foreach (Dimension dim in starModel.Dimensions)
{
if (dim is TimeDimension || dim is DateDimension)
{
continue;
}
dim.Columns = dim.Columns.OrderByDescending(x => (short)x.ColumnType & 3).ThenBy(x => x.Name).ToList();
}
return(starModel);
}
public ShipDestinationInfo(StarModel star, Vector3 fstOffset) {
Target = star;
_fstOffset = fstOffset;
var shipOrbitSlot = (star as IShipOrbitable).ShipOrbitSlot;
_closeEnoughDistance = shipOrbitSlot.OuterRadius;
_progressCheckDistance = shipOrbitSlot.OuterRadius - shipOrbitSlot.InnerRadius;
}
// Use this for initialization
void Start()
{
gameManager = GameObject.FindGameObjectWithTag(Tags.GameManager).GetComponent<StarModel>();
soundController = GameObject.FindGameObjectWithTag(Tags.GameManager).GetComponent<SoundController>();
}
