Beispiel #1
0
        /// <summary>
        /// Returns whether the EntityAIBase should begin execution.
        /// </summary>
        public override bool ShouldExecute()
        {
            TargetEntity = TheEntity.GetAttackTarget();

            if (TargetEntity == null)
            {
                return(false);
            }

            if (TargetEntity.GetDistanceSqToEntity(TheEntity) > (double)(Field_48331_g * Field_48331_g))
            {
                return(false);
            }

            Vec3D vec3d = RandomPositionGenerator.Func_48620_a(TheEntity, 16, 7, Vec3D.CreateVector(TargetEntity.PosX, TargetEntity.PosY, TargetEntity.PosZ));

            if (vec3d == null)
            {
                return(false);
            }
            else
            {
                MovePosX = vec3d.XCoord;
                MovePosY = vec3d.YCoord;
                MovePosZ = vec3d.ZCoord;
                return(true);
            }
        }
Beispiel #2
0
        /// <summary>
        /// Creates a box from a bottom left and top right point. It is an
        /// error if the min has any coordinate greater the maximum point.
        /// </summary>
        /// <param name="min">The bottom left point.</param>
        /// <param name="max">The top right point.</param>
        public BoundingBox3D(Vec3D min, Vec3D max)
        {
            Debug.Assert(min.X <= max.X && min.Y <= max.Y && min.Z <= max.Z, "Box3D min >= max");

            Min = min;
            Max = max;
        }
Beispiel #3
0
        static public Double Distance(LocationValue l1, LocationValue l2)
        {
            Vec3D v1 = new Vec3D(l1);
            Vec3D v2 = new Vec3D(l2);

            return(v1.ScalerDistanceTo(v2));
        }
Beispiel #4
0
        public static void UpdateObjectLocation(String objID, Vec3D loc)
        {
            if (_objectLocations.ContainsKey(objID))
            {
                _objectLocations[objID].X = loc.X;
                _objectLocations[objID].Y = loc.Y;
                _objectLocations[objID].Z = loc.Z;
            }
            else
            {
                _objectLocations.Add(objID, new Vec3D(loc));
            }
            double dist;

            foreach (String o in _objectLocations.Keys)
            {
                if (o == objID)
                {
                    continue;
                }
                dist = _objectLocations[o].ScalerDistanceTo(loc);
                SetScalarDistanceBetweenTwoObjects(o, objID, dist);
            }
            UpdateOthersForNewLocation(objID);
            UpdateObjectsInSensorRange(objID); //might be a bit expensive to do this often
        }
Beispiel #5
0
    private Vec3D PositionPBC(Vec3D v)
    {
        var x = v.x;
        var y = v.y;
        var z = v.z;

        if (x > 1)
        {
            x = x - 2;
        }
        else if (x < -1)
        {
            x = x + 2;
        }

        if (y > 1)
        {
            y = y - 2;
        }
        else if (y < -1)
        {
            y = y + 2;
        }

        if (z > 1)
        {
            z = z - 2;
        }
        else if (z < -1)
        {
            z = z + 2;
        }

        return(new Vec3D(x, y, z));
    }
Beispiel #6
0
        static public VelocityValue ComputeVelocityVector(LocationValue start, LocationValue dest, Double maxSpeed, Double throttle)
        {
            Vec3D startVec = new Vec3D(start);
            Vec3D destVec  = new Vec3D(dest);
            Vec3D velVec;

            if (LocationIsEqual(start, dest))
            {
                velVec = new Vec3D(0, 0, 0);
                return(velVec.ToVelocityValue());
            }
            else
            {
                velVec = startVec.VectorDistanceTo(destVec);
            }


            velVec.Normalize();
            velVec = velVec.Multiply(maxSpeed * throttle);

            //if (System.Double.IsNaN(velVec.X))
            //{
            //    int i = 0;
            //}

            return(velVec.ToVelocityValue());
        }
Beispiel #7
0
        public virtual void Draw(Tessellator par1Tessellator, float par2)
        {
            Vec3D vec3d  = VertexPositions[1].Vector3D.Subtract(VertexPositions[0].Vector3D);
            Vec3D vec3d1 = VertexPositions[1].Vector3D.Subtract(VertexPositions[2].Vector3D);
            Vec3D vec3d2 = vec3d1.CrossProduct(vec3d).Normalize();

            par1Tessellator.StartDrawingQuads();

            if (InvertNormal)
            {
                par1Tessellator.SetNormal(-(float)vec3d2.XCoord, -(float)vec3d2.YCoord, -(float)vec3d2.ZCoord);
            }
            else
            {
                par1Tessellator.SetNormal((float)vec3d2.XCoord, (float)vec3d2.YCoord, (float)vec3d2.ZCoord);
            }

            for (int i = 0; i < 4; i++)
            {
                PositionTextureVertex positiontexturevertex = VertexPositions[i];
                par1Tessellator.AddVertexWithUV((float)positiontexturevertex.Vector3D.XCoord * par2, (float)positiontexturevertex.Vector3D.YCoord * par2, (float)positiontexturevertex.Vector3D.ZCoord * par2, positiontexturevertex.TexturePositionX, positiontexturevertex.TexturePositionY);
            }

            par1Tessellator.Draw();
        }
Beispiel #8
0
            public static Vec3D Normalize(Vec3D v)
            {
                var result = v;

                result.Normalize();
                return(result);
            }
Beispiel #9
0
 public override MovingObjectPosition collisionRayTrace(World world, int i, int j, int k, Vec3D vec3d,
     Vec3D vec3d1)
 {
     int l = world.getBlockMetadata(i, j, k) & 7;
     float f = 0.15F;
     if (l == 1)
     {
         setBlockBounds(0.0F, 0.2F, 0.5F - f, f*2.0F, 0.8F, 0.5F + f);
     }
     else if (l == 2)
     {
         setBlockBounds(1.0F - f*2.0F, 0.2F, 0.5F - f, 1.0F, 0.8F, 0.5F + f);
     }
     else if (l == 3)
     {
         setBlockBounds(0.5F - f, 0.2F, 0.0F, 0.5F + f, 0.8F, f*2.0F);
     }
     else if (l == 4)
     {
         setBlockBounds(0.5F - f, 0.2F, 1.0F - f*2.0F, 0.5F + f, 0.8F, 1.0F);
     }
     else
     {
         float f1 = 0.1F;
         setBlockBounds(0.5F - f1, 0.0F, 0.5F - f1, 0.5F + f1, 0.6F, 0.5F + f1);
     }
     return base.collisionRayTrace(world, i, j, k, vec3d, vec3d1);
 }
Beispiel #10
0
            public void GetScreenVectors(int x, int y, uint size_x, uint size_y, out Vec3D position, out Vec3 direction)
            {
                position  = new Vec3D();
                direction = new Vec3();

                Camera_getScreenVectors(GetNativeReference(), x, y, size_x, size_y, ref position, ref direction);
            }
Beispiel #11
0
 public void ApplyNewValues()
 {
     particlePosition = newParticlePosition;
     particleVelocity = newParticleVelocity;
     alpha            = newAlpha;
     theta            = newTheta;
 }
Beispiel #12
0
        /// <summary>
        /// Returns whether the EntityAIBase should begin execution.
        /// </summary>
        public override bool ShouldExecute()
        {
            if (Entity.GetAge() >= 100)
            {
                return(false);
            }

            if (Entity.GetRNG().Next(120) != 0)
            {
                return(false);
            }

            Vec3D vec3d = RandomPositionGenerator.Func_48622_a(Entity, 10, 7);

            if (vec3d == null)
            {
                return(false);
            }
            else
            {
                Field_46098_b = vec3d.XCoord;
                Field_46099_c = vec3d.YCoord;
                Field_46097_d = vec3d.ZCoord;
                return(true);
            }
        }
Beispiel #13
0
        public bool GlobalToWorld(Coordinate converter, Vec3D position)
        {
            switch (_mapType)
            {
            case MapType.UNKNOWN:
            {
                return(false);
            }

            case MapType.UTM:

                UTMPos utmpos = new UTMPos(_metaData.Zone(), _metaData.North(), -(position.z + _origin.z), position.x + _origin.x, position.y + _origin.y);

                converter.SetUTMPos(utmpos);

                break;

            case MapType.GEOCENTRIC:

                CartPos cartpos = new CartPos(position.x + _origin.x, position.y + _origin.y, position.z + _origin.z);

                converter.SetCartPos(cartpos);

                break;
            }

            return(true);
        }
Beispiel #14
0
    private double Distance2PBC(Vec3D a, Vec3D b)
    {
        var dx = b.x - a.x;
        var dy = b.y - a.y;
        var dz = b.z - a.z;

        if (dx > 1)
        {
            dx = dx - 2;
        }
        else if (dx < -1)
        {
            dx = dx + 2;
        }

        if (dy > 1)
        {
            dy = dy - 2;
        }
        else if (dy < -1)
        {
            dy = dy + 2;
        }

        if (dz > 1)
        {
            dz = dz - 2;
        }
        else if (dz < -1)
        {
            dz = dz + 2;
        }

        return(dx * dx + dy * dy + dz * dz);
    }
Beispiel #15
0
        /// <summary>
        /// Gets the vector of the PathPoint associated with the given index.
        /// </summary>
        public virtual Vec3D GetVectorFromIndex(Entity par1Entity, int par2)
        {
            double d  = (double)Points[par2].XCoord + (double)(int)(par1Entity.Width + 1.0F) * 0.5D;
            double d1 = Points[par2].YCoord;
            double d2 = (double)Points[par2].ZCoord + (double)(int)(par1Entity.Width + 1.0F) * 0.5D;

            return(Vec3D.CreateVector(d, d1, d2));
        }
Beispiel #16
0
        public Vec3D getPosition(Entity entity)
        {
            double d  = points[pathIndex].xCoord + (int)(entity.width + 1.0F) * 0.5D;
            double d1 = points[pathIndex].yCoord;
            double d2 = points[pathIndex].zCoord + (int)(entity.width + 1.0F) * 0.5D;

            return(Vec3D.createVector(d, d1, d2));
        }
Beispiel #17
0
 static public Vec3D Cross(Vec3D a, Vec3D b)
 {
     return(new Vec3D(
                a.y * b.z - a.z * b.y,
                a.z * b.x - a.x * b.z,
                a.x * b.y - a.y * b.x
                ));
 }
Beispiel #18
0
 public void SetPosition()
 {
     try{
         Vec3D v = GetModel().GetRectangularFromEquatorialCoords();
         transform.localPosition = new Vector3((float)v.x, (float)v.y, (float)v.z) * distance;
     }catch (NullReferenceException n) {
     }
 }
Beispiel #19
0
        public bool GetGroundPosition(Vec3D position, Vec3 direction, out MapPos result, ClampFlags flags = ClampFlags.DEFAULT)
        {
            result = new MapPos();

            // Coordinate is now in world Cartesian coordinates (Roi Position)

            Vec3D origo = new Vec3D(0, 0, 0);       // Set used origo

            Intersector isect = new Intersector();

            // Check camera frustrum -----------------------------------------------------------

            if (_camera != null && _camera.IsValid())
            {
                origo = _camera.Position;

                if ((flags & ClampFlags.FRUSTRUM_CULL) != 0)
                {
                    isect.SetCamera(_camera);
                }
            }

            // Adjust intersector to use origo as center
            position = position - origo;

            isect.SetStartPosition((Vec3)position);
            isect.SetDirection(direction);

            if (isect.Intersect(_currentMap, IntersectQuery.NEAREST_POINT | IntersectQuery.NORMAL | ((flags & ClampFlags.WAIT_FOR_DATA) != 0 ? IntersectQuery.WAIT_FOR_DYNAMIC_DATA : 0), 1, true, origo))
            {
                IntersectorResult res = isect.GetResult();

                IntersectorData data = res.GetData(0);

                result.position = data.position + origo;

                result.normal = data.normal;

                result.clamped = true;
            }

            isect.Dispose();   // Drop handle and ignore GC

            if (_topRoi != null)
            {
                RoiNode roi = _topRoi.GetClosestRoiNode(result.position);
                result.node = roi;

                // Remove roiNode position as offset - Go to local RoiNode based coordinate system

                if (roi != null && roi.IsValid())
                {
                    result.position -= roi.Position;
                }
            }

            return(true);
        }
Beispiel #20
0
 public MapLimits(Vec3D lowerLimit, Vec3D higherLimit)
 {
     if (lowerLimit == null || higherLimit == null)
     {
         throw new ArgumentException("Map limits arguments must be both non null!");
     }
     this.lowerLimit  = lowerLimit;
     this.higherLimit = higherLimit;
 }
Beispiel #21
0
 public MovingObjectPosition(int par1, int par2, int par3, int par4, Vec3D par5Vec3D)
 {
     TypeOfHit = EnumMovingObjectType.TILE;
     BlockX    = par1;
     BlockY    = par2;
     BlockZ    = par3;
     SideHit   = par4;
     HitVec    = Vec3D.CreateVector(par5Vec3D.XCoord, par5Vec3D.YCoord, par5Vec3D.ZCoord);
 }
Beispiel #22
0
 public MovingObjectPosition(int i, int j, int k, int l, Vec3D vec3d)
 {
     typeOfHit = EnumMovingObjectType.TILE;
     blockX = i;
     blockY = j;
     blockZ = k;
     sideHit = l;
     hitVec = Vec3D.createVector(vec3d.xCoord, vec3d.yCoord, vec3d.zCoord);
 }
Beispiel #23
0
            public static Vec3D Lerp(ref Vec3D a, ref Vec3D b, double t)
            {
                t = Math.Min(1, Math.Max(0, t));

                return(new Vec3D(
                           a.x + (b.x - a.x) * t,
                           a.y + (b.y - a.y) * t,
                           a.z + (b.z - a.z) * t));
            }
 public MovingObjectPosition(int i, int j, int k, int l, Vec3D vec3d)
 {
     typeOfHit = EnumMovingObjectType.TILE;
     blockX    = i;
     blockY    = j;
     blockZ    = k;
     sideHit   = l;
     hitVec    = Vec3D.createVector(vec3d.xCoord, vec3d.yCoord, vec3d.zCoord);
 }
Beispiel #25
0
            public RoiNode GetClosestRoiNode(Vec3D position)
            {
                //NodeLock.WaitLockEdit();

                RoiNode node = CreateObject(Roi_getClosestRoiNode(GetNativeReference(), ref position)) as RoiNode;

                //NodeLock.UnLock();

                return(node);
            }
Beispiel #26
0
        public double Distance(String ob1, String ob2)
        {
            if (!AllObjects.ContainsKey(ob1) || !AllObjects.ContainsKey(ob2))
            {
                return(-1);
            }
            Vec3D ob1V = new Vec3D(AllObjects[ob1].Location);
            Vec3D ob2V = new Vec3D(AllObjects[ob2].Location);

            return(ob1V.ScalerDistanceTo(ob2V));
        }
Beispiel #27
0
        public bool GlobalToWorld(Vec3D global_position, out CartPos result)
        {
            Coordinate converter = new Coordinate();

            if (!GlobalToWorld(converter, global_position))
            {
                result = null;
                return(false);
            }

            return(converter.GetCartPos(out result));
        }
Beispiel #28
0
        public MapPos GlobalToLocal(Vec3D global_position)
        {
            MapPos result = new MapPos();

            result.position = global_position;

            result.local_orientation = GetLocalOrientation(global_position);

            ToLocal(result);

            return(result);
        }
Beispiel #29
0
        public MapPos WorldToLocal(Vec3D position)
        {
            position.z = -position.z;

            MapPos result = new MapPos();

            result.position = position /* - _origin*/;

            MapToRoi(result);

            return(result);
        }
Beispiel #30
0
        private void doTick()
        {
            var arraylist = new ArrayList();

            for (Iterator iterator = field_6037_b.keySet().iterator(); iterator.hasNext();)
            {
                var s = (string)iterator.next();
                int k = ((Integer)field_6037_b.get(s)).intValue();
                if (k > 0)
                {
                    field_6037_b.put(s, Integer.valueOf(k - 1));
                }
                else
                {
                    arraylist.add(s);
                }
            }

            for (int i = 0; i < arraylist.size(); i++)
            {
                field_6037_b.remove(arraylist.get(i));
            }

            AxisAlignedBB.clearBoundingBoxPool();
            Vec3D.initialize();
            deathTime++;
            if (deathTime % 20 == 0)
            {
                configManager.sendPacketToAllPlayers(new Packet4UpdateTime(worldMngr.getWorldTime()));
            }
            worldMngr.tick();
            while (worldMngr.func_6156_d())
            {
                ;
            }
            worldMngr.updateEntities();
            networkServer.func_715_a();
            configManager.func_637_b();
            entityTracker.updateTrackedEntities();
            for (int j = 0; j < field_9010_p.size(); j++)
            {
                ((IUpdatePlayerListBox)field_9010_p.get(j)).update();
            }

            try
            {
                commandLineParser();
            }
            catch (java.lang.Exception exception)
            {
                logger.log(Level.WARNING, "Unexpected exception while parsing console command", exception);
            }
        }
Beispiel #31
0
 public Model3D(Vec3D[] v, Face[] f, string s)
 {
     vertices = v;
     faces = f;
     numberOfVertices = v.Length;
     numberOfFaces = f.Length;
     source = s;
     totalArea = 0.0;
     foreach (Face fac in f)
         totalArea += fac.area;
     this.TransToCOM();
     //this.normalizeScale();
 }
Beispiel #32
0
        public Vec3D LocalToWorld(MapPos mappos)
        {
            Vec3D result = mappos.position;

            RoiNode roi = mappos.node as RoiNode;

            if (roi != null && roi.IsValid())
            {
                result += roi.Position;
            }

            return(new Vec3D(result.x, result.y, -result.z));
        }
Beispiel #33
0
        public Vec3D LocalToWorld(MapPos mappos)
        {
            Vec3D result = mappos.position;

            if (mappos.roiNode != null && mappos.roiNode.IsValid())
            {
                result += mappos.roiNode.Position;
            }

            //result += _origin;

            return(result);
        }
Beispiel #34
0
        //get CoM, if it doesn't exist: set it!
        public Vec3D getCOM()
        {
            if (COM != null)
                return COM;

            double x = 0, y = 0, z = 0;
            foreach (Vec3D v in vertices)
            {
                x += v.x;
                y += v.y;
                z += v.z;
            }
            COM = new Vec3D(x / vertices.Length, y / vertices.Length, z / vertices.Length);
            return COM;
        }
Beispiel #35
0
        public virtual float func_494_a(Vec3D vec3d, AxisAlignedBB axisalignedbb)
        {
            double d = 1.0D/((axisalignedbb.maxX - axisalignedbb.minX)*2D + 1.0D);
            double d1 = 1.0D/((axisalignedbb.maxY - axisalignedbb.minY)*2D + 1.0D);
            double d2 = 1.0D/((axisalignedbb.maxZ - axisalignedbb.minZ)*2D + 1.0D);
            int i = 0;
            int j = 0;
            for (float f = 0.0F; f <= 1.0F; f = (float) (f + d))
            {
                for (float f1 = 0.0F; f1 <= 1.0F; f1 = (float) (f1 + d1))
                {
                    for (float f2 = 0.0F; f2 <= 1.0F; f2 = (float) (f2 + d2))
                    {
                        double d3 = axisalignedbb.minX + (axisalignedbb.maxX - axisalignedbb.minX)*f;
                        double d4 = axisalignedbb.minY + (axisalignedbb.maxY - axisalignedbb.minY)*f1;
                        double d5 = axisalignedbb.minZ + (axisalignedbb.maxZ - axisalignedbb.minZ)*f2;
                        if (rayTraceBlocks(Vec3D.createVector(d3, d4, d5), vec3d) == null)
                        {
                            i++;
                        }
                        j++;
                    }
                }
            }

            return i/(float) j;
        }
Beispiel #36
0
 private double getDistanceOfPoint(Vec3D v)
 {
     return System.Math.Sqrt(v.x * v.x + v.y * v.y + v.z * v.z);
 }
Beispiel #37
0
 private double getDistanceBetweenPoints(Vec3D v1, Vec3D v2)
 {
     return System.Math.Sqrt(System.Math.Pow(v1.x - v2.x, 2) + System.Math.Pow(v1.y - v2.y, 2) + System.Math.Pow(v1.z - v2.z, 2));
 }
Beispiel #38
0
        public virtual MovingObjectPosition rayTraceBlocks_do(Vec3D vec3d, Vec3D vec3d1, bool flag)
        {
            if (Double.isNaN(vec3d.xCoord) || Double.isNaN(vec3d.yCoord) || Double.isNaN(vec3d.zCoord))
            {
                return null;
            }
            if (Double.isNaN(vec3d1.xCoord) || Double.isNaN(vec3d1.yCoord) || Double.isNaN(vec3d1.zCoord))
            {
                return null;
            }
            int i = MathHelper.floor_double(vec3d1.xCoord);
            int j = MathHelper.floor_double(vec3d1.yCoord);
            int k = MathHelper.floor_double(vec3d1.zCoord);
            int l = MathHelper.floor_double(vec3d.xCoord);
            int i1 = MathHelper.floor_double(vec3d.yCoord);
            int j1 = MathHelper.floor_double(vec3d.zCoord);
            for (int k1 = 200; k1-- >= 0;)
            {
                if (Double.isNaN(vec3d.xCoord) || Double.isNaN(vec3d.yCoord) || Double.isNaN(vec3d.zCoord))
                {
                    return null;
                }
                if (l == i && i1 == j && j1 == k)
                {
                    return null;
                }
                double d = 999D;
                double d1 = 999D;
                double d2 = 999D;
                if (i > l)
                {
                    d = l + 1.0D;
                }
                if (i < l)
                {
                    d = l + 0.0D;
                }
                if (j > i1)
                {
                    d1 = i1 + 1.0D;
                }
                if (j < i1)
                {
                    d1 = i1 + 0.0D;
                }
                if (k > j1)
                {
                    d2 = j1 + 1.0D;
                }
                if (k < j1)
                {
                    d2 = j1 + 0.0D;
                }
                double d3 = 999D;
                double d4 = 999D;
                double d5 = 999D;
                double d6 = vec3d1.xCoord - vec3d.xCoord;
                double d7 = vec3d1.yCoord - vec3d.yCoord;
                double d8 = vec3d1.zCoord - vec3d.zCoord;
                if (d != 999D)
                {
                    d3 = (d - vec3d.xCoord)/d6;
                }
                if (d1 != 999D)
                {
                    d4 = (d1 - vec3d.yCoord)/d7;
                }
                if (d2 != 999D)
                {
                    d5 = (d2 - vec3d.zCoord)/d8;
                }
                byte byte0 = 0;
                if (d3 < d4 && d3 < d5)
                {
                    if (i > l)
                    {
                        byte0 = 4;
                    }
                    else
                    {
                        byte0 = 5;
                    }
                    vec3d.xCoord = d;
                    vec3d.yCoord += d7*d3;
                    vec3d.zCoord += d8*d3;
                }
                else if (d4 < d5)
                {
                    if (j > i1)
                    {
                        byte0 = 0;
                    }
                    else
                    {
                        byte0 = 1;
                    }
                    vec3d.xCoord += d6*d4;
                    vec3d.yCoord = d1;
                    vec3d.zCoord += d8*d4;
                }
                else
                {
                    if (k > j1)
                    {
                        byte0 = 2;
                    }
                    else
                    {
                        byte0 = 3;
                    }
                    vec3d.xCoord += d6*d5;
                    vec3d.yCoord += d7*d5;
                    vec3d.zCoord = d2;
                }
                Vec3D vec3d2 = Vec3D.createVector(vec3d.xCoord, vec3d.yCoord, vec3d.zCoord);
                l = (int) (vec3d2.xCoord = MathHelper.floor_double(vec3d.xCoord));
                if (byte0 == 5)
                {
                    l--;
                    vec3d2.xCoord++;
                }
                i1 = (int) (vec3d2.yCoord = MathHelper.floor_double(vec3d.yCoord));
                if (byte0 == 1)
                {
                    i1--;
                    vec3d2.yCoord++;
                }
                j1 = (int) (vec3d2.zCoord = MathHelper.floor_double(vec3d.zCoord));
                if (byte0 == 3)
                {
                    j1--;
                    vec3d2.zCoord++;
                }
                int l1 = getBlockId(l, i1, j1);
                int i2 = getBlockMetadata(l, i1, j1);
                Block block = Block.blocksList[l1];
                if (l1 > 0 && block.canCollideCheck(i2, flag))
                {
                    MovingObjectPosition movingobjectposition = block.collisionRayTrace(this, l, i1, j1, vec3d, vec3d1);
                    if (movingobjectposition != null)
                    {
                        return movingobjectposition;
                    }
                }
            }

            return null;
        }
Beispiel #39
0
 public MovingObjectPosition(Entity entity)
 {
     typeOfHit = EnumMovingObjectType.ENTITY;
     entityHit = entity;
     hitVec = Vec3D.createVector(entity.posX, entity.posY, entity.posZ);
 }
Beispiel #40
0
 private bool isVecInXZ(Vec3D vec3d)
 {
     if (vec3d == null)
     {
         return false;
     }
     else
     {
         return vec3d.xCoord >= minX && vec3d.xCoord <= maxX && vec3d.zCoord >= minZ && vec3d.zCoord <= maxZ;
     }
 }
Beispiel #41
0
        void AddTrianglesGroupDoodads(TriangleCollection s, ModelInstance mi, Vec3D world_dir, Vec3D world_off, float rot)
        {
            float dx = mi.pos.x;
            float dy = mi.pos.y;
            float dz = mi.pos.z;

            rotate(dx, dz, rot + 90f, out dx, out dz);

            dx += world_off.x;
            dy += world_off.y;
            dz += world_off.z;

            Quaternion q;
            q.x = mi.dir.z;
            q.y = mi.dir.x;
            q.z = mi.dir.y;
            q.w = mi.w;
            Matrix4 rotMatrix = new Matrix4();
            rotMatrix.makeQuaternionRotate(q);

            Model m = mi.model;

            if (m.boundingTriangles == null)
            {

            }
            else
            {

                // We got boiuding stuff, that is better
                int nBoundingVertices = m.boundingVertices.Length / 3;
                int[] vertices = new int[nBoundingVertices];

                for (uint i = 0; i < nBoundingVertices; i++)
                {
                    uint off = i * 3;
                    float x = m.boundingVertices[off];
                    float y = m.boundingVertices[off + 2];
                    float z = m.boundingVertices[off + 1];
                    x *= mi.sc;
                    y *= mi.sc;
                    z *= -mi.sc;

                    Vector pos;
                    pos.x = x;
                    pos.y = y;
                    pos.z = z;
                    Vector new_pos = rotMatrix.mutiply(pos);
                    x = pos.x;
                    y = pos.y;
                    z = pos.z;

                    float dir_x = world_dir.z;
                    float dir_y = world_dir.y - 90;
                    float dir_z = -world_dir.x;

                    rotate(z, y, dir_x, out z, out y);
                    rotate(x, y, dir_z, out x, out y);
                    rotate(x, z, dir_y, out x, out z);

                    float xx = x + dx;
                    float yy = y + dy;
                    float zz = -z + dz;

                    float finalx = ChunkReader.ZEROPOINT - zz;
                    float finaly = ChunkReader.ZEROPOINT - xx;
                    float finalz = yy;
                    vertices[i] = s.AddVertex(finalx, finaly, finalz);
                }

                int nBoundingTriangles = m.boundingTriangles.Length / 3;
                for (uint i = 0; i < nBoundingTriangles; i++)
                {
                    uint off = i * 3;
                    int v0 = vertices[m.boundingTriangles[off]];
                    int v1 = vertices[m.boundingTriangles[off + 1]];
                    int v2 = vertices[m.boundingTriangles[off + 2]];
                    s.AddTriangle(v0, v2, v1, ChunkedTriangleCollection.TriangleFlagModel);
                }

            }
        }
Beispiel #42
0
        void AddTrianglesGroupDoodads(TriangleCollection s, ModelInstance mi, Vec3D world_dir, Vec3D world_off, float rot)
        {
            float dx = mi.pos.x;
            float dy = mi.pos.y;
            float dz = mi.pos.z;

            rotate(dx, dz, rot +90f, out dx, out dz);

            dx += world_off.x;
            dy += world_off.y;
            dz += world_off.z;

            Quaternion q;
            q.x = -mi.dir.z; q.y = mi.dir.x; q.z = mi.dir.y; q.w = mi.w;
            Matrix4 rotMatrix = new Matrix4();
            rotMatrix.makeQuaternionRotate(q);

            Model m = mi.model;

            if (m.boundingTriangles == null)
            {
                /*
                // /cry no bouding info, revert to normal vertices

                ModelView mv = m.view[0]; // View number 1 ?!?!
                int[] vertices = new int[m.vertices.Length / 3];
                for (uint i = 0; i < m.vertices.Length / 3; i++)
                {
                    float x = m.vertices[i * 3];
                    float y = m.vertices[i * 3 + 2];
                    float z = m.vertices[i * 3 + 1];
                    x *= mi.sc;
                    y *= mi.sc;
                    z *= -mi.sc;

                    Vector pos; pos.x = x; pos.y = y; pos.z = z;
                    Vector new_pos = rotMatrix.mutiply(pos);
                    x = pos.x; y = pos.y; z = pos.z;

                    rotate(x, z, (world_dir.y - 90), out x, out z);
                    rotate(y, z, -world_dir.x, out y, out z);
                    rotate(x, y, world_dir.z, out x, out y);

                    float xx = x + dx;
                    float yy = y + dy;
                    float zz = -z + dz;

                    float finalx = ChunkReader.ZEROPOINT - zz;
                    float finaly = ChunkReader.ZEROPOINT - xx;
                    float finalz = yy;

                    vertices[i] = s.AddVertex(finalx, finaly, finalz);
                }

                for (int i = 0; i < mv.triangleList.Length / 3; i++)
                {
                    int off = i * 3;
                    UInt16 vi0 = mv.triangleList[off];
                    UInt16 vi1 = mv.triangleList[off + 1];
                    UInt16 vi2 = mv.triangleList[off + 2];

                    int ind0 = mv.indexList[vi0];
                    int ind1 = mv.indexList[vi1];
                    int ind2 = mv.indexList[vi2];

                    int v0 = vertices[ind0];
                    int v1 = vertices[ind1];
                    int v2 = vertices[ind2];
                    s.AddTriangle(v0, v1, v2, ChunkedTriangleCollection.TriangleFlagModel);
                }
                */
            }
            else
            {

                // We got boiuding stuff, that is better
                int nBoundingVertices = m.boundingVertices.Length / 3;
                int[] vertices = new int[nBoundingVertices];

                for (uint i = 0; i < nBoundingVertices; i++)
                {
                    uint off = i * 3;
                    float x = m.boundingVertices[off];
                    float y = m.boundingVertices[off + 2];
                    float z = m.boundingVertices[off + 1];
                    x *= mi.sc;
                    y *= mi.sc;
                    z *= -mi.sc;

                    Vector pos; pos.x = x; pos.y = y; pos.z = z;
                    Vector new_pos = rotMatrix.mutiply(pos);
                    x = pos.x; y = pos.y; z = pos.z;

                    rotate(x, z, (world_dir.y - 90), out x, out z);
                    rotate(y, z, -world_dir.x, out y, out z);
                    rotate(x, y, world_dir.z, out x, out y);

                    float xx = x + dx;
                    float yy = y + dy;
                    float zz = -z + dz;

                    float finalx = ChunkReader.ZEROPOINT - zz;
                    float finaly = ChunkReader.ZEROPOINT - xx;
                    float finalz = yy;
                    vertices[i] = s.AddVertex(finalx, finaly, finalz);
                }

                int nBoundingTriangles = m.boundingTriangles.Length / 3;
                for (uint i = 0; i < nBoundingTriangles; i++)
                {
                    uint off = i * 3;
                    int v0 = vertices[m.boundingTriangles[off]];
                    int v1 = vertices[m.boundingTriangles[off + 1]];
                    int v2 = vertices[m.boundingTriangles[off + 2]];
                    s.AddTriangle(v0, v1, v2, ChunkedTriangleCollection.TriangleFlagModel);
                }
            }
        }
Beispiel #43
0
 public virtual void velocityToAddToEntity(World world, int i, int j, int k, Entity entity, Vec3D vec3d)
 {
 }
Beispiel #44
0
 private bool isVecInXY(Vec3D vec3d)
 {
     if (vec3d == null)
     {
         return false;
     }
     else
     {
         return vec3d.xCoord >= minX && vec3d.xCoord <= maxX && vec3d.yCoord >= minY && vec3d.yCoord <= maxY;
     }
 }
Beispiel #45
0
 public virtual MovingObjectPosition rayTraceBlocks(Vec3D vec3d, Vec3D vec3d1)
 {
     return rayTraceBlocks_do(vec3d, vec3d1, false);
 }
Beispiel #46
0
 public virtual MovingObjectPosition collisionRayTrace(World world, int i, int j, int k, Vec3D vec3d,
     Vec3D vec3d1)
 {
     setBlockBoundsBasedOnState(world, i, j, k);
     vec3d = vec3d.addVector(-i, -j, -k);
     vec3d1 = vec3d1.addVector(-i, -j, -k);
     Vec3D vec3d2 = vec3d.getIntermediateWithXValue(vec3d1, minX);
     Vec3D vec3d3 = vec3d.getIntermediateWithXValue(vec3d1, maxX);
     Vec3D vec3d4 = vec3d.getIntermediateWithYValue(vec3d1, minY);
     Vec3D vec3d5 = vec3d.getIntermediateWithYValue(vec3d1, maxY);
     Vec3D vec3d6 = vec3d.getIntermediateWithZValue(vec3d1, minZ);
     Vec3D vec3d7 = vec3d.getIntermediateWithZValue(vec3d1, maxZ);
     if (!isVecInsideYZBounds(vec3d2))
     {
         vec3d2 = null;
     }
     if (!isVecInsideYZBounds(vec3d3))
     {
         vec3d3 = null;
     }
     if (!isVecInsideXZBounds(vec3d4))
     {
         vec3d4 = null;
     }
     if (!isVecInsideXZBounds(vec3d5))
     {
         vec3d5 = null;
     }
     if (!isVecInsideXYBounds(vec3d6))
     {
         vec3d6 = null;
     }
     if (!isVecInsideXYBounds(vec3d7))
     {
         vec3d7 = null;
     }
     Vec3D vec3d8 = null;
     if (vec3d2 != null && (vec3d8 == null || vec3d.distanceTo(vec3d2) < vec3d.distanceTo(vec3d8)))
     {
         vec3d8 = vec3d2;
     }
     if (vec3d3 != null && (vec3d8 == null || vec3d.distanceTo(vec3d3) < vec3d.distanceTo(vec3d8)))
     {
         vec3d8 = vec3d3;
     }
     if (vec3d4 != null && (vec3d8 == null || vec3d.distanceTo(vec3d4) < vec3d.distanceTo(vec3d8)))
     {
         vec3d8 = vec3d4;
     }
     if (vec3d5 != null && (vec3d8 == null || vec3d.distanceTo(vec3d5) < vec3d.distanceTo(vec3d8)))
     {
         vec3d8 = vec3d5;
     }
     if (vec3d6 != null && (vec3d8 == null || vec3d.distanceTo(vec3d6) < vec3d.distanceTo(vec3d8)))
     {
         vec3d8 = vec3d6;
     }
     if (vec3d7 != null && (vec3d8 == null || vec3d.distanceTo(vec3d7) < vec3d.distanceTo(vec3d8)))
     {
         vec3d8 = vec3d7;
     }
     if (vec3d8 == null)
     {
         return null;
     }
     sbyte byte0 = -1;
     if (vec3d8 == vec3d2)
     {
         byte0 = 4;
     }
     if (vec3d8 == vec3d3)
     {
         byte0 = 5;
     }
     if (vec3d8 == vec3d4)
     {
         byte0 = 0;
     }
     if (vec3d8 == vec3d5)
     {
         byte0 = 1;
     }
     if (vec3d8 == vec3d6)
     {
         byte0 = 2;
     }
     if (vec3d8 == vec3d7)
     {
         byte0 = 3;
     }
     return new MovingObjectPosition(i, j, k, byte0, vec3d8.addVector(i, j, k));
 }
Beispiel #47
0
 public override void velocityToAddToEntity(World world, int i, int j, int k, Entity entity, Vec3D vec3d)
 {
     modelBlock.velocityToAddToEntity(world, i, j, k, entity, vec3d);
 }
Beispiel #48
0
        //translate every vertex relative to CoM
        public void TransToCOM()
        {
            Vec3D mean = getCOM();

            if (COM.Equals(new Vec3D(0, 0, 0)))
            {
                return;
            }

            for (int i = 0; i < vertices.Length; i++)
            {
                Vec3D v = vertices[i];
                v.sub(mean);
            }
            COM = new Vec3D(0, 0, 0);
        }
Beispiel #49
0
 public MovingObjectPosition func_706_a(Vec3D vec3d, Vec3D vec3d1)
 {
     Vec3D vec3d2 = vec3d.getIntermediateWithXValue(vec3d1, minX);
     Vec3D vec3d3 = vec3d.getIntermediateWithXValue(vec3d1, maxX);
     Vec3D vec3d4 = vec3d.getIntermediateWithYValue(vec3d1, minY);
     Vec3D vec3d5 = vec3d.getIntermediateWithYValue(vec3d1, maxY);
     Vec3D vec3d6 = vec3d.getIntermediateWithZValue(vec3d1, minZ);
     Vec3D vec3d7 = vec3d.getIntermediateWithZValue(vec3d1, maxZ);
     if (!isVecInYZ(vec3d2))
     {
         vec3d2 = null;
     }
     if (!isVecInYZ(vec3d3))
     {
         vec3d3 = null;
     }
     if (!isVecInXZ(vec3d4))
     {
         vec3d4 = null;
     }
     if (!isVecInXZ(vec3d5))
     {
         vec3d5 = null;
     }
     if (!isVecInXY(vec3d6))
     {
         vec3d6 = null;
     }
     if (!isVecInXY(vec3d7))
     {
         vec3d7 = null;
     }
     Vec3D vec3d8 = null;
     if (vec3d2 != null && (vec3d8 == null || vec3d.squareDistanceTo(vec3d2) < vec3d.squareDistanceTo(vec3d8)))
     {
         vec3d8 = vec3d2;
     }
     if (vec3d3 != null && (vec3d8 == null || vec3d.squareDistanceTo(vec3d3) < vec3d.squareDistanceTo(vec3d8)))
     {
         vec3d8 = vec3d3;
     }
     if (vec3d4 != null && (vec3d8 == null || vec3d.squareDistanceTo(vec3d4) < vec3d.squareDistanceTo(vec3d8)))
     {
         vec3d8 = vec3d4;
     }
     if (vec3d5 != null && (vec3d8 == null || vec3d.squareDistanceTo(vec3d5) < vec3d.squareDistanceTo(vec3d8)))
     {
         vec3d8 = vec3d5;
     }
     if (vec3d6 != null && (vec3d8 == null || vec3d.squareDistanceTo(vec3d6) < vec3d.squareDistanceTo(vec3d8)))
     {
         vec3d8 = vec3d6;
     }
     if (vec3d7 != null && (vec3d8 == null || vec3d.squareDistanceTo(vec3d7) < vec3d.squareDistanceTo(vec3d8)))
     {
         vec3d8 = vec3d7;
     }
     if (vec3d8 == null)
     {
         return null;
     }
     sbyte byte0 = -1;
     if (vec3d8 == vec3d2)
     {
         byte0 = 4;
     }
     if (vec3d8 == vec3d3)
     {
         byte0 = 5;
     }
     if (vec3d8 == vec3d4)
     {
         byte0 = 0;
     }
     if (vec3d8 == vec3d5)
     {
         byte0 = 1;
     }
     if (vec3d8 == vec3d6)
     {
         byte0 = 2;
     }
     if (vec3d8 == vec3d7)
     {
         byte0 = 3;
     }
     return new MovingObjectPosition(0, 0, 0, byte0, vec3d8);
 }
Beispiel #50
0
 public override MovingObjectPosition collisionRayTrace(World world, int i, int j, int k, Vec3D vec3d,
     Vec3D vec3d1)
 {
     setBlockBoundsBasedOnState(world, i, j, k);
     return base.collisionRayTrace(world, i, j, k, vec3d, vec3d1);
 }
Beispiel #51
0
 private bool isVecInYZ(Vec3D vec3d)
 {
     if (vec3d == null)
     {
         return false;
     }
     else
     {
         return vec3d.yCoord >= minY && vec3d.yCoord <= maxY && vec3d.zCoord >= minZ && vec3d.zCoord <= maxZ;
     }
 }