Inheritance diagram for Fov:

Classes
struct	LevelPoint

Public Member Functions
void	SetVisible (int x, int y)

void	ClearVisible ()

List< Point >	ListPoints ()

void	Perform (int _x, int _z, int _range, float power=1f)

Static Public Member Functions
static float	DistanceFloat (int x1, int y1, int x2, int y2)

static int	Distance (int x1, int y1, int x2, int y2)

Static Public Member Functions inherited from EClass
static int	rnd (int a)

static int	curve (int a, int start, int step, int rate=75)

static int	rndHalf (int a)

static float	rndf (float a)

static int	rndSqrt (int a)

static void	Wait (float a, Card c)

static void	Wait (float a, Point p)

static int	Bigger (int a, int b)

static int	Smaller (int a, int b)

Public Attributes
byte	r

byte	g

byte	b

bool	isPC

bool	limitGradient

Dictionary< int, byte >	lastPoints = new Dictionary<int, byte>()

Static Public Attributes
static float	nonGradientMod

static List< Cell >	newPoints = new List<Cell>()

static Map	map

static LevelPoint	origin = default(LevelPoint)

static int	range

static float	_power

Static Public Attributes inherited from EClass
static Core	core

Private Member Functions
float	GetVisDistance (int x1, int y1, int x2, int y2)

void	TraceLine (int x2, int y2)

Static Private Attributes
static int	x

static int	y

Additional Inherited Members
Properties inherited from EClass
static Game	game `[get]`

static bool	AdvMode `[get]`

static Player	player `[get]`

static Chara	pc `[get]`

static UI	ui `[get]`

static Map	_map `[get]`

static Zone	_zone `[get]`

static FactionBranch	Branch `[get]`

static FactionBranch	BranchOrHomeBranch `[get]`

static Faction	Home `[get]`

static Faction	Wilds `[get]`

static Scene	scene `[get]`

static BaseGameScreen	screen `[get]`

static GameSetting	setting `[get]`

static GameData	gamedata `[get]`

static ColorProfile	Colors `[get]`

static World	world `[get]`

static SourceManager	sources `[get]`

static SourceManager	editorSources `[get]`

static SoundManager	Sound `[get]`

static CoreDebug	debug `[get]`

Detailed Description

Definition at line 5 of file Fov.cs.

Member Function Documentation

◆ ClearVisible()

void Fov.ClearVisible ( )

inline

Definition at line 96 of file Fov.cs.

    {
        foreach (KeyValuePair<int, byte> lastPoint in lastPoints)
        {
            Cell cell = map.GetCell(lastPoint.Key);
            byte value = lastPoint.Value;
            cell.light -= value;
            cell.lightR -= (ushort)(value * r / 2);
            cell.lightG -= (ushort)(value * g / 2);
            cell.lightB -= (ushort)(value * b / 2);
            if (isPC)
            {
                cell.pcSync = false;
            }
        }
        lastPoints.Clear();
    }

References b, g, Map.GetCell(), isPC, lastPoints, map, and r.

Referenced by Perform().

◆ Distance()

static int Fov.Distance	(	int	x1,
		int	y1,
		int	x2,
		int	y2
	)

inlinestatic

Definition at line 134 of file Fov.cs.

    {
        return (int)Mathf.Sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
    }

Referenced by Spatial.Dist(), and Point.Distance().

◆ DistanceFloat()

static float Fov.DistanceFloat	(	int	x1,
		int	y1,
		int	x2,
		int	y2
	)

inlinestatic

Definition at line 129 of file Fov.cs.

    {
        return Mathf.Sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
    }

Referenced by TileMapElona.DrawTile().

◆ GetVisDistance()

float Fov.GetVisDistance	(	int	x1,
		int	y1,
		int	x2,
		int	y2
	)

inlineprivate

Definition at line 124 of file Fov.cs.

    {
        return Mathf.Sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
    }

Referenced by Perform(), SetVisible(), and TraceLine().

◆ ListPoints()

List< Point > Fov.ListPoints ( )

inline

Definition at line 114 of file Fov.cs.

    {
        List<Point> list = new List<Point>();
        foreach (KeyValuePair<int, byte> lastPoint in lastPoints)
        {
            list.Add(new Point(lastPoint.Key));
        }
        return list;
    }

References lastPoints.

Referenced by AI_Fish.Run().

◆ Perform()

void Fov.Perform	(	int	_x,
		int	_z,
		int	_range,
		float	power = `1f`
	)

inline

Definition at line 139 of file Fov.cs.

    {
        range = _range;
        ClearVisible();
        if (range == 0)
        {
            return;
        }
        _power = power;
        origin.X = _x;
        origin.Y = _z;
        SetVisible(origin.X, origin.Y);
        int num = origin.X - range;
        if (num < 0)
        {
            num = 0;
        }
        int num2 = origin.Y - range;
        if (num2 < 0)
        {
            num2 = 0;
        }
        int num3 = origin.X + range + 1;
        if (num3 >= EClass._map.Size)
        {
            num3 = EClass._map.Size;
        }
        int num4 = origin.Y + range + 1;
        if (num4 >= EClass._map.Size)
        {
            num4 = EClass._map.Size;
        }
        for (int i = num; i < num3; i++)
        {
            TraceLine(i, num2);
            TraceLine(i, num4 - 1);
        }
        for (int j = num2 + 1; j < num4 - 1; j++)
        {
            TraceLine(num, j);
            TraceLine(num3 - 1, j);
        }
        if (range >= 6)
        {
            int max = EClass._map.Size - 1;
            int x = (origin.X + 4).ClampMax(max);
            int y = (origin.Y + 1).ClampMax(max);
            int x2 = (origin.X - 4).ClampMin(0);
            int y2 = (origin.Y - 1).ClampMin(0);
            int x3 = (origin.X + 1).ClampMax(max);
            int y3 = (origin.Y + 4).ClampMax(max);
            int x4 = (origin.X - 1).ClampMin(0);
            int y4 = (origin.Y - 4).ClampMin(0);
            TraceLine(x, y);
            TraceLine(x, y2);
            TraceLine(x2, y);
            TraceLine(x2, y2);
            TraceLine(x3, y3);
            TraceLine(x3, y4);
            TraceLine(x4, y3);
            TraceLine(x4, y4);
        }
        foreach (KeyValuePair<int, byte> lastPoint in lastPoints)
        {
            Cell cell = map.GetCell(lastPoint.Key);
            byte value = lastPoint.Value;
            cell.light += value;
            cell.lightR += (ushort)(value * r / 2);
            cell.lightG += (ushort)(value * g / 2);
            cell.lightB += (ushort)(value * b / 2);
            if (isPC && (value > 0 || GetVisDistance(origin.X, origin.Y, cell.x, cell.z) < 2f) && !cell.isSeen && (!cell.HasWall || EClass._zone.UseFog || cell.room == EClass.pc.Cell.room || cell.hasDoor))
            {
                EClass._map.SetSeen(cell.x, cell.z);
                newPoints.Add(cell);
            }
        }
        if (isPC && newPoints.Count > 0)
        {
            WidgetMinimap.UpdateMap(newPoints);
        }
    }

References EClass._map, _power, EClass._zone, b, Card.Cell, ClearVisible(), g, Map.GetCell(), GetVisDistance(), Cell.hasDoor, Cell.HasWall, isPC, Cell.isSeen, lastPoints, map, newPoints, origin, EClass.pc, r, range, Cell.room, Map.SetSeen(), SetVisible(), MapBounds.Size, TraceLine(), WidgetMinimap.UpdateMap(), Zone.UseFog, Cell.x, Fov.LevelPoint.X, x, Fov.LevelPoint.Y, y, and Cell.z.

Referenced by Card.CalculateFOV(), and Card.ClearFOV().

◆ SetVisible()

void Fov.SetVisible	(	int	x,
		int	y
	)

inline

Definition at line 42 of file Fov.cs.

    {
        Cell cell = map.cells[x, y];
        if (cell.light > 100 && !isPC)
        {
            return;
        }
        int key = x + y * map.Size;
        if (isPC && !cell.outOfBounds)
        {
            cell.pcSync = true;
        }
        if (_power < 0.1f)
        {
            lastPoints[key] = 0;
            return;
        }
        float num = GetVisDistance(x, y, origin.X, origin.Y);
        float power = _power;
        if (limitGradient)
        {
            power *= nonGradientMod;
            if (num >= (float)range)
            {
                power *= EClass.scene.profile.global.edgeLight;
            }
        }
        else
        {
            if (num <= 1f)
            {
                num = 1f;
            }
            power *= (float)(range + 1) - num;
        }
        if (power < 1f)
        {
            power = 1f;
        }
        else if (power > 20f)
        {
            power = 20f;
        }
        if (cell.outOfBounds)
        {
            if (isPC && (power > 0f || GetVisDistance(origin.X, origin.Y, x, y) < 4f))
            {
                cell.isSeen = true;
            }
            power = 0f;
        }
        lastPoints[key] = (byte)power;
    }

References _power, Map.cells, GetVisDistance(), SceneProfile.global, isPC, lastPoints, Cell.light, limitGradient, map, nonGradientMod, origin, Cell.outOfBounds, Scene.profile, range, EClass.scene, MapBounds.Size, Fov.LevelPoint.X, x, Fov.LevelPoint.Y, and y.

Referenced by Perform(), and TraceLine().

◆ TraceLine()

void Fov.TraceLine	(	int	x2,
		int	y2
	)

inlineprivate

Definition at line 221 of file Fov.cs.

    {
        int value = x2 - origin.X;
        int value2 = y2 - origin.Y;
        int num = Math.Abs(value);
        int num2 = Math.Abs(value2);
        int num3 = Math.Sign(value);
        int num4 = Math.Sign(value2) << 16;
        int num5 = (origin.Y << 16) + origin.X;
        if (num < num2)
        {
            int num6 = num;
            num = num2;
            num2 = num6;
            int num7 = num3;
            num3 = num4;
            num4 = num7;
        }
        int num8 = num2 * 2;
        int num9 = -num;
        int num10 = num * 2;
        while (--num >= 0)
        {
            num5 += num3;
            num9 += num8;
            if (num9 > 0)
            {
                num9 -= num10;
                num5 += num4;
            }
            x = num5 & 0xFFFF;
            y = num5 >> 16;
            int num11 = (int)GetVisDistance(origin.X, origin.Y, x, y);
            if (range < 0 || num11 <= range)
            {
                SetVisible(x, y);
                if (map.cells[x, y].blockSight)
                {
                    break;
                }
                continue;
            }
            break;
        }
    }