bool GameObject::tileCollisions(Vector2D pos){
for(vector<TileLayer*>::iterator i = collisionLayers->begin(); i != collisionLayers->end(); i++){
TileLayer* tileLayer = (*i);
vector<vector<int>> tiles = tileLayer->getTileIDs();
Vector2D layerPos = tileLayer->getPosition();
int x, y, tileColumn, tileRow, tileid = 0;
x = layerPos.X() / tileLayer->getTileSize();
y = layerPos.Y() / tileLayer->getTileSize();
Vector2D startPos = pos;
startPos.setX( startPos.X() + 3);
startPos.setY( startPos.Y() + 4);
Vector2D endPos(pos.X() + collisionWidth, pos.Y() + collisionHeight - 4);
for(int i = startPos.X(); i < endPos.X(); i++) {
for(int j = startPos.Y(); j < endPos.Y(); j++) {
tileColumn = i / tileLayer->getTileSize();
tileRow = j / tileLayer->getTileSize();
tileid = tiles[tileRow + y][tileColumn + x];
if(tileid != 0) {
return true;
}
}
}
}
return false;
}
void ANCFBeamBE2D::GetdPosdqT(const Vector2D& p_loc, Matrix& dpdqi)
{
//p = S(p.x,p.y,p.z)*q; d(p)/dq
dpdqi.SetSize(SOS(),Dim());
dpdqi.FillWithZeros();
//d = S + ...
for (int i = 1; i <= NS(); i++)
{
double s = GetS0(p_loc.X(), i);
dpdqi((i-1)*Dim()+1,1) = s;
dpdqi((i-1)*Dim()+2,2) = s;
}
if (p_loc.Y() != 0)
{
double y = p_loc.Y();
Vector2D rx = GetPosx2D(p_loc.X());
Vector2D n(-rx.X(), rx.Y());
n /= rx.Norm();
for (int i = 1; i <= NS(); i++)
{
double sx = GetS0x(p_loc.X(), i) * 2./GetLx();
//y/|n|*dn/dq
dpdqi((i-1)*Dim()+1,2) += y*sx;
dpdqi((i-1)*Dim()+2,1) += -y*sx;
//y*n/|n|*(r_x1*S_x1 + r_x2*S_x2)
dpdqi((i-1)*Dim()+1,1) += y*n.X()*(rx.X()*sx);
dpdqi((i-1)*Dim()+1,2) += y*n.Y()*(rx.X()*sx);
dpdqi((i-1)*Dim()+2,1) += y*n.X()*(rx.Y()*sx);
dpdqi((i-1)*Dim()+2,2) += y*n.Y()*(rx.Y()*sx);
}
}
};
int SplineCurve::GetPoints(std::vector<float> &points) const {
switch (type) {
case POINT:
points.push_back(p1.X());
points.push_back(p1.Y());
return 1;
case LINE:
points.push_back(p2.X());
points.push_back(p2.Y());
return 1;
case BICUBIC: {
int len = int(
(p2 - p1).Len() +
(p3 - p2).Len() +
(p4 - p3).Len());
int steps = len/8;
for (int i = 0; i <= steps; ++i) {
// Get t and t-1 (u)
float t = i / float(steps);
Vector2D p = GetPoint(t);
points.push_back(p.X());
points.push_back(p.Y());
}
return steps + 1;
}
default:
return 0;
}
}
int ReferenceFrame2D::GetNode(Vector2D p_loc) const
{
double tol = 1e-8*GetMBS()->CharacteristicLength();
/*
for (int i = 1; i <=nodes.Length(); i++)
{
if (Dist(p_loc,nodes(i)->Pos2D()) <= tol) return i;
}
GetMBS()->UO() << "ERROR: node not found:" << p_loc << " !!!\n";
return 0;
*/
IVector items;
Vector3D p(p_loc.X(),p_loc.Y(),0.);
Box3D box(p, p);
box.Increase(tol);
searchtree.GetItemsInBox(box,items);
for (int i = 1; i <= items.Length(); i++)
{
Vector3D p2(nodes(items(i))->Pos().X(), nodes(items(i))->Pos().Y(), 0.);
if (Dist(p,p2) <= tol) return items(i);
}
GetMBS()->UO() << "ERROR: node not found:" << p_loc << " !!!\n";
return 0;
}
Vector2D Board::GetDynamicSize() {
double width = 1;
double height = 1;
RelativeCell relCell = GetRelativeCellAt(Vector2D(0,0));
Vector2D topLeft = relCell.GetAbsolutePosition();
int x1 = 0;
int x2 = 0;
int y1 = 0;
int y2 = 0;
for (double i = 0; i < 20; i++) {
for (double j = 0; j < 20; j++) {
if ((GetAbsoluteCellAt(Vector2D((int)(i + topLeft.X()) % 20, (int)(j + topLeft.Y()) % 20))->GetData() & HasTile) == HasTile) {
if (x2 < i) {
x2 = (int)i;
}
if (y2 < j) {
y2 = (int)j;
}
}
}
}
return Vector2D(x2 - x1, y2 - y1);
}
void VisualToolScale::UpdateHold() {
Vector2D delta = (mouse_pos - drag_start) * Vector2D(1, -1);
if (shift_down)
delta = delta.SingleAxis();
if (alt_down) {
if (abs(delta.X()) > abs(delta.Y()))
delta = Vector2D(delta.X(), delta.X() * (initial_scale.Y() / initial_scale.X()));
else
delta = Vector2D(delta.Y() * (initial_scale.X() / initial_scale.Y()), delta.Y());
}
scale = Vector2D(0, 0).Max(delta * 1.25f + initial_scale);
if (ctrl_down)
scale = scale.Round(25.f);
SetSelectedOverride("\\fscx", std::to_string((int)scale.X()));
SetSelectedOverride("\\fscy", std::to_string((int)scale.Y()));
}
double ANCFBeamBE2D::GetS0xx(const Vector2D& p_loc, int shape) const
{
double x = p_loc.X();
switch (shape)
{
case 1: return 0.25*( + 15.*x - 15.*x*x*x);
case 2: return 0.25*(-3. + 15.*x + 3.*x*x - 15.*x*x*x);
case 3: return 0.25*(-1. + 3.*x + 3.*x*x - 5.*x*x*x);
case 4: return 0.25*( - 15.*x + 15.*x*x*x);
case 5: return 0.25*( 3. + 15.*x - 3.*x*x - 15.*x*x*x);
case 6: return 0.25*(-1. - 3.*x + 3.*x*x + 5.*x*x*x);
default: mbs->UO() << "ANCFBeamBE2D::GetS0xx Error: Shape function " << shape << " not available!\n"; return 0;
}
};
double ANCFBeamBE2D::GetS0(const Vector2D& p_loc, int shape) const
{
double x = p_loc.X();
switch (shape)
{
case 1: return 0.125*( 4. - 7.5*x + 5.*x*x*x - 1.5*x*x*x*x*x);
case 2: return 0.125*( 2.5 - 3.5*x - 3.*x*x + 5.*x*x*x + 0.5*x*x*x*x - 1.5*x*x*x*x*x);
case 3: return 0.125*( 0.5 - 0.5*x - 1.*x*x + 1.*x*x*x + 0.5*x*x*x*x - 0.5*x*x*x*x*x);
case 4: return 0.125*( 4. + 7.5*x - 5.*x*x*x + 1.5*x*x*x*x*x);
case 5: return 0.125*(-2.5 - 3.5*x + 3.*x*x + 5.*x*x*x - 0.5*x*x*x*x - 1.5*x*x*x*x*x);
case 6: return 0.125*( 0.5 + 0.5*x - 1.*x*x - 1.*x*x*x + 0.5*x*x*x*x + 0.5*x*x*x*x*x);
default: mbs->UO() << "ANCFBeamBE2D::GetS0 Error: Shape function " << shape << " not available!\n"; return 0;
}
};
double ANCFBeamBE2D::GetS0x(const Vector2D& p_loc, int shape) const
{
double x = p_loc.X();
switch (shape)
{
case 1: return 0.125*(-7.5 + 15.*x*x - 7.5*x*x*x*x);
case 2: return 0.125*(-3.5 - 6.*x + 15.*x*x + 2.*x*x*x - 7.5*x*x*x*x);
case 3: return 0.125*(-0.5 - 2.*x + 3.*x*x + 2.*x*x*x - 2.5*x*x*x*x);
case 4: return 0.125*( 7.5 - 15.*x*x + 7.5*x*x*x*x);
case 5: return 0.125*(-3.5 + 6.*x + 15.*x*x - 2.*x*x*x - 7.5*x*x*x*x);
case 6: return 0.125*( 0.5 - 2.*x - 3.*x*x + 2.*x*x*x + 2.5*x*x*x*x);
default: mbs->UO() << "ANCFBeamBE2D::GetS0x Error: Shape function " << shape << " not available!\n"; return 0;
}
};
void Camera::Update(double milisec) {
double elapsed = milisec / 1000;
double camFix2 = 200 * (_player->GetVelocity()->X() * 0.0015);
_camFix = _camFix + (camFix2 - _camFix) * (3 * elapsed);
_position.X(
_position.X() +
(
(_player->GetPosition().X() - _position.X()
) + _camFix) * (4 * elapsed)
);
_position.Y(
_position.Y() + (
_player->GetPosition().Y() - _position.Y()
) * (4 * elapsed)
);
Vector2D fix = ((AbstractWindow::WindowSize - Player::InitSize) * Vector2D(1.0,1.35)) / Vector2D(2);
Vector2D fix2 = GridGraphicTranslator().FromTo(*_grid->GetSize()) - AbstractWindow::WindowSize;
fix2 += fix;
if (_position.Y() > fix2.Y()) {
_position.Y(fix2.Y());
}
if (_position.X() > fix2.X()) {
_position.X(fix2.X());
}
if (_position.Y() < fix.Y()) {
_position.Y(fix.Y());
}
if (_position.X() < fix.X()) {
_position.X(fix.X());
}
}
void Quadrilateral::GetDSMatrix0(const Vector2D& ploc, Matrix& sf) const
{
double r = ploc.X();
double s = ploc.Y();
if(NNodes() == 4)
{
sf.SetSize(Dim(),NS());
//D_sf/D_r :
sf(1,1) = 0.25*(1+s); //Node 1
sf(1,2) =-0.25*(1+s); //Node 2
sf(1,3) =-0.25*(1-s); //Node 3
sf(1,4) = 0.25*(1-s); //Node 4
//D_sf/D_s :
sf(2,1) = 0.25*(1+r); //Node 1
sf(2,2) = 0.25*(1-r); //Node 2
sf(2,3) =-0.25*(1-r); //Node 3
sf(2,4) =-0.25*(1+r); //Node 4
}
else
{
double r2 = r*r;
double s2 = s*s;
//D_sf/D_r:
sf(1,1) = s/4.0+r*s/2.0+s2*r/2.0+s2/4.0;
sf(1,2) = -s/4.0+r*s/2.0+s2*r/2.0-s2/4.0;
sf(1,3) = s/4.0-s2/4.0+s2*r/2.0-r*s/2.0;
sf(1,4) = -s/4.0-r*s/2.0+s2*r/2.0+s2/4.0;
sf(1,5) = -r*s-s2*r;
sf(1,6) = -1.0/2.0+s2/2.0+r-s2*r;
sf(1,7) = r*s-s2*r;
sf(1,8) = 1.0/2.0-s2/2.0+r-s2*r;
sf(1,9) = 2.0*r*(-1.0+s2);
//D_sf/D_s:
sf(2,1) = r/4.0+r2/4.0+r2*s/2.0+r*s/2.0;
sf(2,2) = -r/4.0+r2/4.0+r2*s/2.0-r*s/2.0;
sf(2,3) = r/4.0-r*s/2.0+r2*s/2.0-r2/4.0;
sf(2,4) = -r/4.0-r2/4.0+r2*s/2.0+r*s/2.0;
sf(2,5) = 1.0/2.0-r2/2.0+s-r2*s;
sf(2,6) = r*s-r2*s;
sf(2,7) = -1.0/2.0+r2/2.0+s-r2*s;
sf(2,8) = -r*s-r2*s;
sf(2,9) = 2.0*(-1.0+r2)*s;
}
}
void VisualToolRotateXY::UpdateHold() {
Vector2D delta = (mouse_pos - drag_start) * 2;
if (shift_down)
delta = delta.SingleAxis();
angle_x = orig_x - delta.Y();
angle_y = orig_y + delta.X();
if (ctrl_down) {
angle_x = floorf(angle_x / 30.f + .5f) * 30.f;
angle_y = floorf(angle_y / 30.f + .5f) * 30.f;
}
angle_x = fmodf(angle_x + 360.f, 360.f);
angle_y = fmodf(angle_y + 360.f, 360.f);
SetSelectedOverride("\\frx", str(boost::format("%.4g") % angle_x));
SetSelectedOverride("\\fry", str(boost::format("%.4g") % angle_y));
}
Move Board::ShiftMoveBack(const Move& move){
// no used cell means there is no shifting necisary
if(!move.HasUsedCell()){
return move;
}
Vector2D from = move.GetFromCell();
Vector2D to = move.GetToCell();
Vector2D used = move.GetUsedCell();
Vector2D correction = _converter->CalcShiftCorrection(to, used);
if(used.X() == 0 && (_grid->GetCellAt(_converter->ToAbsolute(used + correction))->GetData() & HasTile)){
correction -= Vector2D(1, 0);
}
if(used.Y() == 0 && (_grid->GetCellAt(_converter->ToAbsolute(used + correction))->GetData() & HasTile)){
correction -= Vector2D(0, 1);
}
from += correction;
to += correction;
used += correction;
return Move(move.GetMoveType(), from, to, used);
}
void VisualToolDrag::Draw() {
DrawAllFeatures();
// Draw connecting lines
for (feature_iterator cur = features.begin(); cur != features.end(); ++cur) {
if (cur->type == DRAG_START) continue;
feature_iterator p2 = cur;
feature_iterator p1 = cur->parent;
// Move end marker has an arrow; origin doesn't
bool has_arrow = p2->type == DRAG_END;
int arrow_len = has_arrow ? 10 : 0;
// Don't show the connecting line if the features are very close
Vector2D direction = p2->pos - p1->pos;
if (direction.SquareLen() < (20 + arrow_len) * (20 + arrow_len)) continue;
direction = direction.Unit();
// Get the start and end points of the line
Vector2D start = p1->pos + direction * 10;
Vector2D end = p2->pos - direction * (10 + arrow_len);
if (has_arrow) {
gl.SetLineColour(colour[3], 0.8f, 2);
// Arrow line
gl.DrawLine(start, end);
// Arrow head
Vector2D t_half_base_w = Vector2D(-direction.Y(), direction.X()) * 4;
gl.DrawTriangle(end + direction * arrow_len, end + t_half_base_w, end - t_half_base_w);
}
// Draw dashed line
else {
gl.SetLineColour(colour[3], 0.5f, 2);
gl.DrawDashedLine(start, end, 6);
}
}
}
double Quadrilateral::GetS0(const Vector2D& ploc, int shape) const
{
// nodes are always sorted counterclock-wise in x-y (r-s) plane
double r = ploc.X();
double s = ploc.Y();
if(NNodes() == 4)
{
switch(shape)
{
case 1: return 0.25*(1+r)*(1+s);
case 2: return 0.25*(1-r)*(1+s);
case 3: return 0.25*(1-r)*(1-s);
case 4: return 0.25*(1+r)*(1-s);
}
}
else
{
double r2 = r*r;
double s2 = s*s;
switch(shape)
{
case 1: return r*s/4.0+r2*s/4.0+r2*s2/4.0+s2*r/4.0;
case 2: return -r*s/4.0+r2*s/4.0+r2*s2/4.0-s2*r/4.0;
case 3: return r*s/4.0-s2*r/4.0+r2*s2/4.0-r2*s/4.0;
case 4: return -r*s/4.0-r2*s/4.0+r2*s2/4.0+s2*r/4.0;
case 5: return s/2.0-r2*s/2.0+s2/2.0-r2*s2/2.0;
case 6: return -r/2.0+s2*r/2.0+r2/2.0-r2*s2/2.0;
case 7: return -s/2.0+r2*s/2.0+s2/2.0-r2*s2/2.0;
case 8: return r/2.0-s2*r/2.0+r2/2.0-r2*s2/2.0;
case 9: return (-1.0+r2)*(-1.0+s2);
}
}
assert(0);
return 0;
}
void VideoDisplay::DrawOverscanMask(float horizontal_percent, float vertical_percent) const {
Vector2D v(viewport_width, viewport_height);
Vector2D size = Vector2D(horizontal_percent, vertical_percent) / 2 * v;
// Clockwise from top-left
Vector2D corners[] = {
size,
Vector2D(viewport_width - size.X(), size),
v - size,
Vector2D(size, viewport_height - size.Y())
};
// Shift to compensate for black bars
Vector2D pos(viewport_left, viewport_top);
for (auto& corner : corners)
corner = corner + pos;
int count = 0;
std::vector<float> points;
for (size_t i = 0; i < 4; ++i) {
size_t prev = (i + 3) % 4;
size_t next = (i + 1) % 4;
count += SplineCurve(
(corners[prev] + corners[i] * 4) / 5,
corners[i], corners[i],
(corners[next] + corners[i] * 4) / 5)
.GetPoints(points);
}
OpenGLWrapper gl;
gl.SetFillColour(wxColor(30, 70, 200), .5f);
gl.SetLineColour(*wxBLACK, 0, 1);
std::vector<int> vstart(1, 0);
std::vector<int> vcount(1, count);
gl.DrawMultiPolygon(points, vstart, vcount, Vector2D(viewport_left, viewport_top), Vector2D(viewport_width, viewport_height), true);
}
void OpenGLWrapper::SetOrigin(Vector2D origin) {
PrepareTransform();
glTranslatef(origin.X(), origin.Y(), -1.f);
}
int ZobristHashing::GetCellPosition(const Vector2D& position) {
return (int)position.Y() * 20 + (int)position.X();
}
#include <cmath>
#include <cfloat>
#include <ne2d/math/Vector2D.hpp>
#include <ne2d/utility/FloatComparison.hpp>
using namespace std;
using namespace ne;
using namespace ne::math;
using namespace ne::utility;
TESTCASE_GROUP_BEGIN
TESTCASE("Constructor test") {
Vector2D vec;
CHECK(vec.X() == 0.0f);
CHECK(vec.Y() == 0.0f);
CHECK(vec.Z() == 1.0f);
vec = Vector2D(1.0f, 2.0f);
CHECK(vec.X() == 1.0f);
CHECK(vec.Y() == 2.0f);
CHECK(vec.Z() == 1.0f);
vec = { 3.0f, 4.0f };
CHECK(vec.X() == 3.0f);
CHECK(vec.Y() == 4.0f);
CHECK(vec.Z() == 1.0f);
}
TESTCASE_END
Vector2D operator *(float f, Vector2D v) {
return Vector2D(v.X() * f, v.Y() * f);
}
Vector2D operator /(float f, Vector2D v) {
return Vector2D(f / v.X(), f / v.Y());
}
void Set(size_t i, Vector2D p) {
data[i * dim] = p.X();
data[i * dim + 1] = p.Y();
}
void OpenGLWrapper::DrawEllipse(Vector2D center, Vector2D radius) const {
DrawRing(center, radius.Y(), radius.Y(), radius.X() / radius.Y());
}
Vector2D operator +(float f, Vector2D v) {
return Vector2D(v.X() + f, v.Y() + f);
}
Vector2D operator -(float f, Vector2D v) {
return Vector2D(f - v.X(), f - v.Y());
}
void OpenGLWrapper::SetScale(Vector2D scale) {
PrepareTransform();
glScalef(scale.X() / 100.f, scale.Y() / 100.f, 1.f);
}
