Feed aggregator

Font Stadium

Font Stadium is a special font repository consisting of over 220 premium fonts (all in TTF format) that have been professionally designed and curated to meet industry standards.

This font megabundle contains all of the fonts from our Font Nation, Font King, and Pixel Glyphs packages combined.

This is our most elaborate and ambitious product yet. We have listened to the feedback of our customers and at least half of these fonts feature support for foreign language characters' accents (English, Spanish, and French).

Tailored for commercial usage, our library caters to a broad audience of creative professionals, from solo developers and graphic designers, to businesses, companies, and international brands.

Our package will certainly prove useful for designing logos, icons, graphics, posters, UI, texts, dialogues, and much more— giving credit is optional!

• Professionally crafted

• Scaling is smooth and dynamic

• Works on all resolutions

• Colors can be modified

You can also learn how to integrate fonts with TextMesh Pro through our easy-to-follow documentation which can be accessed here at any time.

Terms and Conditions

These fonts can be used commercially and non-commercially for any purpose so long as each party owns their appropriate entity license (Single-Entity or Multi-Entity), and this product listing and its contents are not being redistributed or resold anywhere.

Be sure to check the Package Content tab for the full list of fonts available and feel free to take a closer look at our promotional media to see the names of our fonts and their available characters and styles.

Content:

• a shader
• two C# script
• documentation (PDF)
• demo scene with materials, textures and a simple user control script

Add a triangular ripple effect on a wall, picture and so on. The effect will activated after a character or object collide with the wall.

Content:

• a shader
• two C# script
• documentation (PDF)
• demo scene with materials, textures and a simple user control script

Add a square ripple effect on a wall, picture and so on. The effect will activated after a character or object collide with the wall.

Supports desktop platforms (Windows)

Supports 3D (Built-In Render Pipeline)

Requires DOTween package

3D recreation of a Cultist-like game experience.

• Define your cards and narrative actions.
• Organize and manage cards on the table.
• Smooth drag & drop interface highlighting possible actions.
• Since it’s 3D you can apply custom shaders and lighting for unique effects.
• Upcoming integration with some existing Unity narrative package.

This is a work in progress and some features are still missing.

4Grounds: Extraterrestrial_3

1. Extraterrestrial_24
2. Extraterrestrial_25
3. Extraterrestrial_26
4. Extraterrestrial_27

• One of each for each ground:
• SBSAR file
• graph_0.asset
• Material (.mat file)
• Ambient Occlusion = (1024 × 1024 default) (4096 × 4096 intended)
• Base Color = (1024 × 1024 default) (4096 × 4096 intended)
• Height = (1024 × 1024 default) (4096 × 4096 intended)
• Metallic = (1024 × 1024 default) (4096 × 4096 intended)
• Normal = (1024 × 1024 default) (4096 × 4096 intended)
• Terrain Layer (.terrainlayer)
• Example Scene
• readme.pdf

Attention! Increase SBSAR Output Resolution to 4096 for intended material output. On import the Output Resolution defaults to 1024. In some cases, lower resolutions will decimate the intended output.

4Grounds: Extraterrestrial_3 provides procedural material generation through SBSAR utilization. Provides 4 materials, correlating texture sets, and terrain layers all connected to and generated through the SBSAR file.

Substance 3D for Unity is free and required for SBSAR use and procedural utilization.

Website: https://darkmattermagic.com/4grounds-e3/

SBSAR Manual: https://darkmattermagic.com/manual-sbsar/

More Unity Assets: https://darkmattermagic.com

Scene description

This is a Unity Asset representing a racing track in a winter snowy environment, optimized for drifting games, but can be easily adapted for circuit racing, drag racing or point-to-point racing.

The scene contains Unity terrain with multiple texture layers and object details (rocks, grass, cactus). The other objects present in the scene are: tires, signs (for speed and direction), checkpoint gates, trees, rocks.

The map can be traversed in both directions.

Elements in the scene are grouped and labeled. Each entry starts with the prefix rfd_ so these resources can be easily located in your project.

Structure

The Asset folder is organized with folders: Materials, Models, Prefabs, Textures.

Prefabs

The map makes use of prefabs. There are a total of 7 prefabs.

Each prefab has its scale set to 1 on all axes and its position set to 0 on all axes. Double click on a prefab allows you to edit it and its children. Note: Changes will modify each prefab instance.

Model: Vertices | Edges | Faces

Speed pole: 28 | 52 | 26

Race gate: 122 | 260 | 140

Road signs: 20 | 36 | 18

Rock: 1800 | 4700 | 2800

Tire group (30 tires): 11000 | 2300 | 11500

Tree: 400 | 800 | 430

Wood fence: 200 | 300 | 140

None of the models and prefabs contain animations.

All models are UV mapped.

Textures

On average, textures are 1024x1024px.

The texture size depends on it's purpose in scene, some objects have larger textures for more detail, other are smaller for far away placement.

All textures are in PNG format, some have an active alpha chanel (for example the plants).

All textures have been properly set up in the editor (for example normal maps are flagged appropriately).

There are no texture maps.

Lighting

The project makes use of Universal Render Pipeline (URP).

The entire map is lightmapped.

Note: modifying the scene might require a new lightmapping.

Light probes have been positioned in the map for best results when making use of them.

The sun is the only light in the scene that is not set to static and its mode is set to Mixed, so the lightmapping is faster and the scene is better optimized.

Models have the Generate lightmap UVs option checked for faster and better lightmapping.

Post processing

The scene has post processing applied. The following effects are being used: Bloom, Depth of Field, Vignette, Color Adjustments and Chromatic Aberration.

Collisions

Models have collisions applied to them. Most objects use the Box collider to calculate collisions faster.

Polygon count has been kept low, this track can be easily run or be optimized for mobile devices.

Notes

No audio, music, cars, scripts or other special effects are included in the package.

Help

You can contact me by email if you want me to help you with something regarding this map.

This meticulously crafted 3D asset features a winding, challenging track set in a winter landscape.

This is a Unity Asset representing a racing track, optimized for drifting games, but can be easily adapted for circuit racing, drag racing or point-to-point racing.

The map can be traversed in both directions.

TERRAINS

• 10 Scenes with different landscapes. (Texture Resolutions : 8192 x 8192 so 64km² / and their TerrainData)
• 10 Heightmaps. (Texture Resolutions : Up to 8192 x 8192)
• 10 Mask of : Leaves, Mud, Sand (and wet version), Cliff. (Texture Resolutions : Up to 8192 x 8192)
• 10 Brush of : Leaves, Mud, Sand (and wet version), Cliff. (Texture Resolutions : 4096 x 4096)
• 1 Terrain Material.
• 1 Terrain Lighting.
• 5 Terrain Layers.
• 5 Terrain Textures : Snow, Mud, Ice, Cliff. (Texture Resolutions : 1024 x 1024).
• Each terrain textures contain BaseColor, Normal and M.AO.R.

ASSETS

• Wind control on leaf, branch and trunk vegetation.
• Color, roughness, normal, AO and Height control on material assets.
• 1 Grass. (Texture Resolutions: up to 2048 x 2048)
• 3 Plants. (Texture Resolutions: up to 2048 x 2048)
• 3 Different Big Plants. (Texture Resolutions: up to 2048 x 2048)
• 4 Tropical trees. (Texture Resolutions: up to 2048 x 2048)
• 2 Palm Trees. (Texture Resolutions: up to 2048 x 2048)
• 2 Trees. (Texture Resolutions: up to 2048 x 2048)
• 2 Rocks. (Texture Resolutions: up to 2048 x 2048)
• 1 Tropical Plant. (Texture Resolutions: up to 2048 x 2048)
• Each Assets textures contain BaseColor, Normal and M.AO.R or Roughess.

This product is designed to give you huge island landscapes that can be used for gaming or cinematic purposes.

The goal was to offer you 10 different very detailed environments so that you can model your landscape as you wish.

If the goal is only to make a background landscape you can reduce de size, and there is enough details from close range if you want a map for game purposes.

- 5 different shape spacecrafts

- 6 different materials for each spacecrafts

- Prefabs and spacecraft prefabs with sample flymovement script

- 4096x4096 texture's resolutions

- Each Material has Base Color, Metallic, Roughness, Normal and Emission Template,

- tris and verts counts

SpaceCraft1 - 50k - 68.3k

SpaceCraft2 - 34.5k - 47.6k

SpaceCraft3 - 45.6k - 61.9k

SpaceCraft4 - 24.9k - 33.3k

SpaceCraft5 - 51.1k - 67.4k

P.S. : Tris and vertices counts are low when you open this fbx files in Blender.

- Sample Demo scene and fly and wander example

- 3 particle effect for smoke effect

- A sample skybox

.fbx and .obj meshes

You can use these spacecrafts in your science fiction games videos movies images and more.. There is 5 different shape spacecrafts and 6 different materials for each ship. So, you can use 30 different spacecraft in your project.

Also in this package includes,

a sample skybox,

FlyMovement, and camera scripts,

3 particles for spacecraft's smoke effect

If you have any more questions or problems, contact me via mail:

metinbuyukavcilar@gmail.com

also, you can check my other assets and games:

http://gamesmba.com

Number of textures: 3

Texture dimensions: 128*128

Minimum polygon count: 12

Maximum polygon count: 876

Number of prefabs: 63

Rigging: Yes

Animation: No

I hope this asset is useful for you.

Thank you

 Pack includes the environment, props, weapons and characters.

• Unity Version Compatibility: Works with Unity 2020.3 or higher (LTS preferred)
• Key Features:
• Event-Driven Architecture: Allows screens and components to react to system-wide events without direct dependencies, providing scalability and flexibility.
• Screen Transition Management: Includes options for both additive (keep current screens active) and exclusive (close all other screens) transitions, giving you control over how screens are displayed.
• Draggable UI Support: Offers draggable UI components with customizable drag areas to ensure seamless interaction for users.
• Configurable Screen Behavior: UIScreenConfig assets allow developers to define the behavior and settings of each screen (e.g., can the screen be closed, is it the initial screen, etc.) directly in the Unity editor.
• Screen Hierarchy and History: Handles parent-child relationships between screens, making it easy to nest screens within each other. The screen history allows users to navigate back to previous screens, maintaining a stack of opened screens.
• In-Game and Main Menu Managers: Includes dedicated managers for handling in-game UIs and main menus, providing a specialized solution for different parts of your project.
• Easy Extensibility: Developers can extend or replace any part of the system (e.g., adding custom screen types, transitions, or additional behaviors) thanks to the modular and open architecture.
• Performance Optimized: Designed to ensure that there’s minimal overhead, which makes the system ideal for both resource-constrained mobile platforms and high-end desktop applications.
• Dependencies:
• Text Mesh Pro: This package uses the com.unity.textmeshpro package.
  

If you have any questions about the package or its capabilities, please feel free to contact me: https://www.loags.de/contact/

This Unity UI System package offers a comprehensive and flexible solution for managing complex user interfaces. It is designed with an event-driven architecture, allowing for highly modular and decoupled components that can communicate efficiently without hard dependencies. Whether you're building a game with nested menus, HUDs, pop-up notifications, or application interfaces with multiple screens, this system can handle it with ease.

The system provides the ability to create and manage draggable screens, customizable screen configurations using ScriptableObject assets, and supports complex transitions between screens. With its screen hierarchy feature, it allows you to define parent-child relationships between screens, ensuring that UI screens can be nested, stacked, and managed according to your needs.

A core feature of the package is its history tracking, which stores the stack of opened screens. This enables smooth navigation between screens, including back navigation, making it ideal for multi-step menus or workflows in games and applications. Furthermore, the package includes built-in support for in-game UIs and main menu UIs, complete with configurable screen transition behavior.

In addition, the package is designed with performance in mind. It's optimized for mobile and desktop platforms, ensuring that it runs smoothly regardless of the device. The modularity of the package ensures that developers can extend, override, or replace any part of the system to fit their project needs.

Full README:

UI System for Unity created by: Loags

Overview

This project is a flexible and extensible UI management system for Unity, designed to handle complex user interface (UI) interactions such as screen transitions, hierarchy management, and screen event handling. The system is built with scalability and modularity in mind, enabling you to manage multiple screens and their relationships with ease, while offering robust customization through ScriptableObject configurations.

Features

- Event-driven Architecture: Uses an event bus (UISystemEventBus) to decouple interactions between UI components, ensuring loose coupling and scalability.

- Screen Transitions: Manages transitions between screens with support for additive and exclusive screen opening.

- Screen Hierarchy Management: Handles the relationships between screens (parent-child screens) through UIScreenNode structures.

- Screen History: Tracks the history of opened screens, enabling easy back navigation and the ability to restore previous states.

- Draggable UI Components: Supports draggable UI screens and components that can be moved around within a defined area.

- Customizable Screen Configurations: Screens can be customized using UIScreenConfig assets, enabling easy configuration in the Unity Editor.

- Pause Menu & In-Game UI Support: Special managers for handling pause menus and in-game UI elements, in addition to the main menu.

Structure of the System

The system is divided into several key components:

1. UISystemManager: The core class that manages the entire UI system. It handles event subscriptions, screen hierarchy management, transitions, and screen history tracking.
2. UIScreenConfig: A ScriptableObject asset that holds the configuration for each screen. This includes settings such as whether the screen is closable and whether it is the initial screen displayed when the system starts.
3. UIScreenNode: Represents a node in the UI screen hierarchy. Each node contains information about the screen, its parent and child relationships, and whether the screen is active.
4. UIScreenNodeManager: Manages the hierarchy of UI screens by creating nodes for each screen, and handling operations like finding, adding, or removing screens from the hierarchy.
5. UIScreenRegistrar: Responsible for registering screens with the system and ensuring that screens are placed in the correct spot in the hierarchy (either as root screens or children of other screens).
6. UIScreenTransitionManager: Handles screen transitions, such as opening and closing screens with animations or effects. Supports opening screens additively (without closing other screens) or exclusively (closing all other screens).
7. UIScreenHistoryEntry: Tracks entries in the screen history stack. This allows for back navigation and restoring previous screens when needed.
8. DraggableUIComponent: A component that allows a UI element to be draggable within a defined area. It implements Unity’s IDragHandler to handle drag events and manages resetting the position of draggable components.
9. UISystemScreenDraggable: A specialized version of UISystemScreen that adds support for draggable screens. Combines the functionalities of UISystemScreen and DraggableUIComponent.
10. UISystemEvents: Defines various events (e.g., opening, closing, registering screens) that are used to communicate between different components through the event bus.
11. This UI system offers a highly modular and scalable architecture, enabling developers to manage complex UI interactions with ease. The use of an event-driven design allows for decoupled components, making it easier to expand and maintain the system over time.UISystemEventBus: The event bus that handles the publishing and subscribing of UI events. This enables a decoupled communication system between UI components.
    
    How to Use the UI System
    
    1. Setting Up Screens
    
    1. Create a UIScreenConfig:
    - Right-click in the Project window and go to Create -> UI -> UIScreenConfig.
    - Configure the UIScreenConfig:
    - Screen ID: A unique string identifier for the screen (Will be generated automatically).
    - Can Be Closed: A boolean determining whether this screen can be closed by the user.
    - Is Initial Screen: Whether this screen is the first screen to open when the system starts.
    
    2. Create a Screen GameObject:
    - Create a new UI Canvas in the scene (representing the UI screen).
    - Attach a component that extends from UISystemScreen (or UISystemScreenDraggable if it is a draggable screen) to this GameObject.
    
    3. Assign the UIScreenConfig:
    - Assign the UIScreenConfig asset you created to the screen by attaching it to the UISystemScreen component.
    
    2. Managing Screens
    
    1. Open Screens:
    - Screens can be opened in two ways:
    - Exclusive: Opens a screen and closes all other screens.
    - Additive: Opens a screen while keeping the current screens active.
    
    Example:
    // Open a screen exclusively
    UISystemEventBus.Publish(new UIScreenOpenEvent(screenConfig, true));
    
    // Open a screen additively
    UISystemEventBus.Publish(new UIScreenOpenEvent(screenConfig, false));
    
    2. Close Screens:
    - You can close a specific screen, close the last opened screen, or close all screens.
    
    Example:
    // Close a specific screen
    UISystemEventBus.Publish(new UIScreenCloseEvent(screenConfig));
    
    // Close the last opened screen
    UISystemEventBus.Publish(new UIScreenCloseLastEvent());
    
    // Close all screens
    UISystemEventBus.Publish(new UIScreenCloseAllEvent());
    
    3. Pause Menu Integration:
    - For in-game UIs, you can integrate a pause menu by using the UISystemManagerInGame. This manager includes additional functionality to handle the escape key and toggle the pause menu.
    
    3. Adding Draggable Screens
    
    1. Draggable Screens:
    - To create draggable screens, use the UISystemScreenDraggable component. Ensure the screen has a RectTransform and attach the DraggableUIComponent to handle drag events.
    
    2. Configuring Drag Area:
    - The DraggableUIComponent includes an optional draggableArea property. Assign a RectTransform to this field to constrain the draggable screen within a specific area.
    
    4. Screen Hierarchy and History
    
    1. Hierarchy Management:
    - The system automatically manages the hierarchy of screens through UIScreenNode objects. Screens can have parent-child relationships, and these relationships are reflected in the screen's Transform hierarchy.
    
    2. Screen History:
    - The system tracks the history of opened screens in a stack. You can navigate back to previously opened screens by closing the current screen, which automatically restores the previous screen in the history.
    
    Customization
    
    1. Adding New Screen Types:
    - You can extend the UISystemScreen class to create custom behavior for different screen types.
    - Example: If you want a specialized in-game menu, you can create a class that extends UISystemScreen and adds new features specific to in-game behavior.
    
    2. Custom Screen Transitions:
    - You can extend or modify the UIScreenTransitionManager to add new types of screen transitions (e.g., sliding animations, fades, etc.).
    
    Troubleshooting
    
    1. Screen Not Showing:
    - Ensure that the screen's UIScreenConfig is correctly assigned.
    - Verify that the Canvas containing the screen is active and enabled.
    
    2. Screen Not Draggable:
    - Ensure the DraggableUIComponent is attached and configured correctly.
    - Verify that the draggableArea is correctly assigned (if you want to restrict the draggable area).
    
    Future Improvements
    
    - Animation Integration: Adding more detailed animations for screen transitions.
    - Dynamic Loading: Support for dynamically loading screens.
    - Improved Drag Constraints: Add more complex drag constraints, such as snapping the screen to specific positions.
    - Custom screen size: Add custom screen resize during game to modify screen sizes
    
    

Number of Prefabs:

x12 pieces

x1 board

Number of Textures: one for each prop

Texture Dimensions: 64x64, 128x128, 256x256

Polygon Count of Models:

Minimum Polygon Count: 12 (tile)

Maximum Polygon Count: 494 (knight)

Rigging: No

Animation Count: 0

UV Mapping: Yes

This free 3D voxel art chess set includes all the essential pieces and a board, designed in a minimalist, low-poly style. Each chess piece is separated, allowing you to easily customize the materials to match your project's visual style. The chessboard is also divided into separate materials, making it simple to customize its appearance as well. Whether you're creating a game, an interactive application, or simply need a stylized chess set for your scene, this pack offers a versatile and easy-to-use solution. Perfect for developers looking for a lightweight, customizable chess set to integrate into their projects.

An Easy to use modular system using a 1.5 meter scale factor

Textures are at 256x256 Pixels

The use of a PSX shader pack is highly recommended like the

Valerie Moza's PSX Shader Kit

(*With PSx Era Style i mean Late PS1/Early PS2 Style)

This packs contain most of what you need to get started making your Horror/Creepy game in a PSX Style

Modular content is scaled to 1.5meters be sure to set it in the grid if you having snapping problems.

The pack also contain a little demo scene that showcase a small part of the pack ( You have to use Valerie Moza's PSX Shader Kit pack if you want to achieve the same result ast shown in video & images )

Demo scene contains also some uselfull (commented)script that you can easily adapt to your needs and some that are for specific objects like the CCTV camera movement or the Air Contitioner to make the fan spin

The Package Include:

180 3D Models including:

- Air Conditioner external unit

- ATM

- Bathroom Stall & Door

- Toilet

- Plunger

- Toilet Paper Roll

- 2x Brooms

- 1 Normal Bucket (3 Variants)

- Bycicle Stand

- Cashier Desk

- Cash Register

- Cash Drawer

- Coffee Table

- Crate Trolley

- 2x CRT Monitors

- Desk Trashcan

- 3x Display Tables

- 2x Doors

- Dust Pan

- 2x Fire Extinguisher

- 3x Flashlights

- 3x Lanterns

- 3x Box Flashlights

- DType Battery(for Flashlights)

- Wax Candle

- Oil Can (for the Lantern)

- Fluorescent Light (Base + Lamp + Broken pieces)

- Wall Freezer

- ICE Box

- Street Lamp

- Street Lights

- Mailbox (2 variant)

- Mop

- Mop Bucket

- 3x Pallets

- 1 Payphone (Single entity or modular + Keycode numbers + 2x handset version)

- Pizza (Full and 8 Sliced)

- Pizza Box (Both open and closed)

- Power Box (+ Door)

- Tin Cans (4 variant)

- Newspaper box (2 variant)

- Security Camera

- 3x Signs

- 2x Dumpsters

- 2x Trashcan

- 5x Small Trashcan

- 3x Trash Bags

- 2x Vending Machines

- 38x Modular Building Pieces

8 Usefull sounds:

- 2x Automatic Door Opening

- 2x Automatic Door Closing

- Fluorescent Light Buzzing Loop

- Fluorescent Light Explosion

- Fluorescente Light Start

- Phone Ringing Loop

Over 200 Textures:

Some are Tileable and extremely versatile

Most of the props

Total poly count of the Showcase scene is 139272 Vertx wich divided by 180 result in a 773 vertex medium(257 faces medium per model)

All models are fully unwrapped and Textures can easily be modified and customizable

Technical details

Polycounts:

Trees 3k - 4k tris

Bushes 1k - 2k tris

Grass 2 - 150 tris

flowers 60 - 225 tris

Mushrooms 400 - 600 tris

clifs 1k - 2.4k tris

Rocks 300 - 550 tris

Textures info:

texture 2k/4k

Textures format - PNG

you can check my other FREE packs here :

Medieval Props V1 / Medieval Props V2 / LowPoly Trees Pack

Create stylized fantasy worlds with our collection of nature assets.

Compatible only with Built-In and Universal render pipelines.

Package Content:

3D Models (31):

Trees (3)

Bushes (3)

Grass (3)

flowers (8)

Mushrooms (5)

Clifs (5)

Rocks (4)

+ Prefabs :

every mesh have its own prefabs

+ Others :

skybox (4)

Terrain layers (2)

+ Textures :

every model have texture (base , roughness , normal)

trees have multiple leaf texture

+ Demo

my SOCIALS :

X

INSTAGRAM

2048x2048 Teture size

10 - Prerab (Unique portals)

Texture Sheet - 2048x2048 

Particle System

Easy to scale
Demo scenes included

VIDEO NO POST EFFECT( Friendly mobile)

The package contains 15 hand-painted diffuse textures in high resolution (2048x2048). All the maps are ready to be used for any project in *.tga format.

Content:

• 5 Sand
• 5 Grass
• 5 Grass+Flowers

An example of using textures is shown in the asset: Stylized Fantasy Vegetation 4

Each texture is tiled/seamless and fully compatible with various Unity renderings: Built-in, URP, HDRP.

Number of textures: 6 (4 - albedo, 2 - normal)

Texture dimensions 4096

Minimum polygon count 100

Maximum polygon count 1000

Number of meshes: 17

Number of prefabs: 34

UV mapping: Yes

LOD information (count, number of levels) No

Types of materials and texture maps (e.g., PBR) BaseColor, NormalMap

This asset includes 3D models with stylized textures - props for creating a dog park with agility obstacles. There are 17 models in total, each has 2 skins, a total of 34 prefabs.

What's inside:

• Ball fountain with a VFX water 
• Hydrant fountain with a VFX water 
• Bone bench
• Large sign
• Medium sign
• Dog parking sign
• A-obstacle
• Tire jump
• Big jump obstacle
• Small jump obstacle
• Poles
• Feet poles
• Dog play complex
• Titre obstacle
• Pause Table
• Dog pool
• Tunnel

Elements included:

• 12 unique explosions
• Base color, six point light (TLR and BBF) and emissive textures included
• All textures are 2048x2048
• All particles system are drag-and-drop and ready to use
• Documentation included with usage instructions

This pack contains 12 explosion effects and includes a custom 6D lighting shader, allowing them to dynamically respond to the lighting in your environment. Each explosion is drag-and-drop and ready to be used in your projects with no additional setup required.

This package includes a font distributed under the SIL Open Font License. For more details, see the included Third-Party Notices.txt file

Features:

• 15 different models of fountains;
• 2 materials for each fountain model (light and dark materials);
• Height of fountains - from 0.7 to 5 meters.

Number of Unique Meshes: 15

Collision: No

Triangles Count: from 800 to 6000 tris.

LODs: No.

Number of Materials and Material Instances: 30 (2 materials for each fountain model).

Number of Textures: 120 ( Albedo + AO + MetallicSmoothness+ Normal for each material).

Texture Resolutions: 4096x4096.

The package contains a set of ancient concrete fountains.

15 models of fountains. 2 materials for each fountain model (light and dark materials).

For any questions, email me. Enjoy.

Resolution: 256x256, 128x128, 64x64, 32x32

500 Halloween theme sprites

Note Environment assets are not included in this package

Features:

• Uses the Unity physics engine.
• Support slippery surfaces.
• Easy to implement.
• Demo scene included
• Player graphic included
• Sounds Included (X22)
• Animations Included
• Funny character movement

Demo:

1. CrazyGames (Web)

2. Play Store

Elevate your 2D game development with this all-in-one climbing simulator package designed for Unity. Whether you're building a rock-climbing adventure or a parkour challenge, this package provides everything you need to create dynamic and engaging climbing mechanics. Powered by Unity's internal physics engine, it guarantees compatibility with all Unity Physics 2D components, ensuring smooth integration into your project.

The package features a versatile climbing controller supporting dynamic and static rigid bodies, allowing for funny character movement and interaction. Additionally, it accommodates surfaces with varying friction levels, adding depth and challenge to your gameplay.

With this package, you can easily implement responsive and realistic climbing mechanics, saving time on development and focusing on crafting an immersive experience for your players. Perfect for developers of all skill levels, this toolset empowers you to bring your climbing simulator vision to life.

Note Environment assets are not included in this package