[ogs-changes] dist/java/ogs/cclasses Barbarian.java,NONE,1.1 Bard.java,NONE,1.1 Cleric.java,NONE,1.1
Status: Alpha
Brought to you by:
elemings
|
From: <ele...@us...> - 2003-04-04 20:23:23
|
Update of /cvsroot/ogs/dist/java/ogs/cclasses
In directory sc8-pr-cvs1:/tmp/cvs-serv9450/java/ogs/cclasses
Modified Files:
Fighter.java package.html
Added Files:
Barbarian.java Bard.java Cleric.java Druid.java Monk.java
Paladin.java Ranger.java Rogue.java Sorcerer.java Wizard.java
Log Message:
See ChangeLog files (Apr 3-4) for details.
--- NEW FILE: Barbarian.java ---
/*
* Barbarian.java -- class declaration for barbarians
* Copyright (C) 2003 Eric Lemings <ele...@us...>
*
* This software is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this software; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
* 02111-1307, USA
*
* RCS: $Id: Barbarian.java,v 1.1 2003/04/04 20:22:48 elemings Exp $
*/
package ogs.cclasses;
import ogs.core.CClass;
import ogs.core.Die;
import ogs.core.Experience;
import ogs.core.Saves;
/**
* A savage, uncivilized, warlike character class. Barbarians are
* fearsome warriors that have unique features that give them an edge in
* combat. First of all, a barbarian moves faster than other members of
* his or her race. A barbarian can also fly into a screaming,
* bloodthirsty frenzy that gives them offensive bonuses at the expense
* of defensive ability. At higher levels, barbarians gain the uncanny
* dodge feature (the same feature available to rogues) and the
* extrodinary ability to ignore a little damage that may be inflicted
* by others. <P>
*
* Barbarians are naturally proficient with light and medium armor as
* well as all simple and martial weapons. But because of their chaotic
* natures, all barbarians have one alignment restriction: they can not
* be of lawful alignment Any barbarian that becomes lawful in
* alignment can no longer use their rage ability and cannot advance in
* level. <P>
*
* Barbarians are typically used in fantasy campaign settings though
* this class can be used in other settings as well..
*/
public class Barbarian extends CClass {
/**
* Create a new 1st-level Barbarian cclass.
*/
public Barbarian () {
super ();
}
/**
* Create a new Nth-level Barbarian cclass.
*
* @param xpLevel Experience level of barbarian.
*/
public Barbarian (int xpLevel) {
super (xpLevel);
}
/**
* Determine the hit die for barbarians.
*
* @return Die.d12.
*/
public int getHitDie () {
return (Die.d4);
}
/**
* Determine the skill points per experience level for barbarians.
*
* @return 4 skill points.
*/
public int getSkillPoints () {
return (4);
}
/**
* Determine the value of base attack bonus for barbarians.
*
* @return Value of base attack bonus.
*/
protected int getBaseAttackValue () {
return (Experience.getStrongAttack (getLevel ()));
}
/**
* Determine the value of base Fortitude save bonus for barbarians.
*
* @return Value of base Fortitude save bonus.
*/
protected int getBaseFortSaveValue () {
return (Saves.getStrongBonus (getLevel ()));
}
}
--- NEW FILE: Bard.java ---
/*
* Bard.java -- class declaration for bards
* Copyright (C) 2003 Eric Lemings <ele...@us...>
*
* This software is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this software; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
* 02111-1307, USA
*
* RCS: $Id: Bard.java,v 1.1 2003/04/04 20:22:48 elemings Exp $
*/
package ogs.cclasses;
import java.util.Vector;
import ogs.core.CClass;
import ogs.core.Die;
import ogs.core.Experience;
import ogs.core.Saves;
/**
* A "jack-of-all-trades" character class well versed in music and lore.
* Bards have the ability to cast spells through their song and music.
* Charisma is the ability used by bards to cast spells. In addition to
* spells, bards can produce other unique effects that can charm other
* creatures or inspire their allies. These effects include inspire
* courage, countersong, fascinate, inspire competance, suggestion, and
* inspire greatness. In addition to song and music, bards are
* proficient at many roguish skills and acquire knowledge on many
* esoteric subjects. <P>
*
* At 2st-level, bards automatically gain the Simple Weapon, Light
* Armor, Medium Armor, and Shield Proficiency feats. They also select
* one proficiency from the following weapons: any bow, shortsword,
* longsword, rapier, sap, or whip. Bards have the same alignment
* restriction as barbarians: bards can not be of lawful alignment. Any
* bard that becomes lawful in alignment can still use all bardic
* abilities but cannot advance in level. <P>
*
* Bards are typically found in fantasy campaign settings.
*/
public class Bard extends CClass {
/**
* Create a new 1st-level Bard cclass.
*/
public Bard () {
super ();
}
/**
* Create a new Nth-level Bard cclass.
*
* @param xpLevel Experience level of bard.
*/
public Bard (int xpLevel) {
super (xpLevel);
}
/**
* Determine the hit die for this cclass. Bards use d6 for their hit
* die.
*
* @return Die.d6.
*/
public int getHitDie () {
return (Die.d6);
}
/**
* Determine the skill points per experience level for this cclass.
* Bards gain 4 skill points for each experience level.
*
* @return 4 skill points.
*/
public int getSkillPoints () {
return (4);
}
/**
* Determine the value of base Reflex save bonus for this cclass.
* Bards use the strong advancement rate for base Reflex save bonuses.
*
* @return Value of base Reflex save bonus.
*/
protected int getBaseRefSaveValue () {
return (Saves.getStrongBonus (getLevel ()));
}
/**
* Determine the value of base Will save bonus for this cclass. Bards
* use the strong advancement rate for base Will save bonuses.
*
* @return Value of base Will save bonus.
*/
protected int getBaseWillSaveValue () {
return (Saves.getStrongBonus (getLevel ()));
}
/**
* Determine the number of spells that this bard can cast per day.
*
* @return Number of spells at each spell leve.
*/
public Vector getSpellsPerDay () {
return (new Vector ()); // TODO: Implement.
}
/**
* Determine the number of spells knonwn by this bard.
*
* @return Number of spells at each spell level.
*/
public Vector getSpellsKnown () {
return (new Vector ()); // TODO: Implement.
}
}
--- NEW FILE: Cleric.java ---
/*
* Cleric.java -- class declaration for clerics
* Copyright (C) 2003 Eric Lemings <ele...@us...>
*
* This software is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this software; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
* 02111-1307, USA
*
* RCS: $Id: Cleric.java,v 1.1 2003/04/04 20:22:48 elemings Exp $
*/
package ogs.cclasses;
import java.util.Vector;
import ogs.core.CClass;
import ogs.core.Die;
import ogs.core.Experience;
import ogs.core.Saves;
/**
* A pious character class devoted to the service of a deity. Clerics
* are spell casters of divine magic. Their spells are granted to them
* from their diety through their faith and prayers. In addition,
* clerics may select two domains governed by their diety. Domains
* grant clerics additionaly spells and features. Clerics also have a
* feature called spontaneous casting. A cleric can replace a prepared
* spell (other than a domain spell) with a cure wounds spell (or
* inflict wounds spell depending on his or her alignment) of the same
* spell level or lower. <P>
*
* The most prominent feature of clerics however is the ability to turn
* (or rebuke depending on alignment) undead creatures. Neutral clerics
* choose whether they spontaneous cast cure wounds or inflict wounds
* and whether they turn or rebuke undead. Once a neutral cleric makes
* their choice, it cannot be changed. Clerics can also take up arms
* when duty requires it. As such, clerics are automatically proficient
* with all types of armor and shields and all simple weapons. <P>
*
* Clerics are typically found in fantasy campaign settings.
*/
public class Cleric extends CClass {
/**
* Create a new 1st-level Cleric cclass.
*/
public Cleric () {
super ();
}
/**
* Create a new Nth-level Cleric cclass.
*
* @param xpLevel Experience level of cleric.
*/
public Cleric (int xpLevel) {
super (xpLevel);
}
/**
* Determine the hit die for this cclass. Clerics use d8 for their
* hit die.
*
* @return Die.d8.
*/
public int getHitDie () {
return (Die.d8);
}
/**
* Determine the skill points per experience level for this cclass.
* Clerics gain 2 skill points for each experience level.
*
* @return 2 skill points.
*/
public int getSkillPoints () {
return (2);
}
/**
* Determine the value of base Fortitude save bonus for this cclass.
* Clerics use the strong advancement rate for base Fortitude save
* bonuses.
*
* @return Value of base Fortitude save bonus.
*/
protected int getBaseFortSaveValue () {
return (Saves.getStrongBonus (getLevel ()));
}
/**
* Determine the value of base Will save bonus for this cclass.
* Clerics use the strong advancment rate for base Will save bonuses.
*
* @return Value of base Will save bonus.
*/
protected int getBaseWillSaveValue () {
return (Saves.getStrongBonus (getLevel ()));
}
/**
* Determine the number of spells that this cleric can cast per day.
*
* @return Number of spells at each spell leve.
*/
public Vector getSpellsPerDay () {
return (new Vector ()); // TODO: Implement.
}
}
--- NEW FILE: Druid.java ---
/*
* Druid.java -- class declaration for druids
* Copyright (C) 2003 Eric Lemings <ele...@us...>
*
* This software is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this software; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
* 02111-1307, USA
*
* RCS: $Id: Druid.java,v 1.1 2003/04/04 20:22:48 elemings Exp $
*/
package ogs.cclasses;
import java.util.Vector;
import ogs.core.CClass;
import ogs.core.Die;
import ogs.core.Experience;
import ogs.core.Saves;
/**
* A character class that reveres nature. Druids are protectors and
* servants of nature.. As such, they are rarely if ever found in or
* near large cities. They are most often found in remote and isolated
* wilderness areas. Their intimate knowledge of the natural world is
* their source of power. Like clerics, druids are also spell casters
* of diving magic and Wisdom is their primary spell casting ability.
* In addition to spells, druids gain many special features as they
* advance in level including nature sense, animal companion, woodland
* stride, trackless step, wild shape, venom immunity, alter self, and
* timeless body. <P>
*
* At 1st-level, druids are proficient with light and medium armor
* though they are prohibited from wearing metal armor. They are
* proficient with clubs, daggers, darts, slings, quarterstaffs, spears
* (short, half, long), scimitars, and sickles. Druids must be of
* partially neutral alignment. They can be neutral good, lawful
* neutral, true neutral, chaotic neutral, or neutral evil. A druid
* who becomes any other alignment loses all spells and druidic
* abilities until he or she atones as per the Atonement spell). <P>
*
* This cclass is typically used in fantasy campaign settings.
*/
public class Druid extends CClass {
/**
* Create a new 1st-level Druid cclass.
*/
public Druid () {
super ();
}
/**
* Create a new Nth-level Druid cclass.
*
* @param xpLevel Experience level of druid.
*/
public Druid (int xpLevel) {
super (xpLevel);
}
/**
* Determine the hit die for this cclass. Druids use d8 for their hit
* die.
*
* @return Die.d8.
*/
public int getHitDie () {
return (Die.d8);
}
/**
* Determine the skill points per experience level for this cclass.
* Druids gain 4 skill points for each experience level.
*
* @return 4 skill points.
*/
public int getSkillPoints () {
return (4);
}
/**
* Determine the value of base Fortitude save bonus for this cclass.
* Druids use the strong advancement rate for base Fortitude save
* bonuses.
*
* @return Value of base Fortitude save bonus.
*/
protected int getBaseFortSaveValue () {
return (Saves.getStrongBonus (getLevel ()));
}
/**
* Determine the value of base Will save bonus for this cclass.
* Druids use the strong advancement rate for base Will save bonuses.
*
* @return Value of base Will save bonus.
*/
protected int getBaseWillSaveValue () {
return (Saves.getStrongBonus (getLevel ()));
}
/**
* Determine the number of spells that this druid can cast per day.
*
* @return Number of spells at each spell leve.
*/
public Vector getSpellsPerDay () {
return (new Vector ()); // TODO: Implement.
}
}
--- NEW FILE: Monk.java ---
/*
* Monk.java -- class declaration for monks
* Copyright (C) 2003 Eric Lemings <ele...@us...>
*
* This software is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this software; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
* 02111-1307, USA
*
* RCS: $Id: Monk.java,v 1.1 2003/04/04 20:22:48 elemings Exp $
*/
package ogs.cclasses;
import ogs.core.CClass;
import ogs.core.Die;
import ogs.core.Experience;
import ogs.core.Saves;
/**
* A character class dedicated to martial arts. Monks are well known
* for their discipline and dedication. They are continually in pursuit
* of perfection in mind, body, and spirit. They often live in isolated
* monastaries where they strive to achieve this goal through long hours
* of meditation and practice. Monks therefore have one alignment
* restriction: a monk must be of lawful alignment. A monk who becomes
* non-lawful can no longer advance in level but can still use all monk
* abilities. <P>
*
* Monks are masters of unarmed combat. They gain the Improved Unarmed
* Strike feat at 1st-level and can stun opponents with unarmed strikes.
* Monks are not initially proficient with any armors or shields but
* they are proficient with clubs, light and heavy crossbows, daggers,
* handaxes, javelins, kamas, nunchaku, quaterstaffs, shuriken, and
* slings. Monks also gain many special features as they advance in
* experience level. <P>
*
* This cclass is typically used in fantasy campaign settings.
*/
public class Monk extends CClass {
/**
* Create a new 1st-level Monk cclass.
*/
public Monk () {
super ();
}
/**
* Create a new Nth-level Monk cclass.
*
* @param xpLevel Experience level of monk.
*/
public Monk (int xpLevel) {
super (xpLevel);
}
/**
* Determine the hit die for this cclass. Monks use d8 for their hit
* die.
*
* @return Die.d8.
*/
public int getHitDie () {
return (Die.d8);
}
/**
* Determine the skill points per experience level for this cclass.
* Monks gain 4 skill points for each experience level.
*
* @return 4 skill points.
*/
public int getSkillPoints () {
return (4);
}
/**
* Determine the value of base Fortitude save bonus for this cclass.
* Monks use the strong advancement rate for base Fortitude save
* bonuses.
*
* @return Value of base Fortitude save bonus.
*/
protected int getBaseFortSaveValue () {
return (Saves.getStrongBonus (getLevel ()));
}
/**
* Determine the value of base Reflex save bonus for this cclass.
* Monks use the strong advancement rate for base Reflex save bonuses.
*
* @return Value of base Reflex save bonus.
*/
protected int getBaseRefSaveValue () {
return (Saves.getStrongBonus (getLevel ()));
}
/**
* Determine the value of base Will save bonus for this cclass. Monks
* use the strong advancement rate for base Will save bonuses.
*
* @return Value of base Will save bonus.
*/
protected int getBaseWillSaveValue () {
return (Saves.getStrongBonus (getLevel ()));
}
}
--- NEW FILE: Paladin.java ---
/*
* Paladin.java -- class declaration for paladins
* Copyright (C) 2003 Eric Lemings <ele...@us...>
*
* This software is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this software; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
* 02111-1307, USA
*
* RCS: $Id: Paladin.java,v 1.1 2003/04/04 20:22:48 elemings Exp $
*/
package ogs.cclasses;
import java.util.Vector;
import ogs.core.CClass;
import ogs.core.Die;
import ogs.core.Experience;
import ogs.core.Saves;
/**
* A character class that strives to be the paragon of virtue. Paladins
* are champions of all that is pure and just. They are exemplars and
* the epitome of chilvary. Paladins are often called knights,
* cavaliers, and crusaders. As such, their alignment must always be
* lawful good. Any paladin who ceases to be lawful good or otherwise
* betrays their code of conduct immediately looses all paladin
* abilities and can no longer advance in level as a paladin.
* Ex-paladins may make reparations with an atonement spell. <P>
*
* Paladins begin proficient with all simple and martial weapons, all
* light, medium, and heavy armors, and all shields. Paladins can gain
* many special abilities including detect evil, divine grace, lay on
* hands, divine health, aura of courage, smite evil, remove disease,
* turn undead, special mount, and divine spell casting. Wisdom is used
* as the spell casting ability for paladins. <P>
*
* Paladins are typically found in fantasy campaigns.
*/
public class Paladin extends CClass {
private Vector _feats;
/**
* Create a new 1st-level Paladin cclass.
*/
public Paladin () {
super ();
}
/**
* Create a new Nth-level Paladin cclass.
*
* @param xpLevel Experience level of paladin.
*/
public Paladin (int xpLevel) {
super (xpLevel);
}
/**
* Determine the hit die for this cclass. Paladins use d10 for their
* hit die.
*
* @return Die.d10.
*/
public int getHitDie () {
return (Die.d10);
}
/**
* Determine the skill points per experience level for this cclass.
* Paladins gain 2 skill points for each experience level.
*
* @return 2 skill points.
*/
public int getSkillPoints () {
return (2);
}
/**
* Determine the value of base attack bonus for this cclass. Paladins
* use the strong advancement rate for base attack bonuses.
*
* @return Value of base attack bonus.
*/
protected int getBaseAttackValue () {
return (Experience.getStrongAttack (getLevel ()));
}
/**
* Determine the value of base Fortitude save bonus for this cclass.
* Paladins use the strong advancement rate for base Fortitude save
* bonuses.
*
* @return Value of base Fortitude save bonus.
*/
protected int getBaseFortSaveValue () {
return (Saves.getStrongBonus (getLevel ()));
}
/**
* Attach this Paladin cclass to a character.
*
* @param object Object to attach this paladin to.
*/
public boolean attachObject (Object object) {
//if (! super.attachObject (object)) {
//return (false);
//}
Character character = (Character) object;
//addDivineGrace (character);
//addProficiencies (character);
return (true);
}
/**
* Determine the number of spells that this paladin can cast per day.
* The vector index of the return value is the spell level. If the
* number of spells for a given spell level is zero (0), the number of
* spells that can be cast for that level is the same as the bonus
* spells from the Charisma score of the paladin (if any).
*
* @return Number of spells that can be cast per spell level per day.
*/
public Vector getSpellsPerDay () {
int INT_MAX = Integer.MAX_VALUE;
int spellTable [][] = {
{ 0, INT_MAX, INT_MAX, INT_MAX },
{ 0, INT_MAX, INT_MAX, INT_MAX },
{ 1, INT_MAX, INT_MAX, INT_MAX },
{ 1, INT_MAX, INT_MAX, INT_MAX },
{ 1, 0, INT_MAX, INT_MAX },
{ 1, 0, INT_MAX, INT_MAX },
{ 1, 1, INT_MAX, INT_MAX },
{ 1, 1, 0, INT_MAX },
{ 1, 1, 1, INT_MAX },
{ 1, 1, 1, INT_MAX },
{ 2, 1, 1, 0 },
{ 2, 1, 1, 1 },
{ 2, 2, 1, 1 },
{ 2, 2, 2, 1 },
{ 3, 2, 2, 1 },
{ 3, 3, 3, 2 },
{ 3, 3, 3, 3 },
};
Vector spellCounts = new Vector ();
int xpLevel = getLevel ();
if (xpLevel >= 4) {
for (int i = 0; spellTable [xpLevel][i] != INT_MAX; ++i) {
spellCounts.add (i, new Integer (spellTable [xpLevel][i]));
}
}
return (spellCounts);
}
}
--- NEW FILE: Ranger.java ---
/*
* Ranger.java -- class declaration for rangers
* Copyright (C) 2003 Eric Lemings <ele...@us...>
*
* This software is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this software; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
* 02111-1307, USA
*
* RCS: $Id: Ranger.java,v 1.1 2003/04/04 20:22:48 elemings Exp $
*/
package ogs.cclasses;
import java.util.Vector;
import ogs.core.CClass;
import ogs.core.Die;
import ogs.core.Experience;
import ogs.core.Saves;
/**
* A character class skilled at outdoor hunting and survival. Rangers
* are often found serving as scouts, trackers, bounty hunters,
* frontiersmen, and explorers. They often chase and defend against
* certain species that they have an advantage when fighting with these
* creatures. Starting at 1st-level and every five levels after that, a
* ranger may select a favored enemy. Rangers gain a +1 bonus to Bluff,
* Listen, Sense Motive, Spot, and Wilderness Lore skill checks against
* favored enemies. They get the same bonus to damage (unless the
* creature is immune to critical hits) for melee weapons and ranged
* weapons when within 30 feet. Each bonus for a new favored enemy
* starts at +1 and goes up by +1 every five levels. <P>
*
* Rangers gain the Light Armor, Medium Armor, and Shield Proficiency
* feats at 1st-level as well as the Simple Weapon and Martial Weapon
* (All) Proficiency feats. They also gain the Track feat automatically
* at 1st-level. Rangers with a +9 base attack bonus can also select the
* Improved Two-Weapon Fighting feat if they do not have the other
* prerequisites for the feat. Rangers can also cast divine spells
* starting at 4th-level. Their caster level is one-half their cclass
* experience level. <P>
*
* Rangers typically exist in fantasy campaign settings.
*/
public class Ranger extends CClass {
/**
* Create a new 1st-level Ranger cclass.
*/
public Ranger () {
super ();
}
/**
* Create a new Nth-level Ranger cclass.
*
* @param xpLevel Experience level of ranger.
*/
public Ranger (int xpLevel) {
super (xpLevel);
}
/**
* Determine the hit die for this cclass. Rangers use d10 for their
* hit die.
*
* @return Die.d10.
*/
public int getHitDie () {
return (Die.d10);
}
/**
* Determine the skill points per experience level for this cclass.
* Rangers gain 4 skill points for each experience level.
*
* @return 4 skill points.
*/
public int getSkillPoints () {
return (4);
}
/**
* Determine the value of base attack bonus for this cclass. Rangers
* use the strong advancement rate for base attack bonuses.
*
* @return Value of base attack bonus.
*/
protected int getBaseAttackValue () {
return (Experience.getStrongAttack (getLevel ()));
}
/**
* Determine the value of base Fortitude save bonus for this cclass.
* Rangers use the strong advancement rate for base Fortitude save
* bonuses.
*
* @return Value of base Fortitude save bonus.
*/
protected int getBaseFortSaveValue () {
return (Saves.getStrongBonus (getLevel ()));
}
/**
* Determine the number of spells that this ranger can cast per day.
*
* @return Number of spells at each spell leve.
*/
public Vector getSpellsPerDay () {
return (new Vector ()); // TODO: Implement.
}
}
--- NEW FILE: Rogue.java ---
/*
* Rogue.java -- class declaration for rogues
* Copyright (C) 2003 Eric Lemings <ele...@us...>
*
* This software is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this software; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
* 02111-1307, USA
*
* RCS: $Id: Rogue.java,v 1.1 2003/04/04 20:22:48 elemings Exp $
*/
package ogs.cclasses;
import ogs.core.CClass;
import ogs.core.Die;
import ogs.core.Experience;
import ogs.core.Saves;
/**
* A character class adept at "obtaining the unobtainable". Rogues
* excel at breaking into safes, eluding intricate traps, infiltrating
* secret organizations, gathering intelligence, and usually parting
* others from their money one way or the other. Rogues can be of any
* alignment. While most are considered neutral or evil, good rogues
* are just as common. Their skills however are targeted at enemies
* rather than their own kind. Dexterity ,and wisdom are their most
* valuable assets. Intelligence and charisma are also useful in many
* situations. <P>
*
*
* Rogues can exist in just about any campaign setting.
*/
public class Rogue extends CClass {
/**
* Create a new 1st-level Rogue cclass.
*/
public Rogue () {
super ();
}
/**
* Create a new Nth-level Rogue cclass.
*
* @param xpLevel Experience level of rogue.
*/
public Rogue (int xpLevel) {
super (xpLevel);
}
/**
* Determine the hit die for this cclass. Rogues use d6 for their hit
* die.
*
* @return Die.d6.
*/
public int getHitDie () {
return (Die.d6);
}
/**
* Determine the skill points per experience level for this cclass.
* Rogues gain 8 skill points for each experience level.
*
* @return 8 skill points.
*/
public int getSkillPoints () {
return (8);
}
/**
* Determine the value of base Reflex save bonus for this cclass.
* Rogues use the strong advancement rate for base Reflex save
* bonuses.
*
* @return Value of base Reflex save bonus.
*/
protected int getBaseRefSaveValue () {
return (Saves.getWeakBonus (getLevel ()));
}
}
--- NEW FILE: Sorcerer.java ---
/*
* Sorcerer.java -- class declaration for sorcerer
* Copyright (C) 2003 Eric Lemings <ele...@us...>
*
* This software is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this software; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
* 02111-1307, USA
*
* RCS: $Id: Sorcerer.java,v 1.1 2003/04/04 20:22:48 elemings Exp $
*/
package ogs.cclasses;
import java.util.Vector;
import ogs.core.CClass;
import ogs.core.Die;
import ogs.core.Experience;
import ogs.core.Saves;
/**
* A character class with inherent spell casting abilities. Sorcerers
* are much like wizards. They have no alignment restrictions and can
* summon a familliar at 1st-level. Unlike wizards however, sorcerers
* are more limited in their range of spell casting abilities but do not
* have to memorize spells before casting them. They are also
* proficient with all simple weapons.
*/
public class Sorcerer extends CClass {
/**
* Create a new 1st-level Sorcerer cclass.
*/
public Sorcerer () {
super ();
}
/**
* Create a new Nth-level Sorcerer cclass.
*
* @param xpLevel Experience level of sorcerer.
*/
public Sorcerer (int xpLevel) {
super (xpLevel);
}
/**
* Determine the hit die for this cclass. Sorcerers use d4 for their
* hit die.
*
* @return Die.d4.
*/
public int getHitDie () {
return (Die.d4);
}
/**
* Determine the skill points per experience level for this cclass.
* Sorcerers gain 2 skill points for each experience level.
*
* @return 2 skill points.
*/
public int getSkillPoints () {
return (2);
}
/**
* Determine the value of base attack bonus for this cclass.
* Sorcerers use the weak advancment rate for base attack bonuses.
*
* @return Value of base attack bonus.
*/
protected int getBaseAttackValue () {
return (Experience.getWeakAttack (getLevel ()));
}
/**
* Determine the value of base Will save bonus for sorcerers.
* Sorcerers use the strong advancment rate for base Will save
* bonuses.
*
* @return Value of base Will save bonus.
*/
protected int getBaseWillSaveValue () {
return (Saves.getStrongBonus (getLevel ()));
}
/**
* Determine the number of spells that this sorcerer can cast per day.
*
* @return Number of spells at each spell leve.
*/
public Vector getSpellsPerDay () {
return (new Vector ()); // TODO: Implement.
}
/**
* Determine the number of spells knonwn by this sorcerer.
*
* @return Number of spells at each spell level.
*/
public Vector getSpellsKnown () {
return (new Vector ()); // TODO: Implement.
}
}
--- NEW FILE: Wizard.java ---
/*
* Wizard.java -- class declaration for wizards
* Copyright (C) 2003 Eric Lemings <ele...@us...>
*
* This software is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this software; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
* 02111-1307, USA
*
* RCS: $Id: Wizard.java,v 1.1 2003/04/04 20:22:48 elemings Exp $
*/
package ogs.cclasses;
import java.util.Vector;
import ogs.core.CClass;
import ogs.core.Die;
import ogs.core.Experience;
import ogs.core.Saves;
/**
* A character class devoted to the mastery of arcane magic. Wizards
* are the quintessential wielders of arcane magic. They are
* practically unlimited in their expertise with it. Wizards cast magic
* by scribing known spells into their spellbooks or scrolls, studying
* their spellbooks to prepare selected spells for casting, and then
* triggering the spell to be cast from memory or scrolls. After a
* spell is cast, the process must be repeated to cast it again. <P>
*
* Wizards can specialize in a school of magic. A wizard who
* specializes in a school of magic must select one of the eight schools
* of magic to specialize in and a combination of one or more schools
* that are prohibited. The speciallist can cast extra spells in this
* school but can never cast spells from one or more of the prohibited
* schools. Wizards (only) may also select the Spell Mastery feat that
* allows them to prepare spells without studying a spellbook. <P>
*
* At 1st-level, wizards may summon a familliar just like a sorcerer and
* automatically gain the Scribe Scroll feat. Wizards gain a metamagic
* feat every five levels in addition to feats normally gained.
* Initially, wizards are not proficient with armor or shields and they
* are only proficient with clubs, daggers, light and heavy crossbows,
* and quarterstaffs. Wizard have no alignment restrictions; they may
* be of any alignment. <P>
*
* This cclass is typcially used in fantasy campaign settings.
*
* @see ogs.magic.School
*/
public class Wizard extends CClass {
/**
* Create a new 1st-level Wizard cclass.
*/
public Wizard () {
super ();
}
/**
* Create a new Nth-level Wizard cclass.
*
* @param xpLevel Experience level of wizard.
*/
public Wizard (int xpLevel) {
super (xpLevel);
}
/**
* Determine the hit die for this class. Wizards use d4 for their hit
* die.
*
* @return Die.d4.
*/
public int getHitDie () {
return (Die.d4);
}
/**
* Determine the skill points per experience level for wizards.
* Wizards gain 2 skill points for each experience level.
*
* @return 2 skill points.
*/
public int getSkillPoints () {
return (2);
}
/**
* Determine the value of base attack bonus for wizards. Wizards use
* the weak advancement rate for base attack bonuses.
*
* @return Value of base attack bonus.
*/
protected int getBaseAttackValue () {
return (Experience.getWeakAttack (getLevel ()));
}
/**
* Determine the value of base Will save bonus for wizards. Wizards
* use the strong advancement rate for base Will save bonuses.
*
* @return Value of base Will save bonus.
*/
protected int getBaseWillSaveValue () {
return (Saves.getStrongBonus (getLevel ()));
}
/**
* Determine the number of spells that this wizard can cast per day.
*
* @return Number of spells at each spell leve.
*/
public Vector getSpellsPerDay () {
return (new Vector ()); // TODO: Implement.
}
}
Index: Fighter.java
===================================================================
RCS file: /cvsroot/ogs/dist/java/ogs/cclasses/Fighter.java,v
retrieving revision 1.2
retrieving revision 1.3
diff -C2 -d -r1.2 -r1.3
*** Fighter.java 24 Feb 2003 11:32:15 -0000 1.2
--- Fighter.java 4 Apr 2003 20:22:48 -0000 1.3
***************
*** 29,38 ****
/**
! * A character class that specializes in weapons, armor, and combat.
! * Fighters gain a bonus combat feat at 1st level and every two levels
! * after that (2nd, 4th, 6th, etc).
*/
public class Fighter extends CClass {
-
/**
* Create a new 1st-level Fighter cclass.
--- 29,47 ----
/**
! * A character class formally trained in weapons, armor, and tactics.
! * Fighters are prototypical soldiers and mercenaries. Fighters have no
! * alignment restrictions. They may be of any alignment.
! *
! * At 1st-level, fighers automatically gain the Light, Medium, and Heavy
! * Armor proficiency feats. They are also proficient with all simple
! * and martial weapons. Since fighters have no special features,
! * fighters instead gain a bonus feat at 1st level and every
! * even-numbered level thereafter. Fighters can also select the Weapon
! * Specialization feat at 4th-level or higher.
! *
! * Fighters are a universal cclass. They can be found in virtually all
! * campaign settings.
*/
public class Fighter extends CClass {
/**
* Create a new 1st-level Fighter cclass.
***************
*** 45,49 ****
* Create a new Nth-level Fighter cclass.
*
! * @param xpLevel Experience level of the cclass.
*/
public Fighter (int xpLevel) {
--- 54,58 ----
* Create a new Nth-level Fighter cclass.
*
! * @param xpLevel Experience level of fighter.
*/
public Fighter (int xpLevel) {
***************
*** 52,56 ****
/**
! * Determine the hit die for fighters. Fighters use d10 for hit die.
*
* @return Die.d10.
--- 61,66 ----
/**
! * Determine the hit die for this cclass. Fighters use d10 for their
! * hit die.
*
* @return Die.d10.
***************
*** 61,66 ****
/**
! * Determine the skill points per experience level for fighters.
! * Fighters get 2 skill points per experience level.
*
* @return 2 skill points.
--- 71,76 ----
/**
! * Determine the skill points per experience level for this cclass.
! * Fighters gain 2 skill points for each experience level.
*
* @return 2 skill points.
***************
*** 71,88 ****
/**
! * Determine the value of base attack bonus for fighters.
*
* @return Value of base attack bonus.
*/
! public int getBaseAttackValue () {
return (Experience.getStrongAttack (getLevel ()));
}
/**
! * Determine the value of base Fortitude save bonus for fighters.
*
* @return Value of base Fortitude save bonus.
*/
! public int getBaseFortSaveValue () {
return (Saves.getStrongBonus (getLevel ()));
}
--- 81,101 ----
/**
! * Determine the value of base attack bonus for this cclass. Fighters
! * use the strong advancment rate for base attack bonuses.
*
* @return Value of base attack bonus.
*/
! protected int getBaseAttackValue () {
return (Experience.getStrongAttack (getLevel ()));
}
/**
! * Determine the value of base Fortitude save bonus for this cclass.
! * Fighters use the strong advancement rate for base Fortitude save
! * bonuses.
*
* @return Value of base Fortitude save bonus.
*/
! protected int getBaseFortSaveValue () {
return (Saves.getStrongBonus (getLevel ()));
}
Index: package.html
===================================================================
RCS file: /cvsroot/ogs/dist/java/ogs/cclasses/package.html,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -d -r1.1 -r1.2
*** package.html 7 Jan 2003 08:02:09 -0000 1.1
--- package.html 4 Apr 2003 20:22:48 -0000 1.2
***************
*** 6,11 ****
<BODY>
! The <CODE>ogs.cclasses</CODE> package provides two universal
! character classes.
</BODY>
</HTML>
--- 6,13 ----
<BODY>
! A collection of common character classes. Most of the character
! classes (cclasses) contained within this namespace are typically
! used in fantasy campaign settings. The Fighter cclass however can
! be used in just about any open game regardless of campaign setting.
</BODY>
</HTML>
|