(Quick Reference)

Little Goblin Plugin - Reference Documentation

Authors:

Version: 0.3.2

1 Introduction

Little Goblin is an open source browser game framework that is intended to help you to create browser games. The goal is to have all the infrastructure in place allowing you to implement your idea as fast as possible, because the quickest way to bring (hobby) game development to a halt is (in my experience) to get bogged down in a quagmire of administrative tasks and configuration details. The Little Goblin framework strives to speed up your development without having to handle all the fundamental stuff, like user accounts, security, administration features and so on.

Of course, as it is in Grails, so should be in this framework: just because the framework makes it easy to ignore the underlying complexity at first, you can always dig deeper and hack and improve the system.

License

Little Goblin is licensed under the Apache License 2.0 - in short this means you can use it for commercial and non-commercial purposes and it comes without any warranties.

Contact / Links

  • Project Admin: Ingo Wiarda / ingo_wiarda@dewarim.de
  • Demo Website: http://schedim.de
  • Blog for LittleGoblin: http://dewarim.com
  • Documentation: http://littlegoblin.de
  • Sourceforge page: http://sourceforge.net/projects/littlegoblin
  • GitHub page: https://github.com/dewarim/LittleGoblin

1.1 Change Log

Version 0.3.2 "Tick-Tock"
  • Fixed #3: add gameName config parameter as default title to pages.
  • Changed: Run game ticks in a background thread (no more need for a cron job to run ticks).
  • Fixed #14: Version link in footer was broken.

Version 0.3.1 "Resume"

  • Fixed: admin can edit ItemTypes again.
  • New: admin can assign categories to item types.
  • Fixed: inputValidationService no longer croaks on 'null'-String.
  • Cleanup code.
  • Added more documentation (items, guilds)
  • Project is now language level Java 7
  • Grails 2.2.0

Version 0.3.0 "Cleanup" (a lot of internal changes)

  • Updated to Grails 2.1.1.
  • Fixed session handling.
  • Fixed HTML error in /goblinOrder/_order_list
  • Refactoring pages to use sitemesh layout instead of using homebrew solution.
  • Fixed item filter: remove unnecessary conversion of list to array. (ItemService).
  • Removed old prototyps JS-library files since we have been using jQuery for some time.
  • Fixed message id in highscore.gsp.
  • Added more documentation.
  • Added custom equals & hashCode to many domain classes.
  • Fixed: do not double-encode chatterbox messages.
  • Fixed: textarea in chatterbox.
  • Removed redundant "def inputValidationService", which is inherited from BaseController.

Version 0.2.7

  • Fixed cronGoblin and CronController for recurring events (would previously go into an infinite loop).
  • Added configurable registration with confirmation mail.
  • Added testMode parameter to config file.
  • Updated spring-security-core plugin
  • Added FeatureAdminController.
  • Upgraded to Grails 2.1.1

2 Installation

2.1 Installing the binary package

Please install / configure the following software packages to get started with the Little Goblin binary package:

Download the binary package

Download the binary package Little Goblin Binary

Java

Download and install the Java 7 runtime from http://java.com/

On Ubuntu: sudo apt-get install openjdk-7-jre

Tomcat 7

Download and install Tomcat 7 from http://tomcat.apache.org

On Ubuntu, use: sudo apt-get install tomcat7

Install an RDBMS (Database)

Download a database and configure it, either: MySQL or Postgresql (the latter is recommended).

Create a database user "goblin" with password "goblin" (for testing)

If you want to use mysql, please download the database driver and place it into your Tomcat's lib folder. (It is not included in the goblin.war for license reasons.)

Configure your version

Create in you home directory a folder .grails and inside a file goblin-config.groovy. You can download an example version from GitHub

  • Set the serverUrl to your machine's or server's name (http://localhost or your domain name)
  • Edit the database settings for the production database.

If you want to create a new database on every server start and delete the old data, keep the setting of dbCreate="create". Otherwise, set it to dbCreate="none".

If you have any questions, you can:

2.2 Installing the source code

Checkout the source code

You can get the source code from the Little Goblin GitHub repository

It is available as a zip or tar archive or (recommended) as a git repository which you can clone via bq. git clone git://github.com/dewarim/LittleGoblin.git

Prerequisites to running from source

After you have installed the dependencies, use the command line to run Grails in Little Goblin's main directory: grails and start the application with run-app

Use as a plugin

Add the following line to your Grails application's BuildConfig.groovy (in the plugins section):

compile ':little-goblin:0.3.2'

As a starting point, look at the BootStrap.groovy code in the plugin's source on how to populate the database with essential objects like an admin user. You can login to your application via http://localhost:8080/$appName/portal/landing, where $appName stands for your Grails application's name. Then it's time to begin customizing the game engine and to add your own content. (Extensive documentation on how to do this will follow - if anything is unclear or does not work, please to not hesitate to ask or add an issue )

3 Features

Little Goblin already has a lot of features, and more will come. This part of the documentation gives an overview over the current project status. A more detailed description of the inner workings will follow in the more technical sections later on.

3.1 Infrastructure

The main goal of the Little Goblin framework is to enable you to quickly turn your ideas into a working software project. To this end, the following is provided:

User registration

User registration works via sending a confirmation link to the user's email address. If the user clicks on the link therein, his account will be activated.

License management

Depending on the system's configuration, it's possible to let users create their own content. In this case, you really need to get the licensing done right - as well as in the case where you use media assets from the public domain (for example, Wikimedia). Often, the artist requires his name to appear in the context of the artwork - and even when there is no such request, it is the right and polite thing to do. And you never know when a lawyer comes a-knocking because someone mistakenly thinks you did use one of their images without permission.

Little Goblin allows you to create license objects which can be assigned to images (and perhaps later on other assets). Currently this is implemented for monster images, which can be tagged with a license. TODO: display licenses, not just store them - but at least the artist credit works.

Artist management

As with licenses, you can also manage artists in Little Goblin. Currently, when a monster is displayed, a link is shown which leads to the artist's web site. An artist may own any number of images associated with him. TODO: public display of artist gallery

Image management

With the artist and licenses defined, you can assign them to images and those to one or more game assets (at the moment: to monsters). This way, a image can be re-used for more than one creature. While in an ideal game, you would use images only exactly once, it may be a way for budget games to re-use them until better and more artwork is available.

More than one image can be assigned to a creature and they will be used randomly, so you can add some visual spice for the users. Also, in the case of unique creatures / mobs of a certain type, it is possible to assign the generic image (for example: when you generate an encounter with a special named mob, it could show up with the image for "Boss mob orc", the only difference being the mob's combat values, like in many action RPGs).

In-Game messaging

Simple messages

Little Goblin offers in-game messaging via a simple inbox model. Users can write messages to other characters, and reply to them. The messages can be archived or deleted. TODO: implement sent-as-email feature

Guild's chatterbox

Guilds offer a special feature: a chatterbox were all guild members can exchange messages in life chat. This is intended for non-persistent communication, as older messages will be deleted once the box fills up with new chatter.

3.2 The Game

When started with an empty database, Little Goblin can create a ready-to run fantasy game with a test account and a few quests, items, monsters and so on, allowing you to test the basic game features.

The reference implementation is a game that tries to use all the features offered by the framework.

3.3 Combat

Combat in Little Goblin currently is the fight between a player character and a monster or, in the case of the Grand Melee (see below) between all willing player characters. A fight is started by meeting a monster during a quest encounter. The fight will go on until the player wins, flees or is defeated.

Combat is round-based. At the moment, the player has the option to

  • use items from his or her inventory
  • to attack the opponent
  • run away

Running away is always successful and terminates the current quest. Attacking uses the currently equipped weapon(s) and passive abilities to determine the effects on the opponent.

A closeup of a fight

A round of combat consists of the following steps:

  • determine initiative (rolling a d20 at the moment, add bonuses)
  • attacker rolls to strike
  • defender rolls to parry
  • in case of a hit, compute damage from all items that contribute to damage dealt.
  • check if both combatants are alive
  • counter attack of the defender (strike, parry, deal damage, check result)
  • either finish the combat sequence or start a new round

Special damage and mitigation

Items or a creature's natural abilities may deal special damage (for example, a dragon breathing fire). This is included via a damage multiplier, so a dragon may deal fire damage which increases its base damage by a factor of 1.2. If this dragon is also for some reason a creature of chaos, it may increase the damage further by another factor of 1.3. Likewise, the abilities or items of a fighter may reduce the damage dealt by a certain factor. A ring of protection from chaos may reduce damage with chaotic influence by a factor of 0.5 (so chaos damage is reduced by 50%).

Note that in this simple combat model an armor of protection from fire will reduce the total damage, not the percentage of the damage that is actually dealt be heat. So, attacking a creature that is virtually immune to fire with a +20 burning sword of fire,death,chaos,poison is not the best strategy.

The Grand Melee

The Grand Melee is Highlander-style combat szenario where all participants will fight each other until only the winner is left standing. It is round based with a fixed timeout to prevent players from waiting too long before committing to an action. (If a player does not submit an action, his character will attack a random opponent).

3.4 Reputation

Reputation is the sum off what a group of people have come to expect of you.

In Little Goblin, you can define factions, which may align on race (Elves, Dwarves) or other distinguishing characteristics. If a player character makes a decision during a quest, his or her reputation in respect to the affected factions should change.

If at a later state of the game the character interacts again with factions he has now a positive or negative reputation with, the options offered and behaviour displayed should be influenced by this.

Reputation is not presented as a number to the player, because such a score is not very meaningful. For display, a reputation map is used, which contains descriptions for negative and positive reputation states. Note that reputation at this point is either positive, neutral or negative - the code does not define ambivalent feelings or track the reputation history, so the sentiment "She was once a heroine and a force of good reputation:1000, but she has fallen a long way reputation:0, still we should give her a chance." can currently not be expressed. But then, modeling behaviour of NPCs according to the current reputation is sufficient - the memories of an orcish trader do not need to be longer and more nuanced than that of the average voter.

Example of a reputation message map which goes from -41 to +41:

 repMessages = 'unknown': [0,
               'good': 1, 'very.good': 11, 'very.very.good': 21,  'best': 41,
               'bad': -1, 'very.bad': -11, 'extremely.bad': -21, 'worst': -41]

Example of reputation messages:

    reputation.unknown=We have never heard of you.
    reputation.good=We like you.
    reputation.very.good=We think highly of you.
    reputation.very.very.good=We love you.
    reputation.best=Our lives are blessed by your very presence.
    reputation.bad=We dislike you.
    reputation.very.bad=We hate you.
    reputation.extremely.bad=We will kill you on sight.
    reputation.worst=We are going to kill you and leave your for the ravens

(Of course, you can define the messages in a more appropriate way or from a 3rd-person point of view.)

3.5 Skills

Players characters and more generally creatures (mobs) may have skills. Skills can be learned at academies. Access to academies requires membership in a guild. In Little Goblin, guilds are organizations for all those pursuing a specific trade, like in the middle ages. They are not created by the players. Players may create "orders" (in the sense of a military and / or religious organization, for example the Knights Templar).

Academies like the fighter's guild will offer skills, or more precisely, skill sets. A "skill set" is a course which confers a specific skill like "fighting 101" to a player character - for a price and requiring a certain amount of time. It is possible to have multiple academies teaching the same skill via differently prices skill sets (courses). Skill sets have a required level relevant to the academy that teaches them - so a player character may only learn them in a specific order.

Skills are scriptable: you can associate a class with a skill which will be run when a player character learns this skill. The class will receive the PC, the CreatureSkill instance which connects the character with this skill instance and the skill's configuration field as parameters. The configuration field is an XML string and may hold initialization values.

Combat Skills

Combat skills extend the basic skill class with combat specific fields. Currently, those are Dice objects which offer bonuses for:

  • strike
  • parry
  • initiative
  • damage

Production Skills

Production skills extend the basic skill class and allow a player use create new products (items). When a PC learns a new production skill, a range of new products may become available for crafting.

3.6 Guilds

Guilds in Little Goblin represent trade associations, much like the medieval guilds which were created by craftsmen seeking to build communities of like-minded professionals. They jealously guard the secrets of their trades and seek to create a monopolistic power structure where the only people who are allowed to practice (and capable, due to the control of information) the trade, are those who belong to the guild.

In game terms, a player character who wishes to learn a craft should become a member of the respective guild. This will grant him or her access to the guild's academy and possibly other resources. Some skills may be transferred outside of the regular guild curriculum, either as quest rewards or through other events.

Note: player guilds are called orders in Little Goblin.

Ideas for guilds

While currently not implemented, guilds may become controlled or influenced by players. Also guild membership may later on depend on reputation or quests.

3.7 Items

Items are among the most complex features of Little Goblin. A player character may own any number of them, and they may have special uses and effects which can be activated when the time is right.

Item types

All items have a specific item type which defines:

Required slots

To equip an item (so it can be used), one or more free equipment slots are necessary. An equipment slot may be a body part (an iron helmet requires a free head slot) or, in a later version of the framework, a space ship (a photon torpedo needs a weapons bay).

Current equipment slot types (in the reference implementation - you are free to change them in your game):

  • head
  • neck
  • body
  • hand
  • finger
  • legs
  • feet

A character may have more than one of each slot type (of course, having two heads only makes sense if you play an Ettin...)

Attributes

An item may have any number of item attributes. A sword of flames will have a weapon attribute of type "fire" and a corresponding damage modified. Combat attributes are used to calculate damage - a sword of fire will do more damage against an ice monster.

Current combat attributes include:

  • fire
  • acid
  • water
  • cold
  • electricity
  • death
  • light
  • chaos
  • sound
  • poision
  • shards
  • normal

Item categories

Categories are used group items according to their basic aspects, you can think of them as tags for item properties. For example, a magic potion of healing will belong to the categories 'potion' and 'magic'

  • and perhaps 'healing', if you expect to have a lot of healing items. Shops will not always carry

items of all categories and some may in fact only carry potions or weapons.

Initial item categories (for the handful of test items):

  • potion
  • magic
  • mushroom
  • metal
  • armor
  • weapon

Combat damage

A weapon is simply defined as an item which has a combat dice value set. Dice determine the base damage an item will do via the formula ( number of sides * number of dice) + bonus value. You can name your dice and reuse them for different items, for example "Dice: short swords" or "Dice: Phasers".

h3 Stackable and package size

Items may be combined to stacks. The package size determines the amount of this items you will receive from a shop keeper. For example, buying "a dozen arrows" will add a stack of 12 arrows to your quiver.

Usable and rechargeable items

Some items can be used (activated) to create special effects, which may consume the item or reduce its life expectancy by one. A potion will have only one use, while a laster blaster may have a 100 shots before it can be recharged.

Value and availability

Availability is currently defined in 0.1% steps - so it's a number from 0 to 1000. Items with an availability of zero will never be found in a shop, while others will be on sale some or all the time. The base value of an item is used to calculate the price a shop keeper will pay for it.

Item properties

An item has other properties besides its type. Those are:

  • an owner: a Creature (may be a mob, but most likely it's a player character)
  • a location: currently, two location types are defined: ON_PERSON and AT_HOME
  • a gold value: game events may change the value of an item.
  • amount: for stacked items, default is 1
  • equipped flag: true if the item is currently in use.
  • number of uses left
  • resources: an item may be designed to be used as a production resource in crafting.

A player may choose between several stacks of raw materials to use for a product, and the chosen stack is marked internally for consumption.

3.8 Crafting

Crafting in games can be defined as the controlled and repeatable creation of items by player characters, based on their personal resources (materials, skills, time).

The Little Goblin crafting system allows for production of all kinds of items that a character might want to use. To create an item, a PC should have a corresponding crafting skill, the material components and the proper tools. As with many other online games, crafting takes time - you can define how long it will take a player to create an item.

Tools

Many crafting systems require the presence of components, but few consider the use of multiple tools for crafting. Little Goblin offers the chance to create recipes for items that define what other non-consumable items the player (or, later on, his order) has to own to craft a new item.

At the moment, the quality of tools is not mapped to the crafted item's quality, but that could be an interesting idea for further extensions.

Production lines

Currently, a player can start the production of create several items of a each kind, as long as he has the required components to create at least one item of this type. When the required time is up, the code checks if the resources are available and then generates the item. So it is possible to start a "create 99 gold-tipped arrows, which requires 10 hours" production task while owning only one gold nugget, and then start another process to "create 98 gold nuggets from gold ore in 9 hours"

Note: Work in progress: The crafting and the skill learning system currently rely on external "ticks", that is http calls to the API made by a cron job, which causes specific service classes to check if items are to be generated or skills will be learned by characters etc. This is sub-optimal and will be replaced by background-threads in the future.

Design considerations

A more "realistic" way would be to subtract the required resources each time an item is generated, but on the other hand it is a better system than requiring all resources up front, which would mean that in our example the player has to login after 9 hours, when the 99 gold nuggets are ready, and then create the next 10 hour job of crafting the arrows. This leads to unhealthy gaming patterns where players will stay up late or rise early, just to submit a task to an online game on time.

3.9 Orders

Players may create orders (which are called guilds in some games). An order offers a means to communicate with friends by using the Chatterbox (private chat channel on the order page).

Each player may create his or her own order and wait for other players to send application messages for their characters, which can be accepted or denied. The founder of a guild is also its master. A player character may only be the member of one order.

Roadmap for orders

Orders are currently very simple. They will probably be extended to include:

  • A treasure chest for exchanging items for free.
  • A production / crafting facility to share tools / machines.
  • An organization chart for large orders.
  • The option to add a logo and a more detailed description.

3.10 Quests

Quests are multi-step events that a player character experiences and whose outcome is more or less dependent on the player's choices and possible random factors.

Quests are granted by a QuestGiver, a non-player-character, which may have a short description and an introductory text. The player decides whether to take on a quest or leave it. If the player character dies or runs away from a quest, it is counted as failed and cannot be repeated.

Each quest consists of several steps, which are QuestStep objects chained together by the game designer. You can create extremely long quests, with random encounters and scripted outcomes depending on special circumstances. It is even possible to have looping quests. For example, if the player returns repeatedly to a series of quest steps, until he makes the correct (or final) decision which ends the quest successfully or causes it to fail.

At the end of quest (or, by script, during a quest step), rewards can be given to a character. Those may take the form of items or non-material bonuses like reputation changes. The reference implementation has an example quest where the player decides if he wants to rescue an elven girl and reunite her with her family or give her to the dwarves. The decision results in a change to reputation with both factions (elves and dwarves).

Entry criteria for quests are planned, but not implemented yet. For example, I would like to implement reputation dependent quests - if a player character is known as a friend of the gnomes, he may get some quests from them…

4 Plugin Usage

So, you want to create your own game. That's great.

This chapter describes how to create a new game by using the Little Goblin plugin. As an example I will use the reference implementation, which is currently (as of version 0.3.2) a part of the main plugin, but should really be put into a separate application to keep framework and individual game mechanics apart.

So follow along for a tour … you can find the source code at GitHub: Schedim source code

4.1 How to create a new game

A new app

Create a new grails application. On the command line type:

grails create-app schedim

Of course, it would be nice if you were to come up with your own name instead of Schedim ;) Schedim are a kind of mythological creatures from the Kabbalah (elemental spirits).

Grails creates a new application in a folder by the given name (schedim). Open the application in your favorite IDE, for example Eclipse STS or IntelliJ IDEA. It is also a good idea to create a repository for the software in a source code management system like git or subversion. If you got your game in a SCM (and keep backups...), you do not have to fear losing your code or breaking it beyond repair by making changes to it.

Your new grails application should start out looking like this:

In the new application, open grails-app/conf/BuildConfig.groovy and add the line

compile ':goblin:0.3.2'

to the dependencies closure.

If you now type

grails
    // waiting some time
    grails run-app
    // waiting some more

You will see a message like "Server running. Browse to http://localhost:8080/schedim" If you visit this URL, you will see something like the following:

The many controllers are provided by Little Goblin. But since the database is still empty and no start page has been defined, we still have some work to do.

Landing page configuration

As you can see, the default page of the new game leaves something to be desired. But we can redirect visitors from the base URL to a page of our own choosing.

In the file grails-app/conf/UrlMappings.groovy, modify the static mappings definition:

class UrlMappings {
    static mappings = {
      "/$controller/$action?/$id?"{
	      constraints {

} } "/"(view:"/portal/landing") "500"(view:'/error') } }

Now, if you visit http://localhost:8080/schedim, you should be redirected to the Little Goblin's default landing page:

This still does not look like the test server's page, but it's a start.

Database installation

You may run your game entirely from RAM without any persistent database installed. But while this is great for testing (you get a new database with every start), for a production setting it will probably be less than ideal, because you loose your entire game state once the server shuts down.

If you want to go beyond an in-memory setup, you should install a proper database like Postgresql - this is easy to setup. On Windows, you can use PgAdmin which comes with the database executable to setup a first database called schedim, with a user goblin and password goblin.

If you decide to go with Postgresql (you could also use MySQL or MS-SQLserver etc), please add the following postgresql driver to you dependencies closure in BuildConfig.groovy:

dependencies{    
        // automatically download and install the Postgresql driver:
        runtime 'postgresql:postgresql:9.1-901.jdbc4'
        // or use the MySQL one:
        // runtime 'mysql:mysql-connector-java:5.1.20'
    }

Please note that depending on the Postgresql or Mysql configuration, you may need to allow connections from localhost:

--- in pg_hba.conf: add a separate line:
 host	schedim	     all	127.0.0.1/32	      trust

Database configuration

Next you will need to configure the connection to the database. This is stored in /grails-app/conf/DataSource.groovy

There are three distinct environments under which your game will be running -

  • development, which means you run it via run-app from the Grails console.
  • test, during testing the game will be running with the in-memory H2 database (leave settings as-are).
  • production, which is activated when the schedim.war is deployed into a Tomcat (or other) server.

Add the following settings to your DataSource.groovy:

environments{
    development {
		dataSource {
			dbCreate = "update"
			pooling = true
			logSql = false
			driverClassName = "org.postgresql.Driver"
            dialect = "org.hibernate.dialect.PostgreSQLDialect"
            url = "jdbc:postgresql://127.0.0.1:5432/schedim"			
			username = 'goblin'
			password = 'goblin'
		}

}

production { dataSource { dbCreate = "update" pooling = true logSql = false

driverClassName = "org.postgresql.Driver" dialect = "org.hibernate.dialect.PostgreSQLDialect" url = "jdbc:postgresql://127.0.0.1:5432/schedim" username = 'goblin' password = 'goblin' autoReconnect = true properties { maxActive = -1 minEvictableIdleTimeMillis=1800000 timeBetweenEvictionRunsMillis=1800000 numTestsPerEvictionRun=3 testOnBorrow=true testWhileIdle=true testOnReturn=true validationQuery="SELECT 1" } } } }

If you are using MySQL, use the following lines:

driverClassName = "com.mysql.jdbc.Driver"
		dialect = 'org.hibernate.dialect.MySQL5InnoDBDialect'
		url = "jdbc:mysql://localhost:3306/schedim"

Note the setting for dbCreate: currently they are all set to update, so that Grails tries to add anything new you create. It should not delete any database tables or otherwise break something, just add new stuff.

Once you have a production-ready game, you should set dbCreate to 'none' in the production environment settings.

Security configuration

Little Goblin uses the Grails Spring Security Plugin to enable authentication and authorization of users. You may of course decide to use another security mechanism (or write a game that does not require a login...) but I recommend you just use the following settings in your Config.groovy - after all, Little Goblin is about reducing the time for setup.

grails.plugins.springsecurity.userLookup.userDomainClassName = 'de.dewarim.goblin.UserAccount'
 grails.plugins.springsecurity.userLookup.authorityJoinClassName = 'de.dewarim.goblin.UserRole'
 grails.plugins.springsecurity.authority.className = 'de.dewarim.goblin.Role'
 grails.plugins.springsecurity.userLookup.passwordPropertyName = 'passwd'
 grails.plugins.springsecurity.authority.nameField = 'name'
 grails.plugins.springsecurity.successHandler.defaultTargetUrl = '/portal/start'
 grails.plugins.springsecurity.dao.reflectionSaltSourceProperty = 'username'

You may have noticed the defaultTargetUrl: by changing this you can determine to which page a user will be redirected after login by default. In this case it's the start action of the portal controller.

If you now visit the login page and try to login with the default test user, you will see an error message - which is perfectly ok at this moment, since there are no users in the database.

First failed login: your game is secure...

Adding data

At the moment, your database is completely empty - it should contain just the tables for the Little Goblin domain classes, but not a single row of data. That is about to change...

// TODO

4.2 The landing page

A browsergame starts with a landing page, where the visitor gets a first impression on what the site is all about.

The landing page is mostly static. It can be found in grails-app/views/portal/landing.gsp

It contains the following parts:

  • The links to the login and registration pages
  • The optional Facebook like button
  • A language chooser (currently supported: French and English)
  • Some information about Little Goblin

The layout is governed by a special file, the sitemesh layout definition in grails-app/views/layouts/main.gsp.

If you want to change the general look and feel, making changes to main.gsp is the easiest way to get this done. This file also includes the CSS responsible for styling the HTML elements. That file can be found in web-app/css/main.css.

So, to change the landing page, you can start with:

  • grails-app/views/portal/landing.gsp
  • grails-app/views/layouts/main.gsp
  • web-app/css/main.css

To activate the Facebook like button, edit your application-config.groovy file (named after your application, for example goblin-config.groovy) and add:

facebook {
    // this enables Facebook-JavaScript snippets on your landing page:
    enabled=true
    // show the like button:
    enableLikeButton = true

// if set to true, allow login via Facebook - not implemented yet. enableFacebookLogin = false

// your server's URL and Facebook appId myUrl = 'http://schedim.de/' appId = '217240194988212' }