Reference

layout

https://webkit.org/blog/2518/state-of-web-inspector/

Toolbar
Navigation bar
Activity viewer
Dock controls
Navigation slider
Quick console
Content browser
Details sidebar

Brush tools
Sketch Pane
Board Drawer
Edit in photoshop
Meta data anel

-- Enemy:

local Enemy = {}
Enemy.__index = Enemy

function Enemy.new()
	return setmetatable({}, Enemy)
end

-- Boss:

local Boss = setmetatable({}, Enemy)
Boss.__index = Boss

function Boss.new()
	return setmetatable({}, Boss)
end

-- Orc:

local Orc = {}

function Orc:method()

end

-- Orc methods and properties must be defined before you copy them!

local OrcBoss = setmetatable(copy(Orc), Boss)
OrcBoss.__index = OrcBoss

local OrcEnemy = setmetatable(copy(Orc), Enemy)
OrcEnemy.__index = OrcEnemy

-- You can construct the different orc types like this:

function Orc.enemy()
	return setmetatable({}, OrcEnemy)
end

function Orc.boss()
	return setmetatable({}, OrcBoss)
end

Orc.enemy()
Orc.boss()

-- or like this:

function OrcEnemy.new()
	return setmetatable({}, OrcEnemy)
end

function OrcBoss.new()
	return setmetatable({}, OrcBoss)
end

OrcEnemy.new()
OrcBoss.new()

classDiagram
    class Enemy {
        +new()
    }
    class Boss {
        +new()
    }
    class Orc {
        +method()
    }
    class OrcBoss {
        +new()
    }
    class OrcEnemy {
        +new()
    }
    Enemy <|-- Boss
    Boss <|-- OrcBoss
    Enemy <|-- OrcEnemy
    Orc --|> OrcBoss
    Orc --|> OrcEnemy

In this diagram:

Arrows with a hollow triangle (<|–) represent inheritance. The class at the base of the arrow is the superclass, and the class at the head of the arrow is the subclass. Arrows with a diamond (–|>) represent composition. The class at the base of the arrow is composed of the class at the head of the arrow. This means:

Boss and OrcEnemy are subclasses of Enemy. OrcBoss is a subclass of Boss. OrcBoss and OrcEnemy are composed of Orc. Please note that this is a simplified representation and might not capture all the nuances of your Lua code. For example, the copy(Orc) operation is not represented in the diagram. Also, the new() methods in the diagram represent the setmetatable({}, Class) operations in your Lua code. The method() in Orc is a placeholder for all the methods and properties in Orc that you might define.

I hope this helps! If you have any other questions or need further clarification, feel free to ask.

// Base class Enemy
class Enemy {
    constructor() {
        // Enemy constructor code
    }
}

// Boss inherits from Enemy
class Boss extends Enemy {
    constructor() {
        super(); // Call the constructor of the parent class Enemy
        // Boss constructor code
    }
}

// Orc inherits from Enemy
class Orc extends Enemy {
    constructor() {
        super(); // Call the constructor of the parent class Enemy
        // Orc constructor code
    }

    method() {
        // Orc method code
    }
}

// OrcEnemy inherits from Enemy
class OrcEnemy extends Enemy {
    constructor() {
        super(); // Call the constructor of the parent class Enemy
        // OrcEnemy constructor code
    }
}

// OrcBoss inherits from Boss and Orc
// TypeScript does not support multiple inheritance, so we need to use composition for Orc
class OrcBoss extends Boss {
    private orc: Orc;

    constructor() {
        super(); // Call the constructor of the parent class Boss
        this.orc = new Orc(); // Composition: include an instance of Orc
        // OrcBoss constructor code
    }

    method() {
        return this.orc.method(); // Delegate the method call to the Orc instance
    }
}

In TypeScript, multiple inheritance is not directly supported. However, you can achieve a similar effect by using composition, where OrcBoss contains an instance of Orc and delegates calls to its methods. This way, OrcBoss has the properties and methods of both Boss and Orc.

Please note that the method() in Orc and OrcBoss is a placeholder for the actual implementation you might have in your Lua code. You’ll need to replace the comments with the actual code that should be executed in those methods. If you have any further questions or need additional assistance, feel free to ask!

-- Base class Enemy
Enemy = {}
Enemy.__index = Enemy

function Enemy.new()
    local self = setmetatable({}, Enemy)
    -- Enemy constructor code
    return self
end

-- Boss inherits from Enemy
Boss = setmetatable({}, Enemy)
Boss.__index = Boss

function Boss.new()
    local self = setmetatable(Enemy.new(), Boss)
    -- Boss constructor code
    return self
end

-- Orc inherits from Enemy
Orc = setmetatable({}, Enemy)
Orc.__index = Orc

function Orc.new()
    local self = setmetatable(Enemy.new(), Orc)
    -- Orc constructor code
    return self
end

function Orc:method()
    -- Orc method code
end

-- OrcEnemy inherits from Enemy
OrcEnemy = setmetatable({}, Enemy)
OrcEnemy.__index = OrcEnemy

function OrcEnemy.new()
    local self = setmetatable(Enemy.new(), OrcEnemy)
    -- OrcEnemy constructor code
    return self
end

-- OrcBoss inherits from Boss and has an instance of Orc
OrcBoss = setmetatable({}, Boss)
OrcBoss.__index = OrcBoss

function OrcBoss.new()
    local self = setmetatable(Boss.new(), OrcBoss)
    self.orc = Orc.new() -- Composition: include an instance of Orc
    -- OrcBoss constructor code
    return self
end

function OrcBoss:method()
    return self.orc:method() -- Delegate the method call to the Orc instance
end