public void try_interact(rpg_character actor)
{
Debug.Log("Tried to interact wtih " + name);
if (non_destructive.Count > 0)
{
for (int i = 0; i < non_destructive.Count; i++)
{
non_destructive[i].interact(actor);
if (non_destructive[i].interact_effect != null)
{
GameObject new_effect = GameObject.Instantiate(non_destructive[i].interact_effect);
new_effect.transform.position = transform.position;
}
}
}
else
{
for (int i = 0; i < destructive.Count; i++)
{
destructive[i].interact(actor);
if (destructive[i].interact_effect != null)
{
GameObject new_effect = GameObject.Instantiate(destructive[i].interact_effect);
new_effect.transform.position = transform.position;
}
}
}
}
public override void interact(rpg_character actor)
{
if (!locked)
{
Vector3 temp_pos = replacement.transform.position;
replacement.transform.position = transform.position;
transform.position = temp_pos;
openable is_openable = replacement.GetComponent <openable>();
//If we're currently blocking sight, check to see if we should change
if (block_sight)
{
if (is_openable == null)
{
Debug.Log("Set transparent to true");
util_ref.v_manager.transparent[(int)replacement.transform.position.x, (int)replacement.transform.position.y] = true;
util_ref.v_manager.refresh_fog();
}
if (is_openable != null && !is_openable.block_sight)
{
Debug.Log("Set transparent to true");
util_ref.v_manager.transparent[(int)replacement.transform.position.x, (int)replacement.transform.position.y] = true;
util_ref.v_manager.refresh_fog();
}
}
if (is_openable != null && is_openable.block_sight)
{
Debug.Log("Set transparent to false");
util_ref.v_manager.transparent[(int)replacement.transform.position.x, (int)replacement.transform.position.y] = false;
util_ref.v_manager.refresh_fog();
}
}
}
public override bool activate(rpg_character attacker, attack_entity triggering_attack)
{
//Loop through the list of target squares and limit targets to only the first
//pierce + 1 targets
int remain_pierce = triggering_attack.stats.get_stat_value("Pierce");
List <Vector2Int> new_targets = new List <Vector2Int>();
bool has_targets = false;
for (int i = 0; i < triggering_attack.target_squares.Count; i++)
{
if (remain_pierce > 0)
{
if (util_ref.e_manager.is_occupied(triggering_attack.target_squares[i]) || util_ref.p_manager.get_p_pos() == triggering_attack.target_squares[i])
{
new_targets.Add(triggering_attack.target_squares[i]);
remain_pierce--;
has_targets = true;
}
}
}
triggering_attack.target_squares = new_targets;
return(has_targets);
}
public bool do_attack(rpg_character attacker, Vector2Int target)
{
//Check conditions
if (!util_ref.v_manager.is_visible[target.x, target.y])
{
return(false);
}
Vector2Int start_pos = new Vector2Int((int)attacker.transform.position.x, (int)attacker.transform.position.y);
if (Mathf.Abs(Vector2Int.Distance(start_pos, target)) > stats.get_stat_value("Range"))
{
return(false);
}
switch (shape)
{
case attack_shape.line:
return(line_attack(attacker, target));
case attack_shape.single:
return(single_attack(attacker, target));
case attack_shape.square:
return(area_attack(attacker, target));
default:
Debug.LogError("Do attack encountered default case");
return(false);
}
}
public override bool activate(rpg_character attacker, attack_entity triggering_attack)
{
bool made_attack = false;
for (int i = 0; i < triggering_attack.target_squares.Count; i++)
{
//If the square is occupied, call the take damage method on the enemy at that point
if (util_ref.e_manager.is_occupied(triggering_attack.target_squares[i]))
{
if (attacker.tag != "Enemy")
{
made_attack = true;
attack_data data = new attack_data();
data.attacker = attacker;
data.attack_ref = triggering_attack;
util_ref.e_manager.get_at_square(triggering_attack.target_squares[i]).
GetComponent <rpg_character>().take_damage(data);
}
}
else if (util_ref.p_manager.get_p_pos() == triggering_attack.target_squares[i])
{
if (attacker.gameObject.tag != "Player")
{
made_attack = true;
attack_data data = new attack_data();
data.attacker = attacker;
data.attack_ref = triggering_attack;
util_ref.p_manager.cur_player.GetComponent <rpg_character>().take_damage(data);
}
}
}
return(made_attack);
}
public void do_effect(rpg_character target)
{
if (!initialized)
{
init();
}
Debug.Log("Do effect called for " + effect_name + " on " + target.name);
turns_remaining--;
attack_data dummy_data = new attack_data();
dummy_data.target = target;
if (turns_remaining <= 0)
{
//per_turn_effect.remove_modifier(dummy_data, mod_value);
target.stat_cond.Remove(this);
}
else if (per_turn_effect != null)
{
play_sfx(dummy_data);
//per_turn_effect.set_modifier(dummy_data, mod_value);
//per_turn_effect.has_applied = false;
}
}
public override bool activate(rpg_character attacker, attack_entity triggering_attack)
{
GameObject new_effect = GameObject.Instantiate(effect_prefab);
new_effect.transform.position = attacker.transform.position;
return(true);
}
public override bool activate(rpg_character attacker, attack_entity triggering_attack)
{
bool has_triggered = false;
for (int i = 0; i < triggering_attack.target_squares.Count; i++)
{
if (util_ref.e_manager.is_occupied(triggering_attack.target_squares[i]))
{
if (attacker.gameObject.tag != "Enemy")
{
has_triggered = true;
GameObject new_effect = GameObject.Instantiate(effect_prefab);
new_effect.transform.position = new Vector3(triggering_attack.target_squares[i].x, triggering_attack.target_squares[i].y);
new_effect.GetComponent <effects_script>().parent = attacker.gameObject;
attacker.set_locked("Locked " + attacker.name + " to allow effect to play");
}
}
else if (util_ref.p_manager.get_p_pos() == triggering_attack.target_squares[i])
{
if (attacker.gameObject.tag != "Player")
{
has_triggered = true;
GameObject new_effect = GameObject.Instantiate(effect_prefab);
new_effect.transform.position = new Vector3(triggering_attack.target_squares[i].x, triggering_attack.target_squares[i].y);
}
}
}
return(has_triggered);
}
public override bool activate(rpg_character attacker, attack_entity triggering_attack)
{
bool has_dashed = false;
for (int i = 0; i < triggering_attack.target_squares.Count; i++)
{
if (util_ref.e_manager.is_occupied(triggering_attack.target_squares[i]))
{
GameObject target = util_ref.e_manager.get_at_square(triggering_attack.target_squares[i]);
Vector3 adjacent = attacker.transform.position - target.transform.position;
adjacent = adjacent.normalized;
adjacent = target.transform.position + adjacent;
adjacent = new Vector3(Mathf.Round(adjacent.x), Mathf.Round(adjacent.y), 0);
GameObject afterimage = GameObject.Instantiate(util_ref.sprite_prefab);
afterimage.transform.position = attacker.transform.position;
afterimage.GetComponent <SpriteRenderer>().sprite = attacker.GetComponent <SpriteRenderer>().sprite;
afterimage.AddComponent <fade_effect>();
afterimage.GetComponent <fade_effect>().speed = .75f;
//Debug.Log("Adjacent square is: " + adjacent.ToString());
attacker.transform.position = adjacent;
util_ref.v_manager.refresh_fog();
has_dashed = true;
}
}
return(has_dashed);
}
private bool single_attack(rpg_character attacker, Vector2Int target)
{
target_squares.Clear();
target_squares.Add(target);
return(activate_effects(attacker));
}
// Use this for initialization
void Start()
{
DontDestroyOnLoad(gameObject);
hotbar_prefab = hotbar_ref;
sprite_prefab = sprite_ref;
pickup_prefab = pickup_ref;
g_manager = GameObject.Find("Game Manager").GetComponent <game_manager>();
i_manager = GameObject.Find("Item Manager").GetComponent <item_manager>();
e_manager = GameObject.Find("Enemy Manager").GetComponent <enemy_manager>();
b_manager = GameObject.Find("Enemy Manager").GetComponent <boss_manager>();
p_manager = GameObject.Find("Player Manager").GetComponent <player_manager>();
perks = GameObject.Find("Player Manager").GetComponent <perk_manager>();
feature_spawner = GameObject.Find("Map Manager").GetComponent <map_feature_spawner>();
m_gen = GameObject.Find("Map Manager").GetComponent <map_generator>();
v_manager = GameObject.Find("Map Manager").GetComponent <fov_manager>();
d_manager = GameObject.Find("Dijkstra Manager").GetComponent <dijkstra_manager>();
events = GameObject.Find("Event Manager").GetComponent <event_manager>();
game_master = new rpg_character();
colors = new Color[7];
colors[0] = Color.green;
colors[1] = Color.red;
colors[2] = Color.blue;
colors[3] = Color.cyan;
colors[4] = Color.magenta;
colors[5] = Color.yellow;
colors[6] = Color.grey;
up = new Vector2Int(0, 1);
down = new Vector2Int(0, -1);
left = new Vector2Int(-1, 0);
right = new Vector2Int(1, 0);
}
public override void interact(rpg_character actor)
{
health--;
if (health <= 0)
{
Destroy(gameObject);
}
}
public void add_effect(rpg_character target)
{
target_character = target;
turns_remaining = max_turns;
Debug.Log("Started listening to " + target.name + "_start_turn");
util_ref.events.start_listening(target.name + "_start_turn", on_turn);
on_start();
}
public void trigger_event(string event_name, rpg_character actor)
{
last_actor = actor;
//Debug.Log("Triggered " + event_name);
if (events.ContainsKey(event_name))
{
events[event_name].Invoke();
}
}
/*
* private void OnTriggerEnter2D(Collider2D collision)
* {
* if (collision.gameObject.tag == "Player")
* {
* Debug.Log("Detected collision entering " + gameObject.name);
* collision.gameObject.GetComponent<player_script>().inv.pickup(attached_item);
*
* Destroy(gameObject);
* }
* }
*/
public override void interact(rpg_character actor)
{
if (actor.gameObject.tag == "Player")
{
actor.GetComponent <player_script>().inv.pickup(attached_item);
Destroy(gameObject);
}
}
private bool activate_effects(rpg_character attacker)
{
activated_effect = false;
for (int i = 0; i < components.Length; i++)
{
//Check the function first; if the value is set to true
//the OR evaluation will short-circuit if it's first
activated_effect = components[i].activate(attacker, this) || activated_effect;
}
return(activated_effect);
}
private bool line_attack(rpg_character attacker, Vector2Int target)
{
//Get targets between attacker and chosen square
Vector2Int start_pos = new Vector2Int((int)attacker.gameObject.transform.position.x,
(int)attacker.gameObject.transform.position.y);
target_squares.Clear();
target_squares = line(start_pos.x, start_pos.y, target.x, target.y);
return(activate_effects(attacker));
}
public override void interact(rpg_character actor)
{
Debug.Log("Pushed pushable");
Vector3 adjacent = actor.transform.position - transform.position;
adjacent = adjacent.normalized;
adjacent = transform.position - adjacent;
adjacent = new Vector3(Mathf.Round(adjacent.x), Mathf.Round(adjacent.y), 0);
GetComponent <Rigidbody2D>().MovePosition(new Vector2(adjacent.x, adjacent.y));
}
public override void interact(rpg_character actor)
{
if (actor.stats.get_stat_value("Gold") < requires_gold)
{
return;
}
else
{
actor.stats.get_stat("Gold").set_value(actor.stats.get_stat_value("Gold") - requires_gold);
actor.GetComponent <player_script>().inv.pickup(associated_item);
Destroy(gameObject);
}
}
// Use this for initialization
void Start()
{
attached_character = GetComponent <rpg_character>();
attached_character.stats.init_character();
attached_character.stats.set_stat_max("Health", health_template);
attached_character.stats.set_stat_to_max("Health");
attached_character.stats.set_stat("Max Move", move_template);
attached_character.stats.set_stat("Max Attack", attack_template);
attached_character.stats.set_stat("Max Shared", shared_template);
GetComponent <StateController>().attached_character = attached_character;
attached_character.current_target_character = util_ref.p_manager.cur_player.GetComponent <rpg_character>();
}
private bool area_attack(rpg_character attacker, Vector2Int target)
{
target_squares.Clear();
for (int x = target.x - stats.get_stat_value("Radius"); x < target.x + stats.get_stat_value("Radius"); x++)
{
for (int y = target.y - stats.get_stat_value("Radius"); y < target.y + stats.get_stat_value("Radius"); y++)
{
target_squares.Add(new Vector2Int(x, y));
}
}
return(activate_effects(attacker));
}
//Drop item chosen from item manager
public override void interact(rpg_character actor)
{
if (has_looted)
{
return;
}
item drop_item = util_ref.cur_palette.container_drops.get_weighted_item();
Debug.Log("Dropping " + drop_item.name);
GameObject looted_item = GameObject.Instantiate(util_ref.pickup_prefab);
looted_item.transform.position = transform.position;
looted_item.GetComponent <pickupable>().attached_item = drop_item;
has_looted = true;
}
public override bool activate(rpg_character attacker, attack_entity triggering_attack)
{
if (triggering_attack.activated_effect)
{
temporary_condition new_condition = Object.Instantiate(condition) as temporary_condition;
new_condition.source_character = attacker;
new_condition.source_attack = triggering_attack;
new_condition.add_effect(attacker);
return(true);
}
else
{
return(false);
}
}
public override bool activate(rpg_character attacker, attack_entity triggering_attack)
{
if (triggering_attack.activated_effect)
{
if (attacker.type == character_type.enemy)
{
attacker.queued_attack = replacement_skill;
}
else if (attacker.type == character_type.player)
{
attacker.GetComponent <player_script>().inv.swap_skill(triggering_attack, replacement_skill);
}
}
return(triggering_attack.activated_effect);
}
public override bool activate(rpg_character attacker, attack_entity triggering_attack)
{
bool did_apply = false;
for (int i = 0; i < triggering_attack.target_squares.Count; i++)
{
if (util_ref.e_manager.is_occupied(triggering_attack.target_squares[i]))
{
temporary_condition new_condition = Object.Instantiate(condition) as temporary_condition;
new_condition.source_character = attacker;
new_condition.source_attack = triggering_attack;
new_condition.add_effect(util_ref.e_manager.get_at_square(triggering_attack.target_squares[i]).GetComponent <rpg_character>());
did_apply = true;
}
}
return(did_apply);
}
public void on_apply(rpg_character target)
{
if (!initialized)
{
init();
}
Debug.Log("Called on_apply");
attack_data dummy_data = new attack_data();
dummy_data.target = target;
if (on_apply_effect != null)
{
play_sfx(dummy_data);
//on_apply_effect.set_modifier(dummy_data, mod_value);
}
}
public override bool activate(rpg_character attacker, attack_entity triggering_attack)
{
Debug.Log("Looping through target squares list of length " + triggering_attack.target_squares.Count);
for (int i = 0; i < triggering_attack.target_squares.Count; i++)
{
GameObject new_projectile = GameObject.Instantiate(projectile);
new_projectile.transform.position = attacker.transform.position + new Vector3(.5f, .5f, 0f);
Vector3 target_square = new Vector3(triggering_attack.target_squares[i].x + .5f, triggering_attack.target_squares[i].y + .5f);
new_projectile.GetComponent <projectile_script>().generate_midpoint(attacker.transform.position, target_square);
Debug.Log("Created projectile targeting " + target_square.ToString());
new_projectile.GetComponent <projectile_script>().target = target_square;
new_projectile.GetComponent <projectile_script>().type = type;
}
if (triggering_attack.target_squares.Count > 0)
{
return(true);
}
return(false);
}
public override bool activate(rpg_character attacker, attack_entity triggering_attack)
{
if (cur_cooldown > 0)
{
triggering_attack.target_squares.Clear();
return(false);
}
else
{
cur_cooldown = triggering_attack.stats.get_stat_value("Cooldown");
target_event = attacker.name + "_start_turn";
util_ref.events.start_listening(target_event, tick);
//Get the index of the appropriate skill and set the fill to none
attack_reference = triggering_attack;
int index_reference = util_ref.p_manager.p_script.inv.get_skill_index(attack_reference);
util_ref.p_manager.p_script.inv.hotbar.transform.GetChild(index_reference).GetComponent <Image>().fillAmount = 0f;
return(true);
}
}
public override bool activate(rpg_character attacker, attack_entity triggering_attack)
{
//Need to set stat in character so other attacks can reference the charges
if (triggering_attack.activated_effect)
{
if (!attacker.stats.has_stat(charge_name))
{
attacker.stats.init_stat(charge_name);
attacker.stats.set_stat_max(charge_name, max_charge);
}
if (attacker.stats.get_stat_value(charge_name) == max_charge)
{
triggering_attack.activated_effect = false;
return(false);
}
attacker.stats.get_stat(charge_name).inc_value();
//triggering_attack.stats.get_stat(charge_name).inc_value();
Debug.Log(charge_name + " is now " + attacker.stats.get_stat_value(charge_name));
}
return(triggering_attack.activated_effect);
}
public override bool activate(rpg_character attacker, attack_entity triggering_attack)
{
if (triggering_attack.target_squares.Count <= 0)
{
return(false);
}
int cost = triggering_attack.stats.get_stat_value("cost");
int charges = attacker.stats.get_stat_value(charge_name);
//Debug.Log("Attempting to remove " + cost + " charges from " + charges + " " + charge_name);
if (charges >= cost)
{
attacker.stats.set_stat(charge_name, charges - cost);
//Debug.Log(charge_name + " is now " + attacker.stats.get_stat_value(charge_name));
return(true);
}
else
{
triggering_attack.target_squares.Clear();
return(false);
}
}
