Giter VIP home page Giter VIP logo

docs's Introduction

OpenRCT2 logo

OpenRCT2

An open-source re-implementation of RollerCoaster Tycoon 2, a construction and management simulation video game that simulates amusement park management.


OpenRCT2.org Group Park 5


Download

Latest release Latest development build
OpenRCT2.org OpenRCT2.org

Chat

Chat takes place on Discord. You will need to create a Discord account if you don't yet have one.

If you want to help make the game, join the developer channel.

If you need help, want to talk to the developers, or just want to stay up to date then join the non-developer channel for your language.

If you want to help translate the game to your language, please stop by the Localisation channel.

Language Non Developer Developer Localisation Asset Replacement
English Discord
Discord
Discord Discord Discord
Discord
Nederlands Discord

Contents


1. Introduction

OpenRCT2 is an open-source re-implementation of RollerCoaster Tycoon 2 (RCT2). The gameplay revolves around building and maintaining an amusement park containing attractions, shops and facilities. The player must try to make a profit and maintain a good park reputation whilst keeping the guests happy. OpenRCT2 allows for both scenario and sandbox play. Scenarios require the player to complete a certain objective in a set time limit whilst sandbox allows the player to build a more flexible park with optionally no restrictions or finance.

RollerCoaster Tycoon 2 was originally written by Chris Sawyer in x86 assembly and is the sequel to RollerCoaster Tycoon. The engine was based on Transport Tycoon, an older game which also has an equivalent open-source project, OpenTTD. OpenRCT2 attempts to provide everything from RCT2 as well as many improvements and additional features, some of these include support for modern platforms, an improved interface, improved guest and staff AI, more editing tools, increased limits, and cooperative multiplayer. It also re-introduces mechanics from RollerCoaster Tycoon that were not present in RollerCoaster Tycoon 2. Some of those include; mountain tool in-game, the "have fun" objective, launched coasters (not passing-through the station) and several buttons on the toolbar.


2. Downloading the game (pre-built)

OpenRCT2 requires original files of RollerCoaster Tycoon 2 to play. It can be bought at either Steam or GOG.com. If you have the original RollerCoaster Tycoon and its expansion packs, you can point OpenRCT2 to these in order to play the original scenarios.

OpenRCT2.org offers precompiled builds and installers of the latest master and the develop branch. There is also a Launcher available for Windows and Linux that will automatically update your build of the game so that you always have the latest version.

Flathub offers flatpaks for Linux distributions that support this application distribution system:

Some Linux distributions offer native packages already. These packages are usually third-party, but we're trying to resolve issues they are facing.

Some *BSD operating systems offer native packages. These packages are usually third-party, but we're trying to resolve issues they are facing.


3. Building the game

3.1 Building prerequisites

OpenRCT2 requires original files of RollerCoaster Tycoon 2 to play. It can be bought at either Steam or GOG.com.

Windows prerequisites
  • Visual Studio 2022 (Enterprise / Professional / Community (Free))
    • Desktop development with C++
  • MSYS2 MinGW Toolchain. The toolchains with supported dependencies are mingw-x86_64, mingw-xi686, ucrt-x86_64, clang-x86_64, and clang-xi686, each of these require the $MINGW_PACKAGE_PREFIX and msys and clangarm-64 are lacking packages for some dependencies
    • sdl2 (only for UI client)
    • freetype (can be disabled)
    • fontconfig (can be disabled)
    • libzip (>= 1.0)
    • libpng (>= 1.2)
    • speexdsp (only for UI client)
    • curl (only if building with http support)
    • nlohmann-json (>= 3.6.0)
    • openssl (>= 1.0; only if building with multiplayer support)
    • icu (>= 59.0)
    • zlib
    • gl (commonly provided by Mesa or GPU vendors; only for UI client, can be disabled)
    • cmake
    • benchmark (optional)
    • innoextract (optional runtime dependency; used for GOG installer extraction during setup)
    • libogg
    • libvorbis
    • flac

See the wiki for the actual package names used in pacman.

macOS prerequisites
  • Xcode Command Line Tools
  • Homebrew
  • CMake (available through Homebrew)
Linux prerequisites
  • gcc (>= 8.0) or clang (>= 10.0) (for C++20 support)
  • sdl2 (only for UI client)
  • freetype (can be disabled)
  • fontconfig (can be disabled)
  • libzip (>= 1.0)
  • libpng (>= 1.2)
  • speexdsp (only for UI client)
  • curl (only if building with http support)
  • nlohmann-json (>= 3.6.0)
  • openssl (>= 1.0; only if building with multiplayer support)
  • icu (>= 59.0)
  • zlib
  • gl (commonly provided by Mesa or GPU vendors; only for UI client, can be disabled)
  • cmake
  • innoextract (optional runtime dependency; used for GOG installer extraction during setup)

Refer to https://github.com/OpenRCT2/OpenRCT2/wiki/Building-OpenRCT2-on-Linux#required-packages-general for more information about installing the packages.


3.2 Compiling and running

Windows:

Show instructions
  1. Check out the repository, this can be done using GitHub Desktop or other tools

  2. Open a new Developer Command Prompt for VS 2022

  3. Navigate to the repository (e.g. cd C:\GitHub\OpenRCT2)

  4. To build the x64 version, use msbuild openrct2.proj /t:build /p:platform=x64 To build the x86 version, use msbuild openrct2.proj /t:build /p:platform=Win32 To build the Arm64 version, use msbuild openrct2.proj /t:build /p:platform=arm64

    Note: The file g2.dat may not be generated on cross-compilation (e.g. building for Arm64 on a x64 machine). In this case g2.dat must be copied from a x86/x64 build.

  5. Run the game, bin\openrct2

Once you have ran msbuild once, further development can be done within Visual Studio by opening openrct2.sln. Make sure to select the correct target platform for which you ran the build in point #3 (Win32 for the x86 version, x64 for the x64 version, arm64 for the Arm64 version), otherwise the build will fail in Visual Studio.

Other examples:

set platform=x64
msbuild openrct2.proj /t:clean
msbuild openrct2.proj /t:rebuild /p:configuration=release
msbuild openrct2.proj /t:g2
msbuild openrct2.proj /t:PublishPortable

macOS:

Show instructions

CMake can build either a self-contained application bundle, which includes all the necessary game files and dependencies, or it can build a command line version that links against system installed dependencies. CMake will retrieve the dependencies from Dependencies automatically. You can build the macOS app using CMake using the following commands:

cmake -S . -B build
cmake --build build --target install

Then you can run the game by opening OpenRCT2.app

To build the command line version, you'll need to disable the macOS app bundle:


cmake -S . -B build -DMACOS_BUNDLE=off
cmake --build build
cmake --build build --target install
ln -s ../data data

Then you can run the game by running ./openrct2.

To link against system dependencies instead of letting CMake download the dependencies from Dependencies, add -DMACOS_USE_DEPENDENCIES=off to your cmake args.

Detailed instructions can be found on Building OpenRCT2 on macOS using CMake.

Linux:

Show instructions

The standard CMake build procedure is to install the required libraries, then:

cmake -S . -B build -DCMAKE_INSTALL_PREFIX=. # set your standard cmake options, e.g. build type here - For example, -DCMAKE_BUILD_TYPE=RelWithDebInfo
cmake --build build # you can parallelise your build job with e.g. -j 8 or consider using ninja
cmake --build build --target install # the install target creates all the necessary files in places we expect them

You can also use Ninja in place of Make using -G Ninja in the first command, if you prefer, see Wiki for details.

Detailed instructions can be found on Building OpenRCT2 on Linux.

Note: the cmake -S . -B build syntax is available for CMake >= 3.14. For older versions use:

mkdir build
cd build
cmake .. -DCMAKE_INSTALL_PREFIX=. # set your standard cmake options, e.g. build type here - For example, -DCMAKE_BUILD_TYPE=RelWithDebInfo
cmake --build . --target install

4. Contributing

OpenRCT2 uses the gitflow workflow. If you are implementing a new feature or logic from the original game, please branch off and perform pull requests to develop. If you are fixing a bug for the next release, please branch off and perform pull requests to the correct release branch. master only contains tagged releases, you should never branch off this.

Please read our contributing guidelines for information.

4.1 Bug fixes

A list of bugs can be found on the issue tracker. Feel free to work on any bug and submit a pull request to the develop branch with the fix. Mentioning that you intend to fix a bug on the issue will prevent other people from trying as well.

4.2 New features

Please talk to the OpenRCT2 team first before starting to develop a new feature. We may already have plans for or reasons against something that you'd like to work on. Therefore contacting us will allow us to help you or prevent you from wasting any time. You can talk to us via Discord, see links at the top of this page.

4.3 Translation

You can translate the game into other languages by editing the language files in data/language directory. Please join discussions in the #localisation channel on Discord and submit pull requests to OpenRCT2/Localisation.

4.4 Graphics

You can help create new graphics for the game by visiting the OpenGraphics project. 3D modellers needed!

4.5 Audio

You can help create the music and sound effects for the game. Check out the OpenMusic repository and drop by our #open-sound-and-music channel on Discord to find out more.

4.6 Scenarios

We would also like to distribute additional scenarios with the game, when the time comes. For that, we need talented scenario makers! Check out the OpenScenarios repository.


5. Licence

OpenRCT2 is licensed under the GNU General Public License version 3.


6. More information

Similar Projects

OpenLoco OpenTTD openage OpenRA
icon_x128
Chris Sawyer's Locomotion Transport Tycoon Deluxe Age of Empires 2 Red Alert

7. Sponsors

Companies that kindly allow us to use their stuff:

DigitalOcean JetBrains Backtrace
do_logo_vertical_blue svg jetbrains backtrace
Hosting of various services CLion and other products Minidump uploads and inspection

docs's People

Contributors

gymnasiast avatar halfbro avatar intelorca avatar mzmiric5 avatar rpstester avatar samuel-w avatar say25 avatar sweet-tan avatar telk5093 avatar

Stargazers

 avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar

Watchers

 avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar

docs's Issues

Document how to use track designs

There should be documentation covering how to save/load track designs.

This should include things like adding scenery/paths to a design and placing the design (mirroring, rotating).

Document how to use viewports and the map view

There should be documentation on how the many views in OpenRCT2 work. Things like zooming in/out, rotating the camera, viewing underground, and the map view should be covered in this section.

There should be some extra focus placed on the new OpenRCT2 features like cut away view and highlight path issues and how they work.

Document how to use the financial summary screen

There should be documentation for how the financial summary screen works, and how to open it.

There should also be info on how to take out a loan, how to start marketing campaigns, and how to set research funding.

Make installation pages more complete

Currently, most of the documentation is spread out around openrct2.org, openrct2.io, the GitHub wiki, Reddit posts and docs.openrct2.io. The goal is to concentrate all this documentation in one place (and link to it from the older sources). Also, much of the documentation is written in a quite generic way, while the docs can give more specific instructions for every operating system, hopefully increasing its user-friendliness.

  • Windows
    • Installing OpenRCT2
    • Retrieving files from RCT2
    • Retrieving files from RCT Classic + Mini Game
    • Retrieving files from RCT1
  • macOS
    • Installing OpenRCT2
    • Retrieving files from RCT2: disc
    • Retrieving files from RCT2: GOG
    • Retrieving files from RCT2: Steam
    • Retrieving files from RCT Classic + Mini Game
    • Retrieving files from RCT1: disc
    • Retrieving files from RCT1: GOG
    • Retrieving files from RCT1: Steam
  • Linux
    • Installing OpenRCT2
      • Distro-specific
      • AppImage
      • Compiling yourself
    • Retrieving files from RCT2: disc
    • Retrieving files from RCT2: GOG
    • Retrieving files from RCT2: Steam
    • Retrieving files from RCT Classic + Mini Game
    • Retrieving files from RCT1: disc
    • Retrieving files from RCT1: GOG
    • Retrieving files from RCT1: Steam

Document some basics on placing and modifying scenery

There should be documentation covering how to create scenery, how to paint the scenery that supports it, and how to use features like the foresting feature, using the control key to select a height to build at, how to use the shift key to raise/lower objects, and other things needed for basic scenery usage.

Document how to create custom content

There should be documentation for how to create custom content. There should be sections for:

  • Creating Custom Shops
  • Creating Custom Vehicles
  • Creating Custom Rides
  • Creating Custom Scenery
  • Creating Custom Scenery Sets
  • Creating Custom Entrances
  • Creating Custom Water/Palettes

Document installation process on MacOS X

In order to complete the installation section, there should be a page of documentation detailing how to install OpenRCT2, similar to the one that already exists for Windows.

This page should cover common mistakes/issues (if any) when installing on MacOS.

In addition, maybe it would be useful to cover how to get the files from Steam, since it can't normally be downloaded for MacOS as far as I'm aware (you have to manually download the game files using a command line iirc).

Document how to construct tower based rides

Document how to build things like observation towers, lifts, etc.

The main thing to cover is that they sometimes utilize some kind of special track piece to "cap off" their tops or create another station.

Document how to use the scenario editor

There should be documentation / a tutorial about how to use the scenario editor.

This section will be fairly big and should cover these main topics:

  • Choosing Objects
  • Random Map Generator
  • Setting The Park Perimeter
  • Setting Research Order
  • Setting Park Options
  • Setting Scenario Options
  • Converting Saved Games To Scenarios

Document how to construct flat rides

There should be documentation on how flat rides are constructed.

Since this section is fairly simple, maybe giving some information like stats on a per-ride basis could be useful?

Document how to run a dedicated server

There should be documentation that covers how to run a dedicated server for OpenRCT2. This should cover things like OpenRCT2 user permissions, starting the server using systemd, and other handy things to know when running OpenRCT2 on Linux in headless mode.

Should this documentation cover "basic" server things such as port forwarding and good network security practices, or should it focus on just how to get OpenRCT2 running in a headless mode?

Document installation process on Linux

In order to complete the installation section, there should be a page of documentation detailing how to install OpenRCT2 for Linux, similar to the one that already exists for Windows.

This page should cover common mistakes/issues (if any) when installing on generic Linux in addition to specific common Linux distros (Ubuntu, Debian, Arch? we can decide which ones, probably the ones there are packages for).

In addition, maybe it would be useful to cover how to get the files from Steam, since it can't normally be downloaded for Linux as far as I'm aware (you have to manually download the game files using a command line iirc).

Document managing user content

There should be documents about managing custom user content such as custom music, save files, rides, etc.

There's probably some more that I'm missing, but I'm not sure what OpenRCT2 allows users to do in so far as custom content.

Document how to build roller coasters

There should be documentation covering how to build effective roller coasters.

This includes, but is not limited to:

  • Controlling G-Forces
  • Using Brakes
  • Using Block Brakes
  • Creating Launch Powered Coasters
  • Creating Multiple Stations
  • Creating Synchronised / Dueling Coasters

This is going to be a particularly large section, it might be useful to get some basic information down first, then we could add specific things in later (like how certain coasters get bonuses/penalties for # of inversions, how intensity can penalize excitement)

Document how park rating is calculated

There should be documentation on how the park rating is calculated, and therefore what things impact the rating the most.

Perhaps we could also roll up park awards into this section as well?

Document generic ride information (ratings, admission price, popularity, maintenance)

There should be some ride-agnostic documentation related to ride ratings, admission price, popularity, and maintenance costs - what the actual numbers are, how they affect pricing, how to manage them.

Individual ride types would get their own information if they need to expand on these things (roller coasters can control their stats much more than something like bumper cars can, for example).

Document game settings and options

There should be documentation for each of the main settings and options for the game.

For things related to rendering, there should be on/off preview images for each setting so the user can easily see what the effect is.

This would cover the "Configuration settings" and "Options" headers in toc.md

Document how to manage guests

There should be information about how to manage guests.

This should cover things like how to find a guest's current stat levels, the amount of money they have left, what they are carrying, and how to view a summary of all guests' thoughts about the park.

Wrote a title sequence tutorial and was recommended to post it here, don't have permission

I wrote a tutorial on the title sequence editor, but I don't have permission to post documents. Could someone with said permission copy the following text into a document? I would prefer to have it in the playing subfolder of the docs folder.

Gustav Goblin's Title Sequence Tutorial

One of OpenRCT2's unique new features is the ability to make your own title sequences. These are made in the title sequence editor, which uses a series of simple commands to dictate where the camera goes and how long it stays in one location.

Creating a title sequence

The title sequence editor can be loaded at any point in the game from the options menu. The editor is located in the tab with the spiral slide. (1). To create a new title sequence, click "Edit Title Sequences" (2) and click Create (3.) A window will appear asking for a name. Enter the name and click OK (4).

1

Loading a park

Once your title sequence is created and named, you'll still need to add it to the sequence. Go to the floppy disk tab (1) and click Add (2). A window will pop up with all your parks listed, much like the regular load save window. Click the park you want and it will appear in the list of parks in the title sequence. (3) You can add multiple parks to a title sequence, but for simplicity's sake, we'll just be using this one.

2

From there, go to the last tab in the title sequence page, the command editor (1). Click Insert (2) and select "Load Save" from the command drop-down list. The park(s) you added in the floppy disk tab will appear in the "Save to load" drop-down window. Since we're only using one park, it will be the only park that appears in the list. Select your park and click OK (3). The command to load the park will appear in the title sequence editor.

3

Location

Before we do anything else, it's a good idea to go back to the floppy disk tab and load the park you're using by clicking on it and then clicking Load. This will load the park and allow you to freely navigate.

One of the two most important commands in a title sequence is Location. This command uses a pair of coordinates to tell the camera where to be. Click Insert again (1) and select Location from the drop-down Command list (2). If you position the camera on where to start before inserting the command, your location will automatically appear in the coordinates. However, should you want to change the location after inserting the command, move the camera where you want it to be and click Get (3). This will change the coordinates to your current location. Once you're satisfied with your coordinates, click OK (4.)

4

Something worth noting is the location command can be finicky and not be exactly where you want it to be. If this is the case, select the location command once it's in the list and click Edit. From there, you can tweak the coordinates until you're satisfied. What I like to do is shrink the ORCT2 window to the smallest possible size (the resolution you see in this screenshot) when selecting my coordinates so I can center them better.

Wait

The second of the two essential commands is Wait. This command tells how long the camera stays in a certain location. The default time is 10,000 milliseconds, which translates to 10 seconds. While it may be tough to get used to milliseconds (removing the last three zeroes is an easy way to convert from milliseconds to seconds), this allows for more precise timing in title sequences.

The wait command is inserted in the same way as the location command, with the only variable value being the length of the wait. However, the wait command needs to come after location or any similar commands, as placing it above them will render them useless.

5

Playing and Zoom

Now that we've added a sequence of commands to our title sequence, it's a good idea to preview your title sequence to make sure it looks good. To preview the title sequence, click the play button which is being pressed in the screenshot. When we play our sequence, we notice the screen is zoomed out a bit! This isn't what we want, so we'll need to add a zoom command.

6

Click Insert again and change the command to Zoom. Zoom in to the desired level (location doesn't matter) and press Get (1). Press OK once you're satisfied with your zoom level (2).

7

Title sequences can get long, and playing the whole thing just to check one part is very tedious. This is where Skip To comes in. While playing a title sequence, clicking a command in the title sequence editor and then clicking Skip To will skip to the selected command. It's very useful for longer title sequences.

Rotate

The ride pictured below would make a great focal point for our title sequence, but we need to rotate the camera to see it properly. This means that along with the location and wait commands, we'll need a rotate command as well. One anticlockwise rotation is equal to one click of the rotate button in regular gameplay. Since the angle we want requires two presses of the rotate button, we'll need to enter a value of 2 into the anticlockwise rotations. Remember to put the wait command after the location and rotate commands!

8

Follow Sprite

After our first two shots, we have a nice view of Ozymandias' Revenge curving around this fountain. We could keep the camera here and watch it run its course, but it would pick up the pace if we followed it to the station.

As usual, insert a new command and change the command to Follow Sprite (1). Click Select Sprite (2) and click the sprite you want to follow. In this case, we'll be following Ozymandias' Revenge, so we'll click on the first car of the train. (You can select the other cars of the train as well.) The window under the Select Sprite button should change based on what you selected. Click OK after you're satisfied with the sprite you want to click (4). It's worth noting this doesn't require a location command since our location is focused on the coaster, although you could use a rotate command if you want to change the angle.

8 5

Follow Sprite isn't just limited to tracked rides. You can also follow guests and staff! Additionally, following a flat ride centers the camera on the ride without the use of a location command, something I find really neat.

Other commands

There are many more commands you can use in a title sequence. Load Scenario is self-explanatory; it loads a scenario from the scenario selection screen instead of a save game. You can use multiple load save/scenario commands in a title sequence if you want to feature multiple parks. Just place one after a wait command and continue the process as normal.

Speed is an easy command to use. Just place one alongside a location command and change the speed to your desired setting. The speed settings are the same as the ones ingame; normal, quick, fast, and turbo. However, hyper speed is unavailable for use in title sequences. It's recommended to put a Restart command at the end of a title sequence, although I've found a title sequence will restart regardless.

9

Conclusion

A good idea is to open the default title sequences in the title sequence editor and analyze them. Observe where they choose to focus and how long they stay there. The first shot of RCT1's title sequence has become iconic not just among the RCT community, but among many gamers as a symbol of PC nostalgia.

Even when you master the commands of the title sequence editor, you can still go further. Tell stories with your title sequences. Take viewers on a tour of your favorite park. Have a title solely focused on following your favorite roller coaster or a train that goes around the park. You could even make a stop motion animation using quick wait commands! The title sequence editor has limitless potential, and it's up to you to determine what you do with it.

Document how to construct generic track based rides

There should be documentation going over how to build generic track based rides.

This is probably going to be the largest amount of work in this subsection, because most rides use this style of building. There should be information about using the construction menu in general, what each of the buttons do, using special track types, and probably a couple of other things I'm forgetting at the moment.

This section should not cover things like banking, which will be covered in the roller coaster section.

Recommend Projects

  • React photo React

    A declarative, efficient, and flexible JavaScript library for building user interfaces.

  • Vue.js photo Vue.js

    ๐Ÿ–– Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.

  • Typescript photo Typescript

    TypeScript is a superset of JavaScript that compiles to clean JavaScript output.

  • TensorFlow photo TensorFlow

    An Open Source Machine Learning Framework for Everyone

  • Django photo Django

    The Web framework for perfectionists with deadlines.

  • D3 photo D3

    Bring data to life with SVG, Canvas and HTML. ๐Ÿ“Š๐Ÿ“ˆ๐ŸŽ‰

Recommend Topics

  • javascript

    JavaScript (JS) is a lightweight interpreted programming language with first-class functions.

  • web

    Some thing interesting about web. New door for the world.

  • server

    A server is a program made to process requests and deliver data to clients.

  • Machine learning

    Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.

  • Game

    Some thing interesting about game, make everyone happy.

Recommend Org

  • Facebook photo Facebook

    We are working to build community through open source technology. NB: members must have two-factor auth.

  • Microsoft photo Microsoft

    Open source projects and samples from Microsoft.

  • Google photo Google

    Google โค๏ธ Open Source for everyone.

  • D3 photo D3

    Data-Driven Documents codes.