Hi there, my name is Atanas Laskov. I'm interested in web technologies and game dev. Currently, I am working on a city editor web-app. You can see some preliminary wireframes in the sketchbook. I'm also an artist and digital illustrator.
Supporting the British Red Cross (UI Design, Character Animator)
In this game you explore a beautiful town threatened by a dangerous storm. I did the UI design and icon design in Adobe Illustrator, the character animation in Adobe Animate.
The project gave me the opportunity to do visual effects animation for wind, rain and sparkles in Unity Engine. Some of the Unity Engine prefabs for the UI also are my work.
Project Blob (Character Animator)
Project Blob is a side-scrolling point & click adventure, I animated the girl and her blob pet.
Previously, I wrote 2 games in TypeScript, they both run in the browser:
One of my previous game projects was a C++ game engine with
full Docs and Source Code.
Short docs are available at the end of this page.
The animation, environment design and 3D modeling are my own work.
The following section gives an overview of the class hierarchy implemented in the game. It describes briefly the responsibilities of each class.
Register and instantiate objects by class name.
This is the base class for all objects created by laClassFactory.
Parsing XML-like files into objects.
Base class for all objects loaded by laFileParser.
class laPropertyList: public laLoadableObj
Loads and maintains a list of properties.
class laTypedObject: public laLoadableObj
Loads and maintains an object of the specified class type.
Children of laProgressiveTask have the capability to record the progress of a task and its sub-tasks.
Error handling class containing a text description.
class laElement: public laPropertyList
This class loads and maintains a list of animated 3D models and effects composed at different positions. The data file can request a children of laElement to be used. This way it is possible to implement custom rendering.
class laTile: public laLoadableObj
This class represents a single element in the level grid. A tile can contain several laElement objects.
class laTileset: public laProgressiveTask
This class stores a tileset loaded form file. The tileset is used to describe all types of elements which can be instantiated in the level. Tileset elements include the terrain elements, creature objects, collectables, potions, and so on.
public laProgressiveTask, public laClassFactory
This class represents the entire level. For performance reasoned the level is subdivided into a series of segments; Segments are organized as list of laSegment objects. These segments are twisted in 3D for better visual effect.
class laSegment: public laLoadableObj
This class represents a single segment of the level. Representing the level as a sequence of segments makes it easy to render and animate only those that are visible at any time.
class laLitterBox: public laLoadableObj
Populations of objects, randomly placed.
class laSky: public laLoadableObj
Texture effect for simulating the sky.
class laPoint2: public laLoadableObj
class laPoint3: public laLoadableObj
Represents 2D and 3D vectors. Implements dot products, cross products and other vector operations.
Represents 2D and 3D line segments. Implements finding intersection points and other line-segment operations.
Represents a 3D plane. Implements intersections with laLine2 and other plane operations.
Represents bounding boxes and rectangles.
Abstract renderer interface
class laRenderer_OpenGL: public laRenderer
OpenGL implementation of the laRenderer abstract interface.
Abstract interface for 3D models.
Single face of a 3D model.
class laStaticModel: public laModel
Implements a static (non-animated) model.
class laAnimatedModel: public laModel
Implements an animated model.
Allows the attachment of 3D objects to laModel. At every time t it gives the position and vector rotation of the hook.
Represents a texture.
Represents a RGB colour.
Represents a font.
Resource manager for all fonts.
This class implement a collision detection algorithm.
class laCollisionTests: public laStage
This is a set of tests for debugging the collision detection algorithm.
This class stores collision detection data.
This class contains all the information necessary for collision detection and stores the result of the collision detection.
class laPivot: public laPoint3
This class represents the position and rotation of dynamic objects; It is also a the representation of the object during simulation of physics.
Simulation of physical force applied to an object.
This class helps in calculating timing (dt, frames per second).
class fxParticleSystem: public laLoadableObj
Animated particle effect for smoke, fire and other.
Animated text message floating in 3D.
Animated block of text.
Fades in, fades out the semi-transparent shutter. This is used in the GUI library.
Integrates all sub-systems of the engine. This class is singleton and it throws an error if the client attempts to create more than one instance of it.
Abstract interface for the OS environment.
class laEnvironment_win32: public laEnvironment.
Abstract thread containing the virtual method run()=0; Objects of this type can be passed to laEnvironment for parallel execution.
The laGame class manages several laStage objects. Only one stage can be active at any given time. Stages can be added and removed dynamically.
The stage represents a different phase of the game. For example the main menu can be a stage. The introductory screen can be another one, the game itself a third one.
class stageGame: public laStage
class stageMenu: public laStage
class stageLoad: public laStage
class stageEdit: public laStage
class stageModelViewer: public laStage
class laSettings: public laPropertyList
Game engine settings
class aiAgent: public laLoadableObj, public laClassFactory
This class provides the percepts and controller which can be used to implement AI agents. Any element of the level can have attached AI. Agents perceive information about the environment (for example the distance to the player; this information is supplied by other parts of the engine). The agent is a finite-state machine. New states can be added and removed dynamically but only one can be active at any time.
class aiPercepts: public std::map<unsigned, aiPerceptData>
The set of percepts available to the agent.
class aiAgentState: public laNamedClass, public laLoadableObj
Base class for agent states.
class aiMobState_Prowl: public aiAgentState
class aiMobState_Flyer: public aiAgentState
class aiMobState_LavaJumper: public aiAgentState
class aiState_Autoplay: public aiAgentState
public laLoadableObj, public laNamedClass
This is the base class for all objects placed in a level.
class laStateObject: public laObject
Stableful level object (e.g. stand, walk, and attack states). This class creates transition animations between the animations of the different states.
class laCollectable: public laObject
The player can collect this type of object (e.g. coins and other treasure).
class laMovingCreature: public laStateObject
Base class for all mobile object and creatures.
class laFightingCreature: public laMovingCreature
This type of creature can engage in battle.
class laMonster: public laFightingCreature
Fighting creature controlled by the AI.
class laPlayer: public laFightingCreature
Fighting creature controlled by the player.
class laGateway: public laCollectable
Collecting this item causes transition to the next level.