// Use this for initialization
void Start()
{
var tr = transform;
data.canvas = GameObject.FindObjectOfType <Canvas>();
data.machine = GameObject.Find("machine");
data.progress = new Progress();
data.player = new Player();
float radius = 200;
// 左周り.
var left = new CircleData();
left.radius = radius;
left.list = new Rect[] {
new Rect(0, 0, radius, radius),
new Rect(radius, 0, radius, radius),
new Rect(radius, radius, radius, radius),
new Rect(0, radius, radius, radius),
};
left_ = left;
// 右回り.
var right = new CircleData();
right.radius = radius;
right.list = new Rect[] {
new Rect(0, 0, radius, radius),
new Rect(0, radius, radius, radius),
new Rect(radius, radius, radius, radius),
new Rect(radius, 0, radius, radius),
};
right_ = right;
}
public static void CheckCircle(CircleData c, Vector2 ipos)
{
c.preHitCount = c.hitCount;
var preIndex = c.hitIndex;
var offs = new Vector2(
(ScreenData.instance.exSize.x - c.radius * 2) * 0.5f,
(ScreenData.instance.exSize.y - c.radius * 2) * 0.5f
);
int index = ArrayHelper.FindIndex(c.list, ipos - offs, (_item, _prm) => {
return(_item.Contains(_prm));
});
c.hitIndex = index;
if (index == -1)
{
c.hitCount = 0;
return;
}
var diff = (index - preIndex + c.list.Length) % c.list.Length;
if (diff == 0)
{
// stay
}
else if (diff == 1)
{
c.hitCount++;
}
else
{
c.hitCount = 0;
}
}
private static Vector2 CreateCircleVertexVectorV2(CircleData circleData)
{
return(circleData.center +
circleData.radius *
new Vector2((float)Math.Cos(circleData.theta + circleData.increment),
(float)Math.Sin(circleData.theta + circleData.increment)));
}
public override void FromJson(Dictionary <string, Node> nodes, string data)
{
CircleData d = JsonConvert.DeserializeObject <CircleData>(data);
SetBaseNodeDate(d);
radius = d.radius;
outline = d.outline;
}
// Use this for initialization
void Start()
{
// da = GameObject.FindGameObjectWithTag("EditorOnly").GetComponent<RayCastF>();
da = Camera.main.GetComponent <CircleData>();
var spawnCircle = GameObject.Find("Quadri1");
sc = spawnCircle.GetComponent <SpawnCircle1>();
}
// Use this for initialization
void Start()
{
// da = GameObject.FindGameObjectWithTag("EditorOnly").GetComponent<RayCastF>();
da = Camera.main.GetComponent <CircleData>();
var spawnCircle = GameObject.Find("Quadri");
sc = spawnCircle.GetComponent <SpawnCircle>();
SceneManager.UnloadSceneAsync("CircleTest 1");
}
public CircleGetResult Get(CircleGetCommand command)
{
var id = new CircleId(command.Id);
var circle = circleRepository.Find(id);
var data = new CircleData(circle);
return(new CircleGetResult(data));
}
public void RemoveNextCircleData()
{
TurnLightOff();
if (_nextCircleDataOutput != null)
{
_nextCircleDataOutput.RemoveNextCircleData();
_nextCircleDataOutput = null;
}
}
public override string GetJson()
{
CircleData d = new CircleData();
FillBaseNodeData(d);
d.radius = radius;
d.outline = outline;
return(JsonConvert.SerializeObject(d));
}
public CircleData GetOuterCircle(Canvas c)
{
CircleData cd = new CircleData()
{
Centre = new Point(c.ActualWidth / 2, c.ActualHeight / 2)
};
cd.OuterRadius = (c.ActualWidth > c.ActualHeight) ? (c.ActualHeight / 2) * 0.9 : cd.OuterRadius = (c.ActualWidth / 2) * 0.9;
return(cd);
}
private bool _lockRotation; //allow rotation only on the drop location
void Start()
{
_startCollider = _collider.size;
_circleData = GetComponent <CircleData>();
_lockRotation = false;
_orignalParent = transform.parent;
_originalPosition = transform.localPosition;
_originalRotation = transform.localRotation.eulerAngles.z;
_puzzleCam = GameObject.Find("PuzzleThree").transform.GetChild(0).GetComponent <Camera>();
}
public void CheckSurrounding()
{
Direction missedHole = Direction.None;
foreach (Direction hole in _holeLocations)
{
Point targetPoint = DirectionExtensions.GetDirectionPoint(hole);
GameObject side = GridLevelManager.Instance.GetCircleData(targetPoint.X + GetPoint().X, targetPoint.Y + GetPoint().Y);
if (side != null)
{
CircleData sideData = side.GetComponent <CircleData>();
if (sideData != null)
{
if (sideData.MatchConnectingHole(hole))
{
if (sideData.LightOn())
{
sideData.SetNextCircleData(this);
TurnLightOn();
if (missedHole != Direction.None)
{
targetPoint = DirectionExtensions.GetDirectionPoint(missedHole);
side = GridLevelManager.Instance.GetCircleData(targetPoint.X + GetPoint().X, targetPoint.Y + GetPoint().Y);
sideData = side.GetComponent <CircleData>();
sideData.CheckSurrounding();
}
}
else if (LightOn())
{
sideData.CheckSurrounding();
}
else
{
missedHole = hole;
}
}
}
}
}
if (GridLevelManager.Instance.CheckWinTile(GetPoint()))
{
if (_lightUp)
{
foreach (Direction hole in _holeLocations)
{
if (GridLevelManager.Instance.DirectionFacingGoal(hole, GetPoint().X, GetPoint().Y))
{
GridLevelManager.Instance.ExecuteWin();
}
}
}
}
}
protected override ValidationResult ValidatePropsValues(IDictionary <string, double> figureProps)
{
var data = new CircleData
{
Radius = figureProps[CircleInfo.PropNames.Radius]
};
var validator = new CircleDataValidator();
return(validator.Validate(data));
}
public void SetData(CircleData data)
{
this.data = data;
if (spriteRenderer == null)
{
InitializeSprite(data.GetColor());
}
this.radius = data.GetRadius();
UpdateRadius();
UpdatePosition();
}
public override void FromJson(Dictionary <string, Node> nodes, string data)
{
CircleData d = JsonConvert.DeserializeObject <CircleData>(data);
SetBaseNodeDate(d);
radius = d.radius;
outline = d.outline;
SetConnections(nodes, d.outputs);
OnWidthHeightSet();
}
private void CheckCollisionWithWalls(CircleData circle, float deltaTime)
{
var position = circle.GetPosition();
var radius = circle.GetRadius();
var invertX = false;
var invertY = false;
float deltaX = 0;
float deltaY = 0;
if (position.x + radius > halfWidth)
{
invertX = true;
deltaX = halfWidth - position.x - radius;
}
else if (position.x - radius < -halfWidth)
{
invertX = true;
deltaX = -halfWidth - position.x + radius;
}
if (position.y + radius > halfHeight)
{
invertY = true;
deltaY = halfHeight - position.y - radius;
}
else if (position.y - radius < -halfHeight)
{
invertY = true;
deltaY = -halfHeight - position.y + radius;
}
float updateTimeX = 0;
float updateTimeY = 0;
var speed = circle.GetSpeed();
if (invertX)
{
updateTimeX = deltaX / speed.x;
}
if (invertY)
{
updateTimeY = deltaY / speed.y;
}
if (invertX || invertY)
{
var updateTime = Mathf.Min(updateTimeX, updateTimeY);
circle.UpdatePosition(updateTime);
circle.InvertSpeed(invertX, invertY);
circle.UpdatePosition(-updateTime);
}
}
//Save data
public void Save()
{
man = GetComponent <GridManager>();
foreach (GameObject obj in man.circles)
{
data = GetComponent <CircleData>();
data.circlename = obj.name;
data.color = obj.GetComponent <Renderer>().material.color;
data.coordinate = obj.GetComponent <Transform>().position;
string json = JsonUtility.ToJson(data);
WriteToFile(json);
}
}
private static CircleData CreateCircleData(CircleShape circle, Transform xf)
{
var circleData = new CircleData
{
center = MathUtils.Mul(ref xf, circle.Position),
radius = circle.Radius,
segments = CircleSegments,
increment = Math.PI * 2.0 / 32,
theta = 0.0
};
return(circleData);
}
public Task <CircleGetOutputData> Handle(CircleGetCommand command, CancellationToken cancellationToken)
{
var data = _circleRepository.Find(new CircleId(command.Id));
if (data is null)
{
throw new CircleNotFoundException($"IDが { command.Id } のサークルが見つかりませんでした");
}
var circle = new CircleData(data.Id.Value, data.Name.Value, data.Owner.Value, data.Members.Select(x => x.Value).ToList());
return(Task.FromResult(new CircleGetOutputData(circle)));
}
private void mAsyncChange(bool create)
{
if (!create && mIndexPacge == 0)
{
return;
}
if (create)
{
List <CircleData> end = mBuffs[mIndexs[mIndexs.Count - 1]];
var newDataList = new List <CircleData>();
mBuffs[mIndexs.Count] = newDataList;
mIndexs.Add(mIndexs.Count);
for (int i = 0; i < end.Count; i++)
{
var cd = end[i];
CircleData newCD = null;
int realIndex = GetIndex(mIndexPacge, i, true);
mGroupTransform.Add(1);
if (mTempObject.Count > realIndex)
{
newCD = mTempObject[realIndex];
}
else
{
//GameObject clone = SceneManager.CloneObject(cd.go);
GameObject clone = mGroupTransform.Last.gameObject;
clone.transform.position = cd.go.transform.position + mWorldSzie;
newCD = new CircleData();
newCD.go = clone;
mTempObject.Add(newCD);
}
newDataList.Add(newCD);
if (SentEvent(newCD, realIndex))
{
newCD.go.SetActive(true);
}
else
{
newCD.go.SetActive(false);
}
}
mIndexs[0]++;
mIndexPacge += 1;
}
}
public CircleGetOutputData Handle(CircleGetInputData inputData)
{
var id = new CircleId(inputData.Id);
var circle = circleRepository.Find(id);
var data = new CircleData(
circle.Id.Value,
circle.Name.Value,
circle.Owner?.Value,
circle.Members.Select(x => x.Value).ToList()
);
return(new CircleGetOutputData(data));
}
private Vector2D[] CreateCircleVertexArray(CircleData circleData)
{
var vertices = new List <Vector2D>();
for (int i = 0; i < circleData.segments; i++)
{
Vector2 v1 = CreateCircleVertexVectorV1(circleData);
Vector2 v2 = CreateCircleVertexVectorV2(circleData);
vertices.Add(UnitConverter.Convert(UnitConverter.ToDisplayUnits(v1)));
vertices.Add(UnitConverter.Convert(UnitConverter.ToDisplayUnits(v2)));
circleData.theta += circleData.increment;
}
return(vertices.ToArray());
}
public void DrawColourWheel()
{
if (WheelCanvas == null)
{
return;
}
WheelCanvas.Children.Clear();
CircleData cd = GetOuterCircle(WheelCanvas);
Brush[] rainbow = { Brushes.Red, Brushes.Orange, Brushes.Yellow, Brushes.Green, Brushes.Blue, Brushes.Indigo, Brushes.Violet };
int numSegments = NumSegmentsBox.Value.HasValue ? NumSegmentsBox.Value.Value : 12;
int numCircles = NumCirclesBox.Value.HasValue ? NumCirclesBox.Value.Value : 3;
var endColors = SetColourRange(numSegments);
int wheelWidth = WheelWidth.Value.HasValue ? WheelWidth.Value.Value : 100;
double startingRadius = cd.OuterRadius;
double endingRadius = Math.Max(cd.OuterRadius - wheelWidth, 1);
double radiusChange = (startingRadius - endingRadius) / numCircles;
double sweep = (360.0 / numSegments);
for (int j = 0; j < numCircles; ++j)
{
double outerRadius = startingRadius - j * radiusChange;
double innerRadius = outerRadius - radiusChange;
CircleData thisWheel = new CircleData
{
OuterRadius = outerRadius,
InnerRadius = innerRadius,
Centre = cd.Centre
};
double circleLuminosity = numCircles == 1?0.5:(((double)j + 1) / numCircles) * .9;
Color startColour = new HSLColor(endColors.Item1.Hue, 1, circleLuminosity);
double endColourHue = (double)(numSegments - 1) / numSegments;
Color endColour = new HSLColor(endColors.Item2.Hue, 1, circleLuminosity);
for (int i = 0; i < numSegments; ++i)
{
double start = (360.0 / numSegments) * i;
SolidColorBrush brush = new SolidColorBrush(IntepolateHSV(startColour, endColour, (double)i / numSegments));
WheelCanvas.Children.Add(CreateWheelSegment(thisWheel, start, sweep, brush, false, UseStraightEdges.IsChecked.HasValue?UseStraightEdges.IsChecked.Value:false));
}
}
}
public void Create(OpenGL GL, string texPath, GShaderProgram shader)
{
CircleData c = DrawCircle(0f, 0f, 1f, _numSegments);
vec3[] points = c.points;
vec3[] normals = new vec3[points.Length];
vec2[] texCord = c.texture;
for (int i = 0; i < normals.Length; i++)
{
normals[i] = new vec3(0.0f, 0.0f, -1.0f);
}
if (texPath == null || texPath == "")
{
_textureName = C_DUMMY_TEXTURE;
TextureManager.Instance.CreateTexture1x1(C_DUMMY_TEXTURE, GL, false, Color.Blue);
}
else
{
_textureName = texPath;
TextureManager.Instance.CreateTexture(texPath, GL, false);
}
compassVAO = new VertexBufferArray();
compassVAO.Create(GL);
compassVAO.Bind(GL);
VertexBuffer[] cVBO = new VertexBuffer[3];
cVBO[0] = new VertexBuffer();
cVBO[0].Create(GL);
cVBO[0].Bind(GL);
cVBO[0].SetData(GL, (uint)shader.GetAttributeID(GL, "vPosition"), points, false, 3);
// Texture
cVBO[1] = new VertexBuffer();
cVBO[1].Create(GL);
cVBO[1].Bind(GL);
cVBO[1].SetData(GL, (uint)shader.GetAttributeID(GL, "vTextureCoord"), texCord, false, 2);
// Normals
cVBO[2] = new VertexBuffer();
cVBO[2].Create(GL);
cVBO[2].Bind(GL);
cVBO[2].SetData(GL, (uint)shader.GetAttributeID(GL, "vSurfaceNormal"), normals, false, 3);
compassVAO.Unbind(GL);
}
public CircleData CalculateAverageCircle(CircleData cFrom, CircleData cTo, float factor)
{
return(new CircleData()
{
X = cFrom.X + (cTo.X - cFrom.X) * factor,
Y = cFrom.Y + (cTo.Y - cFrom.Y) * factor,
Radius = Convert.ToInt32(cFrom.Radius + (cTo.Radius - cFrom.Radius) * factor),
Segments = Convert.ToInt32(cFrom.Segments + (cTo.Segments - cFrom.Segments) * factor),
R1 = Convert.ToByte(cFrom.R1 + (cTo.R1 - cFrom.R1) * factor),
G1 = Convert.ToByte(cFrom.G1 + (cTo.G1 - cFrom.G1) * factor),
B1 = Convert.ToByte(cFrom.B1 + (cTo.B1 - cFrom.B1) * factor),
R2 = Convert.ToByte(cFrom.R2 + (cTo.R2 - cFrom.R2) * factor),
G2 = Convert.ToByte(cFrom.G2 + (cTo.G2 - cFrom.G2) * factor),
B2 = Convert.ToByte(cFrom.B2 + (cTo.B2 - cFrom.B2) * factor),
});
}
public bool SpawnCircle(CircleData circle)
{
var circlePosition = circle.GetPosition();
var circleRadius = circle.GetRadius();
foreach (var circleOnField in circles)
{
var minDistance = circleRadius + circleOnField.GetRadius();
var distance = (circlePosition - circleOnField.GetPosition()).magnitude;
if (minDistance > distance)
{
return(false);
}
}
circles.Add(circle);
return(true);
}
private bool SentEvent(CircleData go, int i)
{
if (mLoop)
{
i = i < 0?((mCurNum - Mathf.Abs(i) % mCurNum) % mCurNum):(i % mCurNum);
}
go.index = i;
if (mAutoLen && mCurNum <= i)
{
return(false);
}
if (mCallEvent != null)
{
return(mCallEvent(i, go));
}
return(true);
}
private void UpdateScale()
{
InitializeTransform();
InitializeEffect();
if (fSpriteBatch == null)
{
return;
}
int maxLines = 1000000;
fLines = new DynamicPrimitiveLine(fSpriteBatch.GraphicsDevice);
CircleData circleTo = CreateRandomCircle();
CircleData circleFrom = null;
int currentStep = 0;
int maxSteps = 0;
while (fLines.Lines < maxLines)
{
CircleData currentCircle;
currentStep++;
if (currentStep >= maxSteps)
{
circleFrom = circleTo;
circleTo = CreateRandomCircle();
currentStep = 0;
maxSteps = fRandom.Next(200) + 1;
currentCircle = circleFrom;
}
else
{
float f = Convert.ToSingle(currentStep) / maxSteps;
currentCircle = CalculateAverageCircle(circleFrom, circleTo, f);
}
Color c1 = new Color(currentCircle.R1, currentCircle.G1, currentCircle.B1, (byte)255);
Color c2 = new Color(currentCircle.R2, currentCircle.G2, currentCircle.B2, (byte)255);
fLines.AddCircle(currentCircle.X, currentCircle.Y, 0,
currentCircle.Radius, currentCircle.Radius,
currentCircle.Segments, c1, c2);
}
}
CircleData DrawCircle(float cx, float cy, float r, int num_segments)
{
CircleData c = new CircleData();
vec3[] circle_v = new vec3[num_segments];
vec2[] cTex = new vec2[num_segments];
for (int ii = 0; ii < num_segments; ii++)
{
float theta = 2.0f * 3.1415926f * ii / num_segments; //get the current angle
circle_v[ii].x = r * (float)Math.Cos(theta); //calculate the x component
circle_v[ii].y = r * (float)Math.Sin(theta); //calculate the y component
// Texture coordinates - (0,0) on circle must map to (0.5,0.5) texture and (1,1) maps to (1,1)..
cTex[ii].x = (float)Math.Cos(theta) * 0.5f + 0.5f;
cTex[ii].y = (float)Math.Sin(theta) * 0.5f + 0.5f;
}
c.points = circle_v;
c.texture = cTex;
return(c);
}
public static bool CalculateCircle(
Vector2 p0,
Vector2 p1,
Vector2 p2,
out Vector2 center,
out float radius
)
{
center = Vector2.zero;
radius = 0f;
try {
CircleData cd = findCircle2(p0, p1, p2);
if (cd.center == p0)
{
return(false);
}
center = cd.center;
radius = cd.radius;
}catch {
return(false);
}
return(true);
}
private Vector2D[] CreateCircleVertexArray(CircleData circleData)
{
var vertices = new List<Vector2D>();
for (int i = 0; i < circleData.segments; i++)
{
Vector2 v1 = CreateCircleVertexVectorV1(circleData);
Vector2 v2 = CreateCircleVertexVectorV2(circleData);
vertices.Add(UnitConverter.Convert(UnitConverter.ToDisplayUnits(v1)));
vertices.Add(UnitConverter.Convert(UnitConverter.ToDisplayUnits(v2)));
circleData.theta += circleData.increment;
}
return vertices.ToArray();
}
private static Vector2 CreateCircleVertexVectorV2(CircleData circleData)
{
return circleData.center +
circleData.radius *
new Vector2((float)Math.Cos(circleData.theta + circleData.increment),
(float)Math.Sin(circleData.theta + circleData.increment));
}
private static CircleData CreateCircleData(CircleShape circle, Transform xf)
{
var circleData = new CircleData
{
center = MathUtils.Mul(ref xf, circle.Position),
radius = circle.Radius,
segments = CircleSegments,
increment = Math.PI * 2.0 / 32,
theta = 0.0
};
return circleData;
}
